how-tos

GPT-6.2 API pour les agents de code : outils de fonction, streaming, long contexte et cache

Poyo.ai Team
10 min read
Share:

La GPT-6.2 API au cœur d’une boucle d’agent de code

La GPT-6.2 API est le choix actuel d’OpenAI pour le travail d’agent : le changelog de l’API recommande gpt-6.2-sol « pour le code et les workflows d’agents du quotidien » et gpt-6.2-astra pour les « tâches exigeantes de raisonnement et de code ». Ce guide branche l’un ou l’autre modèle dans un agent de code via l’endpoint Responses de PoYo, avec des outils de fonction, une boucle bornée, la progression en streaming, un large contexte de dépôt et une mise en cache qui garde les longues sessions abordables. Commencez sur la page du modèle GPT-6.2 Sol et gardez GPT-6.2 Astra pour l’escalade.

Si vous n’avez pas encore envoyé de première requête, commencez par le guide de la GPT-6.2 API.

Ce que l’API apporte à un agent de code

ÉlémentGPT-6.2 sur PoYo
Identifiants de modèlegpt-6.2-sol (par défaut), gpt-6.2-astra (escalade)
Endpoint pour l’agentPOST https://api.poyo.ai/v1/responses (SDK OpenAI, base_url="https://api.poyo.ai/v1")
Appel d’outilsResponses uniquement ; OpenAI : « l’appel d’outils nécessite Responses »
Contexte / entrée max / sortie max1,050,000 / 922,000 / 128,000 tokens
Streaming"stream": true ; response.completed contient la sortie finale et usage
Raisonnementreasoning.effort ; none refusé, commencer à medium
Prix par 1M (Sol)$1.60 en entrée / $8 en sortie / $0.08 en lecture de cache / $2 en écriture de cache
Prix par 1M (Astra)$6.40 en entrée / $32 en sortie / $0.32 en lecture de cache / $8 en écriture de cache
Erreurs400 champs invalides, 401 clé invalide, 402 crédits insuffisants, 404 modèle inconnu ; réessayez 429 / 5xx avec backoff

La référence Responses de PoYo documente tools, tool_choice, parallel_tool_calls, reasoning, include, store, previous_response_id et truncation, et précise que la prise en charge des outils dépend du modèle. Les pages de modèle d’OpenAI listent l’appel de fonctions et un ensemble d’outils hébergés pour GPT-6.2. La documentation de PoYo ne montre que web_search_preview comme exemple d’outil hébergé : cet agent utilise donc vos propres outils de fonction, que vous contrôlez de bout en bout.

Définir les outils de fonction

Gardez un jeu d’outils restreint et sûr. Le modèle ne peut demander que les actions que vous implémentez :

import json, os, subprocess
from pathlib import Path
from openai import OpenAI

client = OpenAI(base_url="https://api.poyo.ai/v1", api_key=os.environ["POYO_API_KEY"])
REPO = Path("/srv/checkout").resolve()

TOOLS = [
    {"type": "function", "name": "read_file",
     "description": "Read a UTF-8 text file from the repository.",
     "parameters": {"type": "object", "properties": {"path": {"type": "string"}},
                    "required": ["path"], "additionalProperties": False}},
    {"type": "function", "name": "write_file",
     "description": "Replace a file in the repository with new content.",
     "parameters": {"type": "object",
                    "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
                    "required": ["path", "content"], "additionalProperties": False}},
    {"type": "function", "name": "run_tests",
     "description": "Run the test suite and return the last 200 lines of output.",
     "parameters": {"type": "object", "properties": {}, "additionalProperties": False}},
]

def safe_path(p: str) -> Path:
    full = (REPO / p).resolve()
    if not full.is_relative_to(REPO):
        raise ValueError("path escapes the repository")
    return full

def call_tool(name: str, args: dict) -> str:
    try:
        if name == "read_file":
            return safe_path(args["path"]).read_text(encoding="utf-8")[:200_000]
        if name == "write_file":
            safe_path(args["path"]).write_text(args["content"], encoding="utf-8")
            return "ok"
        if name == "run_tests":
            r = subprocess.run(["pytest", "-q"], cwd=REPO, capture_output=True, text=True, timeout=600)
            return "\n".join((r.stdout + r.stderr).splitlines()[-200:])
        return f"unknown tool {name}"
    except Exception as e:  # return errors to the model instead of crashing the loop
        return f"error: {e}"

Exécutez l’agent sur un checkout ou un conteneur jetable, jamais sur votre copie de travail.

Une boucle d’agent bornée

