TypeScript
```typescript
const result = await session.rpc.fleet.start({
prompt: "Refactor each SDK package independently, then summarize the changes.",
});
if (result.started) {
console.log("Fleet mode started");
}
```
Python
```python
from copilot.rpc import FleetStartRequest
result = await session.rpc.fleet.start(
FleetStartRequest(
prompt="Review each service independently, then summarize the risks."
)
)
if result.started:
print("Fleet mode started")
```
Go
```golang
prompt := "Update each package independently, then report validation results."
result, err := session.RPC.Fleet.Start(ctx, &rpc.FleetStartRequest{
Prompt: &prompt,
})
if err != nil {
return err
}
if result.Started {
fmt.Println("Fleet mode started")
}
```
.NET
```csharp
var result = await session.Rpc.Fleet.StartAsync(
"Audit each project independently, then summarize the findings.");
if (result.Started)
{
Console.WriteLine("Fleet mode started");
}
```
Rust
```rust
use github_copilot_sdk::rpc::FleetStartRequest;
let result = session
.rpc()
.fleet()
.start(FleetStartRequest {
prompt: Some("Research each crate independently, then summarize the plan.".into()),
})
.await?;
if result.started {
println!("Fleet mode started");
}
```
Les liaisons typées natives pour le mode flotte ont été vérifiées dans Node.js/TypeScript, Python, Go, .NET et Rust. Aucune liaison pour Java n’a été trouvée dans `java/src/main/java` sur cette branche ; les exemples Java ne sont donc pas inclus tant que cette interface n’est pas disponible.
### À partir du mode plan
Les interfaces utilisateur du mode Plan peuvent lancer le déploiement de la flotte en renvoyant l’action de sortie `autopilot_fleet`. Les types d’événements de session générés le décrivent comme suit :
```typescript
type ExitPlanModeAction =
| "exit_only"
| "interactive"
| "autopilot"
/** Exit plan mode and continue with parallel autonomous workers. */
| "autopilot_fleet";
```
Utilisez cette option lorsqu’un utilisateur approuve un plan qui contient déjà des éléments de travail indépendants. Utiliser `autopilot` pour un agent autonome unique et `interactive` lorsque l’utilisateur doit rester dans le processus.
## Comment les sous-agents se coordonnent
Le mode flotte s’appuie sur un état de coordination explicite au lieu de la mémoire partagée implicite. L’agent parent décompose le travail en éléments todo, chaque sous-agent possède un todo et l’orchestrateur répartit les workers dont les dépendances sont déjà terminées.
Le schéma canonique est :
```sql
CREATE TABLE todos (
id TEXT PRIMARY KEY,
title TEXT NOT NULL,
description TEXT,
status TEXT DEFAULT 'pending'
);
CREATE TABLE todo_deps (
todo_id TEXT,
depends_on TEXT,
PRIMARY KEY (todo_id, depends_on)
);
```
Chaque élément todo passe par une petite machine à états :
```text
pending -> in_progress -> done
\-> blocked
```
Un sous-agent doit :
1. Réclamez exactement un todo prêt en définissant `status = 'in_progress'`.
2. Travaillez uniquement sur l'étendue de ce todo.
3. Stocker le résultat dans la conversation ou dans le résultat de la tâche correspondante.
4. Définissez `status = 'done'` une fois terminé.
5. Définissez `status = 'blocked'` quand il ne peut pas continuer et incluez la raison.
L’orchestrateur peut identifier les tâches pour lesquelles les dépendances sont satisfaites à l’aide d’une requête telle que :
```sql
SELECT t.*
FROM todos t
WHERE t.status = 'pending'
AND NOT EXISTS (
SELECT 1
FROM todo_deps td
JOIN todos dep ON td.depends_on = dep.id
WHERE td.todo_id = t.id
AND dep.status != 'done'
);
```
Ce modèle attribue à chaque processus un responsable clairement identifié et permet à la session parente de déterminer ce qui est prêt, en cours d’exécution, terminé ou bloqué.
## Hooks de cycle de vie
Le mode flotte appelle des sous-agents via le mécanisme de tâche du runtime. Le runtime émet l’activité des hooks pour les appels d’outils de sous-agent : le journal des modifications du runtime 1.0.52 indique que `preToolUse`, `postToolUse`, `subagentStart` et `subagentStop` se déclenchent correctement pour les appels d’outils de sous-agent.
Aucune fonction de rappel de hook de SDK dédiée pour `subagentStart` ou `subagentStop` n’a été trouvée dans l’interface publique du SDK sur cette branche. Les consommateurs du Kit de développement logiciel (SDK) peuvent observer l’activité de sous-agent via le flux d’événements de session générique, qui inclut des événements tels que `subagent.started`, , `subagent.completed`, `subagent.failed``subagent.selected`, et `subagent.deselected`.