Foutafhandeling en fallbacks
Op deze pagina
Foutafhandeling en fallbacks
Functieaanroepen introduceren een uitdaging waar klassieke code niet mee te maken heeft: wanneer uw functie faalt, zijn er twee ontvangers voor die fout. Uw applicatie, zoals gebruikelijk, én het model, dat wacht op een resultaat om verder te gaan. Als u dit vergeet, ontstaat het meest raadselachtige symptoom in productie: een gesprek dat abrupt stopt zonder uitleg, omdat een uitzondering aan de serverzijde is ingeslikt en het model nog steeds wacht.
De regel die deze hele les structureert, luidt: geef altijd een function_call_output terug, zelfs bij mislukking. Een model dat wordt geïnformeerd dat een API niet beschikbaar is, kan een alternatief voorstellen, om verduidelijking vragen of de situatie aan de gebruiker uitleggen. Een model dat niets ontvangt, kan niets doen.
Fouten terugsturen naar het model
Het formaat van de fout is net zo belangrijk als het verzenden ervan. Een kaal “Error” leert het model niets; een JSON-object dat het fouttype onderscheidt, aangeeft of deze tijdelijk of permanent is, en de volgende stappen schetst, stelt het model in staat een beslissing te nemen. Dit is contra-intuïtief: u schrijft foutberichten die bedoeld zijn om gelezen te worden door een redenerende machine, niet om voor mensen gelogd te worden.
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)
})
}
Opnieuw proberen met exponentiële backoff
Opnieuw proberen heeft alleen zin bij problemen die bij een tweede poging opgelost kunnen zijn: netwerkonderbrekingen, statuscode 429 of tijdelijke uitval. Het opnieuw proberen van een verzoek dat is geweigerd vanwege ongeldige authenticatie of incorrecte parameters, vertraagt alleen het falen terwijl het aantal oproepen vermenigvuldigt. Daarom filtert de onderstaande code expliciet op fouten: de filtering doet het werk, terwijl backoff slechts de beleefdheid is die u de externe service verschuldigd bent.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Opnieuw proberen met exponentiële backoff en 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:
# Datafout: niet opnieuw proberen
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
})
}
Time-outs per functie
Eén enkele time-out voor alle functies is altijd verkeerd geconfigureerd: te kort, en het killt zware verwerking; te lang, en u laat de gebruiker wachten op een simpele cache-lookup. Baseer elke waarde op waargenomen duur onder normale omstandigheden, met een marge, en niet op het slechtst denkbare scenario, wat effectief zou betekenen dat er geen time-out is.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Voert een functie uit met een time-out."""
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) # Standaard 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"
})
}
Fallback tussen functies
Fallback is een afweging, geen reflex: het serveren van zes uur oude cached data is beter dan niets voor een dashboard, en veel slechter dan niets voor een banksaldo. Wanneer u degradeert, zeg dat dan ook—in het resultaat dat naar het model wordt teruggestuurd, zodat het de gebruiker kan waarschuwen in plaats van verouderde data als vers te presenteren.
async def search_product(term: str) -> dict:
"""Zoeken met fallback: primaire API -> cache -> lokale database."""
# Poging 1: Catalogus-API
try:
return await api_catalog.search(term)
except Exception:
pass
# Poging 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
# Poging 3: Lokale 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
De circuit breaker handelt situaties af waar opnieuw proberen niet helpt: een service die langdurig plat ligt. Na N mislukkingen schakelt deze om en geeft direct een fout terug, zonder zelfs maar te proberen, en staat vervolgens af en toe een testverzoek toe om herstel te controleren. Het voordeel is tweeledig: uw gebruikers hoeven niet meer bij elk verzoek op een time-out te wachten, en de worstelende service wordt niet door uw retry-pogingen onder druk gehouden.
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: sta één testpoging toe
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 per externe service
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Volledige robuuste lus
Het volledige patroon brengt de vijf bovenstaande mechanismen samen. Eén voorzorgsmaatregel maakt het echt veilig, en die is makkelijk over het hoofd te zien: beperk het aantal iteraties. Een model dat in een lus een functie aanroept waarvan het het resultaat niet goedkeurt, komt zelden voor, maar zonder een maximum zal het uw budget opbranden tot uitputting toe, en dat is het soort incident dat u pas op de factuur ontdekt.
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"
Belangrijkste punten
- Geef altijd een
function_call_outputterug, zelfs bij een fout - Structureer fouten als JSON zodat het model ze kan gebruiken
- Probeer alleen tijdelijke fouten opnieuw met exponentiële backoff
- Implementeer fallbacks tussen databronnen
- Gebruik een circuit breaker om falende services te beschermen