tRPC-Agent-Go：构建智能AI应用的Go语言Agent框架

// Model是所有语言模型必须实现的接口
type Model interface {
    // 生成内容，支持流式响应
    GenerateContent(ctx context.Context, request *Request) (<-chan *Response, error)

    // 返回模型基本信息
    Info() Info
}
 
// 模型信息结构
type Info struct {
    Name string // 模型名称
}

// 创建OpenAI模型
model := openai.New("gpt-4o-mini",
    openai.WithAPIKey("your-api-key"),
    openai.WithBaseURL("https://api.openai.com/v1"), // 可自定义BaseURL
)
 
// 支持自定义配置
model := openai.New("custom-model",
    openai.WithAPIKey("your-api-key"),
    openai.WithBaseURL("https://your-custom-endpoint.com/v1"),
    openai.WithChannelBufferSize(512),
    openai.WithExtraFields(map[string]interface{}{
        "custom_param": "value",
    }),
)

type Agent interface {
    // 执行Agent调用，返回事件流
    Run(ctx context.Context, invocation *Invocation) (<-chan *event.Event, error)

    // 返回Agent可用的工具列表
    Tools() []tool.Tool

    // 返回Agent的基本信息
    Info() Info

    // 返回子Agent列表，支持层次化组合
    SubAgents() []Agent

    // 根据名称查找子Agent
    FindSubAgent(name string) Agent
}

agent := llmagent.New(
    "assistant",
    llmagent.WithModel(openai.New("gpt-4o-mini")),
    llmagent.WithInstruction("你是一个专业的AI助手"),
    llmagent.WithTools([]tool.Tool{calculatorTool, searchTool}),
)

chain := chainagent.New(
    "content-pipeline",
    chainagent.WithSubAgents([]agent.Agent{
        planningAgent,   // 第一步：制定计划
        researchAgent,   // 第二步：收集信息  
        writingAgent,    // 第三步：创作内容
    }),
)

parallel := parallelagent.New(
    "multi-expert-evaluation",
    parallelagent.WithSubAgents([]agent.Agent{
        marketAgent,      // 市场分析专家
        technicalAgent,   // 技术评估专家
        financeAgent,     // 财务分析专家
    }),
)

cycle := cycleagent.New(
    "problem-solver",
    cycleagent.WithSubAgents([]agent.Agent{
        generatorAgent,  // 生成解决方案
        reviewerAgent,   // 评估质量
    }),
    // 设置最大迭代次数为5，防止无限循环
    cycleagent.WithMaxIterations(5),
)

// 创建文档处理工作流
stateGraph := graph.NewStateGraph(graph.MessagesStateSchema())
 
// 创建分析工具
complexityTool := function.NewFunctionTool(
    analyzeComplexity,
    function.WithName("analyze_complexity"),
    function.WithDescription("分析文档复杂度"),
)
tools := map[string]tool.Tool{"analyze_complexity": complexityTool}
 
// 构建工作流图
g, err := stateGraph.
    AddNode("preprocess", preprocessDocument).          // 预处理节点
    AddLLMNode("analyze", model, 
        "分析文档复杂度，使用analyze_complexity工具", tools). // LLM分析节点
    AddToolsNode("tools", tools).                       // 工具节点
    AddNode("route_complexity", routeComplexity).       // 路由决策节点
    AddLLMNode("summarize", model, "总结复杂文档", nil).  // LLM总结节点
    AddLLMNode("enhance", model, "提升简单文档质量", nil). // LLM增强节点
    AddNode("format_output", formatOutput).             // 格式化节点
    SetEntryPoint("preprocess").                        // 设置入口
    SetFinishPoint("format_output").                    // 设置出口
    AddEdge("preprocess", "analyze").                   // 连接节点
    AddToolsConditionalEdges("analyze", "tools", "route_complexity").
    AddConditionalEdges("route_complexity", complexityCondition, map[string]string{
        "simple":  "enhance",
        "complex": "summarize",
    }).
    AddEdge("enhance", "format_output").
    AddEdge("summarize", "format_output").
    Compile()
 
// 创建GraphAgent并运行
graphAgent, err := graphagent.New("document-processor", g,
    graphagent.WithDescription("文档处理工作流"),
    graphagent.WithInitialState(graph.State{}),
)
 
runner := runner.NewRunner("doc-workflow", graphAgent)
events, _ := runner.Run(ctx, userID, sessionID, 
    model.NewUserMessage("处理这个文档内容"))

// 创建专业领域Agent
marketAnalyst := llmagent.New("market-analyst",
    llmagent.WithModel(model),
    llmagent.WithInstruction("你是市场分析专家"),
    llmagent.WithTools([]tool.Tool{marketDataTool}))
 
techArchitect := llmagent.New("tech-architect", 
    llmagent.WithModel(model),
    llmagent.WithInstruction("你是技术架构专家"),
    llmagent.WithTools([]tool.Tool{techAnalysisTool}))
 
// 串行协作：市场分析 → 技术评估
planningChain := chainagent.New("product-planning",
    chainagent.WithSubAgents([]agent.Agent{
        marketAnalyst, techArchitect,
    }))
 
// 并行协作：多专家同时评估
expertPanel := parallelagent.New("expert-panel",
    parallelagent.WithSubAgents([]agent.Agent{
        marketAnalyst, techArchitect,
    }))
 
// 执行多Agent协作
events, err := expertPanel.Run(ctx, &agent.Invocation{
    Message: model.NewUserMessage("分析市场，设计产品方案"),
})

// Event代表Agent执行过程中的一个事件
type Event struct {
    *model.Response      // 嵌入LLM响应的所有字段
    InvocationID string  // 本次调用的唯一标识
    Author       string  // 事件发起者（Agent名称）
    ID           string  // 事件唯一标识
    Timestamp    time.Time // 事件时间戳
    Branch       string  // 分支标识（多Agent协作）
}

// Agent接口定义
type Agent interface {
    Run(ctx context.Context, invocation *Invocation) (<-chan *event.Event, error)
}
 
// 创建Agent并处理事件流
agent := llmagent.New("assistant", 
    llmagent.WithModel(model),
    llmagent.WithTools(tools))
 
events, err := agent.Run(ctx, &agent.Invocation{
    Message: model.NewUserMessage("计算 2+3 等于多少"),
})
 
// 实时处理事件流
for event := range events {
    switch event.Object {
    case "chat.completion.chunk":
        fmt.Print(event.Choices[0].Delta.Content)
    case "tool.response":
        fmt.Printf("\n[%s] 工具执行完成\n", event.Author)
    case "chat.completion":
        if event.Done {
            fmt.Printf("\n[%s] 最终答案: %s\n", 
                event.Author, event.Choices[0].Message.Content)
        }
    case "error":
        fmt.Printf("错误: %s\n", event.Error.Message)
        return event.Error
    }
    if event.Done { break }
}

chainAgent := chainagent.New("chain", 
    chainagent.WithSubAgents([]agent.Agent{
        analysisAgent, solutionAgent,
    }))
 
events, err := chainAgent.Run(ctx, invocation)
if err != nil {
    return err
}
 
for event := range events {
    switch event.Object {
    case "chat.completion.chunk":
        fmt.Print(event.Choices[0].Delta.Content)
    case "chat.completion":
        if event.Done {
            fmt.Printf("[%s] 完成: %s\n", event.Author, 
                event.Choices[0].Message.Content)
        }
    case "tool.response":
        fmt.Printf("[%s] 工具执行完成\n", event.Author)
    case "error":
        fmt.Printf("[%s] 错误: %s\n", event.Author, event.Error.Message)
    }
}

type Invocation struct {
	Agent             Agent                    // 要调用的Agent实例
	AgentName         string                   // Agent名称
	InvocationID      string                   // 调用唯一标识
	Branch            string                   // 分支标识符（多Agent协作）
	EndInvocation     bool                     // 是否结束调用
	Session           *session.Session         // 会话状态
	Model             model.Model              // 语言模型
	Message           model.Message            // 用户消息
	EventCompletionCh <-chan string            // 事件完成信号
	RunOptions        RunOptions               // 运行选项
	TransferInfo      *TransferInfo            // Agent转移信息
	AgentCallbacks    *Callbacks               // Agent回调
	ModelCallbacks    *model.Callbacks         // 模型回调
	ToolCallbacks     *tool.Callbacks          // 工具回调
}
 
type TransferInfo struct {
	TargetAgentName string // 目标Agent名称
	Message         string // 转移消息
	EndInvocation   bool   // 转移后是否结束
}

// 创建 Invocation 对象（高级用法）
invocation := agent.NewInvocation(
    agent.WithInvocationAgent(r.agent),                               // Agent 实例
    agent.WithInvocationSession(&session.Session{ID: "session-001"}), // Session
    agent.WithInvocationEndInvocation(false),                         // 是否结束调用
    agent.WithInvocationMessage(model.NewUserMessage("User input")),  // 用户消息
    agent.WithInvocationModel(modelInstance),                         // 使用的模型
)
 
// 直接调用 Agent（高级用法）
ctx := context.Background()
eventChan, err := llmAgent.Run(ctx, invocation)
if err != nil {
    log.Fatalf("执行 Agent 失败: %v", err)
}

// Planner接口定义了所有规划器必须实现的方法
type Planner interface {
    // 构建规划指令，为LLM请求添加规划相关的系统指令
    BuildPlanningInstruction(
        ctx context.Context,
        invocation *agent.Invocation,
        llmRequest *model.Request,
    ) string

    // 处理规划响应，对LLM的响应进行后处理和结构化
    ProcessPlanningResponse(
        ctx context.Context,
        invocation *agent.Invocation,
        response *model.Response,
    ) *model.Response
}

// 为OpenAI o系列模型配置推理强度
builtinPlanner := builtin.New(builtin.Options{
    ReasoningEffort: stringPtr("medium"), // "low", "medium", "high"
})
 
// 为Claude/Gemini模型启用思考模式
builtinPlanner := builtin.New(builtin.Options{
    ThinkingEnabled: boolPtr(true),
    ThinkingTokens:  intPtr(1000),
})

// 创建带规划能力的Agent
agent := llmagent.New(
    "planning-assistant",
    llmagent.WithModel(openai.New("gpt-4o")),
    llmagent.WithPlanner(reactPlanner), // 集成规划器
    llmagent.WithInstruction("你是一个善于规划的智能助手"),
)
 
// Agent将自动使用规划器来：
// 1. 为复杂任务制定步骤化计划（PLANNING阶段）
// 2. 在执行过程中进行推理分析（REASONING阶段）
// 3. 调用相应工具执行具体操作（ACTION阶段）
// 4. 整合所有信息提供完整答案（FINAL_ANSWER阶段）

// 自定义Reflection规划器示例
type ReflectionPlanner struct {
    maxIterations int
}
 
func (p *ReflectionPlanner) BuildPlanningInstruction(
    ctx context.Context,
    invocation *agent.Invocation,
    llmRequest *model.Request,
) string {
    return `请按以下步骤进行反思式规划：
1. 分析问题并制定初始计划
2. 执行计划并收集结果
3. 反思执行过程，识别问题和改进点
4. 基于反思优化计划并重新执行
5. 重复反思-优化过程直到达到满意结果`
}
 
func (p *ReflectionPlanner) ProcessPlanningResponse(
    ctx context.Context,
    invocation *agent.Invocation,
    response *model.Response,
) *model.Response {
    // 处理反思内容，提取改进建议
    // 实现反思逻辑...
    return response
}
 
// 使用自定义规划器
reflectionPlanner := &ReflectionPlanner{maxIterations: 3}
agent := llmagent.New(
    "reflection-agent",
    llmagent.WithModel(model),
    llmagent.WithPlanner(reflectionPlanner), // 使用自定义规划器
)

// 基础工具接口
type Tool interface {
    Declaration() *Declaration  // 返回工具元数据
}
 
// 同步调用工具接口
type CallableTool interface {
    Call(ctx context.Context, jsonArgs []byte) (any, error)
    Tool
}
 
// 流式工具接口
type StreamableTool interface {
    StreamableCall(ctx context.Context, jsonArgs []byte) (*tool.StreamReader, error)
    Tool
}

// 计算器工具
calculatorTool := function.NewFunctionTool(
    func(ctx context.Context, input struct {
        Expression string `json:"expression"`
    }) (struct {
        Result float64 `json:"result"`
    }, error) {
        result, err := evaluateExpression(input.Expression)
        return struct{Result float64}{result}, err
    },
    function.WithName("calculator"),
    function.WithDescription("执行数学计算"),
)
 
 type weatherInput struct {
    Location string `json:"location"`
  }
 
 type weatherOutput struct {
    Weather string `json:"weather"`
 }
 
// 2. 实现流式工具函数
 func getStreamableWeather(input weatherInput) *tool.StreamReader {
     stream := tool.NewStream(10)
     go func() {
        defer stream.Writer.Close()

        // 模拟逐步返回天气数据
        result := "Sunny, 25°C in " + input.Location
        for i := 0; i < len(result); i++ {
            chunk := tool.StreamChunk{
                Content: weatherOutput{
                    Weather: result[i : i+1],
                },
                Metadata: tool.Metadata{CreatedAt: time.Now()},
            }

            if closed := stream.Writer.Send(chunk, nil); closed {
                break
            }
            time.Sleep(10 * time.Millisecond) // 模拟延迟
        }
    }()

    return stream.Reader
}
 
// 3. 创建流式工具
    weatherStreamTool :=           function.NewStreamableFunctionTool[weatherInput, weatherOutput](
        getStreamableWeather,
        function.WithName("get_weather_stream"),
        function.WithDescription("流式获取天气信息"),
    )
 
// 创建多工具Agent
agent := llmagent.New(
    "multi-tool-assistant",
    llmagent.WithModel(model),
    llmagent.WithTools([]tool.Tool{
        calculatorTool,
        weatherStreamTool,
        duckduckgo.NewTool(),
    }),
)

// STDIO mcp工具 
mcpToolSet := mcp.NewMCPToolSet(
    mcp.ConnectionConfig{
        Transport: "stdio",
        Command:   "python",
        Args:      []string{"-m", "my_mcp_server"},
        Timeout:   10 * time.Second,
    },
)
 
// SSE mcp工具
mcpToolSet := mcp.NewMCPToolSet(
    mcp.ConnectionConfig{
        Transport: "sse",
        ServerURL: "http://localhost:8080/sse",
        Timeout:   10 * time.Second,
        Headers: map[string]string{
            "Authorization": "Bearer your-token",
        },
    },
)
// streamable mcp工具
mcpToolSet := mcp.NewMCPToolSet(
    mcp.ConnectionConfig{
        Transport: "streamable_http",  // 注意：使用完整名称
        ServerURL: "http://localhost:3000/mcp",
        Timeout:   10 * time.Second,
    },
)
 
agent := llmagent.New("mcp-assistant",
    llmagent.WithModel(model),
    llmagent.WithToolSets([]tool.ToolSet{mcpToolSet}))

// CodeExecutor是代码执行的核心接口
type CodeExecutor interface {
    ExecuteCode(context.Context, CodeExecutionInput) (CodeExecutionResult, error)
    CodeBlockDelimiter() CodeBlockDelimiter
}
 
// 代码执行输入和结果
type CodeExecutionInput struct {
    CodeBlocks  []CodeBlock
    ExecutionID string
}
 
type CodeExecutionResult struct {
    Output      string  // 执行输出
    OutputFiles []File  // 生成的文件
}

// 创建本地执行器
localExecutor := local.New(
    local.WithWorkDir("/tmp/code-execution"),
    local.WithTimeout(30*time.Second),
    local.WithCleanTempFiles(true),
)
 
// 集成到Agent
agent := llmagent.New(
    "data-analyst",
    llmagent.WithModel(model),
    llmagent.WithCodeExecutor(localExecutor), // 集成代码执行器
    llmagent.WithInstruction("你是数据分析师，可以执行Python代码"),
)

// 创建容器执行器
containerExecutor, err := container.New(
    container.WithContainerConfig(container.Config{
        Image: "python:3.11-slim",
    }),
    container.WithHostConfig(container.HostConfig{
        AutoRemove:  true,
        NetworkMode: "none",  // 网络隔离
        Resources: container.Resources{
            Memory: 128 * 1024 * 1024,  // 内存限制
        },
    }),
)
 
agent := llmagent.New(
    "secure-analyst",
    llmagent.WithModel(model),
    llmagent.WithCodeExecutor(containerExecutor), // 使用容器执行器
)

// Agent回复包含代码块时会自动执行：
// ```python
// import statistics
// data = [1, 2, 3, 4, 5]
// print(f"平均值: {statistics.mean(data)}")

 
#### 使用示例
 
```go
// 数据分析Agent
dataAgent := llmagent.New(
    "data-scientist",
    llmagent.WithModel(model),
    llmagent.WithCodeExecutor(local.New()),
    llmagent.WithInstruction("你是数据科学家，使用Python标准库进行数据分析"),
)
 
// 用户提问，Agent自动生成并执行代码
runner := runner.NewRunner("analysis", dataAgent)
events, _ := runner.Run(ctx, userID, sessionID, 
    model.NewUserMessage("分析数据: 23, 45, 12, 67, 34, 89"))
 
// Agent自动：
// 1. 生成Python分析代码
// 2. 执行代码获取结果  
// 3. 解读分析结果

type Runner interface {
    Run(
        ctx context.Context,
        userID string,           // 用户标识
        sessionID string,        // 会话标识  
        message model.Message,   // 输入消息
        runOpts ...agent.RunOption, // 运行选项
    ) (<-chan *event.Event, error)   // 返回事件流
}

// 步骤1: 创建Agent
agent := llmagent.New(
    "customer-service-agent",
    llmagent.WithModel(openai.New("gpt-4o-mini")),
    llmagent.WithInstruction("你是专业的客服助手"),
)
 
// 步骤2: 创建Runner并绑定Agent
r := runner.NewRunner(
    "customer-service-app",  // 应用名称
    agent,                   // 绑定Agent
)
ctx := context.Background()
userMessage := model.NewUserMessage("你好！")
eventChan, err := r.Run(ctx, "user1", "session1", userMessage)
if err != nil {
    panic(err)
}
for event := range eventChan {
    if event.Error != nil {
        fmt.Printf("错误: %s\n", event.Error.Message)
        continue
    }
    if len(event.Choices) >0 {
        fmt.Print(event.Choices[0].Delta.Content)
    }
}

type Service interface {
    // 添加新记忆
    AddMemory(ctx context.Context, userKey UserKey, memory string, topics []string) error
    // 更新现有记忆
    UpdateMemory(ctx context.Context, memoryKey Key, memory string, topics []string) error
    // 删除指定记忆
    DeleteMemory(ctx context.Context, memoryKey Key) error
    // 清空用户所有记忆
    ClearMemories(ctx context.Context, userKey UserKey) error
    // 读取最近记忆
    ReadMemories(ctx context.Context, userKey UserKey, limit int) ([]*Entry, error)
    // 搜索记忆
    SearchMemories(ctx context.Context, userKey UserKey, query string) ([]*Entry, error)
    // 获取记忆工具
    Tools() []tool.Tool
}
 
// 数据结构
type Entry struct {
    ID        string    `json:"id"`
    AppName   string    `json:"app_name"`
    UserID    string    `json:"user_id"`
    Memory    *Memory   `json:"memory"`
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}
 
type Memory struct {
    Memory      string     `json:"memory"`
    Topics      []string   `json:"topics,omitempty"`
    LastUpdated *time.Time `json:"last_updated,omitempty"`
}

llmAgent := llmagent.New(
    "memory-assistant",
    llmagent.WithTools(memoryService.Tools()), // ✅ 步骤1：注册工具
)
 
runner := runner.NewRunner(
    "app",
    llmAgent,
    runner.WithMemoryService(memoryService), // ✅ 步骤2：设置服务
)
 

// Agent会自动调用记忆工具：
 
// 记录信息: "我叫张三，住在北京"
// → memory_add("张三住在北京", ["个人信息"])
 
// 查询信息: "我住在哪里？"  
// → memory_search("住址") → 返回相关记忆
 
// 更新信息: "我搬到上海了"
// → memory_update(id, "张三住在上海", ["个人信息"])

Application (应用)
├── User Sessions (用户会话)
│   ├── Session 1 (会话1)
│   │   ├── Session Data (会话数据)
│   │   └── Events (事件列表)
│   └── Session 2 (会话2)
│       ├── Session Data (会话数据)
│       └── Events (事件列表)
└── App Data (应用数据)

// Service定义会话服务的核心接口
type Service interface {
// CreateSession creates a new session.
	CreateSession(ctx context.Context, key Key, state StateMap, options ...Option) (*Session, error)
 
// GetSession gets a session.
	GetSession(ctx context.Context, key Key, options ...Option) (*Session, error)
 
// ListSessions lists all sessions by user scope of session key.
	ListSessions(ctx context.Context, userKey UserKey, options ...Option) ([]*Session, error)
 
// DeleteSession deletes a session.
	DeleteSession(ctx context.Context, key Key, options ...Option) error
 
// AppendEvent appends an event to a session.
	AppendEvent(ctx context.Context, session *Session, event *event.Event, options ...Option) error
 
// Close closes the service.
	Close() error
}

// 内存存储（适用于开发测试）
sessionService := inmemory.NewSessionService()
 
// Redis存储（适用于生产环境）
sessionService, err := redis.NewService(
    redis.WithURL("redis://localhost:6379/0"),
)
 
// 内网版本使用tRPC Redis插件，同样的方式，只需额外引入内网的redis包，即可使用tRPC Redis插件
import _ "git.woa.com/trpc-go/trpc-agent-go/trpc/storage/redis"
 
sessionService, err := redis.NewService(
    redis.WithURL("redis://localhost:6379/0"),
)

// 创建Runner并配置会话服务
runner := runner.NewRunner(
    "my-agent",
    llmAgent,
    runner.WithSessionService(sessionService), // 集成会话管理
)
 
// 使用Runner进行多轮对话
eventChan, err := runner.Run(ctx, userID, sessionID, userMessage)

// Knowledge是知识管理的主要接口
type Knowledge interface {
    // Search执行语义搜索并返回相关结果
    Search(ctx context.Context, req *SearchRequest) (*SearchResult, error)
}
 
// SearchRequest代表带上下文的搜索请求
type SearchRequest struct {
    Query     string                  // 搜索查询文本
    History   []ConversationMessage   // 对话历史用于上下文
    UserID    string                 // 用户标识
    SessionID string                 // 会话标识
}
 
// SearchResult代表知识搜索的结果
type SearchResult struct {
    Document *document.Document // 匹配的文档
    Score    float64           // 相关性分数
    Text     string            // 文档内容
}

// 创建知识库
kb := knowledge.New(
    knowledge.WithVectorStore(inmemory.New()),
    knowledge.WithEmbedder(openai.New()),
    knowledge.WithSources([]source.Source{
        file.New([]string{"./docs/llm.md"}),
        url.New([]string{"https://wikipedia.org/wiki/LLM"}),
    }),
)
 
// 加载知识库
kb.Load(ctx)
 
// 创建带知识库的Agent
agent := llmagent.New(
    "knowledge-assistant",
    llmagent.WithModel(model),
    llmagent.WithKnowledge(kb), // 自动添加knowledge_search工具
    llmagent.WithInstruction("使用knowledge_search工具搜索相关资料来回答问题"),
)

import (
    agentmetric "trpc.group/trpc-go/trpc-agent-go/telemetry/metric"
    agenttrace "trpc.group/trpc-go/trpc-agent-go/telemetry/trace"
)
 
func main() {
    ctx := context.Background()

    // 启动telemetry收集
    cleanupTrace, _ := agenttrace.Start(ctx)  // 默认localhost:4317
    cleanupMetric, _ := agentmetric.Start(ctx) // 默认localhost:4318
    defer cleanupTrace()
    defer cleanupMetric()

    // Agent执行过程将自动记录telemetry数据
    agent := llmagent.New("assistant", 
        llmagent.WithModel(openai.New("gpt-4o-mini")))

    runner := runner.NewRunner("app", agent)
    events, _ := runner.Run(ctx, "user-001", "session-001", 
        model.NewUserMessage("你好"))
}

invocation                              # 对话顶层span
├── call_llm                           # LLM API调用
├── execute_tool calculator            # 工具调用
├── execute_tool search                # 工具调用
└── execute_tool (merged)              # 并行工具调用合并
 
# GraphAgent执行链路
invocation
└── execute_graph
    ├── execute_node preprocess
    ├── execute_node analyze
    │   └── run_model
    └── execute_node format

cleanupTrace, _ := agenttrace.Start(ctx,
    agenttrace.WithEndpoint("otel-collector:4317"))

counter, _ := metric.Meter.Int64Counter("agent.requests.total")
counter.Add(ctx, 1, metric.WithAttributes(
    attribute.String("agent.name", "assistant")))

// 步骤1: 准备Agent实例
agents := map[string]agent.Agent{
    "chat-assistant": llmagent.New(
        "chat-assistant",
        llmagent.WithModel(openai.New("gpt-4o-mini")),
        llmagent.WithInstruction("你是一个智能助手"),
    ),
}
 
// 步骤2: 创建Debug Server
debugServer := debug.New(agents)
 
// 步骤3: 启动HTTP服务器
http.Handle("/", debugServer.Handler())
log.Fatal(http.ListenAndServe(":8080", nil))

	_ = model.NewCallbacks().
		RegisterBeforeModel(func(ctx context.Context, req *model.Request) (*model.Response, error) {
			fmt.Printf("🌐 Global BeforeModel: processing %d messages\n", len(req.Messages))
return nil, nil
		}).
		RegisterAfterModel(func(ctx context.Context, req *model.Request, rsp *model.Response, modelErr error) (*model.Response, error) {
if modelErr != nil {
				fmt.Printf("🌐 Global AfterModel: error occurred\n")
			} else {
				fmt.Printf("🌐 Global AfterModel: processed successfully\n")
			}
return nil, nil
		})
 

	_ = tool.NewCallbacks().
		RegisterBeforeTool(func(ctx context.Context, toolName string, toolDeclaration *tool.Declaration, jsonArgs []byte) (any, error) {
			fmt.Printf("🌐 Global BeforeTool: executing %s\n", toolName)
return nil, nil
		}).
		RegisterAfterTool(func(ctx context.Context, toolName string, toolDeclaration *tool.Declaration, jsonArgs []byte, result any, runErr error) (any, error) {
if runErr != nil {
				fmt.Printf("🌐 Global AfterTool: %s failed\n", toolName)
			} else {
				fmt.Printf("🌐 Global AfterTool: %s completed\n", toolName)
			}
return nil, nil
		})

	_ = agent.NewCallbacks().
		RegisterBeforeAgent(func(ctx context.Context, invocation *agent.Invocation) (*model.Response, error) {
			fmt.Printf("🌐 Global BeforeAgent: starting %s\n", invocation.AgentName)
return nil, nil
		}).
		RegisterAfterAgent(func(ctx context.Context, invocation *agent.Invocation, runErr error) (*model.Response, error) {
if runErr != nil {
				fmt.Printf("🌐 Global AfterAgent: execution failed\n")
			} else {
				fmt.Printf("🌐 Global AfterAgent: execution completed\n")
			}
return nil, nil
		})
)
 

// 创建带回调的Agent
agent := llmagent.New(
    "callback-demo",
    llmagent.WithModel(model),
    llmagent.WithModelCallbacks(modelCallbacks),
    llmagent.WithToolCallbacks(toolCallbacks),
    llmagent.WithAgentCallbacks(agentCallbacks),
)
 
// 创建Runner并执行
runner := runner.NewRunner(
    "callback-app",
    agent,
    runner.WithSessionService(sessionService),
)
 
// 执行对话
events, err := runner.Run(ctx, userID, sessionID, 
    model.NewUserMessage("Hello"))

// 步骤1: 创建Agent
agent := llmagent.New(
    "my-agent",
    llmagent.WithModel(openai.New("gpt-4o-mini")),
    llmagent.WithInstruction("你是一个智能助手"),
)
 
// 步骤2: 创建A2A服务器
a2aServer, err := a2a.New(
    a2a.WithAgent(agent,true),           // 绑定Agent
    a2a.WithHost("localhost:8080"), // 设置监听地址
)
if err != nil {
    log.Fatal(err)
}
 
// 步骤3: 启动服务器
ctx := context.Background()
if err := a2aServer.Start(ctx); err != nil {
    log.Fatal(err)
}
 
log.Println("A2A服务器已启动: localhost:8080")