Hantering av fel och reservlösningar
På denna sida
Hantering av fel och reservlösningar
Funktionsanrop introducerar en utmaning som klassisk kod inte ställs inför: när din funktion misslyckas finns det **två} mottagare för detta fel. Din applikation, som vanligt – och modellen, som väntar på ett resultat för att kunna fortsätta. Att glömma detta skapar den mest förbryllande symptomen i produktion: en konversation som stannar helt utan förklaring, eftersom ett undantag sväljdes på serversidan och modellen fortfarande väntar.
Regeln som följer strukturerar hela denna lektion: returnera alltid ett function_call_output, även vid fel. En modell som informeras om att ett API inte är tillgängligt kan föreslå ett alternativ, be om förtydligande eller förklara situationen för användaren. En modell som inte får något svar kan ingenting göra.
Returnera fel till modellen
Formatet på felet är lika viktigt som att skicka det. Ett naket “Fel” lär modellen ingenting; ett JSON-objekt som särskiljer feltypen, huruvida det är övergående eller permanent, och nästa steg låter modellen besluta. Detta är kontraintuitivt: du skriver felmeddelanden som är avsedda att läsas av en resonerande maskin, inte loggas för människor.
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)
})
}
Försök igen med exponentiell backoff
Att försöka igen är bara meningsfullt för problem som kan lösas vid ett andra försök: nätverksavbrott, statuskod 429 eller tillfälliga driftstopp. Att försöka igen med en begäran som avvisats på grund av ogiltig autentisering eller felaktiga parametrar fördröjer bara misslyckandet samtidigt som antalet anrop multipliceras. Därför filtrerar koden nedan explicit fel – filtreringen gör jobbet, medan backoff bara är den artighet du skyldar den externa tjänsten.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Försök igen med exponentiell backoff och 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:
# Datafel: försök inte 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
})
}
Tidsgränser per funktion
En enda tidsgräns för alla funktioner är alltid felkonfigurerad: för kort, och den dödar tung bearbetning; för lång, och den får användaren att vänta på en enkel cache-uppslagning. Basera varje värde på observerade varaktigheter under normala förhållanden, med en marginal – inte på det värsta tänkbara fallet, vilket i praktiken skulle innebära att du inte har någon tidsgräns alls.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Kör en funktion med en tidsgräns."""
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"
})
}
Reservlösning mellan funktioner
Reservlösning är en avvägning, inte en reflex: att servera sex timmar gammal cachad data är bättre än ingenting för en instrumentpanel, och betydligt sämre än ingenting för ett banksaldo. När du försämrar kvaliteten, säg det – i resultatet som returneras till modellen, så att den kan varna användaren istället för att presentera inaktuella data som färska.
async def search_product(term: str) -> dict:
"""Sök med reservlösning: primärt API -> cache -> lokal databas."""
# Försök 1: Katalog-API
try:
return await api_catalog.search(term)
except Exception:
pass
# Försök 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
# Försök 3: Lokal SQLite-databas
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"
}
Strömbrytare (Circuit Breaker)
Strömbrytaren hanterar det som försök igen inte kan: en tjänst som är nere under längre tid. Efter N misslyckanden löser den ut och returnerar ett fel omedelbart, utan att ens försöka, och tillåter sedan då och då en testbegäran för att kontrollera återhämtning. Vinsten är twofold – dina användare slutar vänta på en tidsgräns för varje begäran, och den kämpande tjänsten hålls inte nere av dina försök.
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"
# En strömbrytare per extern tjänst
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Komplett robust loop
Det fullständiga mönstret sammanför de fem mekanismerna ovan. En försiktighetsåtgärd gör det verkligen säkert, och den är lätt att missa: begränsa antalet iterationer. En modell som loopar och anropar en funktion vars resultat den ogillar är sällsynt, men utan ett tak kommer den att bränna igenom din budget tills utmattning – och det är den typen av incident du upptäcker på fakturan.
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"
Viktiga punkter
- Returnera alltid ett
function_call_output, även vid fel - Strukturera fel som JSON så att modellen kan använda dem
- Försök bara igen vid övergående fel med exponentiell backoff
- Implementera reservlösningar mellan datakällor
- Använd en strömbrytare för att skydda tjänster som misslyckas