ChatModelAgent（ReAct Agent）

agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
    Name:        "intelligent_assistant",
    Description: "An intelligent assistant capable of using tools",
    Instruction: "You are a professional assistant.",
    Model:       openaiModel,
    ToolsConfig: adk.ToolsConfig{
        Tools: []tool.BaseTool{searchTool, calculatorTool, weatherTool},
    },
    MaxIterations: 20,
})

runner := adk.NewRunner(ctx, adk.RunnerConfig{Agent: agent})
iter := runner.Query(ctx, "What's the weather in Beijing?")

type ChatModelAgentConfig struct {
    Name        string           // Agent 名称（用作 AgentTool 时必填）
    Description string           // 能力描述（用作 AgentTool 时必填）
    Instruction string           // System Prompt，支持 {key} 占位符

    Model       model.BaseChatModel  // 必填。需支持 model.WithTools（用于 Tools）
    ToolsConfig ToolsConfig         // 工具配置

    GenModelInput func(...) []*schema.Message  // 默认：Instruction 作为 System Msg

    Exit          tool.BaseTool   // NOT RECOMMENDED
    OutputKey     string          // NOT RECOMMENDED
    MaxIterations int             // 默认 20

    // Middleware（推荐用 Handlers）
    Handlers    []ChatModelAgentMiddleware  // interface-based（推荐）
    Middlewares []AgentMiddleware           // struct-based（Deprecated）

    // 模型容错
    ModelRetryConfig    *ModelRetryConfig
    ModelFailoverConfig *ModelFailoverConfig
}

type ToolsConfig struct {
    compose.ToolsNodeConfig
    ReturnDirectly     map[string]bool   // 命中后不回调模型，直接返回
    EmitInternalEvents bool              // 透传子 Agent 事件到父 Agent 事件流
}

type ChatModelAgentMiddleware interface {
    // —— 生命周期 Hook ——
    BeforeAgent(ctx, runCtx *ChatModelAgentContext) (context.Context, *ChatModelAgentContext, error)
    AfterAgent(ctx, state *ChatModelAgentState) (context.Context, error)

    BeforeModelRewriteState(ctx, state *ChatModelAgentState, mc *ModelContext) (context.Context, *ChatModelAgentState, error)
    AfterModelRewriteState(ctx, state *ChatModelAgentState, mc *ModelContext) (context.Context, *ChatModelAgentState, error)

    // —— Wrapper ——
    WrapModel(ctx, m model.BaseChatModel, mc *ModelContext) (model.BaseChatModel, error)
    WrapInvokableToolCall(ctx, endpoint InvokableToolCallEndpoint, tCtx *ToolContext) (InvokableToolCallEndpoint, error)
    WrapStreamableToolCall(ctx, endpoint StreamableToolCallEndpoint, tCtx *ToolContext) (StreamableToolCallEndpoint, error)
    // + EnhancedToolCall 变体...
}

type ChatModelAgentContext struct {
    Instruction    string              // 当前指令
    Tools          []tool.BaseTool     // 工具列表
    ReturnDirectly map[string]bool     // 直接返回的工具名集合
    ToolSearchTool *schema.ToolInfo    // 模型原生工具搜索能力
}

type ChatModelAgentState struct {
    Messages          []*schema.Message   // 所有消息
    ToolInfos         []*schema.ToolInfo  // 传给模型的工具定义
    DeferredToolInfos []*schema.ToolInfo  // 延迟检索工具
}

type ModelContext struct {
    Tools               []*schema.ToolInfo   // Deprecated：用 State.ToolInfos
    ModelRetryConfig    *ModelRetryConfig
    ModelFailoverConfig *ModelFailoverConfig
}

type ToolContext struct {
    Name   string // 工具名称
    CallID string // 本次调用唯一标识
}

type MyMiddleware struct {
    *adk.BaseChatModelAgentMiddleware  // 嵌入，只覆盖需要的方法
}

// 运行前注入额外指令
func (m *MyMiddleware) BeforeAgent(ctx context.Context, runCtx *adk.ChatModelAgentContext) (context.Context, *adk.ChatModelAgentContext, error) {
    runCtx.Instruction += "\n必须在回答结束注明"以上信息仅供参考""
    return ctx, runCtx, nil
}

// 每次模型调用前裁剪历史（防 token 超限）
func (m *MyMiddleware) BeforeModelRewriteState(ctx context.Context, state *adk.ChatModelAgentState, mc *adk.ModelContext) (context.Context, *adk.ChatModelAgentState, error) {
    if len(state.Messages) > 30 {
        // 保留 system + 最近 20 条
        state.Messages = append(state.Messages[:1], state.Messages[len(state.Messages)-20:]...)
    }
    return ctx, state, nil
}

// 注册
agent, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
    Model:    model,
    Handlers: []adk.ChatModelAgentMiddleware{&MyMiddleware{}},
})

agent, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
    Model: model,
    ModelRetryConfig: &adk.ModelRetryConfig{
        MaxRetries: 2,
        IsRetryAble: func(ctx context.Context, err error) bool {
            return isTransientError(err)
        },
    },
})

stream := event.Output.MessageOutput.MessageStream
for {
    msg, err := stream.Recv()
    if err == io.EOF { break }
    if err != nil {
        var willRetry *adk.WillRetryError
        if errors.As(err, &willRetry) {
            log.Printf("Retry attempt %d...", willRetry.RetryAttempt)
            break // 等待下一个事件
        }
        break
    }
}

agent, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
    Model: primaryModel,
    ModelFailoverConfig: &adk.ModelFailoverConfig{
        MaxRetries: 1,
        ShouldFailover: func(ctx context.Context, msg *schema.Message, err error) bool {
            return !errors.Is(err, context.Canceled)
        },
        GetFailoverModel: func(ctx context.Context, fc *adk.FailoverContext) (model.BaseChatModel, []*schema.Message, error) {
            return fallbackModel, nil, nil  // nil → 沿用原始输入
        },
    },
})

cancelOpt, cancelFn := adk.WithCancel()
iter := runner.Run(ctx, messages, cancelOpt)

handle := cancelFn(adk.CancelAfterChatModel | adk.CancelAfterToolCalls)
handle.Wait() // 等待取消完成

adk.SetRunLocalValue(ctx, "key", value)
val, ok, _ := adk.GetRunLocalValue(ctx, "key")
adk.DeleteRunLocalValue(ctx, "key")

func init() {
    schema.RegisterName[*ToolStats]("mypackage.ToolStats")
}

adk.SendEvent(ctx, &adk.AgentEvent{
    Output: &adk.AgentOutput{CustomizedOutput: myData},
})