how-tos

GPT-6.2 API voor coding agents: function tools, streaming, lange context en caching

Poyo.ai Team
9 min read
Share:

GPT-6.2 API als motor van een coding-agentlus

De GPT-6.2 API is de huidige keuze van OpenAI voor agentwerk: de API-changelog raadt gpt-6.2-sol aan "voor dagelijkse coding- en agentworkflows" en gpt-6.2-astra voor "veeleisende reasoning- en codingtaken." Deze gids koppelt een van beide modellen via het Responses-endpoint van PoYo aan een coding agent, met function tools, een begrensde lus, gestreamde voortgang, een grote repositorycontext en caching die lange sessies betaalbaar houdt. Begin op de GPT-6.2 Sol-modelpagina en houd GPT-6.2 Astra achter de hand voor escalatie.

Heb je nog geen eerste verzoek verstuurd? Begin dan met de GPT-6.2 API-gids.

Wat de API een coding agent biedt

OnderdeelGPT-6.2 op PoYo
Model-ID'sgpt-6.2-sol (standaard), gpt-6.2-astra (escalatie)
Agent-endpointPOST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1")
Tool callingAlleen Responses; OpenAI: "tool calling vereist Responses"
Context / max. input / max. output1,050,000 / 922,000 / 128,000 tokens
Streaming"stream": true; response.completed bevat de definitieve output en usage
Reasoningreasoning.effort; none geweigerd, begin met medium
Prijs per 1M (Sol)$1.60 input / $8 output / $0.08 cache read / $2 cache write
Prijs per 1M (Astra)$6.40 input / $32 output / $0.32 cache read / $8 cache write
Fouten400 ongeldige velden, 401 foute sleutel, 402 onvoldoende credits, 404 onbekend model; probeer 429 / 5xx opnieuw met backoff

De Responses-referentie van PoYo documenteert tools, tool_choice, parallel_tool_calls, reasoning, include, store, previous_response_id en truncation, en zegt dat toolondersteuning per model verschilt. De modelpagina's van OpenAI vermelden function calling en een set gehoste tools voor GPT-6.2. De documentatie van PoYo toont alleen web_search_preview als voorbeeld van een gehoste tool, dus deze agent gebruikt je eigen function tools, die je van begin tot eind zelf in de hand hebt.

Function tools definiëren

Houd de set tools klein en veilig. Het model kan alleen acties aanvragen die jij implementeert:

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}"

Laat de agent draaien op een wegwerp-checkout of een container, nooit op je eigen werkmap.

Een begrensde agentlus

De lus stuurt het gesprek, voert elk function_call-item uit, voegt een function_call_output met dezelfde call_id toe en herhaalt dat tot het model antwoordt zonder tool call. Hij stopt bij een beurtlimiet en een budget in 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")

Waarom de lus zo is opgebouwd:

  • Output-items gaan op volgorde terug, inclusief reasoning-items. Voor verzoeken waarbij store false is, zoals onder Zero Data Retention, zegt de GPT-6.2-gids van OpenAI: "geef de eerdere output-items op volgorde terug, inclusief versleutelde reasoning-items." include=["reasoning.encrypted_content"] vraagt ze op. Het alternatief is previous_response_id met opgeslagen responses, wat PoYo ook documenteert.
  • De geschiedenis wordt alleen aangevuld. OpenAI waarschuwt dat wijzigingen midden in een gesprek ertoe kunnen leiden dat de Responses API reasoning-items laat vallen, wat "de kwaliteit van antwoorden kan verlagen en het tokengebruik kan verhogen," en een wijziging breekt ook de gecachete prefix.
  • Het budget wordt elke beurt gecontroleerd, met dezelfde prijstabel als de factuur.

We hebben precies deze lus voor dit artikel niet van begin tot eind op PoYo gedraaid. Draai hem eerst op een kleine taak en controleer of de tool calls en usage eruitzien zoals verwacht.

Voortgang naar de gebruiker streamen

Lange agentbeurten voelen traag zonder feedback. Stream elke beurt, toon de tekstdelta's en haal de definitieve output uit response.completed. Dit zijn de eventtypes die PoYo documenteert:

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

Zet stream_turn in de lus in plaats van responses.create. Tool calls worden precies zoals eerder uit final.output gelezen.

Lange context: 922K in, 128K uit

