
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ément | GPT-6.2 sur PoYo |
|---|---|
| Identifiants de modèle | gpt-6.2-sol (par défaut), gpt-6.2-astra (escalade) |
| Endpoint pour l’agent | POST https://api.poyo.ai/v1/responses (SDK OpenAI, base_url="https://api.poyo.ai/v1") |
| Appel d’outils | Responses uniquement ; OpenAI : « l’appel d’outils nécessite Responses » |
| Contexte / entrée max / sortie max | 1,050,000 / 922,000 / 128,000 tokens |
| Streaming | "stream": true ; response.completed contient la sortie finale et usage |
| Raisonnement | reasoning.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 |
| Erreurs | 400 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ù
storevaut 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 estprevious_response_idavec 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_tokensplafonne le texte visible plus le raisonnement. Demandez un fichier par appelwrite_fileplutô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ègle | Valeur |
|---|---|
| Prix de lecture de cache | 0.05× l’entrée ($0.08 par 1M sur Sol, $0.32 sur Astra, sur PoYo) |
| Prix d’écriture de cache | 1.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 cache | 1,024 tokens d’entrée visibles |
| Point d’arrêt implicite | Fin du dernier message éligible |
| Champs d’usage | usage.input_tokens_details.cached_tokens (lectures), cache_write_tokens (écritures) |
Pour rendre les accès au cache probables :
- Placez le contenu stable en premier. Message developer, puis définitions d’outils, puis instantané du dépôt, puis la tâche.
- Utilisez un message
developer, pas desinstructionsde premier niveau. GPT-6.2 ajoute lesinstructionsaprèsinput: elles se retrouveraient hors du préfixe. - Ne modifiez jamais les éléments antérieurs. Ajoutez les sorties d’outils ; ne réécrivez pas l’historique.
- 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.