flowchart TB
    subgraph 应用层["应用层 (User Application)"]
        APP["LLM 应用<br/>聊天机器人/RAG/智能体"]
    end

    subgraph Eino框架核心["Eino 框架核心"]
        subgraph 编排层["编排层 (Orchestration)"]
            CHAIN["Chain<br/>链式编排"]
            GRAPH["Graph<br/>图式编排"]
            WORKFLOW["Workflow<br/>工作流编排"]
        end

        subgraph 执行层["执行层 (Execution)"]
            RUNNABLE["Runnable<br/>统一执行接口"]
            RUNNER["Runner<br/>执行器"]
        end

        subgraph 组件层["组件抽象层 (Components)"]
            MODEL["ChatModel<br/>聊天模型"]
            TOOL["Tool<br/>工具"]
            RETRIEVER["Retriever<br/>检索器"]
            PROMPT["Prompt<br/>提示词模板"]
            EMBEDDING["Embedding<br/>向量化"]
            INDEXER["Indexer<br/>索引器"]
            DOCUMENT["Document<br/>文档处理"]
        end

        subgraph 基础设施层["基础设施层 (Infrastructure)"]
            SCHEMA["Schema<br/>消息/流/工具定义"]
            CALLBACKS["Callbacks<br/>切面机制"]
            STREAM["Stream<br/>流处理机制"]
        end
    end

    subgraph 扩展层["扩展层 (Extensions)"]
        EINOEXT["eino-ext<br/>组件实现/工具"]
        DEVOPS["eino-devops<br/>可视化开发调试"]
        EXAMPLES["eino-examples<br/>示例应用"]
    end

    APP --> 编排层
    编排层 --> 执行层
    执行层 --> 组件层
    组件层 --> 基础设施层
    
    APP -.依赖.-> 扩展层
    组件层 -.实现.-> EINOEXT

    classDef appStyle fill:#e1f5ff,stroke:#0066cc,stroke-width:2px
    classDef coreStyle fill:#fff4e1,stroke:#ff9900,stroke-width:2px
    classDef extStyle fill:#f0f0f0,stroke:#666,stroke-width:1px
    
    class APP appStyle
    class 编排层,执行层,组件层,基础设施层 coreStyle
    class 扩展层 extStyle

// Runnable 是所有可执行对象的统一接口
type Runnable[I, O any] interface {
    // Invoke: 非流输入 => 非流输出
    Invoke(ctx context.Context, input I, opts ...Option) (output O, err error)
    
    // Stream: 非流输入 => 流输出
    Stream(ctx context.Context, input I, opts ...Option) (output *schema.StreamReader[O], err error)
    
    // Collect: 流输入 => 非流输出
    Collect(ctx context.Context, input *schema.StreamReader[I], opts ...Option) (output O, err error)
    
    // Transform: 流输入 => 流输出
    Transform(ctx context.Context, input *schema.StreamReader[I], opts ...Option) (output *schema.StreamReader[O], err error)
}

// Message 是 LLM 交互的核心消息结构
type Message struct {
    Role         RoleType          // 角色: system/user/assistant/tool
    Content      string            // 文本内容
    MultiContent []ChatMessagePart // 多模态内容（图片/音频/视频）
    ToolCalls    []ToolCall        // 工具调用列表
    ResponseMeta *ResponseMeta     // 响应元信息（token使用量、结束原因等）
}

// StreamReader 是流式数据的读取器
type StreamReader[T any] struct {
    // 内部实现支持多种读取模式：stream/array/multiStream/convert/child
}

// 接收流数据的标准模式
for {
    chunk, err := streamReader.Recv()
    if err == io.EOF {
        break  // 正常结束
    }
    if err != nil {
        // 处理错误
        return err
    }
    // 处理 chunk
}

type Runnable[I, O any] interface {
    // Invoke: 非流输入 => 非流输出 (经典的请求-响应模式)
    Invoke(ctx context.Context, input I, opts ...Option) (output O, err error)
    
    // Stream: 非流输入 => 流输出 (适用于流式生成场景)
    Stream(ctx context.Context, input I, opts ...Option) (output *StreamReader[O], err error)
    
    // Collect: 流输入 => 非流输出 (流数据聚合场景)
    Collect(ctx context.Context, input *StreamReader[I], opts ...Option) (output O, err error)
    
    // Transform: 流输入 => 流输出 (流数据转换场景)
    Transform(ctx context.Context, input *StreamReader[I], opts ...Option) (output *StreamReader[O], err error)
}

