mslxdff 0.1.119 → 0.1.121

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.119",
+  "version": "0.1.121",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/providers/workbuddy/chat.js

@@ -2,6 +2,7 @@ import { joinUrl } from "../base.js";
 import { isAuthError, isInsufficientStatus } from "./auth.js";
 import { appendRotationLog as defaultAppend } from "./rotation-log.js";
 import { createTransport } from "../../transport/index.js";
+import { dispatcherFetch } from "../../upstream-engine/sdk/attempt.js";
 import { reshapeWorkbuddySse } from "./reshape.js";
 import { attemptOnceSdk } from "./sdk-chat.js";
 import { sanitizeToolSequence } from "./sanitize-tools.js";
@@ -88,6 +89,9 @@ export function createChatService({
     try { defaultAppend(opts); } catch {}
   };
   const transport = createTransport({ fetchImpl, dispatcher, keepAlive: !!dispatcher, timeoutMs: connectTimeoutMs, retry: {} });
+  // SDK 通道与 legacy 同享 keep-alive 连接池（dispatcher → fetch 注入）；同时该 fetch 被 attempt 层
+  // 包装用于错误路径捕获请求体（上游 4xx 时打印 tool 序列断裂诊断，见 sdk/attempt.js）。
+  const sdkFetch = dispatcher ? dispatcherFetch(dispatcher) : fetchImpl;
 
   function authForKey(key) {
     const idx = keys.indexOf(key);
@@ -100,17 +104,16 @@ export function createChatService({
   // （局部 MSLXDFF_WORKBUDDY_SDK，未设则继承全局 MSLXDFF_UPSTREAM_ENGINE）回退原生 transport；
   // 不可用（Node16/未安装）自动回退并告警一次。上层轮换/刷新/reshape 全链复用。
   // Note: 为什么默认 SDK、翻译层代价与回退语义 — 见 .agents/notes/implemented/feature/2026-09-12-workbuddy-sdk-channel.md
-  // workbuddy 缺省 native transport（legacy）：上游对 DeepSeek 有非标字段要求
-  // （thinking 注入 / reasoning_content 回填，见 payload.js），AI SDK 序列化层 providerOptions
-  // 白名单无法承载这些字段——v0.1.111~118 的 SDK 缺省即 tool 校验 400 的温床。
-  // 显式 MSLXDFF_WORKBUDDY_SDK=sdk（或全局 MSLXDFF_UPSTREAM_ENGINE=sdk）仍可切回 SDK 通道。
-  const engineMode = resolveEngineMode(process.env, "MSLXDFF_WORKBUDDY_SDK", "legacy");
+  // 上游非标字段（thinking / reasoning_effort / reasoning_content / tool_choice 字符串）不依赖 SDK 白名单：
+  // payload.js 前置语义改写 + AI SDK providerOptions 透传（非白名单 key 原样 spread 进 body，2.0.41 实测）。
+  // 序列化/流式/错误映射仍全部交 AI SDK；原生 transport 仅作 SDK 不可用时的回退。v0.1.120 实测见 .scratch/probe-sdk-body.mjs。
+  const engineMode = resolveEngineMode(process.env, "MSLXDFF_WORKBUDDY_SDK", "sdk");
   let sdkFallbackLogged = false;
   async function fetchOnce(url, body, key, auth) {
     const payload = rewriteWorkbuddyPayload(body);
     if (engineMode === "sdk") {
       try {
-        return await attemptOnceSdk({ url, body: payload, key, auth, buildHeaders: buildAuthHeaders });
+        return await attemptOnceSdk({ url, body: payload, key, auth, buildHeaders: buildAuthHeaders, ...(sdkFetch ? { fetchImpl: sdkFetch } : {}) });
       } catch (e) {
         if (!e || !e._sdkLoadFailed) throw e;
         if (!sdkFallbackLogged) {
@@ -158,8 +161,8 @@ export function createChatService({
     const url = joinUrl(baseUrl, chatPath);
     const t0 = nowMs(clock);
     const clean = sanitizeToolSequence(body?.messages);
-    if (clean.droppedCalls || clean.droppedResults) {
-      try { console.error(`[workbuddy] tool-sequence sanitized: dropped ${clean.droppedCalls} call(s), ${clean.droppedResults} result(s), model=${body?.model || ""}`); } catch {}
+    if (clean.droppedCalls || clean.droppedResults || clean.movedResults || clean.injectedHead) {
+      try { console.error(`[workbuddy] tool-sequence sanitized: dropped ${clean.droppedCalls} call(s), ${clean.droppedResults} result(s), moved ${clean.movedResults} result(s), head+${clean.injectedHead}, model=${body?.model || ""}`); } catch {}
       body = { ...body, messages: clean.messages };
     }
     _t0Val = t0;

package/src/providers/workbuddy/sanitize-tools.js

@@ -1,55 +1,61 @@
-// workbuddy 上游对 tool 序列严格校验（400 code 11148 tool_call_sequence_broken）：
-// assistant.tool_calls 与后续 tool 结果必须按 id 一一配对，否则整单拒绝并提示开新会话。
-// 历史上下文经压缩/编辑/跨模型切换后可能断裂（有调用无结果、结果孤立、id 漂移），
-// AI SDK 转换层对缺失字段用占位（toolName "tool" / toolCallId ""）进一步错配。
-// 这里在 workbuddy 出口做防御性清洗：仅保留能成对出现的调用与结果，避免整单 400。
-// 其他上游（opencode 等）宽容，不受影响——只挂在 workbuddy 链路。
+// workbuddy 上游对 tool 序列严格校验（400 code 11148 tool_call_sequence_broken），实测三条规则：
+// ① assistant.tool_calls 与结果必须按 id 一一配对（孤立调用/结果均拒）；
+// ② 结果必须紧跟对应 assistant（配对不能被 user/assistant 消息打断）；
+// ③ 序列不能以"带 tool_calls 的 assistant"开头（tool call 无前置上下文即拒；compaction 裁剪点
+//    落在工具链中间时最易触发）。
+// 这里在 workbuddy 出口做防御性清洗：结果前移到对应调用之后（组内按 calls 顺序）、剔无法配对的
+// 调用/结果、首条为 assistant/tool 时注入占位 user（"continue"）。其他上游宽容不受影响——只挂 workbuddy。
 export function sanitizeToolSequence(messages) {
   const list = Array.isArray(messages) ? messages : [];
 
-  const callIds = new Set();
-  for (const m of list) {
-    if (m?.role === "assistant" && Array.isArray(m.tool_calls)) {
-      for (const tc of m.tool_calls) {
-        const id = String(tc?.id || "");
-        if (id) callIds.add(id);
-      }
-    }
-  }
-
-  const resultIds = new Set();
-  for (const m of list) {
-    if (m?.role === "tool") {
-      const id = String(m.tool_call_id || "");
-      if (id) resultIds.add(id);
-    }
-  }
-
-  const paired = new Set();
-  for (const id of callIds) if (resultIds.has(id)) paired.add(id);
+  const resultById = new Map();
+  list.forEach((m, idx) => {
+    if (m?.role !== "tool") return;
+    const id = String(m.tool_call_id || "");
+    if (id && !resultById.has(id)) resultById.set(id, { msg: m, idx, used: false });
+  });
 
   let droppedCalls = 0;
   let droppedResults = 0;
+  let movedResults = 0;
   const out = [];
-  for (const m of list) {
+  list.forEach((m, idx) => {
     if (m?.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length) {
-      const kept = m.tool_calls.filter((tc) => paired.has(String(tc?.id || "")));
-      droppedCalls += m.tool_calls.length - kept.length;
+      const kept = [];
+      for (const tc of m.tool_calls) {
+        const r = resultById.get(String(tc?.id || ""));
+        if (r && !r.used) kept.push(tc);
+        else droppedCalls++;
+      }
       if (kept.length) {
         out.push({ ...m, tool_calls: kept });
+        for (const tc of kept) {
+          const r = resultById.get(String(tc.id));
+          r.used = true;
+          if (!(r.idx >= idx + 1 && r.idx <= idx + kept.length)) movedResults++;
+          out.push(r.msg);
+        }
       } else if (typeof m.content === "string" && m.content) {
         const { tool_calls: _dropped, ...rest } = m;
         out.push(rest);
       }
-      continue;
+      return;
     }
     if (m?.role === "tool") {
-      if (paired.has(String(m.tool_call_id || ""))) out.push(m);
-      else droppedResults++;
-      continue;
+      const id = String(m.tool_call_id || "");
+      const r = resultById.get(id);
+      if (r && r.idx === idx && r.used) return; // 已前移消费，跳过原位置
+      droppedResults++; // 孤儿或重复
+      return;
     }
     out.push(m);
+  });
+
+  let injectedHead = 0;
+  if (out.length && out[0]?.role !== "user" && out[0]?.role !== "system" && out[0]?.role !== "developer") {
+    out.unshift({ role: "user", content: "continue" });
+    injectedHead = 1;
   }
 
-  return { messages: out, droppedCalls, droppedResults };
+  return { messages: out, droppedCalls, droppedResults, movedResults, injectedHead };
 }

package/src/providers/workbuddy/sdk-chat.js

@@ -8,7 +8,7 @@ export { sdkBaseFromUrl };
 
 let channelLogged = false;
 
-export async function attemptOnceSdk({ url, body, key, auth, buildHeaders, clock = Date.now } = {}) {
+export async function attemptOnceSdk({ url, body, key, auth, buildHeaders, clock = Date.now, fetchImpl } = {}) {
   const out = await attemptGeneric({
     url,
     body,
@@ -16,6 +16,7 @@ export async function attemptOnceSdk({ url, body, key, auth, buildHeaders, clock
     providerName: "workbuddy",
     marker: { name: "x-mslxdff-workbuddy-channel", value: "sdk" },
     clock,
+    ...(fetchImpl ? { fetchImpl } : {}),
   });
   if (!channelLogged) {
     channelLogged = true;

package/src/upstream-engine/mode.js

@@ -1,7 +1,6 @@
 // 引擎模式解析（纯函数，零依赖）：缺省 sdk，legacy/关闭词回退原实现。
 // 供应商级开关未设置时继承全局总闸，使 MSLXDFF_UPSTREAM_ENGINE=legacy 成为一键熔断。
-// defaultMode：调用方可自定缺省（workbuddy 因上游非标字段 thinking/reasoning_content
-// 无法经 AI SDK 序列化层注入，缺省 legacy）；显式 env（供应商级或全局）始终优先。
+// defaultMode：调用方可自定缺省（一般无需传，保持 sdk）；显式 env（供应商级或全局）始终优先。
 // 供 upstream-engine/index.js（opencode 上游）与 providers/workbuddy/chat.js 共用。
 // 见 docs/adr/0017。
 const ENGINE_OFF_WORDS = new Set(["0", "off", "false", "no", "disable", "disabled"]);

package/src/upstream-engine/sdk/attempt.js

@@ -6,6 +6,7 @@
 // 见 .scratch/ai-sdk-upstream/{SPEC.md,SPEC-p3-responses.md} 与 docs/adr/0017。
 import { toModelPrompt, toModelTools, toModelToolChoice, toModelParams } from "./convert.js";
 import { createSseSerializer } from "./sse.js";
+import { diagnoseToolSequence, compactSequence } from "./diagnose.js";
 import { getUndici } from "../../compat.js";
 
 let sdkPromise = null;
@@ -44,6 +45,20 @@ export function markerHeaders(marker) {
   return marker && marker.name ? { [marker.name]: marker.value } : {};
 }
 
+// 错误路径诊断：AI SDK 的 APICallError 对 HTTP 4xx 的 requestBodyValues 是空对象（provider-utils 实测），
+// 故用包装 fetch 捕获真实发出的 body，在上游非 2xx 时打印 tool 序列断裂点与尾部序列。
+function logRequestDiagnosis(bodyText, status) {
+  if (!bodyText || typeof bodyText !== "string") return;
+  let parsed = null;
+  try { parsed = JSON.parse(bodyText); } catch { return; }
+  const msgs = parsed?.messages;
+  if (!Array.isArray(msgs)) return;
+  const { issues, summary } = diagnoseToolSequence(msgs);
+  console.error(`[sdk-upstream] ${status} ${summary} issues=${issues.length ? issues.join(" | ") : "none"}`);
+  console.error(`[sdk-upstream] head: ${compactSequence(msgs, 0, 6)}`);
+  console.error(`[sdk-upstream] tail: ${compactSequence(msgs, Math.max(0, msgs.length - 40))}`);
+}
+
 // SDK 抛出的 APICallError → 带状态码的 Response；非 HTTP 错误返回 null 由调用方 rethrow。
 export function errorResponseFromSdkError(e, { marker = null } = {}) {
   const status = Number(e?.statusCode ?? e?.status);
@@ -125,11 +140,19 @@ export async function attemptOnceSdk({
     err._sdkLoadFailed = true;
     throw err;
   }
+  // 包装注入的 fetch 以捕获真实请求体（诊断用）：不改变调用语义，仅在非 2xx 时被读取。
+  let lastBodyText = null;
+  const capturedFetch = fetchImpl
+    ? async (u, init) => {
+        try { if (init && typeof init.body === "string") lastBodyText = init.body; } catch {}
+        return fetchImpl(u, init);
+      }
+    : undefined;
   const provider = createOpenAICompatible({
     name: providerName,
     baseURL,
     headers: sanitizeHeaders(headers),
-    ...(fetchImpl ? { fetch: fetchImpl } : {}),
+    ...(capturedFetch ? { fetch: capturedFetch } : {}),
   });
   const model = provider.chatModel(String(body?.model || ""));
   let res;
@@ -142,7 +165,10 @@ export async function attemptOnceSdk({
     });
   } catch (e) {
     const mapped = errorResponseFromSdkError(e, { marker });
-    if (mapped) return mapped;
+    if (mapped) {
+      try { logRequestDiagnosis(lastBodyText, mapped.status); } catch {}
+      return mapped;
+    }
     throw e;
   }
   return streamResponseFromParts(res.stream, { marker, clock, t0 });

package/src/upstream-engine/sdk/convert.js

@@ -52,8 +52,9 @@ export function toModelPrompt(messages) {
       const parts = [];
       const text = textOf(m.content);
       if (text) parts.push({ type: "text", text });
-      // 带加密态的 reasoning items（responses 通道思考跨轮）：AI SDK 会转成上游要的 encrypted reasoning item。
       // 无加密态时才退回纯文本 reasoning（chat 通道的 reasoning_content）。
+      // 空串是 payload 回填的有意标记（requiresReasoningContentOnAssistantMessages）：所有 assistant
+      // 必须带该字段——AI SDK 以 length>0 判定是否输出，故用 " " 占位而非 ""。
       const items = Array.isArray(m.reasoning_items) ? m.reasoning_items : [];
       let pushedEncrypted = false;
       for (const r of items) {
@@ -66,7 +67,9 @@ export function toModelPrompt(messages) {
         });
         pushedEncrypted = true;
       }
-      if (!pushedEncrypted && m.reasoning_content) parts.push({ type: "reasoning", text: String(m.reasoning_content) });
+      const rc = typeof m.reasoning_content === "string" ? m.reasoning_content
+        : (typeof m.reasoning === "string" ? m.reasoning : null);
+      if (!pushedEncrypted && rc !== null) parts.push({ type: "reasoning", text: rc || " " });
       for (const tc of Array.isArray(m.tool_calls) ? m.tool_calls : []) {
         if (!tc || typeof tc !== "object") continue;
         parts.push({

package/src/upstream-engine/sdk/diagnose.js

@@ -0,0 +1,61 @@
+// 请求消息序列诊断（纯函数）：上游 11148 tool_call_sequence_broken 时定位断裂点。
+// 上游校验规则：assistant.tool_calls 必须与紧随其后的 tool 结果按 id 严格配对，
+// 且配对过程不能被其他消息（user/assistant/system）打断——仅集合级 id 配对（sanitize-tools）不够。
+// 在 SDK 错误路径对 AI SDK 实际发出的请求体做本诊断，异常位置用消息下标指认。
+export function compactSequence(messages, from = 0, limit = Infinity) {
+  const list = Array.isArray(messages) ? messages : [];
+  const end = Number.isFinite(limit) ? Math.min(list.length, from + limit) : list.length;
+  const out = [];
+  for (let i = Math.max(0, from); i < end; i++) {
+    const m = list[i] || {};
+    const role = String(m.role || "?");
+    if (role === "assistant") {
+      const calls = Array.isArray(m.tool_calls) ? m.tool_calls : [];
+      out.push(calls.length ? `A{${calls.map((t) => String(t?.id || "empty")).join(",")}}` : "A");
+    } else if (role === "tool") out.push(`T{${String(m.tool_call_id || "empty")}}`);
+    else if (role === "user") out.push("U");
+    else if (role === "system" || role === "developer") out.push("S");
+    else out.push(String(role)[0] || "?");
+  }
+  return out.join(" ");
+}
+
+export function diagnoseToolSequence(messages) {
+  const list = Array.isArray(messages) ? messages : [];
+  const issues = [];
+  const open = new Map();
+  let calls = 0;
+  let results = 0;
+  const first = list[0];
+  if (first && first.role !== "user" && first.role !== "system" && first.role !== "developer") {
+    issues.push(`#0 首条为 ${String(first.role || "?")}（上游拒带工具链的 assistant/tool 开头）`);
+  }
+  list.forEach((m, i) => {
+    const role = m?.role;
+    if (role === "assistant") {
+      const tcs = Array.isArray(m.tool_calls) ? m.tool_calls : [];
+      if (tcs.length) {
+        if (open.size) issues.push(`#${i} assistant 打断未闭合{${[...open.keys()].join(",")}}`);
+        for (const tc of tcs) {
+          const id = String(tc?.id || "");
+          calls++;
+          if (!id) issues.push(`#${i} tool_call 空 id`);
+          else if (open.has(id)) issues.push(`#${i} call id 重复:${id}`);
+          else open.set(id, i);
+        }
+      } else if (open.size) {
+        issues.push(`#${i} assistant(无调用) 打断{${[...open.keys()].join(",")}}`);
+      }
+    } else if (role === "tool") {
+      results++;
+      const id = String(m.tool_call_id || "");
+      if (!id) issues.push(`#${i} tool 结果空 id`);
+      else if (!open.has(id)) issues.push(`#${i} 孤立结果:${id}`);
+      else open.delete(id);
+    } else if (open.size) {
+      issues.push(`#${i} ${role} 打断{${[...open.keys()].join(",")}}`);
+    }
+  });
+  for (const [id, at] of open) issues.push(`#${at} 悬空调用:${id}`);
+  return { issues, summary: `msgs=${list.length} calls=${calls} results=${results}` };
+}