from typing import Callable, Dict

# 利用可能なツールを定義
tools: Dict[str, Callable] = {
    "search": lambda query: search_web(query),
    "calculate": lambda expr: eval_math(expr),
    "lookup": lambda term: lookup_wikipedia(term),
}

def execute_action(action: str, input: str) -> str:
    """適切なツールを使用してアクションを実行する"""
    if action in tools:
        return tools[action](input)
    return f"Unknown action: {action}"

REACT_PROMPT = """利用可能なツールを使用して以下の質問に答えてください。

利用可能なツール：
- search[query]: ウェブで情報を検索する
- calculate[expression]: 数式を評価する
- lookup[term]: Wikipediaで用語を調べる
- finish[answer]: 最終的な答えを提供する

常に以下の形式を使用してください：
Thought: <次に何をするかについての推論>
Action: <tool_name>[<input>]

観察を受け取った後は、別のThought/Actionを続けるか、finishしてください。

質問: {question}

{history}
Thought:"""

from openai import OpenAI
import re

client = OpenAI()

def parse_action(response: str) -> tuple:
    """モデルの応答からアクションと入力を解析する"""
    match = re.search(r'Action:\s*(\w+)\[(.*?)\]', response)
    if match:
        return match.group(1), match.group(2)
    return None, None

def react_agent(question: str, max_steps: int = 10) -> str:
    """完了するまでReActループを実行する"""
    history = ""

    for step in range(max_steps):
        # 次の思考とアクションを生成
        prompt = REACT_PROMPT.format(question=question, history=history)

        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0,
            stop=["Observation:"]
        )

        output = response.choices[0].message.content
        history += output + "\n"

        # アクションを解析して実行
        action, action_input = parse_action(output)

        if action == "finish":
            return action_input

        if action:
            observation = execute_action(action, action_input)
            history += f"Observation: {observation}\n"
        else:
            history += "Observation: Could not parse action. Try again.\n"

    return "Max steps reached without conclusion"

from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool
from langchain_openai import ChatOpenAI
from langchain import hub

# ツールを定義
tools = [
    Tool(
        name="Search",
        func=search_web,
        description="最新情報をウェブで検索する"
    ),
    Tool(
        name="Calculator",
        func=eval_math,
        description="数学計算に役立つ"
    ),
]

# hubからReActプロンプトを取得
prompt = hub.pull("hwchase17/react")

# エージェントを作成
llm = ChatOpenAI(model="gpt-4", temperature=0)
agent = create_react_agent(llm, tools, prompt)

# エグゼキューターを作成
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=10,
    handle_parsing_errors=True
)

# 実行
result = agent_executor.invoke({"input": "What is the population of Tokyo times 2?"})
print(result["output"])

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True
)

def react_with_recovery(question: str) -> str:
    """エラー回復機能付きReActエージェント"""
    history = ""
    errors = 0
    max_errors = 3

    for step in range(max_steps):
        try:
            # ... 通常のReActループ
            pass
        except Exception as e:
            errors += 1
            history += f"Observation: Error occurred: {str(e)}. Trying alternative approach.\n"

            if errors >= max_errors:
                return "Too many errors, unable to complete task"

    return result

from pydantic import BaseModel

class ReActStep(BaseModel):
    thought: str
    action: str
    action_input: str
    observation: str | None = None

class ReActTrace(BaseModel):
    question: str
    steps: list[ReActStep]
    final_answer: str