┌─────────────────────────────────────────────────────────────┐
│                     Supervisor (主管Agent)                    │
│  - 接收用户技术交底书                                           │
│  - 动态分配任务给专业Agent                                      │
│  - 汇总结果，协调工作流                                         │
└─────────────────────────────────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        ↓                     ↓                     ↓
┌───────────────┐    ┌───────────────┐    ┌───────────────┐
│ 检索分析员    │    │ 撰写流水线    │    │ 质量审核员    │
│ (第二阶段已完成)│    │ (Plan-Execute)│    │ (ChatModelAgent)│
└───────────────┘    └───────────────┘    └───────────────┘
                           │
              ┌────────────┴────────────┐
              ↓                         ↓
      ┌───────────────┐         ┌───────────────┐
      │权利要求撰写员 │         │说明书撰写员   │
      │(Sequential)   │         │(Sequential)   │
      └───────────────┘         └───────────────┘

package agents

import (
    "context"
    "fmt"
    "os"
    
    "github.com/cloudwego/eino-ext/components/model/openai"
    "github.com/cloudwego/eino/adk"
    "github.com/cloudwego/eino/schema"
)

// NewClaimWriterAgent 创建权利要求撰写员Agent
func NewClaimWriterAgent(ctx context.Context) (adk.Agent, error) {
    // 初始化ChatModel
    chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:  os.Getenv("OPENAI_MODEL"),
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })
    if err != nil {
        return nil, fmt.Errorf("初始化ChatModel失败: %v", err)
    }
    
    // 创建Agent - 权利要求撰写员不需要工具，纯文本生成
    agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
        Name:        "ClaimWriterAgent",
        Description: "专利权利要求撰写专家，擅长撰写符合专利法要求的权利要求书",
        
        Instruction: `你是一位资深的专利代理人，专精于权利要求撰写。你的工作是基于技术交底书和检索分析报告，撰写高质量的权利要求书。

【工作流程】
1. 理解发明点：仔细阅读用户提供的技术交底书和检索分析报告
2. 确定核心发明点：找出最核心的技术创新点
3. 构建权利要求层次：
   - 独立权利要求（权利要求1）：包含全部必要技术特征，划定最大保护范围
   - 从属权利要求（权利要求2+）：对独立权利要求进行限定，增加具体特征
4. 确保格式规范：
   - 独立权利要求应包含前序部分和特征部分，用"其特征在于"连接
   - 从属权利要求应写明引用关系，如"根据权利要求1所述的方法"
   - 使用规范术语，避免模糊用语

【输出格式】
请直接输出完整的权利要求书，包含所有权利要求项，每项以数字序号开头（如"1."、"2."）。不要添加额外解释。

【示例格式】
1. 一种基于区块链的供应链金融方法，其特征在于，包括：
   - 获取供应链交易数据；
   - 将所述交易数据上链存储；
   - 通过智能合约验证交易真实性；
   - 基于验证结果动态调整信用额度。

2. 根据权利要求1所述的方法，其特征在于，所述验证交易真实性包括：
   - 核对交易双方数字签名；
   - 验证交易时间戳与物流信息匹配。`,
        
        Model: chatModel,
    })
    
    if err != nil {
        return nil, fmt.Errorf("创建权利要求撰写员失败: %v", err)
    }
    
    return agent, nil
}

package agents

import (
    "context"
    "fmt"
    "os"
    
    "github.com/cloudwego/eino-ext/components/model/openai"
    "github.com/cloudwego/eino/adk"
)

// NewSpecWriterAgent 创建说明书撰写员Agent
func NewSpecWriterAgent(ctx context.Context) (adk.Agent, error) {
    chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:  os.Getenv("OPENAI_MODEL"),
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })
    if err != nil {
        return nil, fmt.Errorf("初始化ChatModel失败: %v", err)
    }
    
    agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
        Name:        "SpecWriterAgent",
        Description: "专利说明书撰写专家，擅长撰写完整的专利说明书",
        
        Instruction: `你是一位资深的专利代理人，专精于说明书撰写。你的工作是基于技术交底书、检索分析报告和权利要求书，撰写完整的专利说明书。

【说明书结构】
一篇完整的专利说明书应包含以下五个部分：

1. 【技术领域】
   写明本发明所属的技术领域，例如："本发明涉及区块链技术领域，具体涉及一种基于区块链的供应链金融方法。"

2. 【背景技术】
   介绍现有技术的方案及其缺陷，引出本发明的必要性。应引用对比文件（如有）。

3. 【发明内容】
   包括：
   - 要解决的技术问题：本发明要解决的现有技术存在的问题
   - 技术方案：概述本发明的技术方案，与权利要求相呼应
   - 有益效果：与现有技术相比，本发明带来的技术效果

4. 【附图说明】
   如果有附图，简要说明各附图的内容（本示例暂不考虑附图）

5. 【具体实施方式】
   详细描述本发明的实现方式，应包含多个实施例，支持权利要求的保护范围。
   对于方法权利要求，描述具体步骤和实现细节；
   对于装置/系统权利要求，描述各模块的构成和连接关系。

【撰写要点】
- 充分支持：说明书内容应充分支持权利要求书，不能超出权利要求范围
- 清楚完整：使所属领域技术人员能够实现本发明
- 术语一致：全文术语保持一致
- 实施例丰富：提供多个变体实施例，扩大保护范围

请基于输入信息（技术交底书+检索报告+权利要求书）生成完整的专利说明书。`,
        
        Model: chatModel,
    })
    
    if err != nil {
        return nil, fmt.Errorf("创建说明书撰写员失败: %v", err)
    }
    
    return agent, nil
}

package agents

import (
    "context"
    "fmt"
    "os"
    
    "github.com/cloudwego/eino-ext/components/model/openai"
    "github.com/cloudwego/eino/adk"
    "github.com/cloudwego/eino/components/tool"
    "github.com/cloudwego/eino/schema"
    
    "patent-agent-learning/pkg/tools"
)

// NewQualityReviewerAgent 创建质量审核员Agent
func NewQualityReviewerAgent(ctx context.Context) (adk.Agent, error) {
    chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:  os.Getenv("OPENAI_MODEL"),
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })
    if err != nil {
        return nil, fmt.Errorf("初始化ChatModel失败: %v", err)
    }
    
    // 创建格式检查工具（复用第二阶段的工具）
    claimChecker, err := tools.NewClaimCheckerTool()
    if err != nil {
        return nil, fmt.Errorf("创建格式检查工具失败: %v", err)
    }
    
    // 工具列表
    toolList := []tool.BaseTool{claimChecker}
    
    // 获取工具信息并绑定到模型
    toolInfos := make([]*schema.ToolInfo, 0, len(toolList))
    for _, t := range toolList {
        info, err := t.Info(ctx)
        if err != nil {
            return nil, fmt.Errorf("获取工具信息失败: %v", err)
        }
        toolInfos = append(toolInfos, info)
    }
    
    toolCallingModel, err := chatModel.WithTools(toolInfos)
    if err != nil {
        return nil, fmt.Errorf("绑定工具到模型失败: %v", err)
    }
    
    agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
        Name:        "QualityReviewerAgent",
        Description: "专利质量审核专家，检查专利文档的格式、逻辑和合规性",
        
        Instruction: `你是一位资深的专利审查员，拥有20年专利审查经验。你的工作是对完成的专利文档（权利要求书和说明书）进行质量审核。

【审核维度】
1. 格式合规性：
   - 权利要求格式是否符合专利法要求
   - 说明书结构是否完整（技术领域、背景技术等五部分）
   - 引用关系是否正确

2. 逻辑一致性：
   - 说明书是否充分支持权利要求
   - 术语在全文中是否一致
   - 实施例是否与权利要求对应

3. 新颖性和创造性：
   - 权利要求是否清楚界定了保护范围
   - 是否存在可能的驳回理由

4. 形式缺陷：
   - 错别字、语法错误
   - 标点符号使用是否规范

【工作方式】
- 可以调用 claim_format_checker 工具检查权利要求格式
- 基于你的专业知识进行逻辑审核
- 输出结构化的审核报告，包含缺陷列表和修改建议

【输出格式】
请输出审核报告，包含：
- 总体评价（通过/需修改）
- 缺陷列表（每个缺陷标明位置和类型）
- 修改建议
- 优先级（高/中/低）`,
        
        Model: toolCallingModel,
        ToolsConfig: adk.ToolsConfig{
            Tools: toolList,
        },
        MaxIterations: 5,
    })
    
    if err != nil {
        return nil, fmt.Errorf("创建质量审核员失败: %v", err)
    }
    
    return agent, nil
}

package agents

import (
    "context"
    "fmt"
    "log"
    "os"
    
    "github.com/cloudwego/eino-ext/components/model/openai"
    "github.com/cloudwego/eino/adk"
    "github.com/cloudwego/eino/adk/prebuilt/planexecute"
)

// NewWritingPipelineAgent 创建撰写流水线（基于Plan-Execute模式）
func NewWritingPipelineAgent(ctx context.Context) (adk.Agent, error) {
    // 1. 初始化模型（所有组件共享同一个模型）
    chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:  os.Getenv("OPENAI_MODEL"),
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })
    if err != nil {
        return nil, fmt.Errorf("初始化模型失败: %v", err)
    }
    
    // 确保模型支持工具调用
    toolCallingModel, ok := chatModel.(adk.ToolCallingChatModel)
    if !ok {
        return nil, fmt.Errorf("模型不支持Tool Calling")
    }
    
    // 2. 创建Planner（规划器）- 负责生成撰写计划
    planner, err := planexecute.NewPlanner(ctx, &planexecute.PlannerConfig{
        ToolCallingChatModel: toolCallingModel,
        // 使用默认的PlanToolInfo
    })
    if err != nil {
        return nil, fmt.Errorf("创建Planner失败: %v", err)
    }
    
    // 3. 创建Executor（执行器）- 负责执行当前步骤
    // 创建子Agent（权利要求撰写员和说明书撰写员）
    claimWriter, err := NewClaimWriterAgent(ctx)
    if err != nil {
        return nil, fmt.Errorf("创建权利要求撰写员失败: %v", err)
    }
    
    specWriter, err := NewSpecWriterAgent(ctx)
    if err != nil {
        return nil, fmt.Errorf("创建说明书撰写员失败: %v", err)
    }
    
    // 将子Agent作为工具提供给Executor
    // 注意：在实际的Plan-Execute模式中，Executor需要能够调用这些子Agent
    // 这里简化处理，使用SequentialAgent来保证顺序执行
    
    // 4. 创建Replanner（重规划器）- 负责评估进度
    replanner, err := planexecute.NewReplanner(ctx, &planexecute.ReplannerConfig{
        ChatModel: toolCallingModel,
        // 使用默认的PlanTool和RespondTool
    })
    if err != nil {
        return nil, fmt.Errorf("创建Replanner失败: %v", err)
    }
    
    // 5. 组合成PlanExecuteAgent
    // 注意：这里需要按照Eino ADK的规范来组合
    // 由于planexecute.NewPlanExecuteAgent的API可能有所调整
    // 我们先用SequentialAgent实现一个简化版本
    
    // 简化方案：使用SequentialAgent确保顺序执行
    sequentialAgent := adk.NewSequentialAgent(ctx, &adk.SequentialAgentConfig{
        Name: "WritingPipeline",
        SubAgents: []adk.Agent{
            claimWriter,  // 先写权利要求
            specWriter,   // 再写说明书
        },
    })
    
    log.Println("✅ 撰写流水线创建成功（使用SequentialAgent确保顺序执行）")
    return sequentialAgent, nil
}

package agents

import (
    "context"
    "fmt"
    "os"
    
    "github.com/cloudwego/eino-ext/components/model/openai"
    "github.com/cloudwego/eino/adk"
    "github.com/cloudwego/eino/adk/prebuilt/planexecute"
    "github.com/cloudwego/eino/components/tool"
    "github.com/cloudwego/eino/schema"
)

// NewAdvancedWritingPipeline 创建高级版撰写流水线（完整Plan-Execute模式）
func NewAdvancedWritingPipeline(ctx context.Context) (adk.Agent, error) {
    // 1. 初始化模型
    chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:  os.Getenv("OPENAI_MODEL"),
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })
    if err != nil {
        return nil, fmt.Errorf("初始化模型失败: %v", err)
    }
    
    toolCallingModel, ok := chatModel.(adk.ToolCallingChatModel)
    if !ok {
        return nil, fmt.Errorf("模型不支持Tool Calling")
    }
    
    // 2. 创建子Agent（作为Executor可调用的工具）
    claimWriter, err := NewClaimWriterAgent(ctx)
    if err != nil {
        return nil, err
    }
    
    specWriter, err := NewSpecWriterAgent(ctx)
    if err != nil {
        return nil, err
    }
    
    // 3. 将子Agent封装为Tool（这里需要实现一个AgentTool）
    // 由于篇幅限制，这里略去AgentTool的实现细节
    // 实际项目中，你需要实现一个将Agent包装成Tool的适配器
    
    // 4. 创建Planner
    planner, err := planexecute.NewPlanner(ctx, &planexecute.PlannerConfig{
        ToolCallingChatModel: toolCallingModel,
    })
    if err != nil {
        return nil, err
    }
    
    // 5. 创建Executor，配置工具集
    executor, err := planexecute.NewExecutor(ctx, &planexecute.ExecutorConfig{
        Model: toolCallingModel,
        ToolsConfig: adk.ToolsConfig{
            ToolsNodeConfig: compose.ToolsNodeConfig{
                Tools: []tool.BaseTool{
                    // 这里应该是封装好的AgentTool
                    // agentTool1, agentTool2,
                },
            },
        },
        MaxIterations: 10,
    })
    if err != nil {
        return nil, err
    }
    
    // 6. 创建Replanner
    replanner, err := planexecute.NewReplanner(ctx, &planexecute.ReplannerConfig{
        ChatModel: toolCallingModel,
    })
    if err != nil {
        return nil, err
    }
    
    // 7. 组合成PlanExecuteAgent
    planExecuteAgent, err := planexecute.NewPlanExecuteAgent(ctx, &planexecute.Config{
        Planner:       planner,
        Executor:      executor,
        Replanner:     replanner,
        MaxIterations: 5, // 整个流程最多循环5次
    })
    if err != nil {
        return nil, err
    }
    
    return planExecuteAgent, nil
}

package agents

import (
    "context"
    "fmt"
    "os"
    
    "github.com/cloudwego/eino-ext/components/model/openai"
    "github.com/cloudwego/eino/adk"
    "github.com/cloudwego/eino/adk/prebuilt/supervisor"
)

// NewPatentSupervisor 创建专利主管Agent（Supervisor模式）
func NewPatentSupervisor(ctx context.Context) (adk.Agent, error) {
    // 1. 初始化模型
    chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:  os.Getenv("OPENAI_MODEL"),
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })
    if err != nil {
        return nil, fmt.Errorf("初始化模型失败: %v", err)
    }
    
    // 2. 创建所有子Agent
    fmt.Println("正在创建子Agent...")
    
    // 检索分析员（第二阶段已完成）
    retrievalAnalyst, err := NewRetrievalAnalystAgent(ctx)
    if err != nil {
        return nil, fmt.Errorf("创建检索分析员失败: %v", err)
    }
    
    // 撰写流水线
    writingPipeline, err := NewWritingPipelineAgent(ctx)
    if err != nil {
        return nil, fmt.Errorf("创建撰写流水线失败: %v", err)
    }
    
    // 质量审核员
    qualityReviewer, err := NewQualityReviewerAgent(ctx)
    if err != nil {
        return nil, fmt.Errorf("创建质量审核员失败: %v", err)
    }
    
    fmt.Println("✅ 所有子Agent创建成功")
    
    // 3. 创建Supervisor Agent（监督者）
    // 使用WithDeterministicTransferTo确保子Agent完成后自动回调
    supervisorAgent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
        Name:        "PatentSupervisor",
        Description: "专利撰写项目主管，协调检索、撰写、审核全流程",
        
        Instruction: `你是一位经验丰富的专利项目主管，负责协调整个专利撰写团队。

【团队成员】
- RetrievalAnalystAgent：专利检索分析专家，负责检索现有技术、分析区别特征
- WritingPipelineAgent：撰写流水线，负责撰写权利要求书和说明书（先写权利要求，再写说明书）
- QualityReviewerAgent：质量审核专家，负责审核最终文档

【工作流程】
1. 接收用户输入的技术交底书
2. 首先将任务转交给 RetrievalAnalystAgent，要求其进行专利检索并生成检索分析报告
3. 获取检索报告后，将任务转交给 WritingPipelineAgent，要求其基于技术交底书和检索报告撰写专利文档
4. 获取撰写完成的文档后，将任务转交给 QualityReviewerAgent，要求其进行质量审核
5. 收到审核报告后：
   - 如果审核通过，将最终文档返回给用户
   - 如果需要修改，将审核意见连同文档一起返回给用户，或重新分配给撰写员修改

请严格按照这个流程协调团队工作。`,
        
        Model: chatModel,
    })
    
    if err != nil {
        return nil, fmt.Errorf("创建Supervisor Agent失败: %v", err)
    }
    
    // 4. 使用supervisor.New组合Supervisor和子Agent
    // 这个函数会为每个子Agent添加确定性回调机制
    multiAgent, err := supervisor.New(ctx, &supervisor.Config{
        Supervisor: supervisorAgent,
        SubAgents: []adk.Agent{
            retrievalAnalyst,
            writingPipeline,
            qualityReviewer,
        },
    })
    
    if err != nil {
        return nil, fmt.Errorf("组合Supervisor失败: %v", err)
    }
    
    fmt.Println("✅ 专利主管系统创建成功！")
    return multiAgent, nil
}

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"
    
    "github.com/joho/godotenv"
    "github.com/cloudwego/eino/adk"
    "github.com/cloudwego/eino/schema"
    
    "patent-agent-learning/pkg/agents"
)

func main() {
    // 加载环境变量
    if err := godotenv.Load(); err != nil {
        log.Println("警告: 未找到.env文件，使用系统环境变量")
    }
    
    ctx := context.Background()
    
    // 创建专利主管系统
    fmt.Println("🚀 正在启动专利撰写多智能体系统...")
    startTime := time.Now()
    
    supervisor, err := agents.NewPatentSupervisor(ctx)
    if err != nil {
        log.Fatalf("创建专利主管失败: %v", err)
    }
    
    fmt.Printf("✅ 系统启动完成，耗时: %v\n", time.Since(startTime))
    fmt.Println("===================================")
    
    // 准备用户输入 - 技术交底书
    techDisclosure := `本发明涉及一种基于区块链的供应链金融风控方法。

【技术背景】
传统供应链金融依赖中心化信用评估，存在数据造假、信息不对称等问题。

【发明内容】
本发明提出一种基于区块链的供应链金融风控方法，包括：
1. 将供应链上的交易数据（订单、物流、支付）上链存储
2. 通过智能合约自动验证交易的真实性（核对数字签名、时间戳匹配等）
3. 基于验证结果动态调整参与企业的信用额度和融资利率
4. 当出现异常交易时，自动触发预警并冻结相关资产

【有益效果】
提高风控准确性，降低信用风险，实现自动化风控。`
    
    // 构建用户消息
    userMessage := schema.UserMessage(fmt.Sprintf(`
请帮我撰写一份专利文档。

技术交底书：
%s

要求：
1. 先进行专利检索，分析现有技术
2. 基于检索结果撰写权利要求书和说明书
3. 对完成的文档进行质量审核
4. 输出最终文档和审核报告
    `, techDisclosure))
    
    fmt.Println("📥 用户输入：")
    fmt.Println(techDisclosure)
    fmt.Println("===================================")
    fmt.Println("🤖 系统开始工作，请耐心等待（这可能需要2-3分钟）...")
    fmt.Println()
    
    // 运行系统（流式输出，便于观察执行过程）
    input := &adk.AgentInput{
        Messages:         []*schema.Message{userMessage},
        EnableStreaming:  true,
    }
    
    runner := adk.NewRunner(ctx, adk.RunnerConfig{
        Agent: supervisor,
    })
    
    iter := runner.Run(ctx, input)
    
    // 处理事件流
    var finalResponse string
    stepCount := 0
    
    for {
        event, ok := iter.Next()
        if !ok {
            break
        }
        
        // 如果有错误
        if event.Err != nil {
            fmt.Printf("❌ 错误: %v\n", event.Err)
            continue
        }
        
        // 打印Agent切换信息
        if event.Action != nil && event.Action.TransferToAgent != nil {
            stepCount++
            fmt.Printf("\n【步骤 %d】任务移交给: %s\n", stepCount, event.Action.TransferToAgent.DestAgentName)
        }
        
        // 打印输出内容
        if event.Output != nil && event.Output.MessageOutput != nil {
            msg, err := event.Output.MessageOutput.GetMessage()
            if err == nil && msg != nil && msg.Content != "" {
                // 根据Agent名称不同，用不同颜色或前缀标识（这里简单用文字标识）
                switch event.AgentName {
                case "PatentSupervisor":
                    fmt.Printf("📋 [主管]: %s\n", msg.Content)
                case "RetrievalAnalystAgent":
                    fmt.Printf("🔍 [检索员]: %s\n", msg.Content)
                case "ClaimWriterAgent":
                    fmt.Printf("📝 [权利要求撰写员]: %s\n", msg.Content)
                case "SpecWriterAgent":
                    fmt.Printf("📄 [说明书撰写员]: %s\n", msg.Content)
                case "QualityReviewerAgent":
                    fmt.Printf("✅ [审核员]: %s\n", msg.Content)
                case "WritingPipeline":
                    fmt.Printf("⚙️ [撰写流水线]: %s\n", msg.Content)
                default:
                    fmt.Printf("[%s]: %s\n", event.AgentName, msg.Content)
                }
                
                // 累积最终输出（假设最后一个非空输出是最终结果）
                if event.AgentName == "PatentSupervisor" && msg.Content != "" {
                    finalResponse = msg.Content
                }
            }
        }
    }
    
    fmt.Println("\n===================================")
    fmt.Println("✅ 专利撰写流程完成！")
    
    if finalResponse != "" {
        fmt.Println("\n📄 最终输出摘要：")
        fmt.Println(finalResponse)
    }
}

// 创建一个顺序执行的工作流
sequentialAgent := adk.NewSequentialAgent(ctx, &adk.SequentialAgentConfig{
    Name: "patent_workflow",
    SubAgents: []adk.Agent{
        retrievalAnalyst,  // 1. 先检索
        writingPipeline,   // 2. 再撰写
        qualityReviewer,   // 3. 最后审核
    },
})

// 运行：每个子Agent依次执行，前一个的输出传递给下一个

// 创建一个循环执行的工作流
loopAgent := adk.NewLoopAgent(ctx, &adk.LoopAgentConfig{
    Name: "iterative_improvement",
    SubAgents: []adk.Agent{
        writer,      // 撰写
        reviewer,    // 审核
        improver,    // 根据审核意见修改
    },
    MaxIterations: 3,  // 最多循环3次
})

// 运行：会循环执行 writer -> reviewer -> improver，直到达到最大次数或某个Agent产生ExitAction

// 创建一个并行执行的工作流
parallelAgent := adk.NewParallelAgent(ctx, &adk.ParallelAgentConfig{
    Name: "parallel_search",
    SubAgents: []adk.Agent{
        cnipaSearcher,   // 中国专利局检索
        usptoSearcher,   // 美国专利局检索
        epoSearcher,     // 欧洲专利局检索
    },
})

// 运行：三个检索同时进行，结果合并返回

// 在Agent中获取Session
func someAgentFunction(ctx context.Context) {
    // 获取Session中的所有值
    sessionValues := adk.GetSessionValues(ctx)
    
    // 获取特定键的值
    retrievalReport, exists := adk.GetSessionValue(ctx, "retrieval_report")
    if exists {
        fmt.Printf("找到检索报告: %v\n", retrievalReport)
    }
    
    // 添加值到Session
    adk.AddSessionValue(ctx, "claim_draft", claimText)
    
    // 批量添加
    adk.AddSessionValues(ctx, map[string]any{
        "invention_point": inventionPoint,
        "search_keywords": keywords,
        "search_id":       searchID,
    })
}

// 在Plan-Execute模式中，Session自动管理计划和执行步骤
// PlanSessionKey: 存储当前计划
// ExecutedStepsSessionKey: 存储已执行的步骤

# 克隆官方示例仓库
git clone https://github.com/cloudwego/eino-examples.git
cd eino-examples

# 1. Supervisor模式示例
cd adk/multiagent/supervisor
go run main.go

# 2. Plan-Execute-Replan示例
cd adk/multiagent/plan-execute-replan
go run main.go

# 3. 项目管理器示例（类似我们的专利系统）
cd adk/multiagent/integration-project-manager
go run main.go

# 4. Excel Agent完整实现（最佳实践参考）
cd adk/multiagent/integration-excel-agent
go run main.go

import "github.com/cloudwego/eino/adk/common/tool/graphtool"

// 将编排好的Graph封装为工具
graphTool, err := graphtool.NewInvokableGraphTool(
    graph,                 // 你的Graph
    "patent_search_graph", // 工具名称
    "执行专利检索并分析结果",  // 工具描述
)

// 将工具添加到Agent
agent, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
    Model: model,
    ToolsConfig: adk.ToolsConfig{
        ToolsNodeConfig: compose.ToolsNodeConfig{
            Tools: []tool.BaseTool{graphTool},
        },
    },
})