thincoder 0.12.62 → 0.12.64

package/src/embedding.mjs

@@ -1,120 +0,0 @@
-/**
- * embedding.mjs — vector embeddings
- * OpenAI-compatible /v1/embeddings (SiliconFlow bge-m3 / Ollama / OpenAI all supported),
- * reuses provider.mjs fetch + retry pattern, zero dependencies.
- * Vectors are normalized before storage; dot product then equals cosine similarity.
- */
-
-import { RETRYABLE_STATUS } from "./provider/index.mjs"
-const MAX_RETRIES = 3
-const BATCH_SIZE = 32 // max texts per request (within SiliconFlow limits)
-
-/** Create an embedder. config: { baseURL, apiKey, model } */
-export function createEmbedder(config) {
-  if (!config?.baseURL) throw new Error("embedding config: baseURL is required — configure embedding.baseURL in ~/.thincoder/config.json")
-  if (!config?.apiKey) throw new Error("embedding config: apiKey is required — configure embedding.apiKey in ~/.thincoder/config.json")
-  if (!config?.model) throw new Error("embedding config: model is required — configure embedding.model in ~/.thincoder/config.json")
-  return {
-    baseURL: config.baseURL.replace(/\/+$/, ""),
-    apiKey: config.apiKey,
-    model: config.model,
-  }
-}
-
-/**
- * Batch embedding. texts: string[] → Float32Array[] (normalized)
- * Auto-batches, retries on failure (exponential backoff).
- */
-export async function embed(embedder, texts, { signal } = {}) {
-  if (texts.length === 0) return []
-  const vectors = []
-  for (let i = 0; i < texts.length; i += BATCH_SIZE) {
-    const batch = texts.slice(i, i + BATCH_SIZE)
-    const data = await requestWithRetry(embedder, batch, signal)
-    // Mismatched count is a hard error — silently accepting would misalign vectors with texts, poisoning the entire index
-    if (!Array.isArray(data.data) || data.data.length !== batch.length) {
-      throw new Error(`Embedding API returned ${data.data?.length ?? 0} vectors for ${batch.length} inputs`)
-    }
-    // Spec says data[] order matches input, but sort by index field if present — don't bet on server implementation
-    const items = data.data.every((d) => typeof d.index === "number")
-      ? [...data.data].sort((a, b) => a.index - b.index)
-      : data.data
-    for (const item of items) {
-      vectors.push(normalize(Float32Array.from(item.embedding)))
-    }
-  }
-  return vectors
-}
-
-/** Cosine similarity (inputs are normalized, dot product equals cosine) */
-export function cosine(a, b) {
-  if (a.length !== b.length) return 0
-  let sum = 0
-  const n = a.length
-  for (let i = 0; i < n; i++) sum += a[i] * b[i]
-  return sum
-}
-
-/** Float32Array → Buffer suitable for sqlite BLOB storage */
-export function toBlob(vec) {
-  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength)
-}
-
-/** sqlite BLOB → Float32Array */
-export function fromBlob(buf) {
-  // BLOB may come from Buffer pool where byteOffset isn't 4-aligned; creating a view directly would RangeError — copy to align first
-  if (buf.byteOffset % 4 !== 0) buf = new Uint8Array(buf)
-  if (buf.byteLength % 4 !== 0) return new Float32Array(0)
-  return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4)
-}
-
-// ---------------------------------------------------------------- internal
-
-async function requestWithRetry(embedder, input, signal) {
-  let lastError
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    if (attempt > 0) await sleep(2 ** (attempt - 1) * 1000)
-
-    let response
-    try {
-      response = await fetch(`${embedder.baseURL}/embeddings`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${embedder.apiKey}`,
-        },
-        body: JSON.stringify({ model: embedder.model, input }),
-        signal: signal
-          ? AbortSignal.any([signal, AbortSignal.timeout(60_000)])
-          : AbortSignal.timeout(60_000),
-      })
-    } catch (error) {
-      if (error.name === "AbortError") throw error
-      lastError = error
-      continue
-    }
-
-    if (response.ok) return response.json()
-
-    const text = await response.text().catch(() => "")
-    const message = `Embedding API error ${response.status}: ${text}`
-    if (RETRYABLE_STATUS.has(response.status)) {
-      lastError = new Error(message)
-      continue
-    }
-    throw new Error(message)
-  }
-  throw lastError
-}
-
-function normalize(vec) {
-  let sum = 0
-  for (let i = 0; i < vec.length; i++) sum += vec[i] * vec[i]
-  const norm = Math.sqrt(sum) || 1
-  for (let i = 0; i < vec.length; i++) vec[i] /= norm
-  return vec
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}

package/src/escape.mjs

@@ -1,152 +0,0 @@
-/**
- * escape.mjs — 中和 OpenAI 兼容服务端在 message content 内做的非标二次转义解析 + 孤立代理净化。
- *
- * 两个独立毒源（均真机实证）：
- *
- * ① 字面 hex 转义二次解析（2026-08-06 Kimi 首观察）：Kimi/deepseek 等网关会把 content 里的字面
- *    "\x5Cx" / "\x5Cu" 当作 hex escape 再解释一遍，不足位时 400（"unexpected end of hex escape"）。
- *    对策：不足位序列前 double 反斜杠（\\x5CxNN 形态还原为字面量）；合法完整序列放行。
- *    Known limitation（2026-09-01 v3 修复）：反斜杠 run ≥3 时（如 "\\\x5Cu" 三反斜杠+u）v1 的
- *    lookbehind 只看前 1 字符会整体放行，但二次解析按配对消费后尾部的 \x5Cu 仍裸露 → 炸。
- *    修复：按 run 奇偶判断——run 为奇数时尾部的 \x5Cu/\x5Cx 裸露（需 double），偶数已配对（放行）。
- *
- * ② 孤立 UTF-16 代理对（2026-09-02 deepseek 真机实锤）：content 里的**真实孤立代理字符**
- *    （高代理 U+D800-DBFF 无低代理跟随，或低代理 U+DC00-DFFF 无高代理前置）——JSON.stringify
- *    输出 \ud83d（合法 JSON），但 deepseek 解析器严格 UTF-16 解码，孤立代理 → 400
- *    （"unexpected end of hex escape" / "lone leading surrogate in hex escape"）。
- *    来源实证：doc_search 结果预览 `slice(0, N)` 按 UTF-16 码元截断，emoji 🔴（代理对）恰在
- *    截断边界被切成孤立高代理 → 注入 system reminder → 每轮发送 → deepseek 400。
- *    对策：发送前把孤立代理替换为  U+FFFD（任何来源安全兜底）；源头截断点另修 UTF-16 安全切。
- */
-
-/** 中和非法字面 hex 转义序列（毒源①）。 */
-export function escapeLiteralEscapes(text) {
-  text = String(text ?? "")
-  let out = ""
-  let i = 0
-  const n = text.length
-  while (i < n) {
-    const ch = text[i]
-    if (ch !== "\\") { out += ch; i++; continue }
-    // 数反斜杠 run 长度
-    let run = 0
-    while (i + run < n && text[i + run] === "\\") run++
-    const next = text[i + run]
-    if ((next === "x" || next === "u") && run % 2 === 1) {
-      // run 奇数 → 二次解析配对消费后尾部 \x5Cx/\x5Cu 裸露——hex 不足则网关炸 → 前插反斜杠 double
-      const need = next === "u" ? 4 : 2
-      const after = text.slice(i + run + 1, i + run + 1 + need)
-      if (!new RegExp(`^[0-9a-fA-F]{${need}}$`).test(after)) {
-        out += "\\".repeat(run + 1) + next
-        i += run + 1
-        continue
-      }
-      // 合法完整：输出全序列并跳过（hex 尾不重新扫描）
-      out += text.slice(i, i + run + 1 + need)
-      i += run + 1 + need
-      continue
-    }
-    out += "\\".repeat(run)
-    i += run
-  }
-  return out
-}
-
-/** 净化孤立 UTF-16 代理对（毒源②）：高代理无低代理跟随 / 低代理无高代理前置 → 替换为 。 */
-export function sanitizeLoneSurrogates(text) {
-  text = String(text ?? "")
-  let out = ""
-  let i = 0
-  const n = text.length
-  while (i < n) {
-    const cp = text.charCodeAt(i)
-    if (cp >= 0xd800 && cp <= 0xdbff) {
-      const next = text.charCodeAt(i + 1)
-      if (next >= 0xdc00 && next <= 0xdfff) { out += text[i] + text[i + 1]; i += 2; continue }
-      out += ""; i++; continue // 孤立高代理
-    }
-    if (cp >= 0xdc00 && cp <= 0xdfff) { out += ""; i++; continue } // 孤立低代理
-    out += text[i]; i++
-  }
-  return out
-}
-
-/** 发送前文本净化总入口：hex 转义中和 + 孤立代理净化。 */
-export function sanitizeText(text) {
-  return sanitizeLoneSurrogates(escapeLiteralEscapes(text))
-}
-
-/** 对单条消息的 content 应用 sanitizeText（支持字符串或 OpenAI 多模态 part 数组）。
- *  2026-08-31 会诊 F5：deepseek-v4-flash 网关对 tool_calls[].function.arguments 与
- *  reasoning_content 做同样的非标二次转义解析（字面 \\x5Cx/\\x5Cu 经工具参数/思考回传 → 400，
- *  列号确定性复现 = 毒序列在 content 之外）——这两个字符串字段同样需要中和。 */
-export function escapeMessageContent(message) {
-  const content = message?.content
-  let changed = false
-  let next = message
-  if (typeof content === "string") {
-    const escaped = sanitizeText(content)
-    if (escaped !== content) {
-      next = { ...next, content: escaped }
-      changed = true
-    }
-  } else if (Array.isArray(content)) {
-    const parts = content.map((p) => {
-      if (p && typeof p === "object" && p.type === "text" && typeof p.text === "string") {
-        const escaped = sanitizeText(p.text)
-        if (escaped !== p.text) {
-          changed = true
-          return { ...p, text: escaped }
-        }
-      }
-      return p
-    })
-    if (changed) next = { ...next, content: parts }
-  }
-  if (Array.isArray(next.tool_calls)) {
-    let tcChanged = false
-    const tool_calls = next.tool_calls.map((tc) => {
-      const args = tc?.function?.arguments
-      if (typeof args === "string") {
-        const escaped = sanitizeText(args)
-        if (escaped !== args) {
-          tcChanged = true
-          return { ...tc, function: { ...tc.function, arguments: escaped } }
-        }
-      }
-      return tc
-    })
-    if (tcChanged) {
-      next = { ...next, tool_calls }
-      changed = true
-    }
-  }
-  if (typeof next.reasoning_content === "string") {
-    const escaped = sanitizeText(next.reasoning_content)
-    if (escaped !== next.reasoning_content) {
-      next = { ...next, reasoning_content: escaped }
-      changed = true
-    }
-  }
-  return changed ? next : message
-}
-
-/** IKBGX4 + SESSION.md §9 D-S1：剥离仅本地使用的整消息标记字段（transient/ts）——发送给 provider 前移除。
- * 严格 OpenAI 兼容服务端（opencode/LiteLLM 等）会拒绝消息级未知 key
- * （"Extra inputs are not permitted, field: 'messages[i].transient'"）；ts 同理
- * （消息时间戳是本地取证字段，不进任何 provider 请求——T-S3）。copy-on-write：
- * 历史里的原对象不动（read_history 仍能读到 ts）。 */
-export function stripLocalMessageFields(messages) {
-  return messages.map((m) => {
-    if (m && typeof m === "object" && ("transient" in m || "ts" in m)) {
-      const { transient, ts, ...rest } = m
-      return rest
-    }
-    return m
-  })
-}
-
-/** 对整个 messages 数组逐条应用 escapeMessageContent（先剥离本地字段，再转义）。 */
-export function escapeMessages(messages) {
-  return stripLocalMessageFields(messages).map(escapeMessageContent)
-}

package/src/expand-home.mjs

@@ -1,16 +0,0 @@
-/**
- * expand-home.mjs — 配置路径字段家目录展开器（第 29 批 HOME-EXPANSION，2026-09-11）。
- * `loadConfig()` 单一规范化点（设计 MEMORY.md §9.3a）：纯函数、零依赖、home 可注入。
- */
-
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-/** 展开配置路径字段的前缀 `~`（`~` / `~/` / `~\`）为主目录绝对路径；不识别形态原样返回。
- *  home 第二参 = 测试注入缝（生产缺省 homedir()）。 */
-export function expandHome(p, home = homedir()) {
-  if (typeof p !== "string" || !p.startsWith("~")) return p   // 非字符串 / 非 ~ 前缀 → 原样
-  if (p === "~") return home                                  // 裸 ~ = 主目录
-  if (p[1] !== "/" && p[1] !== "\\") return p                 // ~user 等非分隔符 → 原样（不猜用户）
-  return join(home, p.slice(2).replaceAll("\\", "/"))         // 余段分隔符归一（跨端统一）
-}

package/src/explore-distill.mjs

@@ -1,155 +0,0 @@
-/**
- * explore-distill.mjs — End-of-run exploration distillation (AGENT-LOOP §13 +
- * CONTEXT-COMPACTION §5, 2026-08-23). 2026-09-05 module-split: moved verbatim out of
- * context.mjs (524 > 500 hard limit). The main agent's machine line is flooded by inline
- * step-by-step exploration (read/grep/...). At run end we distill THIS run's exploration
- * tool-results into one semantic summary note that replaces them in the machine line,
- * while agent._fullHistory (the human line) stays untouched. VS Code compact.mjs
- * distillation mirrors this module (same-name file in thincoder-vscode/src, cross-repo
- * parity anchors point here).
- */
-
-import { chat } from "./provider/index.mjs"
-
-/** Read-only knowledge tools counted as "exploration" (execute writes files → never exploration). */
-export const EXPLORE_TOOLS = new Set([
-  "read", "grep", "glob", "ls", "code_search", "doc_search", "repo_outline",
-])
-
-/** Summary prompt for turning a burst of exploration results into a semantic summary. */
-export const EXPLORE_SUMMARY_PROMPT = `You are distilling exploration tool results. Summarize the following read-only codebase exploration into a compact semantic summary for the main agent's own context.
-
-Requirements:
-- Capture WHAT was discovered, WHERE (which files / directories / symbols), and the KEY CONCLUSIONS — do not list tool calls mechanically
-- Keep actionable facts the main agent needs to continue: code locations, function names, file paths, structure, and open questions the exploration raised
-- Drop raw tool-output noise, repeated lines, and verbatim file dumps — keep only what must be remembered
-- Be honest: mark anything not actually verified as "unverified"; do not present guesses as facts
-- Use bullet points; aim for information completeness, not a hard word limit
-
-Exploration log:
-`
-
-/** tool_calls name across both stored shapes ({function:{name}} and flat {name}). */
-function toolCallName(tc) {
-  return tc?.function?.name ?? tc?.name ?? ""
-}
-
-/** Tool that produced a tool-result message (falls back to its owner assistant's tool_call). */
-function toolResultName(msg, ownerToolCalls) {
-  if (typeof msg?.name === "string" && msg.name) return msg.name
-  const owner = (ownerToolCalls ?? []).find((tc) => tc.id === msg?.tool_call_id)
-  return owner ? toolCallName(owner) : ""
-}
-
-/**
- * Find the pure-exploration "assistant(tool_calls)→tool…" pair blocks added since `start`.
- * A block is explorable only when EVERY tool call AND every tool result in it is an exploration
- * tool — mixed blocks (read + edit in one turn) stay untouched, or we'd orphan the edit pairing.
- */
-function findExplorationBlocks(history, start) {
-  const blocks = []
-  let i = start
-  while (i < history.length) {
-    const m = history[i]
-    if (m?.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
-      let j = i + 1
-      while (j < history.length && history[j]?.role === "tool") j++
-      const toolMsgs = history.slice(i + 1, j)
-      const allCallsExplore = m.tool_calls.every((tc) => EXPLORE_TOOLS.has(toolCallName(tc)))
-      const allResultsExplore = toolMsgs.length > 0 && toolMsgs.every((t) => EXPLORE_TOOLS.has(toolResultName(t, m.tool_calls)))
-      if (allCallsExplore && allResultsExplore) {
-        blocks.push({ start: i, end: j, messages: history.slice(i, j), toolCount: toolMsgs.length })
-      }
-      i = j
-    } else {
-      i++
-    }
-  }
-  return blocks
-}
-
-/** Serialize a batch of exploration messages for the summary LLM (same shape as compaction serialization). */
-function serializeExplorationMessages(messages) {
-  const cap = 8000 // exploration results ARE the signal to distill — generous cap (quality-first, N1)
-  return messages
-    .map((m) => {
-      const toolNote = m.tool_calls ? ` [called tools: ${m.tool_calls.map(toolCallName).join(", ")}]` : ""
-      let text = ""
-      if (typeof m.content === "string") text = m.content
-      else if (Array.isArray(m.content)) text = m.content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join(" ")
-      return `[${m.role}]${toolNote} ${text.slice(0, cap)}`
-    })
-    .join("\n")
-}
-
-/**
- * Core (shared) distillation: replace this run's pure-exploration pair blocks with a single
- * "[Exploration summary]" note placed where the first block was. Returns a NEW history array,
- * or null when there is nothing to shrink (<3 exploration results / LLM failure). Pairing-safe:
- * whole assistant→tool blocks are removed, so no orphan tool_calls/tool can survive.
- */
-async function distillExplorations(history, start, provider, signal, agent, depth) {
-  if (!Array.isArray(history) || history.length - start < 2) return null
-  const blocks = findExplorationBlocks(history, start)
-  const resultCount = blocks.reduce((n, b) => n + b.toolCount, 0)
-  if (resultCount < 3) return null
-
-  const serialized = blocks.map((b) => serializeExplorationMessages(b.messages)).join("\n")
-
-  let summary
-  try {
-    // Silent by design (D11): thinking:null and no onToken/onReasoning — this internal
-    // distillation must not stream to the frontend. signal propagates user cancellation.
-    const resp = await chat({ ...provider, thinking: null, reasoningEffort: null }, {
-      messages: [{ role: "user", content: EXPLORE_SUMMARY_PROMPT + serialized }],
-      signal,
-      // §18.6 D-TR4：轨迹元数据增补——kind=distill（探索蒸馏面——agent 元数据透出；
-      // depth 经 summarizeRunExplorations 参数透传——agent.mjs 主作用域传入）
-      logCtx: {
-        stage: "distill", child: agent?._logId ?? null, kind: "distill",
-        role: agent?._role ?? null, depth: depth ?? null,
-        session: agent?._sessionStart ?? null, cwd: agent?.cwd ?? process.cwd(),
-        traces: agent?.config?.traces?.enabled !== false,
-      },
-    })
-    summary = resp?.content
-  } catch {
-    return null // N3: never block the run's return or lose history — original results stay
-  }
-  if (!summary) return null
-
-  const drop = new Set()
-  for (const b of blocks) for (let k = b.start; k < b.end; k++) drop.add(k)
-  const note = { role: "user", content: "[Exploration summary]\n" + summary }
-  const next = []
-  let inserted = false
-  for (let k = 0; k < history.length; k++) {
-    if (drop.has(k)) {
-      if (!inserted) { next.push(note); inserted = true }
-      continue
-    }
-    next.push(history[k])
-  }
-  return next
-}
-
-/**
- * End-of-run exploration distillation (runAgent's final return). Shrinks the MACHINE line
- * (agent.history) only; agent._fullHistory is never touched. Triggers when this run added ≥3
- * exploration tool results; on LLM failure it silently keeps the original history (N3).
- * The distillation itself is silent and never streams (D11); `callbacks.onDistilled` fires
- * ONLY after the replacement actually lands (never on no-op/failure) — callers persist the
- * compressed session (SEND-STALL-DISTILL §2.3).
- */
-export async function summarizeRunExplorations(agent, callbacks, signal, depth = 0) {
-  const next = await distillExplorations(agent.history, agent._runStartHistoryLen ?? 0, agent.provider, signal, agent, depth)
-  if (!next) return
-  agent.history = next
-  // The machine line changed shape — the measured token baseline was for the pre-shrink context.
-  // Invalidate so the next compaction check re-estimates instead of over-counting stale history.
-  agent._lastPromptTokens = null
-  agent._usageAtLen = null
-  // The compressed machine line must reach the disk: the run's own save already happened,
-  // so without this hook the async distill would leave the session un-compressed on exit.
-  callbacks.onDistilled?.()
-}

package/src/generate-title.mjs

@@ -1,88 +0,0 @@
-/**
- * generate-title.mjs — LLM-generated session titles (CLI side)
- * Called after the first user message to auto-title the session.
- * Mirrors thincoder-vscode/src/extension/generate-title.mjs but uses the CLI provider shape.
- *
- * CLI is OpenAI-compatible ONLY: a single direct fetch (no anthropic/google format dispatch) —
- * see docs/design/SESSION.md §IK9UZ8-D.
- */
-
-import { proxyFetch } from "./proxy.mjs"
-
-// Test seam (_-prefix, mirrors run.mjs seams): lets the proxy-branch regression
-// test swap the proxy fetch. The branch it exercises used to carry a dynamic
-// import("../proxy.mjs") that silently resolved to the REPO ROOT from src/ —
-// the thrown ERR_MODULE_NOT_FOUND vanished into the catch, and proxy users
-// lost session titles with zero test coverage (2026-08-30 review).
-export const _deps = { proxyFetchImpl: proxyFetch }
-
-const MAX_TITLE_TOKENS = 100
-
-/** Generate a session title from the first user message using an LLM. Returns title string or null. */
-export async function generateTitle(userContent, provider) {
-  // Extract text even from multimodal content (array of parts)
-  const userText = Array.isArray(userContent)
-    ? userContent.find((p) => p.type === "text")?.text || ""
-    : userContent
-  if (typeof userText !== "string" || userText.length < 10) return null
-  if (!provider?.apiKey || !provider?.baseURL || !provider?.model) return null
-
-  try {
-    const body = JSON.stringify({
-      model: provider.model,
-      messages: [
-        { role: "system", content: "Generate a concise title (max 40 chars, no quotes) for this conversation. Reply ONLY with the title." },
-        { role: "user", content: userText.slice(0, 200) },
-      ],
-      // Disable thinking so reasoning_content doesn't consume the whole output budget and
-      // leave content empty (IK9UZ8). Providers that don't accept the field ignore it
-      // (OpenAI-compatible convention). A 40-char title wants ~60–80 tokens, so 100 is
-      // ~2.5x headroom (design decision — docs/design/SESSION.md §IK9UZ8-D).
-      thinking: { type: "disabled" },
-      max_tokens: MAX_TITLE_TOKENS,
-      stream: false,
-    })
-    const chatPath = provider.chatPath ?? "/chat/completions"
-    const url = `${provider.baseURL.replace(/\/+$/, "")}${chatPath}`
-    const opts = {
-      method: "POST",
-      headers: { ...(provider.headers ?? {}), "Content-Type": "application/json", Authorization: `Bearer ${provider.apiKey}` }, // 定制头展开（PROVIDER.md §21）——定制头在前、内置头在后：内置头胜出
-      body,
-      signal: AbortSignal.timeout(10000),
-    }
-    const res = provider.proxyUri
-      ? await _deps.proxyFetchImpl(url, opts, provider.proxyUri)
-      : await fetch(url, opts)
-    if (!res.ok) return null
-    const data = await res.json()
-    const title = data.choices?.[0]?.message?.content?.trim().slice(0, 40)
-    return title || null
-  } catch {
-    return null
-  }
-}
-
-/** Derive + assign the session title from the first user message (once per session).
- *  Extracted from agent-turn.mjs's finally block (2026-08-30): the lookup + call +
- *  assign belongs beside generateTitle, not in the turn driver. Non-fatal on
- *  failure — title generation must never break the turn. Returns the title (or null). */
-export async function ensureSessionTitle(agent) {
-  if (agent.title) return agent.title
-  try {
-    // TUI-OOM-ROOTCAUSE 批（SESSION.md §14.3.3）：绑定态首条 user 消息在记录存储（段 1）——
-    // 内存窗口可能已滑过它（store.firstUserMessage 首扫一次并缓存）；未绑定回退内存查找。
-    let firstUser = agent._recordStore?.firstUserMessage?.() ?? null
-    if (!firstUser) {
-      firstUser = (agent._fullHistory ?? agent.history).find(
-        (m) => m.role === "user" && typeof m.content === "string" && !m.content.startsWith("[System reminder:"),
-      )
-    }
-    if (firstUser) {
-      const title = await generateTitle(firstUser.content, agent.provider)
-      if (title) agent.title = title
-    }
-  } catch {
-    // Title generation failure is non-fatal
-  }
-  return agent.title ?? null
-}