flowchart TB
    subgraph 消息系统["消息系统 (Message System)"]
        Message["Message<br/>核心消息结构"]
        MessagePart["ChatMessagePart<br/>多模态内容"]
        ToolCall["ToolCall<br/>工具调用"]
        RoleType["RoleType<br/>角色类型"]
        ResponseMeta["ResponseMeta<br/>响应元信息"]
    end

    subgraph 流处理系统["流处理系统 (Stream Processing)"]
        StreamReader["StreamReader<br/>流读取器"]
        StreamWriter["StreamWriter<br/>流写入器"]
        Pipe["Pipe()<br/>创建流管道"]
        StreamOps["流操作<br/>Copy/Merge/Convert"]
    end

    subgraph 工具系统["工具系统 (Tool System)"]
        ToolInfo["ToolInfo<br/>工具定义"]
        ParamsOneOf["ParamsOneOf<br/>参数定义"]
        ParameterInfo["ParameterInfo<br/>参数信息"]
        ToolChoice["ToolChoice<br/>工具选择策略"]
    end

    subgraph 文档系统["文档系统 (Document System)"]
        Document["Document<br/>文档结构"]
        DocMetaData["MetaData<br/>元数据"]
    end

    subgraph 模板系统["模板系统 (Template System)"]
        MessagesTemplate["MessagesTemplate<br/>消息模板接口"]
        FormatType["FormatType<br/>模板类型"]
        FormatFunc["formatContent()<br/>渲染函数"]
    end

    Message --> MessagePart
    Message --> ToolCall
    Message --> RoleType
    Message --> ResponseMeta

    StreamReader --> StreamWriter
    Pipe --> StreamReader
    Pipe --> StreamWriter
    StreamReader --> StreamOps

    ToolInfo --> ParamsOneOf
    ParamsOneOf --> ParameterInfo
    ToolInfo --> ToolChoice

    Document --> DocMetaData

    MessagesTemplate --> Message
    MessagesTemplate --> FormatType
    FormatType --> FormatFunc

    classDef messageStyle fill:#e1f5ff,stroke:#0066cc,stroke-width:2px
    classDef streamStyle fill:#fff4e1,stroke:#ff9900,stroke-width:2px
    classDef toolStyle fill:#e8f5e8,stroke:#009900,stroke-width:2px
    classDef docStyle fill:#f0f0f0,stroke:#666,stroke-width:1px
    classDef templateStyle fill:#ffe1f0,stroke:#cc0066,stroke-width:1px

    class 消息系统 messageStyle
    class 流处理系统 streamStyle
    class 工具系统 toolStyle
    class 文档系统 docStyle
    class 模板系统 templateStyle

// Message 是 LLM 交互的核心消息结构
type Message struct {
    Role             RoleType          // 角色: system/user/assistant/tool
    Content          string            // 文本内容
    MultiContent     []ChatMessagePart // 多模态内容
    Name             string            // 可选的名称标识
    ToolCalls        []ToolCall        // 助手返回的工具调用列表
    ToolCallID       string            // 工具消息的调用ID
    ToolName         string            // 工具名称
    ResponseMeta     *ResponseMeta     // 响应元信息
    ReasoningContent string            // 推理过程内容
    Extra            map[string]any    // 扩展字段
}

type ToolCall struct {
    Index    *int         // 索引（流式模式下用于合并）
    ID       string       // 工具调用唯一ID
    Type     string       // 类型，默认 "function"
    Function FunctionCall // 函数调用信息
    Extra    map[string]any
}

type FunctionCall struct {
    Name      string // 函数名
    Arguments string // JSON 格式的参数
}

type ChatMessagePart struct {
    Type     ChatMessagePartType // text/image_url/audio_url/video_url/file_url
    Text     string              // 文本内容
    ImageURL *ChatMessageImageURL // 图片URL
    AudioURL *ChatMessageAudioURL // 音频URL
    VideoURL *ChatMessageVideoURL // 视频URL
    FileURL  *ChatMessageFileURL  // 文件URL
}

type StreamReader[T any] struct {
    typ readerType  // 读取器类型
    
    st  *stream[T]              // 基础流实现
    ar  *arrayReader[T]         // 数组读取器
    msr *multiStreamReader[T]   // 多流合并读取器
    srw *streamReaderWithConvert[T] // 带转换的读取器
    csr *childStreamReader[T]   // 子流读取器（用于Copy）
}

// 读取器类型
const (
    readerTypeStream        // 基于 channel 的流
    readerTypeArray         // 基于数组的流
    readerTypeMultiStream   // 多流合并
    readerTypeWithConvert   // 带类型转换
    readerTypeChild         // Copy 产生的子流
)

// stream 是基于 channel 的流，1个发送者和1个接收者
type stream[T any] struct {
    items  chan streamItem[T] // 数据通道
    closed chan struct{}      // 关闭信号通道
    
    automaticClose bool       // 是否启用自动关闭（GC时）
    closedFlag     *uint32    // 关闭标志（用于自动关闭）
}

type streamItem[T any] struct {
    chunk T     // 数据块
    err   error // 错误（如果有）
}

type ToolInfo struct {
    Name  string       // 工具名称，唯一标识
    Desc  string       // 工具描述，告诉模型何时使用
    Extra map[string]any // 扩展信息
    *ParamsOneOf       // 参数定义（可选）
}

params := &ParameterInfo{
    Type: Object,
    SubParams: map[string]*ParameterInfo{
        "city": {
            Type:     String,
            Desc:     "城市名称",
            Required: true,
        },
        "unit": {
            Type:     String,
            Desc:     "温度单位",
            Enum:     []string{"celsius", "fahrenheit"},
            Required: false,
        },
    },
}

toolInfo := &ToolInfo{
    Name:        "get_weather",
    Desc:        "获取指定城市的天气",
    ParamsOneOf: NewParamsOneOfByParams(map[string]*ParameterInfo{
        "city": params.SubParams["city"],
        "unit": params.SubParams["unit"],
    }),
}

jsonSchema := &jsonschema.Schema{
    Type: "object",
    Properties: orderedmap.New[string, *jsonschema.Schema](),
    Required: []string{"city"},
}
jsonSchema.Properties.Set("city", &jsonschema.Schema{
    Type:        "string",
    Description: "城市名称",
})

toolInfo := &ToolInfo{
    Name:        "get_weather",
    Desc:        "获取指定城市的天气",
    ParamsOneOf: NewParamsOneOfByJSONSchema(jsonSchema),
}

type Document struct {
    ID       string         // 文档唯一标识
    Content  string         // 文档内容
    MetaData map[string]any // 元数据
}

// 评分相关
doc.WithScore(0.95)  // 设置相关性评分
score := doc.Score() // 获取评分

// 子索引
doc.WithSubIndexes([]string{"index1", "index2"})
indexes := doc.SubIndexes()

// 向量
doc.WithDenseVector([]float64{0.1, 0.2, 0.3})
vector := doc.DenseVector()

doc.WithSparseVector(map[int]float64{0: 0.5, 10: 0.8})
sparse := doc.SparseVector()

// 额外信息
doc.WithExtraInfo("这是一篇技术文档")
info := doc.ExtraInfo()

// DSL信息（用于查询）
doc.WithDSLInfo(map[string]any{"filter": "category:tech"})
dsl := doc.DSLInfo()

type MessagesTemplate interface {
    Format(ctx context.Context, vs map[string]any, formatType FormatType) ([]*Message, error)
}

// 1. 单条消息模板
msg := schema.UserMessage("你好，{name}！")
formatted, _ := msg.Format(ctx, map[string]any{"name": "Eino"}, schema.FString)
// formatted[0].Content = "你好，Eino！"

// 2. 消息占位符
template := prompt.FromMessages(
    schema.SystemMessage("你是一个有帮助的助手"),
    schema.MessagesPlaceholder("history", false), // 插入历史消息
    schema.UserMessage("问题：{query}"),
)

params := map[string]any{
    "history": []*schema.Message{
        schema.UserMessage("我是谁？"),
        schema.AssistantMessage("你是用户", nil),
    },
    "query": "今天天气怎么样？",
}

messages, _ := template.Format(ctx, params, schema.FString)

// ConcatMessages 有严格的约束
func ConcatMessages(msgs []*Message) (*Message, error) {
    // 1. 所有消息的 Role 必须相同
    // 2. 所有消息的 Name 必须相同（如果有）
    // 3. 所有消息的 ToolCallID 必须相同（如果有）
    // 4. ToolCalls 通过 Index 合并，Index 相同的合并为一个
    // 5. Content 按顺序拼接
}

// Pipe 创建的流有缓冲区限制
sr, sw := schema.Pipe[string](10) // 缓冲区大小为 10

// 发送满后会阻塞
for i := 0; i < 20; i++ {
    sw.Send(fmt.Sprintf("data-%d", i), nil) // 第11次会阻塞，直到接收端读取
}

// Copy 创建独立的读取器，共享底层数据
readers := sr.Copy(3) // 创建3个独立读取器

// 原流 sr 不可再使用
// 每个 reader 可独立读取，互不影响
for i, r := range readers {
    go func(idx int, reader *StreamReader[string]) {
        defer reader.Close()
        for {
            chunk, err := reader.Recv()
            if err == io.EOF {
                break
            }
            // 处理 chunk
        }
    }(i, r)
}

// ParamsOneOf 可以转换为 JSONSchema 或 OpenAPIV3
paramsOneOf := NewParamsOneOfByParams(params)

// 转换为 JSONSchema（推荐）
jsonSchema, err := paramsOneOf.ToJSONSchema()

// 转换为 OpenAPIV3（已废弃）
openAPIV3, err := paramsOneOf.ToOpenAPIV3()

sr := schema.Pipe[string](10)

// 启用自动关闭，GC 时自动释放资源
sr.SetAutomaticClose()

// 无需手动 Close，GC 会自动清理
// 但手动 Close 更可控

type MyCustomTemplate struct {
    template string
}

func (t *MyCustomTemplate) Format(ctx context.Context, vs map[string]any, formatType FormatType) ([]*Message, error) {
    // 自定义渲染逻辑
    content := renderTemplate(t.template, vs)
    return []*Message{
        schema.UserMessage(content),
    }, nil
}

// 将 Message 流转换为纯文本流
textStream := schema.StreamReaderWithConvert(messageStream, func(msg *schema.Message) (string, error) {
    if msg.Content == "" {
        return "", schema.ErrNoValue // 跳过空消息
    }
    return msg.Content, nil
})

doc := &schema.Document{
    ID:      "doc-1",
    Content: "文档内容",
    MetaData: map[string]any{
        "author":     "张三",
        "created_at": time.Now(),
        "tags":       []string{"tech", "ai"},
        "custom":     myCustomData,
    },
}

// ConcatMessages 使用 strings.Builder 优化
// 时间复杂度：O(n × m)，n 为消息数，m 为平均内容长度
// 空间复杂度：O(总内容长度)

// 性能测试（参考值）：
// 1000条消息，每条100字符：约 1ms
// 10000条消息，每条100字符：约 10ms

// 启用自动关闭
sr.SetAutomaticClose()
// GC 时自动调用 Close()

sr, sw := schema.Pipe[string](10)

// 发送端
go func() {
    defer sw.Close() // 确保关闭
    for _, item := range items {
        sw.Send(item, nil)
    }
}()

// 接收端
defer sr.Close() // 确保关闭
for {
    chunk, err := sr.Recv()
    if err == io.EOF {
        break
    }
    // 处理 chunk
}

// 创建系统消息
sysMsg := schema.SystemMessage("你是一个有帮助的AI助手")

// 创建用户消息
userMsg := schema.UserMessage("什么是 Eino 框架？")

// 创建带工具调用的助手消息
toolCalls := []schema.ToolCall{
    {
        ID:   "call-1",
        Type: "function",
        Function: schema.FunctionCall{
            Name:      "search_web",
            Arguments: `{"query":"Eino framework"}`,
        },
    },
}
assistantMsg := schema.AssistantMessage("让我搜索一下", toolCalls)

// 创建工具响应消息
toolMsg := schema.ToolMessage(
    "搜索结果：Eino 是一个 Go 语言的 LLM 应用开发框架",
    "call-1",
    schema.WithToolName("search_web"),
)

// 接收流式消息并拼接
var chunks []*schema.Message
defer stream.Close()

for {
    chunk, err := stream.Recv()
    if err == io.EOF {
        break
    }
    if err != nil {
        return err
    }
    chunks = append(chunks, chunk)
}

// 拼接为完整消息
fullMessage, err := schema.ConcatMessages(chunks)
if err != nil {
    return err
}

fmt.Println(fullMessage.Content)

