Agent Client Protocol (ACP)

Kiro CLI met en œuvre le Agent Client Protocol (ACP), une norme ouverte qui permet aux agents d'IA de fonctionner avec n'importe quel éditeur compatible. Cela signifie que vous pouvez utiliser les capacités agentives de Kiro dans les IDE JetBrains, Zed et d'autres éditeurs compatibles avec ACP.

Les agents de programmation par IA et les éditeurs sont étroitement couplés, mais l'interopérabilité n'est pas la norme par défaut. Chaque éditeur doit créer des intégrations personnalisées pour chaque agent, et les agents doivent mettre en œuvre des API propres à chaque éditeur. Cela crée une surcharge d'intégration, une compatibilité limitée et un enfermement propriétaire pour les développeurs.

L'ACP résout ce problème en fournissant un protocole normalisé pour la communication agent-éditeur — semblable à la façon dont le Language Server Protocol (LSP) a normalisé l'intégration des serveurs de langage. Les agents qui mettent en œuvre l'ACP fonctionnent avec n'importe quel éditeur compatible, et les éditeurs qui prennent en charge l'ACP ont accès à tous les agents compatibles avec l'ACP.

Exécutez Kiro comme agent ACP :

kiro-cli acp

Pour utiliser une configuration d'agent précise :

kiro-cli acp --agent my-agent

L'agent communique via stdin/stdout en utilisant JSON-RPC 2.0. Configurez votre éditeur pour qu'il lance cette commande, et vous êtes prêt à commencer.

Kiro CLI peut être utilisé comme agent ACP dans n'importe quel éditeur qui prend en charge le protocole.

Les IDE JetBrains (IntelliJ IDEA, WebStorm, PyCharm, etc.) prennent en charge l'ACP par l'intermédiaire d'AI Assistant. Consultez la documentation ACP de JetBrains pour tous les détails.

Pour ajouter Kiro comme agent personnalisé :

1. Ouvrez la fenêtre d'outil AI Chat
2. Cliquez sur le bouton des paramètres et sélectionnez Add Custom Agent
3. Ajoutez ce qui suit à ~/.jetbrains/acp.json :

{
  "agent_servers": {
    "Kiro Agent": {
      "command": "/full/path/to/kiro-cli",
      "args": ["acp"]
    }
  }
}

L'agent apparaîtra dans le sélecteur de mode d'AI Chat.

Zed prend en charge nativement les agents ACP. Consultez la documentation sur les agents externes de Zed pour tous les détails. Ajoutez ce qui suit à vos paramètres Zed (~/.config/zed/settings.json) :

{
  "agent_servers": {
    "Kiro Agent": {
      "type": "custom",
      "command": "~/.local/bin/kiro-cli",
      "args": ["acp"],
      "env": {}
    }
  }
}

Sélectionnez « Kiro Agent » dans le sélecteur d'agent du panneau d'IA de Zed.

Tout éditeur prenant en charge l'ACP peut intégrer Kiro en lançant kiro-cli acp et en communiquant via JSON-RPC sur stdio. Consultez la spécification ACP pour les détails du protocole.

Kiro CLI met en œuvre les méthodes ACP suivantes, vous donnant accès à la gestion des sessions, à la sélection du modèle et à la diffusion en continu des réponses lorsque vous utilisez Kiro par l'intermédiaire de n'importe quel éditeur compatible avec l'ACP.

L'agent ACP de Kiro annonce ces capacités lors de l'initialisation :

• loadSession: true - Prend en charge le chargement de sessions existantes
• promptCapabilities.image: true - Prend en charge le contenu image dans les requêtes

L'agent envoie ces types de mises à jour de session via session/notification :

Kiro étend l'ACP avec des méthodes personnalisées (préfixées par _kiro.dev/ conformément à la spécification ACP) pour exposer des fonctionnalités propres à Kiro comme les commandes slash, les serveurs MCP et la compaction du contexte. Les clients qui ne prennent pas en charge ces extensions peuvent les ignorer sans problème — il s'agit d'améliorations facultatives.

Voici comment un client ACP initialise une connexion avec Kiro :

// Client sends initialize request
{
  "jsonrpc": "2.0",
  "id": 0,
  "method": "initialize",
  "params": {
    "protocolVersion": 1,
    "clientCapabilities": {
      "fs": {
        "readTextFile": true,
        "writeTextFile": true
      },
      "terminal": true
    },
    "clientInfo": {
      "name": "my-editor",
      "version": "1.0.0"
    }
  }
}

// Kiro responds with capabilities
{
  "jsonrpc": "2.0",
  "id": 0,
  "result": {
    "protocolVersion": 1,
    "agentCapabilities": {
      "loadSession": true,
      "promptCapabilities": {
        "image": true
      }
    },
    "agentInfo": {
      "name": "kiro-cli",
      "version": "1.5.0"
    }
  }
}

Après l'initialisation, créez une session et commencez à envoyer des requêtes :

// Create a new session
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "session/new",
  "params": {
    "cwd": "/home/user/my-project",
    "mcpServers": []
  }
}

// Send a prompt
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "session/prompt",
  "params": {
    "sessionId": "sess_abc123",
    "content": [
      {
        "type": "text",
        "text": "Explain this codebase"
      }
    ]
  }
}

Les sessions ACP sont conservées sur le disque à :

~/.kiro/sessions/cli/

Chaque session crée deux fichiers :

• <session-id>.json - Métadonnées et état de la session
• <session-id>.jsonl - Journal des événements (historique de conversation)

Les journaux de l'agent ACP sont écrits à l'emplacement standard des journaux de Kiro :

Contrôlez le niveau de verbosité des journaux avec des variables d'environnement :

KIRO_LOG_LEVEL=debug kiro-cli acp
KIRO_CHAT_LOG_FILE=/path/to/custom.log kiro-cli acp

• Clavardage interactif - Utilise l'ACP en interne
• Intégration MCP - Les serveurs MCP peuvent être transmis aux sessions ACP
• Référence des commandes CLI