Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Foutafhandeling en fallbacks

Les 4 van 20 Ontwikkelaar
Op deze pagina
  1. Foutafhandeling en fallbacks
  2. Fouten terugsturen naar het model
  3. Opnieuw proberen met exponentiële backoff
  4. Time-outs per functie
  5. Fallback tussen functies
  6. Circuit breaker
  7. Volledige robuuste lus
  8. Belangrijkste punten

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_output terug, 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