Cómo integrar GPT, Claude y otros modelos de IA de manera unificada con Copilot CLI

6 may 2026

Cómo integrar GPT, Claude y otros modelos de IA de manera unificada con Copilot CLI

En el desarrollo de aplicaciones de IA, ¿cómo integrar múltiples modelos como GPT y Claude a través de una interfaz unificada? Este artículo comparte el diseño del sistema de proveedores de IA basado en la arquitectura Orleans Grain, así como la experiencia práctica de integración con GitHub Copilot CLI.

Antecedentes

En el desarrollo moderno de aplicaciones de IA, integrar los últimos modelos GPT es una necesidad central para muchos desarrolladores. GitHub Copilot CLI es una herramienta potente que no solo admite los modelos de la serie GPT de OpenAI (como GPT-4, GPT-5), sino también otros modelos de IA主流 como Claude. A través de Copilot CLI, los desarrolladores pueden usar una interfaz de línea de comandos unificada para invocar diferentes modelos de IA, sin necesidad de implementar por separado la lógica de integración compleja para cada modelo.

En realidad, este es un tema que ya se ha discutido mucho. Escribir la lógica de invocación para cada modelo es una experiencia dolorosa. Después de todo, cuando se escribe mucho código, cualquiera se cansa, y en lugar de reinventar la rueda, es mejor encontrar una interfaz unificada que resuelva todo. Copilot CLI es precisamente ese tipo de solución: tú solo invoca, el resto se lo dejas a él.

Valores principales:

Interfaz CLI unificada para acceder a múltiples modelos de IA
Soporte para gestión de sesiones y mantenimiento del contexto
Capacidades de invocación de herramientas integradas (operaciones de archivos, operaciones Git, etc.)
Soporte para respuestas en streaming y salida en tiempo real

Sobre HagiCode

La solución compartida en este artículo proviene de nuestra experiencia práctica en el proyecto HagiCode. HagiCode es un proyecto de asistente de código de IA. Durante el desarrollo, nos enfrentamos al desafío de admitir múltiples modelos de IA simultáneamente: algunos usuarios prefieren GPT-4, otros prefieren Claude, y algunos quieren probar el último GPT-5. Si implementamos un conjunto de lógica de invocación por separado para cada modelo, el código se vuelve difícil de mantener. A través de la interfaz unificada de Copilot CLI, resolvimos con éxito este problema de soporte multicmodelo.

Dicho de forma simple, los gustos de los usuarios son diversos y es difícil satisfacer a todos. A algunos les gusta GPT, otros prefieren Claude, y algunos insisten en usar el último GPT-5. Solo queremos que todos puedan usar el modelo que les gusta, después de todo, la felicidad es lo más importante.

Diseño de la arquitectura del sistema

Implementamos un sistema de proveedores de IA escalable a través de la arquitectura Orleans Grain. La arquitectura general es la siguiente:

┌─────────────────┐
│  Frontend/Cliente │
└────────┬────────┘
         │
         ▼
┌─────────────────────────────────┐
│  IGitHubCopilotGrain (Capa de interfaz)   │
│  - ExecuteCommandStreamAsync    │
│  - RunEditAsync                 │
│  - CancelAsync                  │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  GitHubCopilotGrain (Capa de implementación)    │
│  - Gestión de estado                      │
│  - Vinculación de sesión                      │
│  - Mapeo de respuestas                      │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  CopilotAIProvider (Capa de proveedor)   │
│  - Análisis de configuración                      │
│  - Gestión de permisos                      │
│  - Procesamiento de streaming                      │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  HagiCode.Libs (Runtime compartido)     │
│  - Gestión de procesos de Copilot CLI          │
│  - Análisis de protocolo de mensajes                  │
│  - Mantenimiento de sesión                      │
└─────────────────────────────────┘

La ventaja de esta arquitectura radica en capas claras y responsabilidades únicas. La capa de interfaz define el contrato unificado del servicio de IA, la capa de implementación maneja la gestión de estado distribuido de Orleans, la capa de proveedor encapsula los detalles de interacción de Copilot CLI, y el runtime subyacente es responsable de comunicarse con el proceso CLI.

Dicho de forma simple, se trata de dejar claro quién hace qué, sin mezclar las cosas. Después de todo, con el código, una vez que se desordena, es difícil modificarlo más tarde.

Análisis de componentes principales

1. GitHubCopilotGrain: Interfaz de servicio de IA distribuido

Como implementación de Orleans Grain, GitHubCopilotGrain proporciona capacidades de servicio de IA distribuido:

public interface IGitHubCopilotGrain : IGrainWithStringKey
{
    /// <summary>
    /// Ejecuta un comando y devuelve respuestas en streaming
    /// </summary>
    Task<IAsyncEnumerable<GitHubCopilotResponse>> ExecuteCommandStreamAsync(
        string command,
        string? heroId = null,
        CancellationToken token = default,
        string? executionMessageId = null,
        string? systemMessage = null,
        Dictionary<string, string>? requestSettings = null);

    /// <summary>
    /// Ejecuta una operación de edición
    /// </summary>
    Task<IAsyncEnumerable<GitHubCopilotResponse>> RunEditAsync(
        string editCommand,
        string? heroId = null,
        CancellationToken token = default);

    /// <summary>
    /// Cancela la ejecución actual
    /// </summary>
    Task CancelAsync(string heroId);
}

Puntos de diseño clave:

Uso de IAsyncEnumerable para soportar respuestas en streaming, evitando esperas prolongadas
Aislamiento de estado a nivel de sesión a través de heroId
Soporte para pasar requestSettings para configurar dinámicamente los parámetros del modelo

2. CopilotAIProvider: Implementación principal del proveedor

CopilotAIProvider es el núcleo de toda la solución, encapsulando toda la lógica de interacción con Copilot CLI:

public class CopilotAIProvider : IAIProvider, IVersionedAIProvider
{
    private readonly CopilotOptions _options;
    private readonly ICopilotProcessExecutor _executor;

    public async IAsyncEnumerable<AIStreamingChunk> SendMessageAsync(
        AIRequest request,
        string? embeddedCommandPrompt = null,
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        // Construir opciones de ejecución
        var options = new CopilotOptions
        {
            Model = request.Model ?? _options.Model,
            SessionId = request.Options?.Settings?.GetValueOrDefault("copilotSessionId"),
            Timeout = _options.Timeout,
            PermissionMode = request.OperationType == AIOperationType.Edit
                ? CopilotPermissionMode.BypassPermissions
                : CopilotPermissionMode.Default
        };

        // Ejecutar comando y procesar respuestas en streaming
        await foreach (var message in _executor.ExecuteAsync(
            options, request.Prompt, cancellationToken))
        {
            yield return BuildChunk(message);
        }
    }
}

Características principales:

Mecanismo de reintento automático: Maneja problemas temporales de red y excepciones del proceso CLI
Seguimiento de contenido de razonamiento: Captura el proceso de razonamiento del modelo (campo reasoning)
Manejo de múltiples tipos de mensajes: Soporta mensajes como assistant, tool.started, tool.completed, etc.
Cambio de modo de permisos: Las operaciones de edición usan automáticamente bypassPermissions, las consultas ordinarias usan default

3. CopilotOptions: Sistema de configuración flexible

La clase de configuración admite una amplia variedad de opciones:

public class CopilotOptions
{
    /// <summary>
    /// Especifica el modelo a usar, como "gpt-4", "gpt-5", "claude-opus-4.5"
    /// </summary>
    public string Model { get; set; } = "gpt-4";

    /// <summary>
    /// Ruta del archivo ejecutable de Copilot CLI
    /// </summary>
    public string ExecutablePath { get; set; } = "copilot";

    /// <summary>
    /// Tiempo de espera de la sesión
    /// </summary>
    public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1800);

    /// <summary>
    /// Método de autenticación
    /// </summary>
    public CopilotAuthSource AuthSource { get; set; } = CopilotAuthSource.LoggedInUser;

    /// <summary>
    /// Modo de permisos
    /// </summary>
    public CopilotPermissionMode PermissionMode { get; set; } = CopilotPermissionMode.Default;

    /// <summary>
    /// ID de sesión, usado para mantener el contexto
    /// </summary>
    public string? SessionId { get; set; }

    /// <summary>
    /// Configuración de permisos de herramientas
    /// </summary>
    public CopilotToolPermissions? Permissions { get; set; }
}

La configuración se trata de que sea suficiente. Después de todo, ¿quién quiere escribir un montón de configuraciones que nunca se usarán? Con cubrir la mayoría de los escenarios es suficiente.

Guía de configuración

1. Configuración básica

Agregue la configuración del proveedor Copilot en appsettings.json:

