
GPT-6.2 API adalah pilihan OpenAI saat ini untuk pekerjaan agen: changelog API merekomendasikan gpt-6.2-sol "untuk coding dan alur kerja agen sehari-hari" dan gpt-6.2-astra untuk "tugas reasoning dan coding yang berat." Panduan ini menghubungkan salah satu model tersebut ke agen coding melalui endpoint Responses PoYo, dengan function tool, loop yang dibatasi, progres yang di-stream, konteks repositori yang besar, dan caching yang menjaga sesi panjang tetap terjangkau. Mulailah di halaman model GPT-6.2 Sol dan simpan GPT-6.2 Astra untuk eskalasi.
Jika Anda belum mengirim permintaan pertama, mulailah dengan panduan GPT-6.2 API.
Apa yang diberikan API ini untuk agen coding
| Item | GPT-6.2 di PoYo |
|---|---|
| ID model | gpt-6.2-sol (default), gpt-6.2-astra (eskalasi) |
| Endpoint agen | POST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1") |
| Tool calling | Hanya Responses; OpenAI: "tool calling memerlukan Responses" |
| Konteks / input maksimum / output maksimum | 1,050,000 / 922,000 / 128,000 token |
| Streaming | "stream": true; response.completed membawa output akhir dan usage |
| Reasoning | reasoning.effort; none ditolak, mulai dari medium |
| Harga per 1M (Sol) | $1.60 input / $8 output / $0.08 baca cache / $2 tulis cache |
| Harga per 1M (Astra) | $6.40 input / $32 output / $0.32 baca cache / $8 tulis cache |
| Error | 400 field tidak valid, 401 kunci salah, 402 kredit tidak cukup, 404 model tidak dikenal; ulangi 429 / 5xx dengan backoff |
Referensi Responses PoYo mendokumentasikan tools, tool_choice, parallel_tool_calls, reasoning, include, store, previous_response_id, dan truncation, serta menyebutkan bahwa dukungan tool bergantung pada model. Halaman model OpenAI mencantumkan function calling dan sejumlah hosted tool untuk GPT-6.2. Dokumentasi PoYo hanya menampilkan web_search_preview sebagai contoh hosted tool, jadi agen ini memakai function tool Anda sendiri, yang sepenuhnya Anda kendalikan.
Mendefinisikan function tool
Jaga agar kumpulan tool tetap kecil dan aman. Model hanya bisa meminta aksi yang Anda implementasikan:
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}"
Jalankan agen di checkout atau container sekali pakai, jangan pernah di working tree Anda.
Loop agen yang dibatasi
Loop ini mengirim percakapan, mengeksekusi setiap item function_call, menambahkan function_call_output dengan call_id yang sama, dan mengulanginya sampai model menjawab tanpa tool call. Loop berhenti pada batas giliran dan anggaran dalam dolar.
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")
Mengapa loop dibuat seperti ini:
- Item output dikembalikan sesuai urutan, termasuk item reasoning. Untuk permintaan dengan
storebernilai false, seperti pada Zero Data Retention, panduan GPT-6.2 OpenAI meminta Anda untuk "mengirim kembali item output sebelumnya sesuai urutan, termasuk item reasoning yang terenkripsi."include=["reasoning.encrypted_content"]meminta item tersebut. Alternatifnya adalahprevious_response_iddengan respons yang disimpan, yang juga didokumentasikan PoYo. - Riwayat hanya ditambah, tidak diubah. OpenAI memperingatkan bahwa edit di tengah percakapan bisa membuat Responses API membuang item reasoning, yang "dapat menurunkan kualitas jawaban dan menambah pemakaian token," dan sebuah edit juga merusak prefix yang sudah di-cache.
- Anggaran diperiksa di setiap giliran, memakai tabel harga yang sama dengan tagihan.
Kami belum menjalankan loop ini persis end to end di PoYo untuk artikel ini. Jalankan dulu pada tugas kecil dan pastikan tool call serta usage terlihat sesuai harapan.
Streaming progres ke pengguna
Giliran agen yang panjang terasa lambat tanpa umpan balik. Stream setiap giliran, tampilkan delta teks, dan ambil output akhir dari response.completed. Berikut tipe event yang didokumentasikan 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
Pakai stream_turn di dalam loop sebagai pengganti responses.create. Tool call dibaca dari final.output persis seperti sebelumnya.
Konteks panjang: 922K masuk, 128K keluar
GPT-6.2 menerima hingga 922,000 token input per permintaan. Agen bisa memuat sebagian besar repositori di awal alih-alih membaca file satu per satu. Ada tiga batasan yang memengaruhi pilihan itu:
- Setiap giliran mengirim ulang riwayat. Snapshot 200K token selama 20 giliran berarti setidaknya 4M token input. Dengan tarif Sol $1.60, itu $6.40 tanpa cache. Dengan satu tulis cache untuk snapshot ($0.40) dan 19 baca cache seharga $0.08 ($0.30), biayanya sekitar $0.70.
- Tingkat konteks panjang OpenAI dimulai di atas 272K token input. Halaman harga OpenAI menggandakan tarif input dan cache serta mengenakan 1.5× tarif output untuk seluruh permintaan setelah batas itu. Jaga permintaan agen di bawah 272K kecuali tugasnya memang membutuhkan lebih, dan periksa halaman model untuk tarif PoYo yang berlaku.
- Reasoning berbagi anggaran output.
max_output_tokensmembatasi teks yang terlihat ditambah reasoning. Minta satu file per panggilanwrite_file, bukan penulisan ulang seluruh repositori.
Pangkas output tool sebelum menambahkannya: kembalikan 200 baris terakhir dari hasil test, bukan 20,000. Dengan begitu, pertumbuhan per giliran, dan tagihannya, tetap linear dan kecil.
Prompt caching untuk sesi agen
Panduan caching OpenAI menetapkan aturan berikut untuk GPT-6.2:
| Aturan | Nilai |
|---|---|
| Harga baca cache | 0.05× input ($0.08 per 1M di Sol, $0.32 di Astra, di PoYo) |
| Harga tulis cache | 1.25× input untuk retensi default 30 menit ($2 / $8 per 1M di PoYo) |
| Prefix minimum yang bisa di-cache | 1,024 token input yang terlihat |
| Breakpoint implisit | Akhir pesan terakhir yang memenuhi syarat |
| Field usage | usage.input_tokens_details.cached_tokens (baca), cache_write_tokens (tulis) |
Agar cache hit lebih mungkin terjadi:
- Taruh konten yang stabil di awal. Pesan developer, lalu definisi tool, lalu snapshot repositori, lalu tugasnya.
- Gunakan pesan
developer, bukaninstructionstingkat atas. GPT-6.2 menambahkaninstructionssetelahinput, sehingga instruksi itu akan berada di luar prefix. - Jangan pernah mengedit item sebelumnya. Tambahkan output tool; jangan menulis ulang riwayat.
- Jaga pengaturan tetap stabil dalam satu sesi. Panduan OpenAI meminta prefix tetap tidak berubah saat Anda mengubah pengaturan di antara respons.
OpenAI juga mendokumentasikan prompt_cache_options (breakpoint eksplisit dan retensi 12 jam). Skema Responses PoYo tidak mencantumkan field itu dan dinyatakan tertutup untuk field tambahan (additionalProperties: false), jadi jangan sertakan field tersebut dan andalkan caching implisit. Sesi 25 giliran dalam kasus terbaik di Sol turun dari $3.82 tanpa cache menjadi sekitar $0.74; perhitungannya ada di Harga GPT-6.2 API.
Kapan menyerahkan run ke Astra
Mulai setiap run di gpt-6.2-sol. Jika run berhenti di batas giliran dengan test yang masih gagal, mulai ulang tugas di gpt-6.2-astra dengan daftar item yang baru. Jangan berganti model di dalam percakapan yang sama, karena OpenAI menyebutkan bahwa perpindahan model bisa membuang item reasoning. Perhitungan routing dan contoh router ada di GPT-6.2 Sol API vs GPT-6.2 Astra API. Untuk melihat pendekatan vendor lain pada loop yang sama, bandingkan dengan Gemini 4 Carbon API untuk agen coding.
Pertanyaan yang sering diajukan
Apakah GPT-6.2 API mendukung function calling?
Ya, di /v1/responses. Definisikan tool dengan type: "function", baca item function_call dari output, dan kirim hasilnya kembali sebagai item function_call_output dengan call_id yang sama.
Bisakah saya memakai tool GPT-6.2 API dengan Chat Completions?
Tidak. OpenAI menyatakan GPT-6.2 mendukung Chat Completions, tetapi tool calling memerlukan Responses.
Bagaimana cara melakukan streaming satu giliran agen GPT-6.2 API?
Atur stream: true di Responses, cetak event response.output_text.delta, lalu baca tool call dan usage dari event response.completed.
Bagaimana cara menekan biaya GPT-6.2 API di sesi agen yang panjang?
Pertahankan prefix yang stabil (pesan developer, tool, snapshot) di awal, tambahkan alih-alih mengedit, pangkas output tool, dan usahakan tetap di bawah 272K token input per permintaan bila memungkinkan.
Model GPT-6.2 mana yang sebaiknya menjalankan agen coding saya?
Mulailah dengan gpt-6.2-sol, yang harganya seperempat Astra per token, lalu mulai ulang run yang gagal di gpt-6.2-astra.