Le cadre de codage (`CodingAgent`)

CodingAgent est un cadre léger — fourni dans adk-agent derrière la fonctionnalité coding — qui raccorde les outils de développement, un outil de planification write_todos, et une invite système de codage minimale à un LlmAgent normal. C’est du configuré plutôt que LlmAgent, pas un nouveau type d’agent, donc cela maintient la construction par défaut de adk-agent légère (la fonctionnalité intègre adk-devtools).

En construire un

use adk_agent::coding::CodingAgent;
use adk_devtools::Workspace;

let coding = CodingAgent::builder()
    .model(model)                              // any adk-model provider (required)
    .workspace(Workspace::new("./my-repo"))    // sandboxed (required)
    .instruction("Follow the project's existing style; prefer small diffs.") // optional, appended
    .build()?;

let agent = coding.agent();   // Arc<dyn Agent> — hand to a Runner

Options du générateur:

Méthode	Effet
`.model(Arc<dyn Llm>)`	Le modèle (obligatoire).
`.workspace(Workspace)`	L’espace de travail auquel les outils sont confinés (obligatoire).
`.name("…")`	Nom de l’agent (par défaut `"coding-agent"`).
`.instruction("…")`	Instructions supplémentaires ajoutées à l’invite de codage de base.
`.tool(Arc<dyn Tool>)`	Enregistrer un outil supplémentaire (MCP, outil de fonction, …).
`.without_todos()`	Désactiver l’outil de planification `write_todos`.

Ce qui est câblé

L’ensemble d’outils de développement — read/write/edit/glob/grep/bash, limité à l’espace de travail.
write_todos — un outil de planification que le modèle utilise pour enregistrer et mettre à jour une courte liste de tâches. Relisez-la depuis le harness :
```
for todo in coding.todos() {
    println!("[{}] {}", todo.status, todo.content);  // pending | in_progress | completed
}
```
Une invite minimale — instructions de base de moins de 1 k tokens (« explorer avant de modifier », « lire avant d’éditer », « vérifier en exécutant les tests », « suivre un plan »), volontairement réduites afin que les capacités viennent des outils et des compétences plutôt que d’une énorme invite.

La boucle

Vous exécutez un CodingAgent comme n’importe quel agent — via un Runner. Dans un tour, le LlmAgent sous-jacent exécute déjà une boucle plan → agir → observer : il appelle des outils, voit leurs résultats et continue jusqu’à ce que ce soit terminé. Un tour typique :

write_todos(...)            # plan
glob / grep / read_file     # explore
edit_file / write_file      # change
bash("…test…")              # verify
write_todos(... completed)  # update plan
→ final summary

Pour un travail sur plusieurs tours, réutilisez le même Runner + session entre les appels et l’agent s’appuie sur son travail précédent (il relit et modifie les fichiers qu’il a écrits). Voir l’exemple coding_agent (mode multiturn).

Mémoire et compétences

Comme il s’agit d’un LlmAgent en dessous, tout le reste dans ADK se compose :

Attachez un MemoryService (par ex. le graphe de connaissances bi-temporel) sur le Runner pour la mémoire de projet entre sessions.
Ajoutez des compétences paresseuses via adk-skill pour étendre les capacités sans gonfler l’invite.
Les hooks/garde-fous (adk-plugin, adk-guardrail) filtrent les appels d’outils de manière déterministe.

L’exécution

Le harness produit un Arc<dyn Agent> ; pilotez-le avec adk-runner (voir le guide de démarrage rapide) ou utilisez le CLI, qui encapsule tout cela.

Suivant : Le CLI →