{
  "AI": {
    "Providers": {
      "Providers": {
        "GitHubCopilot": {
          "Enabled": true,
          "ExecutablePath": "copilot",
          "Model": "gpt-5",
          "Timeout": 1800,
          "IdleTimeout": 300,
          "UseLoggedInUser": true,
          "NoAskUser": true,
          "PermissionMode": "default",
          "Permissions": {
            "AllowAllTools": false,
            "AllowAllPaths": false,
            "AllowedTools": ["Read", "Bash(git:*)", "Bash(cat:*)"],
            "DeniedTools": []
          }
        }
      }
    }
  }
}

2. Selección de modelo

El sistema admite los siguientes modelos (se especifican a través del parámetro --model de Copilot CLI):

Modelo	Descripción	Escenarios recomendados
gpt-4 / gpt-4-turbo	Modelo de cuarta generación de OpenAI	Tareas generales, alta relación calidad-precio
gpt-5	Modelo de quinta generación más reciente de OpenAI	Razonamiento complejo, requiere los mejores resultados
claude-sonnet-4.5	Anthropic Sonnet 4.5	Equilibrio entre rendimiento y costo
claude-opus-4.5	Anthropic Opus 4.5	Tareas de alta precisión

En la práctica de HagiCode, usamos GPT-4 como modelo predeterminado para uso diario, cambiamos a GPT-5 para tareas complejas (como refactorizaciones grandes), y los modelos Claude sirven como alternativa para los usuarios que prefieren Anthropic.

3. Registro de servicios

Registre los servicios relacionados en el contenedor DI:

// Registrar proveedor de IA Copilot
services.AddSingleton<IAIProvider, CopilotAIProvider>();

// Registrar Orleans Grain
services.AddSingleton<IGitHubCopilotGrain, GitHubCopilotGrain>();

// Registrar ejecutor de procesos
services.AddSingleton<ICopilotProcessExecutor, CopilotProcessExecutor>();

En realidad, son solo estas pocas líneas de código, nada especial. Simplemente registramos lo que debe registrarse, para no encontrarlo cuando lo necesitemos.

Ejemplos prácticos

1. Invocación básica

// Obtener Grain
var grain = grainFactory.GetGrain<IGitHubCopilotGrain>("session-123");

// Ejecutar comando
await foreach (var response in grain.ExecuteCommandStreamAsync(
    "Analizar la estructura de código del directorio actual y generar documentación",
    heroId: null,
    token: cancellationToken))
{
    switch (response.Type)
    {
        case ExecutorResponseType.Text:
            Console.Write(response.Content);
            break;
        case ExecutorResponseType.ToolCall:
            Console.WriteLine($"[Invocación de herramienta] {response.ToolName}");
            break;
        case ExecutorResponseType.Completion:
            Console.WriteLine($"\n[Completado] Tokens usados: {response.PromptTokens}+{response.CompletionTokens}");
            break;
    }
}

2. Sesión con contexto

var requestSettings = new Dictionary<string, string>
{
    { "model", "gpt-5" },
    { "temperature", "0.7" },
    { "maxTokens", "4096" },
    { "copilotSessionId", "existing-session-123" }  // Mantener contexto de sesión
};

await foreach (var response in grain.ExecuteCommandStreamAsync(
    "Basado en el análisis anterior, generar las pruebas unitarias correspondientes",
    requestSettings: requestSettings,
    token: cancellationToken))
{
    // Procesar respuesta
}

3. Invocación en modo edición

await foreach (var response in grain.RunEditAsync(
    "Convertir todos los nombres PascalCase a camelCase",
    heroId: "hero-001",
    token: cancellationToken))
{
    if (response.Type == ExecutorResponseType.FileEdit)
    {
        Console.WriteLine($"[Edición] {response.FilePath}: {response.EditCount} modificaciones");
    }
}

Mejores prácticas

Mantenimiento de sesión

Usar el parámetro copilotSessionId permite mantener el contexto entre solicitudes, lo cual es muy útil en escenarios que requieren múltiples rondas de diálogo. Por ejemplo:

// Primera ronda: establecer contexto
var settings1 = new Dictionary<string, string> { { "copilotSessionId", "session-001" } };
await grain.ExecuteCommandStreamAsync("Este es un proyecto C# que usa .NET 8", requestSettings: settings1);

// Segunda ronda: preguntar basándose en el contexto
var settings2 = new Dictionary<string, string> { { "copilotSessionId", "session-001" } };
await grain.ExecuteCommandStreamAsync("Recomendar una estructura de proyecto adecuada", requestSettings: settings2);

Después de todo, la IA no es omnipotente, sin contexto, ¿cómo sabría lo que estás diciendo? Es como chatear,必须有 ida y vuelta para poder continuar.

Control de permisos

Elija el modo de permisos apropiado según el tipo de operación:

Operaciones de consulta: Use el modo default, permitiendo que la IA solo lea archivos y ejecute comandos Git seguros
Operaciones de edición: Use el modo bypassPermissions, permitiendo que la IA modifique archivos

var permissionMode = operationType == AIOperationType.Edit
    ? CopilotPermissionMode.BypassPermissions
    : CopilotPermissionMode.Default;

Lista blanca de herramientas

Controle las operaciones que puede ejecutar la IA a través de la configuración AllowedTools:

{
  "Permissions": {
    "AllowAllTools": false,
    "AllowedTools": [
      "Read",
      "Bash(git:*)",
      "Bash(cat:*)",
      "Glob"
    ]
  }
}

En HagiCode, limitamos estrictamente los permisos de operación de la IA, solo permitiendo leer archivos y ejecutar comandos Git para garantizar la seguridad del sistema.

Después de todo, con la seguridad, nunca se es demasiado cuidadoso. ¿Quién sabe si la IA decide eliminar todo el proyecto en un momento de inspiración?

Manejo de tiempo de espera

El tiempo de espera predeterminado es de 30 minutos. Para operaciones que involucran muchos archivos (como análisis de código completo), puede ser necesario ajustar:

var options = new CopilotOptions
{
    Timeout = TimeSpan.FromMinutes(60)  // Extender a 60 minutos
};

Preguntas frecuentes

P: ¿Cómo cambiar entre diferentes modelos de IA?

R: Específelo a través del elemento de configuración Model o requestSettings:

var settings = new Dictionary<string, string> { { "model", "claude-opus-4.5" } };

En realidad, es solo cambiar un parámetro, nada complejo.

P: ¿Cuánto tiempo se puede mantener el contexto de la sesión?

R: Depende de la implementación de Copilot CLI, generalmente se limpia después del tiempo de espera de inactividad de la sesión (predeterminado 5 minutos). Se puede ajustar a través de la configuración IdleTimeout.

P: ¿Cómo manejar el bloqueo del proceso CLI?

R: CopilotAIProvider tiene un mecanismo de reintento automático integrado que capturará las excepciones del proceso y reiniciará CLI. Si el número de fallos consecutivos es demasiado alto, lanzará AIProviderException.

El bloqueo del programa es algo que nadie puede evitar. Solo se puede hacer la mejor tolerancia a fallos posible, si realmente se bloquea, simplemente reinicie.

P: ¿Admite herramientas personalizadas?

R: Las herramientas que soporta Copilot CLI están predefinidas, pero puede controlar qué herramientas están disponibles a través de la configuración AllowedTools. Las herramientas personalizadas deben esperar actualizaciones futuras de Copilot CLI.

Conclusión

A través de la integración unificada de múltiples modelos de IA con Copilot CLI, resolvimos el desafío de soporte multicmodelo en el desarrollo de HagiCode. Las ventajas principales de esta solución son:

Interfaz unificada: Un conjunto de código soporta múltiples modelos como GPT, Claude, etc.
Gestión de sesiones: Maneja automáticamente el mantenimiento del contexto y el aislamiento de sesiones
Integración de herramientas: Herramientas comunes integradas como operaciones de archivos, operaciones Git, etc.
Respuestas en streaming: Devuelve la salida de IA en tiempo real, mejorando la experiencia del usuario
Seguridad controlable: Control de permisos granular y lista blanca de herramientas

Si su proyecto también necesita soportar múltiples modelos de IA, o está buscando una solución madura de integración de herramientas CLI, pruebe Copilot CLI. Esta arquitectura ha sido verificada completamente en HagiCode y puede soportar las necesidades complejas del entorno de producción.

Después de todo, ¿quién quiere escribir un conjunto de código de invocación para cada modelo? Tener una solución unificada facilita las cosas para todos.

Referencias

Si este artículo te ayuda:

Ven a GitHub y danos una Star: github.com/HagiCode-org/site
Visita el sitio oficial para más información: hagicode.com
Mira el video de demostración de la versión oficial: www.bilibili.com/video/BV1z4oWB3EpY/
Instalación con un solo clic: docs.hagicode.com/installation/docker-compose
Instalación rápida del escritorio Desktop: hagicode.com/desktop/
La prueba pública ha comenzado, bienvenido a instalar y probar

开始使用 HagiCode

一次安装，几分钟上手

HagiCode for Windows 在 Microsoft Store 免费提供。打开商店即可安装并保持更新；也可以先对比各版本与定价，再决定从哪个渠道开始。

前往 Microsoft Store 安装查看版本与定价