第 4 章：手写 ReAct 循环

Thought: 我需要先计算括号里的加法
Action: calculator(128 + 256)
Observation: 384
Thought: 然后乘以 2
Action: calculator(384 * 2)
Observation: 768
Thought: 最后减去 100
Action: calculator(768 - 100)
Observation: 668
Final Answer: 668

while not done and steps < max_steps:
    thought_action = llm.generate(prompt)
    if "Final Answer" in thought_action:
        return extract_answer(thought_action)
    tool_name, args = parse_action(thought_action)
    observation = execute_tool(tool_name, args)
    prompt += f"\nObservation: {observation}"

import re

SYSTEM_PROMPT = """You are a helpful assistant that solves problems step by step.
You must follow this format exactly:

Thought: describe your reasoning
Action: tool_name(arg1, arg2, ...)
Observation: the result of the action (provided by the system)
...
Final Answer: the final answer

Available tools:
- calculator(expression: str) - evaluates a Python arithmetic expression safely
- finish(answer: str) - use when you have the final answer
"""


def calculator(expression: str) -> str:
    allowed = set("0123456789+-*/(). ")
    if not all(c in allowed for c in expression):
        return "Error: invalid characters"
    try:
        return str(eval(expression))
    except Exception as exc:
        return f"Error: {exc}"


def parse_action(text: str):
    match = re.search(r"Action:\s*(\w+)\((.*)\)", text)
    if not match:
        return None
    tool_name = match.group(1)
    args = [a.strip().strip('"').strip("'") for a in match.group(2).split(",") if a.strip()]
    return tool_name, args


def run_react(client, question: str, max_steps: int = 10) -> str:
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": question},
    ]

    for step in range(max_steps):
        response = client.chat_completion(messages=messages, temperature=0.0, max_tokens=200)
        text = response["choices"][0]["message"]["content"]
        print(f"\n--- Step {step + 1} ---")
        print(text)

        if "Final Answer:" in text:
            return text.split("Final Answer:", 1)[1].strip()

        parsed = parse_action(text)
        if not parsed:
            observation = "Observation: I did not understand the action. Please use 'Action: tool_name(args)'."
        else:
            tool_name, args = parsed
            if tool_name == "calculator" and args:
                result = calculator(args[0])
                observation = f"Observation: {result}"
            else:
                observation = f"Observation: unknown tool '{tool_name}'"

        print(observation)
        messages.append({"role": "assistant", "content": text})
        messages.append({"role": "user", "content": observation})

    return "Reached max steps without final answer."

You must use this format:
Thought: <your reasoning>
Action: <tool_name>(<args>)
Observation: <result will be inserted by system>
...
Final Answer: <final answer>

Available tools:
- search(query: str) -> list of documents
- calculator(expression: str) -> result
- finish(answer: str) -> ends the task

async function runReAct(client: OpenAIClient, question: string, maxSteps = 10) {
  const messages: ChatMessage[] = [
    { role: "system", content: SYSTEM_PROMPT },
    { role: "user", content: question },
  ];

  for (let step = 0; step < maxSteps; step++) {
    const response = await client.chatCompletion({ messages, temperature: 0, max_tokens: 200 });
    const text = response.choices[0].message.content ?? "";

    if (text.includes("Final Answer:")) {
      return text.split("Final Answer:")[1].trim();
    }

    const observation = executeTool(text);
    messages.push({ role: "assistant", content: text });
    messages.push({ role: "user", content: observation });
  }
  return "Reached max steps";
}

for step := 0; step < maxSteps; step++ {
    resp, _ := client.ChatCompletion(openaiclient.ChatCompletionRequest{
        Messages: messages,
        Temperature: floatPtr(0),
        MaxTokens: intPtr(200),
    })
    text := resp.Choices[0].Message.Content
    if strings.Contains(text, "Final Answer:") {
        return strings.SplitN(text, "Final Answer:", 2)[1]
    }
    observation := executeTool(text)
    messages = append(messages,
        openaiclient.Message{Role: "assistant", Content: text},
        openaiclient.Message{Role: "user", Content: observation},
    )
}