Kļūdu apstrāde un rezerves risinājumi
Šajā lapā
Kļūdu apstrāde un rezerves risinājumi
Funkciju izsaukšana rada izaicinājumu, ar ko klasiskais kods nesaskaras: ja tava funkcija neizdodas, šī kļūda ir adresēta diviem saņēmējiem. Tavam lietojumam, kā parasti, un modelim, kas gaida rezultātu, lai turpinātu darbu. Aizmirstot par to, rodas vismulsinošākais simptoms darbības vidē: saruna pēkšņi apstājas bez jebkāda skaidrojuma, jo izņēmums tika “norīts” servera pusē, bet modelis joprojām gaida.
Noteikums, uz kura balstās visa šī nodarbība, ir šāds: vienmēr atgriez function_call_output, pat ja rodas kļūda. Modelis, kas informēts par API nepieejamību, var piedāvāt alternatīvu, lūgt precizējumus vai izskaidrot situāciju lietotājam. Modelis, kas nesaņem neko, nevar darīt neko.
Kļūdu atgriešana modelim
Kļūdas formāts ir tikpat svarīgs kā tās nosūtīšana. Tukšs “Kļūda” modelim nemāca neko; JSON objekts, kas norāda kļūdas veidu, vai tā ir pārejoša vai pastāvīga, un kādi ir nākamie soļi, ļauj modelim pieņemt lēmumu. Tas šķiet pretrunā ar intuīciju: tu raksti kļūdas ziņojumus, kas domāti lasīšanai spriežojošai mašīnai, nevis žurnālfailiem cilvēkiem.
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)
})
}
Atkārtošana ar eksponenciālu aizturi
Atkārtošanai ir jēga tikai tad, ja problēmas varētu atrisināties otrajā mēģinājumā: tīkla pārtraukumi, 429 statusa kodi vai īslaicīgi darbības traucējumi. Atkārtota pieprasījuma nosūtīšana, kas noraidīts nepareizas autentifikācijas vai nepareizu parametru dēļ, tikai aizkavē neveiksmi, vienlaikus reizinot izsaukumu skaitu. Tāpēc zemāk esošais kods skaidri filtrē kļūdas – filtrēšana veic galveno darbu, bet aizture ir tikai pieklājība, ko parādi attālajam servisam.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Atkārtošana ar eksponenciālu aizturi un nejaušību (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:
# Datu kļūda: neatkārtot
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
})
}
Laika limiti katrai funkcijai
Viens laika limits visām funkcijām vienmēr būs nepareizi konfigurēts: ja tas ir pārāk īss, tas pārtrauc smagu apstrādi; ja pārāk garš, tas liek lietotājam gaidīt vienkāršas kešatmiņas meklēšanas dēļ. Katrai vērtībai jābūt balstītai uz novērotajiem ilgumiem normālos apstākļos ar nelielu rezervi, nevis uz sliktāko iespējamo scenāriju, kas faktiski nozīmētu, ka laika limita nav vispār.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Izpilda funkciju ar laika 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) # Pēc noklusējuma 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"
})
}
Rezerves risinājumi starp funkcijām
Rezerves risinājums ir kompromiss, nevis automātisks reflekss: sešas stundas vecu kešatmiņas datu piegāde ir labāk nekā nekas informācijas panelim, bet daudz sliktāk nekā nekas bankas konta atlikumam. Kad veic pasliktināšanu (degradāciju), pasaki to – rezultātā, kas tiek atgriezts modelim, lai tas varētu brīdināt lietotāju, nevis pasniegt novecojušus datus kā svaigus.
async def search_product(term: str) -> dict:
"""Meklēšana ar rezerves risinājumu: primārais API -> kešatmiņa -> lokālā datubāze."""
# 1. mēģinājums: Kataloga API
try:
return await api_catalog.search(term)
except Exception:
pass
# 2. mēģinājums: Redis kešatmiņa
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. mēģinājums: Lokālā SQLite datubāze
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"
}
Ķēdes pārtraucējs (Circuit Breaker)
Ķēdes pārtraucējs risina to, ko atkārtošana nevar: serviss, kas ir nefunkcionējošs ilgstoši. Pēc N neveiksmēm tas “izslēdzas” un nekavējoties atgriež kļūdu, pat nemēģinot izpildīt pieprasījumu, un tikai reizēm ļauj cauri testa pieprasījumam, lai pārbaudītu atjaunošanos. Ieguvums ir divkāršs – tavi lietotāji vairs negaida laika limita beigas katrā pieprasījumā, un grūtībās nonākušais serviss netiek turēts lejā ar taviem atkārtojumiem.
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"
# Viens ķēdes pārtraucējs katram ārējam servisam
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Pilns robusts cikls
Pilns modelis apvieno iepriekš minētos piecus mehānismus. Viens piesardzības pasākums padara to patiesi drošu, un to ir viegli palaist garām: ierobežo iterāciju skaitu. Modelis, kas ciklā izsauc funkciju, kuras rezultāts tam nepatīk, ir rets gadījums, bet bez augšējās robežas tas iztērēs tavu budžetu līdz izsīkumam – un tieši šādu incidentu tu uzzini no rēķina.
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"
Galvenās atziņas
- Vienmēr atgriez
function_call_output, pat ja rodas kļūda - Strukturē kļūdas kā JSON, lai modelis tās varētu izmantot
- Atkārto tikai pārejošas kļūdas, izmantojot eksponenciālu aizturi
- Ievies rezerves risinājumus starp datu avotiem
- Izmanto ķēdes pārtraucēju, lai aizsargātu nefunkcionējošus servisus