mslxdff 0.1.103 → 0.1.105

package/package.json

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

package/src/chat-pipeline/serial-trial.js

@@ -9,6 +9,7 @@ import { handlePeerRelay } from "../routes/chat/peer-handler.js";
 import { handleBroadbandRelay } from "../routes/chat/broadband-handler.js";
 import { handleViaRoute } from "../routes/chat/via-route-handler.js";
 import { handleExhaustedLocal, handleExhaustedAll } from "../routes/chat/exhausted-handler.js";
+import { shouldUseGroupForModel } from "../state/schemas/use-group.js";
 
 /**
  * 串行 trial — 从 engine.js 抽出的第二段：via-route 单路径 → 串行 trial →
@@ -112,7 +113,8 @@ export async function runSerialTrial(ctx, deps = {}) {
       const isStream = Boolean(body.stream);
       const d = hedgeDelayMs();
       const hasPeers = Boolean(peers) && peers.ordered().length > 0;
-      const doHedge = shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) && upRes.status === 200 && upRes.body;
+      const canUseGroup = shouldUseGroupForModel(model);
+      const doHedge = canUseGroup && shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) && upRes.status === 200 && upRes.body;
       if (doHedge) {
         const hr = await hedge({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res, hedgeDelayMs: d });
         if (hr.handled) return { done: true };
@@ -128,12 +130,20 @@ export async function runSerialTrial(ctx, deps = {}) {
       }
     }
     if (canForwardPeers) {
-      const pr = await peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, stages, startedAt, plugins, res });
-      if (pr.handled) return { done: true };
+      if (!shouldUseGroupForModel(model)) {
+        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (peer)" });
+      } else {
+        const pr = await peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, stages, startedAt, plugins, res });
+        if (pr.handled) return { done: true };
+      }
     }
     if (groups) {
-      const br = await broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, stages, res, startedAt, plugins });
-      if (br.handled) return { done: true };
+      if (!shouldUseGroupForModel(model)) {
+        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (broadband)" });
+      } else {
+        const br = await broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, stages, res, startedAt, plugins });
+        if (br.handled) return { done: true };
+      }
     }
     if (canFallback) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: lastErr?.message || `upstream ${lastErr?.status ?? 502}` }); continue; }
     await exhaustedLocal({ res, body, lastErr, order, handlerCtx: { ...handlerCtx, model, reqId }, evt, logCall, mark, perf0, stages, done, requested, useAuto });

package/src/cli/commands/use-group.js

@@ -0,0 +1,56 @@
+import { loadUseGroup, saveUseGroup, getEffectiveUseGroup, getUseGroupEnv } from "../../state/schemas/use-group.js";
+import { argValue } from "../policy.js";
+
+function parseInput(v) {
+  if (v === undefined || v === null || v === "") return null;
+  const s = String(v).trim().toLowerCase();
+  if (["1", "true", "on", "yes", "enable", "enabled", "open"].includes(s)) return true;
+  if (["0", "false", "off", "no", "disable", "disabled", "close", "closed"].includes(s)) return false;
+  return null;
+}
+
+export async function handleUseGroup(args) {
+  const hasFlag = args.some((a) => ["-use-group", "--use-group", "-use_group", "--use_group", "-usegroup", "--usegroup"].includes(a));
+  if (!hasFlag) return false;
+
+  // 取值：支持 -use-group true / -use-group=true / --use-group=off
+  let raw = argValue(args, "-use-group", "--use-group", "-use_group", "--use_group", "-usegroup", "--usegroup");
+  // 兼容 -use-group=true 这种等号形态
+  if (raw === null || raw === undefined) {
+    const eq = args.find((a) => a.startsWith("-use-group=") || a.startsWith("--use-group=") || a.startsWith("-use_group=") || a.startsWith("--use_group="));
+    if (eq) raw = eq.split("=")[1];
+  }
+  // 如果 flag 后面紧跟的不是另一个 flag，则视为值；否则视为查询
+  if (raw !== null && raw !== undefined && String(raw).startsWith("-")) raw = null;
+
+  const envVal = getUseGroupEnv();
+  const effective = getEffectiveUseGroup();
+  const stored = loadUseGroup();
+
+  if (raw === null || raw === undefined || raw === "") {
+    // 查询模式
+    console.log(`use-group: ${effective ? "on" : "off"} (effective)`);
+    console.log(`  stored: ${stored ? "on" : "off"} (state.json useGroup)`);
+    if (envVal !== null) console.log(`  env MSLXDFF_USE_GROUP=${envVal ? "on" : "off"} (overrides stored)`);
+    console.log(`  default: on`);
+    console.log(`  usage: mslxdff -use-group on|off  (opencode 供应商本机失败时是否走组员网络，默认 on)`);
+    console.log(`  env:   MSLXDFF_USE_GROUP=0|1  (优先级高于 state)`);
+    process.exit(0);
+  }
+
+  const parsed = parseInput(raw);
+  if (parsed === null) {
+    console.error(`invalid value for -use-group: ${raw} (expected on/off/true/false/1/0)`);
+    process.exit(1);
+  }
+
+  if (envVal !== null) {
+    console.log(`note: env MSLXDFF_USE_GROUP=${envVal ? "on" : "off"} is set and overrides stored value; unset env to use stored value`);
+  }
+
+  saveUseGroup(parsed);
+  console.log(`use-group set to ${parsed ? "on" : "off"} (stored in state.json)`);
+  console.log(`  opencode 供应商：本机失败时 ${parsed ? "允许" : "不再"} 通过组员网络请求上游`);
+  if (!parsed) console.log(`  提示：opencode 请求将仅在本机重试，不再走 peer/broadband 组员中继`);
+  process.exit(0);
+}

package/src/cli/help.js

@@ -43,6 +43,7 @@ Usage:
   mslxdff -autostart status        查看自启状态
   mslxdff -chat ["prompt"]       chat REPL（mimo-v2.5-free 优先/big-pickle 兜底，自然语言转命令，模糊匹配由模型完成，历史持久化，超长自动压缩，仅拦 -uninstall，daemon 重启不影响）
   mslxdff -resetban [ip]           clear join-failure bans (all, or one ip)
+  mslxdff -use-group [on|off]     opencode 供应商本机失败时是否走组员网络（默认 on；off 则仅本机，MSLXDFF_USE_GROUP 环境变量可覆盖）
   mslxdff -help                    show this help
 
 Environment:
@@ -62,6 +63,7 @@ Environment:
   MSLXDFF_BAN_THRESHOLD   failed joins before an ip is banned (default 5)
   MSLXDFF_BAN_WINDOW_MS   ban duration after too many failures (default 48h)
   MSLXDFF_HEDGE_DELAY_MS  hedge peer race when local stream first chunk slow (default 1000, 0/off to disable)
+  MSLXDFF_USE_GROUP       opencode 组员中继开关（默认 on；0/off/false 关闭后 opencode 仅本机，不走 peer/broadband）
   MSLXDFF_AUTO_UPDATE   auto-update: hourly by default, 0/off/false to disable, 1/true or ms
   MSLXDFF_AUTO_UPDATE_MS  same as above, explicit ms (overrides AUTO_UPDATE)
 `);

package/src/cli/index.js

@@ -49,6 +49,8 @@ export async function run(args = process.argv.slice(2)) {
   if (await handleLeaveGroup(args)) return;
   if (await handleDelGroup(args)) return;
 
+  const { handleUseGroup } = await import("./commands/use-group.js");
+  if (await handleUseGroup(args)) return;
   const { handlePort, handleDaemonFlag, handleBareRun } = await import("./commands/daemon.js");
   if (await handlePort(args)) return;
   if (await handleDaemonFlag(args, VERSION)) return;

package/src/state/facade.js

@@ -57,3 +57,4 @@ export {
 export { loadPeers, savePeers, loadPeerErrors, savePeerErrors, loadPeerStats, savePeerStats } from "./schemas/peer.js";
 export { loadGroups, loadGroupsJoined, saveGroupsJoined, loadBans, saveBans, saveGroups } from "./schemas/group.js";
 export { loadTimezone, loadTimezoneState, saveTimezone, clearTimezone, getTimezoneEnv, DEFAULT_TZ, isValidTimezone } from "./schemas/timezone.js";
+export { loadUseGroup, saveUseGroup, getEffectiveUseGroup, shouldUseGroupForModel, isUseGroupEnabled, getUseGroupEnv } from "./schemas/use-group.js";

package/src/state/schemas/use-group.js

@@ -0,0 +1,56 @@
+import { defaultStateFile, readState, writeStateImmediate } from "../store.js";
+
+function parseBool(v) {
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") {
+    const s = v.trim().toLowerCase();
+    if (["0", "false", "off", "no", "disable", "disabled", "close", "closed"].includes(s)) return false;
+    if (["1", "true", "on", "yes", "enable", "enabled", "open"].includes(s)) return true;
+  }
+  return null;
+}
+
+export function loadUseGroup({ file = defaultStateFile() } = {}) {
+  const raw = readState(file).useGroup;
+  const parsed = parseBool(raw);
+  return parsed === null ? true : parsed; // 默认开
+}
+
+export function saveUseGroup(value, { file = defaultStateFile() } = {}) {
+  const b = Boolean(value);
+  writeStateImmediate(file, { useGroup: b });
+  return b;
+}
+
+export function getUseGroupEnv() {
+  const raw = process.env.MSLXDFF_USE_GROUP;
+  if (raw === undefined || raw === null || raw === "") return null;
+  return parseBool(raw);
+}
+
+export function getEffectiveUseGroup({ file = defaultStateFile() } = {}) {
+  const env = getUseGroupEnv();
+  if (env !== null) return env;
+  return loadUseGroup({ file });
+}
+
+// 仅对 opencode 供应商生效：opencode 的模型为裸 id 或 opencode/ 前缀
+export function shouldUseGroupForModel(model, { file = defaultStateFile() } = {}) {
+  const m = String(model || "").trim();
+  if (!m) return getEffectiveUseGroup({ file });
+  // 带前缀：判断是否为 opencode
+  if (m.includes("/")) {
+    const head = m.split("/")[0].trim().toLowerCase();
+    if (head === "opencode" || head === "oc") {
+      return getEffectiveUseGroup({ file });
+    }
+    return true; // 其他供应商不受此开关限制
+  }
+  // 裸 id 视为 opencode
+  return getEffectiveUseGroup({ file });
+}
+
+export function isUseGroupEnabled({ file } = {}) {
+  return getEffectiveUseGroup({ file });
+}

package/src/upstream-responses.js

@@ -12,9 +12,17 @@ export function chatToResponsesBody(chatBody) {
   const nonSystem = msgs.filter((m) => m.role !== "system");
   const inputParts = nonSystem.map((m) => {
     const c = m.content;
-    if (typeof c === "string") return `${m.role}: ${c}`;
-    if (Array.isArray(c)) return `${m.role}: ${c.map((x) => x.text || "").join("")}`;
-    return `${m.role}: ${String(c || "")}`;
+    let base;
+    if (typeof c === "string") base = `${m.role}: ${c}`;
+    else if (Array.isArray(c)) base = `${m.role}: ${c.map((x) => x.text || x.content || "").join("")}`;
+    else base = `${m.role}: ${String(c || "")}`;
+    // 保留 tool_calls / tool 结果，避免多轮丢失
+    if (Array.isArray(m.tool_calls) && m.tool_calls.length) {
+      const tcStr = m.tool_calls.map((tc) => `${tc.function?.name || "tool"}(${tc.function?.arguments || ""})`).join("; ");
+      base += ` [tool_calls: ${tcStr}]`;
+    }
+    if (m.role === "tool" && m.tool_call_id) base += ` (call_id=${m.tool_call_id})`;
+    return base;
   });
   const input = inputParts.join("\n\n") || "hi";
   const out = { model: chatBody.model, input, stream: false };
@@ -25,25 +33,31 @@ export function chatToResponsesBody(chatBody) {
       if (!t || typeof t !== "object") return null;
       if (t.type === "function" && t.function && typeof t.function === "object") {
         const fn = t.function;
+        // 去掉 responses 不支持的 strict 等字段，parameters 原样透传
         const nt = { type: "function", name: fn.name, description: fn.description || undefined, parameters: fn.parameters || undefined };
         // 清理 undefined
         Object.keys(nt).forEach((k) => nt[k] === undefined && delete nt[k]);
         return nt.name ? nt : null;
       }
-      // 已是平铺形态或未知形态，透传但确保 name 存在
-      if (t.name) return t;
+      // 已是平铺形态或未知形态，透传但确保 name 存在，清理 strict
+      if (t.name) {
+        const { strict, ...rest } = t;
+        return rest;
+      }
       return null;
     }).filter(Boolean);
     if (mapped.length) out.tools = mapped;
   }
   if (chatBody.tool_choice) {
     const tc = chatBody.tool_choice;
-    // chat: "auto" | {type:"auto"} | {type:"function", function:{name}} -> responses: "auto" | {type:"function", name}
-    if (typeof tc === "string") out.tool_choice = tc;
-    else if (tc && typeof tc === "object") {
-      if (tc.type === "function" && tc.function?.name) out.tool_choice = { type: "function", name: tc.function.name };
-      else if (tc.type) out.tool_choice = tc;
-      else out.tool_choice = tc;
+    // responses 仅支持 "auto"（实测 required/named 均 400），一律归一为 auto
+    if (typeof tc === "string") {
+      out.tool_choice = tc === "auto" ? "auto" : "auto";
+    } else if (tc && typeof tc === "object") {
+      if (tc.type === "auto" || tc.type === "required") out.tool_choice = "auto";
+      else if (tc.type === "function") out.tool_choice = "auto";
+      else if (tc.type) out.tool_choice = "auto";
+      else out.tool_choice = "auto";
     }
   }
   if (chatBody.temperature != null) out.temperature = chatBody.temperature;
@@ -53,15 +67,22 @@ export function chatToResponsesBody(chatBody) {
 
 export function responsesToChatJson(respJson) {
   let text = "";
+  const toolCalls = [];
   for (const item of respJson.output || []) {
     if (item.type === "message" && item.role === "assistant") {
       for (const c of item.content || []) {
         if (c.type === "output_text") text += c.text || "";
         else if (c.type === "text") text += c.text || "";
       }
+    } else if (item.type === "function_call") {
+      toolCalls.push({
+        id: item.call_id || item.id || `call_${toolCalls.length}`,
+        type: "function",
+        function: { name: item.name || "", arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments || "") },
+      });
     }
   }
-  if (!text) {
+  if (!text && toolCalls.length === 0) {
     for (const item of respJson.output || []) {
       if (item.type === "message") {
         const t = item.content?.[0]?.text;
@@ -69,12 +90,18 @@ export function responsesToChatJson(respJson) {
       }
     }
   }
+  const message = { role: "assistant", content: text };
+  if (toolCalls.length) {
+    message.tool_calls = toolCalls;
+    // 有 tool_calls 时 content 可为 ""，finish_reason 应为 tool_calls
+  }
+  const finish = toolCalls.length ? "tool_calls" : (respJson.status === "completed" ? "stop" : "length");
   const chatJson = {
     id: respJson.id || `resp_${Date.now()}`,
     object: "chat.completion",
     created: Math.floor((respJson.created_at || Date.now() / 1000)),
     model: respJson.model,
-    choices: [{ index: 0, finish_reason: respJson.status === "completed" ? "stop" : "length", message: { role: "assistant", content: text } }],
+    choices: [{ index: 0, finish_reason: finish, message }],
     usage: respJson.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
   };
   return chatJson;
@@ -102,6 +129,7 @@ export function reshapeResponsesSse(res, fallbackModel) {
   let respModel = fallbackModel || "";
   let created = Math.floor(Date.now() / 1000);
   let hasSentRole = false;
+  const toolMap = new Map(); // output_index -> {idx, id, name}
 
   function chatChunk(delta, finish) {
     const id = respId || `resp_${Date.now()}`;
@@ -155,37 +183,75 @@ export function reshapeResponsesSse(res, fallbackModel) {
           if (data.response?.created_at) created = Math.floor(data.response.created_at);
           if (data.response?.id && !respId) respId = data.response.id;
           // 关注 output_text.delta
-          if (curEvent === "response.output_text.delta" || data.type === "response.output_text.delta") {
-            const deltaText = data.delta || "";
-            if (deltaText) {
-              if (!hasSentRole) {
-                hasSentRole = true;
-                out += chatChunk({ role: "assistant" }, null);
-              }
-              out += chatChunk({ content: deltaText }, null);
-            }
-          } else if (curEvent === "response.completed" || data.type === "response.completed") {
-            const usage = data.response?.usage || null;
-            const finish = data.response?.status === "completed" ? "stop" : null;
-            // 末帧带 usage
-            const id = respId || `resp_${Date.now()}`;
-            const payload = {
-              id,
-              object: "chat.completion.chunk",
-              created,
-              model: respModel,
-              choices: [{ index: 0, delta: {}, finish_reason: finish }],
-              usage: usage || undefined,
-            };
-            out += `data: ${JSON.stringify(payload)}\n\n`;
-          } else if (data.type === "response.output_item.added" && data.item?.type === "message") {
-            // message 开始，可发送 role
-            if (!hasSentRole) {
-              hasSentRole = true;
-              out += chatChunk({ role: "assistant" }, null);
-            }
-          }
-          // reasoning 加密块忽略
+           if (curEvent === "response.output_text.delta" || data.type === "response.output_text.delta") {
+             const deltaText = data.delta || "";
+             if (deltaText) {
+               if (!hasSentRole) {
+                 hasSentRole = true;
+                 out += chatChunk({ role: "assistant" }, null);
+               }
+               out += chatChunk({ content: deltaText }, null);
+             }
+           } else if (curEvent === "response.completed" || data.type === "response.completed") {
+             const usage = data.response?.usage || null;
+             // 若有 tool_calls，finish 应为 tool_calls
+             const hasTools = toolMap.size > 0;
+             const finish = hasTools ? "tool_calls" : (data.response?.status === "completed" ? "stop" : null);
+             // 末帧带 usage
+             const id = respId || `resp_${Date.now()}`;
+             const payload = {
+               id,
+               object: "chat.completion.chunk",
+               created,
+               model: respModel,
+               choices: [{ index: 0, delta: {}, finish_reason: finish }],
+               usage: usage || undefined,
+             };
+             out += `data: ${JSON.stringify(payload)}\n\n`;
+           } else if (data.type === "response.output_item.added" && data.item?.type === "message") {
+             // message 开始，可发送 role
+             if (!hasSentRole) {
+               hasSentRole = true;
+               out += chatChunk({ role: "assistant" }, null);
+             }
+           } else if (data.type === "response.output_item.added" && data.item?.type === "function_call") {
+             const outIdx = Number(data.output_index ?? 1);
+             const toolIdx = Math.max(0, outIdx - 1);
+             const callId = data.item?.call_id || data.item?.id || "";
+             const name = data.item?.name || "";
+             toolMap.set(outIdx, { idx: toolIdx, id: callId, name });
+             if (!hasSentRole) {
+               hasSentRole = true;
+               out += chatChunk({ role: "assistant" }, null);
+             }
+             const tc = { index: toolIdx, id: callId, type: "function", function: { name, arguments: "" } };
+             // 清理空字符串，避免 undefined
+             if (!callId) delete tc.id;
+             if (!name) delete tc.function.name;
+             out += chatChunk({ tool_calls: [tc] }, null);
+           } else if (data.type === "response.function_call_arguments.delta") {
+             const outIdx = Number(data.output_index ?? 1);
+             const entry = toolMap.get(outIdx) || { idx: Math.max(0, outIdx - 1) };
+             const deltaArgs = data.delta || "";
+             if (deltaArgs) {
+               if (!hasSentRole) {
+                 hasSentRole = true;
+                 out += chatChunk({ role: "assistant" }, null);
+               }
+               out += chatChunk({ tool_calls: [{ index: entry.idx, function: { arguments: deltaArgs } }] }, null);
+             }
+           } else if (data.type === "response.function_call_arguments.done") {
+             const outIdx = Number(data.output_index ?? 1);
+             const entry = toolMap.get(outIdx) || { idx: Math.max(0, outIdx - 1) };
+             const args = data.arguments || "";
+             if (args && !toolMap.get(outIdx)?._done) {
+               // done 可能带全量，若未通过 delta 发送过，补发
+               // 已通过 delta 流式发送则忽略，避免重复
+             }
+           } else if (data.type === "response.output_item.done" && data.item?.type === "function_call") {
+             // 可忽略，已通过 added+delta 完整
+           }
+           // reasoning 加密块忽略
         }
         if (out) controller.enqueue(encoder.encode(out));
       } catch {