
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
| Element | GPT-6.2 w PoYo |
|---|---|
| ID modeli | gpt-6.2-sol (domyślny), gpt-6.2-astra (eskalacja) |
| Endpoint dla agenta | POST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1") |
| Wywoływanie narzędzi | Tylko Responses; OpenAI: „wywoływanie narzędzi wymaga Responses” |
| Kontekst / maks. wejście / maks. wyjście | 1,050,000 / 922,000 / 128,000 tokenów |
| Streaming | "stream": true; response.completed niesie końcowe wyjście i usage |
| Rozumowanie | reasoning.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łędy | 400 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
storema 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ą jestprevious_response_idz 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_tokensogranicza widoczny tekst razem z rozumowaniem. Proś o jeden plik na wywołaniewrite_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:
| Zasada | Wartość |
|---|---|
| Cena odczytu z cache | 0.05× wejścia ($0.08 za 1M na Sol, $0.32 na Astra, w PoYo) |
| Cena zapisu do cache | 1.25× wejścia przy domyślnej 30-minutowej retencji ($2 / $8 za 1M w PoYo) |
| Minimalny prefiks do cache'owania | 1,024 widoczne tokeny wejściowe |
| Niejawny punkt podziału | Koniec ostatniej kwalifikującej się wiadomości |
| Pola usage | usage.input_tokens_details.cached_tokens (odczyty), cache_write_tokens (zapisy) |
Aby trafienia w cache były bardziej prawdopodobne:
- Stałą treść umieszczaj na początku. Wiadomość developer, potem definicje narzędzi, potem snapshot repozytorium, potem zadanie.
- Używaj wiadomości
developer, a nieinstructionsnajwyższego poziomu. GPT-6.2 dołączainstructionspoinput, więc znalazłyby się poza prefiksem. - Nigdy nie edytuj wcześniejszych elementów. Dopisuj wyjścia narzędzi; nie przepisuj historii.
- 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.