mslxdff 0.1.232 → 0.1.233

package/src/providers/qoder/sse.js

@@ -13,6 +13,10 @@ export function extractDelta(dataLine) {
   }
   if (wrapper.statusCodeValue !== undefined && Number(wrapper.statusCodeValue) !== 200) {
     const detail = typeof wrapper.body === "string" && wrapper.body ? wrapper.body : JSON.stringify(wrapper).slice(0, 400);
+    // 登录过期（code 105）与非 200 容器同层：先于额度/排队判，命中交门面走「刷新令牌→原地重发」，
+    // 绝不可当普通 403 冷却换号（实测会把整池过期号轮一遍，每号还叠 3 次空转重试，白烧）。
+    const login = findLoginSignal(wrapper);
+    if (login) return { err: { kind: "auth", status: 401, detail: login.slice(0, 300), loginExpired: true } };
     // 额度耗尽可能裹在非 200 信封里，且实测是**多层嵌套**（外层 statusCodeValue:403 →
     // code:10605 → 内层 code:"110" / "Billing daily count exceeded"）。只看一层会把额度错
     // 当普通 403；显式扫各层信号才能可靠命中（排队 10605 无 110 信号，天然不误判）。
@@ -22,7 +26,11 @@ export function extractDelta(dataLine) {
     // 不新增 kind：errorStatus 与流内 error 的 type 字段一律不变（对外契约零改动），
     // 门面据 x-mslxdff-qoder-queued 走队列档冷却 + 同请求换号。
     const queued = findQueueSignal(wrapper);
-    return { err: { kind: "upstream", status: Number(wrapper.statusCodeValue) || 502, detail, ...(queued ? { queued: true, code: queued.code } : {}) } };
+    if (queued) {
+      const ra = retryAfterFrom(detail);
+      return { err: { kind: "upstream", status: Number(wrapper.statusCodeValue) || 502, detail, queued: true, code: queued.code, ...(queued.noCapacity ? { noCapacity: true } : {}), ...ra } };
+    }
+    return { err: { kind: "upstream", status: Number(wrapper.statusCodeValue) || 502, detail } };
   }
   const inner = wrapper.body;
   if (!inner || typeof inner !== "string") {
@@ -34,6 +42,9 @@ export function extractDelta(dataLine) {
     ddbg(`[inner-parse-fail] ${e.message} body=${inner.slice(0, 300)}`);
     return {};
   }
+  // 实测真身形态：statusCodeValue:200 信封，内层 body 直接 {"code":"105","message":"Login expired"}。
+  // 只认内层结构化 code（正常 chat chunk 无顶层 code 字段，正文文本永不匹配 → 零误伤）。
+  if (isLoginExpired(j.code, j.message)) return { err: { kind: "auth", status: 401, code: j.code, detail: String(j.message || "").slice(0, 300), loginExpired: true } };
   let usageIn = 0, usageOut = 0;
   if (j.usage && typeof j.usage === "object") {
     usageIn = Math.trunc(Number(j.usage.prompt_tokens) || 0);
@@ -56,10 +67,13 @@ export function extractDelta(dataLine) {
   }
   if (typeof j.code === "string" && j.code && j.code !== "0") {
     const msg = String(j.message || "");
-    // 额度耗尽（实测 code=110 "Billing daily count exceeded"）：按配额错单列，门面据此换号。
-    // 只认 code 110 / Billing 专属措辞 —— 普通 "quota exceeded"（code 115）仍归业务错，不误伤。
+    // 判序：内容审核文案最先——上游会把 inappropriate 类文案配在 1xx/4xx 码上（既有契约锁「审核→content_policy」）。
+    if (/inappropriate|DataInspection|Sensitive|ContentFilter/i.test(msg)) return { err: { kind: "content_policy", code: j.code, detail: msg } };
+    // 额度耗尽（官方额度码族 + Billing 专属措辞）：按配额错单列，门面据此换号（长冷却）。
     if (isQuotaError(j.code, msg)) return { err: { kind: "quota", status: 429, code: j.code, detail: msg || `code=${j.code}` } };
-    return { err: { kind: /inappropriate|DataInspection|Sensitive|ContentFilter/i.test(msg) ? "content_policy" : "business", code: j.code, detail: msg } };
+    // 请求被拒（内容/长度/能力，换号无用）：归 request → 400 直出，不冷却不换号。
+    if (isRequestError(j.code)) return { err: { kind: "request", code: j.code, detail: msg || `code=${j.code}` } };
+    return { err: { kind: "business", code: j.code, detail: msg } };
   }
   if (finishReason) return { finishReason, usageIn, usageOut };
   if (usageIn > 0 || usageOut > 0) return { usageIn, usageOut };
@@ -69,12 +83,26 @@ export function extractDelta(dataLine) {
   return {};
 }
 
-/** 额度耗尽识别：code 110 白名单 + Billing 专属措辞（收紧：普通 quota exceeded 归业务错） */
+/** 额度耗尽识别：Qoder 额度码家族（110、112–114、117–119、122）+ Billing 专属措辞。
+ *  旧版只认 110——实测上游 403 信封内层发同族码时会被误归 business→502，
+ *  门面按普通坏号短冷却 30s 反复撞（额度按天重置，短冷却等于白烧），故补全。
+ *  收紧两处（均为实测冲突证据，宁缺勿滥）：
+ *  - code 115（"quota exceeded" 泛化措辞）归业务错（既有契约：不误伤）；
+ *  - code 116 官方表写 Team Credits，但现网实测被复用为 DataInspection 内容审核 → 不入额度族，留给 content_policy。 */
+const QUOTA_CODES = new Set(["110", "112", "113", "114", "117", "118", "119", "122"]);
 export function isQuotaError(code, message) {
-  if (String(code || "").trim() === "110") return true;
+  if (QUOTA_CODES.has(String(code || "").trim())) return true;
   return /billing\s*(daily)?\s*(count|limit|quota)?\s*exceed/i.test(String(message || ""));
 }
 
+// 请求拒绝码（对齐 magpie/CLIProxyAPI 的 REQUEST_CODES 真值）：这些是「这条请求被拒」而非「这个号不行」——
+// 敏感内容(406)/范围不支持(416)/能力不支持(430)/输入过长(80411)/图太多(80412)/自定义模型服务侧(1004xx)。
+// 换号救不了（同一条请求发给哪个号都被拒），故归 request → errorStatus 折 400 直出，不冷却不换号。
+const REQUEST_CODES = new Set(["406", "416", "430", "80411", "80412", "100400", "100401", "100402", "100403"]);
+export function isRequestError(code) {
+  return REQUEST_CODES.has(String(code || "").trim());
+}
+
 // 显式额度信号扫描：信封各层里找 code 110 / Billing 明确措辞。
 // 限深 4 层（实测 3 层足够，留一层余量），字符串层自动尝试 JSON.parse 后继续下钻。
 // 排队 10605（isQueued/serviceAvailable）无 110 信号 → 返回 null，天然不误判为额度。
@@ -104,21 +132,36 @@ export function findQuotaSignal(value, depth = 0) {
 
 /** 排队识别（与额度共用 10605 容器 → 判序必须先额度、后排队的纯函数）：
  *  命中条件 = 容器码 10605，或内层显式 isQueued:true / serviceAvailable:false。
- *  实测形态：403 信封 → code 10605 → message 里带 isQueued:true、retryAfterSeconds:30。 */
+ *  实测形态：403 信封 → code 10605 → message 里带 isQueued:true、retryAfterSeconds:30。
+ *  noCapacity 子型（2026-10-22 现网）：isQueued:true + queueCount:0 + serviceAvailable:false + subCode:RESOURCE_LIMIT
+ *  = 「p3 队列此刻无容量、无人在排」——同档位整池共享同一队列，换号救不了，只能等 Retry-After。
+ *  2026-10-22 真机回归：现网 HTTP 403 body 是四层转义信封
+ *  {"error":{"message":"{\"code\":\"403\",\"message\":\"{\\\"code\\\":\\\"10605\\\",…}}"}——
+ *  引号被叠成 \"isQueued\"，带引号的正则在第 0 层永远打不中，纯靠下钻又撞深度顶。
+ *  与 retryAfterFrom 同法：判决前先剥反斜杠归一，令任意嵌套层度的字面量都还原为可匹配形态。 */
 export function isQueueSignal(code, message) {
   if (String(code || "").trim() === QUEUE_CODE) return true;
-  const s = String(message || "");
+  const s = String(message || "").replace(/\\/g, "");
   if (!s) return false;
   return /"isQueued"\s*:\s*true/.test(s) || /"serviceAvailable"\s*:\s*false/.test(s);
 }
 
-/** 排队信号扫描：与 findQuotaSignal 同构（同限深、字符串层自动 parse 下钻），命中返回 { code }。 */
+// noCapacity 判据（isQueueSignal 已命中为前提）：队列空（queueCount:0）且服务不可用（serviceAvailable:false）。
+// 与「真排队等放行」（queueCount>0）区分：前者换号无用（整池同队列同容量），后者可能另一号有空位。
+// 剥反斜杠同 isQueueSignal（真机四层转义，见上）。
+export function isNoCapacitySignal(message) {
+  const s = String(message || "").replace(/\\/g, "");
+  if (!s) return false;
+  return /"queueCount"\s*:\s*0/.test(s) && /"serviceAvailable"\s*:\s*false/.test(s);
+}
+
+/** 排队信号扫描：与 findQuotaSignal 同构（同限深、字符串层自动 parse 下钻），命中返回 { code, noCapacity }。 */
 export function findQueueSignal(value, depth = 0) {
   if (value == null || depth > MAX_ENVELOPE_DEPTH) return null;
   if (typeof value === "string") {
     const s = value.trim();
     if (!s) return null;
-    if (isQueueSignal("", s)) return { code: QUEUE_CODE };
+    if (isQueueSignal("", s)) return { code: QUEUE_CODE, noCapacity: isNoCapacitySignal(s) };
     try {
       return findQueueSignal(JSON.parse(s), depth + 1);
     } catch {
@@ -126,7 +169,9 @@ export function findQueueSignal(value, depth = 0) {
     }
   }
   if (typeof value !== "object") return null;
-  if (isQueueSignal(value.code, value.message)) return { code: String(value.code || QUEUE_CODE) };
+  if (isQueueSignal(value.code, value.message)) {
+    return { code: String(value.code || QUEUE_CODE), noCapacity: isNoCapacitySignal(String(value.message || "")) };
+  }
   for (const v of Object.values(value)) {
     const hit = findQueueSignal(v, depth + 1);
     if (hit) return hit;
@@ -134,10 +179,53 @@ export function findQueueSignal(value, depth = 0) {
   return null;
 }
 
-// 错误四分类 → HTTP 状态（对齐 errors.go ErrorStatus 语义）
+// 登录过期（code 105 "Login expired"）：令牌过期≠号坏——官方 CLI 临期自动续，
+// 识别命中后门面用 refresh_token 换新 token 原地重发；refresh 也被拒（真作废）才长冷却该号并提示重登。
+export function isLoginExpired(code, message) {
+  if (String(code || "").trim() === "105") return true;
+  const s = String(message || "");
+  // 只认带 code 的结构化形态（正文里出现 "Login expired" 字样不得误伤）。
+  // (?![0-9]) 数字边界是 2026-10-22 真机教训：排队码 10605 以 105 开头，
+  // 无边界时 "code":"10605" 被当前缀命中 → login 抢在 queue 判决前误判，noCapacity 链全哑。
+  return /"code"\s*:\s*"?105"?(?![0-9])/.test(s);
+}
+
+/** 登录信号扫描：与 findQuotaSignal 同构（限深 4 层、字符串层自动 parse 下钻）。 */
+export function findLoginSignal(value, depth = 0) {
+  if (value == null || depth > MAX_ENVELOPE_DEPTH) return null;
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (!s) return null;
+    if (isLoginExpired("", s)) return s;
+    try {
+      return findLoginSignal(JSON.parse(s), depth + 1);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof value !== "object") return null;
+  if (isLoginExpired(value.code, value.message)) return String(value.message || "Login expired");
+  for (const v of Object.values(value)) {
+    const hit = findLoginSignal(v, depth + 1);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+// 从错误 detail（可能是 JSON 或 JSON-in-string）里抽 retryAfterSeconds → { retryAfter: 秒 }（无则 {}）。
+// 上游排队判决自带 retryAfterSeconds:30，透传给上层做 Retry-After，别让上层瞎猜退避。
+export function retryAfterFrom(text) {
+  const m = String(text || "").replace(/\\/g, "").match(/"retryAfterSeconds"\s*:\s*(\d+)/i);
+  if (!m) return {};
+  const n = Number(m[1]);
+  return Number.isFinite(n) && n > 0 ? { retryAfter: n } : {};
+}
+
+// 错误分类 → HTTP 状态（对齐 errors.go ErrorStatus 语义；request=请求被拒折 400 直出）
 export function errorStatus(err) {
   if (!err) return 500;
   if (err.kind === "content_policy") return 400;
+  if (err.kind === "request") return 400; // 换号无用：如实 400 给客户端，不冷却不换号
   if (err.kind === "auth") return [401, 403].includes(err.status) ? err.status : 401;
   if (err.kind === "upstream") return [401, 403, 429].includes(err.status) ? err.status : 502;
   if (err.kind === "quota") return 429; // 额度错按限流语义出（门面据此换号/冷却）

package/src/providers/qoder/sticky.js

@@ -15,7 +15,7 @@ export function createStickyPicker({ pick, isCooling = () => false, now = Date.n
 
   // onDecision（可选）：把"这次为什么选它"回报给调用方 —— 决定必须可观测。
   // sticky=同请求复用 / new=新请求轮转选中 / switch=上次的号在冷却(或 TTL 过期)故换 / rr=无 scope 退回轮转
-  return function pickSticky(scope, onDecision) {
+  function pickSticky(scope, onDecision) {
     if (!scope) {
       onDecision?.("rr");
       return pick();
@@ -34,5 +34,8 @@ export function createStickyPicker({ pick, isCooling = () => false, now = Date.n
       if (seen.size > maxEntries) evict();
     }
     return key;
-  };
+  }
+  // forget：丢弃 scope 的粘号记录（令牌刷新换了 key 后必须丢弃，否则同请求重试还粘旧 key）
+  pickSticky.forget = (scope) => { seen.delete(scope); };
+  return pickSticky;
 }

package/src/providers/qoder/wire-messages.js

@@ -0,0 +1,242 @@
+// qoder 线格式消息转换层：OpenAI/Anthropic messages → Qoder 原生 wire messages。
+// 从 payload.js 拆出（体积门 + 职责边界：这里只管"消息形状/配对/缓存标记/会话指纹"，不管请求体装配）。
+// 关键事实（2026-10-22 取证，对齐官方 qodercli + dsh-qoder-connect + magpie qoder 插件）：
+//  - messages 必须发 Qoder 原生形状（user 带 contents[]、assistant 回传 reasoning_content、tool 带 tool_call_id）；
+//  - 注入官方 Qoder agent 人格（缓存稳定种子）；末个可缓存块打 cache_control:ephemeral（Anthropic 系只缓存标记段）；
+//  - session_id 按对话稳定（同对话跨请求命中上游 prompt 缓存）；
+//  - tool 配对修复：上游对「孤儿 tool result」整体拒收，须补派生 id / 防抢占认领 / 降级不丢内容。
+import { createHash } from "node:crypto";
+
+export function blankResponseMeta() {
+  return {
+    id: "",
+    usage: {
+      prompt_tokens: 0, completion_tokens: 0, total_tokens: 0,
+      completion_tokens_details: { reasoning_tokens: 0 },
+      prompt_tokens_details: { cached_tokens: 0 },
+    },
+  };
+}
+
+// OpenAI user 消息 → Qoder contents 形状
+export function buildUserMessage(text) {
+  return {
+    role: "user", content: "",
+    contents: [{ type: "text", text: String(text || "") }],
+    response_meta: blankResponseMeta(),
+    reasoning_content_signature: "",
+  };
+}
+
+export function buildStructuredMessage(role, text) {
+  return { role, content: String(text || ""), response_meta: blankResponseMeta(), reasoning_content_signature: "" };
+}
+
+export function normalizeContent(content) {
+  if (typeof content === "string") return content;
+  if (content == null) return "";
+  if (Array.isArray(content)) {
+    let out = "";
+    for (const b of content) {
+      const t = typeof b === "object" && b ? b.text : b;
+      if (typeof t === "string") out += (out ? "\n\n" : "") + t;
+    }
+    return out;
+  }
+  return JSON.stringify(content);
+}
+
+// 单段 image → Qoder image_url part；拿不到可用 url 返回 null
+function imagePartToUrl(b) {
+  // OpenAI 形状 {type:'image_url', image_url:{url}}
+  const direct = typeof b.image_url === "string" ? b.image_url : b.image_url?.url;
+  if (typeof direct === "string" && direct) return { type: "image_url", image_url: { url: direct } };
+  // Anthropic 形状 {type:'image', source:{type:'base64'|'url', media_type, data|url}}
+  const src = b.source;
+  if (src && typeof src === "object") {
+    if (src.type === "url" && typeof src.url === "string" && src.url)
+      return { type: "image_url", image_url: { url: src.url } };
+    if (src.type === "base64" && src.data && src.media_type)
+      return { type: "image_url", image_url: { url: `data:${src.media_type};base64,${src.data}` } };
+  }
+  return null;
+}
+
+// 官方会话人格（对齐 qoder-agent-sdk：magpie 插件同款）：人格行前置、客户端 system 拼后。
+// 固定前缀让上游 prompt 缓存跨轮命中，也让模型身份口径稳定（不再自称别名）。
+const QODER_SYS = "You are a Qoder agent. Use the instructions below and the tools available to you to assist the user.";
+export function withQoderPersona(systemText) {
+  const s = String(systemText || "").trim();
+  return s ? `${QODER_SYS}\n\n${s}` : QODER_SYS;
+}
+
+// tool 配对修复（对齐 magpie #277/#290/#359，实测上游行为）：
+//  - 上游对「tool 行没有应答它前面 assistant 的某个 call」的请求整体拒绝
+//    （"Messages with role 'tool' must be a response to a preceding message with 'tool_calls'"），
+//    客户端丢 id / 上下文压缩截断都会造成孤儿 result → 整个 turn 被枪毙（表现为莫名的 400/空 turn）。
+//  - 修法：call 缺 id 按内容派生稳定 id（同 turn 内跨请求一致，不破坏上游缓存）；
+//    孤儿 result 认领「其后没有任何 result 点名的那个未应答 call」（防孤儿抢占合法点名），认领不到降级 user 文本。
+function callIdFor(at, k, c) {
+  const said = typeof c.function?.arguments === "string" ? c.function.arguments : JSON.stringify(c.function?.arguments ?? {});
+  return "call_" + createHash("sha256").update(`${at}\0${k}\0${c.function?.name ?? ""}\0${said}`).digest("hex").slice(0, 32);
+}
+
+// 从 from 起收集其后所有 result 行点名的 id（user 的 tool_result 数组形态与 tool 行都算），
+// 直到下一个 assistant/user 文本行为止——这是"合法点名预约表"，孤儿认领时须避开。
+function namedAhead(incoming, from) {
+  const names = new Set();
+  for (let j = from; j < incoming.length; j++) {
+    const m = incoming[j];
+    if (!m) continue;
+    if (m.role === "tool") { if (m.tool_call_id) names.add(String(m.tool_call_id)); continue; }
+    if (m.role === "user" && Array.isArray(m.content) && m.content[0]?.type === "tool_result") {
+      for (const b of m.content) if (b?.type === "tool_result" && b.tool_use_id) names.add(String(b.tool_use_id));
+      continue;
+    }
+    break; // 碰到别的角色（assistant 新 turn / user 真话）即停
+  }
+  return names;
+}
+
+// OpenAI messages → Qoder 原生 wire messages（官方形状：user=contents[]；assistant=content+tool_calls+reasoning_content）
+export function toQoderWireMessages(incoming) {
+  const msgs = incoming || [];
+  const out = [];
+  let pendingCallIds = []; // 最近一个 assistant 轮里尚未被 result 应答的 call ids（按发出顺序）
+  let systemText = "";
+  const claimOrDemote = (id, at) => {
+    const sid = String(id || "");
+    if (sid && pendingCallIds.includes(sid)) {
+      pendingCallIds = pendingCallIds.filter((p) => p !== sid);
+      return { ok: true, id: sid };
+    }
+    // 客户端丢了 id / 点名了对不上的 id：认领「后面没人点名」的第一个未应答 call
+    const reserved = namedAhead(msgs, at);
+    const freeAt = pendingCallIds.findIndex((p) => !reserved.has(p));
+    if (freeAt >= 0) return { ok: true, id: pendingCallIds.splice(freeAt, 1)[0] };
+    return { ok: false };
+  };
+  for (let i = 0; i < msgs.length; i++) {
+    const m = msgs[i];
+    if (!m || typeof m !== "object") continue;
+    const text = normalizeContent(m.content);
+    if (m.role === "system") {
+      if (text) systemText = systemText ? systemText + "\n\n" + text : text;
+      continue;
+    }
+    if (m.role === "user") {
+      pendingCallIds = [];
+      // Anthropic tool_result 数组形态 → tool 行（翻译层产物）
+      if (Array.isArray(m.content) && m.content[0]?.type === "tool_result") {
+        for (const b of m.content) {
+          if (b?.type !== "tool_result") continue;
+          const rt = normalizeContent(b.content);
+          const claimed = claimOrDemote(b.tool_use_id || "", i);
+          if (claimed.ok) out.push({ role: "tool", tool_call_id: claimed.id, content: rt });
+          else out.push(buildUserMessage(rt)); // 无路可认领 → 降级 user 文本，内容不丢
+        }
+        continue;
+      }
+      if (Array.isArray(m.content)) {
+        const parts = [];
+        for (const b of m.content) {
+          if (!b || typeof b !== "object") continue;
+          if (b.type === "text" && typeof b.text === "string" && b.text) { parts.push({ type: "text", text: b.text }); continue; }
+          if (b.type === "image" || b.type === "image_url") {
+            const p = imagePartToUrl(b);
+            if (p) { parts.push(p); continue; }
+          }
+          const t = typeof b.text === "string" ? b.text : null;
+          if (t) parts.push({ type: "text", text: t });
+        }
+        if (!parts.length && text) parts.push({ type: "text", text });
+        out.push({
+          role: "user", content: "",
+          contents: parts.length ? parts : [{ type: "text", text: "" }],
+          response_meta: blankResponseMeta(),
+          reasoning_content_signature: "",
+        });
+        continue;
+      }
+      out.push(buildUserMessage(text));
+      continue;
+    }
+    if (m.role === "assistant") {
+      const hasToolCalls = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;
+      if (!text && !hasToolCalls && !m.reasoning_content) continue; // 空气泡不发
+      pendingCallIds = [];
+      const msg = buildStructuredMessage("assistant", text || " ");
+      if (hasToolCalls) {
+        msg.tool_calls = m.tool_calls.map((c, k) => (c?.id ? c : { ...c, id: callIdFor(i, k, c || {}) }));
+        pendingCallIds = msg.tool_calls.map((c) => c.id);
+      }
+      if (m.reasoning_content) msg.reasoning_content = String(m.reasoning_content);
+      out.push(msg);
+      continue;
+    }
+    if (m.role === "tool") {
+      const claimed = claimOrDemote(m.tool_call_id || "", i);
+      if (claimed.ok) {
+        const msg = buildStructuredMessage("tool", text);
+        msg.tool_call_id = claimed.id;
+        if (m.name) msg.name = m.name;
+        out.push(msg);
+      } else {
+        out.push(buildUserMessage(text)); // 孤儿 result → user 文本（上游会整体拒绝 tool 行）
+      }
+      continue;
+    }
+    if (text) out.push(buildStructuredMessage(m.role || "user", text));
+  }
+  // system 人格前置一条（客户端无 system 时也给官方人格，对齐上游客户端行为）
+  out.unshift(buildStructuredMessage("system", withQoderPersona(systemText)));
+  return out;
+}
+
+// 会话指纹（prompt 缓存亲和的关键，对齐 magpie #290）：同一对话（system + 首个 user 相同）
+// 恒定同名 → 上游命中会话缓存，首包显著变快；不同对话各不相同。客户端的 key 原文绝不出门。
+export function conversationSessionId(userId, modelKey, wireMessages) {
+  const sys = [];
+  let firstUser = "";
+  for (const m of wireMessages) {
+    if (m?.role === "system" && m.content) sys.push(String(m.content));
+    if (m?.role === "user") {
+      firstUser = JSON.stringify(m.contents || m.content || "");
+      break;
+    }
+  }
+  const h = createHash("sha256");
+  h.update("qoder-conv");
+  h.update("\0");
+  h.update(String(userId || ""));
+  h.update("\0");
+  h.update(String(modelKey || ""));
+  h.update("\0");
+  h.update(JSON.stringify([sys, firstUser]));
+  const hex = h.digest("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+
+// cache_control 标记（对齐 qoder-agent-sdk 真值，magpie #290）：最后一个 user 轮里
+// 最后一个非工具块打 ephemeral；末轮是 tool 结果时不标。Anthropic 系模型只缓存标记段，
+// 不标 = 整段对话每次全价重算（慢且贵）。输入块原样不动，只加标记。
+const UNCACHED_TYPES = new Set(["thinking", "redacted_thinking", "tool_use", "tool_result"]);
+function findLastCacheable(blocks) {
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const t = blocks[i]?.type;
+    if (t && !UNCACHED_TYPES.has(t)) return i;
+  }
+  return -1;
+}
+export function cacheMark(wireMessages) {
+  const last = wireMessages[wireMessages.length - 1];
+  if (!last || last.role !== "user") return wireMessages;
+  const blocks = Array.isArray(last.contents) ? last.contents : null;
+  if (!blocks || !blocks.length) return wireMessages;
+  const idx = findLastCacheable(blocks);
+  if (idx < 0) return wireMessages;
+  const marked = blocks.slice();
+  marked[idx] = { ...marked[idx], cache_control: { type: "ephemeral" } };
+  wireMessages[wireMessages.length - 1] = { ...last, contents: marked };
+  return wireMessages;
+}

package/src/providers/raccoon/chat.js

@@ -29,7 +29,7 @@ const PEEK_MAX_BYTES = 8192;
  * 出站请求体：剥 `raccoon/` 前缀 + 注入 `extra_body.thinking`。
  * 思考取值优先级：**请求体声明的档位**（`extra_body.thinking.type` / `reasoning_effort` / `reasoningEffort`
  * / `effort` / `thinking.type`，经 src/thinking-effort.js 归一，关断值最高优先）＞ 构造/调用方 `effort`
- * ＞ env `MSLXDFF_RACCOON_THINKING` ＞ 默认「开」。
+ * ＞ env `MSLXDFF_RACCOON_THINKING` ＞ 默认「关」（见 const.js 的 RACCOON_DEFAULT_EFFORT）。
  * **绝不发 `reasoning_effort`**：上游不认该参数（实测传与不传无可测差异），发了只会多一处形态差异。
  * 客户端声明的通用档位字段消费后一律剥除，出站只留本家原生形状 `extra_body.thinking.type`。
  */

package/src/providers/raccoon/const.js

@@ -147,7 +147,21 @@ export function raccoonUserAgent(env = process.env) {
 export const RACCOON_EFFORT_ON = "on";
 export const RACCOON_EFFORT_OFF = "off";
 export const RACCOON_EFFORTS = [RACCOON_EFFORT_ON, RACCOON_EFFORT_OFF];
-export const RACCOON_DEFAULT_EFFORT = RACCOON_EFFORT_ON;
+/**
+ * 默认**关思考**（2026-10-22 本机实测改判，旧值 on）。
+ *
+ * 上游开着思考时，reasoning 与正文抢同一份 `max_tokens`，且推理极慢，两件事叠加正好
+ * 把这家变成「看起来通、实际用不了」：
+ *   · sn-deepseek-v4-1-flash：max_tokens=2000 时 2000 个 completion token **全是 reasoning**，
+ *     正文 0 字、finish=length（talkfull 15:49:35 实录）；
+ *   · Claude Code 形态的请求（system + tools）TTFT 实测 26~84 秒，网关 300s 流闸门、
+ *     客户端首字节耐心全在这段时间里耗着；
+ *   · sn-sensenova-6-8-flash 更绝：连 `thinking.type=disabled` 都压不住，仍产出 980
+ *     reasoning token / 1024 上限 → 正文 80 字即被截断。
+ * 关掉思考后同一请求 TTFT 降到 0.9~4.5 秒、正文完整，这是**可用性**问题不是偏好问题，
+ * 故默认值取 off；要思考的调用方显式传档位（`effort`/请求体 thinking）仍照传，不拦。
+ */
+export const RACCOON_DEFAULT_EFFORT = RACCOON_EFFORT_OFF;
 
 /**
  * 思考档位 → 出站 `thinking.type`。
@@ -158,12 +172,15 @@ export function raccoonThinkingType(effort) {
 }
 
 /**
- * 思考开关的环境默认：`MSLXDFF_RACCOON_THINKING=off|0|false|no|disabled` 关，其余（含未设）=开。
- * 优先级见 `chat.js` 的 `buildRaccoonWireBody`（请求体显式声明 > effort 参数 > 本 env > 默认开）。
+ * 思考开关的环境默认：`MSLXDFF_RACCOON_THINKING=on|1|true|yes|enabled` 开，其余（含未设）=关。
+ * 优先级见 `chat.js` 的 `buildRaccoonWireBody`（请求体显式声明 > effort 参数 > 本 env > 默认关）。
+ * ⚠ 与旧实现相反（旧为「非 off 即开」）：默认值改关的原因见 `RACCOON_DEFAULT_EFFORT`。
  */
 export function raccoonEffortFromEnv(env = process.env) {
   const raw = typeof env?.MSLXDFF_RACCOON_THINKING === "string" ? env.MSLXDFF_RACCOON_THINKING.trim().toLowerCase() : "";
-  return raw === "off" || raw === "0" || raw === "false" || raw === "no" || raw === "disabled" ? RACCOON_EFFORT_OFF : RACCOON_EFFORT_ON;
+  return raw === "on" || raw === "1" || raw === "true" || raw === "yes" || raw === "enabled"
+    ? RACCOON_EFFORT_ON
+    : RACCOON_EFFORT_OFF;
 }
 
 /** 冷却档位（对齐 qoder/zcode 先例：限流短冷、额度长冷）。 */

package/src/providers/raccoon/index.js

@@ -5,7 +5,7 @@ import { envInt } from "../base.js";
 import { createKeyRing } from "../keyring.js";
 import { loadProviderKeys } from "../../state.js";
 import { forwardRaccoonChat } from "./chat.js";
-import { buildRaccoonModelList, listRaccoonModels } from "./models.js";
+import { buildRaccoonModelList, listRaccoonModels, mergeRaccoonCatalogIntoAllowlist } from "./models.js";
 import { applyRaccoonRefresh, listRaccoonAccountDocs, raccoonCredentialFromDoc, readRaccoonAccountDoc, syncRaccoonKeys, writeRaccoonAccountFile } from "./account-store.js";
 import { refreshRaccoonCredential } from "./login.js";
 import { isRaccoonExpiringSoon, raccoonTokenFingerprint } from "./auth.js";
@@ -178,12 +178,25 @@ export function createRaccoonProvider({
     return allCoolingResponse();
   }
 
+  let catalogMergeTried = false;
   async function listModels() {
     let token = ring.keys[0];
     // 内存号已不在文档里（重登换号）时先对齐，否则目录撞 401 后静默回落内置表，表现为「列表不是最新的」
     if (token && !accountFor(token)) token = (await healKeyFromDocs(token)) || token;
     if (!token) return [];
-    const { models } = await listRaccoonModels({ credential: credentialFor(token), fetchImpl });
+    const { models, source } = await listRaccoonModels({ credential: credentialFor(token), fetchImpl });
+    // 上游目录是这家唯一真相（模型 id 全由上游定义、按账号下发）：每进程首次成功拉到就只增不减
+    // 并入 allowlist，否则 dispatcher 会拿登录时播种的静态白名单把新上架模型（如 …-1017）挡掉。
+    // 只在 source=upstream 时做：回落兜底表时并入的仍是静态 id，没有意义还会白写盘。
+    if (source === "upstream" && !catalogMergeTried) {
+      catalogMergeTried = true;
+      try {
+        const { added } = mergeRaccoonCatalogIntoAllowlist(models, file ? { file } : {});
+        if (added.length) console.error(`[raccoon] 上游目录新模型并入白名单: ${added.join(", ")}`);
+      } catch (e) {
+        console.error(`[raccoon] 目录并入白名单失败（列表照常返回）: ${String(e?.message || e).slice(0, 160)}`);
+      }
+    }
     return buildRaccoonModelList({ id, models });
   }