Реактивный цикл агента

def think(messages: list, tools: list, system: str) -> tuple[str, list]:
    """
    Фаза THINK: отправить контекст в LLM, получить решение.
    Возвращает: (stop_reason, response_content)
    """
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=4096,
        system=system,
        tools=tools,
        messages=messages,
    )

    # Добавляем ответ ассистента в историю (это тоже часть THINK)
    messages.append({"role": "assistant", "content": response.content})

    return response.stop_reason, response.content


# Использование в цикле:
stop_reason, content = think(messages, tools, system_prompt)

if stop_reason == "end_turn":
    # Финальный ответ — извлекаем текст и выходим
    return next(b.text for b in content if hasattr(b, "text"))

elif stop_reason == "tool_use":
    # Есть запросы на инструменты — переходим в ACT
    tool_calls = [b for b in content if b.type == "tool_use"]
    # ...

else:
    # max_tokens, stop_sequence или неизвестная причина
    raise RuntimeError(f"Unexpected stop_reason: {stop_reason}")

def act(tool_calls: list, tool_registry: dict) -> list[dict]:
    """
    Фаза ACT: выполнить все запрошенные инструменты.
    Возвращает список tool_result для фазы OBSERVE.
    """
    results = []

    for call in tool_calls:
        fn = tool_registry.get(call.name)

        if fn is None:
            # Инструмент не зарегистрирован — сообщаем LLM, не падаем
            result_content = f"Ошибка: инструмент '{call.name}' не найден."
            is_error = True
        else:
            try:
                result_content = fn(**call.input)
                is_error = False
            except Exception as e:
                # Инструмент упал — передаём ошибку в контекст как строку
                result_content = f"Ошибка выполнения {call.name}: {e}"
                is_error = True

        results.append({
            "type": "tool_result",
            "tool_use_id": call.id,      # связываем результат с вызовом
            "content": str(result_content),
            # "is_error": is_error,       # опционально: подсвечивает ошибку для LLM
        })

    return results

def observe(messages: list, tool_results: list) -> None:
    """
    Фаза OBSERVE: добавить результаты инструментов в контекст.
    Все результаты одной итерации — одно сообщение user.
    """
    messages.append({
        "role": "user",
        "content": tool_results,   # список tool_result-блоков
    })

    # После observe — iteration += 1, и цикл начинается заново с THINK

import anthropic
import logging
import time

logger = logging.getLogger(__name__)
client = anthropic.Anthropic()


def run_agent(
    user_message: str,
    tools: list,
    tool_registry: dict,
    system_prompt: str,
    max_iterations: int = 15,
    timeout_seconds: float = 120.0,
) -> str:
    """
    Реактивный цикл агента с полной обработкой выходов.
    """
    messages = [{"role": "user", "content": user_message}]
    start_time = time.monotonic()

    for iteration in range(max_iterations):

        # ── Проверка таймаута ────────────────────────────────
        elapsed = time.monotonic() - start_time
        if elapsed > timeout_seconds:
            logger.warning(f"Agent timeout after {elapsed:.1f}s ({iteration} iterations)")
            return "Превышено время ожидания. Попробуй сформулировать задачу короче."

        logger.debug(f"[iter {iteration}] context size: {len(messages)} messages")

        # ── THINK ────────────────────────────────────────────
        try:
            response = client.messages.create(
                model="claude-opus-4-6",
                max_tokens=4096,
                system=system_prompt,
                tools=tools,
                messages=messages,
            )
        except anthropic.APIError as e:
            logger.error(f"LLM API error: {e}")
            raise

        messages.append({"role": "assistant", "content": response.content})
        logger.debug(f"[iter {iteration}] stop_reason={response.stop_reason}")

        # ── Выход: финальный ответ ───────────────────────────
        if response.stop_reason == "end_turn":
            text = next(
                (b.text for b in response.content if hasattr(b, "text")), ""
            )
            logger.info(f"Agent done in {iteration + 1} iterations, {elapsed:.1f}s")
            return text

        # ── Выход: переполнение контекста ────────────────────
        if response.stop_reason == "max_tokens":
            logger.warning("Context window full, returning partial result")
            return "Задача слишком объёмная. Разбей её на части."

        # ── Неизвестный stop_reason ──────────────────────────
        if response.stop_reason != "tool_use":
            raise RuntimeError(f"Unexpected stop_reason: {response.stop_reason!r}")

        # ── ACT: выполняем инструменты ───────────────────────
        tool_calls = [b for b in response.content if b.type == "tool_use"]
        tool_results = []

        for call in tool_calls:
            logger.debug(f"[iter {iteration}] calling {call.name}({call.input})")
            fn = tool_registry.get(call.name)

            try:
                result = fn(**call.input) if fn else f"Инструмент '{call.name}' не найден"
                is_error = fn is None
            except Exception as e:
                result = f"Ошибка {call.name}: {e}"
                is_error = True
                logger.warning(f"Tool {call.name} failed: {e}")

            tool_results.append({
                "type": "tool_result",
                "tool_use_id": call.id,
                "content": str(result),
            })

        # ── OBSERVE: добавляем результаты в контекст ─────────
        messages.append({"role": "user", "content": tool_results})

    # ── Выход: лимит итераций ────────────────────────────────
    logger.warning(f"Max iterations ({max_iterations}) reached")
    return "Задача не завершена за допустимое число шагов."

def debug_iteration(iteration: int, stop_reason: str, content: list) -> None:
    """Выводит сводку одной итерации цикла."""
    print(f"\n{'─'*50}")
    print(f"Итерация {iteration} │ stop_reason: {stop_reason}")

    for block in content:
        if hasattr(block, "text") and block.text:
            preview = block.text[:120].replace("\n", " ")
            print(f"  [text]     {preview}{'…' if len(block.text) > 120 else ''}")
        elif block.type == "tool_use":
            print(f"  [tool_use] {block.name}({block.input})")

# Вставляем в цикл сразу после вызова LLM:
debug_iteration(iteration, response.stop_reason, response.content)