La boucle envoie la conversation, exécute chaque élément function_call, ajoute un function_call_output avec le même call_id, et recommence jusqu’à ce que le modèle réponde sans appel d’outil. Elle s’arrête à une limite de tours et à un budget en dollars.

PRICES = {"gpt-6.2-sol": (1.60, 8.00, 0.08, 2.00), "gpt-6.2-astra": (6.40, 32.00, 0.32, 8.00)}

def cost(model, u) -> float:
    p_in, p_out, p_read, p_write = PRICES[model]
    d = getattr(u, "input_tokens_details", None)
    read = getattr(d, "cached_tokens", 0) or 0
    write = getattr(d, "cache_write_tokens", 0) or 0
    return ((u.input_tokens - read - write) * p_in + read * p_read
            + write * p_write + u.output_tokens * p_out) / 1e6

DEVELOPER = ("You are a coding agent working in a Python repository. "
             "Read files before editing. Run the tests after every change. "
             "When the tests pass, reply with a short summary and no tool call.")

def run_agent(task: str, model="gpt-6.2-sol", max_turns=30, budget_usd=3.00):
    items = [{"role": "developer", "content": DEVELOPER},
             {"role": "user", "content": task}]
    spent = 0.0
    for turn in range(max_turns):
        resp = client.responses.create(
            model=model, input=items, tools=TOOLS,
            reasoning={"effort": "medium"}, max_output_tokens=16000,
            store=False, include=["reasoning.encrypted_content"],
        )
        spent += cost(model, resp.usage)
        items += [o.model_dump(exclude_none=True) for o in resp.output]
        calls = [o for o in resp.output if o.type == "function_call"]
        if not calls:
            return resp.output_text, spent, turn + 1
        for c in calls:
            items.append({"type": "function_call_output", "call_id": c.call_id,
                          "output": call_tool(c.name, json.loads(c.arguments))})
        if spent >= budget_usd:
            break
    raise RuntimeError(f"stopped after {turn + 1} turns, ${spent:.3f} spent")

Pourquoi la boucle est construite ainsi :

  • Les éléments de sortie sont renvoyés dans l’ordre, éléments de raisonnement compris. Pour les requêtes où store vaut false, comme en Zero Data Retention, le guide GPT-6.2 d’OpenAI demande de « renvoyer les éléments de sortie précédents dans l’ordre, y compris les éléments de raisonnement chiffrés ». include=["reasoning.encrypted_content"] les demande. L’alternative est previous_response_id avec des réponses stockées, que PoYo documente aussi.
  • L’historique est en ajout seul. OpenAI avertit que des modifications en cours de conversation peuvent amener la Responses API à abandonner des éléments de raisonnement, ce qui « peut réduire la qualité des réponses et augmenter la consommation de tokens », et une modification casse aussi le préfixe en cache.
  • Le budget est vérifié à chaque tour, avec la même table de prix que la facture.

Nous n’avons pas exécuté cette boucle exacte de bout en bout sur PoYo pour cet article. Lancez-la d’abord sur une petite tâche et vérifiez que les appels d’outils et usage ont l’allure attendue.

Diffuser la progression à l’utilisateur en streaming

Les longs tours d’agent paraissent lents sans retour. Diffusez chaque tour en streaming, affichez les deltas de texte et récupérez la sortie finale dans response.completed. Voici les types d’événements que PoYo documente :

def stream_turn(model, items):
    final = None
    with client.responses.create(model=model, input=items, tools=TOOLS,
                                 reasoning={"effort": "medium"}, max_output_tokens=16000,
                                 store=False, include=["reasoning.encrypted_content"],
                                 stream=True) as stream:
        for event in stream:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "response.completed":
                final = event.response
            elif event.type == "response.failed":
                raise RuntimeError(event.response)
    return final  # same object as the non-streaming call: .output, .usage

Utilisez stream_turn dans la boucle à la place de responses.create. Les appels d’outils se lisent dans final.output exactement comme avant.

Long contexte : 922K en entrée, 128K en sortie

