Comment intégrer de manière unifiée GPT, Claude et autres modèles IA avec Copilot CLI

6 mai 2026

Comment intégrer de manière unifiée GPT, Claude et autres modèles IA avec Copilot CLI

Dans le développement d’applications IA, comment intégrer de manière unifiée plusieurs modèles comme GPT et Claude ? Cet article présente la conception d’un système de fournisseurs IA basé sur l’architecture Orleans Grain, ainsi que notre expérience pratique d’intégration avec GitHub Copilot CLI.

Contexte

Dans le développement d’applications IA modernes, l’intégration des derniers modèles GPT est un besoin central pour de nombreux développeurs. GitHub Copilot CLI est un outil puissant qui prend en charge non seulement les modèles de la série GPT d’OpenAI (comme GPT-4, GPT-5), mais aussi d’autres modèles IA主流 comme Claude. Avec Copilot CLI, les développeurs peuvent appeler différents modèles IA via une interface en ligne de commande unifiée, sans avoir à implémenter une logique d’intégration complexe pour chaque modèle.

C’est en fait un problème souvent évoqué. Écrire la logique d’appel pour chaque modèle, c’est une histoire sans fin. Après tout, trop de code finit par énerver tout le monde. Au lieu de réinventer la roue, mieux vaut trouver une interface unifiée pour tout gérer. Copilot CLI est exactement ça — vous appelez, le reste est géré.

Valeurs clés :

Interface CLI unifiée pour accéder à plusieurs modèles IA
Support de la gestion des sessions et du maintien du contexte
Capacités d’appel d’outils intégrées (opérations de fichiers, Git, etc.)
Support des réponses en streaming et de la sortie en temps réel

À propos de HagiCode

La solution présentée dans cet article provient de notre expérience pratique dans le projet HagiCode. HagiCode est un projet d’assistant de code IA. Au cours du développement, nous avons rencontré le défi de devoir prendre en charge plusieurs modèles IA simultanément — certains utilisateurs préfèrent GPT-4, d’autres Claude, et d’autres veulent essayer le dernier GPT-5. Si nous implémentions une logique d’appel distincte pour chaque modèle, le code deviendrait difficile à maintenir. Grâce à l’interface unifiée de Copilot CLI, nous avons résolu avec succès ce problème de support multi-modèles.

En fait, c’est juste que les utilisateurs ont des goûts variés, difficiles à satisfaire tout le monde. Certains aiment GPT, d’autres préfèrent Claude, et d’autres encore veulent absolument utiliser le dernier GPT-5. Nous voulons simplement que chacun puisse utiliser le modèle qu’il aime, après tout, le bonheur est le plus important.

Conception de l’architecture système

Nous avons implémenté un système de fournisseurs IA évolutif via l’architecture Orleans Grain, avec une architecture globale comme suit :

┌─────────────────┐
│  Frontend/Client │
└────────┬────────┘
         │
         ▼
┌─────────────────────────────────┐
│  IGitHubCopilotGrain (Interface) │
│  - ExecuteCommandStreamAsync    │
│  - RunEditAsync                 │
│  - CancelAsync                  │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  GitHubCopilotGrain (Implémentation) │
│  - Gestion d'état               │
│  - Liaison de session           │
│  - Mapping des réponses         │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  CopilotAIProvider (Fournisseur) │
│  - Analyse de configuration     │
│  - Gestion des permissions      │
│  - Traitement streaming         │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  HagiCode.Libs (Runtime partagé) │
│  - Gestion des processus CLI    │
│  - Analyse du protocole de messages │
│  - Maintien de session          │
└─────────────────────────────────┘

L’avantage de cette architecture réside dans une séparation claire des couches et des responsabilités uniques. La couche d’interface définit le contrat de service IA unifié, la couche d’implémentation gère l’état distribué d’Orleans, la couche fournisseur encapsule les détails d’interaction avec Copilot CLI, et le runtime de base gère la communication avec le processus CLI.

En gros, il s’agit de bien séparer les choses, chacun fait ce qu’il doit faire, sans tout mélanger. Après tout, une fois que le code est en désordre, il devient difficile de le modifier par la suite.

Analyse des composants clés

1. GitHubCopilotGrain : Interface de service IA distribuée

En tant qu’implémentation Orleans Grain, GitHubCopilotGrain fournit des capacités de service IA distribuées :

public interface IGitHubCopilotGrain : IGrainWithStringKey
{
    /// <summary>
    /// Exécute une commande et retourne la réponse 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>
    /// Exécute une opération d'édition
    /// </summary>
    Task<IAsyncEnumerable<GitHubCopilotResponse>> RunEditAsync(
        string editCommand,
        string? heroId = null,
        CancellationToken token = default);

    /// <summary>
    /// Annule l'exécution en cours
    /// </summary>
    Task CancelAsync(string heroId);
}

Points de conception clés :

Utilisation de IAsyncEnumerable pour prendre en charge les réponses en streaming, évitant les longues attentes
Isolation de l’état au niveau de la session via heroId
Support de requestSettings pour configurer dynamiquement les paramètres du modèle

