{"meta":{"title":"Serveur ACP de Copilot CLI","intro":"En savoir plus sur le serveur du Protocole Client Agent GitHub Copilot CLI.","product":"GitHub Copilot","breadcrumbs":[{"href":"/fr/copilot","title":"GitHub Copilot"},{"href":"/fr/copilot/reference","title":"Informations de référence"},{"href":"/fr/copilot/reference/copilot-cli-reference","title":"Copilot CLI référence"},{"href":"/fr/copilot/reference/copilot-cli-reference/acp-server","title":"Serveur ACP"}],"documentType":"article"},"body":"# Serveur ACP de Copilot CLI\n\nEn savoir plus sur le serveur du Protocole Client Agent GitHub Copilot CLI.\n\n> \\[!NOTE]\n> Le support ACP dans GitHub Copilot CLI est en préversion publique et est susceptible de changer.\n\n## Aperçu\n\nLe protocole ACP (Agent Client Protocol) est un protocole qui normalise la communication entre les clients (tels que les éditeurs de code et les IDE) et les agents (par Copilot CLIexemple). Pour plus d’informations sur ce protocole, consultez [l’introduction officielle](https://agentclientprotocol.com/get-started/introduction).\n\n## Cas d’utilisation\n\n* **Intégrations d’IDE :** Intégrez la Copilot prise en charge dans n’importe quel éditeur ou environnement de développement.\n* **CI/CD pipelines :** Orchestrer des tâches de codage agentiques dans des flux de travail automatisés.\n* **Frontends personnalisés :** Créez des interfaces spécialisées pour des flux de travail de développement spécifiques.\n* **Systèmes multi-agents :** Coordonnez-vous Copilot avec d’autres agents IA à l’aide d’un protocole standard.\n\n## Démarrage du serveur ACP\n\nUtilisez l’option `--acp` de la `copilot` commande pour démarrer le serveur ACP de l’interface CLI. Vous pouvez spécifier le mode de transport avec l’option `--stdio` ou `--port`. Si aucun mode de transport n’est spécifié, le serveur est défini par défaut sur le mode stdio.\n\nLe mode ACP permet aux sessions avec un fournisseur BYOK (bring-your-own-key) configuré (`COPILOT_PROVIDER_*` variables d’environnement) de s’exécuter sans GitHub login, ce qui correspond au comportement du mode `-p`/interactive.\n\n### Options appliquées à chaque session\n\nLa requête ACP `session/new` permet uniquement à un client de définir quelques paramètres de session, tels que le répertoire de travail et les serveurs MCP à utiliser. Il n’inclut pas le filtrage des outils ni les paramètres de raisonnement. Pour les configurer, transmettez les options correspondantes lorsque vous **démarrez le serveur**. Le serveur stocke les valeurs et les applique comme configuration initiale pour chaque session qu’il crée ou charge, pour tout client qui se connecte. Le client qui se connecte ne choisit pas ces valeurs — c’est la personne qui lance le serveur qui les choisit.\n\n| Option serveur                               | Valeur acceptée                                                         | Effet sur chaque session                                |\n| -------------------------------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------- |\n| `--available-tools=TOOL ...`                 | Une liste de noms d’outils entre guillemets et séparés par des virgules | La session ne peut utiliser que les outils répertoriés. |\n| `--excluded-tools=TOOL ...`                  | Une liste de noms d’outils entre guillemets et séparés par des virgules | Les outils répertoriés sont supprimés de la session.    |\n| `--effort=LEVEL`, `--reasoning-effort=LEVEL` |                                                                         |                                                         |\n| `low`, `medium`, `high`, `xhigh` ou`max`     | Définit l’effort initial de raisonnement de la session.                 |                                                         |\n\nPar exemple, cette commande démarre un serveur dont toutes les sessions utilisent le niveau maximal d’effort de raisonnement et n’exposent que les outils `bash` et `view` :\n\n```bash\ncopilot --acp --port 3000 --effort=max --available-tools=\"bash,view\"\n```\n\nChaque session sur laquelle le client connecté s’ouvre sur ce serveur hérite de ces paramètres. Étant donné que les valeurs sont corrigées au démarrage du serveur, un client ne peut pas les modifier par session via `session/new`.\n\n### mode stdio\n\nLe mode stdio est déduit par défaut lorsque vous démarrez le serveur ACP. Vous pouvez également utiliser l’option pour lever l’ambiguïté `--stdio` .\n\n```bash\ncopilot --acp --stdio\n```\n\n### Mode TCP\n\nSi l’option `--port` est fournie en combinaison avec l’option `--acp` , le serveur est démarré en mode TCP.\n\n```bash\ncopilot --acp --port 3000\n```\n\n### Choix entre stdio et TCP\n\nLes deux modes de transport portent les mêmes messages ACP, encodés en tant que JSON délimité par une nouvelle ligne (NDJSON). Ils diffèrent uniquement dans la façon dont un client se connecte au serveur et comment le cycle de vie du serveur est géré. Les deux modes sont mutuellement exclusifs : fournir à la fois `--stdio` et `--port` est refusé.\n\n| Aspect                  | mode stdio                                                                                                                               | Mode TCP                                                                                                                                                          |\n| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Connexion du client** | Le client démarre `copilot --acp` en tant que processus enfant et échange des messages sur l’entrée et la sortie standard du processus.  | Le serveur ouvre un écouteur TCP auquel les clients se connectent via un socket réseau. Par défaut, il se lie à l’adresse de bouclage `127.0.0.1`.                |\n| **Nombre de clients**   | Un seul client : le processus qui a généré le serveur et possède le canal.                                                               | L’écouteur accepte les connexions socket, chacune étant traitée comme une connexion d’agent distincte.                                                            |\n| **Cycle de vie**        | Lié au processus parent. Lorsque le flux d’entrée se ferme, car le parent quitte ou ferme le canal, le serveur s’arrête automatiquement. | Indépendant de n’importe quel client unique. Le serveur reste à l’écoute sur le port jusqu’à ce qu’il soit arrêté, par exemple avec <kbd>Ctrl</kbd>+<kbd>C</kbd>. |\n| **Sortie standard**     | Réservé pour le flux de protocole NDJSON, il ne peut donc pas être utilisé pour les journaux ou d’autres textes.                         | Gratuit pour d’autres utilisations, car le trafic de protocole se déplace sur le socket.                                                                          |\n\nQuand utiliser chaque mode :\n\n* Utilisez le **mode stdio** lorsqu’un éditeur, un IDE ou un script lance Copilot CLI directement comme sous-processus. Il s’agit de la configuration par défaut et de la configuration recommandée pour l’intégration à l’IDE, car le transport est établi automatiquement au démarrage du processus et fermé lorsqu’il se termine.\n* Utilisez le **mode TCP** lorsqu’un client doit atteindre le serveur sur un socket au lieu d’un canal( par exemple, à partir d’un processus ou d’un conteneur distinct, ou lors de la connexion à un serveur de longue durée sur un port connu.\n\n## Exemple : intégration au serveur ACP\n\nL’exemple suivant est une application cliente qui utilise Copilot en interagissant avec le serveur ACP de GitHub Copilot CLI. Il démarre le serveur ACP en mode stdio, ouvre une session, vous demande d’entrer une invite, de l’envoyer et d’imprimer la réponse diffusée.\n\nIl existe un écosystème croissant de bibliothèques pour interagir avec les serveurs ACP par programmation. Cet exemple utilise la [bibliothèque ACP TypeScript](https://agentclientprotocol.com/libraries/typescript).\n\nPour exécuter cet exemple, vous avez besoin des dépendances suivantes :\n\n* [Node.js](https://nodejs.org) version 18 ou ultérieure.\n* GitHub Copilot CLI, installé et soit authentifié avec GitHub, soit configuré avec un fournisseur BYOK (voir [Démarrage du serveur ACP](#starting-the-acp-server)).\n* Package `@agentclientprotocol/sdk` , qui fournit la bibliothèque ACP TypeScript. Installez-le en exécutant `npm install @agentclientprotocol/sdk`.\n\n```typescript copy\nimport * as acp from \"@agentclientprotocol/sdk\";\nimport { spawn } from \"node:child_process\";\nimport { Readable, Writable } from \"node:stream\";\nimport * as readline from \"node:readline/promises\";\n\nasync function main() {\n  const executable = process.env.COPILOT_CLI_PATH ?? \"copilot\";\n\n  // ACP uses standard input/output (stdin/stdout) for transport; we pipe these for the NDJSON stream.\n  const copilotProcess = spawn(executable, [\"--acp\", \"--stdio\"], {\n    stdio: [\"pipe\", \"pipe\", \"inherit\"],\n  });\n\n  if (!copilotProcess.stdin || !copilotProcess.stdout) {\n    throw new Error(\"Failed to start Copilot ACP process with piped stdio.\");\n  }\n\n  // Create ACP streams (NDJSON over stdio)\n  const output = Writable.toWeb(copilotProcess.stdin) as WritableStream<Uint8Array>;\n  const input = Readable.toWeb(copilotProcess.stdout) as ReadableStream<Uint8Array>;\n  const stream = acp.ndJsonStream(output, input);\n\n  const client: acp.Client = {\n    async requestPermission(params) {\n      // This example should not trigger tool calls; if it does, refuse.\n      return { outcome: { outcome: \"cancelled\" } };\n    },\n\n    async sessionUpdate(params) {\n      const update = params.update;\n\n      if (update.sessionUpdate === \"agent_message_chunk\" && update.content.type === \"text\") {\n        process.stdout.write(update.content.text);\n      }\n    },\n  };\n\n  const connection = new acp.ClientSideConnection((_agent) => client, stream);\n\n  await connection.initialize({\n    protocolVersion: acp.PROTOCOL_VERSION,\n    clientCapabilities: {},\n  });\n\n  const sessionResult = await connection.newSession({\n    cwd: process.cwd(),\n    mcpServers: [],\n  });\n\n  process.stdout.write(\"Session started!\\n\");\n\n  // Ask the user to enter a prompt instead of using a hard-coded one.\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n  const promptText = await rl.question(\"Enter a prompt: \");\n  rl.close();\n\n  const promptResult = await connection.prompt({\n    sessionId: sessionResult.sessionId,\n    prompt: [{ type: \"text\", text: promptText }],\n  });\n\n  process.stdout.write(\"\\n\");\n\n  if (promptResult.stopReason !== \"end_turn\") {\n    process.stderr.write(`Prompt finished with stopReason=${promptResult.stopReason}\\n`);\n  }\n\n  // Best-effort cleanup\n  copilotProcess.stdin.end();\n  copilotProcess.kill(\"SIGTERM\");\n  await new Promise<void>((resolve) => {\n    copilotProcess.once(\"exit\", () => resolve());\n    setTimeout(() => resolve(), 2000);\n  });\n}\n\nmain().catch((error) => {\n  console.error(error);\n  process.exitCode = 1;\n});\n```\n\nPour exécuter l’exemple :\n\n1. Enregistrez le code ci-dessus dans un fichier nommé `acp-client.ts`.\n2. Exécutez le fichier avec `npx tsx`, qui exécute le TypeScript directement sans étape de génération distincte :\n\n   ```bash\n   npx tsx acp-client.ts\n   ```\n\n## Utilisation des commandes slash\n\nLes commandes slash intégrées de GitHub Copilot CLI peuvent être exécutées via ACP. Pour appeler celui-ci, envoyez-le en tant qu’invite ordinaire dont le texte est la commande, passé en tant que bloc de contenu de texte unique( par exemple, `/context` ou `/session info`. Le serveur reconnaît la commande et l’exécute directement : commandes d’information telles que `/usage` ou `/context` renvoyer leur sortie sans appeler le modèle, tandis que les commandes d’action telles que `/plan` ou `/review` démarrent la tâche d’agent correspondante. Dans les deux cas, le texte de la commande n’est pas envoyé au modèle en tant que question.\n\n### Découverte des commandes disponibles\n\nLe serveur publie les commandes qu’il prend en charge via la notification de session ACP `available_commands_update` standard. Il est envoyé après la création ou le chargement d’une session, puis de nouveau chaque fois que l’ensemble change, par exemple lorsque le chargement des compétences est terminé. Cette liste publiée constitue l’ensemble de commandes de référence, toujours à jour, que vous pouvez exécuter via ACP, et les clients la présentent généralement dans un menu de commandes.\n\nLa liste annoncée contient les éléments suivants :\n\n* **Commandes intégrées**, telles que `/compact`, `/context`, `/usage`, `/env`, `/model`, `/mcp`, `/plan`, `/review`, `/research`, `/session` et `/rename`.\n* **Compétences invocables activées par l’utilisateur**, qui apparaissent sous forme `/SKILL-NAME` de commandes.\n\nLes commandes que le client lui-même enregistre ne lui sont pas annoncées en retour.\n\n### Accès à la liste à partir de votre client\n\nÉtant donné que la liste arrive en tant que notification plutôt que en réponse à une demande, il n’existe aucune méthode pour l’extraire à la demande. Votre client y accède en gérant la notification et en réagissant aux mises à jour dont le `session/update` type est `available_commands_update`. Chaque entrée a une `name` (sans barre oblique principale), un `description`et un facultatif `input.hint` qui décrit les arguments de la commande. La notification est renvoyée chaque fois que l’ensemble change ; considérez donc chacune d’elles comme un remplacement complet de toute liste que vous avez en cache.\n\nLe gestionnaire suivant `sessionUpdate` capture les commandes publiées, en étendant l’objet `client` à partir de l’exemple présenté précédemment.\n\n```typescript copy\n// Track the latest advertised commands for the session.\nlet availableCommands: acp.AvailableCommand[] = [];\n\nconst client: acp.Client = {\n  async sessionUpdate(params) {\n    const update = params.update;\n\n    if (update.sessionUpdate === \"available_commands_update\") {\n      // This notification is a full snapshot—replace any cached list.\n      availableCommands = update.availableCommands;\n      for (const command of availableCommands) {\n        // command.name has no leading slash; invoke it by sending \"/<name>\" as a prompt.\n        console.log(`/${command.name} — ${command.description}`);\n      }\n      return;\n    }\n\n    // ...handle other updates, such as agent_message_chunk\n  },\n\n  // ...other client methods, such as requestPermission\n};\n```\n\nPour exécuter l’une des commandes publiées, envoyez son nom en tant qu’invite dans un bloc de contenu texte unique, par exemple, `{ type: \"text\", text: \"/context\" }`comme décrit dans [Utilisation des commandes de barre oblique](#using-slash-commands).\n\n### Commandes qui ne peuvent pas être utilisées sur ACP\n\nLes commandes slash qui dépendent de l’interface interactive du terminal ne sont pas prises en charge par le serveur ACP. Cela inclut les commandes qui ouvrent un sélecteur, une boîte de dialogue ou une vue plein écran, telles que `/diff`, , `/resume``/theme`, `/settings`, , `/login`, `/help``/tasks`et `/undo`. En règle générale, si une commande n’apparaît pas dans la `available_commands_update` liste, elle ne s’exécute pas sur ACP : le serveur traite le texte comme une invite ordinaire et le transfère au modèle au lieu de l’exécuter.\n\nÉtant donné que les clients ACP n’ont pas de sélecteurs interactifs, une commande intégrée qui ouvrirait normalement un sous-menu retourne plutôt ses options sous forme de texte. Fournissez explicitement la sous-commande pour obtenir un résultat direct, par exemple, `/session info` ou `/mcp list` plutôt que `/session` ou `/mcp` par lui-même.\n\nPour obtenir la liste complète des commandes de barre oblique pour Copilot CLI, consultez [Référence de commande CLI pour GitHub Copilot](/fr/copilot/reference/copilot-cli-reference/cli-command-reference#slash-commands-in-the-interactive-interface).\n\n## Lectures complémentaires\n\n* [Documentation ACP officielle](https://agentclientprotocol.com/protocol/overview)"}