Serveur ACP de Copilot CLI

Aperçu

Le 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 pour CLIexemple). Pour plus d’informations sur ce protocole, consultez l’introduction officielle.

Cas d’utilisation

• Intégrations d’IDE : Intégrez la Copilot prise en charge dans n’importe quel éditeur ou environnement de développement.
• CI/CD pipelines : Orchestrer des tâches de codage agentiques dans des flux de travail automatisés.
• Frontends personnalisés : Créez des interfaces spécialisées pour des flux de travail de développement spécifiques.
• Systèmes multi-agents : Coordonnez-vous Copilot avec d’autres agents IA à l’aide d’un protocole standard.

Démarrage du serveur ACP

          CLI GitHub Copilot peut être démarré en tant que serveur ACP à l’aide de l’indicateur `--acp` . Le serveur prend en charge deux modes, `stdio` et `TCP`.

mode stdio (recommandé pour l’intégration de l’IDE)

Par défaut, en fournissant l'indicateur --acp, le mode stdio est déduit. L’indicateur --stdio peut également être fourni pour la désambiguation.

copilot --acp --stdio

Mode TCP

Si l’indicateur --port est fourni en combinaison avec l’indicateur --acp , le serveur est démarré en mode TCP.

copilot --acp --port 3000

Intégration au serveur ACP

Il existe un écosystème croissant de bibliothèques pour interagir par programmation avec les serveurs ACP. Étant donné que CLI GitHub Copilot est correctement installé et authentifié, l'exemple suivant illustre l'utilisation du client typescript pour envoyer une invite unique et afficher la réponse IA.

import * as acp from "@agentclientprotocol/sdk";
import { spawn } from "node:child_process";
import { Readable, Writable } from "node:stream";

async function main() {
  const executable = process.env.COPILOT_CLI_PATH ?? "copilot";

  // ACP uses standard input/output (stdin/stdout) for transport; we pipe these for the NDJSON stream.
  const copilotProcess = spawn(executable, ["--acp", "--stdio"], {
    stdio: ["pipe", "pipe", "inherit"],
  });

  if (!copilotProcess.stdin || !copilotProcess.stdout) {
    throw new Error("Failed to start Copilot ACP process with piped stdio.");
  }

  // Create ACP streams (NDJSON over stdio)
  const output = Writable.toWeb(copilotProcess.stdin) as WritableStream<Uint8Array>;
  const input = Readable.toWeb(copilotProcess.stdout) as ReadableStream<Uint8Array>;
  const stream = acp.ndJsonStream(output, input);

  const client: acp.Client = {
    async requestPermission(params) {
      // This example should not trigger tool calls; if it does, refuse.
      return { outcome: { outcome: "cancelled" } };
    },

    async sessionUpdate(params) {
      const update = params.update;

      if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
        process.stdout.write(update.content.text);
      }
    },
  };

  const connection = new acp.ClientSideConnection((_agent) => client, stream);

  await connection.initialize({
    protocolVersion: acp.PROTOCOL_VERSION,
    clientCapabilities: {},
  });

  const sessionResult = await connection.newSession({
    cwd: process.cwd(),
    mcpServers: [],
  });

  process.stdout.write("Session started!\n");
  const promptText = "Hello ACP Server!";
  process.stdout.write(`Sending prompt: '${promptText}'\n`);

  const promptResult = await connection.prompt({
    sessionId: sessionResult.sessionId,
    prompt: [{ type: "text", text: promptText }],
  });

  process.stdout.write("\n");

  if (promptResult.stopReason !== "end_turn") {
    process.stderr.write(`Prompt finished with stopReason=${promptResult.stopReason}\n`);
  }

  // Best-effort cleanup
  copilotProcess.stdin.end();
  copilotProcess.kill("SIGTERM");
  await new Promise<void>((resolve) => {
    copilotProcess.once("exit", () => resolve());
    setTimeout(() => resolve(), 2000);
  });
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Lectures complémentaires

• Documentation ACP officielle