Håndtering af fejl og fallbacks
På denne side
Håndtering af fejl og fallbacks
Funktionskald introducerer en udfordring, som klassisk kode ikke står over for: Når din funktion fejler, er der to modtagere af den fejl. Din applikation, som sædvanligt – og modellen, som venter på et resultat for at kunne fortsætte. Glemmer du dette, opstår det mest forvirrende symptom i produktion: En samtale, der stopper brat uden forklaring, fordi en undtagelse blev slugt på serversiden, mens modellen stadig venter.
Reglen, der strukturerer hele denne lektion, er følgende: Returnér altid en function_call_output, også ved fejl. En model, der får besked om, at en API ikke er tilgængelig, kan foreslå en alternativ løsning, bede om afklaring eller forklare brugeren situationen. En model, der ikke modtager noget, kan intet gøre.
Returnering af fejl til modellen
Formatet på fejlen er lige så vigtigt som selve afsendelsen. En nøgen “Error” lærer modellen ingenting; et JSON-objekt, der skelner mellem fejltypen, om den er midlertidig eller permanent, og hvilke næste skridt der skal tages, giver modellen mulighed for at træffe en beslutning. Det virker måske kontraintuitivt: Du skriver fejlmeddelelser, der er beregnet til at blive læst af en ræsonnerende maskine, ikke logget til mennesker.
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)
})
}
Genforsøg med eksponentiel backoff
Genforsøg giver kun mening for problemer, der kan løse sig selv ved et andet forsøg: Netværksafbrydelser, 429-statuskoder eller midlertidige nedbrud. At genforsøge en anmodning, der er afvist på grund af ugyldig godkendelse eller forkerte parametre, forsinker kun fejlen, samtidig med at antallet af kald ganges. Derfor filtrerer koden nedenstående eksplicit efter fejltyper – filtreringen udfører arbejdet, mens backoff blot er den høflighed, du skylder den eksterne tjeneste.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Genforsøg med eksponentiel backoff og 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:
# Datafejl: Forsøg ikke igen
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
})
}
Tidsudløb pr. funktion
Et enkelt tidsudløb for alle funktioner er altid forkert konfigureret: Er det for kort, dræber det tung behandling; er det for langt, får du brugeren til at vente på et simpelt cache-opslag. Basisér hver værdi på observerede varigheder under normale forhold med en margin – ikke på det værst tænkelige scenarie, hvilket i praksis ville betyde, at du slet ikke har noget tidsudløb.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Udfører en funktion med et tidsudløb."""
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 som standard
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"
})
}
Fallback mellem funktioner
Fallback er en afvejning, ikke en refleks: At levere seks timer gamle cachelagrede data er bedre end ingenting til et dashboard, men langt værre end ingenting til en banksaldo. Når du degraderer ydelsen, så sig det – i resultatet returneret til modellen, så den kan advare brugeren i stedet for at præsentere forældede data som friske.
async def search_product(term: str) -> dict:
"""Søgning med fallback: Primær API -> cache -> lokal database."""
# Forsøg 1: Katalog-API
try:
return await api_catalog.search(term)
except Exception:
pass
# Forsøg 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
# Forsøg 3: Lokal 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"
}
Circuit breaker
Circuit breaker håndterer det, som genforsøg ikke kan: En tjeneste, der er nede i længere tid. Efter N fejl udløses den og returnerer straks en fejl uden overhovedet at forsøge, hvorefter den lejlighedsvis tillader en testanmodning at passere for at tjekke, om tjenesten er kommet sig. Gevinsten er dobbelt: Dine brugere holder op med at vente på tidsudløb ved hver anmodning, og den pressede tjeneste holdes ikke nede af dine genforsøg.
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: tillad ét testforsøg
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"
# Én circuit breaker pr. ekstern tjeneste
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Komplet robust løkke
Det fulde mønster samler de fem mekanismer ovenfor. Én forholdsregel gør det virkelig sikkert, og den er let at overse: Sæt en grænse for antallet af iterationer. Det er sjældent, at en model løber i en løkke, hvor den kalder en funktion, hvis resultat den ikke bryder sig om, men uden et loft vil den brænde dit budget af indtil udmattelse – og det er den slags hændelser, du først opdager på regningen.
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"
Vigtige pointer
- Returnér altid en
function_call_output, også ved fejl - Strukturér fejl som JSON, så modellen kan bruge dem
- Genforsøg kun midlertidige fejl med eksponentiel backoff
- Implementér fallbacks mellem datakilder
- Brug en circuit breaker til at beskytte fejlramte tjenester