Премини към основното съдържание
Български— Изберете език
Меню

Обработка на грешки и резервни механизми

Урок 4 от 20 Програмист
На тази страница
  1. Обработка на грешки и резервни механизми
  2. Връщане на грешки към модела
  3. Повторни опити с експоненциално забавяне
  4. Таймаути за всяка функция
  5. Резервен механизъм между функции
  6. Прекъсвач на веригата (Circuit Breaker)
  7. Пълен устойчив цикъл
  8. Ключови изводи

Обработка на грешки и резервни механизми

Извикването на функции въвежда предизвикателство, с което класическият код не се сблъсква: когато функцията Ви се провали, има два получателя на тази грешка. Вашето приложение, както обикновено – и моделът, който чака резултат, за да продължи. Пропускането на този факт създава най-объркващия симптом в продукционна среда: разговор, който спира внезапно без обяснение, защото изключението е погълнато от сървърната страна, а моделът все още чака.

Правилото, което следва, структурира целия този урок: винаги връщайте function_call_output, дори при неуспех. Модел, информиран, че даден API е недостъпен, може да предложи алтернатива, да поиска изясняване или да обясни ситуацията на потребителя. Модел, който не получава нищо, не може да направи нищо.

Връщане на грешки към модела

Форматът на грешката е също толкова важен, колкото и самото ѝ изпращане. Гола дума „Грешка“ не учи модела на нищо; JSON обект, който разграничава типа на грешката, дали е временна или постоянна, и следващите стъпки, позволява на модела да вземе решение. Това е контраинтуитивно: Вие пишете съобщения за грешки, предназначени да бъдат четени от машина за разсъждение, а не за логване за хора.

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

Повторни опити с експоненциално забавяне

Повторните опити имат смисъл само за проблеми, които могат да се разрешат при втория опит: прекъсвания на мрежата, статус кодове 429 или временни прекъсвания на услугата. Повторният опит за заявка, отхвърлена поради невалидна автентикация или неправилни параметри, само забавя провала, като същевременно умножава броя на обажданията. Ето защо кодът по-долу изрично филтрира грешките – филтрирането върши работата, докато експоненциалното забавяне е просто любезността, която дължите на отдалечената услуга.

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

Таймаути за всяка функция

Единен таймаут за всички функции винаги е конфигуриран неправилно: твърде кратък е и убива тежката обработка; твърде дълъг е и кара потребителя да чака за просто търсене в кеша. Базирайте всяка стойност на наблюдаваните продължителности при нормални условия, с марж – не на най-лошия въобразим случай, което ефективно би означавало липса на таймаут.

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

Резервен механизъм между функции

Резервният механизъм е компромис, а не рефлекс: предоставянето на кеширани данни на шест часа е по-добре от нищо за табло с показатели и много по-зле от нищо за банков баланс. Когато влошавате качеството, кажете го – в резултата, върнат на модела, за да може той да предупреди потребителя, вместо да представя остарели данни като актуални.

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

Прекъсвач на веригата (Circuit Breaker)

Прекъсвачът на веригата се справя с онова, което повторните опити не могат: услуга, която е спряла за дълго време. След N неуспеха той се задейства и връща грешка незабавно, без дори да опитва, след което от време на време позволява тестова заявка, за да провери за възстановяване. Ползата е двойна – потребителите Ви спират да чакат таймаут при всяка заявка, а затруднената услуга не се държи в блокирано състояние от Вашите повторни опити.

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

Пълен устойчив цикъл

Пълният шаблон обединява петте механизма по-горе. Една предпазна мярка го прави наистина безопасен и лесно се пропуска: ограничете броя на итерациите. Модел, който влиза в цикъл, извиквайки функция, чийто резултат не му харесва, е рядък, но без таван той ще изразходи бюджета Ви до изчерпване – а това е вид инцидент, който откривате във фактурата.

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"

Ключови изводи

  • Винаги връщайте function_call_output, дори при грешка
  • Структурирайте грешките като JSON, за да може моделът да ги използва
  • Правете повторни опити само за временни грешки с експоненциално забавяне
  • Внедрете резервни механизми между източниците на данни
  • Използвайте прекъсвач на веригата, за да защитите отказващите услуги