
GPT-6.2 API er OpenAI's aktuelle valg til agentarbejde: API-changelog'en anbefaler gpt-6.2-sol "til daglig kodning og agent-workflows" og gpt-6.2-astra til "krævende ræsonnements- og kodeopgaver." Denne guide kobler en af modellerne til en kodeagent via PoYo's Responses-endpoint, med funktionsværktøjer, en afgrænset løkke, streamet fremdrift, en stor repository-kontekst og caching, der holder lange sessioner til at betale. Start på GPT-6.2 Sol-modelsiden, og gem GPT-6.2 Astra til eskalering.
Hvis du ikke har sendt en første anmodning endnu, så start med GPT-6.2 API-guiden.
Hvad API'et giver en kodeagent
| Punkt | GPT-6.2 på PoYo |
|---|---|
| Model-ID'er | gpt-6.2-sol (standard), gpt-6.2-astra (eskalering) |
| Agent-endpoint | POST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1") |
| Værktøjskald | Kun Responses; OpenAI: "værktøjskald kræver Responses" |
| Kontekst / maks. input / maks. output | 1,050,000 / 922,000 / 128,000 tokens |
| Streaming | "stream": true; response.completed indeholder det endelige output og usage |
| Ræsonnement | reasoning.effort; none afvises, start med medium |
| Pris pr. 1M (Sol) | $1.60 input / $8 output / $0.08 cache-læsning / $2 cache-skrivning |
| Pris pr. 1M (Astra) | $6.40 input / $32 output / $0.32 cache-læsning / $8 cache-skrivning |
| Fejl | 400 ugyldige felter, 401 forkert nøgle, 402 utilstrækkelige kreditter, 404 ukendt model; prøv 429 / 5xx igen med backoff |
PoYo's Responses-reference dokumenterer tools, tool_choice, parallel_tool_calls, reasoning, include, store, previous_response_id og truncation og siger, at understøttelse af værktøjer afhænger af modellen. OpenAI's modelsider angiver function calling og et sæt hostede værktøjer for GPT-6.2. PoYo's dokumentation viser kun web_search_preview som eksempel på et hostet værktøj, så denne agent bruger dine egne funktionsværktøjer, som du styrer fra ende til anden.
Definér funktionsværktøjer
Hold værktøjssættet lille og sikkert. Modellen kan kun anmode om handlinger, som du implementerer:
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}"
Kør agenten mod en checkout eller container, der kan smides væk, aldrig mod dit arbejdstræ.
En afgrænset agentløkke
Løkken sender samtalen, udfører hvert function_call-element, tilføjer et function_call_output med samme call_id og gentager, indtil modellen svarer uden et værktøjskald. Den stopper ved en rundegrænse og et budget i dollar.
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")
Derfor er løkken bygget sådan:
- Output-elementer sendes tilbage i rækkefølge, inklusive ræsonnementselementer. For anmodninger, hvor
storeer false, som under Zero Data Retention, siger OpenAI's GPT-6.2-guide, at man skal "sende de tidligere output-elementer tilbage i rækkefølge, inklusive krypterede ræsonnementselementer."include=["reasoning.encrypted_content"]beder om dem. Alternativet erprevious_response_idmed gemte svar, som PoYo også dokumenterer. - Historikken udvides kun. OpenAI advarer om, at redigeringer midt i en samtale kan få Responses API til at droppe ræsonnementselementer, hvilket "kan forringe svarkvaliteten og øge tokenforbruget", og en redigering bryder også det cachede præfiks.
- Budgettet tjekkes hver runde med den samme pristabel som regningen.
Vi har ikke kørt præcis denne løkke fra ende til anden på PoYo til dette indlæg. Kør den på en lille opgave først, og bekræft, at værktøjskald og usage ser ud som forventet.
Streaming af fremdrift til brugeren
Lange agentrunder føles langsomme uden feedback. Stream hver runde, vis tekst-deltaer, og tag det endelige output fra response.completed. Det er de hændelsestyper, PoYo dokumenterer:
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
Sæt stream_turn ind i løkken i stedet for responses.create. Værktøjskald læses fra final.output præcis som før.
Lang kontekst: 922K ind, 128K ud
GPT-6.2 accepterer op til 922,000 input-tokens pr. anmodning. En agent kan indlæse en stor del af et repository fra starten i stedet for at læse filerne én ad gangen. Tre grænser former det valg:
- Hver runde sender historikken igen. Et snapshot på 200K tokens over 20 runder er mindst 4M input-tokens. Med Sols $1.60 er det $6.40 uden cache. Med én cache-skrivning af snapshottet ($0.40) og 19 cache-læsninger til $0.08 ($0.30) er det omkring $0.70.
- OpenAI's lang-kontekst-niveau starter over 272K input-tokens. OpenAI's prisside fordobler input- og cachetaksterne og tager 1.5× for output for hele anmodningen over den grænse. Hold agentanmodninger under 272K, medmindre opgaven kræver mere, og tjek modelsiden for den PoYo-takst, der gælder.
- Ræsonnement deler outputbudgettet.
max_output_tokensbegrænser synlig tekst plus ræsonnement. Bed om én fil pr.write_file-kald frem for at omskrive hele repository'et.
Beskær værktøjsoutput, før du tilføjer det: returnér de sidste 200 linjer af en testkørsel, ikke 20,000. Det holder væksten pr. runde, og regningen, lineær og lille.
Prompt caching i agentsessioner
OpenAI's caching-guide fastsætter disse regler for GPT-6.2:
| Regel | Værdi |
|---|---|
| Pris for cache-læsning | 0.05× input ($0.08 pr. 1M på Sol, $0.32 på Astra, på PoYo) |
| Pris for cache-skrivning | 1.25× input ved standardopbevaring på 30 minutter ($2 / $8 pr. 1M på PoYo) |
| Mindste præfiks, der kan caches | 1,024 synlige input-tokens |
| Implicit breakpoint | Slutningen af den seneste kvalificerede besked |
| Forbrugsfelter | usage.input_tokens_details.cached_tokens (læsninger), cache_write_tokens (skrivninger) |
Sådan gør du cache-hits sandsynlige:
- Læg stabilt indhold først. Developer-beskeden, så værktøjsdefinitionerne, så repository-snapshottet og til sidst opgaven.
- Brug en
developer-besked, ikkeinstructionspå topniveau. GPT-6.2 tilføjerinstructionsefterinput, så de ville ligge uden for præfikset. - Redigér aldrig tidligere elementer. Tilføj værktøjsoutput; omskriv ikke historikken.
- Hold indstillingerne stabile inden for en session. OpenAI's guide siger, at præfikset skal holdes uændret, når du ændrer indstillinger mellem svar.
OpenAI dokumenterer også prompt_cache_options (eksplicitte breakpoints og 12 timers opbevaring). PoYo's Responses-skema angiver ikke det felt og er erklæret lukket for ekstra felter (additionalProperties: false), så udelad det, og stol på implicit caching. En session på 25 runder på Sol i bedste tilfælde falder fra $3.82 uden cache til omkring $0.74; udregningen står i GPT-6.2 API-priser.
Hvornår kørslen skal overdrages til Astra
Start hver kørsel på gpt-6.2-sol. Hvis den stopper ved rundegrænsen med fejlende tests, så start opgaven forfra på gpt-6.2-astra med en ny elementliste. Skift ikke model inden for samme samtale, fordi OpenAI siger, at modelskift kan droppe ræsonnementselementer. Routing-regnestykket og en router finder du i GPT-6.2 Sol API vs GPT-6.2 Astra API. Vil du se en anden leverandørs bud på samme løkke, så sammenlign med Gemini 4 Carbon API til kodeagenter.
Ofte stillede spørgsmål
Understøtter GPT-6.2 API function calling?
Ja, på /v1/responses. Definér værktøjer med type: "function", læs function_call-elementer fra output, og send resultaterne tilbage som function_call_output-elementer med samme call_id.
Kan jeg bruge værktøjer i GPT-6.2 API med Chat Completions?
Nej. OpenAI siger, at GPT-6.2 understøtter Chat Completions, men at værktøjskald kræver Responses.
Hvordan streamer jeg en agentrunde i GPT-6.2 API?
Sæt stream: true på Responses, udskriv response.output_text.delta-hændelser, og læs værktøjskald og usage fra hændelsen response.completed.
Hvordan sænker jeg omkostningerne ved GPT-6.2 API i lange agentsessioner?
Hold et stabilt præfiks (developer-besked, værktøjer, snapshot) i starten, tilføj i stedet for at redigere, beskær værktøjsoutput, og hold dig under 272K input-tokens pr. anmodning, når du kan.
Hvilken GPT-6.2-model skal køre min kodeagent?
Start med gpt-6.2-sol, der koster en fjerdedel af Astra pr. token, og start en mislykket kørsel forfra på gpt-6.2-astra.