2. CopilotAIProvider : Implémentation du fournisseur principal

CopilotAIProvider est le cœur de toute la solution, encapsulant toute la logique d’interaction avec 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)
    {
        // Construire les options d'exécution
        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
        };

        // Exécuter la commande et traiter la réponse en streaming
        await foreach (var message in _executor.ExecuteAsync(
            options, request.Prompt, cancellationToken))
        {
            yield return BuildChunk(message);
        }
    }
}

Fonctionnalités clés :

Mécanisme de réessai automatique : Gère les problèmes réseau temporaires et les anomalies du processus CLI
Suivi du contenu de raisonnement : Capture le processus de raisonnement du modèle (champ reasoning)
Traitement de plusieurs types de messages : Supporte assistant, tool.started, tool.completed, etc.
Commutation des modes de permission : Les opérations d’édition utilisent automatiquement bypassPermissions, les requêtes normales utilisent default

3. CopilotOptions : Système de configuration flexible

La classe de configuration supporte de nombreuses options :

public class CopilotOptions
{
    /// <summary>
    /// Spécifie le modèle à utiliser, comme "gpt-4", "gpt-5", "claude-opus-4.5"
    /// </summary>
    public string Model { get; set; } = "gpt-4";

    /// <summary>
    /// Chemin de l'exécutable Copilot CLI
    /// </summary>
    public string ExecutablePath { get; set; } = "copilot";

    /// <summary>
    /// Délai d'expiration de la session
    /// </summary>
    public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1800);

    /// <summary>
    /// Méthode d'authentification
    /// </summary>
    public CopilotAuthSource AuthSource { get; set; } = CopilotAuthSource.LoggedInUser;

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

    /// <summary>
    /// ID de session, pour maintenir le contexte
    /// </summary>
    public string? SessionId { get; set; }

    /// <summary>
    /// Configuration des permissions d'outils
    /// </summary>
    public CopilotToolPermissions? Permissions { get; set; }
}

La configuration, c’est comme tout : il suffit que ça soit assez. Après tout, qui veut écrire une pile de configurations qui ne serviront jamais ? Couvrir la plupart des scénarios suffit.

Guide de configuration

1. Configuration de base

Ajoutez la configuration du fournisseur Copilot dans 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. Sélection du modèle

Le système prend en charge les modèles suivants (spécifiés via le paramètre --model de Copilot CLI) :

Modèle	Description	Scénarios recommandés
gpt-4 / gpt-4-turbo	Modèle de 4ème génération OpenAI	Tâches générales, excellent rapport qualité-prix
gpt-5	Dernier modèle de 5ème génération OpenAI	Raisonnement complexe, meilleurs résultats
claude-sonnet-4.5	Anthropic Sonnet 4.5	Équilibre performance et coût
claude-opus-4.5	Anthropic Opus 4.5	Tâches de haute précision

Dans la pratique de HagiCode, nous utilisons GPT-4 par défaut comme modèle quotidien, pour les tâches complexes (comme les refactorisations majeures) nous basculons vers GPT-5, tandis que les modèles Claude sont proposés comme alternative aux utilisateurs qui préfèrent Anthropic.

3. Enregistrement des services

Enregistrez les services associés dans le conteneur DI :

// Enregistrer le fournisseur IA Copilot
services.AddSingleton<IAIProvider, CopilotAIProvider>();

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

// Enregistrer l'exécuteur de processus
services.AddSingleton<ICopilotProcessExecutor, CopilotProcessExecutor>();

En fait, ce n’est que quelques lignes de code, rien de spécial. Il suffit d’enregistrer tout ce qui doit l’être, pour éviter de ne pas trouver ce dont on a besoin au moment de l’utiliser.

Exemples pratiques

1. Appel de base

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

// Exécuter la commande
await foreach (var response in grain.ExecuteCommandStreamAsync(
    "Analyser la structure du code du répertoire actuel et générer la documentation",
    heroId: null,
    token: cancellationToken))
{
    switch (response.Type)
    {
        case ExecutorResponseType.Text:
            Console.Write(response.Content);
            break;
        case ExecutorResponseType.ToolCall:
            Console.WriteLine($"[Appel d'outil] {response.ToolName}");
            break;
        case ExecutorResponseType.Completion:
            Console.WriteLine($"\n[Terminé] Tokens utilisés: {response.PromptTokens}+{response.CompletionTokens}");
            break;
    }
}

2. Session avec contexte

var requestSettings = new Dictionary<string, string>
{
    { "model", "gpt-5" },
    { "temperature", "0.7" },
    { "maxTokens", "4096" },
    { "copilotSessionId", "existing-session-123" }  // Maintenir le contexte de session
};

await foreach (var response in grain.ExecuteCommandStreamAsync(
    "Sur la base de l'analyse précédente, générer les tests unitaires correspondants",
    requestSettings: requestSettings,
    token: cancellationToken))
{
    // Traiter la réponse
}

3. Appel en mode édition

await foreach (var response in grain.RunEditAsync(
    "Convertir tous les noms PascalCase en camelCase",
    heroId: "hero-001",
    token: cancellationToken))
{
    if (response.Type == ExecutorResponseType.FileEdit)
    {
        Console.WriteLine($"[Édition] {response.FilePath}: {response.EditCount} modifications");
    }
}

Meilleures pratiques

Maintien de session

Utilisez le paramètre copilotSessionId pour maintenir le contexte entre les requêtes, ce qui est très utile dans les scénarios nécessitant plusieurs tours de dialogue. Par exemple :

// Premier tour : établir le contexte
var settings1 = new Dictionary<string, string> { { "copilotSessionId", "session-001" } };
await grain.ExecuteCommandStreamAsync("C'est un projet C# utilisant .NET 8", requestSettings: settings1);

// Deuxième tour : poser une question basée sur le contexte
var settings2 = new Dictionary<string, string> { { "copilotSessionId", "session-001" } };
await grain.ExecuteCommandStreamAsync("Recommander une structure de projet appropriée", requestSettings: settings2);

Après tout, l’IA n’est pas omnipotente, sans contexte comment peut-elle savoir de quoi vous parlez ? C’est comme une conversation, il faut des allers-retours pour pouvoir continuer.

Contrôle des permissions

Choisissez le mode de permission approprié selon le type d’opération :

Opérations de requête : Utilisez le mode default, l’IA ne peut que lire les fichiers et exécuter des commandes Git sûres
Opérations d’édition : Utilisez le mode bypassPermissions, permettant à l’IA de modifier les fichiers

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

Liste blanche d’outils

Contrôlez les opérations que l’IA peut exécuter via la configuration AllowedTools :

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

Dans HagiCode, nous limitons strictement les permissions d’opération de l’IA, n’autorisant que la lecture de fichiers et l’exécution de commandes Git, assurant ainsi la sécurité du système.

Après tout, la sécurité, on ne peut jamais être trop prudent. Qui sait si l’IA ne décidera pas de supprimer tout votre projet sur un coup de tête ?

Gestion du délai d’expiration

Le délai d’expiration par défaut est de 30 minutes, pour les opérations impliquant de nombreux fichiers (comme l’analyse complète du code), un ajustement peut être nécessaire :

var options = new CopilotOptions
{
    Timeout = TimeSpan.FromMinutes(60)  // Étendre à 60 minutes
};

Questions fréquentes

Q : Comment basculer entre différents modèles IA ?

R : Spécifiez via la configuration Model ou requestSettings :

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

En fait, il suffit de changer un paramètre, rien de compliqué.

Q : Combien de temps le contexte de session peut-il être maintenu ?

R : Cela dépend de l’implémentation de Copilot CLI, généralement nettoyé après le délai d’inactivité de la session (5 minutes par défaut). Peut être ajusté via la configuration IdleTimeout.

Q : Comment gérer les plantages du processus CLI ?

R : CopilotAIProvider intègre un mécanisme de réessai automatique, il capture les anomalies du processus et redémarre le CLI. Si les échecs consécutifs sont trop nombreux, une AIProviderException sera lancée.

Les plantages de programme, personne ne peut les éviter. On peut seulement faire de son mieux pour la tolérance aux pannes, si ça tombe vraiment, on redémarre.

Q : Les outils personnalisés sont-ils pris en charge ?

R : Les outils pris en charge par Copilot CLI sont prédéfinis, mais vous pouvez contrôler quels outils sont disponibles via la configuration AllowedTools. Les outils personnalisés nécessitent d’attendre les futures mises à jour de Copilot CLI.

Conclusion

En intégrant de manière unifiée plusieurs modèles IA via Copilot CLI, nous avons résolu le problème du support multi-modèles dans le développement de HagiCode. Les avantages clés de cette solution sont :

Interface unifiée : Un seul code pour prendre en charge plusieurs modèles comme GPT, Claude
Gestion des sessions : Gestion automatique du maintien du contexte et de l’isolement des sessions
Intégration d’outils : Outils courants intégrés comme les opérations de fichiers et Git
Réponses en streaming : Retour en temps réel de la sortie IA, améliorant l’expérience utilisateur
Sécurité contrôlable : Contrôle granulaire des permissions et liste blanche d’outils

Si votre projet doit également prendre en charge plusieurs modèles IA, ou si vous recherchez une solution d’intégration CLI mature, essayez Copilot CLI. Cette architecture a été entièrement testée dans HagiCode et peut répondre aux exigences complexes des environnements de production.

Après tout, qui veut écrire un code d’appel pour chaque modèle ? Avoir une solution unifiée, tout le monde gagne du temps.

Références

Si cet article vous a aidé :

Venez mettre une étoile sur GitHub : github.com/HagiCode-org/site
Visitez le site officiel pour en savoir plus : hagicode.com
Regardez la vidéo de démonstration de la version officielle : www.bilibili.com/video/BV1z4oWB3EpY/
Installation en un clic : docs.hagicode.com/installation/docker-compose
Installation rapide du bureau Desktop : hagicode.com/desktop/
La bêta publique a commencé, bienvenue pour l’installation et l’essai

开始使用 HagiCode

一次安装，几分钟上手

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

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