Obdelava napak in nadomestne rešitve
Na tej strani
Obdelava napak in nadomestne rešitve
Klicanje funkcij prinaša izziv, s katerim se klasična koda ne sooča: ko tvoja funkcija odpove, imata napako dva prejemnika. Tvoja aplikacija, kot običajno, in model, ki čaka na rezultat za nadaljevanje. Pozaba na to ustvari najbolj zmeden simptom v produkciji: pogovor, ki se nenadoma ustavi brez razlage, ker je bila izjema pogoltnjena na strani strežnika, model pa še vedno čaka.
Pravilo, ki sledi, strukturira celotno lekcijo: vedno vrni function_call_output, tudi ob napaki. Model, obveščen, da API ni na voljo, lahko predlaga alternativo, zaprosi za pojasnilo ali uporabniku razloži situacijo. Model, ki ne prejme ničesar, ne more storiti ničesar.
Vračanje napak modelu
Format napake je prav tako pomemben kot njen pošiljanje. Golo sporočilo “Napaka” modelu ne pove ničesar; objekt JSON, ki razlikuje vrsto napake, ali je prehodna ali trajna, in naslednje korake, omogoča modelu odločitev. To je protislovno: pišeš sporočila o napakah, namenjena branju s strani stroja za razmišljanje, ne beleženju za ljudi.
import json
from openai import OpenAI
client = OpenAI()
def execute_function(name: str, arguments: str, call_id: str) -> dict:
try:
args = json.loads(arguments)
result = dispatcher[name](**args)
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps(result)
}
except KeyError:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": "unknown_function",
"message": f"The function '{name}' does not exist"
})
}
except json.JSONDecodeError:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": "invalid_arguments",
"message": "The JSON arguments are malformed"
})
}
except Exception as e:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": "internal_error",
"message": str(e)
})
}
Ponovni poskus z eksponentnim zamikom
Ponovni poskus ima smisel le pri težavah, ki se lahko ob drugem poskusu razrešijo: prekinitve omrežja, statusne kode 429 ali začasne izpadi. Ponovni poskus zahteve, zavrnjene zaradi neveljavne avtentikacije ali napačnih parametrov, le odlaša neuspeh in hkrati množi število klicev. Zato spodnja koda izrecno filtrira napake – filtriranje opravi delo, zamik pa je le vljudnost, ki jo dolguješ oddaljeni storitvi.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Ponovni poskus z eksponentnim zamikom in naključnim odmikom."""
for attempt in range(max_retries + 1):
try:
return func(**args)
except (ConnectionError, TimeoutError) as e:
if attempt == max_retries:
raise
delay = base_delay * (2 ** attempt) + random.uniform(0, 0.5)
time.sleep(delay)
except ValueError:
# Napaka podatkov: ne ponavljaj
raise
def execute_function_robust(name, arguments, call_id):
args = json.loads(arguments)
try:
result = execute_with_retry(dispatcher[name], args)
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps(result)
}
except Exception as e:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": type(e).__name__,
"message": str(e),
"retries_performed": 3
})
}
Časovne omejitve za posamezne funkcije
Ena sama časovna omejitev za vse funkcije je vedno napačno nastavljena: prekratka ubije težko obdelavo; predolga pa prisili uporabnika v čakanje na preprost iskalni pomnilnik. Vsako vrednost določi na podlagi opaženih trajanj v normalnih pogojih, z robom – ne na podlagi najslabšega možnega primera, kar bi v praksi pomenilo, da časovne omejitve sploh nimaš.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Izvede funkcijo s časovno omejitvijo."""
import concurrent.futures
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(func)
try:
return future.result(timeout=timeout_seconds)
except concurrent.futures.TimeoutError:
raise TimeoutError(
f"Function interrupted after {timeout_seconds}s"
)
def execute_with_timeout(name, arguments, call_id):
args = json.loads(arguments)
timeout = TIMEOUTS.get(name, 10) # privzeto 10 s
try:
result = with_timeout(
lambda: dispatcher[name](**args),
timeout
)
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps(result)
}
except TimeoutError as e:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": "timeout",
"message": str(e),
"suggestion": "Retry with more specific criteria"
})
}
Nadomestne rešitve med funkcijami
Nadomestna rešitev je kompromis, ne refleks: streženje šest ur starih predpomnjenih podatkov je za nadzorno ploščo bolje kot nič, za stanje na bančnem računu pa bistveno slabše kot nič. Ko degradiraš storitev, to tudi povej – v rezultatu, vrnjenem modelu, da lahko opozori uporabnika, namesto da zastarele podatke predstavi kot sveže.
async def search_product(term: str) -> dict:
"""Iskanje z nadomestno rešitvijo: glavni API -> predpomnilnik -> lokalna baza podatkov."""
# Poskus 1: API kataloga
try:
return await api_catalog.search(term)
except Exception:
pass
# Poskus 2: Predpomnilnik Redis
try:
cached = await redis_client.get(f"product:{term}")
if cached:
result = json.loads(cached)
result["_source"] = "cache"
result["_warning"] = "Data may be outdated"
return result
except Exception:
pass
# Poskus 3: Lokalna baza podatkov SQLite
try:
row = db.execute(
"SELECT * FROM products WHERE name LIKE ?",
(f"%{term}%",)
).fetchone()
if row:
return {
"name": row["name"],
"price": row["price"],
"_source": "local_db",
"_warning": "Data from last synchronization"
}
except Exception:
pass
return {
"error": "unavailable",
"message": "No data source accessible for this search"
}
Odklopnik (Circuit Breaker)
Odklopnik obravnava tisto, česar ponovni poskus ne more: storitev, ki je dlje časa nedostopna. Po N neuspehih se sproži in takoj vrne napako, ne da bi sploh poskusil, nato pa občasno dovoli testni zahtevek, da preveri obnovitev. Dobiček je dvojen – tvoji uporabniki ne čakajo več na časovni iztek pri vsaki zahtevi, storitev v težavah pa ni zaradi tvojih ponovnih poskusov še dodatno obremenjena.
from datetime import datetime, timedelta
class CircuitBreaker:
def __init__(self, failure_threshold=5, open_duration=60):
self.threshold = failure_threshold
self.duration = open_duration
self.failures = 0
self.last_failure = None
self.state = "closed" # closed, open, half-open
def can_execute(self) -> bool:
if self.state == "closed":
return True
if self.state == "open":
if datetime.now() - self.last_failure > timedelta(seconds=self.duration):
self.state = "half-open"
return True
return False
return True # half-open: dovoli en testni poskus
def record_success(self):
self.failures = 0
self.state = "closed"
def record_failure(self):
self.failures += 1
self.last_failure = datetime.now()
if self.failures >= self.threshold:
self.state = "open"
# En odklopnik na zunanjo storitev
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Popoln robusten zank
Celoten vzorec združuje zgornjih pet mehanizmov. En previdnostni ukrep ga naredi resnično varnega in ga je lahko spregledati: omeji število iteracij. Model, ki v zanki kliče funkcijo, katere rezultat mu ni všeč, je redek, a brez zgornje meje bo porabil tvoj proračun do izčrpanosti – in to je vrsta incidenta, ki jo odkriješ šele na računu.
def robust_loop(prompt, tools, max_turns=10):
messages = prompt
for turn in range(max_turns):
response = client.responses.create(
model="gpt-5.6-terra",
input=messages,
tools=tools
)
calls = [i for i in response.output if i.type == "function_call"]
if not calls:
return response.output_text
results = []
for call in calls:
result = execute_function_robust(
call.name, call.arguments, call.call_id
)
results.append(result)
messages = response.output + results
return "Workflow interrupted: turn limit reached"
Ključne ugotovitve
- Vedno vrni
function_call_output, tudi ob napaki - Strukturiraj napake kot JSON, da jih model lahko uporabi
- Ponavljaj le prehodne napake z eksponentnim zamikom
- Implementiraj nadomestne rešitve med viri podatkov
- Uporabi odklopnik za zaščito odpovedujočih storitev