Agent Patterns: ReAct, Reflexion e Tree of Thoughts

# ReAct canônico com tool_use do Anthropic (estrutura idêntica em OpenAI)
from anthropic import Anthropic

client = Anthropic()

TOOLS = [
    {
        "name": "get_price",
        "description": "Retorna preço atual de um ticker.",
        "input_schema": {
            "type": "object",
            "properties": {"ticker": {"type": "string"}},
            "required": ["ticker"],
        },
    },
    {
        "name": "hist_price",
        "description": "Retorna histórico de preços.",
        "input_schema": {
            "type": "object",
            "properties": {
                "ticker": {"type": "string"},
                "days":   {"type": "integer"},
            },
            "required": ["ticker", "days"],
        },
    },
]

def react_agent(user_query: str, max_steps: int = 8) -> str:
    messages = [{"role": "user", "content": user_query}]
    for _ in range(max_steps):
        r = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            tools=TOOLS,
            messages=messages,
        )
        if r.stop_reason == "end_turn":
            return r.content[0].text           # resposta final
        if r.stop_reason == "tool_use":
            tool_block = next(b for b in r.content if b.type == "tool_use")
            result = execute_tool(tool_block.name, tool_block.input)
            messages.append({"role": "assistant", "content": r.content})
            messages.append({
                "role": "user",
                "content": [{
                    "type": "tool_result",
                    "tool_use_id": tool_block.id,
                    "content": str(result),
                }],
            })
    raise RuntimeError("max_steps atingido — agent não convergiu")

# Reflexion — versão didática com oracle (rodar_testes)
def reflexion_solve(task: str, oracle, max_attempts: int = 3) -> str:
    memory: list[str] = []          # lições aprendidas entre tentativas
    for attempt in range(max_attempts):
        prompt = (
            f"Tarefa: {task}\n\n"
            f"Lições de tentativas anteriores:\n" +
            "\n".join(f"- {m}" for m in memory) +
            "\n\nProduza solução."
        )
        solution = llm_call(prompt)
        passed, feedback = oracle(solution)      # ex: rodar testes
        if passed:
            return solution

        # Reflexão: LLM critica a tentativa à luz do feedback
        reflection = llm_call(
            f"Tarefa: {task}\nSolução tentada: {solution}\n"
            f"Feedback do oracle: {feedback}\n\n"
            "Em 1-2 frases, o que deu errado e o que fazer diferente na próxima tentativa?"
        )
        memory.append(reflection)
    return solution   # última tentativa, mesmo se falhou

# Router barato com Haiku 4.5 (ou gpt-4o-mini) decidindo rota
from anthropic import Anthropic
client = Anthropic()

ROUTES = ["faq", "search_rag", "math_code", "book_meeting", "refuse"]

def route(query: str) -> str:
    r = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=30,
        system=(
            "Classifique a intenção do usuário em UMA das rotas: " +
            ", ".join(ROUTES) +
            ". Responda apenas com a palavra da rota."
        ),
        messages=[{"role": "user", "content": query}],
    )
    choice = r.content[0].text.strip().lower()
    return choice if choice in ROUTES else "search_rag"

# Dispatch
def handle(query: str) -> str:
    route_name = route(query)
    match route_name:
        case "faq":          return answer_from_faq_cache(query)
        case "search_rag":   return rag_pipeline(query)
        case "math_code":    return code_agent(query)
        case "book_meeting": return tool_chain_booking(query)
        case "refuse":       return "Não posso ajudar com isso."