# agent/executor.py
import json
from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeout
from .tools import TOOLS

_POOL = ThreadPoolExecutor(max_workers=8)
MAX_RESULT_CHARS = 8_000   # tool output is most of your context bill; cap it

def _validate(schema: dict, args: dict) -> None:
    missing = [k for k in schema.get("required", []) if k not in args]
    unknown = sorted(set(args) - set(schema.get("properties", {})))
    if missing:
        raise ValueError(f"Missing required argument(s): {missing}")
    if unknown:
        raise ValueError(f"Unknown argument(s): {unknown}")

def run_tool(block) -> dict:
    """Turn one tool_use block into one tool_result block. Never raises."""
    def error(msg: str) -> dict:
        return {"type": "tool_result", "tool_use_id": block.id, "content": msg, "is_error": True}

    tool = TOOLS.get(block.name)
    if tool is None:
        return error(f"Unknown tool {block.name!r}. Available: {sorted(TOOLS)}")
    try:
        _validate(tool.input_schema, block.input)
        output = _POOL.submit(tool.handler, **block.input).result(timeout=tool.timeout_s)
    except FutureTimeout:
        return error(f"{tool.name} timed out after {tool.timeout_s}s. Retry at most once.")
    except Exception as exc:
        return error(f"{type(exc).__name__}: {exc}")

    text = json.dumps(output, default=str)
    if len(text) > MAX_RESULT_CHARS:
        text = text[:MAX_RESULT_CHARS] + f" ...[truncated {len(text) - MAX_RESULT_CHARS} chars]"
    return {"type": "tool_result", "tool_use_id": block.id, "content": text}

# agent/loop.py
import logging
from dataclasses import dataclass, field
import anthropic
from .tools import api_tools
from .executor import run_tool

log = logging.getLogger("agent")
MODEL = "claude-sonnet-5-5"
SYSTEM = ("You are an order-support assistant. Use tools for any order facts; never guess. "
          "If a tool returns an error, fix your input once or tell the user what failed.")
MAX_STEPS = 8

@dataclass
class Result:
    status: str          # done | max_steps | truncated | model_unavailable | refusal | ...
    text: str
    steps: int
    messages: list = field(repr=False)

def _text(resp) -> str:
    return "".join(b.text for b in resp.content if b.type == "text")

def run_agent(user_msg: str, client=None, model: str = MODEL) -> Result:
    client = client or anthropic.Anthropic(timeout=60.0, max_retries=2)
    messages = [{"role": "user", "content": user_msg}]
    tools = api_tools()          # build once: a stable prefix is cache-friendly
    steps = 0

    while True:
        if steps >= MAX_STEPS:
            return Result("max_steps", "", steps, messages)
        try:
            resp = client.messages.create(model=model, max_tokens=2048, system=SYSTEM,
                                          tools=tools, messages=messages)
        except (anthropic.RateLimitError, anthropic.InternalServerError,
                anthropic.APITimeoutError, anthropic.APIConnectionError) as exc:
            # The SDK already retried these. Degrade; don't stack another retry loop on top.
            log.warning("model unavailable after SDK retries: %s", type(exc).__name__)
            return Result("model_unavailable", "", steps, messages)
        # Any other APIStatusError (400/401/404) is a bug in OUR request: let it raise.

        steps += 1
        log.info("step=%d stop=%s in=%d out=%d", steps, resp.stop_reason,
                 resp.usage.input_tokens, resp.usage.output_tokens)
        messages.append({"role": "assistant", "content": resp.content})   # verbatim

        if resp.stop_reason == "tool_use":
            results = [run_tool(b) for b in resp.content if b.type == "tool_use"]
            messages.append({"role": "user", "content": results})          # tool_results ONLY
            continue
        if resp.stop_reason == "end_turn":
            return Result("done", _text(resp), steps, messages)
        if resp.stop_reason == "max_tokens":
            return Result("truncated", _text(resp), steps, messages)
        return Result(resp.stop_reason, _text(resp), steps, messages)

r = run_agent("Where is order A-1002? It's late -- open a ticket if needed.")
print(r.status, r.steps, "steps")
print(r.text)