07多智能体：先跑通两条路线

// New creates a supervisor-based multi-agent system with the given configuration.
//
// In the supervisor pattern, a designated supervisor agent coordinates multiple sub-agents.
// The supervisor can delegate tasks to sub-agents and receive their responses, while
// sub-agents can only communicate with the supervisor (not with each other directly).
// This hierarchical structure enables complex problem-solving through coordinated agent interactions.
//
// The returned agent is wrapped in an internal container that provides unified tracing.
// When used with Runner and callbacks, all agents within the supervisor structure will
// share the same trace root, making it easy to observe the entire multi-agent execution
// as a single logical unit.
//
// NOT RECOMMENDED: Supervisor is built on agent transfer with full context sharing,
// which has not proven to be more effective empirically. Consider using
// ChatModelAgent with AgentTool or DeepAgent instead for most multi-agent scenarios.
func New(ctx context.Context, conf *Config) (adk.ResumableAgent, error) {
  subAgents := make([]adk.Agent, 0, len(conf.SubAgents))
  supervisorName := conf.Supervisor.Name(ctx)
  for _, subAgent := range conf.SubAgents {
    subAgents = append(subAgents, adk.AgentWithDeterministicTransferTo(ctx, &adk.DeterministicTransferConfig{
      Agent:        subAgent,
      ToAgentNames: []string{supervisorName},
    }))
  }

  inner, err := adk.SetSubAgents(ctx, conf.Supervisor, subAgents)
  if err != nil {
    return nil, err
  }

  return &supervisorContainer{
    name:  supervisorName,
    inner: inner,
  }, nil
}

// New creates a new Deep agent instance with the provided configuration.
// This function initializes built-in tools, creates a task tool for subagent orchestration,
// and returns a fully configured ChatModelAgent ready for execution.
func New(ctx context.Context, cfg *Config) (adk.ResumableAgent, error) {
  return NewTyped(ctx, cfg)
}

// NewTyped creates a new typed Deep agent instance with the provided configuration.
// This function initializes built-in tools, creates a task tool for subagent orchestration,
// and returns a fully configured TypedChatModelAgent ready for execution.
func NewTyped[M adk.MessageType](ctx context.Context, cfg *TypedConfig[M]) (adk.TypedResumableAgent[M], error) {
  handlers, err := buildTypedBuiltinAgentMiddlewares(ctx, cfg)
  if err != nil {
    return nil, err
  }

  instruction := cfg.Instruction
  if len(instruction) == 0 {
    instruction = internal.SelectPrompt(internal.I18nPrompts{
      English: baseAgentInstruction,
      Chinese: baseAgentInstructionChinese,
    })
  }

  if !cfg.WithoutGeneralSubAgent || len(cfg.SubAgents) > 0 {
    tt, err := typedTaskToolMiddleware(
      ctx,
      cfg.TaskToolDescriptionGenerator,
      cfg.SubAgents,

      cfg.WithoutGeneralSubAgent,
      cfg.ChatModel,
      instruction,
      cfg.ToolsConfig,
      cfg.MaxIteration,
      cfg.Middlewares,
      append(handlers, cfg.Handlers...),
      cfg.ModelFailoverConfig,
    )
    if err != nil {
      return nil, fmt.Errorf("failed to new task tool: %w", err)
    }
    handlers = append(handlers, tt)
  }

  return adk.NewTypedChatModelAgent(ctx, &adk.TypedChatModelAgentConfig[M]{
    Name:          cfg.Name,
    Description:   cfg.Description,
    Instruction:   instruction,
    Model:         cfg.ChatModel,
    ToolsConfig:   cfg.ToolsConfig,
    MaxIterations: cfg.MaxIteration,
    Middlewares:   cfg.Middlewares,
    Handlers:      append(handlers, cfg.Handlers...),

// … 省略 6 行；完整声明 L113–166，点击上方「浏览完整文件」

// New creates a new plan-execute-replan agent with the given configuration.
// The plan-execute-replan pattern works in three phases:
// 1. Planning: Generate a structured plan with clear, actionable steps
// 2. Execution: Execute the first step of the plan
// 3. Replanning: Evaluate progress and either complete the task or revise the plan
// This approach enables complex problem-solving through iterative refinement.
func New(ctx context.Context, cfg *Config) (adk.ResumableAgent, error) {
  maxIterations := cfg.MaxIterations
  if maxIterations <= 0 {
    maxIterations = 10
  }
  loop, err := adk.NewLoopAgent(ctx, &adk.LoopAgentConfig{
    Name:          "execute_replan",
    SubAgents:     []adk.Agent{cfg.Executor, cfg.Replanner},
    MaxIterations: maxIterations,
  })
  if err != nil {
    return nil, err
  }

  return adk.NewSequentialAgent(ctx, &adk.SequentialAgentConfig{
    Name:      "plan_execute_replan",
    SubAgents: []adk.Agent{cfg.Planner, loop},
  })
}

// NewReplanner creates a plan-execute-replan agent wired with plan and respond tools.
// It configures the provided ToolCallingChatModel with the tools and returns an Agent.
func NewReplanner(_ context.Context, cfg *ReplannerConfig) (adk.Agent, error) {
  planTool := cfg.PlanTool
  if planTool == nil {
    planTool = &PlanToolInfo
  }

  respondTool := cfg.RespondTool
  if respondTool == nil {
    respondTool = &RespondToolInfo
  }

  chatModel, err := cfg.ChatModel.WithTools([]*schema.ToolInfo{planTool, respondTool})
  if err != nil {
    return nil, err
  }

  planParser := cfg.NewPlan
  if planParser == nil {
    planParser = defaultNewPlan
  }

  return &replanner{
    chatModel:   chatModel,
    planTool:    planTool,
    respondTool: respondTool,
    genInputFn:  cfg.GenInputFn,
    newPlan:     planParser,
  }, nil
}

// Config provides configuration options for creating a plan-execute-replan agent.
type Config struct {
  // Planner specifies the agent that generates the plan.
  // You can use provided NewPlanner to create a planner agent.
  Planner adk.Agent

  // Executor specifies the agent that executes the plan generated by planner or replanner.
  // You can use provided NewExecutor to create an executor agent.
  Executor adk.Agent

  // Replanner specifies the agent that replans the plan.
  // You can use provided NewReplanner to create a replanner agent.
  Replanner adk.Agent

  // MaxIterations defines the maximum number of loops for 'execute-replan'.
  // Optional. If not provided, 10 will be used as the default.
  MaxIterations int
}