// 定义天气查询工具
weatherTool := &schema.ToolInfo{
    Name: "get_weather",
    Desc: "获取指定城市的天气信息。当用户询问天气时使用此工具。",
    ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
        "city": {
            Type:     schema.String,
            Desc:     "城市名称，例如：北京、上海",
            Required: true,
        },
        "unit": {
            Type:     schema.String,
            Desc:     "温度单位",
            Enum:     []string{"celsius", "fahrenheit"},
            Required: false,
        },
    }),
}

// 定义数学计算工具
calcTool := &schema.ToolInfo{
    Name: "calculator",
    Desc: "执行数学计算。支持加减乘除和基础数学函数。",
    ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
        "expression": {
            Type:     schema.String,
            Desc:     "数学表达式，例如：1 + 2 * 3",
            Required: true,
        },
    }),
}

// 使用 FString 格式
msg := schema.UserMessage("你好，{name}！今天是{date}")
formatted, _ := msg.Format(ctx, map[string]any{
    "name": "Alice",
    "date": "2024-12-19",
}, schema.FString)
// 输出：你好，Alice！今天是2024-12-19

// 使用 Jinja2 格式（支持循环、条件等）
msg2 := schema.UserMessage(`
{% for item in items %}

- {{ item }}

{% endfor %}
`)
formatted2, _ := msg2.Format(ctx, map[string]any{
    "items": []string{"苹果", "香蕉", "橙子"},
}, schema.Jinja2)

// 创建流管道
sr, sw := schema.Pipe[string](10)

// 发送数据
go func() {
    defer sw.Close()
    for i := 0; i < 5; i++ {
        sw.Send(fmt.Sprintf("chunk-%d", i), nil)
        time.Sleep(100 * time.Millisecond)
    }
}()

// 接收数据
defer sr.Close()
for {
    chunk, err := sr.Recv()
    if err == io.EOF {
        break
    }
    fmt.Println(chunk)
}

// 创建多个流
sr1, sw1 := schema.Pipe[string](5)
sr2, sw2 := schema.Pipe[string](5)
sr3, sw3 := schema.Pipe[string](5)

// 分别发送数据
go sendData(sw1, "stream1")
go sendData(sw2, "stream2")
go sendData(sw3, "stream3")

// 合并流
mergedStream := schema.MergeStreamReaders([]*schema.StreamReader[string]{
    sr1, sr2, sr3,
})

// 读取合并后的流（顺序不确定）
defer mergedStream.Close()
for {
    chunk, err := mergedStream.Recv()
    if err == io.EOF {
        break
    }
    fmt.Println(chunk)
}

// 创建流时指定缓冲区大小
sr, sw := schema.Pipe[string](100) // 缓冲区大小为 100

// 缓冲区大小影响：
// - 太小：发送端容易阻塞
// - 太大：占用内存多
// - 建议：10-100 之间

// 三种模板格式的选择：
// 1. FString：简单变量替换，性能最好
formatType := schema.FString

// 2. GoTemplate：支持条件、循环等，性能中等
formatType := schema.GoTemplate

// 3. Jinja2：功能最强大，兼容 LangChain，性能较慢
formatType := schema.Jinja2

// 启用自动关闭（GC 时自动释放）
sr.SetAutomaticClose()

// 适用场景：
// - 流的生命周期不确定
// - 无法保证手动调用 Close()
// - 性能不是特别敏感

// ✅ 正确：使用 defer 确保关闭
sr, sw := schema.Pipe[string](10)
defer sr.Close()

for {
    chunk, err := sr.Recv()
    if err == io.EOF {
        break
    }
    // 处理 chunk
}

// ❌ 错误：忘记关闭
sr, sw := schema.Pipe[string](10)
for {
    chunk, err := sr.Recv()
    if err == io.EOF {
        break
    }
}
// sr 泄漏！

// 方案 1：拆分为多条消息
func splitLargeContent(content string, chunkSize int) []*schema.Message {
    var messages []*schema.Message
    for i := 0; i < len(content); i += chunkSize {
        end := i + chunkSize
        if end > len(content) {
            end = len(content)
        }
        messages = append(messages, schema.UserMessage(content[i:end]))
    }
    return messages
}

// 方案 2：使用流式处理
sr, sw := schema.Pipe[string](10)
go func() {
    defer sw.Close()
    file, _ := os.Open("large_file.txt")
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        sw.Send(scanner.Text(), nil)
    }
}()

// 方案 1：使用消息池
var messagePool = sync.Pool{
    New: func() interface{} {
        return &schema.Message{}
    },
}

func getMessage() *schema.Message {
    return messagePool.Get().(*schema.Message)
}

func putMessage(msg *schema.Message) {
    *msg = schema.Message{} // 重置
    messagePool.Put(msg)
}

// 方案 2：复用 Content 字段
var sb strings.Builder
sb.Reset()
for _, chunk := range chunks {
    sb.WriteString(chunk)
}
msg.Content = sb.String()

// 旧代码（使用 OpenAPIV3）
paramsOneOf := schema.NewParamsOneOfByOpenAPIV3(openAPIV3Schema)

// 新代码（使用 JSONSchema）
paramsOneOf := schema.NewParamsOneOfByJSONSchema(jsonSchema)

func SystemMessage(content string) *Message

type Message struct {
    Role    RoleType // 固定为 System
    Content string   // 传入的 content 参数
}

// SystemMessage 创建系统消息
// 用途：设置 AI 助手的角色、规则、行为约束
// 位置：通常放在对话的最开始
func SystemMessage(content string) *Message {
    return &Message{
        Role:    System,
        Content: content,
    }
}

// 示例 1：设置助手角色
sysMsg := schema.SystemMessage("你是一个专业的 Go 语言编程助手")

// 示例 2：设置行为规则
sysMsg := schema.SystemMessage(`
你是一个有帮助的 AI 助手。请遵循以下规则：

1. 回答要准确、专业
2. 不确定时要明确说明
3. 代码示例要完整可运行

`)

// 示例 3：Few-shot 示例
sysMsg := schema.SystemMessage(`
你是一个情感分析助手。以下是示例：

输入：这个产品真不错！
输出：积极

输入：质量太差了
输出：消极
`)

func UserMessage(content string) *Message

type Message struct {
    Role    RoleType // 固定为 User
    Content string   // 传入的 content 参数
}

// UserMessage 创建用户消息
// 用途：表示用户的输入、问题或指令
// 特点：可以包含变量占位符，配合模板使用
func UserMessage(content string) *Message {
    return &Message{
        Role:    User,
        Content: content,
    }
}

// 示例 1：简单问题
userMsg := schema.UserMessage("什么是 Eino 框架？")

// 示例 2：带变量的模板消息
userMsg := schema.UserMessage("请帮我查询{city}的天气")

// 示例 3：多行输入
userMsg := schema.UserMessage(`
请分析以下代码的性能问题：

func process(data []int) {
    // 代码内容
}
`)

func AssistantMessage(content string, toolCalls []ToolCall) *Message

type Message struct {
    Role      RoleType   // 固定为 Assistant
    Content   string     // 传入的 content 参数
    ToolCalls []ToolCall // 传入的 toolCalls 参数
}

// AssistantMessage 创建助手消息
// 用途：表示 AI 模型的回复
// 特点：可以同时包含文本内容和工具调用
func AssistantMessage(content string, toolCalls []ToolCall) *Message {
    return &Message{
        Role:      Assistant,
        Content:   content,
        ToolCalls: toolCalls,
    }
}

// 示例 1：纯文本回复
assistantMsg := schema.AssistantMessage("Eino 是一个 Go 语言的 LLM 应用开发框架", nil)

// 示例 2：带工具调用的回复
toolCalls := []schema.ToolCall{
    {
        ID:   "call-123",
        Type: "function",
        Function: schema.FunctionCall{
            Name:      "get_weather",
            Arguments: `{"city":"北京"}`,
        },
    },
}
assistantMsg := schema.AssistantMessage("让我查询一下北京的天气", toolCalls)

// 示例 3：多个工具调用
toolCalls := []schema.ToolCall{
    {
        ID:   "call-1",
        Type: "function",
        Function: schema.FunctionCall{
            Name:      "search_web",
            Arguments: `{"query":"Eino framework"}`,
        },
    },
    {
        ID:   "call-2",
        Type: "function",
        Function: schema.FunctionCall{
            Name:      "get_current_time",
            Arguments: `{}`,
        },
    },
}
assistantMsg := schema.AssistantMessage("我需要搜索信息并获取当前时间", toolCalls)

