Hibakezelés és tartalék megoldások
Ezen az oldalon
Hibakezelés és tartalék megoldások
A függvényhívás olyan kihívást jelent, amellyel a klasszikus kód nem néz szembe: ha a függvényed meghibásodik, a hiba két címzettet érint. Az alkalmazásodat, mint szokás – és a modellt is, amely az eredményre vár a folytatáshoz. Ha ezt elfelejted, az a legzavaróbb tünetet okozza éles környezetben: a beszélgetés minden magyarázat nélkül megáll, mert a kivételt elnyelte a szerveroldali kód, a modell pedig még mindig vár.
Az ezt a leckét végigkísérő szabály a következő: mindig adj vissza egy function_call_output objektumot, még hiba esetén is. Egy modell, amely értesül arról, hogy egy API nem elérhető, tud alternatívát javasolni, pontosítást kérni, vagy elmagyarázni a helyzetet a felhasználónak. Egy modell, amely semmit sem kap, semmit sem tud tenni.
Hibák visszaadása a modellnek
A hiba formátuma ugyanolyan fontos, mint maga a küldés. Egy puszta „Error“ üzenet semmit sem tanít a modellnek; egy JSON objektum, amely megkülönbözteti a hiba típusát, azt, hogy átmeneti vagy végleges-e, valamint a következő lépéseket, lehetővé teszi a modell számára a döntést. Ez ellentmondásosnak tűnhet: olyan hibaüzeneteket írsz, amelyeket egy érvelő gépnek szántál olvasásra, nem pedig emberek számára naplózásra.
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)
})
}
Újrapróbálkozás exponenciális visszalépéssel
Az újrapróbálkozás csak olyan problémák esetén van értelme, amelyek egy második kísérletre megoldódhatnak: hálózati kimaradás, 429-es státuszkódok vagy ideiglenes leállások. Érvénytelen hitelesítés vagy helytelen paraméterek miatt elutasított kérések újrapróbálása csak késlelteti a kudarcot, miközben megsokszorozza a hívások számát. Ezért az alábbi kód kifejezetten szűri a hibákat – a szűrés végzi a munkát, míg a visszalépés csak az a udvariasság, amellyel a távoli szolgáltatásnak tartozol.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Újrapróbálkozás exponenciális visszalépéssel és jitterrel."""
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:
# Adathiba: ne próbáld újra
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
})
}
Függvényenkénti időtúllépések (Timeouts)
Egyetlen, minden függvényre vonatkozó időtúllépés mindig rosszul van beállítva: ha túl rövid, megöl minden nehéz feldolgozást; ha túl hosszú, akkor a felhasználónak egyszerű gyorsítótárazott lekérdezésekre is várnia kell. Minden értéket a normál körülmények között megfigyelt időtartamok alapján állíts be, egy biztonsági ráhagyással – nem a legrosszabb elképzelhető eset alapján, ami gyakorlatilag azt jelentené, hogy nincs is időtúllépés.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Függvény végrehajtása időtúllépéssel."""
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) # Alapértelmezés: 10s
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"
})
}
Tartalék megoldások (Fallback) függvények között
A tartalék megoldás kompromisszum, nem reflex: egy hatórás gyorsítótárazott adat kiszolgálása jobb, mint a semmi egy irányítópultnál, de sokkal rosszabb, mint a semmi egy bankszámlaegyenleg esetén. Ha minőségromlást alkalmazol, mondd ki ezt – a modellnek visszaadott eredményben, így az figyelmeztetheti a felhasználót, ahelyett, hogy elavult adatot frissnek mutatna be.
async def search_product(term: str) -> dict:
"""Keresés tartalék megoldással: elsődleges API -> gyorsítótár -> helyi adatbázis."""
# 1. kísérlet: Katalógus API
try:
return await api_catalog.search(term)
except Exception:
pass
# 2. kísérlet: Redis gyorsítótár
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
# 3. kísérlet: Helyi SQLite adatbázis
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"
}
Áramkör megszakító (Circuit Breaker)
Az áramkör megszakító azt kezeli, amit az újrapróbálkozás nem: olyan szolgáltatást, amely hosszú távon leállt. N hiba után aktiválódik, és azonnal hibát ad vissza anélkül, hogy megpróbálná a hívást, majd időnként engedélyez egy tesztelést a helyreállítás ellenőrzésére. A nyereség kétszeres: a felhasználóid nem várnak minden kérésnél időtúllépésre, és a küzdő szolgáltatást sem tartják lent a folyamatos újrapróbálkozások.
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: allow one test attempt
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"
# Egy áramkör megszakító minden külső szolgáltatáshoz
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Teljes robusztus ciklus
A teljes minta egyesíti a fenti öt mechanizmust. Egy óvintézkedés teszi igazán biztonságossá, amit könnyű elmulasztani: korlátozd az iterációk számát. Ritka, hogy egy modell addig hívjon循环osan egy függvényt, amíg az eredmény nem tetszik neki, de felső korlát nélkül elégeti a költségkeretedet a kimerülésig – és ez az a típusú incidens, amit csak a számlán veszel észre.
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"
Főbb megállapítások
- Mindig adj vissza egy
function_call_outputobjektumot, még hiba esetén is - Strukturáld a hibákat JSON-ként, hogy a modell fel tudja használni őket
- Csak az átmeneti hibákat próbáld újra exponenciális visszalépéssel
- Implementálj tartalék megoldásokat az adatforrások között
- Használj áramkör megszakítót a hibás szolgáltatások védelmére