Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Klaidų apdorojimas ir atsarginiai variantai

Paskaita 4 iš 20 Kūrėjas
Šiame puslapyje
  1. Klaidų apdorojimas ir atsarginiai variantai
  2. Klaidų grąžinimas modeliui
  3. Kartojimas su eksponentine delsa
  4. Atskiros funkcijų laiko limitai
  5. Perėjimas prie atsarginių funkcijų
  6. Grandininis jungiklis (Circuit Breaker)
  7. Pilnas patikimas ciklas
  8. Svarbiausi punktai

Klaidų apdorojimas ir atsarginiai variantai

Funkcijų kvietimas kelia iššūkį, su kuriuo klasikinis kodas nesusiduria: kai tavo funkcija nepavyksta, tą klaidą gauna du gavėjai. Tavo programa, kaip įprasta, ir modelis, kuris laukia rezultato, kad galėtų tęsti darbą. Pamiršus tai, gamyboje atsiranda pats keisčiausias simptomas: pokalbis staiga nutrūksta be jokio paaiškinimo, nes išimtis buvo „nuryta“ serverio pusėje, o modelis vis dar laukia.

Taisyklė, kuri struktūrizuoja visą šią pamoką, skamba taip: visada grąžinkite function_call_output, net ir įvykus klaidai. Modelis, informuotas, kad API nepasiekiamas, gali pasiūlyti alternatyvą, paprašyti patikslinimo arba paaiškinti situaciją vartotojui. Modelis, kuris nieko negauna, negali nieko padaryti.

Klaidų grąžinimas modeliui

Klaidos formatas yra toks pat svarbus kaip ir jos siuntimas. Paprastas „Error“ modeliui nieko nepasako; JSON objektas, kuris atskiria klaidos tipą, nurodo, ar ji laikina, ar nuolatinė, ir numato tolesnius veiksmus, leidžia modeliui priimti sprendimą. Tai gali atrodyti prieštaraujama intuicijai: rašote klaidų pranešimus, skirtus skaityti samprotuojančiai mašinai, o ne fiksuoti žmonių žurnalams.

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)
            })
        }

Kartojimas su eksponentine delsa

Kartojimas (retry) turi prasmę tik toms problemoms, kurios gali išsispręsti antruoju bandymu: tinklo sutrikimai, 429 statuso kodai arba laikini neveikumai. Kartoti užklausą, atmestą dėl neteisingo autentifikavimo ar klaidingų parametrų, reiškia tik atidėti nesėkmę ir dauginti kvietimų skaičių. Štai kodėl žemiau esantis kodas aiškiai filtruoja klaidas – filtravimas atlieka darbą, o delsa yra tik mandagumas, kurį skolingi nuotolinei tarnybai.

import time
import random

def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
    """Kartojimas su eksponentine delsa ir trikdžiu (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:
            # Duomenų klaida: nekartoti
            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
            })
        }

Atskiros funkcijų laiko limitai

Vienas visiems funkcijoms taikomas laiko limitas visada yra neteisingai nustatytas: per trumpas – jis nutraukia sunkius apdorojimus; per ilgas – verčia vartotoją laukti paprasto podėlio (cache) užklausos rezultato. Kiekvieną reikšmę grindkite stebima trukme įprastomis sąlygomis, palikdami atsargą – o ne blogiausiu įmanomu atveju, kuris iš esmės reikštų, kad laiko limito nėra вовсе.

import signal
from functools import wraps

TIMEOUTS = {
    "search_client": 5,
    "generate_report": 30,
    "send_email": 10,
}

def with_timeout(func, timeout_seconds):
    """Vydo funkciją su laiko limitu."""
    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)  # Pagal nutylėjimą 10 s

    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"
            })
        }

Perėjimas prie atsarginių funkcijų

Atsarginis variantas (fallback) yra kompromisas, o ne refleksas: šešių valandų senumo podėlio duomenų pateikimas geriau nei nieko informaciniam skydeliui, tačiau daug blogiau nei nieko banko sąskaitos likučiui. Kai degraduojate, tai įvardykite – rezultate, grąžinamame modeliui, kad jis galėtų įspėti vartotoją, o ne pateikti pasenusių duomenų kaip naujų.

async def search_product(term: str) -> dict:
    """Paieška su atsarginiu variantu: pagrindinis API -> podėlis -> vietinė duomenų bazė."""
    # 1 bandymas: Katalogo API
    try:
        return await api_catalog.search(term)
    except Exception:
        pass

    # 2 bandymas: Redis podėlis
    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

    # 3 bandymas: Vietinė SQLite duomenų bazė
    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"
    }

Grandininis jungiklis (Circuit Breaker)

Grandininis jungiklis tvarko tai, ko kartojimas negali: ilgai neveikiančią tarnybą. Po N nesėkmių jis „išmuša“ ir iškart grąžina klaidą net nebandydamas, o tada retkarčiais leidžia praeiti bandomajai užklausai, kad patikrintų, ar sistema atsistatė. Naudą gaunate dvigubą – jūsų vartotojai nustoja laukti laiko limito kiekvienoje užklausoje, o vargstanti tarnyba nėra dar labiau apkraunama jūsų kartojimais.

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"

# Vienas grandininis jungiklis kiekvienai išorinei tarnybai
breakers = {
    "weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
    "catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}

Pilnas patikimas ciklas

Visas šis šablonas sujungia penkis aukščiau išvardintus mechanizmus. Viena atsargumo priemonė daro jį tikrai saugiu, ir ją lengva praleisti: apribokite iteracijų skaičių. Modelis, kuris sukasi cikle kviesdamas funkciją, kurios rezultato jam nepakanka, yra retas atvejis, tačiau be viršutinės ribos jis išeikvos jūsų biudžetą iki visiško išsekimo – o tokio incidento paprastai nepastebite, kol negaunate sąskaitos.

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"

Svarbiausi punktai

  • Visada grąžinkite function_call_output, net ir įvykus klaidai
  • Strukturinkite klaidas kaip JSON, kad modelis galėtų jas panaudoti
  • Kartokite tik laikinas klaidas naudodami eksponentinę delsą
  • Įgyvendinkite perėjimą prie atsarginių duomenų šaltinių
  • Naudokite grandininį jungiklis (circuit breaker) apsaugoti neveikiančioms tarnyboms