1
react.NewAgent({ToolCallingModel, ToolsConfig}) → Stream/Generate
2
react.WithMessageFuture() → 观察中间步骤（无需 Callback）
3
host.NewMultiAgent({Host, Specialists}) → 调度型多 Agent
4
自定义 Graph + State → Plan-Execute / Deer-Go

1
用户输入 → ChatModel 思考 → 需要调 Tool？
2
                              ├─ 是 → 执行 Tool → Tool 结果交还 ChatModel → 继续思考
3
                              └─ 否 → 输出最终答案

1
import (
2
    "github.com/cloudwego/eino/flow/agent/react"
3
    "github.com/cloudwego/eino/compose"
4
)
5

6
rAgent, err := react.NewAgent(ctx, &react.AgentConfig{
7
    ToolCallingModel: arkModel,
8
    ToolsConfig: compose.ToolsNodeConfig{
9
        Tools: []tool.BaseTool{restaurantTool, dishTool},
10
    },
11
})
12

13
// 流式调用（与 ChatModel.Stream 一样的 Recv+EOF 模式）
14
sr, _ := rAgent.Stream(ctx, []*schema.Message{
15
    schema.SystemMessage("你是一个帮助用户推荐餐厅的助手..."),
16
    schema.UserMessage("我在北京，推荐口味辣的菜，至少2家餐厅"),
17
})
18
defer sr.Close()
19

20
for {
21
    msg, err := sr.Recv()
22
    if errors.Is(err, io.EOF) { break }
23
    fmt.Print(msg.Content)
24
}

1
react.NewAgent(ctx, &react.AgentConfig{
2
    MessageModifier: func(_ context.Context, input []*schema.Message) []*schema.Message {
3
        return append([]*schema.Message{schema.SystemMessage(sys)}, input...)
4
    },
5
})

1
toolCallChecker := func(ctx context.Context, sr *schema.StreamReader[*schema.Message]) (bool, error) {
2
    defer sr.Close()
3
    for {
4
        msg, err := sr.Recv()
5
        if errors.Is(err, io.EOF) { break }
6
        if len(msg.ToolCalls) > 0 { return true, nil }
7
    }
8
    return false, nil
9
}

1
anyG, opts := rAgent.ExportGraph()
2
gen := visualize.NewMermaidGenerator("flow/agent/react")
3
g := compose.NewGraph[[]*schema.Message, *schema.Message]()
4
g.AddGraphNode("react_agent", anyG, opts...)
5
g.AddEdge(compose.START, "react_agent")
6
g.AddEdge("react_agent", compose.END)
7
g.Compile(context.Background(), compose.WithGraphCompileCallbacks(gen))

1
config := &AgentConfig{
2
    Model: am,
3
    ToolsConfig: compose.ToolsNodeConfig{
4
        Tools: []tool.BaseTool{summarizeTool, locationTool},
5
    },
6
    ToolReturnDirectly: map[string]struct{}{
7
        "summarize_news": {},  // ← summarize_news 执行完直接结束
8
    },
9
}

1
msg, _ := schema.ConcatAgenticMessages(msgs)
2

3
for _, block := range msg.ContentBlocks {
4
    switch block.Type {
5
    case schema.ContentBlockTypeReasoning:
6
        fmt.Printf("[推理] %s\n", block.Reasoning.Text)
7
    case schema.ContentBlockTypeServerToolCall:
8
        fmt.Printf("[服务端工具] %s\n", block.ServerToolCall.Name)
9
    case schema.ContentBlockTypeAssistantGenText:
10
        fmt.Printf("[输出] %s\n", block.AssistantGenText.Text)
11
    }
12
}

1
type MemoryStore interface {
2
    Write(ctx, sessionID string, msgs []*schema.Message) error
3
    Read(ctx, sessionID string) ([]*schema.Message, error)
4
    Query(ctx, sessionID, text string, limit int) ([]*schema.Message, error)
5
}

1
store := memory.NewInMemoryStore()
2
sessionID := "session:demo"
3

4
// 每轮对话
5
prev, _ := store.Read(ctx, sessionID)                          // 恢复历史
6
eff := append(prev, schema.UserMessage(turn))                  // 拼接新输入
7
sr, _ := agent.Stream(ctx, eff, msgFutureOpt)                  // 执行
8
_ = store.Write(ctx, sessionID, append(eff, produced...))      // 持久化

1
msgFutureOpt, msgFuture := react.WithMessageFuture()
2

3
// 消费中间消息流
4
iter := msgFuture.GetMessageStreams()
5
for {
6
    sr, ok, _ := iter.Next()
7
    if !ok { break }
8
    full, _ := schema.ConcatMessages(readAllChunks(sr))
9
    fmt.Printf("中间消息: role=%s content=%s\n", full.Role, full.Content)
10
}

1
type ChatModel struct {
2
    Model         model.BaseChatModel
3
    GetOptionFunc OptionFunc  // ← 根据 State 返回动态选项
4
}
5

6
func (d *ChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
7
    var dynamicOpts []model.Option
8

9
    compose.ProcessState[*State](ctx, func(_ context.Context, state *State) error {
10
        dynamicOpts = d.GetOptionFunc(ctx, input, state)
11
        state.Iteration++
12
        return nil
13
    })
14

15
    return d.Model.Generate(ctx, input, append(dynamicOpts, opts...)...)
16
}

