Function Calling 调用链追踪：从 Prompt 参数到执行的全流程可视化

sequenceDiagram
    participant U as 用户
    participant P as Prompt 组装层
    participant M as LLM
    participant T as 工具调度器
    participant F as 实际函数
    participant L as 追踪系统
    U->>P: 发送问题
    P->>P: 注入工具 Schema
    P->>L: 📝 Node1: Prompt 快照记录
    P->>M: 发起推理请求
    M->>L: 📝 Node2: 模型输出（含 tool_call）
    M-->>P: 返回 tool_call 决策
    alt 需要调用工具
        P->>T: 派发 tool_call
        T->>T: 参数校验
        T->>L: 📝 Node3: 工具名 + 参数
        T->>F: 执行函数
        F-->>T: 返回结果
        T->>L: 📝 Node4: 工具返回值
        T-->>P: 注入结果到上下文
    else 直接回复
        M-->>U: 返回文本回复
    end
    P->>L: 📝 Node5: 最终响应
    P-->>U: 返回给用户

package tracing
import (
    "context"
    "encoding/json"
    "fmt"
    "time"
)
// TraceNode 追踪节点
type TraceNode struct {
    ID        string          `json:"id"`
    Type      string          `json:"type"`      // prompt_compile, llm_call, tool_exec, result_inject
    Timestamp time.Time       `json:"timestamp"`
    Input     json.RawMessage `json:"input"`
    Output    json.RawMessage `json:"output"`
    Duration  time.Duration   `json:"duration_ms"`
    Error     string          `json:"error,omitempty"`
}
// TraceChain 完整调用链
type TraceChain struct {
    TraceID   string      `json:"trace_id"`
    Nodes     []TraceNode `json:"nodes"`
    StartTime time.Time   `json:"start_time"`
    EndTime   time.Time   `json:"end_time"`
}
// Tracer 链路追踪器
type Tracer struct {
    chain *TraceChain
    mu    sync.Mutex
}
// NewTracer 创建追踪器
func NewTracer(traceID string) *Tracer {
    return &Tracer{
        chain: &TraceChain{
            TraceID:   traceID,
            Nodes:     make([]TraceNode, 0),
            StartTime: time.Now(),
        },
    }
}
// RecordNode 记录一个调用节点，返回结束函数
func (t *Tracer) RecordNode(nodeType string, input interface{}) func(output interface{}, err error) {
    inputBytes, _ := json.Marshal(input)
    start := time.Now()
    node := TraceNode{
        ID:        fmt.Sprintf("%s-%d", nodeType, len(t.chain.Nodes)),
        Type:      nodeType,
        Timestamp: start,
        Input:     inputBytes,
    }
    return func(output interface{}, err error) {
        node.Duration = time.Since(start)
        if err != nil {
            node.Error = err.Error()
        } else if output != nil {
            node.Output, _ = json.Marshal(output)
        }
        t.mu.Lock()
        t.chain.Nodes = append(t.chain.Nodes, node)
        t.mu.Unlock()
    }
}
// Export 导出完整链路
func (t *Tracer) Export() *TraceChain {
    t.mu.Lock()
    defer t.mu.Unlock()
    t.chain.EndTime = time.Now()
    return t.chain
}

func handleFunctionCall(ctx context.Context, prompt string, tools []Tool) (string, *TraceChain) {
    tracer := NewTracer(generateTraceID())
    // Node 1: Prompt 编译
    endPrompt := tracer.RecordNode("prompt_compile", map[string]interface{}{
        "user_input": prompt,
        "tool_count": len(tools),
    })
    compiledPrompt := buildPrompt(prompt, tools)
    endPrompt(compiledPrompt, nil)
    // Node 2: LLM 推理
    endLLM := tracer.RecordNode("llm_call", map[string]interface{}{
        "model":     "gpt-4",
        "prompt_len": len(compiledPrompt),
    })
    response, err := callLLM(ctx, compiledPrompt)
    if err != nil {
        endLLM(nil, fmt.Errorf("LLM 调用失败: %w", err))
        return "", tracer.Export()
    }
    endLLM(response, nil)
    // Node 3: 工具执行
    if response.ToolCall != nil {
        endTool := tracer.RecordNode("tool_exec", map[string]interface{}{
            "tool_name":  response.ToolCall.Name,
            "parameters": response.ToolCall.Args,
        })
        result, execErr := executeTool(ctx, response.ToolCall)
        endTool(result, execErr)
        if execErr != nil {
            return fmt.Sprintf("工具执行失败: %v", execErr), tracer.Export()
        }
    }
    return response.Content, tracer.Export()
}