func ToolMessage(content string, toolCallID string, opts ...ToolMessageOption) *Message

type Message struct {
    Role       RoleType // 固定为 Tool
    Content    string   // 传入的 content 参数
    ToolCallID string   // 传入的 toolCallID 参数
    ToolName   string   // 通过 WithToolName 设置
}

// ToolMessage 创建工具消息
// 用途：表示工具执行的结果
// 关联：通过 ToolCallID 关联到 AssistantMessage 的 ToolCall
func ToolMessage(content string, toolCallID string, opts ...ToolMessageOption) *Message {
    o := &toolMessageOptions{}
    for _, opt := range opts {
        opt(o)
    }
    return &Message{
        Role:       Tool,
        Content:    content,
        ToolCallID: toolCallID,
        ToolName:   o.toolName,
    }
}

// WithToolName 设置工具名称
func WithToolName(name string) ToolMessageOption {
    return func(o *toolMessageOptions) {
        o.toolName = name
    }
}

// 示例 1：简单工具结果
toolMsg := schema.ToolMessage(
    "北京今天晴天，温度 25°C",
    "call-123",
)

// 示例 2：带工具名称
toolMsg := schema.ToolMessage(
    `{"temperature":25,"condition":"sunny"}`,
    "call-123",
    schema.WithToolName("get_weather"),
)

// 示例 3：工具执行失败
toolMsg := schema.ToolMessage(
    "错误：未找到指定城市",
    "call-123",
    schema.WithToolName("get_weather"),
)

func (m *Message) Format(ctx context.Context, vs map[string]any, formatType FormatType) ([]*Message, error)

// Format 渲染消息模板
// 支持三种模板格式：FString、GoTemplate、Jinja2
// 会同时渲染 Content 和 MultiContent 中的文本
func (m *Message) Format(ctx context.Context, vs map[string]any, formatType FormatType) ([]*Message, error) {
    // 渲染 Content
    c, err := formatContent(m.Content, vs, formatType)
    if err != nil {
        return nil, err
    }
    copied := *m
    copied.Content = c

    // 复制 MultiContent
    if len(m.MultiContent) != 0 {
        copied.MultiContent = make([]ChatMessagePart, len(m.MultiContent))
        copy(copied.MultiContent, m.MultiContent)
    }

    // 渲染 MultiContent 中的文本
    for i, mc := range copied.MultiContent {
        switch mc.Type {
        case ChatMessagePartTypeText:
            nmc, err := formatContent(mc.Text, vs, formatType)
            if err != nil {
                return nil, err
            }
            copied.MultiContent[i].Text = nmc
        // 处理其他类型（ImageURL、AudioURL 等）
        }
    }
    return []*Message{&copied}, nil
}

// formatContent 根据格式类型渲染内容
func formatContent(content string, vs map[string]any, formatType FormatType) (string, error) {
    switch formatType {
    case FString:
        return pyfmt.Fmt(content, vs)  // Python 格式字符串
    case GoTemplate:
        // Go 标准模板
        parsedTmpl, err := template.New("template").Parse(content)
        // ...
    case Jinja2:
        // Jinja2 模板
        tpl, err := jinjaEnv.FromString(content)
        // ...
    }
}

// 示例 1：FString 格式（Python 风格）
msg := schema.UserMessage("你好，{name}！今天是{date}")
params := map[string]any{
    "name": "Alice",
    "date": "2024-12-19",
}
rendered, _ := msg.Format(ctx, params, schema.FString)
// rendered[0].Content = "你好，Alice！今天是2024-12-19"

// 示例 2：GoTemplate 格式
msg := schema.UserMessage("你好，{{.name}}！{{if .vip}}您是VIP用户{{end}}")
params := map[string]any{
    "name": "Bob",
    "vip":  true,
}
rendered, _ := msg.Format(ctx, params, schema.GoTemplate)
// rendered[0].Content = "你好，Bob！您是VIP用户"

// 示例 3：Jinja2 格式（支持循环）
msg := schema.UserMessage(`
任务列表：
{% for task in tasks %}

- {{ task }}

{% endfor %}
`)
params := map[string]any{
    "tasks": []string{"学习 Eino", "编写代码", "测试功能"},
}
rendered, _ := msg.Format(ctx, params, schema.Jinja2)