how-tos

GPT-6.2 API für Coding-Agenten: Function Tools, Streaming, langer Kontext und Caching

Poyo.ai Team
9 min read
Share:

GPT-6.2 API als Antrieb einer Coding-Agenten-Schleife

Die GPT-6.2 API ist OpenAIs aktuelle Empfehlung für Agenten-Arbeit: Das API-Changelog empfiehlt gpt-6.2-sol „für alltägliche Coding- und Agenten-Workflows“ und gpt-6.2-astra für „anspruchsvolle Reasoning- und Coding-Aufgaben“. Dieser Leitfaden bindet eines der beiden Modelle über PoYos Responses-Endpunkt in einen Coding-Agenten ein, mit Function Tools, einer begrenzten Schleife, gestreamtem Fortschritt, großem Repository-Kontext und Caching, das lange Sessions bezahlbar hält. Beginnen Sie auf der GPT-6.2 Sol Modellseite und halten Sie GPT-6.2 Astra für die Eskalation bereit.

Falls Sie noch keine erste Anfrage gesendet haben, beginnen Sie mit dem GPT-6.2 API Leitfaden.

Was die API einem Coding-Agenten bietet

PunktGPT-6.2 bei PoYo
Modell-IDsgpt-6.2-sol (Standard), gpt-6.2-astra (Eskalation)
Agenten-EndpunktPOST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1")
Tool CallingNur Responses; OpenAI: „Tool Calling erfordert Responses“
Kontext / max. Input / max. Output1,050,000 / 922,000 / 128,000 Token
Streaming"stream": true; response.completed enthält die finale Ausgabe und usage
Reasoningreasoning.effort; none abgelehnt, mit medium beginnen
Preis pro 1M (Sol)$1.60 Input / $8 Output / $0.08 Cache-Read / $2 Cache-Write
Preis pro 1M (Astra)$6.40 Input / $32 Output / $0.32 Cache-Read / $8 Cache-Write
Fehler400 ungültige Felder, 401 falscher Schlüssel, 402 nicht genügend Credits, 404 unbekanntes Modell; 429 / 5xx mit Backoff wiederholen

PoYos Responses-Referenz dokumentiert tools, tool_choice, parallel_tool_calls, reasoning, include, store, previous_response_id und truncation und weist darauf hin, dass die Tool-Unterstützung vom Modell abhängt. OpenAIs Modellseiten führen für GPT-6.2 Function Calling und eine Reihe gehosteter Tools auf. PoYos Dokumentation zeigt nur web_search_preview als Beispiel für ein gehostetes Tool, daher nutzt dieser Agent Ihre eigenen Function Tools, die Sie von Anfang bis Ende kontrollieren.

Function Tools definieren

Halten Sie das Tool-Set klein und sicher. Das Modell kann nur Aktionen anfordern, die Sie implementieren:

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

Lassen Sie den Agenten gegen einen Wegwerf-Checkout oder einen Container laufen, nie gegen Ihren Arbeitsbaum.

Eine begrenzte Agenten-Schleife

Die Schleife sendet die Konversation, führt jedes function_call-Item aus, hängt ein function_call_output mit derselben call_id an und wiederholt das, bis das Modell ohne Tool Call antwortet. Sie stoppt bei einem Turn-Limit und einem Dollar-Budget.

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

Warum die Schleife so aufgebaut ist:

  • Output-Items gehen in der richtigen Reihenfolge zurück, einschließlich der Reasoning-Items. Für Anfragen, bei denen store false ist, etwa unter Zero Data Retention, sagt OpenAIs GPT-6.2-Leitfaden: „Geben Sie die vorherigen Output-Items in der richtigen Reihenfolge zurück, einschließlich der verschlüsselten Reasoning-Items.“ include=["reasoning.encrypted_content"] fordert sie an. Die Alternative ist previous_response_id mit gespeicherten Responses, was PoYo ebenfalls dokumentiert.
  • Der Verlauf wird nur ergänzt. OpenAI warnt, dass Änderungen mitten in der Konversation dazu führen können, dass die Responses API Reasoning-Items verwirft, was „die Antwortqualität verringern und den Token-Verbrauch erhöhen kann“, und eine Änderung bricht außerdem das gecachte Präfix.
  • Das Budget wird in jedem Turn geprüft, mit derselben Preistabelle wie die Abrechnung.

Wir haben genau diese Schleife für diesen Beitrag nicht durchgängig auf PoYo ausgeführt. Lassen Sie sie zuerst mit einer kleinen Aufgabe laufen und prüfen Sie, ob die Tool Calls und usage wie erwartet aussehen.

Fortschritt an den Nutzer streamen

Lange Agenten-Turns wirken ohne Rückmeldung träge. Streamen Sie jeden Turn, zeigen Sie die Text-Deltas an und nehmen Sie die finale Ausgabe aus response.completed. Das sind die Event-Typen, die PoYo dokumentiert:

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

Setzen Sie stream_turn in der Schleife anstelle von responses.create ein. Tool Calls werden genau wie zuvor aus final.output gelesen.

Langer Kontext: 922K rein, 128K raus

GPT-6.2 akzeptiert bis zu 922,000 Input-Token pro Anfrage. Ein Agent kann einen großen Teil eines Repositorys vorab laden, statt Dateien einzeln zu lesen. Drei Grenzen bestimmen diese Entscheidung:

  • Jeder Turn sendet den Verlauf erneut. Ein Snapshot mit 200K Token über 20 Turns ergibt mindestens 4M Input-Token. Bei Sols $1.60 sind das ungecacht $6.40. Mit einem Cache-Write des Snapshots ($0.40) und 19 Cache-Reads zu $0.08 ($0.30) sind es etwa $0.70.
  • OpenAIs Long-Context-Tarif beginnt über 272K Input-Token. OpenAIs Preisseite verdoppelt jenseits dieser Grenze die Input- und Cache-Preise und berechnet für die gesamte Anfrage 1.5× Output. Halten Sie Agenten-Anfragen unter 272K, sofern die Aufgabe nicht mehr braucht, und prüfen Sie auf der Modellseite, welcher PoYo-Preis gilt.
  • Reasoning teilt sich das Output-Budget. max_output_tokens begrenzt sichtbaren Text plus Reasoning. Lassen Sie pro write_file-Aufruf eine Datei schreiben statt das ganze Repository neu.

Kürzen Sie Tool-Ausgaben, bevor Sie sie anhängen: Geben Sie die letzten 200 Zeilen eines Testlaufs zurück, nicht 20,000. So bleibt das Wachstum pro Turn, und damit die Rechnung, linear und klein.

Prompt Caching für Agenten-Sessions

OpenAIs Caching-Leitfaden legt für GPT-6.2 diese Regeln fest:

RegelWert
Cache-Read-Preis0.05× Input ($0.08 pro 1M auf Sol, $0.32 auf Astra, bei PoYo)
Cache-Write-Preis1.25× Input bei der standardmäßigen 30-minütigen Aufbewahrung ($2 / $8 pro 1M bei PoYo)
Minimales cachebares Präfix1,024 sichtbare Input-Token
Impliziter BreakpointEnde der letzten geeigneten Nachricht
Usage-Felderusage.input_tokens_details.cached_tokens (Reads), cache_write_tokens (Writes)

So werden Cache-Treffer wahrscheinlich:

  1. Stabile Inhalte zuerst. Developer-Nachricht, dann Tool-Definitionen, dann der Repository-Snapshot, dann die Aufgabe.
  2. Eine developer-Nachricht verwenden, keine Top-Level-instructions. GPT-6.2 hängt instructions hinter input an, sie stünden also außerhalb des Präfixes.
  3. Frühere Items nie bearbeiten. Tool-Ausgaben anhängen, den Verlauf nicht umschreiben.
  4. Einstellungen innerhalb einer Session stabil halten. Laut OpenAIs Leitfaden soll das Präfix unverändert bleiben, wenn Sie Einstellungen zwischen Antworten ändern.

OpenAI dokumentiert außerdem prompt_cache_options (explizite Breakpoints und eine Aufbewahrung von 12 Stunden). PoYos Responses-Schema führt dieses Feld nicht auf und ist für zusätzliche Felder gesperrt (additionalProperties: false), lassen Sie es also weg und verlassen Sie sich auf implizites Caching. Eine Session mit 25 Turns auf Sol sinkt im besten Fall von $3.82 ungecacht auf etwa $0.74; die Rechnung steht in GPT-6.2 API Preise.

Wann Sie den Lauf an Astra übergeben

Starten Sie jeden Lauf auf gpt-6.2-sol. Wenn er mit fehlschlagenden Tests am Turn-Limit stoppt, starten Sie die Aufgabe auf gpt-6.2-astra mit einer frischen Item-Liste neu. Wechseln Sie das Modell nicht innerhalb derselben Konversation, denn laut OpenAI können Modellwechsel Reasoning-Items verwerfen. Die Routing-Rechnung und einen Router finden Sie in GPT-6.2 Sol API vs. GPT-6.2 Astra API. Wie ein anderer Anbieter dieselbe Schleife umsetzt, sehen Sie im Vergleich mit Gemini 4 Carbon API für Coding-Agenten.

Häufig gestellte Fragen

Unterstützt die GPT-6.2 API Function Calling?

Ja, auf /v1/responses. Definieren Sie Tools mit type: "function", lesen Sie function_call-Items aus output und senden Sie die Ergebnisse als function_call_output-Items mit derselben call_id zurück.

Kann ich Tools der GPT-6.2 API mit Chat Completions nutzen?

Nein. Laut OpenAI unterstützt GPT-6.2 Chat Completions, aber Tool Calling erfordert Responses.

Wie streame ich einen Agenten-Turn der GPT-6.2 API?

Setzen Sie stream: true bei Responses, geben Sie response.output_text.delta-Events aus und lesen Sie Tool Calls und usage aus dem Event response.completed.

Wie senke ich die Kosten der GPT-6.2 API in langen Agenten-Sessions?

Halten Sie ein stabiles Präfix (Developer-Nachricht, Tools, Snapshot) am Anfang, hängen Sie an statt zu bearbeiten, kürzen Sie Tool-Ausgaben und bleiben Sie nach Möglichkeit unter 272K Input-Token pro Anfrage.

Welches GPT-6.2-Modell sollte meinen Coding-Agenten antreiben?

Beginnen Sie mit gpt-6.2-sol, das pro Token ein Viertel von Astra kostet, und starten Sie einen fehlgeschlagenen Lauf auf gpt-6.2-astra neu.

Share: