how-tos

GPT-6.2 API dla agentów programistycznych: function tools, streaming, długi kontekst i cache

Poyo.ai Team
9 min read
Share:

GPT-6.2 API napędzające pętlę agenta programistycznego

GPT-6.2 API to obecny wybór OpenAI do pracy agentowej: changelog API zaleca gpt-6.2-sol „do codziennego programowania i przepływów agentowych”, a gpt-6.2-astra do „wymagających zadań z rozumowania i programowania”. Ten przewodnik podłącza dowolny z tych modeli do agenta programistycznego przez endpoint Responses w PoYo: z function tools, ograniczoną pętlą, streamingiem postępu, dużym kontekstem repozytorium i cache, który utrzymuje koszt długich sesji w rozsądnych granicach. Zacznij na stronie modelu GPT-6.2 Sol, a GPT-6.2 Astra zostaw do eskalacji.

Jeśli nie wysłałeś jeszcze pierwszego żądania, zacznij od przewodnika po GPT-6.2 API.

Co API daje agentowi programistycznemu

ElementGPT-6.2 w PoYo
ID modeligpt-6.2-sol (domyślny), gpt-6.2-astra (eskalacja)
Endpoint dla agentaPOST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1")
Wywoływanie narzędziTylko Responses; OpenAI: „wywoływanie narzędzi wymaga Responses”
Kontekst / maks. wejście / maks. wyjście1,050,000 / 922,000 / 128,000 tokenów
Streaming"stream": true; response.completed niesie końcowe wyjście i usage
Rozumowaniereasoning.effort; none odrzucane, zacznij od medium
Cena za 1M (Sol)$1.60 wejście / $8 wyjście / $0.08 odczyt z cache / $2 zapis do cache
Cena za 1M (Astra)$6.40 wejście / $32 wyjście / $0.32 odczyt z cache / $8 zapis do cache
Błędy400 nieprawidłowe pola, 401 zły klucz, 402 za mało kredytów, 404 nieznany model; 429 / 5xx ponawiaj z backoffem

Dokumentacja Responses w PoYo opisuje tools, tool_choice, parallel_tool_calls, reasoning, include, store, previous_response_id i truncation oraz zaznacza, że obsługa narzędzi zależy od modelu. Strony modeli OpenAI wymieniają dla GPT-6.2 wywoływanie funkcji i zestaw narzędzi hostowanych. Dokumentacja PoYo pokazuje jako przykład narzędzia hostowanego tylko web_search_preview, więc ten agent używa twoich własnych function tools, nad którymi masz pełną kontrolę.

Zdefiniuj function tools

Zestaw narzędzi powinien być mały i bezpieczny. Model może żądać tylko tych akcji, które zaimplementujesz:

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

Uruchamiaj agenta na jednorazowym checkoucie lub w kontenerze, nigdy na swoim katalogu roboczym.

Ograniczona pętla agenta

Pętla wysyła rozmowę, wykonuje każdy element function_call, dołącza function_call_output z tym samym call_id i powtarza, aż model odpowie bez wywołania narzędzia. Zatrzymuje się po osiągnięciu limitu tur i budżetu w dolarach.

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

Dlaczego pętla jest zbudowana w ten sposób:

  • Elementy wyjścia wracają w kolejności, łącznie z elementami rozumowania. Dla żądań, w których store ma wartość false, jak przy Zero Data Retention, przewodnik OpenAI po GPT-6.2 zaleca „przekazywać wcześniejsze elementy wyjścia z powrotem w kolejności, łącznie z zaszyfrowanymi elementami rozumowania”. include=["reasoning.encrypted_content"] prosi o nie. Alternatywą jest previous_response_id z zapisanymi odpowiedziami, co PoYo również dokumentuje.
  • Historia jest tylko dopisywana. OpenAI ostrzega, że edycje w trakcie rozmowy mogą sprawić, że Responses API odrzuci elementy rozumowania, co „może obniżyć jakość odpowiedzi i zwiększyć zużycie tokenów”, a edycja dodatkowo psuje zcache'owany prefiks.
  • Budżet jest sprawdzany w każdej turze, na podstawie tej samej tabeli cen co rachunek.

Na potrzeby tego artykułu nie uruchomiliśmy dokładnie tej pętli od początku do końca w PoYo. Najpierw uruchom ją na małym zadaniu i sprawdź, czy wywołania narzędzi i usage wyglądają zgodnie z oczekiwaniami.

Streaming postępu do użytkownika

Bez informacji zwrotnej długie tury agenta wydają się powolne. Streamuj każdą turę, pokazuj delty tekstu i bierz końcowe wyjście z response.completed. To typy zdarzeń, które dokumentuje PoYo:

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

Podstaw stream_turn w pętli zamiast responses.create. Wywołania narzędzi odczytujesz z final.output dokładnie tak jak wcześniej.

Długi kontekst: 922K na wejściu, 128K na wyjściu

GPT-6.2 przyjmuje do 922,000 tokenów wejściowych na żądanie. Agent może od razu załadować dużą część repozytorium zamiast czytać pliki po jednym. Ten wybór kształtują trzy ograniczenia:

  • Każda tura wysyła historię ponownie. Snapshot o długości 200K tokenów przez 20 tur to co najmniej 4M tokenów wejściowych. Przy cenie Sol $1.60 daje to $6.40 bez cache. Z jednym zapisem snapshotu do cache ($0.40) i 19 odczytami z cache po $0.08 ($0.30) wychodzi około $0.70.
  • Poziom długiego kontekstu w OpenAI zaczyna się powyżej 272K tokenów wejściowych. Powyżej tej granicy strona z cennikiem OpenAI podwaja stawki za wejście i cache oraz pobiera 1.5× za wyjście za całe żądanie. Trzymaj żądania agenta poniżej 272K, chyba że zadanie wymaga więcej, i sprawdź na stronie modelu, która stawka PoYo ma zastosowanie.
  • Rozumowanie dzieli budżet wyjścia. max_output_tokens ogranicza widoczny tekst razem z rozumowaniem. Proś o jeden plik na wywołanie write_file, a nie o przepisanie całego repozytorium.

Przycinaj wyjście narzędzi przed dołączeniem go do historii: zwracaj ostatnie 200 linii z uruchomienia testów, a nie 20,000. Dzięki temu przyrost na turę, a z nim rachunek, pozostaje liniowy i mały.

Cache promptów w sesjach agentowych

Przewodnik OpenAI po cache'owaniu ustala dla GPT-6.2 następujące zasady:

ZasadaWartość
Cena odczytu z cache0.05× wejścia ($0.08 za 1M na Sol, $0.32 na Astra, w PoYo)
Cena zapisu do cache1.25× wejścia przy domyślnej 30-minutowej retencji ($2 / $8 za 1M w PoYo)
Minimalny prefiks do cache'owania1,024 widoczne tokeny wejściowe
Niejawny punkt podziałuKoniec ostatniej kwalifikującej się wiadomości
Pola usageusage.input_tokens_details.cached_tokens (odczyty), cache_write_tokens (zapisy)

Aby trafienia w cache były bardziej prawdopodobne:

  1. Stałą treść umieszczaj na początku. Wiadomość developer, potem definicje narzędzi, potem snapshot repozytorium, potem zadanie.
  2. Używaj wiadomości developer, a nie instructions najwyższego poziomu. GPT-6.2 dołącza instructions po input, więc znalazłyby się poza prefiksem.
  3. Nigdy nie edytuj wcześniejszych elementów. Dopisuj wyjścia narzędzi; nie przepisuj historii.
  4. Nie zmieniaj ustawień w trakcie sesji. Przewodnik OpenAI zaleca zachowanie niezmienionego prefiksu, gdy zmieniasz ustawienia między odpowiedziami.

OpenAI dokumentuje też prompt_cache_options (jawne punkty podziału i 12-godzinną retencję). Schemat Responses w PoYo nie wymienia tego pola i jest zamknięty na dodatkowe pola (additionalProperties: false), więc pomiń je i polegaj na niejawnym cache'owaniu. 25-turowa sesja na Sol w najlepszym przypadku tanieje z $3.82 bez cache do około $0.74; obliczenia znajdziesz w artykule Cennik GPT-6.2 API.

Kiedy przekazać uruchomienie do Astra

Każde uruchomienie zaczynaj na gpt-6.2-sol. Jeśli zatrzyma się na limicie tur z nieprzechodzącymi testami, uruchom zadanie od nowa na gpt-6.2-astra z nową listą elementów. Nie zmieniaj modelu w tej samej rozmowie, bo według OpenAI zmiany modelu mogą odrzucać elementy rozumowania. Rachunek routingu i router opisuje GPT-6.2 Sol API vs GPT-6.2 Astra API. Jeśli chcesz zobaczyć tę samą pętlę u innego dostawcy, porównaj z artykułem Gemini 4 Carbon API dla agentów programistycznych.

Najczęściej zadawane pytania

Czy GPT-6.2 API obsługuje wywoływanie funkcji?

Tak, na /v1/responses. Definiuj narzędzia z type: "function", odczytuj elementy function_call z output i odsyłaj wyniki jako elementy function_call_output z tym samym call_id.

Czy mogę używać narzędzi GPT-6.2 API z Chat Completions?

Nie. OpenAI podaje, że GPT-6.2 obsługuje Chat Completions, ale wywoływanie narzędzi wymaga Responses.

Jak streamować turę agenta w GPT-6.2 API?

Ustaw stream: true w Responses, wypisuj zdarzenia response.output_text.delta i odczytuj wywołania narzędzi oraz usage ze zdarzenia response.completed.

Jak obniżyć koszty GPT-6.2 API w długich sesjach agentowych?

Trzymaj stały prefiks (wiadomość developer, narzędzia, snapshot) na początku, dopisuj zamiast edytować, przycinaj wyjście narzędzi i w miarę możliwości mieść się w 272K tokenów wejściowych na żądanie.

Który model GPT-6.2 powinien napędzać mojego agenta programistycznego?

Zacznij od gpt-6.2-sol, który za token kosztuje jedną czwartą ceny Astra, i uruchamiaj nieudane przebiegi od nowa na gpt-6.2-astra.

Share: