how-tos

GPT-6.2 API til kodeagenter: funktionsværktøjer, streaming, lang kontekst og caching

Poyo.ai Team
8 min read
Share:

GPT-6.2 API driver en løkke i en kodeagent

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

PunktGPT-6.2 på PoYo
Model-ID'ergpt-6.2-sol (standard), gpt-6.2-astra (eskalering)
Agent-endpointPOST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1")
VærktøjskaldKun Responses; OpenAI: "værktøjskald kræver Responses"
Kontekst / maks. input / maks. output1,050,000 / 922,000 / 128,000 tokens
Streaming"stream": true; response.completed indeholder det endelige output og usage
Ræsonnementreasoning.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
Fejl400 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 store er 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 er previous_response_id med 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_tokens begræ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:

RegelVærdi
Pris for cache-læsning0.05× input ($0.08 pr. 1M på Sol, $0.32 på Astra, på PoYo)
Pris for cache-skrivning1.25× input ved standardopbevaring på 30 minutter ($2 / $8 pr. 1M på PoYo)
Mindste præfiks, der kan caches1,024 synlige input-tokens
Implicit breakpointSlutningen af den seneste kvalificerede besked
Forbrugsfelterusage.input_tokens_details.cached_tokens (læsninger), cache_write_tokens (skrivninger)

Sådan gør du cache-hits sandsynlige:

  1. Læg stabilt indhold først. Developer-beskeden, så værktøjsdefinitionerne, så repository-snapshottet og til sidst opgaven.
  2. Brug en developer-besked, ikke instructions på topniveau. GPT-6.2 tilføjer instructions efter input, så de ville ligge uden for præfikset.
  3. Redigér aldrig tidligere elementer. Tilføj værktøjsoutput; omskriv ikke historikken.
  4. 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.

Share: