┌─────────────────────────────────────────────────────────┐
│                      Agent Layer                        │
│  ┌──────────────────────────────────────────────────┐  │
│  │             Middleware Stack                     │  │
│  │  ┌────────────────────────────────────────────┐  │  │
│  │  │  SummarizationMiddleware (priority: 40)   │  │  │
│  │  │  - Auto summarize (>170k tokens)         │  │  │
│  │  │  - Keep recent 6 messages                 │  │  │
│  │  └────────────────────────────────────────────┘  │  │
│  │  ┌────────────────────────────────────────────┐  │  │
│  │  │  FilesystemMiddleware (priority: 100)     │  │  │
│  │  │  - Tools: [fs_*, bash_*]                  │  │  │
│  │  │  - Auto eviction (>20k tokens)            │  │  │
│  │  └────────────────────────────────────────────┘  │  │
│  │  ┌────────────────────────────────────────────┐  │  │
│  │  │  SubAgentMiddleware (priority: 200)       │  │  │
│  │  │  - Tools: [task]                          │  │  │
│  │  │  - Context isolation                      │  │  │
│  │  └────────────────────────────────────────────┘  │  │
│  │  ┌────────────────────────────────────────────┐  │  │
│  │  │  CustomMiddleware (priority: 500+)        │  │  │
│  │  └────────────────────────────────────────────┘  │  │
│  └──────────────────────────────────────────────────┘  │
│         │ WrapModelCall      │ WrapToolCall            │
│         ▼                    ▼                         │
│  ┌─────────────┐      ┌──────────────┐                │
│  │  Provider   │      │ Tool Executor│                │
│  │  (Stream)   │      │  (Execute)   │                │
│  └─────────────┘      └──────────────┘                │
└─────────────────────────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────┐
│                    Backend Layer                        │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │ StateBackend │  │ StoreBackend │  │FilesystemBE  │  │
│  │  (临时内存)  │  │  (持久化)    │  │  (真实FS)    │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
│                ┌──────────────────┐                     │
│                │ CompositeBackend │                     │
│                │   (路由组合)     │                     │
│                └──────────────────┘                     │
└─────────────────────────────────────────────────────────┘

Request → M1 → M2 → M3 → Handler → M3 → M2 → M1 → Response
          ↓    ↓    ↓              ↑    ↑    ↑
      Before Before Before       After After After

type Middleware interface {
    // 基础信息
    Name() string
    Priority() int  // 0-100: 系统, 100-500: 功能, 500+: 用户

    // 提供工具
    Tools() []tools.Tool

    // 双向拦截
    WrapModelCall(ctx, req, handler) (*ModelResponse, error)
    WrapToolCall(ctx, req, handler) (*ToolCallResponse, error)

    // 生命周期
    OnAgentStart(ctx, agentID) error
    OnAgentStop(ctx, agentID) error
}

// 启用自动总结
config := &types.AgentConfig{
    Middlewares: []string{"summarization"},
}

fsMiddleware := middleware.NewFilesystemMiddleware(&middleware.FilesystemMiddlewareConfig{
    Backend:        backend,
    EnableEviction: true,
    TokenLimit:     20000,
})

subagentMiddleware := middleware.NewSubAgentMiddleware(&middleware.SubAgentMiddlewareConfig{
    Specs: []middleware.SubAgentSpec{
        {Name: "researcher", Description: "Research expert"},
        {Name: "coder", Description: "Coding expert"},
    },
    Factory:        subagentFactory,
    EnableParallel: true,
})

// 创建栈（自动按优先级排序）
stack := middleware.NewStack([]middleware.Middleware{
    fsMiddleware,       // priority: 100
    subagentMiddleware, // priority: 200
    customMiddleware,   // priority: 500
})

// 获取所有工具
tools := stack.Tools()

// 执行模型调用（经过所有中间件）
response := stack.WrapModelCall(ctx, request, finalHandler)

type BackendProtocol interface {
    // 文件操作
    Read(ctx, path, offset, limit) (string, error)
    Write(ctx, path, content) (*WriteResult, error)
    Edit(ctx, path, old, new, replaceAll) (*EditResult, error)

    // 目录操作
    ListInfo(ctx, path) ([]FileInfo, error)
    GlobInfo(ctx, pattern, path) ([]FileInfo, error)

    // 搜索
    GrepRaw(ctx, pattern, path, glob) ([]GrepMatch, error)
}

// 内存临时存储
backend := backends.NewStateBackend()
backend.Write(ctx, "/temp.txt", "content")

// 持久化存储
storeBackend := backends.NewStoreBackend(storeImpl, "agent-id")
storeBackend.Write(ctx, "/memory.txt", "persistent data")

// 真实文件系统
fsBackend := backends.NewFilesystemBackend(sandboxFS)
fsBackend.Write(ctx, "/workspace/output.txt", "result")

// 路由策略：不同路径使用不同后端
composite := backends.NewCompositeBackend(
    backends.NewStateBackend(), // 默认后端
    []backends.RouteConfig{
        {Prefix: "/memories/", Backend: storeBackend},
        {Prefix: "/workspace/", Backend: fsBackend},
    },
)

// /memories/* → 持久化存储
composite.Write(ctx, "/memories/user_profile.json", data)

// /workspace/* → 真实文件系统
composite.Write(ctx, "/workspace/output.py", code)

// 其他路径 → 内存临时存储
composite.Write(ctx, "/temp/cache.txt", temp)

// 订阅Progress通道
progressCh := ag.Subscribe([]types.AgentChannel{
    types.ChannelProgress,
}, nil)

for envelope := range progressCh {
    switch e := envelope.Event.(type) {
    case *types.ProgressTextChunkEvent:
        fmt.Print(e.Delta)  // 流式输出
    case *types.ProgressToolStartEvent:
        fmt.Printf("[Tool] %s\n", e.Call.Name)
    case *types.ProgressToolEndEvent:
        fmt.Printf("[Result] %v\n", e.Result)
    }
}

// 只订阅特定事件类型
eventCh := ag.Subscribe(
    []types.AgentChannel{types.ChannelProgress},
    &types.EventFilter{
        EventTypes: []string{
            "progress.text_chunk",
            "progress.tool_start",
        },
    },
)

type Tool interface {
    Name() string
    Description() string
    InputSchema() map[string]interface{}
    Execute(ctx context.Context, input map[string]interface{}) (interface{}, error)
}

// 创建注册表
registry := tools.NewRegistry()

// 注册所有内置工具
builtin.RegisterAll(registry)

// 或选择性注册
registry.Register(builtin.NewFileSystemTool())
registry.Register(builtin.NewBashTool())

// 注册自定义工具
registry.Register(&MyCustomTool{})

type Provider interface {
    // 流式API
    StreamMessages(ctx, request) (<-chan StreamEvent, error)

    // 非流式API
    Messages(ctx, request) (*Response, error)

    // 模型信息
    Name() string
    SupportedModels() []string
}

// Anthropic
p := provider.NewAnthropicProvider(apiKey)

// OpenAI
p := provider.NewOpenAIProvider(apiKey)

// DeepSeek
p := provider.NewDeepSeekProvider(apiKey)

// 统一接口调用
stream, _ := p.StreamMessages(ctx, request)
for event := range stream {
    // 处理流式事件
}

// 本地沙箱
Sandbox: &types.SandboxConfig{
    Kind:    types.SandboxKindLocal,
    WorkDir: "./workspace",
}

// 阿里云沙箱
Sandbox: &types.SandboxConfig{
    Kind:    types.SandboxKindAliyun,
    WorkDir: "/workspace",
    Config: map[string]interface{}{
        "region":    "cn-hangzhou",
        "accessKey": os.Getenv("ALIYUN_AK"),
        "secretKey": os.Getenv("ALIYUN_SK"),
    },
}

// 定义协议
type BackendProtocol interface { ... }

// 工厂函数
type BackendFactory func(ctx) (BackendProtocol, error)

// 延迟初始化
backend := factory(ctx)

type Middleware interface {
    WrapModelCall(ctx, req, next) (*Response, error)
}

// 自动组合
stack.WrapModelCall(ctx, req, finalHandler)

// 订阅事件
ch := ag.Subscribe(channels, filter)

// 发布事件
ag.Emit(event)