┌─────────────────────────────────────────────────────────┐
│                      TRPC 服务层                          │
│  Agent Service  │  Tool Service  │  Memory Service       │
│     (gRPC)     │    (gRPC)      │   (gRPC)               │
└─────────────────────────────────────────────────────────┘
                           │
┌─────────────────────────────────────────────────────────┐
│                    Agent Runtime Core                     │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
│  │ Graph    │  │  Tool    │  │ Memory   │  │ A2A     │ │
│  │ Engine   │  │ Runtime  │  │ Manager  │  │ Bridge  │ │
│  └──────────┘  └──────────┘  └──────────┘  └─────────┘ │
└─────────────────────────────────────────────────────────┘
                           │
┌─────────────────────────────────────────────────────────┐
│                  LLM Provider 层                          │
│  OpenAI  │  Claude  │  Qwen  │  DeepSeek  │  自定义...  │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│                   Application Layer                      │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │ Agent   │  │ Agent   │  │ Agent   │  │ Agent   │    │
│  │ 1       │  │ 2       │  │ 3       │  │ N       │    │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘    │
└─────────────────────────────────────────────────────────┘
                           │
┌─────────────────────────────────────────────────────────┐
│                  Event Bus / Orchestrator                │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │ Event   │──│ State   │──│ Tool    │──│ MCP     │    │
│  │ Stream  │  │ Machine │  │ Router  │  │ Discovery│    │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘    │
└─────────────────────────────────────────────────────────┘
                           │
┌─────────────────────────────────────────────────────────┐
│                  Go Kit Middleware Layer                 │
│  Logging  │  Metrics  │  Tracing  │  Rate Limit  │ Retry│
└─────────────────────────────────────────────────────────┘
                           │
┌─────────────────────────────────────────────────────────┐
│                     LLM / Tool 层                        │
│  Any LLM  │  Any Tool  │  MCP Servers  │  Custom Logic  │
└─────────────────────────────────────────────────────────┘

// 注册 MCP 工具服务器
mcpServer := mcp.NewServer("my-tools", mcp.Config{
    Endpoint: "trpc://mcp-service:8080",
})

// 注册工具
mcpServer.RegisterTool("calculator.add", func(ctx context.Context, args mcp.Args) (any, error) {
    return args.GetInt("a") + args.GetInt("b"), nil
})

// 自动发现所有 MCP 服务器
discovery := mcp.NewKubernetesDiscovery("default")
tools, _ := discovery.Discover(ctx)

// 注册所有发现的工具
agent.RegisterTools(tools...)

// Agent A 调用 Agent B
client := a2a.NewClient("trpc://agent-b:8080")
response, err := client.Call(ctx, a2a.Request{
    Task: "分析这段代码的安全漏洞",
    Code: "...",
    Timeout: 30 * time.Second,
})

// Agent A 发布任务
eventBus.Publish(ctx, event.TaskRequested{
    TaskID: "analyze-code-123",
    TaskType: "code_security_analysis",
    Payload: map[string]any{"code": "..."},
})

// Agent B 订阅这个类型的任务，自动认领
agent.Subscribe("code_security_analysis", func(ctx context.Context, task event.Task) error {
    // 处理任务
    result := analyze(task.Payload["code"])
    // 发布结果
    eventBus.Publish(ctx, event.TaskCompleted{TaskID: task.ID, Result: result})
    return nil
})

// 所有指标自动采集，你什么都不用做
// agent_requests_total
// agent_duration_seconds
// tool_calls_total
// llm_tokens_used_total
// ...

// 加日志中间件
agent.Use(middleware.Logger(logger))

// 加指标中间件
agent.Use(middleware.Prometheus(prom))

// 加链路追踪中间件
agent.Use(middleware.OpenTelemetry(tracer))

// 自己写中间件
agent.Use(func(next agent.HandlerFunc) agent.HandlerFunc {
    return func(ctx context.Context, req *agent.Request) (*agent.Response, error) {
        start := time.Now()
        resp, err := next(ctx, req)
        log.Printf("Agent took %v", time.Since(start))
        return resp, err
    }
})

package main

import (
    "context"
    "trpc.group/trpc-go/trpc"
    "trpc.group/trpc-agent-go/agent"
    "trpc.group/trpc-agent-go/tools/git"
    "trpc.group/trpc-agent-go/tools/github"
)

func main() {
    // 创建 Agent 图工作流
    graph := agent.NewGraph("code-review-agent")

    // 步骤 1：获取 PR 变更
    graph.AddNode("fetch_pr", func(ctx context.Context, state *agent.State) error {
        prNumber := state.GetInt("pr_number")
        diff, err := github.GetPRDiff(ctx, "my-org/my-repo", prNumber)
        state.Set("diff", diff)
        return err
    })

    // 步骤 2：分析代码变更
    graph.AddNode("analyze_code", func(ctx context.Context, state *agent.State) error {
        diff := state.GetString("diff")
        review, err := agent.LLM().AnalyzeCode(ctx, diff)
        state.Set("review", review)
        return err
    })

    // 步骤 3：提交评论
    graph.AddNode("post_comment", func(ctx context.Context, state *agent.State) error {
        prNumber := state.GetInt("pr_number")
        review := state.Get("review")
        return github.PostPRComment(ctx, "my-org/my-repo", prNumber, review)
    })

    // 定义执行流程
    graph.AddEdge("fetch_pr", "analyze_code")
    graph.AddEdge("analyze_code", "post_comment")

    // 启动 TRPC 服务
    service := agent.NewService(graph)
    trpc.NewServer().RegisterService(service).Serve()
}

package main

import (
    "context"
    "github.com/agenticgokit/agokit/agent"
    "github.com/agenticgokit/agokit/event"
    "github.com/agenticgokit/agokit/providers/openai"
)

func main() {
    // 初始化事件总线
    bus := event.NewInMemoryBus()

    // 创建 Agent
    codeReviewAgent := agent.New("code-review-agent",
        agent.WithLLM(openai.New(os.Getenv("OPENAI_API_KEY"))),
        agent.WithEventBus(bus),
    )

    // 订阅 PR 提交事件
    bus.Subscribe("pr_submitted", func(ctx context.Context, e event.Event) error {
        prNumber := e.Payload.GetInt("pr_number")

        // 执行代码审查
        result, err := codeReviewAgent.Execute(ctx, agent.Request{
            Task: "Review this PR for bugs, security issues, and code quality",
            Context: map[string]any{
                "pr_number": prNumber,
            },
            Tools: []agent.Tool{
                github.FetchPRDiff("my-org/my-repo"),
                github.PostPRComment("my-org/my-repo"),
            },
        })

        if err == nil {
            bus.Publish(ctx, event.New("review_completed", map[string]any{
                "pr_number": prNumber,
                "result": result.Content,
            }))
        }

        return err
    })

    // 阻塞运行
    select {}
}