M03 Agent 核心架构设计

type AgentState struct {
    Goal        string
    Steps       []Step
    FinalAnswer string
    StartTime   time.Time
}

type Step struct {
    Thought     string
    Action      Action
    Observation string
    Error       error
    Duration    time.Duration
}

type Action struct {
    Tool  string
    Input json.RawMessage
}

type Agent interface {
    Run(ctx context.Context, goal string) (string, error)
    RunStream(ctx context.Context, goal string) (<-chan AgentEvent, error)
}

You are a helpful AI assistant.
You have access to the following tools:
{{range .Tools}}
Tool: {{.Name}}
Description: {{.Description}}
Input Schema: {{.Schema}}
{{end}}

To answer the user's question, you must follow this format EXACTLY:
Thought: [your reasoning about what to do next]
Action: [tool name]
Action Input: [JSON input for the tool]

After receiving a tool result (Observation), you can:
- Continue with another Thought/Action/Action Input cycle
- OR provide the final answer using:
Final Answer: [your answer to the user]

type LLMOutput struct {
    Thought     string
    Action      string
    ActionInput string
    FinalAnswer string
    IsFinal     bool
}

func ParseReActOutput(text string) LLMOutput {
    var out LLMOutput
    if idx := strings.Index(text, "Final Answer:"); idx != -1 {
        out.FinalAnswer = strings.TrimSpace(text[idx+len("Final Answer:"):])
        out.IsFinal = true
        return out
    }

    if m := thoughtRe.FindStringSubmatch(text); len(m) > 1 {
        out.Thought = m[1]
    }
    if m := actionRe.FindStringSubmatch(text); len(m) > 1 {
        out.Action = m[1]
    }
    if m := inputRe.FindStringSubmatch(text); len(m) > 1 {
        out.ActionInput = m[1]
    }
    return out
}

func (a *ReactAgent) Run(ctx context.Context, goal string) (string, error) {
    state := &AgentState{Goal: goal, StartTime: time.Now()}

    for i := 0; i < a.maxSteps; i++ {
        prompt := a.promptBuilder.BuildReActPrompt(state)

        resp, err := a.llm.Complete(ctx, CompletionRequest{
            Model: a.model,
            Messages: []Message{{Role: "user", Content: prompt}},
        })
        if err != nil {
            return "", fmt.Errorf("step %d: %w", i, err)
        }

        output := ParseReActOutput(resp.Content)
        if output.IsFinal {
            return output.FinalAnswer, nil
        }

        obs, toolErr := a.tools.Execute(ctx, output.Action, []byte(output.ActionInput))
        step := Step{
            Thought: output.Thought,
            Action:  Action{Tool: output.Action},
            Observation: obs,
            Error:       toolErr,
        }
        state.Steps = append(state.Steps, step)
    }

    return "", ErrMaxStepsReached
}

type ToolDefinition struct {
    Type     string      `json:"type"`
    Function FunctionDef `json:"function"`
}

type FunctionDef struct {
    Name        string          `json:"name"`
    Description string          `json:"description"`
    Parameters  json.RawMessage `json:"parameters"`
}

func (a *FunctionCallingAgent) processToolCalls(ctx context.Context, calls []ToolCall) ([]Message, error) {
    var results []Message
    for _, call := range calls {
        result, err := a.tools.Execute(ctx, call.Function.Name, []byte(call.Function.Arguments))
        resultStr := result
        if err != nil {
            resultStr = "Error: " + err.Error()
        }

        results = append(results, Message{
            Role:       "tool",
            Content:    resultStr,
            ToolCallID: call.ID,
        })
    }
    return results, nil
}

type Plan struct {
    Steps []PlanStep
}

type PlanStep struct {
    ID        int
    Task      string
    DependsOn []int
    Result    string
    Done      bool
}

type PlanAndExecuteAgent struct {
    planner  Planner
    executor Executor
}

func (a *PlanAndExecuteAgent) Run(ctx context.Context, goal string) (string, error) {
    plan, err := a.planner.Plan(ctx, goal)
    if err != nil {
        return "", err
    }
    return a.executePlan(ctx, plan)
}

func (a *PlanAndExecuteAgent) executePlan(ctx context.Context, plan *Plan) (string, error) {
    completed := make(map[int]string)
    var mu sync.Mutex

    for _, batch := range topologicalBatches(plan) {
        var wg sync.WaitGroup
        for _, step := range batch {
            wg.Add(1)
            go func(s PlanStep) {
                defer wg.Done()
                result, _ := a.executor.Execute(ctx, s, completed)
                mu.Lock()
                completed[s.ID] = result
                mu.Unlock()
            }(step)
        }
        wg.Wait()
    }

    return a.synthesize(ctx, completed)
}

for i := 0; i < a.maxSteps; i++ {
    // do agent loop
}
return "", ErrMaxStepsReached

func (a *ReactAgent) handleToolError(ctx context.Context, state *AgentState, step Step, err error) (string, bool) {
    if step.RetryCount >= a.maxRetries {
        return "", false
    }

    reflection := a.reflect(ctx, state, err)
    state.AddReflection(reflection)
    return reflection, true
}

func main() {
    agent := NewCLIAgent(
        WithLLM(openai.New(os.Getenv("OPENAI_API_KEY"))),
        WithTools(NewFileTools(), NewShellTool()),
        WithHistory(LoadHistory(".agent_history")),
    )

    scanner := bufio.NewScanner(os.Stdin)
    for {
        fmt.Print("> ")
        if !scanner.Scan() {
            break
        }

        input := scanner.Text()
        if strings.HasPrefix(input, "/") {
            agent.HandleCommand(input)
            continue
        }

        for event := range agent.RunStream(context.Background(), input) {
            fmt.Print(event.Content)
        }
        fmt.Println()
    }
}