从能聊到可靠：多轮对话系统的工程化设计

type RunStatus string

const (
	Pending  RunStatus = "pending"
	Success  RunStatus = "success"
	Error    RunStatus = "error"
	Canceled RunStatus = "canceled"
)

type Run struct {
	ID             string
	ConversationID uint
	UserID         uint
	Status         RunStatus
	ErrorCode      string
	InputTokens    int64
	OutputTokens   int64
	StartedAt      time.Time
	EndedAt        *time.Time
}

type Message struct {
	ID             uint
	ConversationID uint
	ParentID       *uint
	RunID          string
	Role           string
	Content        string
	Status         RunStatus
	ErrorCode      string
}

send(input):
  run = create_run(status=pending)
  user_msg = create_message(role=user, status=pending)
  assistant_msg = create_message(role=assistant, status=pending)

  try:
    result = generate(run, user_msg, assistant_msg, input)
    mark_success(run, user_msg, assistant_msg, result)
    return result

  catch GenerationCanceled:
    save_partial_text(assistant_msg)
    mark_canceled(run, assistant_msg)

  catch err:
    mark_error(run, user_msg, assistant_msg, classify(err))

// 容易串分支：只按时间取消息。
history := repo.ListRecentMessages(conversationID, 20)

func BuildPath(messages []Message, leafID uint) []Message {
	byID := map[uint]Message{}
	for _, m := range messages {
		byID[m.ID] = m
	}

	var path []Message
	seen := map[uint]bool{}
	for id := leafID; id != 0; {
		m, ok := byID[id]
		if !ok || seen[id] {
			break
		}
		seen[id] = true
		path = append(path, m)
		if m.ParentID == nil {
			break
		}
		id = *m.ParentID
	}

	for i, j := 0, len(path)-1; i < j; i, j = i+1, j-1 {
		path[i], path[j] = path[j], path[i]
	}
	return path
}

func DefaultParent(recent []Message) *Message {
	for i := len(recent) - 1; i >= 0; i-- {
		m := recent[i]
		if m.Role == "assistant" && m.Status == Success {
			return &m
		}
	}
	return nil
}

type BlockKind string

const (
	SystemPolicy BlockKind = "system_policy"
	Transcript   BlockKind = "transcript"
	Stable       BlockKind = "stable_context"
	Dynamic      BlockKind = "dynamic_context"
	ToolGuide    BlockKind = "tool_guidance"
)

type PromptBlock struct {
	Kind      BlockKind
	Content   string
	Tokens    int64
	Cacheable bool
	Sources   []SourceRef
}

type PromptPlan struct {
	Messages []LLMMessage
	Trace    PromptTrace
}

type PromptTrace struct {
	TotalTokens int64
	Blocks      []BlockTrace
}

type BlockTrace struct {
	Kind        BlockKind
	Tokens      int64
	Cacheable   bool
	SourceCount int
}

<ctx>
  <summary>用户正在讨论企业知识库权限模型。</summary>
  <rag source="pricing.pdf#chunk-12">
    企业版支持 SSO、审计日志和自定义数据保留周期。
  </rag>
  <memory key="language">用户偏好中文回答。</memory>
</ctx>

<user_input>
  企业版和团队版有什么区别？
</user_input>

type Slot struct {
	Kind     string
	Content  string
	Tokens   int64
	Priority int
	Required bool
}

func SelectSlots(slots []Slot, budget int64) []Slot {
	sort.SliceStable(slots, func(i, j int) bool {
		if slots[i].Required != slots[j].Required {
			return slots[i].Required
		}
		return slots[i].Priority > slots[j].Priority
	})

	var used int64
	var out []Slot
	for _, s := range slots {
		if s.Required || used+s.Tokens <= budget {
			out = append(out, s)
			used += s.Tokens
		}
	}
	return out
}

type RetrieveStatus string

const (
	Hit      RetrieveStatus = "hit"
	Empty    RetrieveStatus = "empty"
	LowScore RetrieveStatus = "low_score"
	Timeout  RetrieveStatus = "timeout"
	Failed   RetrieveStatus = "failed"
)

type RetrieveResult struct {
	Status         RetrieveStatus
	Reason         string
	Chunks         []Chunk
	CandidateCount int
	MaxScore       float64
}

retrieve_context(query, files):
  result = rag.retrieve(query, files)

  if result.error:
    trace("rag failed; fallback to full text")
    return full_text_fallback(files)

  if result.chunks is empty:
    trace("rag miss", status=result.status, reason=result.reason)
    return evidence_miss(result.reason)

  trace("rag hit", count=len(result.chunks), max_score=result.max_score)
  return rag_chunks(result.chunks)

run_tool_loop(messages, tools):
  ledger = {}
  llm_calls = 0
  tool_calls = 0

  while llm_calls < max_llm_calls:
    output = llm.generate(messages, tools)
    llm_calls += 1

    if output.tool_calls is empty:
      return output

    for call in output.tool_calls:
      if tool_calls >= max_tool_calls:
        disable_tools("tool limit reached")
        return llm.generate(messages, tools=[])

      key = call.name + canonical_json(call.arguments)
      if key not in ledger:
        validate(call.arguments, schema=call.schema)
        result = execute_tool(call)
        ledger[key] = truncate_for_model(result)
        tool_calls += 1

      messages.append(tool_result(call.id, ledger[key]))

  disable_tools("llm call limit reached")
  return llm.generate(messages, tools=[])