1
func getDynamicOptions(ctx context.Context, input []*schema.Message, state *State) []model.Option {
2
    if state.Iteration >= 1 {
3
        // 第二轮开始：关闭思考，禁止 Tool 调用
4
        return []model.Option{
5
            ark.WithThinking(&arkModel.Thinking{Type: arkModel.ThinkingTypeDisabled}),
6
            model.WithToolChoice(schema.ToolChoiceForbidden),
7
        }
8
    }
9
    // 第一轮：允许 Tool 调用
10
    return []model.Option{
11
        model.WithToolChoice(schema.ToolChoiceAllowed),
12
        model.WithTools(toolInfos),
13
    }
14
}

1
rAgent, _ := react.NewAgent(ctx, &react.AgentConfig{
2
    ToolsConfig: compose.ToolsNodeConfig{
3
        Tools: []tool.BaseTool{sumTool},
4
        UnknownToolsHandler: func(ctx context.Context, name, input string) (string, error) {
5
            return fmt.Sprintf(
6
                "unknown tool: %s; try again with the correct tool name", name,
7
            ), nil
8
        },
9
    },
10
})

1
用户 → Host（分析意图）
2
         ├─ "写日记" → WriteJournalSpecialist
3
         ├─ "读日记" → ReadJournalSpecialist
4
         └─ "查日记" → AnswerWithJournalSpecialist

1
import "github.com/cloudwego/eino/flow/agent/multiagent/host"
2

3
h := &host.Host{ChatModel: chatModel, SystemPrompt: "..."}
4

5
hostMA, _ := host.NewMultiAgent(ctx, &host.MultiAgentConfig{
6
    Host: *h,
7
    Specialists: []*host.Specialist{writer, reader, answerer},
8
})
9

10
// 多轮对话
11
out, _ := hostMA.Stream(ctx, []*schema.Message{schema.UserMessage(input)},
12
    host.WithAgentCallbacks(cb),  // 可监听 HandOff 事件
13
)

1
Planner（规划者）→ Executor（执行者）⇄ Reviser（审查者）
2
                                             ↓
3
                                    输出"最终答案" → END

1
config := &Config{
2
    PlannerModel:  deepSeekModel,    // 规划者模型
3
    ExecutorModel: arkModel,         // 执行者模型（需支持 ToolCalling）
4
    ReviserModel:  deepSeekModel,    // 审查者模型
5
    ToolsConfig:   compose.ToolsNodeConfig{Tools: toolsConfig},
6
    MaxStep: 100,
7
}

1
for {
2
    result, err := agent.Invoke(ctx, input,
3
        compose.WithCheckPointID("1"),
4
        compose.WithRuntimeMaxSteps(20),
5
    )
6

7
    info, ok := compose.ExtractInterruptInfo(err)
8
    if ok {
9
        // 中断了——展示结果，等待用户确认
10
        fmt.Print("Do you want to continue? (y/n): ")
11
        // ... 读用户输入 ...
12
        continue  // 自动 Resume
13
    }
14
    fmt.Printf("[FinalResult]: %s", result)
15
    break
16
}

1
// 命令行工具（Docker 沙箱）
2
sandbox.NewDockerSandbox(ctx, &sandbox.Config{...})
3

4
// 浏览器工具
5
browseruse.NewBrowserUseTool(ctx, &browseruse.Config{...})
6

7
// 搜索引擎
8
duckduckgo.NewSearch(ctx, &duckduckgo.Config{...})

1
func agentHandOff(ctx context.Context, input string) (next string, err error) {
2
    compose.ProcessState[*model.State](ctx, func(_ context.Context, state *model.State) error {
3
        next = state.Goto
4
        return nil
5
    })
6
    return next, nil
7
}
8

9
// 所有 Agent 节点共享同一个 Branch 函数
10
g.AddBranch(consts.Coordinator, compose.NewGraphBranch(agentHandOff, outMap))
11
g.AddBranch(consts.Planner, compose.NewGraphBranch(agentHandOff, outMap))

1
Coordinator → BackgroundInvestigator → Planner → ResearchTeam
2
                                                      ├─→ Researcher
3
                                                      ├─→ Coder
4
                                                      └─→ Planner（迭代）
5
                                                           └─→ Reporter → Human → Coordinator

1
// ReAct Agent
2
"github.com/cloudwego/eino/flow/agent/react"           // react.NewAgent, WithMessageFuture
3

4
// Multi-Agent
5
"github.com/cloudwego/eino/flow/agent/multiagent/host"  // host.NewMultiAgent, Host, Specialist
6

7
// Compose 底层
8
"github.com/cloudwego/eino/compose"                     // Graph, Branch, ProcessState, ToolNode
9
"github.com/cloudwego/eino/schema"                      // Message, AgenticMessage, ToolInfo
10

11
// Callbacks
12
"github.com/cloudwego/eino/callbacks"                   // Handler, HandlerBuilder
13
"github.com/cloudwego/eino/utils/callbacks"              // NewHandlerHelper

1
Flow 模块核心方法：
2
  react.NewAgent({ToolCallingModel, ToolsConfig})
3
  host.NewMultiAgent({Host, Specialists})
4
  compose.NewGraphBranch(fn, outMap)
5
  compose.ProcessState[T](ctx, fn) — 读写 Graph State
6

7
选型：标准→ADK | 自定义循环→react | 多Agent调度→host | 状态图→Graph+State