> ## Documentation Index
> Fetch the complete documentation index at: https://phaseo.app/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Exécuter un agent de revue de code avec des outils d’exécution

> Créez un flux de revue de code reprenable avec des outils d’exécution locaux, du JSON strict et des points de validation humaine.

Utilisez cette recette si un flux de travail doit :

* examiner le contexte lié au code avec des outils d’exécution locaux
* renvoyer une sortie structurée stricte plutôt que du texte libre
* suspendre les décisions à haut risque pour demander une approbation humaine
* enregistrer des points de reprise entre les tours du modèle et les appels d’outil

## 1. Définir un contrat de sortie restreint

```ts theme={null}
type CodeReviewPlan = {
  risk: "low" | "medium" | "high";
  summary: string;
  recommendedActions: string[];
  needsApproval: boolean;
};
```

Le premier flux de revue de code reste ainsi facile à examiner dans les journaux et à transmettre aux étapes de travail suivantes.

## 2. Définir de petits outils d’exécution

```ts theme={null}
import { defineTool } from "@phaseo/agent-sdk";

const lookupDiffSummary = defineTool({
  id: "lookup-diff-summary",
  description: "Return a short summary of the changed files in one pull request.",
  async execute(input: { pullRequestId: string }) {
    return {
      pullRequestId: input.pullRequestId,
      files: ["apps/api/src/pipeline/before/index.ts"],
      summary: "Changes touch request validation.",
    };
  },
});

const lookupFailingChecks = defineTool({
  id: "lookup-failing-checks",
  description: "Return the failing CI checks for one pull request.",
  async execute(input: { pullRequestId: string }) {
    return {
      pullRequestId: input.pullRequestId,
      failingChecks: ["web-typecheck"],
    };
  },
});
```

Gardez ces outils déterministes et idempotents pour que les données des étapes enregistrées restent utiles lorsqu’un worker reprend le travail plus tard.

## 3. Créer l’agent avec un point de revue humaine

```ts theme={null}
import { createAgent } from "@phaseo/agent-sdk";

const codingReviewAgent = createAgent<string, CodeReviewPlan>({
  id: "coding-review-agent",
  model: "phaseo/free",
  instructions:
    "Use the available tools to inspect the coding task, then return a strict JSON review plan.",
  tools: [lookupDiffSummary, lookupFailingChecks],
  parseOutput(text) {
    return JSON.parse(text) as CodeReviewPlan;
  },
  humanReview: ({ parsedOutput }) =>
    parsedOutput?.needsApproval
      ? {
          reason: "coding_review_approval_required",
          payload: parsedOutput,
        }
      : null,
});
```

## 4. Utiliser l’adaptateur Gateway pour imposer le JSON strict

```ts theme={null}
import {
  createGatewayAgentClient,
} from "@phaseo/agent-sdk";

const client = createGatewayAgentClient({
  clientOptions: {
    apiKey: process.env.PHASEO_API_KEY!,
  },
  responseFormat: {
    type: "json_schema",
    name: "code_review_plan",
    schema: {
      type: "object",
      properties: {
        risk: {
          type: "string",
          enum: ["low", "medium", "high"],
        },
        summary: { type: "string" },
        recommendedActions: {
          type: "array",
          items: { type: "string" },
          minItems: 1,
        },
        needsApproval: { type: "boolean" },
      },
      required: ["risk", "summary", "recommendedActions", "needsApproval"],
      additionalProperties: false,
    },
  },
  plugins: [{ id: "response-healing", mode: "strict" }],
});
```

## 5. Exécuter et reprendre le flux de travail

```ts theme={null}
const result = await codingReviewAgent.run({
  input: "Review pull request pr_482 and produce a remediation plan.",
  client,
  onEvent(event) {
    console.log(event.type, event.runId);
  },
});

if (result.run.status === "waiting_for_human") {
  const continued = await codingReviewAgent.continueRun({
    run: result,
    client,
    humanInput: "Approved. Finalize the plan.",
  });

  console.log(continued.output);
}
```

## 6. Points à vérifier

Après une exécution avec des outils et une autre suspendue dans l’attente d’une approbation, vérifiez les points suivants :

* les vues de détails de la requête affichent clairement la boucle d’outils d’exécution
* les exécutions suspendues passent à l’état `waiting_for_human`
* les enregistrements d’étape créent un point de reprise après l’exécution d’un outil
* les échecs de schéma et l’activité de réparation du plugin restent visibles dans les journaux

## Guides associés

* [SDK Agent pour TypeScript](../sdk-reference/typescript/agent-sdk.mdx)
* [Créer une boucle d’agent durable](./agent-sdk-durable-loop.mdx)
* [Valider les sorties structurées](../guides/structured-outputs.mdx)
* [Récupérer un JSON structuré mal formé](./response-healing-for-structured-json.mdx)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.