type BaseChatModel interface {
    Generate(ctx context.Context, input []*Message, opts ...Option) (*Message, error)
    Stream(ctx context.Context, input []*Message, opts ...Option) (*StreamReader[*Message], error)
}

type ToolCallingChatModel interface {
    BaseChatModel
    WithTools(tools []*ToolInfo) ToolCallingChatModel
}

type Tool interface {
    Info() *ToolInfo
    Invoke(ctx context.Context, input string, opts ...Option) (string, error)
}

type Retriever interface {
    Retrieve(ctx context.Context, query string, opts ...Option) ([]*Document, error)
}

type Chain[I, O any] struct {
    // 私有字段
}

func (c *Chain[I, O]) AppendChatModel(key string, model BaseChatModel, opts ...NodeOption) *Chain[I, O]
func (c *Chain[I, O]) AppendLambda(key string, lambda *Lambda, opts ...NodeOption) *Chain[I, O]
func (c *Chain[I, O]) Compile(ctx context.Context, opts ...CompileOption) (Runnable[I, O], error)

type Graph[I, O any] struct {
    // 私有字段
}

func (g *Graph[I, O]) AddChatModelNode(key string, model BaseChatModel, opts ...NodeOption) error
func (g *Graph[I, O]) AddEdge(from, to string) error
func (g *Graph[I, O]) AddBranch(from string, branch *GraphBranch) error
func (g *Graph[I, O]) Compile(ctx context.Context, opts ...CompileOption) (Runnable[I, O], error)

type Workflow[I, O any] struct {
    // 私有字段
}

type WorkflowNode struct {
    // 私有字段
}

func (wn *WorkflowNode) AddInput(fromNodeKey string, inputs ...*FieldMapping) *WorkflowNode
func (wn *WorkflowNode) SetStaticValue(path FieldPath, value any) *WorkflowNode

sequenceDiagram
    autonumber
    participant User as 用户
    participant App as 应用层
    participant Chain as Chain编排器
    participant Prompt as ChatTemplate
    participant Model as ChatModel
    participant Tool as ToolsNode
    participant CB as Callbacks

    User->>App: 发送问题
    App->>Chain: Invoke(ctx, input)
    
    Note over Chain: 编译时已构建执行图
    
    Chain->>CB: OnStart(runInfo, input)
    
    Chain->>Prompt: Invoke(ctx, params)
    CB-->>Prompt: 注入回调
    Prompt->>CB: OnStart
    Prompt->>Prompt: 渲染模板
    Prompt->>CB: OnEnd(messages)
    Prompt-->>Chain: []*Message
    
    Chain->>Model: Stream(ctx, messages)
    CB-->>Model: 注入回调
    Model->>CB: OnStartWithStreamInput
    Model->>Model: 调用 LLM API
    Model->>CB: OnEndWithStreamOutput
    Model-->>Chain: StreamReader[Message]
    
    Note over Chain: 判断是否有工具调用
    
    alt 有工具调用
        Chain->>Chain: Concat 流为完整消息
        Chain->>Tool: Invoke(ctx, toolCalls)
        Tool->>Tool: 执行工具
        Tool-->>Chain: []*Message (工具结果)
        Chain->>Model: Generate(ctx, messages)
        Model-->>Chain: Message (最终答案)
    else 无工具调用
        Chain->>Chain: Concat 流为完整消息
    end
    
    Chain->>CB: OnEnd(output)
    Chain-->>App: 最终输出
    App-->>User: 返回结果

// 在 Lambda 节点中实现重试
lambda := compose.InvokableLambda(func(ctx context.Context, input string) (string, error) {
    var lastErr error
    for i := 0; i < 3; i++ {  // 重试3次
        result, err := callExternalAPI(ctx, input)
        if err == nil {
            return result, nil
        }
        lastErr = err
        time.Sleep(time.Second * time.Duration(i+1))  // 指数退避
    }
    return "", lastErr
})

ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

result, err := chain.Invoke(ctx, input)
if errors.Is(err, context.DeadlineExceeded) {
    // 处理超时
}

flowchart TB
    subgraph 核心模块
        Schema[Schema<br/>消息/流/工具]
        Compose[Compose<br/>编排引擎]
        Components[Components<br/>组件抽象]
        Callbacks[Callbacks<br/>回调系统]
    end
    
    subgraph 高级模块
        ADK[ADK<br/>智能体套件]
        Flow[Flow<br/>预制流程]
    end
    
    subgraph 基础设施
        Internal[Internal<br/>内部工具]
        Utils[Utils<br/>工具类]
    end
    
    Compose --> Schema
    Compose --> Callbacks
    Compose --> Components
    Compose --> Internal
    
    Components --> Schema
    Components --> Callbacks
    
    ADK --> Compose
    ADK --> Components
    ADK --> Schema
    
    Flow --> Compose
    Flow --> Components
    
    Callbacks --> Internal
    Utils --> Callbacks

    classDef coreStyle fill:#fff4e1,stroke:#ff9900,stroke-width:2px
    classDef advStyle fill:#e1f5ff,stroke:#0066cc,stroke-width:2px
    classDef infraStyle fill:#f0f0f0,stroke:#666,stroke-width:1px
    
    class Schema,Compose,Components,Callbacks coreStyle
    class ADK,Flow advStyle
    class Internal,Utils infraStyle

// Graph 的 State 提供线程安全的读写
graph := NewGraph[Input, Output](
    WithState(func(ctx context.Context) *MyState {
        return &MyState{Data: make(map[string]any)}
    }),
)

// StatePreHandler 读取状态
graph.AddPreHandler("node1", StatePreHandler(func(ctx context.Context, state *MyState) context.Context {
    // 线程安全地读取 state
    value := state.Data["key"]
    return context.WithValue(ctx, "value", value)
}))

// StatePostHandler 写入状态
graph.AddPostHandler("node1", StatePostHandler(func(ctx context.Context, state *MyState, out any) {
    // 线程安全地写入 state
    state.Data["result"] = out
}))

// 创建并发节点
graph := NewGraph[Input, Output]()
graph.AddLambdaNode("node1", lambda1)
graph.AddLambdaNode("node2", lambda2)
graph.AddLambdaNode("node3", lambda3)

// node1 和 node2 并发执行
graph.AddEdge(START, "node1")
graph.AddEdge(START, "node2")

// node3 等待 node1 和 node2 完成后执行
graph.AddEdge("node1", "node3")
graph.AddEdge("node2", "node3")
graph.AddEdge("node3", END)

// 创建性能监控回调
handler := callbacks.NewHandlerBuilder().
    OnStartFn(func(ctx context.Context, info *RunInfo, input CallbackInput) context.Context {
        start := time.Now()
        return context.WithValue(ctx, "start_time", start)
    }).
    OnEndFn(func(ctx context.Context, info *RunInfo, output CallbackOutput) context.Context {
        start := ctx.Value("start_time").(time.Time)
        duration := time.Since(start)
        // 记录指标
        metrics.RecordDuration(info.Component, info.NodeKey, duration)
        
        // 记录 Token 使用量
        if msg, ok := output.Output.(*schema.Message); ok && msg.ResponseMeta != nil {
            metrics.RecordTokens(msg.ResponseMeta.Usage)
        }
        return ctx
    }).
    OnErrorFn(func(ctx context.Context, info *RunInfo, err error) context.Context {
        metrics.RecordError(info.Component, info.NodeKey, err)
        return ctx
    }).
    Build()

graph := NewGraph[Input, Output](
    WithState(stateGenerator),           // 启用状态管理
    WithGenericState[*MyState](),        // 指定状态类型
    WithNodeTriggerMode(AllPredecessor), // 节点触发模式
)

runnable, err := graph.Compile(ctx,
    WithMaxRunSteps(10),        // 最大迭代次数（Pregel模式）
    WithStreamGraph(true),      // 启用图流式输出
)

result, err := runnable.Invoke(ctx, input,
    WithCallbacks(handler),                        // 添加回调
    WithChatModelOption(WithTemperature(0.7)),     // 配置 ChatModel
    WithToolOption(WithTimeout(30*time.Second)),   // 配置 Tool
)

package main

import (
    "context"
    "fmt"

    "github.com/cloudwego/eino/compose"
    "github.com/cloudwego/eino/schema"
)

