mslxdff 0.1.159 → 0.1.160

package/src/providers/workbuddy/reshape.js

@@ -1,152 +1,152 @@
-// workbuddy 流式 reasoning_content 整形：上游思考模型（如 glm-5.3-flash）把思考过程一词一 chunk
-// 地放进 delta.reasoning_content，客户端会把每个增量渲染成独立 "- Thought" 条目。
-// 旧版：连续 reasoning 增量缓冲到首个 content/finish 才一次性 flush → 思考期 10~30s 界面完全无变化（用户看到 workbuddy 后台流量走但 opencode 界面卡住）
-// 新版：增量聚合 + 阈值分片：缓冲 reasoning，达到 REASONING_CHUNK_SIZE（默认 100 字符）即分片 flush，
-// 期间仅首个 role 帧透传保持 TTFB，其余纯 reasoning 空帧吞掉（之前会透传 800+ 空 role 帧）；
-// 尾段不足阈值的在 content/finish/流结束时兜底 flush。恒空 reasoning（deepseek-v4-flash）零改写。
-// 仅包 workbuddy 出口的 SSE 响应，不影响其他供应商与全局聚合器。
-
-const REASONING_CHUNK_SIZE = 150;
-
-export function reshapeWorkbuddySse(res) {
-  try {
-    const ct = res.headers?.get?.("content-type") || "";
-    if (res.status !== 200 || !ct.includes("text/event-stream") || !res.body) return res;
-  } catch { return res; }
-
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let buf = "";
-  let reasoningBuf = "";
-  let lastMeta = null;
-  let closed = false;
-  let hasSentRole = false;
-  let lastFlushAt = Date.now();
-
-  function flushReasoningInto(out) {
-    if (!reasoningBuf) return;
-    const meta = lastMeta || {};
-    out.push(`data: ${JSON.stringify({
-      id: meta.id || "chatcmpl-workbuddy-reshape",
-      object: meta.object || "chat.completion.chunk",
-      created: meta.created || Math.floor(Date.now() / 1000),
-      model: meta.model || "",
-      choices: [{ index: 0, delta: { reasoning_content: reasoningBuf }, finish_reason: null }],
-    })}\n\n`);
-    reasoningBuf = "";
-    lastFlushAt = Date.now();
-  }
-
-  let blankStreak = false;
-  // 处理一段完整行文本（以 \n 结尾），产出的行/帧推进 out（连续空行合并为单个事件分隔）
-  function processInto(text, out) {
-    for (const line of text.split("\n")) {
-      if (!line) { if (!blankStreak) out.push("\n"); blankStreak = true; continue; }
-      blankStreak = false;
-      if (!line.startsWith("data:")) { out.push(line + "\n"); continue; }
-      const payload = line.slice(5).trim();
-      if (!payload || payload === "[DONE]") { out.push(line + "\n"); continue; }
-      let obj;
-      try { obj = JSON.parse(payload); } catch { out.push(line + "\n"); continue; }
-      const ch = obj.choices?.[0];
-      if (ch && typeof ch === "object") {
-        if (obj.id) lastMeta = { id: obj.id, model: obj.model, object: obj.object, created: obj.created };
-        const d = ch.delta && typeof ch.delta === "object" ? ch.delta : null;
-        const rc = d ? d.reasoning_content : undefined;
-        if (typeof rc === "string" && rc) {
-          reasoningBuf += rc;
-          d.reasoning_content = "";
-          const isBoundary = (typeof d.content === "string" && d.content) || !!ch.finish_reason;
-          // 首个 reasoning 帧的 role 透传一次，保 TTFB；后续纯 reasoning 的 role 重复帧直接吞掉
-          if (!hasSentRole && d.role !== undefined) {
-            hasSentRole = true;
-            const rm = lastMeta || obj;
-            out.push(`data: ${JSON.stringify({
-              id: rm.id || obj.id || "chatcmpl-workbuddy-reshape",
-              object: rm.object || obj.object || "chat.completion.chunk",
-              created: rm.created || obj.created || Math.floor(Date.now() / 1000),
-              model: rm.model || obj.model || "",
-              choices: [{ index: 0, delta: { role: d.role }, finish_reason: null }],
-            })}\n\n`);
-          } else if (d.role !== undefined) {
-            // 后续重复 role 帧不再透传，避免 800+ 空帧洪泛
-            // 标记已发送过，避免后续非 reasoning 帧再误判为首次
-            hasSentRole = true;
-          }
-          // 阈值分片：攒够 100 字符即向前吐一块，期间界面可见增量而非全程静默
-          // 时间阈值：若距上次 flush 已超 700ms 且已攒 20+ 字符，也吐一块（避免小尾巴长时间不更新）
-          const now = Date.now();
-          const shouldChunk = reasoningBuf.length >= REASONING_CHUNK_SIZE
-            || (reasoningBuf.length >= 50 && now - lastFlushAt > 1500);
-          if (shouldChunk) flushReasoningInto(out);
-          if (isBoundary) {
-            // 兜底：content/finish 前把剩余思考一次性吐出，再透传本帧
-            flushReasoningInto(out);
-            const hasPassthrough = isBoundary || (Array.isArray(d.tool_calls) && d.tool_calls.length);
-            if (hasPassthrough) out.push(`data: ${JSON.stringify(obj)}\n\n`);
-            continue;
-          }
-          // 纯 reasoning 碎片帧已缓冲/或已分片吐出，原空帧吞掉
-          continue;
-        }
-        // 非 reasoning 帧：若有 content/finish 先兜底 flush
-        if ((typeof d?.content === "string" && d.content) || ch.finish_reason) flushReasoningInto(out);
-        if (!hasSentRole && d?.role !== undefined) {
-          hasSentRole = true;
-        } else if (hasSentRole && d?.role !== undefined) {
-          // 去重：首个 role 后续重复 role 去掉，避免下游每帧都带 role
-          try { const clone = JSON.parse(payload); delete clone.choices[0].delta.role; out.push(`data: ${JSON.stringify(clone)}\n\n`); continue; } catch { /* fallback透传 */ }
-        }
-      }
-      out.push(line + "\n");
-    }
-  }
-
-  const body = new ReadableStream({
-    async pull(controller) {
-      if (closed) { try { controller.close(); } catch {} return; }
-      try {
-        // 循环读源，直到"有输出 / 流结束 / 出错"才返回。
-        // WHATWG 流规范：pull 的 promise 解析后若未 enqueue，规范不会再自动调度 pull
-        // （仅当解析期间有新读请求触发 pullAgain 才重调）——消费者只挂一个待处理 read 时，
-        // 任何一次"只吞帧不出数据"的拉取都会让整流永久停摆。workbuddy 思考流按帧到达
-        // （role 帧后每个 reasoning 碎片都不足 150 字符阈值）时必现，即"首帧后卡死"根因。
-        for (;;) {
-          const { done, value } = await reader.read();
-          if (done) {
-            closed = true;
-            const out = [];
-            if (buf) { processInto(buf + "\n", out); buf = ""; }
-            flushReasoningInto(out);
-            if (out.length) controller.enqueue(encoder.encode(out.join("")));
-            controller.close();
-            return;
-          }
-          buf += decoder.decode(value, { stream: true });
-          const idx = buf.lastIndexOf("\n");
-          if (idx < 0) continue;
-          const complete = buf.slice(0, idx + 1);
-          buf = buf.slice(idx + 1);
-          const out = [];
-          processInto(complete, out);
-          if (out.length) { controller.enqueue(encoder.encode(out.join(""))); return; }
-        }
-      } catch {
-        closed = true;
-        try { controller.close(); } catch {}
-      }
-    },
-    cancel() {
-      closed = true;
-      try {
-        const p = reader.cancel();
-        if (p && typeof p.catch === "function") p.catch(() => {});
-      } catch {}
-    },
-  });
-
-  const out = new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
-  try { out._t = res._t; } catch {}
-  return out;
-}
+// workbuddy 流式 reasoning_content 整形：上游思考模型（如 glm-5.3-flash）把思考过程一词一 chunk
+// 地放进 delta.reasoning_content，客户端会把每个增量渲染成独立 "- Thought" 条目。
+// 旧版：连续 reasoning 增量缓冲到首个 content/finish 才一次性 flush → 思考期 10~30s 界面完全无变化（用户看到 workbuddy 后台流量走但 opencode 界面卡住）
+// 新版：增量聚合 + 阈值分片：缓冲 reasoning，达到 REASONING_CHUNK_SIZE（默认 100 字符）即分片 flush，
+// 期间仅首个 role 帧透传保持 TTFB，其余纯 reasoning 空帧吞掉（之前会透传 800+ 空 role 帧）；
+// 尾段不足阈值的在 content/finish/流结束时兜底 flush。恒空 reasoning（deepseek-v4-flash）零改写。
+// 仅包 workbuddy 出口的 SSE 响应，不影响其他供应商与全局聚合器。
+
+const REASONING_CHUNK_SIZE = 150;
+
+export function reshapeWorkbuddySse(res) {
+  try {
+    const ct = res.headers?.get?.("content-type") || "";
+    if (res.status !== 200 || !ct.includes("text/event-stream") || !res.body) return res;
+  } catch { return res; }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buf = "";
+  let reasoningBuf = "";
+  let lastMeta = null;
+  let closed = false;
+  let hasSentRole = false;
+  let lastFlushAt = Date.now();
+
+  function flushReasoningInto(out) {
+    if (!reasoningBuf) return;
+    const meta = lastMeta || {};
+    out.push(`data: ${JSON.stringify({
+      id: meta.id || "chatcmpl-workbuddy-reshape",
+      object: meta.object || "chat.completion.chunk",
+      created: meta.created || Math.floor(Date.now() / 1000),
+      model: meta.model || "",
+      choices: [{ index: 0, delta: { reasoning_content: reasoningBuf }, finish_reason: null }],
+    })}\n\n`);
+    reasoningBuf = "";
+    lastFlushAt = Date.now();
+  }
+
+  let blankStreak = false;
+  // 处理一段完整行文本（以 \n 结尾），产出的行/帧推进 out（连续空行合并为单个事件分隔）
+  function processInto(text, out) {
+    for (const line of text.split("\n")) {
+      if (!line) { if (!blankStreak) out.push("\n"); blankStreak = true; continue; }
+      blankStreak = false;
+      if (!line.startsWith("data:")) { out.push(line + "\n"); continue; }
+      const payload = line.slice(5).trim();
+      if (!payload || payload === "[DONE]") { out.push(line + "\n"); continue; }
+      let obj;
+      try { obj = JSON.parse(payload); } catch { out.push(line + "\n"); continue; }
+      const ch = obj.choices?.[0];
+      if (ch && typeof ch === "object") {
+        if (obj.id) lastMeta = { id: obj.id, model: obj.model, object: obj.object, created: obj.created };
+        const d = ch.delta && typeof ch.delta === "object" ? ch.delta : null;
+        const rc = d ? d.reasoning_content : undefined;
+        if (typeof rc === "string" && rc) {
+          reasoningBuf += rc;
+          d.reasoning_content = "";
+          const isBoundary = (typeof d.content === "string" && d.content) || !!ch.finish_reason;
+          // 首个 reasoning 帧的 role 透传一次，保 TTFB；后续纯 reasoning 的 role 重复帧直接吞掉
+          if (!hasSentRole && d.role !== undefined) {
+            hasSentRole = true;
+            const rm = lastMeta || obj;
+            out.push(`data: ${JSON.stringify({
+              id: rm.id || obj.id || "chatcmpl-workbuddy-reshape",
+              object: rm.object || obj.object || "chat.completion.chunk",
+              created: rm.created || obj.created || Math.floor(Date.now() / 1000),
+              model: rm.model || obj.model || "",
+              choices: [{ index: 0, delta: { role: d.role }, finish_reason: null }],
+            })}\n\n`);
+          } else if (d.role !== undefined) {
+            // 后续重复 role 帧不再透传，避免 800+ 空帧洪泛
+            // 标记已发送过，避免后续非 reasoning 帧再误判为首次
+            hasSentRole = true;
+          }
+          // 阈值分片：攒够 100 字符即向前吐一块，期间界面可见增量而非全程静默
+          // 时间阈值：若距上次 flush 已超 700ms 且已攒 20+ 字符，也吐一块（避免小尾巴长时间不更新）
+          const now = Date.now();
+          const shouldChunk = reasoningBuf.length >= REASONING_CHUNK_SIZE
+            || (reasoningBuf.length >= 50 && now - lastFlushAt > 1500);
+          if (shouldChunk) flushReasoningInto(out);
+          if (isBoundary) {
+            // 兜底：content/finish 前把剩余思考一次性吐出，再透传本帧
+            flushReasoningInto(out);
+            const hasPassthrough = isBoundary || (Array.isArray(d.tool_calls) && d.tool_calls.length);
+            if (hasPassthrough) out.push(`data: ${JSON.stringify(obj)}\n\n`);
+            continue;
+          }
+          // 纯 reasoning 碎片帧已缓冲/或已分片吐出，原空帧吞掉
+          continue;
+        }
+        // 非 reasoning 帧：若有 content/finish 先兜底 flush
+        if ((typeof d?.content === "string" && d.content) || ch.finish_reason) flushReasoningInto(out);
+        if (!hasSentRole && d?.role !== undefined) {
+          hasSentRole = true;
+        } else if (hasSentRole && d?.role !== undefined) {
+          // 去重：首个 role 后续重复 role 去掉，避免下游每帧都带 role
+          try { const clone = JSON.parse(payload); delete clone.choices[0].delta.role; out.push(`data: ${JSON.stringify(clone)}\n\n`); continue; } catch { /* fallback透传 */ }
+        }
+      }
+      out.push(line + "\n");
+    }
+  }
+
+  const body = new ReadableStream({
+    async pull(controller) {
+      if (closed) { try { controller.close(); } catch {} return; }
+      try {
+        // 循环读源，直到"有输出 / 流结束 / 出错"才返回。
+        // WHATWG 流规范：pull 的 promise 解析后若未 enqueue，规范不会再自动调度 pull
+        // （仅当解析期间有新读请求触发 pullAgain 才重调）——消费者只挂一个待处理 read 时，
+        // 任何一次"只吞帧不出数据"的拉取都会让整流永久停摆。workbuddy 思考流按帧到达
+        // （role 帧后每个 reasoning 碎片都不足 150 字符阈值）时必现，即"首帧后卡死"根因。
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) {
+            closed = true;
+            const out = [];
+            if (buf) { processInto(buf + "\n", out); buf = ""; }
+            flushReasoningInto(out);
+            if (out.length) controller.enqueue(encoder.encode(out.join("")));
+            controller.close();
+            return;
+          }
+          buf += decoder.decode(value, { stream: true });
+          const idx = buf.lastIndexOf("\n");
+          if (idx < 0) continue;
+          const complete = buf.slice(0, idx + 1);
+          buf = buf.slice(idx + 1);
+          const out = [];
+          processInto(complete, out);
+          if (out.length) { controller.enqueue(encoder.encode(out.join(""))); return; }
+        }
+      } catch {
+        closed = true;
+        try { controller.close(); } catch {}
+      }
+    },
+    cancel() {
+      closed = true;
+      try {
+        const p = reader.cancel();
+        if (p && typeof p.catch === "function") p.catch(() => {});
+      } catch {}
+    },
+  });
+
+  const out = new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+  try { out._t = res._t; } catch {}
+  return out;
+}

package/src/providers/workbuddy.js

@@ -1,2 +1,2 @@
-// Shim — 保持历史导入路径兼容，真实实现下沉至 ./workbuddy/ 深模块
-export * from "./workbuddy/index.js";
+// Shim — 保持历史导入路径兼容，真实实现下沉至 ./workbuddy/ 深模块
+export * from "./workbuddy/index.js";

package/src/providers/zcode/chat.js

@@ -2,7 +2,8 @@
 // 失败响应带 x-mslxdff-zcode-kind 标记，供 provider 工厂决定冷却策略。
 import { timeoutSignal } from "../../compat.js";
 import { ZCODE_MESSAGES_URL, canonicalZcodeModel, zcodeErrorKind } from "./const.js";
-import { buildZcodeHeaders } from "./headers.js";
+import { shapeZcodeWireRequest } from "./context-shape.js";
+import { buildZcodeModelHeaders } from "./headers.js";
 import { aggregateAnthropicToOpenAi, anthropicToOpenAiStream } from "./sse.js";
 
 const DEFAULT_MAX_TOKENS = 4096;
@@ -97,7 +98,7 @@ const ERROR_MAP = {
   auth: { status: 401, type: "auth_error", text: (f) => `zcode: 登录已失效（code ${f.code || 1006}）。请运行 mslxdff -provider zcode login 重新登录` },
   quota: { status: 429, type: "quota_exhausted", text: () => "zcode: 免费额度已用完（按日重置），请明日再试或添加账号" },
   rate_limit: { status: 429, type: "all_cooling", text: () => "zcode: 上游限流（账号冷却中），请稍后重试" },
-  security: { status: 403, type: "security_reject", text: (f) => `zcode: 安全校验拒绝（code ${f.code || 3007}）${f.message ? `：${f.message}` : ""} · 该额度走 Start Plan 验证码通道（每条请求需一次性 x-aliyun-captcha-verify-param；未启用验证码农场时必现），见 docs/adr/0038` },
+  security: { status: 403, type: "security_reject", text: (f) => `zcode: 安全校验拒绝（code ${f.code || 3007}）${f.message ? `：${f.message}` : ""} · v3.14.4 起模型请求已免验证码（仅 claim 通道仍需要），偶发请重试，见 docs/adr/0038` },
   param: { status: 400, type: "invalid_request", text: (f) => `zcode: 请求参数被上游拒绝（code ${f.code}）${f.message ? `：${f.message}` : ""}` },
   server: { status: 502, type: "upstream_error", text: (f) => `zcode: 上游服务异常${f.code ? `（code ${f.code}）` : ""}${f.message ? `：${f.message}` : ""}` },
   network: { status: 502, type: "upstream_error", text: (f) => `zcode: 网络错误 ${f.message || ""}`.trim() },
@@ -115,21 +116,21 @@ export function zcodeErrorResponse(fail = {}) {
   });
 }
 
-export async function forwardZcodeChat({ body, token, deviceMid, fetchImpl, version, timeoutMs = 120_000 } = {}) {
+export async function forwardZcodeChat({ body, token, deviceMid, fetchImpl, version, timeoutMs = 120_000, provider = "zai" } = {}) {
   const anthropicBody = toAnthropicRequest(body);
-  const modelId = anthropicBody.model;
-  const headers = {
-    ...buildZcodeHeaders({ token, deviceMid, version }),
-    "Content-Type": "application/json",
-    Accept: "text/event-stream",
-  };
+  const modelId = anthropicBody.model; // 响应回显用 canonical id；出站另行归一
+  // 官方线形：小写模型 + system 身份块 + currentDate 前缀（缺任一 → 上游 3012）。
+  // deviceMid 入参保留签名兼容，但模型请求出站不带（官方 CLI 模型请求不带该头，实测）。
+  const wireBody = shapeZcodeWireRequest(anthropicBody, { provider });
+  const headers = { "content-type": "application/json", ...buildZcodeModelHeaders({ token, version }) };
+  void deviceMid;
 
   let res;
   try {
     res = await fetchImpl(ZCODE_MESSAGES_URL, {
       method: "POST",
       headers,
-      body: JSON.stringify(anthropicBody),
+      body: JSON.stringify(wireBody),
       signal: timeoutSignal(timeoutMs),
     });
   } catch (e) {

package/src/providers/zcode/const.js

@@ -8,7 +8,7 @@ export const ZCODE_MESSAGES_URL = `${ZCODE_ORIGIN}/api/v1/zcode-plan/anthropic/v
 export const zcodeBalanceUrl = (appVersion) =>
   `${ZCODE_ORIGIN}/api/v1/zcode-plan/billing/balance?app_version=${encodeURIComponent(String(appVersion || ""))}`;
 
-export const ZCODE_DEFAULT_APP_VERSION = "3.11.2";
+export const ZCODE_DEFAULT_APP_VERSION = "3.14.4";
 export const ZCODE_RELEASE_CHANNEL = "stable";
 
 export function zcodeAppVersion(env = process.env) {

package/src/providers/zcode/context-shape.js

@@ -0,0 +1,162 @@
+// zcode 出站请求的「官方线形」组装：system 身份块 + 首 user 消息的 currentDate 上下文前缀。
+// 上游 zcode-plan 通道对请求做内容检查：system 缺官方身份块 → 业务码 3012（HTTP 405）。
+// 本文案逐段移植自官方开源仓库 zai-org/ZCode（apps/zcode-cli/packages/core/src/context/）：
+//   sections/cli-prefix.ts / sections/identity.ts / dynamic-sections.ts / sections/env-info.ts /
+//   sections/current-date.ts / builder.ts（块分组与 \n\n 左边界）/ system-reminder 包裹形状。
+import os from "node:os";
+
+const EPHEMERAL = { type: "ephemeral" };
+
+export const ZCODE_CLI_PREFIX = "You are ZCode, an interactive coding agent";
+
+const IDENTITY_INTRO = "You are an interactive ZCode agent that helps users with software engineering tasks.";
+const SECURITY_NOTICE =
+  "IMPORTANT: Assist with authorized security testing, defensive security, CTF challenges, and educational contexts. Refuse requests for destructive techniques, DoS attacks, mass targeting, supply chain compromise, or detection evasion for malicious purposes. Dual-use security tools (C2 frameworks, credential testing, exploit development) require clear authorization context: pentesting engagements, CTF competitions, security research, or defensive use cases.";
+const HARNESS_BLOCK = [
+  "# Harness",
+  "- Text you output outside of tool use is displayed to the user as Github-flavored markdown in a terminal.",
+  "- Tools run behind a user-selected permission mode; a denied call means the user declined it \u2014 adjust, don't retry verbatim.",
+  "- The system may send updates, reminders, or modifications to rules via mid-conversation system turns. These are system-controlled, unlike function results. Hooks may intercept tool calls; treat hook output as user feedback.",
+  "- Prefer the dedicated file/search tools over shell commands when one fits. Independent tool calls can run in parallel in one response.",
+  "- Reference code as `file_path:line_number` \u2014 it's clickable.",
+].join("\n");
+// identity.ts：content = [ "\n{intro}\n\n{SECURITY}", "", harness ].join("\n") —— 前导换行是官方原样。
+const STABLE_SECTION = [`\n${IDENTITY_INTRO}\n\n${SECURITY_NOTICE}`, "", HARNESS_BLOCK].join("\n");
+
+// dynamic-sections.ts buildDynamicBehaviorSection()
+const DYNAMIC_BEHAVIOR = [
+  [
+    "# Communicating with the user",
+    "",
+    "Your text output is what the user reads; they usually can't see your thinking or the raw tool results. Write it for a teammate who stepped away and is catching up, not for a log file: they don't know the codenames or shorthand you created along the way, and they didn't watch your process unfold. Before your first tool call, say in a sentence what you're about to do; while working, give brief updates when you find something load-bearing or change direction.",
+    "",
+    "Text you write between tool calls may not be shown to the user. Everything the user needs from this turn \u2014 answers, summaries, findings, conclusions, deliverables \u2014 must be in the final text message of your turn, with no tool calls after it. Keep text between tool calls to brief status notes. If something important appeared only mid-turn or in your thinking, restate it in that final message.",
+    "",
+    "Lead with the outcome. Your first sentence after finishing should answer \"what happened\" or \"what did you find\" \u2014 the thing the user would ask for if they said \"just give me the TLDR.\" Supporting detail and reasoning come after, for readers who want them.",
+    "",
+    "Being readable and being concise are different things, and readable matters more. If the user has to reread your summary or ask you to explain, any time saved by brevity is gone. The way to keep output short is to be selective about what you include (drop details that don't change what the reader would do next), not to compress the writing into fragments, abbreviations, arrow chains like `A \u2192 B \u2192 fails`, or jargon. What you do include, write in complete sentences with the technical terms spelled out. Don't make the reader cross-reference labels or numbering you invented earlier; say what you mean in place.",
+    "",
+    "Match the response to the question: a simple question gets a direct answer in prose, not headers and sections. Use tables only for short enumerable facts, with explanations in the surrounding prose rather than the cells. Calibrate to the user \u2014 a bit tighter for an expert, more explanatory for someone newer.",
+  ].join("\n"),
+  "",
+  "Write code that reads like the surrounding code: match its comment density, naming, and idiom.",
+  "Only write a code comment to state a constraint the code itself can't show \u2014 never to say where it came from, what the next line does, or why your change is correct; that's you talking to the reviewer, not the next reader, and it's noise the moment the PR merges.",
+  "",
+  "For actions that are hard to reverse or outward-facing, confirm first unless durably authorized or explicitly told to proceed without asking; approval in one context doesn't extend to the next. Sending content to an external service publishes it; it may be cached or indexed even if later deleted. Before deleting or overwriting, look at the target \u2014 if what you find contradicts how it was described, or you didn't create it, surface that instead of proceeding. Report outcomes faithfully: if tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging.",
+].join("\n");
+
+// dynamic-sections.ts buildContextManagementSection()
+const CONTEXT_MANAGEMENT = [
+  ["# Context management", "When the conversation grows long, some or all of the current context is summarized; the summary, along with any remaining unsummarized context, is provided in the next context window so work can continue \u2014 you don't need to wrap up early or hand off mid-task."].join("\n"),
+  "",
+  "When you have enough information to act, act. Do not re-derive facts already established in the conversation, re-litigate a decision the user has already made, or narrate options you will not pursue. If you are weighing a choice, give a recommendation, not an exhaustive survey",
+  "",
+  "You are operating autonomously. The user is not watching in real time and cannot answer questions mid-task, so asking 'Want me to\u2026?' or 'Shall I\u2026?' will block the work. For reversible actions that follow from the original request, proceed without asking. Stop only for destructive actions or genuine scope changes the user must decide. Offering follow-ups after the task is done is fine; asking permission before doing the work is not.",
+  "",
+  "Exception: when the user is describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment. Report your findings and stop. Don't apply a fix until they ask for one.",
+  "",
+  "Before ending your turn, check your last paragraph. If it is a plan, an analysis, a question, a list of next steps, or a promise about work you have not done ('I'll\u2026', 'let me know when\u2026'), do that work now with tool calls. That includes retrying after errors and gathering missing information yourself. Do not stop because the context or session is long. End your turn only when the task is complete or you are blocked on input only the user can provide.",
+  "",
+  "Before running a command that changes system state \u2014 restarts, deletes, config edits \u2014 check that the evidence actually supports that specific action. A signal that pattern-matches to a known failure may have a different cause.",
+].join("\n");
+
+// builder.ts buildContextMetaUserBody() 的 intro/outro（current-date.ts 的正文夹在中间）
+const CONTEXT_INTRO = "As you answer the user's questions, you can use the following context:";
+const CONTEXT_OUTRO = "      IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.";
+const REMINDER_OPEN = "<system-reminder>";
+const REMINDER_CLOSE = "</system-reminder>";
+
+function localIsoDate(d = new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
+function normalizeCallerSystem(system) {
+  const out = [];
+  if (typeof system === "string") {
+    if (system.trim()) out.push({ type: "text", text: system });
+  } else if (Array.isArray(system)) {
+    for (const item of system) {
+      if (typeof item === "string") {
+        if (item.trim()) out.push({ type: "text", text: item });
+      } else if (item && typeof item === "object" && item.type === "text" && typeof item.text === "string" && item.text.trim()) {
+        out.push({ type: "text", text: item.text });
+      }
+    }
+  }
+  return out;
+}
+
+// env-info.ts buildEnvInfoContent()：CLI 无 git 上下文的固定形态
+function buildEnvironmentSection({ cwd, model, provider, platform, shell, osVersion }) {
+  const lines = [
+    "# Environment",
+    "You have been invoked in the following environment:",
+    `- Primary working directory: ${cwd}`,
+    "- Is a git repository: no",
+    `- Platform: ${platform}`,
+    `- Shell: ${shell}`,
+    `- OS Version: ${osVersion}`,
+  ];
+  if (model) lines.push(`- You are powered by the model named ${provider}-api/${model}.`);
+  return lines.join("\n");
+}
+
+/**
+ * 官方式 system 块数组：cliPrefix / stable / dynamic（\n\n 左边界）三块均带 ephemeral，
+ * 调用方原 system 追加在末尾（不进官方缓存块）。
+ */
+export function buildZcodeSystemBlocks({ system, model, provider = "zai", cwd = process.cwd(), now = new Date(), platform, shell, osVersion } = {}) {
+  const env = buildEnvironmentSection({
+    cwd,
+    model,
+    provider,
+    platform: platform || process.platform,
+    shell: shell || (process.platform === "win32" ? "cmd" : (process.env.SHELL || "sh")),
+    osVersion: osVersion || os.release(),
+  });
+  const dynamic = [DYNAMIC_BEHAVIOR, env, CONTEXT_MANAGEMENT].join("\n\n");
+  const official = [
+    { type: "text", text: ZCODE_CLI_PREFIX, cache_control: { ...EPHEMERAL } },
+    { type: "text", text: STABLE_SECTION, cache_control: { ...EPHEMERAL } },
+    // builder.ts:270-271：Main Agent 的 dynamic system block 自带 \n\n 左边界
+    { type: "text", text: `\n\n${dynamic}`, cache_control: { ...EPHEMERAL } },
+  ];
+  return [...official, ...normalizeCallerSystem(system)];
+}
+
+/** 首 user 消息的 currentDate 上下文块（builder.ts meta_user → system-reminder 包裹）。 */
+export function buildZcodeContextPrefixBlock(now = new Date()) {
+  const body = [
+    CONTEXT_INTRO,
+    `# currentDate\nToday's date is ${localIsoDate(now)}.`,
+    "",
+    CONTEXT_OUTRO,
+  ].join("\n");
+  return { type: "text", text: `${REMINDER_OPEN}\n${body}\n${REMINDER_CLOSE}` };
+}
+
+/** 把上下文前缀挂到首个 user 消息 content 最前（字符串 content 升格为块数组；已挂则不动）。 */
+export function attachZcodeContextPrefix(messages, now = new Date()) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+  const first = messages[0];
+  if (!first || first.role !== "user") return messages;
+  const content = Array.isArray(first.content)
+    ? first.content
+    : [{ type: "text", text: String(first.content ?? "") }];
+  if (content.some((c) => c?.type === "text" && typeof c.text === "string" && c.text.startsWith(REMINDER_OPEN))) {
+    return messages;
+  }
+  return [{ ...first, content: [buildZcodeContextPrefixBlock(now), ...content] }, ...messages.slice(1)];
+}
+
+/** 内部 Anthropic 请求 → 官方出站线形：小写模型名 + 身份 system 块 + currentDate 前缀，其余透传。 */
+export function shapeZcodeWireRequest(req = {}, { cwd, provider = "zai", now = new Date() } = {}) {
+  const model = typeof req.model === "string" ? req.model.toLowerCase() : req.model;
+  return {
+    ...req,
+    model,
+    system: buildZcodeSystemBlocks({ system: req.system, model, provider, cwd, now }),
+    messages: attachZcodeContextPrefix(req.messages, now),
+  };
+}

package/src/providers/zcode/headers.js

@@ -53,3 +53,41 @@ export function buildZcodeHeaders(opts = {}) {
   if (token) headers["Authorization"] = `Bearer ${token}`;
   return headers;
 }
+
+// 模型请求专用形态（zcode-plan 通道）：与官方 CLI 出站同形 —— 双鉴权头、ai-sdk UA、
+// x-title=cli、production 渠道、anthropic-version、gzip；**不带** X-Device-Mid，
+// **不带** 验证码头（v3.14.4 起模型请求免校验，client/configs captcha.skip_model_request=true）。
+export function buildZcodeModelHeaders(opts = {}) {
+  const ver = normalizeHeaderValue(opts.version) ?? zcodeAppVersion();
+  const platform = normalizeHeaderValue(opts.platform) ?? process.platform;
+  const arch = normalizeHeaderValue(opts.arch) ?? process.arch;
+  const intl = (() => { try { return Intl.DateTimeFormat().resolvedOptions() || {}; } catch { return {}; } })();
+  const language = normalizeHeaderValue(opts.lang) ?? normalizeHeaderValue(intl.locale) ?? "unknown";
+  const timeZone = normalizeHeaderValue(opts.tz) ?? normalizeHeaderValue(intl.timeZone) ?? "unknown";
+  const osVersion = "osVersion" in opts ? normalizeHeaderValue(opts.osVersion) : normalizeHeaderValue(os.release());
+  const token = normalizeHeaderValue(opts.token);
+  const headers = {
+    "accept-encoding": "gzip",
+    "anthropic-version": "2023-06-01",
+    "authorization": token ? `Bearer ${token}` : undefined,
+    "http-referer": ZCODE_ORIGIN,
+    "user-agent": `ZCode/${ver} ai-sdk/anthropic/3.0.81`,
+    "x-api-key": token,
+    "x-client-language": language,
+    "x-client-timezone": timeZone,
+    "x-os-category": osCategory(platform),
+    "x-platform": `${platform}-${arch}`,
+    "x-release-channel": "production",
+    "x-request-id": normalizeHeaderValue(opts.requestId) ?? uuid(),
+    "x-title": "Z Code@cli",
+    "x-zcode-agent": "glm",
+    "x-zcode-app-version": ver,
+    "x-zcode-session-type": "main",
+    "x-zcode-trace-id": normalizeHeaderValue(opts.traceId) ?? uuid(),
+  };
+  if (osVersion) headers["x-os-version"] = osVersion;
+  for (const k of Object.keys(headers)) {
+    if (headers[k] === undefined) delete headers[k];
+  }
+  return headers;
+}