Eino: ToolsNode 使用说明

// 基础工具接口，提供工具信息
type BaseTool interface {
    Info(ctx context.Context) (*schema.ToolInfo, error)
}

// 可调用的工具接口，支持同步调用
type InvokableTool interface {
    BaseTool
    InvokableRun(ctx context.Context, argumentsInJSON string, opts ...Option) (string, error)
}

// 支持流式输出的工具接口
type StreamableTool interface {
    BaseTool
    StreamableRun(ctx context.Context, argumentsInJSON string, opts ...Option) (*schema.StreamReader[string], error)
}

type ToolInfo struct {
    // 工具的唯一名称，用于清晰地表达其用途
    Name string
    // 用于告诉模型如何/何时/为什么使用这个工具
    // 可以在描述中包含少量示例
    Desc string
    // 工具接受的参数定义
    // 可以通过两种方式描述：
    // 1. 使用 ParameterInfo：schema.NewParamsOneOfByParams(params)
    // 2. 使用 OpenAPIV3：schema.NewParamsOneOfByOpenAPIV3(openAPIV3)
    *ParamsOneOf
}

// 创建工具节点
toolsNode := compose.NewToolsNode([]tool.Tool{
    searchTool,    // 搜索工具
    weatherTool,   // 天气查询工具
    calculatorTool, // 计算器工具
})

// 在 Chain 中使用
chain := compose.NewChain[*schema.Message, []*schema.Message]()
chain.AppendToolsNode(toolsNode)

// 编译并运行
runnable, err := chain.Compile()
if err != nil {
    return err
}

// 输入消息包含工具调用信息
input := &schema.Message{
    Content: "查询深圳明天的天气",
    ToolCalls: []*schema.ToolCall{
        {
            Name: "weather",
            Arguments: `{"city": "深圳", "date": "tomorrow"}`,
        },
    },
}

result, err := runnable.Invoke(ctx, input)

// graph 中
graph := compose.NewGraph[*schema.Message, []*schema.Message]()
chain.AddToolsNode(toolsNode)

// 定义 Option 结构体
type MyToolOptions struct {
    Timeout time.Duration
    MaxRetries int
    RetryInterval time.Duration
}

// 定义 Option 函数
func WithTimeout(timeout time.Duration) tool.Option {
    return tool.WrapToolImplSpecificOptFn(func(o *MyToolOptions) {
        o.Timeout = timeout
    })
}

// 创建 callback handler
handler := &tool.CallbackHandler{
    OnStart: func(ctx context.Context, info *callbacks.RunInfo, input *tool.CallbackInput) context.Context {
        fmt.Printf("开始执行工具，参数: %s\n", input.ArgumentsInJSON)
        return ctx
    },
    OnEnd: func(ctx context.Context, info *callbacks.RunInfo, output *tool.CallbackOutput) context.Context {
        fmt.Printf("工具执行完成，结果: %s\n", output.Response)
        return ctx
    },
    OnEndWithStreamOutput: func(ctx context.Context, info *callbacks.RunInfo, output *schema.StreamReader[*tool.CallbackOutput]) context.Context {
        fmt.Println("工具开始流式输出")
        for chunk := range output.Chan() {
            fmt.Printf("收到流式输出: %s\n", chunk.Response)
        }
        return ctx
    },
}

// 使用 callback handler
helper := template.NewHandlerHelper().
    Tool(handler).
    Handler()

// 在运行时使用
runnable, err := chain.Compile()
if err != nil {
    return err
}
result, err := runnable.Invoke(ctx, input, compose.WithCallbacks(helper))