func main() {
    ctx := context.Background()

    // 创建一个简单的处理器
    processor := compose.InvokableLambda(func(ctx context.Context, input string) (string, error) {
        return fmt.Sprintf("处理结果: %s", input), nil
    })

    // 创建 Chain
    chain := compose.NewChain[string, string]()
    chain.AppendLambda("processor", processor)

    // 编译
    runnable, err := chain.Compile(ctx)
    if err != nil {
        panic(err)
    }

    // 执行
    result, err := runnable.Invoke(ctx, "你好，Eino!")
    if err != nil {
        panic(err)
    }

    fmt.Println(result)
    // 输出: 处理结果: 你好，Eino!
}

package main

import (
    "context"
    "fmt"

    "github.com/cloudwego/eino/compose"
    "github.com/cloudwego/eino/components/prompt"
    "github.com/cloudwego/eino/schema"
    // 假设你已经实现了 OpenAI ChatModel
    // "your-project/models/openai"
)

func main() {
    ctx := context.Background()

    // 创建 Prompt Template
    chatTemplate := prompt.FromMessages(
        schema.SystemMessage("你是一个有帮助的AI助手"),
        schema.UserMessage("用户问题: {query}"),
    )

    // 创建 ChatModel（示例，实际需要从 eino-ext 导入）
    // chatModel, _ := openai.NewChatModel(ctx, &openai.Config{
    //     APIKey: "your-api-key",
    //     Model:  "gpt-3.5-turbo",
    // })

    // 创建 Chain
    chain := compose.NewChain[map[string]any, *schema.Message]()
    chain.AppendChatTemplate("template", chatTemplate)
    // chain.AppendChatModel("model", chatModel)  // 取消注释以使用真实模型

    // 为了演示，我们用 Lambda 模拟 ChatModel
    mockModel := compose.InvokableLambda(func(ctx context.Context, messages []*schema.Message) (*schema.Message, error) {
        lastMsg := messages[len(messages)-1]
        return schema.AssistantMessage("这是对以下问题的回答: "+lastMsg.Content, nil), nil
    })
    chain.AppendLambda("model", mockModel)

    // 编译并执行
    runnable, _ := chain.Compile(ctx)
    result, _ := runnable.Invoke(ctx, map[string]any{
        "query": "什么是 Eino 框架？",
    })

    fmt.Println(result.Content)
}

package main

import (
    "context"
    "errors"
    "fmt"
    "io"
    "time"

    "github.com/cloudwego/eino/compose"
    "github.com/cloudwego/eino/schema"
)

func main() {
    ctx := context.Background()

    // 创建一个流式 Lambda
    streamLambda := compose.StreamableLambda(func(ctx context.Context, input string) (*schema.StreamReader[string], error) {
        sr, sw := schema.Pipe[string](10)

        go func() {
            defer sw.Close()

            words := []string{"流式", "输出", "示例", "演示"}
            for _, word := range words {
                sw.Send(word+" ", nil)
                time.Sleep(100 * time.Millisecond) // 模拟延迟
            }
        }()

        return sr, nil
    })

    // 创建 Graph
    graph := compose.NewGraph[string, string]()
    graph.AddLambdaNode("streamer", streamLambda)
    graph.AddEdge(compose.START, "streamer")
    graph.AddEdge("streamer", compose.END)

    // 编译
    runnable, _ := graph.Compile(ctx)

    // 流式执行
    stream, _ := runnable.Stream(ctx, "输入")

    // 接收流数据
    defer stream.Close()
    for {
        chunk, err := stream.Recv()
        if errors.Is(err, io.EOF) {
            break
        }
        if err != nil {
            panic(err)
        }
        fmt.Print(chunk)
    }
    // 输出: 流式 输出 示例 演示
}

package main

import (
    "context"
    "fmt"

    "github.com/cloudwego/eino/compose"
    "github.com/cloudwego/eino/schema"
)

func main() {
    ctx := context.Background()

    // 定义工具
    weatherTool := &schema.ToolInfo{
        Name: "get_weather",
        Desc: "获取指定城市的天气",
        ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
            "city": {Type: "string", Desc: "城市名称"},
        }),
    }

    // 创建 ToolsNode
    toolsNode := compose.NewToolsNode()
    toolsNode.RegisterTool(weatherTool, func(ctx context.Context, arguments string) (string, error) {
        return fmt.Sprintf("北京今天晴天，25度"), nil
    })

    // 创建 Graph（ReAct 模式）
    graph := compose.NewGraph[map[string]any, *schema.Message]()

    // 添加 ChatTemplate 节点（处理输入）
    // 添加 ChatModel 节点（生成回复或工具调用）
    // 添加 ToolsNode 节点（执行工具）
    // 添加 Branch 节点（判断是否需要工具调用）

    // (完整实现见 flow/agent/react 包)

    fmt.Println("ReAct Agent 示例（简化版）")
}

package main

import (
    "context"
    "fmt"
    "time"

    "github.com/cloudwego/eino/callbacks"
    "github.com/cloudwego/eino/compose"
)

func main() {
    ctx := context.Background()

    // 创建监控 Handler
    handler := callbacks.NewHandlerBuilder().
        OnStartFn(func(ctx context.Context, info *callbacks.RunInfo, input callbacks.CallbackInput) context.Context {
            fmt.Printf("[%s] 开始执行节点: %s\n", time.Now().Format("15:04:05"), info.NodeKey)
            return context.WithValue(ctx, "start_time", time.Now())
        }).
        OnEndFn(func(ctx context.Context, info *callbacks.RunInfo, output callbacks.CallbackOutput) context.Context {
            start := ctx.Value("start_time").(time.Time)
            duration := time.Since(start)
            fmt.Printf("[%s] 节点 %s 执行完成，耗时: %v\n", time.Now().Format("15:04:05"), info.NodeKey, duration)
            return ctx
        }).
        OnErrorFn(func(ctx context.Context, info *callbacks.RunInfo, err error) context.Context {
            fmt.Printf("[%s] 节点 %s 执行失败: %v\n", time.Now().Format("15:04:05"), info.NodeKey, err)
            return ctx
        }).
        Build()

    // 创建 Chain
    lambda1 := compose.InvokableLambda(func(ctx context.Context, input string) (string, error) {
        time.Sleep(100 * time.Millisecond)
        return input + " -> Lambda1", nil
    })

    lambda2 := compose.InvokableLambda(func(ctx context.Context, input string) (string, error) {
        time.Sleep(150 * time.Millisecond)
        return input + " -> Lambda2", nil
    })

    chain := compose.NewChain[string, string]()
    chain.AppendLambda("lambda1", lambda1)
    chain.AppendLambda("lambda2", lambda2)

    runnable, _ := chain.Compile(ctx)

    // 使用 Callbacks 执行
    result, _ := runnable.Invoke(ctx, "输入", compose.WithCallbacks(handler))

    fmt.Printf("\n最终结果: %s\n", result)
}

[14:30:01] 开始执行节点: lambda1
[14:30:01] 节点 lambda1 执行完成，耗时: 100ms
[14:30:01] 开始执行节点: lambda2
[14:30:01] 节点 lambda2 执行完成，耗时: 150ms

最终结果: 输入 -> Lambda1 -> Lambda2

package main

import (
    "context"
    "fmt"

    "github.com/cloudwego/eino/compose"
    "github.com/cloudwego/eino/schema"
)

type UserInfo struct {
    Name string
    Age  int
}

type ProcessedInfo struct {
    Greeting string
    Category string
}

func main() {
    ctx := context.Background()

    // Lambda 1: 处理姓名
    lambda1 := compose.InvokableLambda(func(ctx context.Context, input struct{ Name string }) (struct{ Greeting string }, error) {
        return struct{ Greeting string }{
            Greeting: "你好, " + input.Name,
        }, nil
    })

    // Lambda 2: 处理年龄
    lambda2 := compose.InvokableLambda(func(ctx context.Context, input struct{ Age int }) (struct{ Category string }, error) {
        category := "成人"
        if input.Age < 18 {
            category = "未成年"
        }
        return struct{ Category string }{Category: category}, nil
    })

    // Lambda 3: 合并结果
    lambda3 := compose.InvokableLambda(func(ctx context.Context, input ProcessedInfo) (*schema.Message, error) {
        content := fmt.Sprintf("%s，您是%s", input.Greeting, input.Category)
        return schema.UserMessage(content), nil
    })

    // 创建 Workflow
    wf := compose.NewWorkflow[UserInfo, *schema.Message]()

    // 添加节点并建立字段映射
    wf.AddLambdaNode("lambda1", lambda1).
        AddInput(compose.START, compose.MapFields("Name", "Name"))

    wf.AddLambdaNode("lambda2", lambda2).
        AddInput(compose.START, compose.MapFields("Age", "Age"))

    wf.AddLambdaNode("lambda3", lambda3).
        AddInput("lambda1", compose.MapFields("Greeting", "Greeting")).
        AddInput("lambda2", compose.MapFields("Category", "Category"))

    wf.End().AddInput("lambda3")

    // 编译并执行
    runnable, _ := wf.Compile(ctx)
    result, _ := runnable.Invoke(ctx, UserInfo{
        Name: "张三",
        Age:  25,
    })

    fmt.Println(result.Content)
    // 输出: 你好, 张三，您是成人
}

