Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Rukovanje greškama i rezervne opcije

Lekcija 4 od 20 Programer
Na ovoj stranici
  1. Rukovanje greškama i rezervne opcije
  2. Vraćanje grešaka modelu
  3. Ponovni pokušaj s eksponencijalnim odmakom
  4. Isteci po funkcijama
  5. Rezervne opcije između funkcija
  6. Osigurač kruga (Circuit Breaker)
  7. Potpuna robusna petlja
  8. Ključne točke

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