mocode-ai 1.5.1 → 1.5.3

package/dist/agent/index.js

@@ -382,6 +382,8 @@ runtimeOrContext = defaultRuntime) {
         },
         onStepStart: () => spinner.start(t('agent.thinking')),
         onChatDone: () => spinner.stop(),
+        // 退避重试要在状态行可见:否则用户面对的是几十秒到几分钟的静止 spinner,与卡死无异。
+        onModelRetry: (r) => spinner.start(t('agent.retrying', { seconds: Math.max(1, Math.round(r.waitMs / 1000)), attempt: r.attempt })),
         // 流式实时用量 → 底栏 context 进度条左侧 chip;轮末由 repl 清空。
         onLiveUsage: (u) => layout.setLiveUsage(u),
         onTextEnd: () => {

package/dist/agent/model-turn.js

@@ -1,4 +1,20 @@
 import { estimatePromptTokens, estimateTokens, isContextLengthError, } from '../llm/index.js';
+/**
+ * 沿 cause 链(≤3 层)取第一个 errno,供 trace 取证。
+ * undici 把底层 errno 挂在 cause 上(`TypeError: fetch failed` → cause `read ECONNRESET`),
+ * openai SDK 再包一层 APIConnectionError 后,顶层 code 恒为 undefined;不留这一项,
+ * 事后只能看到一个 'Error',无法区分 DNS 失败 / 连接被拒 / TLS 握手失败。
+ */
+function traceCauseCode(err) {
+    let cur = err;
+    for (let depth = 0; depth <= 3 && cur && typeof cur === 'object'; depth++) {
+        const e = cur;
+        if (typeof e.code === 'string')
+            return e.code;
+        cur = e.cause;
+    }
+    return undefined;
+}
 /** Executes context preparation plus exactly one model step, including the single overflow retry path. */
 export async function runModelTurn(input) {
     const { opts, ctx, history, historyManager, runtimeContextState, scheduler, contextTrimmer, modelRunner, activeTools, runPolicy, step, cacheState, turnLifecycle, cancellationLifecycle, rebuildHistoryIndexes, } = input;
@@ -112,28 +128,44 @@ export async function runModelTurn(input) {
         onText,
         onToolCall,
         onProgress: reportLive,
-        onRetry: (retry) => emitTrace('model_retry', {
-            model: requestModel,
-            provider,
-            attempt: retry.attempt,
-            nextAttempt: retry.nextAttempt,
-            waitMs: retry.waitMs,
-            code: retry.code,
-        }),
+        onRetry: (retry) => {
+            emitTrace('model_retry', {
+                model: requestModel,
+                provider,
+                attempt: retry.attempt,
+                nextAttempt: retry.nextAttempt,
+                waitMs: retry.waitMs,
+                code: retry.code,
+            });
+            // 退避最长可到 30s、最坏累计数分钟。只写 trace 的话用户看到的就是「卡住不动」,
+            // 与「直接报错终止」一样不可解释 —— 所以同时转达给宿主做可见反馈。
+            hooks.onModelRetry?.(retry);
+        },
     };
     const runChatOnce = async () => {
         try {
             return await modelRunner.run({ history: requestHistory, handlers: chatHandlers, tools: activeTools }, signal);
         }
         catch (error) {
-            const errorValue = error && typeof error === 'object' ? error : undefined;
+            const errorValue = error && typeof error === 'object'
+                ? error
+                : undefined;
             emitTrace('model_end', {
                 model: requestModel,
                 provider,
                 status: signal?.aborted ? 'aborted' : 'error',
                 code: typeof errorValue?.status === 'number'
                     ? `HTTP_${errorValue.status}`
-                    : (errorValue?.code ?? errorValue?.name ?? 'MODEL_ERROR'),
+                    : // 构造器名优先于 `name`:SDK 的 APIError 家族 err.name 恒为 'Error'(无信息量),
+                        // 构造器名才分得出 APIConnectionError(建连失败)/ APIError(流内报错)。
+                        (errorValue?.code ??
+                            error?.constructor?.name ??
+                            errorValue?.name ??
+                            'MODEL_ERROR'),
+                // 取证用:错误文案与 cause 链上的 errno。没有这两项时,trace 只留一个 'Error',
+                // 事后无法判断到底是 DNS 失败、连接被拒还是 TLS 握手失败(实测踩过)。
+                message: typeof errorValue?.message === 'string' ? errorValue.message.slice(0, 300) : undefined,
+                causeCode: traceCauseCode(error),
                 durationMs: Date.now() - modelStartedAt,
             });
             throw error;

package/dist/i18n/index.js

@@ -190,6 +190,7 @@ const zhCN = {
     'agent.thinking': '思考中',
     'agent.generating': '生成 {tool}',
     'agent.executing': '执行 {tool}',
+    'agent.retrying': '连接异常，{seconds}s 后重试（第 {attempt} 次）',
     'agent.noReply': '(无回复)',
     'agent.maxSteps': '达到最大步数({count})，本轮停止。',
     'agent.aborted': '(已中断)',
@@ -225,6 +226,7 @@ const zhCN = {
     'repl.llmTimeoutError': '请求超时：模型服务响应过慢。可重试，或输入 /model switch 换一个模型。',
     'repl.llmNetworkError': '网络错误：无法连接 {base}。检查网络连接，或输入 /model 核对 baseURL 配置。',
     'repl.llmContextError': '上下文超长：输入 /compact 压缩会话后重试。',
+    'repl.llmServerError': '模型服务端在生成中途中断（错误来自响应流内部，非 HTTP 层）。该轮未写入会话历史，直接重发即可；若反复出现，用 /model switch 换模型或 /compact 压缩会话。',
     'permission.path': '路径: {value}',
     'permission.command': '命令: {value}',
     'permission.task': '任务: {value}',
@@ -518,6 +520,7 @@ const en = {
     'agent.thinking': 'Thinking',
     'agent.generating': 'Generating {tool}',
     'agent.executing': 'Running {tool}',
+    'agent.retrying': 'Connection lost, retrying in {seconds}s (attempt {attempt})',
     'agent.noReply': '(no reply)',
     'agent.maxSteps': 'Maximum steps reached ({count}); this turn has stopped.',
     'agent.aborted': '(aborted)',
@@ -553,6 +556,7 @@ const en = {
     'repl.llmTimeoutError': 'Request timed out: the model service responded too slowly. Retry, or run /model switch to use another model.',
     'repl.llmNetworkError': 'Network error: cannot reach {base}. Check your connection, or run /model to verify the baseURL.',
     'repl.llmContextError': 'Context too long: run /compact to compress the session, then retry.',
+    'repl.llmServerError': 'The model backend aborted mid-stream (the error came from inside the response stream). This turn was not written to session history — just resend it. If it repeats, run /model switch or /compact.',
     'permission.path': 'Path: {value}',
     'permission.command': 'Command: {value}',
     'permission.task': 'Task: {value}',
@@ -658,7 +662,13 @@ const resources = {
     'zh-CN': zhCN,
     en,
 };
-let currentLanguage = 'zh-CN';
+/**
+ * 未显式配置语言时的默认值。刻意固定为 en 而**不**探测系统 locale：
+ * 中文 Windows 的 `Intl.DateTimeFormat().resolvedOptions().locale` 为 zh-CN，
+ * 会让新装用户一开就是中文界面。要中文须显式 /language zh-CN 或 MOCODE_LANGUAGE=zh-CN。
+ */
+export const DEFAULT_LANGUAGE = 'en';
+let currentLanguage = DEFAULT_LANGUAGE;
 export function normalizeLanguage(value) {
     const normalized = value?.trim().toLowerCase().replace('_', '-');
     if (!normalized)
@@ -669,12 +679,12 @@ export function normalizeLanguage(value) {
         return 'en';
     return null;
 }
+/**
+ * 解析生效语言：只认显式配置（MOCODE_LANGUAGE / ~/.mocode/config / 项目级 config），
+ * 无法识别或未配置时落 DEFAULT_LANGUAGE（en）。不再回退系统 locale。
+ */
 export function detectLanguage(preferred) {
-    const explicit = normalizeLanguage(preferred);
-    if (explicit)
-        return explicit;
-    const system = normalizeLanguage(process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || Intl.DateTimeFormat().resolvedOptions().locale);
-    return system ?? 'zh-CN';
+    return normalizeLanguage(preferred) ?? DEFAULT_LANGUAGE;
 }
 export function setLanguage(language) {
     currentLanguage = language;

package/dist/llm/index.js

@@ -5,6 +5,7 @@ import { getPlanDisabledTools, getProfileDisabledTools } from '../tools/constant
 import { imageSizeFromDataUrl } from '../attachments/image.js';
 import { ThinkTagFilter } from './think-filter.js';
 import { sanitizeToolSchemas } from './tool-schema.js';
+import { isMarkedStreamInterrupted } from './stream-interrupt.js';
 import { defaultAnthropicFetch, anthropicChatOnce } from './providers/anthropic.js';
 import { registerModelProvider, getModelProvider, listModelProviders } from './provider.js';
 // 强制关闭第三方调试日志泄漏:openai SDK 在 process.env.DEBUG === 'true' 时用裸
@@ -29,6 +30,12 @@ const RETRY_MAX_ATTEMPTS = 10;
 const RETRY_BASE_MS = 1000;
 const RETRY_MAX_MS = 30000;
 const RETRY_JITTER = 0.2;
+/**
+ * 「流中途故障」(见 isStreamInterruptedError)单独的重试预算,不共享 HTTP 层的 10 次。
+ * 这类错误绝大多数是推理后端瞬时故障,重试两次足够;若它其实是永久故障,10 次指数退避
+ * (封顶 30s)会让用户干等近两分钟,代价远大于收益。
+ */
+const STREAM_RETRY_MAX_ATTEMPTS = 2;
 /**
  * 流式响应里出现的推理模型自创 `think` 标签(DeepSeek R1 / Qwen3 / 部分自训模型):
  * 与 OpenAI 兼容协议的独立 `reasoning_content` 字段不同,这些模型把 thinking 直接嵌进 content
@@ -100,7 +107,9 @@ export function isRetryableError(err, signal) {
     if (!err || typeof err !== 'object')
         return false;
     const e = err;
-    if (e.name === 'AbortError' || e.name === 'APIUserAbortError')
+    // SDK 的 APIError 家族不设 this.name(见下),判类别一律用构造器名。
+    const ctor = e.constructor?.name ?? '';
+    if (e.name === 'AbortError' || e.name === 'APIUserAbortError' || ctor === 'APIUserAbortError')
         return false;
     // OpenAI SDK APIError 走 status 分支(覆盖 4xx/5xx/429)
     const status = e.status;
@@ -111,25 +120,138 @@ export function isRetryableError(err, signal) {
             return true;
         return false;
     }
-    // Node 网络错 code(APIConnectionError 内部也会带一个)
-    const code = e.code;
-    if (code === 'ETIMEDOUT' ||
-        code === 'ECONNRESET' ||
-        code === 'ENOTFOUND' ||
-        code === 'EAI_AGAIN' ||
-        code === 'ECONNREFUSED' ||
-        code === 'EPIPE') {
+    // 证书 / 协议层不匹配是**永久性**错误,重试只会白等满退避(10 次≈两分钟)。
+    // 必须先于下面的宽兜底判定:fetch failed / cause 里的证书错文案都会被宽兜底捞走。
+    if (causeChainFrames(err).some((f) => (!!f.code && FATAL_TRANSPORT_CODE.test(f.code)) || (!!f.message && FATAL_TRANSPORT_MESSAGE.test(f.message))))
+        return false;
+    // Node 网络错 errno:顶层没有就沿 cause 链找(undici 把 errno 藏在 cause 里)。
+    if (causeChainFrames(err).some((f) => !!f.code && RETRYABLE_ERRNO.has(f.code)))
         return true;
-    }
-    // OpenAI SDK 的网络错类(无 status)
-    if (e.name === 'APIConnectionError' || e.name === 'APIConnectionTimeoutError')
+    // OpenAI SDK 的网络错类(无 status)。必须用**构造器名**:SDK 的 APIError 家族只做
+    // `super(message)`,从不设 this.name(`err.name` 恒为 'Error')—— 旧代码这里写
+    // `e.name === 'APIConnectionError'` 是永不命中的死分支,于是建连失败(DNS / 连接被拒 /
+    // TLS 握手 / 半路断流)一次即抛、整轮 run 直接终止(trace 里 model_end.code 只剩 'Error')。
+    if (ctor === 'APIConnectionError' || ctor === 'APIConnectionTimeoutError')
         return true;
-    // 兜底:错误信息里出现 timeout 字样(部分代理把错误折叠成普通 Error)
-    if (typeof e.message === 'string' && /\btime(d|ed)?\s*out\b|ETIMEDOUT/i.test(e.message)) {
+    // 兜底:文案。部分代理把错误折叠成普通 Error;SDK 的 APIConnectionError 默认文案就是
+    // 'Connection error.'(负载里没有任何细节,`code` 也为 undefined,只能靠文案兜)。
+    const msg = typeof e.message === 'string' ? e.message : '';
+    if (/\btime(d|ed)?\s*out\b|ETIMEDOUT/i.test(msg))
+        return true;
+    if (/^connection error\.?$/i.test(msg.trim()) || /\bfetch failed\b/i.test(msg))
         return true;
-    }
     return false;
 }
+/**
+ * 「传输/协议层的流中断」判据:连接被掐断、响应提前结束、cause 里藏着 errno。
+ *
+ * 实测(Node 22 + openai SDK + 服务端 destroy socket):HTTP 200 建连并已吐出 chunk 后
+ * 连接被掐,抛的是 `Error: Premature close`(code `ERR_STREAM_PREMATURE_CLOSE`)——
+ * 既不是 APIError 也没有 status,`isRetryableError` 一条都不命中。网关超时、NAT 回收、
+ * 推理进程 OOM 被杀、k8s pod 重启都属于这一类,是线上最常见的「半路断流」。
+ *
+ * undici 还会把底层 errno 藏在 `cause` 里(`TypeError: fetch failed` → cause
+ * `SocketError: other side closed` / `read ECONNRESET`),只看顶层必然漏,故沿 cause 链找。
+ */
+const STREAM_BREAK_CODES = new Set([
+    'ERR_STREAM_PREMATURE_CLOSE',
+    'ERR_STREAM_DESTROYED',
+    'ERR_STREAM_UNABLE_TO_PIPE',
+    'ERR_HTTP2_STREAM_CANCEL',
+    'UND_ERR_SOCKET',
+    'ECONNRESET',
+    'ECONNABORTED',
+    'EPIPE',
+    'ETIMEDOUT',
+    'ERR_SOCKET_CONNECTION_TIMEOUT',
+]);
+const STREAM_BREAK_MESSAGE = /premature close|other side closed|socket hang up|\bterminated\b|stream (?:closed|ended) (?:prematurely|unexpectedly)|econnreset|econnaborted/i;
+/**
+ * 「连接层」可重试 errno。与 STREAM_BREAK_CODES 的区别:这些在**建连/发请求**阶段就失败
+ * (DNS 解析、拒绝连接、路由不可达、连接超时),压根没有响应流可言,但处置一样 —— 重试。
+ * 旧实现只在顶层 `err.code` 上查,而 undici 把 errno 埋在 cause 里,永远查不到。
+ */
+const RETRYABLE_ERRNO = new Set([
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'ECONNREFUSED',
+    'EPIPE',
+    'ECONNABORTED',
+    'ENETUNREACH',
+    'EHOSTUNREACH',
+    'ERR_SOCKET_CONNECTION_TIMEOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_SOCKET',
+]);
+/** 证书 / TLS 协议不匹配:重试必然再错,判死以免白等退避。 */
+const FATAL_TRANSPORT_CODE = /^(?:ERR_SSL|ERR_TLS|ERR_OSSL|UNABLE_TO_VERIFY|DEPTH_ZERO|SELF_SIGNED|CERT_|EPROTO)/;
+const FATAL_TRANSPORT_MESSAGE = /certificate|self[- ]signed|\bEPROTO\b|wrong version number|unsupported protocol/i;
+/**
+ * 沿错误自身与 cause 链(≤3 层)收集每层的 code / message。
+ *
+ * 为什么必须看 cause:undici 把底层 errno 挂在 cause 上(`TypeError: fetch failed` →
+ * cause `Error: read ECONNRESET`,code 在 cause 里),openai SDK 又把那次 fetch 失败再包一层
+ * `APIConnectionError({ cause })`(`core.mjs` 的 catch 分支)。只看顶层 `err.code` / `err.message`
+ * 永远是 undefined / 'Connection error.' —— 这正是这类故障长期无法被识别、无法重试的根因。
+ */
+function causeChainFrames(err) {
+    const frames = [];
+    let cur = err;
+    for (let depth = 0; depth <= 3; depth++) {
+        if (!cur || typeof cur !== 'object')
+            break;
+        const e = cur;
+        frames.push({
+            code: typeof e.code === 'string' ? e.code : undefined,
+            message: typeof e.message === 'string' ? e.message : undefined,
+        });
+        cur = e.cause;
+    }
+    return frames;
+}
+/** 错误链(含 cause)上是否存在「连接被掐断」的信号。 */
+function hasStreamBreakSignal(err) {
+    return causeChainFrames(err).some((f) => (!!f.code && STREAM_BREAK_CODES.has(f.code)) || (!!f.message && STREAM_BREAK_MESSAGE.test(f.message)));
+}
+/**
+ * 判定「服务端在响应流中途报错 / 流被中途掐断」——HTTP 层已建连并开始流式返回(状态码 200),
+ * 失败发生在流内部。两条命中路径:
+ *
+ * ① **SSE error chunk**:SDK 的两条流内抛错路径(node_modules/openai/streaming.mjs:41 / :57)
+ *    都构造 `new APIError(undefined, data.error, …)`:status 为 undefined,code/message 取自
+ *    负载,例如 DashScope 的 `ClientError` + `Backend buffer overflow.`。
+ * ② **传输层断流**:见 hasStreamBreakSignal;或 provider 显式打了标记
+ *    (`providers/anthropic.ts` 的 SSE `event: error`,由 markStreamInterrupted 标注)。
+ *
+ * 为什么要单独识别:isRetryableError 只认 status(429 / 5xx)、Node errno 白名单与 timeout 字样,
+ * 这三类都不沾 → 被当成「不可重试的客户端请求错」一次即抛,整轮 run 直接终止。但它们的真实语义
+ * 是「服务端/链路在生成到一半时挂了」,属瞬时故障,重试是正确处置(已实测同一会话更大 prompt 可成功)。
+ *
+ * 只认 APIError 本身,不认子类:APIConnectionError / APIConnectionTimeoutError 是**建连阶段**
+ * 失败,归 isRetryableError 的构造器名分支(它有 10 次 HTTP 层预算,更合适);而 APIUserAbortError
+ * 是用户中断,绝不能重试。
+ * 判据用构造器名而非 instanceof:同进程若存在 openai 的多份模块实例(ESM/CJS 混载),
+ * instanceof 会失配。
+ *
+ * 注意:这里只判定「类别」;能否真的重试还要看调用方的「本次尝试零产出」前提。
+ */
+export function isStreamInterruptedError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    if (e.name === 'AbortError' || e.name === 'APIUserAbortError')
+        return false;
+    if (isMarkedStreamInterrupted(err))
+        return true;
+    // 有 HTTP 状态码 = 建连阶段失败,交由 isRetryableError 既有规则处理。
+    if (typeof e.status === 'number')
+        return false;
+    if ((e.constructor?.name ?? '') === 'APIError')
+        return true;
+    return hasStreamBreakSignal(err);
+}
 /**
  * 判定一次失败是否是「请求上下文超长」(后端实测拒绝了我们的 prompt)。
  *
@@ -187,6 +309,13 @@ export function classifyChatError(msg) {
     if (/\benotfound\b|\beconnrefused\b|\beai_again\b|getaddrinfo|fetch failed|network error|certificate/.test(m) ||
         /无法连接|网络(?:错误|异常|不可用)|域名解析/.test(msg))
         return 'network';
+    // 服务端在生成中途故障(流内报错,无 HTTP 状态码):推理后端崩溃 / 网关缓冲溢出等瞬时故障。
+    // 已实测 DashScope compatible-mode 会回 `code=ClientError` + `message="Backend buffer overflow."`。
+    // 走到这里说明重试预算已用尽(或已有半截输出不能重试),给「直接重发」的引导而非裸报错。
+    if (/backend\s+buffer|buffer\s+overflow|engine\s+(?:crash|error|failed|aborted)|internal\s+server\s+error|server\s+(?:overloaded|busy|unavailable)/.test(m) ||
+        /premature close|other side closed/.test(m) ||
+        /后端.{0,10}(?:溢出|崩溃|异常)|服务(?:端|器)(?:内部)?(?:错误|异常|繁忙|不可用)/.test(msg))
+        return 'server';
     return null;
 }
 /** 从 OpenAI APIError.headers 解析 Retry-After(秒);不支持或缺失返回 undefined。封顶 RETRY_MAX_MS。 */
@@ -339,7 +468,9 @@ function retryErrorCode(error) {
     const value = error;
     if (typeof value.status === 'number')
         return `HTTP_${value.status}`;
-    return value.code ?? value.name ?? 'RETRYABLE_ERROR';
+    // 优先构造器名:SDK 的 APIError 家族 `err.name` 恒为 'Error'(无信息量),
+    // 构造器名才区分得出是 APIConnectionError(建连失败)还是流内 APIError。
+    return value.code ?? value.constructor?.name ?? value.name ?? 'RETRYABLE_ERROR';
 }
 /** Bind chat dispatch, retries and built-in providers to one explicit runtime. */
 export function createChatTransport(runtime) {
@@ -352,23 +483,50 @@ toolsOverride) {
 }
 async function chatWithRuntime(runtime, messages, handlers, signal, toolsOverride) {
     let lastErr;
+    // 本次尝试是否已向调用方产出过内容(可见文本 / 工具名)。用于判断「流中途故障可否安全重试」:
+    // 重试会从请求头重放,已流出并显示在内容区的半截文本会再写一遍(history 因异常未落,倒是不脏)。
+    // 用包装 handler 而非改各 provider 内部,OpenAI / Anthropic 两条路径统一生效。
+    let producedOutput = false;
+    const guardedHandlers = {
+        ...handlers,
+        onText: (text) => {
+            producedOutput = true;
+            handlers.onText?.(text);
+        },
+        onToolCall: (name) => {
+            producedOutput = true;
+            handlers.onToolCall?.(name);
+        },
+    };
+    // 流中途故障用独立计数,避免与 HTTP 层共享 10 次预算(理由见 STREAM_RETRY_MAX_ATTEMPTS)。
+    let streamRetries = 0;
     for (let attempt = 1; attempt <= RETRY_MAX_ATTEMPTS; attempt++) {
         if (signal?.aborted) {
             throw new DOMException('This operation was aborted', 'AbortError');
         }
+        producedOutput = false;
         try {
             const provider = getModelProvider(runtime.config.provider);
             if (!provider) {
                 // 未注册的 provider:给出可用名单,避免悄悄落到错误实现。
                 throw new Error(`未知的 LLM provider "${runtime.config.provider}";已注册:${listModelProviders().join(', ') || '(空)'}`);
             }
-            return await provider.chatOnce(messages, handlers, signal, toolsOverride, runtime);
+            return await provider.chatOnce(messages, guardedHandlers, signal, toolsOverride, runtime);
         }
         catch (err) {
             lastErr = err;
-            if (attempt >= RETRY_MAX_ATTEMPTS || !isRetryableError(err, signal)) {
+            // 流中途故障的额外可重试窗口:仅当本次尝试零产出(否则重试会重放半截文本)、用户没有中断、
+            // 且未超它的独立预算。HTTP 层规则(isRetryableError)保持原样,两条判定取并集。
+            // 用户中断必须显式排除:undici 在 abort 时也可能抛「连接被掐断」形态的错,只看错误本身会误判。
+            const streamRetryable = !signal?.aborted &&
+                isStreamInterruptedError(err) &&
+                !producedOutput &&
+                streamRetries < STREAM_RETRY_MAX_ATTEMPTS;
+            if (attempt >= RETRY_MAX_ATTEMPTS || (!isRetryableError(err, signal) && !streamRetryable)) {
                 throw err;
             }
+            if (streamRetryable)
+                streamRetries++;
             const wait = computeBackoff(attempt, getRetryAfterMs(err));
             const retry = {
                 attempt,

package/dist/llm/providers/anthropic.js

@@ -1,4 +1,5 @@
 import { config, getActiveModel } from '../../config/index.js';
+import { markStreamInterrupted } from '../stream-interrupt.js';
 let fetchImplOverride = null;
 /** 仅供单测注入；生产路径使用 Node 18+ 全局 fetch。 */
 export function __setAnthropicFetchImpl(impl) {
@@ -292,6 +293,11 @@ export async function anthropicChatOnce(messages, handlers, signal, tools, runti
             const error = event.error;
             const thrown = new Error(typeof error?.message === 'string' ? error.message : 'Anthropic stream error');
             thrown.name = typeof error?.type === 'string' ? error.type : 'AnthropicStreamError';
+            // 打「流中途中断」标记:HTTP 层已 200 建连说明请求本身被接受了,流内报错必然是服务端侧
+            // (overloaded_error / api_error 等瞬时故障)。没有这个标记,它就是个无 status 的普通
+            // Error → isRetryableError 一条都不命中 → 整轮 run 直接终止、一次都不重试。
+            // 真正的重试门槛由 chatWithRuntime 的「本次尝试零产出」前提把关。
+            markStreamInterrupted(thrown);
             throw thrown;
         }
         if (type === 'message_start') {

package/dist/llm/stream-interrupt.js

@@ -0,0 +1,24 @@
+/**
+ * 「流中途被打断」的显式标记。
+ *
+ * 为什么需要它:能否安全重试取决于「错误是否发生在响应流**里面**」(HTTP 层已 200 建连),
+ * 而这类错误的判定只能由**抛错方**知道 —— OpenAI 兼容路径是 SDK 造的 status-less `APIError`,
+ * Anthropic 路径是 SSE `event: error`(一个 name 被设成供应商错误类型的普通 Error)。
+ * 与其在 transport 层猜 vendor 的错误名,不如让 provider 在抛错时打标。
+ *
+ * 独立成 leaf 模块(零 import):`llm/index.ts` 与 `llm/providers/*.ts` 都要用它,
+ * 而 providers 只对 index 做 type-only import(见 provider.ts 头注),放 index 会成环。
+ *
+ * 只标记「错误类别」,不代表可以无条件重试:调用方仍必须叠加「本次尝试零产出」前提
+ * (见 chatWithRuntime 的 producedOutput),否则重试会在内容区重放半截文本。
+ */
+const interrupted = new WeakSet();
+/** 由 provider 在「响应流内部报错」时调用,标记该错误为可重试的流中断。 */
+export function markStreamInterrupted(err) {
+    if (err && typeof err === 'object')
+        interrupted.add(err);
+}
+/** 该错误是否被标记为流中途中断。 */
+export function isMarkedStreamInterrupted(err) {
+    return !!err && typeof err === 'object' && interrupted.has(err);
+}

package/dist/repl/commands.js

@@ -148,6 +148,7 @@ export const LLM_ERROR_HINT_KEYS = {
     timeout: 'repl.llmTimeoutError',
     network: 'repl.llmNetworkError',
     context: 'repl.llmContextError',
+    server: 'repl.llmServerError',
 };
 /** /help 的分组:按使用场景归组,组内保持菜单树顺序。未列入的顶层命令兜底进「其他」。 */
 export const HELP_GROUPS = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 25 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {