golang/eino eino框架的基础使用 在ChatModel中使用工具

package main

import (
    "bufio"
    "cc/tools"
    "context"
    "errors"
    "flag"
    "fmt"
    "io"
    "math"
    "os"
    "strings"
    "time"

    "github.com/cloudwego/eino-ext/components/model/openai"
    "github.com/cloudwego/eino/components/model"
    "github.com/cloudwego/eino/schema"
)

func main() {
    var instruction string
    flag.StringVar(&instruction, "instruction", "You are a helpful assistant.", "")
    flag.Parse()

    ctx := context.Background()

    globTool := tools.GlobTool{}
    toolInfo, err := globTool.Info(ctx)
    if err != nil {
        _, _ = fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }

    // tool registry: name → InvokableRun
    toolRegistry := map[string]func(context.Context, string) (string, error){
        globTool.Name(): func(c context.Context, args string) (string, error) {
            return globTool.InvokableRun(c, args)
        },
    }

    cm, err := newChatModel(ctx)
    if err != nil {
        _, _ = fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }

    cm, _ = cm.WithTools([]*schema.ToolInfo{toolInfo})

    fmt.Println("Chat session started. Type 'exit' or 'quit' to end.")
    scanner := bufio.NewScanner(os.Stdin)

    messages := []*schema.Message{
        schema.SystemMessage(instruction),
    }
    for {
        fmt.Print("\n[User] ")
        if !scanner.Scan() {
            break
        }

        query := strings.TrimSpace(scanner.Text())
        if query == "" {
            continue
        }

        if query == "exit" || query == "quit" {
            break
        }

        messages = append(messages, schema.UserMessage(query))

        fmt.Print("[Assistant] ")

        // Agentic loop: keep calling the model until it stops issuing tool calls.
        for {
            stream, err := streamWithRetry(ctx, cm, messages)
            if err != nil {
                fmt.Fprintf(os.Stderr, "\nError: %v\n", err)
                break
            }

            var textContent string
            var toolCallFrames []*schema.Message
            for {
                frame, err := stream.Recv()
                if errors.Is(err, io.EOF) {
                    break
                }
                if err != nil {
                    fmt.Fprintf(os.Stderr, "\nStream error: %v\n", err)
                    break
                }
                if frame == nil {
                    continue
                }
                if frame.Content != "" {
                    textContent += frame.Content
                    fmt.Print(frame.Content)
                }
                if len(frame.ToolCalls) > 0 {
                    toolCallFrames = append(toolCallFrames, frame)
                }
            }
            stream.Close()

            if len(toolCallFrames) == 0 {
                // No tool calls — we have the final answer.
                messages = append(messages, schema.AssistantMessage(textContent, nil))
                break
            }

            // Concatenate streaming tool-call chunks into a single message.
            assistantMsg, err := schema.ConcatMessages(toolCallFrames)
            if err != nil {
                fmt.Fprintf(os.Stderr, "\nError concatenating tool calls: %v\n", err)
                break
            }
            messages = append(messages, assistantMsg)

            // Execute each tool call and append its result.
            for _, tc := range assistantMsg.ToolCalls {
                fn, ok := toolRegistry[tc.Function.Name]
                if !ok {
                    fmt.Fprintf(os.Stderr, "\nUnknown tool: %s\n", tc.Function.Name)
                    messages = append(messages, schema.ToolMessage(
                        fmt.Sprintf("error: unknown tool %q", tc.Function.Name), tc.ID,
                    ))
                    continue
                }
                result, err := fn(ctx, tc.Function.Arguments)
                if err != nil {
                    result = fmt.Sprintf("error: %v", err)
                }
                fmt.Printf("\n[Tool: %s] %s\n[Assistant] ", tc.Function.Name, result)
                messages = append(messages, schema.ToolMessage(result, tc.ID))
            }
            // Continue loop — ask model for next response.
        }

        fmt.Println()
    }
}

// streamWithRetry calls cm.Stream with exponential backoff on 429 errors.
func streamWithRetry(ctx context.Context, cm model.ToolCallingChatModel, messages []*schema.Message) (*schema.StreamReader[*schema.Message], error) {
    const maxRetries = 5
    const baseDelay = time.Second

    for attempt := range maxRetries {
        stream, err := cm.Stream(ctx, messages)
        if err == nil {
            return stream, nil
        }
        if !strings.Contains(err.Error(), "429") || attempt == maxRetries-1 {
            return nil, err
        }
        delay := time.Duration(math.Pow(2, float64(attempt))) * baseDelay
        fmt.Fprintf(os.Stderr, "\n[rate limited, retrying in %s]\n[Assistant] ", delay)
        select {
        case <-time.After(delay):
        case <-ctx.Done():
            return nil, ctx.Err()
        }
    }
    panic("unreachable")
}

func newChatModel(ctx context.Context) (model.ToolCallingChatModel, error) {
    return openai.NewChatModel(ctx, &openai.ChatModelConfig{
        APIKey:  "",
        Model:   "qwen/qwen3.6-plus:free",
        BaseURL: "https://openrouter.ai/api/v1",
    })
}

Chat session started. Type 'exit' or 'quit' to end.

[User] 帮我分析下当前目录的结构
[Assistant] 
[rate limited, retrying in 1s]
[Assistant]
[Tool: Glob] go.sum
go.mod
docs/01.md
docs/02.md
tools/glob.go
main.go

[Assistant] 当前目录结构如下：

```
.
├── main.go          # 主入口文件
├── go.mod           # Go 模块依赖文件
├── go.sum           # Go 依赖校验文件（自动生成）
├── docs/            # 文档目录
│   ├── 01.md
│   └── 02.md
└── tools/           # 工具包目录
    └── glob.go      # glob 工具源码
```

**说明**：
- **Go 项目**：这是一个标准的 Go 项目，包含 `go.mod` 和 `go.sum` 依赖管理文件，以及一个可执行的入口文件 `main.go`
- **docs/**：存放了一些文档文件（01.md, 02.md），可能是使用说明或笔记
- **tools/glob.go**：一个工具包，从文件名来看，似乎是与文件 glob 匹配功能相关的代码

需要我查看某个具体文件的内容吗？

[User]