Klaidų apdorojimas ir atsarginiai variantai
Šiame puslapyje
Klaidų apdorojimas ir atsarginiai variantai
Funkcijų kvietimas kelia iššūkį, su kuriuo klasikinis kodas nesusiduria: kai tavo funkcija nepavyksta, tą klaidą gauna du gavėjai. Tavo programa, kaip įprasta, ir modelis, kuris laukia rezultato, kad galėtų tęsti darbą. Pamiršus tai, gamyboje atsiranda pats keisčiausias simptomas: pokalbis staiga nutrūksta be jokio paaiškinimo, nes išimtis buvo „nuryta“ serverio pusėje, o modelis vis dar laukia.
Taisyklė, kuri struktūrizuoja visą šią pamoką, skamba taip: visada grąžinkite function_call_output, net ir įvykus klaidai. Modelis, informuotas, kad API nepasiekiamas, gali pasiūlyti alternatyvą, paprašyti patikslinimo arba paaiškinti situaciją vartotojui. Modelis, kuris nieko negauna, negali nieko padaryti.
Klaidų grąžinimas modeliui
Klaidos formatas yra toks pat svarbus kaip ir jos siuntimas. Paprastas „Error“ modeliui nieko nepasako; JSON objektas, kuris atskiria klaidos tipą, nurodo, ar ji laikina, ar nuolatinė, ir numato tolesnius veiksmus, leidžia modeliui priimti sprendimą. Tai gali atrodyti prieštaraujama intuicijai: rašote klaidų pranešimus, skirtus skaityti samprotuojančiai mašinai, o ne fiksuoti žmonių žurnalams.
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)
})
}
Kartojimas su eksponentine delsa
Kartojimas (retry) turi prasmę tik toms problemoms, kurios gali išsispręsti antruoju bandymu: tinklo sutrikimai, 429 statuso kodai arba laikini neveikumai. Kartoti užklausą, atmestą dėl neteisingo autentifikavimo ar klaidingų parametrų, reiškia tik atidėti nesėkmę ir dauginti kvietimų skaičių. Štai kodėl žemiau esantis kodas aiškiai filtruoja klaidas – filtravimas atlieka darbą, o delsa yra tik mandagumas, kurį skolingi nuotolinei tarnybai.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Kartojimas su eksponentine delsa ir trikdžiu (jitter)."""
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:
# Duomenų klaida: nekartoti
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
})
}
Atskiros funkcijų laiko limitai
Vienas visiems funkcijoms taikomas laiko limitas visada yra neteisingai nustatytas: per trumpas – jis nutraukia sunkius apdorojimus; per ilgas – verčia vartotoją laukti paprasto podėlio (cache) užklausos rezultato. Kiekvieną reikšmę grindkite stebima trukme įprastomis sąlygomis, palikdami atsargą – o ne blogiausiu įmanomu atveju, kuris iš esmės reikštų, kad laiko limito nėra вовсе.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Vydo funkciją su laiko limitu."""
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) # Pagal nutylėjimą 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"
})
}
Perėjimas prie atsarginių funkcijų
Atsarginis variantas (fallback) yra kompromisas, o ne refleksas: šešių valandų senumo podėlio duomenų pateikimas geriau nei nieko informaciniam skydeliui, tačiau daug blogiau nei nieko banko sąskaitos likučiui. Kai degraduojate, tai įvardykite – rezultate, grąžinamame modeliui, kad jis galėtų įspėti vartotoją, o ne pateikti pasenusių duomenų kaip naujų.
async def search_product(term: str) -> dict:
"""Paieška su atsarginiu variantu: pagrindinis API -> podėlis -> vietinė duomenų bazė."""
# 1 bandymas: Katalogo API
try:
return await api_catalog.search(term)
except Exception:
pass
# 2 bandymas: Redis podėlis
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 bandymas: Vietinė SQLite duomenų bazė
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"
}
Grandininis jungiklis (Circuit Breaker)
Grandininis jungiklis tvarko tai, ko kartojimas negali: ilgai neveikiančią tarnybą. Po N nesėkmių jis „išmuša“ ir iškart grąžina klaidą net nebandydamas, o tada retkarčiais leidžia praeiti bandomajai užklausai, kad patikrintų, ar sistema atsistatė. Naudą gaunate dvigubą – jūsų vartotojai nustoja laukti laiko limito kiekvienoje užklausoje, o vargstanti tarnyba nėra dar labiau apkraunama jūsų kartojimais.
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"
# Vienas grandininis jungiklis kiekvienai išorinei tarnybai
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Pilnas patikimas ciklas
Visas šis šablonas sujungia penkis aukščiau išvardintus mechanizmus. Viena atsargumo priemonė daro jį tikrai saugiu, ir ją lengva praleisti: apribokite iteracijų skaičių. Modelis, kuris sukasi cikle kviesdamas funkciją, kurios rezultato jam nepakanka, yra retas atvejis, tačiau be viršutinės ribos jis išeikvos jūsų biudžetą iki visiško išsekimo – o tokio incidento paprastai nepastebite, kol negaunate sąskaitos.
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"
Svarbiausi punktai
- Visada grąžinkite
function_call_output, net ir įvykus klaidai - Strukturinkite klaidas kaip JSON, kad modelis galėtų jas panaudoti
- Kartokite tik laikinas klaidas naudodami eksponentinę delsą
- Įgyvendinkite perėjimą prie atsarginių duomenų šaltinių
- Naudokite grandininį jungiklis (circuit breaker) apsaugoti neveikiančioms tarnyboms