// 自定义 ChatModel
type MyChatModel struct {
    // 配置字段
}

func (m *MyChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
    // 实现生成逻辑
    return schema.AssistantMessage("回复内容", nil), nil
}

func (m *MyChatModel) Stream(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.StreamReader[*schema.Message], error) {
    // 实现流式生成逻辑
    sr, sw := schema.Pipe[*schema.Message](10)
    go func() {
        defer sw.Close()
        // 发送流式数据
    }()
    return sr, nil
}

// 使用自定义组件
chain := compose.NewChain[map[string]any, *schema.Message]()
chain.AppendChatModel("my_model", &MyChatModel{})

type MyHandler struct {
    logger *log.Logger
}

func (h *MyHandler) OnStart(ctx context.Context, info *callbacks.RunInfo, input callbacks.CallbackInput) context.Context {
    h.logger.Printf("开始: %s", info.NodeKey)
    return ctx
}

func (h *MyHandler) OnEnd(ctx context.Context, info *callbacks.RunInfo, output callbacks.CallbackOutput) context.Context {
    h.logger.Printf("结束: %s", info.NodeKey)
    return ctx
}

func (h *MyHandler) OnError(ctx context.Context, info *callbacks.RunInfo, err error) context.Context {
    h.logger.Printf("错误: %s, %v", info.NodeKey, err)
    return ctx
}

// 使用自定义 Handler
handler := &MyHandler{logger: log.New(os.Stdout, "", log.LstdFlags)}
runnable.Invoke(ctx, input, compose.WithCallbacks(handler))

// 条件分支 Lambda
branchLambda := compose.InvokableLambda(func(ctx context.Context, input *schema.Message) (string, error) {
    if len(input.ToolCalls) > 0 {
        return "tools", nil  // 有工具调用，走工具路径
    }
    return "end", nil  // 无工具调用，直接结束
})

// 使用 Branch
graph.AddLambdaNode("branch", branchLambda)
graph.AddBranch("model", compose.NewGraphBranch(branchLambda, map[string]string{
    "tools": "tools_node",
    "end":   compose.END,
}))

// 通过 Branch 实现降级
graph.AddBranch("model", compose.NewGraphBranch(
    compose.InvokableLambda(func(ctx context.Context, input *schema.Message) (string, error) {
        if input.ResponseMeta != nil && input.ResponseMeta.FinishReason == "error" {
            return "fallback", nil
        }
        return "normal", nil
    }),
    map[string]string{
        "normal":   compose.END,
        "fallback": "fallback_node",
    },
))

// 在 Lambda 中实现重试逻辑
retryLambda := compose.InvokableLambda(func(ctx context.Context, input string) (string, error) {
    maxRetries := 3
    for i := 0; i < maxRetries; i++ {
        result, err := doSomething(ctx, input)
        if err == nil {
            return result, nil
        }
        if i < maxRetries-1 {
            time.Sleep(time.Second * time.Duration(i+1))
        }
    }
    return "", fmt.Errorf("达到最大重试次数")
})

// 全局监控 Handler
monitorHandler := callbacks.NewHandlerBuilder().
    OnEndFn(func(ctx context.Context, info *callbacks.RunInfo, output callbacks.CallbackOutput) context.Context {
        // 记录延迟
        duration := getDuration(ctx)
        prometheus.RecordLatency(info.Component, duration)
        
        // 记录 Token
        if msg, ok := output.Output.(*schema.Message); ok && msg.ResponseMeta != nil {
            prometheus.RecordTokens(msg.ResponseMeta.Usage.TotalTokens)
        }
        return ctx
    }).
    OnErrorFn(func(ctx context.Context, info *callbacks.RunInfo, err error) context.Context {
        // 记录错误
        prometheus.RecordError(info.Component, err.Error())
        return ctx
    }).
    Build()

// 全局注入
callbacks.AppendGlobalHandlers(monitorHandler)