Rukovanje greškama i rezervne opcije
Na ovoj stranici
Rukovanje greškama i rezervne opcije
Pozivanje funkcija uvodi izazov s kojim se klasični kod ne suočava: kada tvoja funkcija zakaže, postoje dva primatelja te greške. Tvoja aplikacija, kao i obično – i model, koji čeka rezultat kako bi nastavio. Zaboravljanje ove činjenice stvara najzbunjujući simptom u produkciji: razgovor koji naglo staje bez objašnjenja jer je iznimka progutana na strani poslužitelja, a model još uvijek čeka.
Pravilo koje strukturira cijelu ovu lekciju glasi: uvijek vrati function_call_output, čak i kod neuspjeha. Model informiran da API nije dostupan može predložiti alternativu, zatražiti pojašnjenje ili objasniti situaciju korisniku. Model koji ne primi ništa ne može učiniti ništa.
Vraćanje grešaka modelu
Format greške jednako je važan kao i slanje iste. Goli „Error“ modelu ne govori ništa; JSON objekt koji razlikuje vrstu greške, je li prolazna ili trajna, te koje su sljedeće korake, omogućuje modelu da donese odluku. Ovo je kontraintuitivno: pišeš poruke o greškama namijenjene stroju za rezoniranje, a ne ljudima za zapisnike.
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 pokušaj s eksponencijalnim odmakom
Ponovni pokušaj ima smisla samo za probleme koji se mogu riješiti drugim pokušajem: prekidi mreže, statusni kodovi 429 ili privremeni ispadi. Ponovno slanje zahtjeva odbijenog zbog neispravne autentifikacije ili netočnih parametara samo odgađa neuspjeh dok istovremeno umnožava pozive. Zato donji kod eksplicitno filtrira greške – filtriranje obavlja posao, dok je odmak samo ljubaznost koju duguješ udaljenoj usluzi.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Retry with exponential backoff and 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:
# Data error: do not retry
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
})
}
Isteci po funkcijama
Jedan istek za sve funkcije uvijek je pogrešno konfiguriran: prekratak ubija tešku obradu; predugačak tjera korisnika da čeka na jednostavno dohvaćanje iz predmemorije. Temelji svaku vrijednost na opaženim trajanjima pod normalnim uvjetima, s marginom – a ne na najgorem mogućem slučaju, što bi efektivno značilo da nemaš nikakav istek.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Executes a function with a timeout."""
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) # 10s by default
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"
})
}
Rezervne opcije između funkcija
Rezervna opcija je kompromis, a ne refleks: posluživanje podataka iz predmemorije starosti šest sati bolje je od ničega za nadzornu ploču, a daleko gore od ničega za stanje na bankovnom računu. Kada degradiraš uslugu, to i reci – u rezultatu vraćenom modelu, kako bi on mogao upozoriti korisnika umjesto da ustajale podatke prikazuje kao svježe.
async def search_product(term: str) -> dict:
"""Search with fallback: primary API -> cache -> local database."""
# Attempt 1: Catalog API
try:
return await api_catalog.search(term)
except Exception:
pass
# Attempt 2: Redis cache
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
# Attempt 3: Local SQLite database
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"
}
Osigurač kruga (Circuit Breaker)
Osigurač kruga rješava ono što ponovni pokušaj ne može: uslugu koja je dugoročno nedostupna. Nakon N neuspjeha, on se aktivira i odmah vraća grešku, bez ikakvog pokušaja, zatim povremeno dopušta testni zahtjev kako bi provjerio oporavak. Dobit je dvostruka – tvoji korisnici prestaju čekati istek pri svakom zahtjevu, a uslugi koja se muči ne otežavaš oporavak svojim ponovnim pokušajima.
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"
# One circuit breaker per external service
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Potpuna robusna petlja
Cjelokupni uzorak objedinjuje pet gore navedenih mehanizama. Jedan oprez čini ga doista sigurnim, a lako ga je previdjeti: ograniči broj iteracija. Model koji u petlji poziva funkciju čiji mu se rezultat ne sviđa rijedak je slučaj, ali bez gornje granice potrošit će tvoj budžet do iscrpljenosti – a to je vrsta incidenta koju otkriješ tek 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 točke
- Uvijek vrati
function_call_output, čak i kod greške - Strukturiraj greške kao JSON kako bi ih model mogao iskoristiti
- Ponavljaj samo prolazne greške s eksponencijalnim odmakom
- Implementiraj rezervne opcije između izvora podataka
- Koristi osigurač kruga za zaštitu usluga koje otkazuju