GPT-6.2 accepteert tot 922,000 input-tokens per verzoek. Een agent kan een groot deel van een repository vooraf laden in plaats van bestanden één voor één te lezen. Drie grenzen bepalen die keuze:

  • Elke beurt stuurt de geschiedenis opnieuw. Een snapshot van 200K tokens over 20 beurten is minstens 4M input-tokens. Tegen de $1.60 van Sol is dat $6.40 zonder cache. Met één cache write van de snapshot ($0.40) en 19 cache reads tegen $0.08 ($0.30) is het ongeveer $0.70.
  • De long-context-tier van OpenAI begint boven 272K input-tokens. De prijspagina van OpenAI verdubbelt boven die grens de input- en cachetarieven en rekent 1.5× output voor het hele verzoek. Houd agentverzoeken onder 272K tenzij de taak meer nodig heeft, en controleer op de modelpagina welk PoYo-tarief geldt.
  • Reasoning deelt het outputbudget. max_output_tokens begrenst zichtbare tekst plus reasoning. Vraag om één bestand per write_file-aanroep in plaats van het hele repository te herschrijven.

Kort tooloutput in voordat je hem toevoegt: geef de laatste 200 regels van een testrun terug, niet 20,000. Zo blijft de groei per beurt, en daarmee de rekening, lineair en klein.

Prompt caching voor agentsessies

De caching-gids van OpenAI legt voor GPT-6.2 deze regels vast:

RegelWaarde
Cache-read-prijs0.05× input ($0.08 per 1M op Sol, $0.32 op Astra, op PoYo)
Cache-write-prijs1.25× input voor de standaardbewaartijd van 30 minuten ($2 / $8 per 1M op PoYo)
Minimale cachebare prefix1,024 zichtbare input-tokens
Impliciet breakpointEinde van het laatste geschikte bericht
Usage-veldenusage.input_tokens_details.cached_tokens (reads), cache_write_tokens (writes)

Zo maak je cache-hits waarschijnlijk:

  1. Zet stabiele content vooraan. Eerst het developer-bericht, dan de tooldefinities, dan de repositorysnapshot, dan de taak.
  2. Gebruik een developer-bericht, geen top-level instructions. GPT-6.2 voegt instructions toe na input, dus die zouden buiten de prefix vallen.
  3. Bewerk nooit eerdere items. Voeg tooloutputs toe; herschrijf de geschiedenis niet.
  4. Houd instellingen stabiel binnen een sessie. Volgens de gids van OpenAI moet de prefix ongewijzigd blijven wanneer je instellingen tussen responses wijzigt.

OpenAI documenteert ook prompt_cache_options (expliciete breakpoints en een bewaartijd van 12 uur). Het Responses-schema van PoYo vermeldt dat veld niet en staat geen extra velden toe (additionalProperties: false), dus laat het weg en vertrouw op impliciete caching. Een sessie van 25 beurten op Sol daalt in het beste geval van $3.82 zonder cache naar ongeveer $0.74; de berekening staat in GPT-6.2 API-prijzen.

Wanneer je de run aan Astra overdraagt

Start elke run op gpt-6.2-sol. Als hij stopt bij de beurtlimiet met falende tests, start de taak dan opnieuw op gpt-6.2-astra met een nieuwe itemlijst. Wissel niet van model binnen hetzelfde gesprek, want volgens OpenAI kunnen modelwissels reasoning-items laten vallen. De routingberekening en een router staan in GPT-6.2 Sol API vs. GPT-6.2 Astra API. Voor de aanpak van een andere aanbieder voor dezelfde lus, vergelijk met Gemini 4 Carbon API voor coding agents.

Veelgestelde vragen

Ondersteunt de GPT-6.2 API function calling?

Ja, op /v1/responses. Definieer tools met type: "function", lees function_call-items uit output en stuur de resultaten terug als function_call_output-items met dezelfde call_id.

Kan ik tools van de GPT-6.2 API gebruiken met Chat Completions?

Nee. Volgens OpenAI ondersteunt GPT-6.2 Chat Completions, maar tool calling vereist Responses.

Hoe stream ik een agentbeurt van de GPT-6.2 API?

Stel stream: true in op Responses, print de response.output_text.delta-events en lees tool calls en usage uit het event response.completed.

Hoe verlaag ik de kosten van de GPT-6.2 API in lange agentsessies?

Houd een stabiele prefix (developer-bericht, tools, snapshot) vooraan, voeg toe in plaats van te bewerken, kort tooloutput in en blijf waar mogelijk onder 272K input-tokens per verzoek.

Welk GPT-6.2-model moet mijn coding agent draaien?

Begin met gpt-6.2-sol, dat per token een kwart van Astra kost, en start een mislukte run opnieuw op gpt-6.2-astra.

Share: