ACP offre à une interface de codage et à un agent de codage un moyen partagé d'ouvrir un projet, d'échanger des invites, de diffuser la progression, de demander une approbation, d'annuler un travail et de continuer la même session. ADK-Rust implémente les deux côtés de cette relation.
Architecture ADK-Rust ACP
Le programme avec l'interface est le client ACP. Le programme effectuant le travail de codage est l'agent ACP. ADK-Rust peut s’asseoir de chaque côté de cette relation.
01 · ADK-Rust est le client/hôte ACP
Décide qu'une tâche de référentiel nécessite un spécialiste du codage.
Démarre le processus, choisit l'espace de travail, conserve le contexte et applique la stratégie d'autorisation.
Inspecte le code, propose des modifications, appelle des outils et diffuse sa progression.
The shared ACP v1 contract
Both directions use the same message vocabulary.
initializesession/newsession/promptsession/updaterequest_permissioncancelclose · list · resume · delete02 · ADK-Rust est l'agent/serveur ACP
Possède l'interface utilisateur de conversation et démarre le binaire ADK-Rust.
Négocie les capacités, valide les sessions, diffuse les mises à jour et gère les annulations.
Utilise des modèles, des outils Rust, des flux de travail, des sessions, de la mémoire et des artefacts pour terminer le tour.
Une session ACP est mappée à une session ADK-Rust persistante.
Le client sélectionne une option réellement proposée par l'agent.
Flux de texte, de réflexions, de démarrages d'outils et d'achèvement d'outils sous la forme session/update.
Stable ACP v1 utilise un sous-processus local et JSON-RPC sur stdio.
Commencez par la relation
Un agent de codage peut raisonner sur un référentiel et utiliser des outils, mais les utilisateurs ont toujours besoin d'une interface où ils peuvent décrire le travail, voir ce que fait l'agent, répondre aux questions, approuver les actions sensibles et arrêter un tour. Sans standard, chaque éditeur et chaque agent de codage a besoin d'une intégration personnalisée pour ces bases.
ACP définit cette conversation manquante. Le client est propriétaire de l'interface et de l'environnement de travail qu'il choisit de fournir. L'agent possède l'intelligence de codage. Ils se mettent d'accord sur les sessions, les invites, le contenu, les mises à jour en direct, les appels d'outils, les choix d'autorisations, l'annulation et l'achèvement sans avoir besoin de partager le code d'implémentation.
ADK-Rust prend en charge les deux directions pratiques. Un agent ADK peut déléguer le travail à un agent de codage ACP externe en tant qu'outil. Grâce à la fonctionnalité serveur, un éditeur peut démarrer un binaire ADK-Rust et utiliser son Runner, ses modèles, ses outils, ses sessions, sa mémoire et ses flux de travail via le même contrat ACP v1.
Généralement un éditeur, une application de bureau, un coordinateur CLI ou ADK-Rust. Il démarre l'agent de codage, ouvre une session de projet, affiche la progression et décide comment les questions d'autorisation parviennent à l'utilisateur.
Il reçoit des invites, des raisons concernant le référentiel, rapporte l'activité de l'outil, demande avant les actions sensibles et renvoie une raison d'arrêt à la fin du tour.
Une session possède un ID, un répertoire de travail absolu, des racines d'espace de travail facultatives, plusieurs invites, des mises à jour en streaming et un cycle de vie clair de fermeture ou de reprise.
L'agent décrit l'appel exact de l'outil et propose des choix. Le client renvoie l'un de ces choix, de sorte que l'application (et non l'agent) contrôle si l'action se poursuit.
One ACP turn
Read from top to bottom. Initialization establishes the contract once. A session then carries several prompts, live updates, approval questions, cancellation, and a final stop reason.
Editor or ADK-Rust
Coding process or ADK-Rust
initializeprotocolVersion: 1
capabilitiesWhat this agent really supports
session/newAbsolute cwd + workspace roots
session/promptTyped content blocks
session/updateText · thought · tool call
session/request_permissionChoose from offered options
permission responseAllow once · always · reject
PromptResponseend_turn · cancelled
session/cancel into the Runner cancellation token and returns a typed cancelled stop reason.Première direction · ADK-Rust est le client
Le processus externe ACP apparaît dans ADK-Rust en tant qu'outil nommé. Votre coordinateur peut décider quand l'utiliser, choisir le répertoire du projet, préserver le contexte lorsque le travail s'étend sur plusieurs tours, diffuser la progression dans votre interface et conserver la politique d'approbation en dehors de l'agent de codage.
AcpAgentToolIdéal lorsqu'un agent ADK délègue occasionnellement une tâche de référentiel autonome. Chaque appel démarre un processus ACP et renvoie son texte comme sortie normale de l'outil.
AcpToolsetDonnez un coordinateur nommé agents de révision, de test, de migration ou de documentation. Leurs descriptions d'outils aident le modèle à acheminer chaque tâche vers le bon processus.
AcpSessionMaintenez le processus et la session ACP en vie à travers les invites. L'agent se souvient de ce qu'il a déjà inspecté et une poignée d'annulation peut arrêter un virage en vol.
stream_promptRecevez des fragments de texte, de réflexion, d'appel d'outil, d'autorisation, d'achèvement et d'erreur au fur et à mesure qu'ils se produisent au lieu d'attendre une chaîne combinée.
use adk_acp::{AcpAgentTool, PermissionPolicy};
let coder = AcpAgentTool::new("my-coding-agent --acp")
.name("repository_coder")
.description("Inspect and improve this Rust project")
.working_dir("/absolute/path/to/project")
.permission_policy(PermissionPolicy::DenyAll);
let coordinator = LlmAgentBuilder::new("coordinator")
.model(model)
.tool(Arc::new(coder))
.build()?;let mut session = AcpSession::start(
AcpAgentConfig::new("my-coding-agent --acp")
.working_dir("/absolute/path/to/project"),
Arc::new(permission_policy),
).await?;
let cancel = session.cancellation_handle()?;
tokio::spawn(async move {
shutdown.cancelled().await;
cancel.cancel().await
});
let result = session
.prompt("Trace the failing test and propose a fix")
.await?;Le client peut fournir l'environnement de travail
ACP ne suppose pas qu'un agent de codage puisse lire votre disque ou exécuter des commandes directement. Le client déclare les services qu'il est prêt à fournir, traite chaque demande et maintient les règles de sécurité au plus près du produit et de l'utilisateur.
ADK-Rust expose désormais les interfaces hôtes de fichiers et de terminaux typés et transmet les serveurs MCP fournis par le client à la création de session. Rien n'est activé par défaut. Un outil de documentation en lecture seule, un éditeur de bureau avec des tampons non enregistrés et un générateur de build isolé peuvent chacun publier un ensemble de fonctionnalités différent et précis.
Your editor or application decides how reads and writes work. It can return an unsaved buffer, enforce approved roots, reject a symlink escape, or make the session read-only.
The coding agent can start a command, collect output, wait, stop it, and release it through the client. Terminal support stays disabled until the host implements the complete lifecycle.
Attach an MCP server when the ACP session opens. ADK-Rust starts it inside the selected project, exposes its tools only to that session, and cancels it when the session closes.
Pourquoi MCP apparaît dans la configuration de la session ACP
Par exemple, un éditeur peut attacher son serveur MCP de suivi des problèmes ou de recherche dans le référentiel lorsqu'il ouvre la session. L'agent de codage reçoit ces outils sans posséder ses informations d'identification ou sa configuration. ADK-Rust prend en charge le transport stdio requis par la version stable ACP v1, démarre chaque serveur avec une poignée de main limitée et le supprime avec la session. Les transports facultatifs HTTP et SSE sont acceptés par le client uniquement lorsque l'agent externe les annonce.
L'approbation appartient à l'hôte
Un agent de codage peut avoir besoin de modifier un fichier, d'exécuter une commande, d'installer une dépendance ou de supprimer la sortie générée. ACP renvoie cette opération proposée au client avec un menu de choix valides. ADK-Rust conserve les détails relatifs à la sécurité et refuse les demandes par défaut.
Pour un workflow local approuvé, une règle peut approuver des opérations connues. Pour un produit interactif, PermissionPolicy::async_custom peut attendre une boîte de dialogue sur le bureau, un écran d'approbation Web ou un service de stratégie d'organisation. ADK-Rust renvoie l'ID d'option opaque exact fourni par l'agent ; il n’invente jamais de valeur d’approbation.
La demande contient l'ID de session, l'ID d'appel d'outil, le titre, le type d'outil, l'entrée brute et chaque option de réponse prise en charge par l'agent.
Refuser par défaut, utiliser une règle synchrone ou attendre un dialogue humain ou un service de stratégie à distance via async_custom.
Les choix d'autorisation et de rejet correspondent à la signification de ACP, puis l'ID d'option opaque d'origine est renvoyé. Une pièce d’identité fabriquée devient une annulation.
L'agent de codage reçoit la décision dans la même session et peut continuer l'appel à l'outil, choisir un autre chemin ou terminer le tour.
let policy = PermissionPolicy::async_custom(|request| async move {
let choice = approval_ui.ask(ApprovalPrompt {
title: request.title,
kind: request.kind,
input: request.raw_input,
options: request.options,
}).await;
match choice {
Approval::Once => PermissionDecision::AllowOnce,
Approval::Always => PermissionDecision::AllowAlways,
Approval::Reject => PermissionDecision::Deny,
}
});ACP indique aux deux parties quel projet et quelles racines supplémentaires appartiennent à la session. Cela ne crée pas de limite de sécurité pour le système d'exploitation. Si le processus de codage doit être isolé du reste de la machine, exécutez-le via adk-sandbox, un conteneur ou une autre stratégie de processus.
Keep credentials in the process environment or the client's secret store. Protocol stdout must contain only ACP JSON-RPC messages.
Deuxième direction · ADK-Rust est l'agent ACP
L'éditeur démarre votre binaire Rust en tant que sous-processus ACP. Le SDK officiel possède le cadrage JSON-RPC, les identifiants de requête, le décodage typé et le stdio. Le gestionnaire de session mappe une session ACP à une session ADK-Rust, puis le Runner diffuse les événements de modèle et d'outil sous forme de notifications session/update en direct.
Cette direction est utile lorsque votre agent dispose d'instructions spécifiques au domaine, d'outils Rust, d'agents de workflow, de mémoire ou de services internes qui doivent être disponibles à partir d'une interface de codage. L'éditeur n'a pas besoin de comprendre ces éléments internes ; il voit les capacités et le cycle de vie que le binaire publie honnêtement.
use adk_acp::server::{
AcpServer, AcpServerConfigBuilder
};
let config = AcpServerConfigBuilder::new()
.agent(Arc::new(repository_agent))
.session_service(Arc::new(session_service))
.agent_name("repository-guide")
.agent_description("Explains and improves this workspace")
.max_sessions(16)
.build()?;
let server = AcpServer::run(config).await?;
server.wait().await?;{
"name": "repository-guide",
"command": "/absolute/path/to/repository-guide",
"args": [],
"env": {
"MODEL_API_KEY": "from-the-editor-secret-store"
}
}{
"jsonrpc": "2.0",
"id": 3,
"method": "session/prompt",
"params": {
"sessionId": "session-7f2a",
"prompt": [{
"type": "text",
"text": "Explain error handling in src/main.rs"
}]
}
}{"jsonrpc":"2.0","method":"session/update","params":{
"sessionId":"session-7f2a",
"update":{"sessionUpdate":"agent_message_chunk","content":{
"type":"text","text":"The entry point uses..."
}}
}}
{"jsonrpc":"2.0","id":3,"result":{
"stopReason":"end_turn"
}}Portée vérifiée
ADK-Rust utilise désormais la caisse officielle agent-client-protocol pour les deux rôles. Le tableau sépare la surface interopérable v1 des fonctionnalités qui doivent encore être implémentées, afin qu'un éditeur ou un produit ne découvre pas une fonctionnalité manquante une fois le travail d'intégration commencé.
ACP protocol v1 · official Rust SDK 1.2 · JSON-RPC over local stdio
ImplementedInitialize, new session, prompt, live updates, tool permissions, one-shot, persistent, streaming
ImplementedCloneable handle sends session/cancel while another task awaits the prompt
ImplementedInitialize, new, prompt, update, cancel, close, list, resume, delete
ImplementedText and resource links; unsupported media types are rejected and not advertised
Implemented scopeOpt-in host traits advertise only the file and terminal operations the application implements
Implemented APITyped session configuration, required stdio server support, per-session ADK toolsets, bounded startup and cleanup
Implemented · stdioThe runtime can await an exact-call decision; the server bridge is held back because the official SDK currently loses the outer prompt response in the nested-request test
SDK limitationHTTP or WebSocket ACP between machines
Protocol work is evolving; stdio onlyPorte d'interopérabilité
Un client SDK officiel se connecte à l'agent ADK-Rust SDK via un transport en mémoire et termine l'initialisation → nouveau → invite → mise à jour → fermer → liste → reprendre → fermer → supprimer. Les tests d'annulation couvrent à la fois la session/annulation ACP et l'annulation de la demande JSON-RPC, puis prouvent que la session peut accepter une autre invite après le nettoyage. Les tests d'autorisation couvrent les menus de rejet en premier, les identifiants opaques, les sélections fabriquées et une décision humaine attendue. Une porte en direct distincte démarre un véritable enfant stdio MCP et découvre son catalogue d'outils via le même McpToolset utilisé par les sessions ACP.
Choisissez la limite
Commencez par demander ce qui se trouve de l’autre côté. Un agent de codage a besoin d'une session de projet et d'un hôte interactif. Un agent commercial distant a besoin d’un contrat de tâches réseau. Un outil ou un service de données nécessite un contrat de capacité appelable.
Utilisez ACP entre une interface de codage et l'agent travaillant dans une session de projet.
Explore ACP A2AUtilisez A2A pour découvrir un agent distant, envoyer du travail, suivre l'état des tâches et recevoir des artefacts sur un réseau.
Explore A2A MCPUtilisez MCP pour fournir à un agent des outils, des invites et des ressources appelables sans transformer ce serveur en agent lui-même.
Explore MCPConstruisez avec le rôle dont vous avez besoin
Start with stdio, one absolute workspace, and DenyAll. Add a custom approval experience, persistent sessions, and stronger process isolation as the product's trust boundary becomes clear.