Capstone: agent Python completo com Claude SDK

# src/schemas.py
from pydantic import BaseModel, Field
from typing import Literal

class TriageInput(BaseModel):
    text: str = Field(min_length=10, max_length=5000)
    client_id: str

class TicketCategory(BaseModel):
    kind: Literal["bug", "feature", "question"]
    priority: Literal["low", "med", "high"]
    summary: str = Field(max_length=200)

# src/tools.py
from anthropic import Anthropic

async def create_linear_ticket(title: str, description: str, team: str) -> str:
    """Cria ticket no Linear e retorna url."""
    ...

async def notify_slack(channel: str, text: str) -> None:
    """Envia mensagem no Slack."""
    ...

TOOLS = [
    {
        "name": "create_linear_ticket",
        "description": "Create a Linear issue...",
        "input_schema": TicketInput.model_json_schema(),
    },
    {
        "name": "notify_slack",
        "description": "Send Slack message...",
        "input_schema": SlackInput.model_json_schema(),
    },
]

# src/agent.py
async def run_agent(input: TriageInput) -> TicketCategory:
    client = Anthropic()
    messages = [{"role": "user", "content": input.text}]
    for _ in range(5):  # max_steps
        resp = client.messages.create(
            model="claude-sonnet-4",
            max_tokens=1024,
            tools=TOOLS,
            messages=messages,
        )
        if resp.stop_reason == "tool_use":
            for block in resp.content:
                if block.type == "tool_use":
                    result = await execute_tool(block.name, block.input)
                    messages.append({"role": "assistant", "content": resp.content})
                    messages.append({
                        "role": "user",
                        "content": [{
                            "type": "tool_result",
                            "tool_use_id": block.id,
                            "content": result,
                        }],
                    })
            continue
        # Final answer
        return TicketCategory.model_validate_json(resp.content[0].text)
    raise Exception("max steps reached")

# src/main.py
from fastapi import FastAPI

app = FastAPI()

@app.post("/triage")
async def triage(input: TriageInput) -> TicketCategory:
    return await run_agent(input)

from langfuse.decorators import observe

@observe(name="triage_agent")
async def run_agent(input: TriageInput) -> TicketCategory:
    # cada API call é span-automático
    ...

# Langfuse UI mostra:
# - trace por request
# - cada turn do loop como span
# - tool calls com input/output
# - latency, tokens, cost

# Mock do LLM — VCR ou Anthropic replay
import pytest
from unittest.mock import patch

@pytest.mark.asyncio
async def test_agent_classifies_bug():
    with patch("src.agent.Anthropic") as mock:
        mock.return_value.messages.create.return_value = ...  # canned response
        result = await run_agent(TriageInput(text="app crasha ao abrir", client_id="c1"))
        assert result.kind == "bug"