magic-agent 2.1.5 → 2.3.2

package/internal/suggest/suggest.go

@@ -0,0 +1,532 @@
+// Package suggest - 生成「下一轮快捷回复」的建议（一轮对话结束后给用户可点的下一句）。
+//
+// 为什么要有它（用户 2026-10-23：「在回复结束后 ai 自动生成下一轮的建议，点击即可发送」）：
+// 每轮回答结束后，用户往往还要再打一句「继续 / 看下 diff / 先别动」。这些句子**就在回答里**
+// （AI 问「要我继续吗？」、AI 列了「下一步」），把它提炼成按钮能省一次打字 —— 但提炼必须
+// 来自模型对**这一轮原文**的理解，不能套模板硬凑（模板会给出与内容无关的噪音）。
+//
+// 三条纪律：
+//  1. **一次性旁路调用**：`agent.Runner` + `ToolsOff` + 不带 SessionID —— 独立进程、独立会话，
+//     不续接也不污染用户正在聊的那条上下文；不经过 CLI 的 ask 通道，不留会话登记。
+//  2. **宁缺毋滥**：模型没给出可用句子、或这轮本来就没有下一步时返回空数组，调用方据此不画按钮。
+//  3. **不编造**：提示词明确禁止引入对话里没出现过的文件 / 数字 / 结论；解析侧再做一层长度、
+//     去重、形态校验，挡掉「AI 的回答」冒充「用户的话」。
+//
+// 与 `--summarize-title`（internal/session/title.go::Summarize）的分工：那条把会话首问压成
+// 标题、结果落进标题表；这条只产出一组**临时**建议，不落盘、不缓存 —— 下一轮结束就重算。
+package suggest
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+// 默认参数。取「短、快」：建议是锦上添花，不能让它拖住下一轮。
+const (
+	// DefaultEngine 默认用 llm：纯文本、不带工具、没有 CLI 会话副作用（与 --title-engine 同口径）。
+	DefaultEngine = "llm"
+	// DefaultCount 最多给几条建议（UI 一行放得下 3 枚）。
+	DefaultCount = 3
+	// MaxLabelRunes 单条建议的字数上限。提示词要求 ≤16；解析时放宽到 28 仍然接受，
+	// 再长就不是「随手发的一句话」了，直接丢掉（不截断 —— 截断后的半句话发出去更糟）。
+	MaxLabelRunes = 28
+	// DefaultTimeout 单次旁路调用的超时。到点没有结果就当没有建议（调用方不等待）。
+	DefaultTimeout = 22 * time.Second
+)
+
+// Request 生成建议的输入。
+type Request struct {
+	// User 用户最新那一句（可为空：比如本轮是系统派发的任务）。
+	User string
+	// Reply 引擎这一轮的**权威正文**（必填；空 = 没有可提炼的内容）。
+	Reply string
+	// Engine 用哪个引擎生成（空 = DefaultEngine）。
+	Engine string
+	// Model 模型标识（空 = 引擎默认）。
+	Model string
+	// Count 最多几条（<=0 = DefaultCount）。
+	Count int
+	// Timeout 单次调用超时（<=0 = DefaultTimeout）。
+	Timeout time.Duration
+}
+
+// Result 生成结果。
+type Result struct {
+	Suggestions []string `json:"suggestions"`
+	Engine      string   `json:"engine,omitempty"`
+	Model       string   `json:"model,omitempty"`
+	ElapsedMS   int64    `json:"elapsedMs,omitempty"`
+}
+
+// RequestBody 是 CLI / 插件之间传的 JSON 形状（只含对话内容，引擎走 -e/-m）。
+type RequestBody struct {
+	User  string `json:"user"`
+	Reply string `json:"reply"`
+}
+
+// Prompt 拼提示词。截断策略：用户那句取**开头**（它通常很短），回复取**结尾** ——
+// 下一步 / 待确认的问题几乎都在最后一段，截掉尾部等于把要提炼的东西扔了。
+func Prompt(user, reply string, count int) string {
+	if count <= 0 || count > DefaultCount {
+		count = DefaultCount
+	}
+	u := strings.TrimSpace(user)
+	if n := len([]rune(u)); n > 1500 {
+		u = string([]rune(u)[:1500]) + "…"
+	}
+	r := strings.TrimSpace(reply)
+	if n := len([]rune(r)); n > 6000 {
+		r = "…" + string([]rune(r)[n-6000:])
+	}
+	var b strings.Builder
+	b.WriteString("你是「下一句」建议器，服务于一个正在用 AI agent 干活的用户。\n")
+	b.WriteString("读完下面这一轮对话，给出用户此刻最可能**直接发出去**的简短指令。\n\n")
+	b.WriteString("硬约束：\n")
+	fmt.Fprintf(&b, "1. 最多 %d 条；每条 ≤ 16 个汉字，口语，像用户随手打的；不要编号、引号、句末标点。\n", count)
+	b.WriteString("2. 必须是**用户对 AI 说的话**，不是 AI 的回答，也不是给用户的说明。\n")
+	b.WriteString("3. 只依据这一轮里**已经出现**的内容（AI 问的问题、列出的下一步、给出的选项）。\n")
+	b.WriteString("   不许编造对话里没有的文件、数字、结论；拿不准就不要写。\n")
+	b.WriteString("4. AI 在等拍板 → 给直接的肯定/否定答复；AI 列了下一步 → 挑最关键的 1-2 条；\n")
+	b.WriteString("   给多条时按「最该先做」排序，**第一条就是最佳建议**（托管模式会直接发它）；\n")
+	b.WriteString("   这一轮已经彻底结束、没有下一步 → 给空数组。宁缺毋滥。\n")
+	b.WriteString("5. 只输出 JSON：{\"suggestions\":[\"…\",\"…\"]}，不要解释、不要 markdown 围栏。\n")
+	b.WriteString("6. 这一轮如果是**交付型任务**（小说 / 故事 / 文章 / 诗 / 剧本 / 文案 / 报告 / 代码 / 图纸），\n")
+	b.WriteString("   而 AI 已经把成品完整交出来、没有提问、也没有列出下一步 → **必须给空数组**。\n")
+	b.WriteString("   不要建议「再来一篇」「换个题材」「再写一个」「继续写」这类**另起一篇**的话；\n")
+	b.WriteString("   除非 AI 在这一轮明确问「要不要再来一篇 / 下一篇写什么」。即使用户上一句就是\n")
+	b.WriteString("   「再来一篇」，只要这一篇已经交付完、没有新问题，也算结束。\n\n")
+	b.WriteString("例 1（交付完成 → 空）：\n")
+	b.WriteString("用户：写一个短篇恋爱小说\n")
+	b.WriteString("AI：# 标题 …（完整故事，结尾收束，没有提问）\n")
+	b.WriteString("输出：{\"suggestions\":[]}\n\n")
+	b.WriteString("例 2（AI 在等拍板 → 1-2 条）：\n")
+	b.WriteString("用户：修一下登录 bug\n")
+	b.WriteString("AI：修好了，测试通过。要不要我顺手把过期 token 也处理掉？\n")
+	b.WriteString("输出：{\"suggestions\":[\"处理过期 token\",\"先这样\"]}\n\n")
+	b.WriteString("用户刚才说：\n")
+	if u == "" {
+		b.WriteString("（本轮由系统派发，没有用户原话）\n")
+	} else {
+		b.WriteString(u + "\n")
+	}
+	b.WriteString("\nAI 的回复：\n")
+	b.WriteString(r)
+	b.WriteString("\n")
+	return b.String()
+}
+
+// Schema 结构化输出契约（llm 引擎会按它做一次 JSON 后处理；其余引擎靠提示词约束）。
+func Schema() *agent.JSONSchema {
+	return &agent.JSONSchema{
+		Type: "object",
+		Properties: map[string]map[string]any{
+			"suggestions": {"type": "array", "items": map[string]any{"type": "string"}},
+		},
+		Required: []string{"suggestions"},
+	}
+}
+
+// Parse 从模型输出里抽建议。容忍三种形态：JSON 对象 {"suggestions":[…]}
+// （带不带 ``` 围栏都行）、裸 JSON 数组、以及一眼能认出的逐行短句。
+// 解析失败 / 全是废句 → 返回空切片（不是错误：没有建议是合法结果）。
+func Parse(raw string, count int) []string {
+	if count <= 0 || count > DefaultCount {
+		count = DefaultCount
+	}
+	text := strings.TrimSpace(raw)
+	if text == "" {
+		return []string{}
+	}
+	if obj := firstJSONValue(text); obj != nil {
+		var arr []any
+		switch v := obj.(type) {
+		case map[string]any:
+			if a, ok := v["suggestions"].([]any); ok {
+				arr = a
+			}
+		case []any:
+			arr = v
+		}
+		if arr != nil {
+			return normalize(arrToStrings(arr), count)
+		}
+	}
+	return normalize(splitLines(text), count)
+}
+
+// Generate 跑一次旁路生成。失败时返回空建议 + error（调用方如实降级：不画按钮）。
+//
+// 2026-10-23 用户定调：「建议的生成要走引擎的不启用工具 json 返回的方式，提高速度」。
+// 这里的主路径就是如此：当前引擎（in.Engine）+ ToolsOff + JSONSchema + NoThinking，
+// 各引擎都通过 NoThinking 走官方关闭参数；失败/超时再降级到 llm 的 no-think 变体
+// （纯文本、无工具、1-2s），保证界面不会跟着主引擎的 CLI 一起卡到 20s。
+// `ToolsOff` / `JSONSchema` / `NoThinking` 不是可选项 —— 少任何一条都会把建议变成
+// 一次带工具痕迹（或默认高档思考）的完整 agent 轮次。
+func Generate(ctx context.Context, in Request) (Result, error) {
+	reply := strings.TrimSpace(in.Reply)
+	if reply == "" {
+		return Result{Suggestions: []string{}}, nil
+	}
+	name := strings.TrimSpace(in.Engine)
+	if name == "" {
+		name = DefaultEngine
+	}
+	if agent.Lookup(name) == nil {
+		return Result{}, fmt.Errorf("建议生成：未知引擎 %q", name)
+	}
+	timeout := in.Timeout
+	if timeout <= 0 {
+		timeout = DefaultTimeout
+	}
+	cctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	start := time.Now()
+
+	/* 建议一律不思考；所有引擎都尽量走官方开关：
+	   llm 用 no-think 变体 / reasoning_effort=none，claude --thinking disabled，
+	   codex effort=none，codebuddy settings alwaysThinkingEnabled=false，
+	   dsh InitializeParams.reasoningEffort=off。没有可靠开关的引擎（trae/openclaw/arkclaw）
+	   仍会被 NoThinking 标记，失败后再降级 llm；不在这里预先改道。 */
+	/* 主引擎：优先当前引擎（用户要的“引擎 JSON 返回”）。claude / codex 给 10s ——
+	   这是「CLI 启动 + 一次短 JSON」的实测上限；超过 10s 多半是凭据/主会话占用，
+	   继续等只会把界面的 20s 预算吃光。之后才降级到 llm（1-2s），并清掉当前引擎的 model。 */
+	primaryBudget := timeout
+	if name != DefaultEngine && primaryBudget > 10*time.Second {
+		primaryBudget = 10 * time.Second
+	}
+	res, err := tryGenerate(cctx, in, name, primaryBudget, start)
+	if err == nil {
+		return res, nil
+	}
+	if name == DefaultEngine {
+		return Result{}, err
+	}
+
+	/* 降级：给 llm 留一段独立预算（整体仍受 timeout 约束）。主引擎的错误不丢，
+	   只有 fallback 也失败时才报它 —— 至少让调用方知道不是“没有建议”，是真失败。 */
+	remain := timeout - time.Since(start)
+	if remain < 2*time.Second {
+		remain = 2 * time.Second
+	}
+	if remain > 8*time.Second {
+		remain = 8 * time.Second
+	}
+	fallbackIn := in
+	fallbackIn.Model = "" // model 是当前引擎的，不能拿去喂 llm
+	fallback, ferr := tryGenerate(cctx, fallbackIn, DefaultEngine, remain, start)
+	if ferr != nil {
+		return Result{}, err
+	}
+	return fallback, nil
+}
+
+// fastLLMModel 找 models.json 里第一条「不思考」的变体（extraBody.thinking.type=disabled）。
+// 建议是短文本，思考只会把 1s 拖成 4s；有这种条目就用它，不硬编码某个模型 id。
+func fastLLMModel() string {
+	list, err := agent.LoadLLMConfigModels()
+	if err != nil {
+		return ""
+	}
+	for _, m := range list {
+		if llmModelDisablesThinking(m) {
+			return m.ID
+		}
+	}
+	return ""
+}
+
+// llmModelDisablesThinking 判断 models.json 条目是否声明了不思考变体。
+func llmModelDisablesThinking(m agent.LLMConfigModel) bool {
+	if strings.TrimSpace(m.ID) == "" || m.ExtraBody == nil {
+		return false
+	}
+	th, ok := m.ExtraBody["thinking"].(map[string]any)
+	if !ok {
+		return false
+	}
+	return strings.EqualFold(strings.TrimSpace(fmt.Sprint(th["type"])), "disabled")
+}
+
+// noThinkLLMModel 给建议选一个真正不思考的 llm 模型：
+// 用户选的模型本身就是 no-think 变体 → 用它；否则用 models.json 里第一条
+// thinking.disabled 变体；没有变体才退回用户选的模型（无法关闭，至少不阻断）。
+func noThinkLLMModel(selected string) string {
+	selected = strings.TrimSpace(selected)
+	if selected != "" {
+		if m, ok := agent.LookupLLMConfigModel(selected); ok && llmModelDisablesThinking(m) {
+			return m.ID
+		}
+	}
+	if fast := fastLLMModel(); fast != "" {
+		return fast
+	}
+	return selected
+}
+
+// tryGenerate 用指定引擎跑一次 ToolsOff + JSONSchema 的短调用。
+func tryGenerate(ctx context.Context, in Request, name string, budget time.Duration, start time.Time) (Result, error) {
+	engine := agent.Lookup(name)
+	if engine == nil {
+		return Result{}, fmt.Errorf("建议生成：未知引擎 %q", name)
+	}
+	reply := strings.TrimSpace(in.Reply)
+	attemptCtx, cancel := context.WithTimeout(ctx, budget)
+	defer cancel()
+	/* 建议是纯文本短任务，**一律不思考**。Reasoning 只作为没有 NoThinking 通道的
+	   引擎的兜底（minimal 仍比默认高档轻）；能真正关闭的引擎看 NoThinking。 */
+	reasoning := "minimal"
+	model := strings.TrimSpace(in.Model)
+	if name == DefaultEngine {
+		/* 建议一律不思考：llm 有 no-think 变体就用它（默认引擎不配模型时也走这里）。
+		   用户显式选了会思考的模型（如 MiniMax-M3.1-Flash）时，宁可换同文件的
+		   no-think 变体，也不让建议在思考上多花几秒；配置里没有变体才保留原模型。 */
+		model = noThinkLLMModel(model)
+	}
+	runner := &agent.Runner{Engine: engine, Timeout: budget}
+	resp, err := runner.Run(attemptCtx, agent.Request{
+		Model: model,
+		Tools: agent.ToolsOff,
+		/* NoThinking：claude → --thinking disabled，codex → effort none，
+		   llm 换成 thinking.disabled 变体，codebuddy → settings:false，
+		   dsh → initialize.reasoningEffort=off。 */
+		NoThinking: true,
+		Reasoning:  reasoning,
+		MaxTokens:  300,
+		Messages:   []agent.Message{{Role: "user", Content: Prompt(in.User, reply, in.Count)}},
+		JSONSchema: Schema(),
+	})
+	if err != nil {
+		return Result{}, err
+	}
+	items := Parse(resp.Text, in.Count)
+	items = dropCreativeRestarts(items, in.User, reply)
+	return Result{
+		Suggestions: items,
+		Engine:      engine.Name(),
+		Model:       resp.Model,
+		ElapsedMS:   time.Since(start).Milliseconds(),
+	}, nil
+}
+
+// ── 交付完成后的「另起一篇」过滤（2026-10-23 用户实测）─────────────────
+//
+// 提示词已经要求「交付完就给空数组」，但模型仍会把「再写一篇 / 换个题材」当成下一步
+// （用户截图：短篇写完，托管自动发出「再来一篇职场题材的」，又生成一篇）。
+// 这一层是**确定性兜底**：只在创作类轮次里，丢掉「另起一篇」形态的建议；
+// AI 明确问「要不要再来一篇 / 下一篇写什么」时放行。
+
+var (
+	creativeTurnRe = regexp.MustCompile(`小说|故事|文章|短篇|长篇|诗歌?|剧本|文案|作文|题材|写一篇|再写一篇|再来一篇|创作`)
+	// 「再来一篇 / 再写一章 / 再画一首」：量词是篇/章/首/部，基本只用于创作。
+	anotherWritingRe = regexp.MustCompile(`^(再|又)?(来|写|生成|创作|画|做)(一|两)?(篇|章|首|部)`)
+	// 「再来个职场篇 / 再写一个短篇」：没有创作名词，但以篇/章/首/部收尾。
+	anotherPieceRe = regexp.MustCompile(`^(再|又)?(来|写|生成|创作|画|做)(一|个)?[^，。！？]{0,10}(篇|章|首|部)$`)
+	// 「再写一个校园故事 / 来个职场段子」：量词是「个/段」时必须带创作名词。
+	anotherCreativeRe = regexp.MustCompile(`^(再|又)?(来|写|生成|创作|画|做)(一|个|段)?[^，。！？]{0,8}(小说|故事|文章|散文|诗歌?|剧本|文案|作文|童话|段子|番外|续集|续篇)`)
+	switchTopicRe     = regexp.MustCompile(`^(换|改)(一|个)?[^，。！？]{0,8}(题材|主题|方向|背景)`)
+	nextPieceRe       = regexp.MustCompile(`^下一(篇|章|首|部)`)
+	continueWriteRe   = regexp.MustCompile(`^(继续|接着)(写|创作|生成|画)`)
+	bareContinueRe    = regexp.MustCompile(`^(继续|接着)(吧|来)?$`)
+	inviteAnotherRe   = regexp.MustCompile(`(要不要|需要我|想不想|是否).{0,10}(再|下一|续)|要继续吗|接着(写|来)吗|下一(篇|章|个)|续写|告诉我.{0,10}(题材|主题|方向)`)
+)
+
+// looksLikeCreativeReply 识别「用户只说继续，但 AI 交的是一篇完整创作」：
+// Markdown 一级标题 + 超过 400 字 + 没有代码块。技术长文也按此处理（成品交付完不该再
+// 建议「另起一篇」），带代码块的工程回答则排除，避免误杀「再写一个测试」。
+func looksLikeCreativeReply(reply string) bool {
+	r := strings.TrimSpace(reply)
+	if !strings.HasPrefix(r, "# ") || strings.Contains(r, "```") {
+		return false
+	}
+	return utf8.RuneCountInString(r) >= 400
+}
+
+// dropCreativeRestarts 把「成品交付完之后的另起一篇」过滤掉。
+// 只在创作类轮次（用户这句本身是创作请求，或 AI 交了一篇完整创作）生效 ——
+// 写代码时「再写一个测试」是正常下一步，不能误杀。
+func dropCreativeRestarts(items []string, user, reply string) []string {
+	if !creativeTurnRe.MatchString(strings.TrimSpace(user)) && !looksLikeCreativeReply(reply) {
+		return items
+	}
+	tail := []rune(strings.TrimSpace(reply))
+	if len(tail) > 600 {
+		tail = tail[len(tail)-600:]
+	}
+	invited := inviteAnotherRe.MatchString(string(tail))
+	unfinished := strings.Contains(string(tail), "未完") || strings.Contains(string(tail), "待续") || strings.Contains(string(tail), "下一章")
+	explicitCreative := creativeTurnRe.MatchString(strings.TrimSpace(user))
+	out := make([]string, 0, len(items))
+	for _, s := range items {
+		t := strings.TrimSpace(s)
+		if t == "" {
+			continue
+		}
+		restart := anotherWritingRe.MatchString(t) || anotherPieceRe.MatchString(t) ||
+			anotherCreativeRe.MatchString(t) || switchTopicRe.MatchString(t) || nextPieceRe.MatchString(t)
+		if restart && !invited {
+			continue
+		}
+		if continueWriteRe.MatchString(t) && !invited && !unfinished {
+			continue
+		}
+		/* 光秃秃一句「继续」是最容易把成品续写成第二篇的：只在用户这句本身是创作请求时挡。 */
+		if bareContinueRe.MatchString(t) && explicitCreative && !invited && !unfinished {
+			continue
+		}
+		out = append(out, s)
+	}
+	return out
+}
+
+// ── 解析辅助 ──────────────────────────────────────────────────────────────
+
+// firstJSONValue 从可能裹着围栏 / 解释文字的输出里抠出**第一个** JSON 值。
+// 用 json.Decoder 逐个 '{' / '[' 试（比正则稳：能正确处理字符串里的括号）。
+func firstJSONValue(s string) any {
+	s = stripFence(s)
+	for i := 0; i < len(s); i++ {
+		if s[i] != '{' && s[i] != '[' {
+			continue
+		}
+		dec := json.NewDecoder(strings.NewReader(s[i:]))
+		dec.UseNumber()
+		var v any
+		if err := dec.Decode(&v); err == nil {
+			return v
+		}
+	}
+	return nil
+}
+
+// dropFenced 去掉整段 ``` 围栏（含围栏里的代码）：逐行兜底时不能把代码示例当建议。
+func dropFenced(s string) string {
+	var b strings.Builder
+	inFence := false
+	for _, ln := range strings.Split(s, "\n") {
+		if strings.HasPrefix(strings.TrimSpace(ln), "```") {
+			inFence = !inFence
+			continue
+		}
+		if !inFence {
+			b.WriteString(ln)
+			b.WriteString("\n")
+		}
+	}
+	return b.String()
+}
+
+func stripFence(s string) string {
+	t := strings.TrimSpace(s)
+	if !strings.HasPrefix(t, "```") {
+		return t
+	}
+	if i := strings.Index(t, "\n"); i >= 0 {
+		t = t[i+1:]
+	} else {
+		t = strings.TrimPrefix(t, "```")
+	}
+	if i := strings.LastIndex(t, "```"); i >= 0 {
+		t = t[:i]
+	}
+	return strings.TrimSpace(t)
+}
+
+func arrToStrings(a []any) []string {
+	out := make([]string, 0, len(a))
+	for _, v := range a {
+		if s, ok := v.(string); ok {
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
+// splitLines 兜底：模型没按 JSON 回（或只回了一串短句）时，按行取。
+// 只保留「像一句指令」的行 —— 带冒号解释、带代码、太长的一律不要。
+func splitLines(text string) []string {
+	var out []string
+	for _, ln := range strings.Split(dropFenced(text), "\n") {
+		ln = strings.TrimSpace(ln)
+		if ln == "" {
+			continue
+		}
+		ln = trimListPrefix(ln)
+		if strings.ContainsAny(ln, "`{}<>") || strings.Contains(ln, "：") || strings.Contains(ln, "://") {
+			continue
+		}
+		out = append(out, ln)
+	}
+	return out
+}
+
+// normalize 归一 + 校验：剥引号/列表号/句末标点，丢弃过长、多行、像 AI 回答的句子，去重截断。
+func normalize(in []string, count int) []string {
+	out := make([]string, 0, count)
+	seen := make(map[string]bool, len(in))
+	for _, raw := range in {
+		s := strings.TrimSpace(raw)
+		s = trimListPrefix(s)
+		/* 引号与句末标点会互相挡着（「好的」。 里右引号在句号前面）：多剥两轮。 */
+		for i := 0; i < 2; i++ {
+			s = strings.TrimRight(s, "。．.！!？?；;，,")
+			s = strings.Trim(s, " \t\r\n\"'“”‘’「」『』")
+		}
+		s = strings.TrimRight(s, "。．.！!？?；;，,")
+		s = strings.Join(strings.Fields(s), " ")
+		if s == "" || utf8.RuneCountInString(s) > MaxLabelRunes {
+			continue
+		}
+		/* 以省略号开头 = 上游被截断的半句话（见 Prompt 的截断），发出去会缺主语。 */
+		if strings.HasPrefix(s, "…") || strings.ContainsAny(s, "\n\r") {
+			continue
+		}
+		/* 「AI 的答复」冒充「用户的话」：这类开头一定不是用户要发的。 */
+		if strings.HasPrefix(s, "AI") || strings.HasPrefix(s, "助手") || strings.HasPrefix(s, "Agent") {
+			continue
+		}
+		if seen[s] {
+			continue
+		}
+		seen[s] = true
+		out = append(out, s)
+		if len(out) >= count {
+			break
+		}
+	}
+	return out
+}
+
+// trimListPrefix 去掉「1. / 1、/ - / • / (1)」这类列表前缀（模型偶尔会自作主张编号）。
+func trimListPrefix(s string) string {
+	t := strings.TrimSpace(s)
+	for i := 0; i < 3; i++ { // 最多剥三层（如 "- 1. xxx"）
+		prev := t
+		t = strings.TrimLeft(t, "-*•· ")
+		for _, sep := range []string{".", "、", ")", "）", ":"} {
+			if j := strings.Index(t, sep); j > 0 && j <= 3 {
+				allDigit := true
+				for _, r := range t[:j] {
+					if r < '0' || r > '9' {
+						allDigit = false
+						break
+					}
+				}
+				if allDigit {
+					t = strings.TrimSpace(t[j+len(sep):])
+					break
+				}
+			}
+		}
+		if t == prev {
+			break
+		}
+	}
+	return strings.TrimSpace(t)
+}