GPT-6.2 accepte jusqu’à 922,000 tokens en entrée par requête. Un agent peut charger d’emblée une grande partie d’un dépôt au lieu de lire les fichiers un par un. Trois limites encadrent ce choix :

  • Chaque tour renvoie l’historique. Un instantané de 200K tokens sur 20 tours représente au moins 4M tokens en entrée. Au tarif de $1.60 de Sol, cela fait $6.40 sans cache. Avec une écriture en cache de l’instantané ($0.40) et 19 lectures de cache à $0.08 ($0.30), cela revient à environ $0.70.
  • Le niveau long contexte d’OpenAI commence au-delà de 272K tokens en entrée. La page de tarification d’OpenAI double les tarifs d’entrée et de cache et facture la sortie 1.5× pour l’ensemble de la requête au-delà de ce seuil. Gardez les requêtes d’agent sous 272K, sauf si la tâche exige davantage, et vérifiez sur la page du modèle le tarif PoYo applicable.
  • Le raisonnement partage le budget de sortie. max_output_tokens plafonne le texte visible plus le raisonnement. Demandez un fichier par appel write_file plutôt qu’une réécriture de tout le dépôt.

Réduisez la sortie des outils avant de l’ajouter : renvoyez les 200 dernières lignes d’une exécution de tests, pas 20,000. La croissance par tour, et la facture, restent ainsi linéaires et faibles.

Mise en cache du prompt pour les sessions d’agent

Le guide de mise en cache d’OpenAI fixe ces règles pour GPT-6.2 :

RègleValeur
Prix de lecture de cache0.05× l’entrée ($0.08 par 1M sur Sol, $0.32 sur Astra, sur PoYo)
Prix d’écriture de cache1.25× l’entrée pour la rétention par défaut de 30 minutes ($2 / $8 par 1M sur PoYo)
Préfixe minimal pouvant être mis en cache1,024 tokens d’entrée visibles
Point d’arrêt impliciteFin du dernier message éligible
Champs d’usageusage.input_tokens_details.cached_tokens (lectures), cache_write_tokens (écritures)

Pour rendre les accès au cache probables :

  1. Placez le contenu stable en premier. Message developer, puis définitions d’outils, puis instantané du dépôt, puis la tâche.
  2. Utilisez un message developer, pas des instructions de premier niveau. GPT-6.2 ajoute les instructions après input : elles se retrouveraient hors du préfixe.
  3. Ne modifiez jamais les éléments antérieurs. Ajoutez les sorties d’outils ; ne réécrivez pas l’historique.
  4. Gardez des réglages stables au sein d’une session. Le guide d’OpenAI demande de garder le préfixe inchangé lorsque vous modifiez des réglages entre deux réponses.

OpenAI documente aussi prompt_cache_options (points d’arrêt explicites et rétention de 12 heures). Le schéma Responses de PoYo ne liste pas ce champ et est déclaré fermé aux champs supplémentaires (additionalProperties: false) : laissez-le donc de côté et comptez sur la mise en cache implicite. Dans le meilleur cas, une session de 25 tours sur Sol passe de $3.82 sans cache à environ $0.74 ; le calcul est dans Prix de la GPT-6.2 API.

Quand confier l’exécution à Astra

Démarrez chaque exécution sur gpt-6.2-sol. Si elle s’arrête à la limite de tours avec des tests en échec, relancez la tâche sur gpt-6.2-astra avec une nouvelle liste d’éléments. Ne changez pas de modèle au sein de la même conversation, car OpenAI indique que les changements de modèle peuvent abandonner des éléments de raisonnement. Le calcul du routage et un routeur sont dans GPT-6.2 Sol API vs GPT-6.2 Astra API. Pour voir la même boucle chez un autre fournisseur, comparez avec Gemini 4 Carbon API pour les agents de code.

Questions fréquentes

La GPT-6.2 API prend-elle en charge l’appel de fonctions ?

Oui, sur /v1/responses. Définissez les outils avec type: "function", lisez les éléments function_call dans output et renvoyez les résultats sous forme d’éléments function_call_output avec le même call_id.

Puis-je utiliser les outils de la GPT-6.2 API avec Chat Completions ?

Non. OpenAI indique que GPT-6.2 prend en charge Chat Completions, mais que l’appel d’outils nécessite Responses.

Comment diffuser en streaming un tour d’agent de la GPT-6.2 API ?

Définissez stream: true sur Responses, affichez les événements response.output_text.delta, et lisez les appels d’outils et usage dans l’événement response.completed.

Comment réduire les coûts de la GPT-6.2 API dans les longues sessions d’agent ?

Gardez un préfixe stable (message developer, outils, instantané) au début, ajoutez au lieu de modifier, réduisez la sortie des outils, et restez sous 272K tokens en entrée par requête quand c’est possible.

Quel modèle GPT-6.2 doit faire tourner mon agent de code ?

Commencez par gpt-6.2-sol, qui coûte le quart d’Astra par token, et relancez une exécution échouée sur gpt-6.2-astra.

Share: