Eino ADK 模块详解

graph TB
    subgraph "智能体接口层 (Agent Interface Layer)"
        Agent[Agent Interface]
        ResumableAgent[ResumableAgent Interface]
        OnSubAgents[OnSubAgents Interface]
    end
    
    subgraph "事件系统层 (Event System Layer)"
        AgentEvent[AgentEvent]
        AgentInput[AgentInput]
        AgentOutput[AgentOutput]
        AgentAction[AgentAction]
        MessageVariant[MessageVariant]
    end
    
    subgraph "执行引擎层 (Execution Engine Layer)"
        Runner[Agent Runner]
        AsyncIterator[AsyncIterator]
        ReactGraph[ReAct Graph]
        WorkflowAgent[Workflow Agent]
    end
    
    subgraph "预构建模式层 (Prebuilt Patterns Layer)"
        ChatModelAgent[ChatModel Agent]
        PlanExecute[Plan-Execute Agent]
        Supervisor[Supervisor Agent]
        FlowAgent[Flow Agent]
    end
    
    subgraph "工具集成层 (Tool Integration Layer)"
        ToolsConfig[Tools Configuration]
        AgentTool[Agent Tool]
        ExitTool[Exit Tool]
        TransferTool[Transfer Tool]
    end
    
    Agent --> AgentEvent
    Agent --> AgentInput
    Agent --> AgentOutput
    Agent --> AgentAction
    
    AgentEvent --> MessageVariant
    AgentOutput --> MessageVariant
    
    Runner --> AsyncIterator
    Runner --> ReactGraph
    Runner --> WorkflowAgent
    
    ChatModelAgent --> ReactGraph
    PlanExecute --> WorkflowAgent
    Supervisor --> WorkflowAgent
    FlowAgent --> WorkflowAgent
    
    ReactGraph --> ToolsConfig
    ChatModelAgent --> AgentTool
    ChatModelAgent --> ExitTool
    
    style Agent fill:#e8f5e8
    style AgentEvent fill:#fff3e0
    style Runner fill:#f3e5f5
    style ChatModelAgent fill:#e3f2fd

// adk/interface.go

// Message 和 MessageStream 类型别名
type Message = *schema.Message
type MessageStream = *schema.StreamReader[Message]

// MessageVariant 消息变体，支持流式和非流式消息
type MessageVariant struct {
	IsStreaming bool          // 是否为流式消息
	
	Message       Message     // 非流式消息
	MessageStream MessageStream // 流式消息
	
	Role     schema.RoleType  // 消息角色：Assistant 或 Tool
	ToolName string          // 工具名称（仅当 Role 为 Tool 时使用）
}

// AgentInput 智能体输入
type AgentInput struct {
	Messages        []Message  // 输入消息列表
	EnableStreaming bool       // 是否启用流式输出
}

// AgentOutput 智能体输出
type AgentOutput struct {
	MessageOutput    *MessageVariant  // 消息输出
	CustomizedOutput any              // 自定义输出
}

// AgentAction 智能体动作
type AgentAction struct {
	Exit            bool                      // 是否退出
	Interrupted     *InterruptInfo           // 中断信息
	TransferToAgent *TransferToAgentAction   // 转移到其他智能体
	CustomizedAction any                     // 自定义动作
}

// AgentEvent 智能体事件
type AgentEvent struct {
	AgentName string        // 智能体名称
	RunPath   []RunStep     // 运行路径
	Output    *AgentOutput  // 输出
	Action    *AgentAction  // 动作
	Err       error         // 错误信息
}

// adk/interface.go

// Agent 智能体核心接口
type Agent interface {
	// Name 返回智能体名称
	Name(ctx context.Context) string
	
	// Description 返回智能体描述
	// 帮助其他智能体确定是否将任务转移给此智能体
	Description(ctx context.Context) string
	
	// Run 运行智能体
	// AsyncIterator 中返回的 AgentEvent 必须是安全可修改的
	// 如果 AgentEvent 包含 MessageStream，MessageStream 必须是独占且安全可直接接收的
	// 注意：建议在 AsyncIterator 发出的 AgentEvent 的 MessageStream 上使用 SetAutomaticClose()，
	// 这样即使事件未被处理，MessageStream 仍然可以被关闭
	Run(ctx context.Context, input *AgentInput, options ...AgentRunOption) *AsyncIterator[*AgentEvent]
}

// OnSubAgents 子智能体管理接口
type OnSubAgents interface {
	// OnSetSubAgents 设置子智能体
	OnSetSubAgents(ctx context.Context, subAgents []Agent) error
	
	// OnSetAsSubAgent 设置为子智能体
	OnSetAsSubAgent(ctx context.Context, parent Agent) error
	
	// OnDisallowTransferToParent 禁止转移到父智能体
	OnDisallowTransferToParent(ctx context.Context) error
}

// ResumableAgent 可恢复智能体接口
type ResumableAgent interface {
	Agent
	
	// Resume 从保存的状态恢复执行
	Resume(ctx context.Context, data []byte, input *AgentInput, options ...AgentRunOption) *AsyncIterator[*AgentEvent]
}

sequenceDiagram
    participant Client
    participant Agent
    participant AsyncIterator
    participant EventGenerator
    
    Client->>Agent: Run(ctx, input, options)
    Agent->>AsyncIterator: 创建异步迭代器
    Agent->>EventGenerator: 启动事件生成器
    Agent-->>Client: 返回 AsyncIterator
    
    loop 事件生成
        EventGenerator->>EventGenerator: 执行智能体逻辑
        EventGenerator->>AsyncIterator: Send(AgentEvent)
        
        alt 有输出
            AsyncIterator->>Client: Next() -> AgentEvent with Output
        else 有动作
            AsyncIterator->>Client: Next() -> AgentEvent with Action
        else 有错误
            AsyncIterator->>Client: Next() -> AgentEvent with Error
        end
        
        alt 退出动作
            EventGenerator->>AsyncIterator: Send(ExitEvent)
            EventGenerator->>AsyncIterator: Close()
            break
        end
    end
    
    Client->>AsyncIterator: Close()

// adk/chatmodel.go

// ChatModelAgentConfig 聊天模型智能体配置
type ChatModelAgentConfig struct {
	// Name 智能体名称，最好在所有智能体中唯一
	Name string
	
	// Description 智能体能力描述
	// 帮助其他智能体确定是否将任务转移给此智能体
	Description string
	
	// Instruction 用作此智能体系统提示的指令
	// 可选。如果为空，将不使用系统提示
	// 支持默认 GenModelInput 中会话值的 f-string 占位符，例如：
	// "You are a helpful assistant. The current time is {Time}. The current user is {User}."
	// 这些占位符将被 "Time" 和 "User" 的会话值替换
	Instruction string
	
	// Model 聊天模型
	Model model.ToolCallingChatModel
	
	// ToolsConfig 工具配置
	ToolsConfig ToolsConfig
	
	// GenModelInput 将指令和输入消息转换为模型输入格式
	// 可选。默认为 defaultGenModelInput，它组合指令和消息
	GenModelInput GenModelInput
	
	// Exit 定义用于终止智能体进程的工具
	// 可选。如果为 nil，将不生成退出动作
	// 可以直接使用提供的 'ExitTool' 实现
	Exit tool.BaseTool
	
	// OutputKey 在会话中存储智能体响应
	// 可选。设置时，通过 AddSessionValue(ctx, outputKey, msg.Content) 存储输出
	OutputKey string
	
	// MaxIterations 定义 ChatModel 生成循环的上限
	// 如果超过此限制，智能体将以错误终止
	// 可选。默认为 20
	MaxIterations int
}

// ChatModelAgent 聊天模型智能体实现
type ChatModelAgent struct {
	name        string
	description string
	instruction string
	
	model       model.ToolCallingChatModel
	toolsConfig ToolsConfig
	
	genModelInput GenModelInput
	
	outputKey     string
	maxIterations int
	
	subAgents   []Agent
	parentAgent Agent
	
	disallowTransferToParent bool
	
	exit tool.BaseTool
	
	// 运行器
	once   sync.Once
	run    runFunc
	frozen uint32
}

// adk/react.go

// State ReAct 执行状态
type State struct {
	Messages []Message  // 消息历史
	
	ReturnDirectlyToolCallID string  // 直接返回的工具调用 ID
	
	ToolGenActions map[string]*AgentAction  // 工具生成的动作
	
	AgentName string  // 智能体名称
	
	AgentToolInterruptData map[string]*agentToolInterruptInfo  // 智能体工具中断数据
	
	RemainingIterations int  // 剩余迭代次数
}

// ReAct 图构建
func newReact(ctx context.Context, config *reactConfig) (reactGraph, error) {
	// 生成状态函数
	genState := func(ctx context.Context) *State {
		return &State{
			ToolGenActions:         map[string]*AgentAction{},
			AgentName:              config.agentName,
			AgentToolInterruptData: make(map[string]*agentToolInterruptInfo),
			RemainingIterations: func() int {
				if config.maxIterations <= 0 {
					return 20
				}
				return config.maxIterations
			}(),
		}
	}
	
	// 创建图
	g := compose.NewGraph[[]Message, Message](compose.WithGenLocalState(genState))
	
	// 获取工具信息
	toolsInfo, err := genToolInfos(ctx, config.toolsConfig)
	if err != nil {
		return nil, err
	}
	
	// 创建带工具的聊天模型
	chatModel, err := config.model.WithTools(toolsInfo)
	if err != nil {
		return nil, err
	}
	
	// 创建工具节点
	toolsNode, err := compose.NewToolNode(ctx, config.toolsConfig)
	if err != nil {
		return nil, err
	}
	
	// 添加聊天模型节点
	modelPreHandle := func(ctx context.Context, input []Message, st *State) ([]Message, error) {
		if st.RemainingIterations <= 0 {
			return nil, ErrExceedMaxIterations
		}
		st.RemainingIterations--
		
		st.Messages = append(st.Messages, input...)
		return st.Messages, nil
	}
	_ = g.AddChatModelNode("ChatModel", chatModel,
		compose.WithStatePreHandler(modelPreHandle), 
		compose.WithNodeName("ChatModel"))
	
	// 添加工具节点
	toolPreHandle := func(ctx context.Context, input Message, st *State) (Message, error) {
		if input != nil {
			st.Messages = append(st.Messages, input)
		}
		
		input = st.Messages[len(st.Messages)-1]
		// 处理直接返回的工具
		if len(config.toolsReturnDirectly) > 0 {
			for i := range input.ToolCalls {
				toolName := input.ToolCalls[i].Function.Name
				if config.toolsReturnDirectly[toolName] {
					st.ReturnDirectlyToolCallID = input.ToolCalls[i].ID
				}
			}
		}
		
		return input, nil
	}
	
	_ = g.AddToolsNode("ToolNode", toolsNode,
		compose.WithStatePreHandler(toolPreHandle), 
		compose.WithNodeName("ToolNode"))
	
	// 添加边和分支逻辑
	_ = g.AddEdge(compose.START, "ChatModel")
	
	// 工具调用检查分支
	toolCallCheck := func(ctx context.Context, sMsg MessageStream) (string, error) {
		// 检查是否有工具调用
		// 如果有，转到工具节点；否则结束
	}
	
	// 添加条件分支
	// ...
	
	return g, nil
}

package main

import (
	"context"
	"fmt"
	
	"github.com/cloudwego/eino/adk"
	"github.com/cloudwego/eino/components/model"
	"github.com/cloudwego/eino/components/tool"
	"github.com/cloudwego/eino/schema"
)

func chatModelAgentExample() {
	ctx := context.Background()
	
	// 创建聊天模型（这里使用模拟实现）
	chatModel := &MockChatModel{}
	
	// 定义工具
	weatherTool := &WeatherTool{}
	calculatorTool := &CalculatorTool{}
	
	// 创建智能体配置
	config := &adk.ChatModelAgentConfig{
		Name:        "AssistantAgent",
		Description: "A helpful assistant that can check weather and do calculations",
		Instruction: "You are a helpful assistant. Use the available tools to help users with their requests.",
		Model:       chatModel,
		ToolsConfig: adk.ToolsConfig{
			Tools: []tool.BaseTool{weatherTool, calculatorTool},
		},
		MaxIterations: 10,
	}
	
	// 创建智能体
	agent, err := adk.NewChatModelAgent(ctx, config)
	if err != nil {
		panic(err)
	}
	
	// 准备输入
	input := &adk.AgentInput{
		Messages: []adk.Message{
			schema.UserMessage("What's the weather like in Beijing? Also, what's 15 * 23?"),
		},
		EnableStreaming: false,
	}
	
	// 运行智能体
	iterator := agent.Run(ctx, input)
	defer iterator.Close()
	
	// 处理事件
	for {
		event, ok := iterator.Next()
		if !ok {
			break
		}
		
		if event.Err != nil {
			fmt.Printf("错误: %v\n", event.Err)
			break
		}
		
		if event.Output != nil && event.Output.MessageOutput != nil {
			message, err := event.Output.MessageOutput.GetMessage()
			if err != nil {
				fmt.Printf("获取消息失败: %v\n", err)
				continue
			}
			
			fmt.Printf("智能体输出: %s\n", message.Content)
		}
		
		if event.Action != nil {
			if event.Action.Exit {
				fmt.Println("智能体退出")
				break
			}
			
			if event.Action.TransferToAgent != nil {
				fmt.Printf("转移到智能体: %s\n", event.Action.TransferToAgent.DestAgentName)
			}
		}
	}
}

// 模拟天气工具
type WeatherTool struct{}

func (w *WeatherTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
	return &schema.ToolInfo{
		Name: "get_weather",
		Desc: "Get current weather information for a city",
		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
			"city": {
				Type:     schema.String,
				Desc:     "City name",
				Required: true,
			},
		}),
	}, nil
}

func (w *WeatherTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
	// 解析参数并返回天气信息
	return `{"city": "Beijing", "temperature": "22°C", "condition": "Sunny"}`, nil
}

// 模拟计算器工具
type CalculatorTool struct{}

func (c *CalculatorTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
	return &schema.ToolInfo{
		Name: "calculator",
		Desc: "Perform basic mathematical calculations",
		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
			"expression": {
				Type:     schema.String,
				Desc:     "Mathematical expression to evaluate",
				Required: true,
			},
		}),
	}, nil
}

func (c *CalculatorTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
	// 解析表达式并返回计算结果
	return "345", nil
}

// adk/runner.go

// Runner 智能体运行器，支持多智能体协作
type Runner struct {
	agents map[string]Agent  // 智能体映射
	
	enableStreaming bool     // 是否启用流式输出
	maxIterations   int      // 最大迭代次数
	
	// 会话管理
	sessionValues map[string]any
}

// RunnerConfig 运行器配置
type RunnerConfig struct {
	// Agents 智能体列表
	Agents []Agent
	
	// EnableStreaming 是否启用流式输出
	EnableStreaming bool
	
	// MaxIterations 最大迭代次数
	MaxIterations int
	
	// InitialSessionValues 初始会话值
	InitialSessionValues map[string]any
}

// NewRunner 创建新的智能体运行器
func NewRunner(ctx context.Context, config *RunnerConfig) (*Runner, error) {
	runner := &Runner{
		agents:          make(map[string]Agent),
		enableStreaming: config.EnableStreaming,
		maxIterations:   config.MaxIterations,
		sessionValues:   make(map[string]any),
	}
	
	// 复制初始会话值
	for k, v := range config.InitialSessionValues {
		runner.sessionValues[k] = v
	}
	
	// 注册智能体
	for _, agent := range config.Agents {
		name := agent.Name(ctx)
		if _, exists := runner.agents[name]; exists {
			return nil, fmt.Errorf("duplicate agent name: %s", name)
		}
		runner.agents[name] = agent
	}
	
	// 设置智能体关系
	for _, agent := range config.Agents {
		if subAgentManager, ok := agent.(OnSubAgents); ok {
			var subAgents []Agent
			for _, subAgent := range config.Agents {
				if subAgent != agent {
					subAgents = append(subAgents, subAgent)
				}
			}
			
			err := subAgentManager.OnSetSubAgents(ctx, subAgents)
			if err != nil {
				return nil, fmt.Errorf("failed to set sub agents for %s: %w", agent.Name(ctx), err)
			}
		}
	}
	
	return runner, nil
}

// Run 运行智能体
func (r *Runner) Run(ctx context.Context, startAgentName string, input *AgentInput) *AsyncIterator[*AgentEvent] {
	iterator, generator := NewAsyncIteratorPair[*AgentEvent]()
	
	go func() {
		defer generator.Close()
		
		currentAgentName := startAgentName
		currentInput := input
		iterations := 0
		
		for iterations < r.maxIterations {
			iterations++
			
			// 获取当前智能体
			agent, exists := r.agents[currentAgentName]
			if !exists {
				generator.Send(&AgentEvent{
					AgentName: currentAgentName,
					Err:       fmt.Errorf("agent not found: %s", currentAgentName),
				})
				return
			}
			
			// 运行智能体
			agentIterator := agent.Run(ctx, currentInput)
			
			var lastEvent *AgentEvent
			for {
				event, ok := agentIterator.Next()
				if !ok {
					break
				}
				
				// 设置智能体名称和运行路径
				event.AgentName = currentAgentName
				event.RunPath = append(event.RunPath, RunStep{agentName: currentAgentName})
				
				generator.Send(event)
				lastEvent = event
				
				// 检查是否有错误
				if event.Err != nil {
					agentIterator.Close()
					return
				}
			}
			
			agentIterator.Close()
			
			// 检查最后事件的动作
			if lastEvent == nil {
				return
			}
			
			if lastEvent.Action == nil {
				return
			}
			
			if lastEvent.Action.Exit {
				return
			}
			
			if lastEvent.Action.TransferToAgent != nil {
				// 转移到其他智能体
				currentAgentName = lastEvent.Action.TransferToAgent.DestAgentName
				
				// 准备新的输入
				if lastEvent.Output != nil && lastEvent.Output.MessageOutput != nil {
					message, err := lastEvent.Output.MessageOutput.GetMessage()
					if err != nil {
						generator.Send(&AgentEvent{
							AgentName: currentAgentName,
							Err:       fmt.Errorf("failed to get message for transfer: %w", err),
						})
						return
					}
					
					currentInput = &AgentInput{
						Messages:        append(currentInput.Messages, message),
						EnableStreaming: r.enableStreaming,
					}
				}
				
				continue
			}
			
			// 没有更多动作，结束
			return
		}
		
		// 超过最大迭代次数
		generator.Send(&AgentEvent{
			AgentName: currentAgentName,
			Err:       fmt.Errorf("exceeded maximum iterations: %d", r.maxIterations),
		})
	}()
	
	return iterator
}

package main

import (
	"context"
	"fmt"
	
	"github.com/cloudwego/eino/adk"
	"github.com/cloudwego/eino/schema"
)

func multiAgentExample() {
	ctx := context.Background()
	
	// 创建专门的智能体
	
	// 1. 路由智能体 - 决定任务分配
	routerAgent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
		Name:        "Router",
		Description: "Routes tasks to appropriate specialist agents",
		Instruction: `You are a router agent. Based on the user's request, decide which specialist agent should handle it:
- For weather questions, transfer to WeatherAgent
- For math calculations, transfer to MathAgent  
- For general questions, handle yourself
Use the transfer_to_agent tool to route tasks.`,
		Model: &MockChatModel{},
		ToolsConfig: adk.ToolsConfig{
			Tools: []tool.BaseTool{
				&TransferTool{},
			},
		},
	})
	if err != nil {
		panic(err)
	}
	
	// 2. 天气智能体
	weatherAgent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
		Name:        "WeatherAgent",
		Description: "Provides weather information for any location",
		Instruction: "You are a weather specialist. Use the weather tool to provide accurate weather information.",
		Model:       &MockChatModel{},
		ToolsConfig: adk.ToolsConfig{
			Tools: []tool.BaseTool{
				&WeatherTool{},
				&ExitTool{},
			},
		},
	})
	if err != nil {
		panic(err)
	}
	
	// 3. 数学智能体
	mathAgent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
		Name:        "MathAgent", 
		Description: "Performs mathematical calculations and solves math problems",
		Instruction: "You are a math specialist. Use the calculator tool to solve mathematical problems accurately.",
		Model:       &MockChatModel{},
		ToolsConfig: adk.ToolsConfig{
			Tools: []tool.BaseTool{
				&CalculatorTool{},
				&ExitTool{},
			},
		},
	})
	if err != nil {
		panic(err)
	}
	
	// 创建运行器
	runner, err := adk.NewRunner(ctx, &adk.RunnerConfig{
		Agents: []adk.Agent{routerAgent, weatherAgent, mathAgent},
		EnableStreaming: false,
		MaxIterations:   20,
		InitialSessionValues: map[string]any{
			"user_id": "user123",
			"session_id": "session456",
		},
	})
	if err != nil {
		panic(err)
	}
	
	// 测试多智能体协作
	testCases := []string{
		"What's the weather like in Tokyo?",
		"Calculate 156 * 789 + 234",
		"What's the capital of France?",
	}
	
	for i, query := range testCases {
		fmt.Printf("\n=== 测试案例 %d: %s ===\n", i+1, query)
		
		input := &adk.AgentInput{
			Messages: []adk.Message{
				schema.UserMessage(query),
			},
			EnableStreaming: false,
		}
		
		// 从路由智能体开始
		iterator := runner.Run(ctx, "Router", input)
		defer iterator.Close()
		
		// 处理事件流
		for {
			event, ok := iterator.Next()
			if !ok {
				break
			}
			
			if event.Err != nil {
				fmt.Printf("错误 [%s]: %v\n", event.AgentName, event.Err)
				break
			}
			
			if event.Output != nil && event.Output.MessageOutput != nil {
				message, err := event.Output.MessageOutput.GetMessage()
				if err != nil {
					fmt.Printf("获取消息失败 [%s]: %v\n", event.AgentName, err)
					continue
				}
				
				fmt.Printf("输出 [%s]: %s\n", event.AgentName, message.Content)
			}
			
			if event.Action != nil {
				if event.Action.Exit {
					fmt.Printf("智能体 [%s] 退出\n", event.AgentName)
					break
				}
				
				if event.Action.TransferToAgent != nil {
					fmt.Printf("转移: [%s] -> [%s]\n", 
						event.AgentName, 
						event.Action.TransferToAgent.DestAgentName)
				}
			}
		}
	}
}

// 转移工具
type TransferTool struct{}

func (t *TransferTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
	return &schema.ToolInfo{
		Name: "transfer_to_agent",
		Desc: "Transfer the task to a specialist agent",
		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
			"agent_name": {
				Type:     schema.String,
				Desc:     "Name of the agent to transfer to (WeatherAgent, MathAgent)",
				Required: true,
			},
			"reason": {
				Type:     schema.String,
				Desc:     "Reason for the transfer",
				Required: false,
			},
		}),
	}, nil
}

func (t *TransferTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
	// 解析参数
	var params struct {
		AgentName string `json:"agent_name"`
		Reason    string `json:"reason"`
	}
	
	err := json.Unmarshal([]byte(argumentsInJSON), &params)
	if err != nil {
		return "", err
	}
	
	// 生成转移动作
	action := adk.NewTransferToAgentAction(params.AgentName)
	
	// 通过上下文发送动作（这里简化处理）
	return fmt.Sprintf("Transferring to %s: %s", params.AgentName, params.Reason), nil
}

// 退出工具
type ExitTool struct{}

func (e *ExitTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
	return &schema.ToolInfo{
		Name: "exit",
		Desc: "Exit the agent execution",
		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
			"message": {
				Type:     schema.String,
				Desc:     "Final message before exit",
				Required: false,
			},
		}),
	}, nil
}

func (e *ExitTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
	// 生成退出动作
	action := adk.NewExitAction()
	
	// 通过上下文发送动作（这里简化处理）
	return "Task completed successfully", nil
}

// adk/prebuilt/planexecute/plan_execute.go

// Config Plan-Execute 智能体配置
type Config struct {
	// Planner 生成计划的智能体
	Planner adk.Agent
	
	// Executor 执行计划的智能体
	Executor adk.Agent
	
	// Replanner 重新规划的智能体
	Replanner adk.Agent
	
	// MaxIterations 执行-重新规划的最大循环次数
	MaxIterations int
}

// New 创建新的 Plan-Execute 智能体
// Plan-Execute 模式分为三个阶段：
// 1. 规划：生成具有明确可操作步骤的结构化计划
// 2. 执行：执行计划的第一步
// 3. 重新规划：评估进度，完成任务或修订计划
// 这种方法通过迭代改进实现复杂问题解决
func New(ctx context.Context, cfg *Config) (adk.Agent, error) {
	if cfg.Planner == nil {
		return nil, errors.New("planner is required")
	}
	if cfg.Executor == nil {
		return nil, errors.New("executor is required")
	}
	if cfg.Replanner == nil {
		return nil, errors.New("replanner is required")
	}
	
	maxIterations := cfg.MaxIterations
	if maxIterations <= 0 {
		maxIterations = 10
	}
	
	return &planExecuteAgent{
		planner:       cfg.Planner,
		executor:      cfg.Executor,
		replanner:     cfg.Replanner,
		maxIterations: maxIterations,
	}, nil
}

type planExecuteAgent struct {
	planner       adk.Agent
	executor      adk.Agent
	replanner     adk.Agent
	maxIterations int
}

func (a *planExecuteAgent) Name(ctx context.Context) string {
	return "PlanExecuteAgent"
}

func (a *planExecuteAgent) Description(ctx context.Context) string {
	return "An agent that breaks down complex tasks into planning, execution, and replanning phases"
}

func (a *planExecuteAgent) Run(ctx context.Context, input *adk.AgentInput, options ...adk.AgentRunOption) *adk.AsyncIterator[*adk.AgentEvent] {
	iterator, generator := adk.NewAsyncIteratorPair[*adk.AgentEvent]()
	
	go func() {
		defer generator.Close()
		
		// 阶段 1: 规划
		planIterator := a.planner.Run(ctx, input, options...)
		plan, err := a.collectAgentOutput(planIterator)
		if err != nil {
			generator.Send(&adk.AgentEvent{
				AgentName: a.Name(ctx),
				Err:       fmt.Errorf("planning failed: %w", err),
			})
			return
		}
		
		generator.Send(&adk.AgentEvent{
			AgentName: a.Name(ctx),
			Output: &adk.AgentOutput{
				MessageOutput: &adk.MessageVariant{
					Message: schema.AssistantMessage(fmt.Sprintf("Plan created: %s", plan)),
				},
			},
		})
		
		// 阶段 2 & 3: 执行和重新规划循环
		currentPlan := plan
		for i := 0; i < a.maxIterations; i++ {
			// 执行当前计划
			executeInput := &adk.AgentInput{
				Messages: []adk.Message{
					schema.UserMessage(fmt.Sprintf("Execute this plan: %s", currentPlan)),
				},
				EnableStreaming: input.EnableStreaming,
			}
			
			executeIterator := a.executor.Run(ctx, executeInput, options...)
			executeResult, err := a.collectAgentOutput(executeIterator)
			if err != nil {
				generator.Send(&adk.AgentEvent{
					AgentName: a.Name(ctx),
					Err:       fmt.Errorf("execution failed: %w", err),
				})
				return
			}
			
			generator.Send(&adk.AgentEvent{
				AgentName: a.Name(ctx),
				Output: &adk.AgentOutput{
					MessageOutput: &adk.MessageVariant{
						Message: schema.AssistantMessage(fmt.Sprintf("Execution result: %s", executeResult)),
					},
				},
			})
			
			// 重新规划
			replanInput := &adk.AgentInput{
				Messages: []adk.Message{
					schema.UserMessage(fmt.Sprintf("Original plan: %s\nExecution result: %s\nShould we continue or are we done?", currentPlan, executeResult)),
				},
				EnableStreaming: input.EnableStreaming,
			}
			
			replanIterator := a.replanner.Run(ctx, replanInput, options...)
			replanResult, err := a.collectAgentOutput(replanIterator)
			if err != nil {
				generator.Send(&adk.AgentEvent{
					AgentName: a.Name(ctx),
					Err:       fmt.Errorf("replanning failed: %w", err),
				})
				return
			}
			
			// 检查是否完成
			if strings.Contains(strings.ToLower(replanResult), "done") || 
			   strings.Contains(strings.ToLower(replanResult), "complete") {
				generator.Send(&adk.AgentEvent{
					AgentName: a.Name(ctx),
					Output: &adk.AgentOutput{
						MessageOutput: &adk.MessageVariant{
							Message: schema.AssistantMessage("Task completed successfully"),
						},
					},
					Action: adk.NewExitAction(),
				})
				return
			}
			
			// 更新计划
			currentPlan = replanResult
		}
		
		// 超过最大迭代次数
		generator.Send(&adk.AgentEvent{
			AgentName: a.Name(ctx),
			Err:       fmt.Errorf("exceeded maximum iterations: %d", a.maxIterations),
		})
	}()
	
	return iterator
}

func (a *planExecuteAgent) collectAgentOutput(iterator *adk.AsyncIterator[*adk.AgentEvent]) (string, error) {
	defer iterator.Close()
	
	var outputs []string
	for {
		event, ok := iterator.Next()
		if !ok {
			break
		}
		
		if event.Err != nil {
			return "", event.Err
		}
		
		if event.Output != nil && event.Output.MessageOutput != nil {
			message, err := event.Output.MessageOutput.GetMessage()
			if err != nil {
				return "", err
			}
			outputs = append(outputs, message.Content)
		}
		
		if event.Action != nil && event.Action.Exit {
			break
		}
	}
	
	return strings.Join(outputs, "\n"), nil
}