minimal-agent 0.13.0 → 0.14.0

package/src/llm/client.js

@@ -26,7 +26,9 @@
 import { dlog } from '../utils/debugLog.js';
 import { buildOpenAIRequest, createOpenAISSEParser, isImageInputRejected, isMaxTokensRejected, isPromptCacheKeyRejected, isResponseFormatUnsupported, } from './providers/openaiFormat.js';
 import { promptMaterialHash, shortCacheScope } from './promptCache.js';
-import { buildAnthropicRequest, createAnthropicSSEParser } from './providers/anthropicFormat.js';
+import { buildAnthropicRequest, createAnthropicSSEParser, } from './providers/anthropicFormat.js';
+import { chatGateway } from './gatewayClient.js';
+import { prepareMessagesForProvider } from './messageProvenance.js';
 /**
  * 记住"这个 baseURL::model 不支持 response_format.json_schema"，避免每次都先撞 400。
  * 单进程内有效；每个 -p 子进程是全新进程 → 首个结构化调用吃一次 400 再退化，可接受。
@@ -133,7 +135,10 @@ export function _nextRetryDelayMs(retryAfterMs) {
 }
 /** 可重试的 HTTP 状态码。4xx 除 408/425/429 外不重试（重试无意义）。 */
 function isRetryableStatus(status) {
-    return status === 408 || status === 425 || status === 429 || (status >= 500 && status < 600);
+    return (status === 408 ||
+        status === 425 ||
+        status === 429 ||
+        (status >= 500 && status < 600));
 }
 /** 鉴权类错误：明确告诉用户"key 失效/过期/无权访问"，避免重试无意义。 */
 function isClientAuthError(status) {
@@ -212,7 +217,9 @@ export function createIdleWatchdog(userSignal, timeoutMs = IDLE_TIMEOUT_MS) {
     };
     arm();
     return {
-        signal: userSignal ? AbortSignal.any([userSignal, ctrl.signal]) : ctrl.signal,
+        signal: userSignal
+            ? AbortSignal.any([userSignal, ctrl.signal])
+            : ctrl.signal,
         kick: arm,
         dispose: () => {
             if (timer)
@@ -240,8 +247,34 @@ export function createIdleWatchdog(userSignal, timeoutMs = IDLE_TIMEOUT_MS) {
  * }
  * ```
  */
+export function createModelProvider(provider) {
+    return {
+        source: provider.source === 'gateway' ? 'gateway' : 'local',
+        descriptor: provider,
+        stream: (request) => {
+            if (provider.source === 'gateway') {
+                if (request.responseFormat &&
+                    provider.gatewayCapabilities?.structuredOutput === false) {
+                    throw new Error('当前在线模型不支持结构化输出');
+                }
+                return chatGateway({
+                    provider: provider,
+                    messages: request.messages,
+                    tools: request.tools,
+                    signal: request.signal,
+                    conversationMode: request.conversationMode,
+                    responseFormat: request.responseFormat,
+                });
+            }
+            return streamLocal({ ...request, provider: provider });
+        },
+    };
+}
 export async function* chat(args) {
-    const { provider, messages, tools, signal, responseFormat, promptCache } = args;
+    yield* createModelProvider(args.provider).stream(args);
+}
+async function* streamLocal(args) {
+    const { provider, messages, tools, signal, responseFormat, promptCache, conversationMode, cacheEdits, } = args;
     const format = provider.apiFormat === 'anthropic' ? 'anthropic' : 'openai';
     if (format === 'anthropic' && responseFormat) {
         throw new Error('output_schema 结构化输出目前不支持 Anthropic Messages 格式的 provider' +
@@ -251,17 +284,14 @@ export async function* chat(args) {
     // 过滤并清洁 messages 数组，剥离 timestamp, id, _ephemeral 等本地渲染元数据。
     // 两种格式共用同一份清洗后的内部形状——Anthropic 分支的翻译（system 摘除/
     // tool_calls→tool_use 等）在 buildAnthropicRequest 内部做，不在这里做。
-    let cleanedMessages = messages
-        .filter((m) => !(m.role === 'system' && m._ephemeral === true))
-        .map((m) => {
-        const { id, timestamp, attachments, browserReferences, display_metadata, ...rest } = m;
-        return rest;
-    });
+    let cleanedMessages = prepareMessagesForProvider(messages, conversationMode ?? 'private');
     const includeUsage = process.env.MINIMAL_AGENT_DISABLE_USAGE !== '1';
     const rfKey = `${provider.baseURL}::${provider.model}`;
     // OpenAI 分支专属的「就地退化」状态；Anthropic 无此概念，两个 flag 恒为 false，
     // 下面的退化 if 分支天然不会进入（不需要额外的 format 判断散落各处）。
-    let wantResponseFormat = format === 'openai' && responseFormat !== undefined && !rfUnsupported.has(rfKey);
+    let wantResponseFormat = format === 'openai' &&
+        responseFormat !== undefined &&
+        !rfUnsupported.has(rfKey);
     let wantMaxTokens = format === 'openai' &&
         typeof provider.maxTokens === 'number' &&
         provider.maxTokens > 0 &&
@@ -278,7 +308,12 @@ export async function* chat(args) {
         const textOnly = c.filter((p) => p.type === 'text');
         const newContent = textOnly.length > 0
             ? textOnly.map((p) => ({ type: 'text', text: p.text }))
-            : [{ type: 'text', text: '[图片内容未发送：当前模型不支持图片输入]' }];
+            : [
+                {
+                    type: 'text',
+                    text: '[图片内容未发送：当前模型不支持图片输入]',
+                },
+            ];
         return { ...m, content: newContent };
     });
     // 空闲 watchdog：每个 attempt 一只（重试前换新）；fetch 等待期自动计时，
@@ -286,7 +321,12 @@ export async function* chat(args) {
     let watchdog = createIdleWatchdog(signal);
     const postChat = () => {
         const req = format === 'anthropic'
-            ? buildAnthropicRequest({ provider, cleanedMessages, tools })
+            ? buildAnthropicRequest({
+                provider,
+                cleanedMessages,
+                tools,
+                ...(cacheEdits ? { cacheEdits } : {}),
+            })
             : buildOpenAIRequest({
                 provider,
                 cleanedMessages,
@@ -298,7 +338,12 @@ export async function* chat(args) {
                 withPromptCacheKey: wantPromptCacheKey,
                 responseFormat,
             });
-        return fetch(req.url, { method: 'POST', headers: req.headers, body: req.body, signal: watchdog.signal });
+        return fetch(req.url, {
+            method: 'POST',
+            headers: req.headers,
+            body: req.body,
+            signal: watchdog.signal,
+        });
     };
     const reqId = ++reqCounter;
     dlog('llm', `req#${reqId} POST →`, {
@@ -315,7 +360,9 @@ export async function* chat(args) {
             .map((message) => message.content)),
         toolSchemaHash: promptMaterialHash(tools.map((tool) => ({
             name: tool.name,
-            description: typeof tool.description === 'function' ? tool.description() : tool.description,
+            description: typeof tool.description === 'function'
+                ? tool.description()
+                : tool.description,
             parameters: tool.parameters,
         }))),
     });
@@ -386,7 +433,8 @@ export async function* chat(args) {
             errText = await resp.text().catch(() => '');
         }
         // 退化①：response_format.json_schema 不支持
-        if (wantResponseFormat && isResponseFormatUnsupported(resp.status, errText)) {
+        if (wantResponseFormat &&
+            isResponseFormatUnsupported(resp.status, errText)) {
             // 记住该 model 不支持，单进程内后续结构化调用直接跳过 response_format（不再撞 400）。
             rfUnsupported.add(rfKey);
             console.warn(`[minimal-agent] provider model "${provider.model}" 不支持 response_format.json_schema，` +
@@ -399,7 +447,8 @@ export async function* chat(args) {
             }
             catch (e) {
                 // 退化二次 fetch 也网络错：把错误外提到外层重试循环
-                if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) === 'break')
+                if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) ===
+                    'break')
                     break;
                 continue;
             }
@@ -419,7 +468,8 @@ export async function* chat(args) {
                 watchdog.kick();
             }
             catch (e) {
-                if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) === 'break')
+                if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) ===
+                    'break')
                     break;
                 continue;
             }
@@ -432,9 +482,14 @@ export async function* chat(args) {
         if (!imagesStripped && isImageInputRejected(resp.status, errText)) {
             const hasImages = cleanedMessages.some((m) => {
                 const c = m.content;
-                return Array.isArray(c) && c.some((p) => p.type === 'image_url' || p.type === 'video_url');
+                return (Array.isArray(c) &&
+                    c.some((p) => p.type === 'image_url' || p.type === 'video_url'));
             });
             if (hasImages) {
+                if (args.visionPolicy === 'required') {
+                    throw new Error(`当前模型拒绝了本轮必需的图片输入，已停止而未删除图片重试。` +
+                        `请改用支持视觉的模型或检查模型配置。Provider 返回：${errText.slice(0, 500)}`);
+                }
                 console.warn(`[minimal-agent] provider model "${provider.model}" 不支持图片输入，` +
                     `已剥离图片重发（仅保留文本内容）。如该模型实际支持视觉，请在模型设置中确认。`);
                 cleanedMessages = stripImagesFromMessages(cleanedMessages);
@@ -444,7 +499,8 @@ export async function* chat(args) {
                     watchdog.kick();
                 }
                 catch (e) {
-                    if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) === 'break')
+                    if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) ===
+                        'break')
                         break;
                     continue;
                 }
@@ -486,7 +542,9 @@ export async function* chat(args) {
     const decoder = new TextDecoder();
     /** 临时缓冲：HTTP chunk 不一定按行切，要自己拼 */
     let buffer = '';
-    const parser = format === 'anthropic' ? createAnthropicSSEParser() : createOpenAISSEParser();
+    const parser = format === 'anthropic'
+        ? createAnthropicSSEParser()
+        : createOpenAISSEParser();
     try {
         while (true) {
             // 每次 read 前检查 abort：用户按 ESC/Ctrl+C 时 signal.aborted 为 true。

package/src/llm/client.ts

@@ -24,7 +24,14 @@
  * ============================================================
  */
 
-import type { LlmStreamEvent, Message, Provider, Tool } from '../types.js';
+import type {
+  GatewayProvider,
+  LlmStreamEvent,
+  LocalProvider,
+  Message,
+  Provider,
+  Tool,
+} from '../types.js';
 import { dlog } from '../utils/debugLog.js';
 import {
   buildOpenAIRequest,
@@ -35,7 +42,13 @@ import {
   isResponseFormatUnsupported,
 } from './providers/openaiFormat.js';
 import { promptMaterialHash, shortCacheScope } from './promptCache.js';
-import { buildAnthropicRequest, createAnthropicSSEParser } from './providers/anthropicFormat.js';
+import {
+  buildAnthropicRequest,
+  createAnthropicSSEParser,
+} from './providers/anthropicFormat.js';
+import { chatGateway } from './gatewayClient.js';
+import type { ModelProvider } from './modelProvider.js';
+import { prepareMessagesForProvider } from './messageProvenance.js';
 
 /**
  * 记住"这个 baseURL::model 不支持 response_format.json_schema"，避免每次都先撞 400。
@@ -132,7 +145,8 @@ let backoffTier = 0;
  * retryAfterMs 有值（429 的 Retry-After 头）时听服务器的（仍封顶 60s、仍抬档）。
  */
 function nextRetryDelayMs(retryAfterMs?: number): number {
-  const tierMs = BACKOFF_TIERS_MS[Math.min(backoffTier, BACKOFF_TIERS_MS.length - 1)];
+  const tierMs =
+    BACKOFF_TIERS_MS[Math.min(backoffTier, BACKOFF_TIERS_MS.length - 1)];
   backoffTier = Math.min(backoffTier + 1, BACKOFF_TIERS_MS.length - 1);
   if (retryAfterMs !== undefined) return Math.min(retryAfterMs, 60_000);
   const jittered = tierMs * (0.85 + Math.random() * 0.3);
@@ -158,7 +172,12 @@ export function _nextRetryDelayMs(retryAfterMs?: number): number {
 
 /** 可重试的 HTTP 状态码。4xx 除 408/425/429 外不重试（重试无意义）。 */
 function isRetryableStatus(status: number): boolean {
-  return status === 408 || status === 425 || status === 429 || (status >= 500 && status < 600);
+  return (
+    status === 408 ||
+    status === 425 ||
+    status === 429 ||
+    (status >= 500 && status < 600)
+  );
 }
 
 /** 鉴权类错误：明确告诉用户"key 失效/过期/无权访问"，避免重试无意义。 */
@@ -253,7 +272,9 @@ export function createIdleWatchdog(
   };
   arm();
   return {
-    signal: userSignal ? AbortSignal.any([userSignal, ctrl.signal]) : ctrl.signal,
+    signal: userSignal
+      ? AbortSignal.any([userSignal, ctrl.signal])
+      : ctrl.signal,
     kick: arm,
     dispose: () => {
       if (timer) clearTimeout(timer);
@@ -281,8 +302,42 @@ export function createIdleWatchdog(
  * }
  * ```
  */
-export async function* chat(args: {
-  provider: Provider;
+export function createModelProvider(provider: Provider): ModelProvider {
+  return {
+    source: provider.source === 'gateway' ? 'gateway' : 'local',
+    descriptor: provider,
+    stream: (request) => {
+      if (provider.source === 'gateway') {
+        if (
+          request.responseFormat &&
+          provider.gatewayCapabilities?.structuredOutput === false
+        ) {
+          throw new Error('当前在线模型不支持结构化输出');
+        }
+        return chatGateway({
+          provider: provider as GatewayProvider,
+          messages: request.messages,
+          tools: request.tools,
+          signal: request.signal,
+          conversationMode: request.conversationMode,
+          responseFormat: request.responseFormat,
+        });
+      }
+      return streamLocal({ ...request, provider: provider as LocalProvider });
+    },
+  };
+}
+
+export async function* chat(
+  args: Omit<Parameters<typeof streamLocal>[0], 'provider'> & {
+    provider: Provider;
+  },
+): AsyncGenerator<LlmStreamEvent, void, void> {
+  yield* createModelProvider(args.provider).stream(args);
+}
+
+async function* streamLocal(args: {
+  provider: LocalProvider;
   messages: Message[];
   tools: Tool[];
   signal?: AbortSignal;
@@ -292,12 +347,36 @@ export async function* chat(args: {
    *  传了会在发请求前直接抛错，不浪费一次网络往返。*/
   responseFormat?: {
     type: 'json_schema';
-    json_schema: { name: string; schema: Record<string, unknown>; strict?: boolean };
+    json_schema: {
+      name: string;
+      schema: Record<string, unknown>;
+      strict?: boolean;
+    };
   };
   promptCache?: import('../types.js').PromptCacheContext;
+  /** 当前调用所在会话模式；群聊下未标注的旧历史按私聊数据处理。 */
+  conversationMode?: import('../runtime/agentRuntimeContext.js').ConversationMode;
+  /**
+   * cache_edits 式回收状态（Anthropic 格式 + provider.cacheEdits 开启时由 loop 传入）。
+   * 传入后 buildAnthropicRequest 会随请求发送删除指令并维护 pinned/pendingNew——
+   * 该状态有跨轮生命周期（pinned 每轮重发），调用方必须传同一份会话级对象，
+   * 并在 compact 后调 resetCacheEdits。OpenAI 格式忽略此参数。
+   */
+  cacheEdits?: import('../types.js').CacheEditsState;
+  visionPolicy?: 'required' | 'optional-history';
 }): AsyncGenerator<LlmStreamEvent, void, void> {
-  const { provider, messages, tools, signal, responseFormat, promptCache } = args;
-  const format: 'openai' | 'anthropic' = provider.apiFormat === 'anthropic' ? 'anthropic' : 'openai';
+  const {
+    provider,
+    messages,
+    tools,
+    signal,
+    responseFormat,
+    promptCache,
+    conversationMode,
+    cacheEdits,
+  } = args;
+  const format: 'openai' | 'anthropic' =
+    provider.apiFormat === 'anthropic' ? 'anthropic' : 'openai';
 
   if (format === 'anthropic' && responseFormat) {
     throw new Error(
@@ -310,12 +389,10 @@ export async function* chat(args: {
   // 过滤并清洁 messages 数组，剥离 timestamp, id, _ephemeral 等本地渲染元数据。
   // 两种格式共用同一份清洗后的内部形状——Anthropic 分支的翻译（system 摘除/
   // tool_calls→tool_use 等）在 buildAnthropicRequest 内部做，不在这里做。
-  let cleanedMessages: Message[] = messages
-    .filter((m) => !(m.role === 'system' && (m as { _ephemeral?: boolean })._ephemeral === true))
-    .map((m) => {
-      const { id, timestamp, attachments, browserReferences, display_metadata, ...rest } = m as any;
-      return rest;
-    });
+  let cleanedMessages: Message[] = prepareMessagesForProvider(
+    messages,
+    conversationMode ?? 'private',
+  );
 
   const includeUsage = process.env.MINIMAL_AGENT_DISABLE_USAGE !== '1';
   const rfKey = `${provider.baseURL}::${provider.model}`;
@@ -323,7 +400,9 @@ export async function* chat(args: {
   // OpenAI 分支专属的「就地退化」状态；Anthropic 无此概念，两个 flag 恒为 false，
   // 下面的退化 if 分支天然不会进入（不需要额外的 format 判断散落各处）。
   let wantResponseFormat =
-    format === 'openai' && responseFormat !== undefined && !rfUnsupported.has(rfKey);
+    format === 'openai' &&
+    responseFormat !== undefined &&
+    !rfUnsupported.has(rfKey);
   let wantMaxTokens =
     format === 'openai' &&
     typeof provider.maxTokens === 'number' &&
@@ -341,9 +420,15 @@ export async function* chat(args: {
       const c = (m as { content?: unknown }).content;
       if (!Array.isArray(c)) return m;
       const textOnly = c.filter((p: any) => p.type === 'text');
-      const newContent = textOnly.length > 0
-        ? textOnly.map((p: any) => ({ type: 'text' as const, text: p.text }))
-        : [{ type: 'text' as const, text: '[图片内容未发送：当前模型不支持图片输入]' }];
+      const newContent =
+        textOnly.length > 0
+          ? textOnly.map((p: any) => ({ type: 'text' as const, text: p.text }))
+          : [
+              {
+                type: 'text' as const,
+                text: '[图片内容未发送：当前模型不支持图片输入]',
+              },
+            ];
       return { ...m, content: newContent } as Message;
     });
 
@@ -354,7 +439,12 @@ export async function* chat(args: {
   const postChat = (): Promise<Response> => {
     const req =
       format === 'anthropic'
-        ? buildAnthropicRequest({ provider, cleanedMessages, tools })
+        ? buildAnthropicRequest({
+            provider,
+            cleanedMessages,
+            tools,
+            ...(cacheEdits ? { cacheEdits } : {}),
+          })
         : buildOpenAIRequest({
             provider,
             cleanedMessages,
@@ -366,7 +456,12 @@ export async function* chat(args: {
             withPromptCacheKey: wantPromptCacheKey,
             responseFormat,
           });
-    return fetch(req.url, { method: 'POST', headers: req.headers, body: req.body, signal: watchdog.signal });
+    return fetch(req.url, {
+      method: 'POST',
+      headers: req.headers,
+      body: req.body,
+      signal: watchdog.signal,
+    });
   };
 
   const reqId = ++reqCounter;
@@ -387,7 +482,10 @@ export async function* chat(args: {
     toolSchemaHash: promptMaterialHash(
       tools.map((tool) => ({
         name: tool.name,
-        description: typeof tool.description === 'function' ? tool.description() : tool.description,
+        description:
+          typeof tool.description === 'function'
+            ? tool.description()
+            : tool.description,
         parameters: tool.parameters,
       })),
     ),
@@ -409,11 +507,16 @@ export async function* chat(args: {
   ): Promise<'break' | 'retry'> => {
     if (signal?.aborted) throw makeAbortError();
     const err = e as Error;
-    lastErr = new Error(`LLM 网络错误 [${err.name ?? 'NetworkError'}]：${err.message}`);
+    lastErr = new Error(
+      `LLM 网络错误 [${err.name ?? 'NetworkError'}]：${err.message}`,
+    );
     dlog('llm', `req#${reqId} attempt ${attempt} ${label}:`, err.message);
     if (attempt >= DEFAULT_RETRY.maxAttempts) return 'break';
     const delay = nextRetryDelayMs();
-    dlog('llm', `req#${reqId} retry in ${delay}ms (attempt ${attempt + 1}/${DEFAULT_RETRY.maxAttempts}, tier=${backoffTier})`);
+    dlog(
+      'llm',
+      `req#${reqId} retry in ${delay}ms (attempt ${attempt + 1}/${DEFAULT_RETRY.maxAttempts}, tier=${backoffTier})`,
+    );
     await sleep(delay, signal);
     return 'retry';
   };
@@ -435,7 +538,10 @@ export async function* chat(args: {
       // 1) 用户主动 abort → handleNetworkError 里立刻抛
       // 2) AbortSignal.timeout 触发的超时（Fetch 空闲超时还没回）
       // 3) 其它网络错误（ECONNRESET / fetch failed / DNS 失败）→ 全部按"可重试"处理
-      if ((await handleNetworkError(e, attempt, 'failed (network)')) === 'break') break;
+      if (
+        (await handleNetworkError(e, attempt, 'failed (network)')) === 'break'
+      )
+        break;
       continue;
     }
 
@@ -456,7 +562,14 @@ export async function* chat(args: {
         resp = await postChat();
         watchdog.kick();
       } catch (e) {
-        if ((await handleNetworkError(e, attempt, 'cache-key fallback fetch failed')) === 'break') break;
+        if (
+          (await handleNetworkError(
+            e,
+            attempt,
+            'cache-key fallback fetch failed',
+          )) === 'break'
+        )
+          break;
         continue;
       }
       if (resp.ok) break;
@@ -464,7 +577,10 @@ export async function* chat(args: {
     }
 
     // 退化①：response_format.json_schema 不支持
-    if (wantResponseFormat && isResponseFormatUnsupported(resp.status, errText)) {
+    if (
+      wantResponseFormat &&
+      isResponseFormatUnsupported(resp.status, errText)
+    ) {
       // 记住该 model 不支持，单进程内后续结构化调用直接跳过 response_format（不再撞 400）。
       rfUnsupported.add(rfKey);
       console.warn(
@@ -478,7 +594,11 @@ export async function* chat(args: {
         watchdog.kick();
       } catch (e) {
         // 退化二次 fetch 也网络错：把错误外提到外层重试循环
-        if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) === 'break') break;
+        if (
+          (await handleNetworkError(e, attempt, 'fallback fetch failed')) ===
+          'break'
+        )
+          break;
         continue;
       }
       if (resp.ok) break;
@@ -498,7 +618,11 @@ export async function* chat(args: {
         resp = await postChat();
         watchdog.kick();
       } catch (e) {
-        if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) === 'break') break;
+        if (
+          (await handleNetworkError(e, attempt, 'fallback fetch failed')) ===
+          'break'
+        )
+          break;
         continue;
       }
       if (resp.ok) break;
@@ -510,9 +634,18 @@ export async function* chat(args: {
     if (!imagesStripped && isImageInputRejected(resp.status, errText)) {
       const hasImages = cleanedMessages.some((m) => {
         const c = (m as { content?: unknown }).content;
-        return Array.isArray(c) && c.some((p: any) => p.type === 'image_url' || p.type === 'video_url');
+        return (
+          Array.isArray(c) &&
+          c.some((p: any) => p.type === 'image_url' || p.type === 'video_url')
+        );
       });
       if (hasImages) {
+        if (args.visionPolicy === 'required') {
+          throw new Error(
+            `当前模型拒绝了本轮必需的图片输入，已停止而未删除图片重试。` +
+              `请改用支持视觉的模型或检查模型配置。Provider 返回：${errText.slice(0, 500)}`,
+          );
+        }
         console.warn(
           `[minimal-agent] provider model "${provider.model}" 不支持图片输入，` +
             `已剥离图片重发（仅保留文本内容）。如该模型实际支持视觉，请在模型设置中确认。`,
@@ -523,7 +656,11 @@ export async function* chat(args: {
           resp = await postChat();
           watchdog.kick();
         } catch (e) {
-          if ((await handleNetworkError(e, attempt, 'fallback fetch failed')) === 'break') break;
+          if (
+            (await handleNetworkError(e, attempt, 'fallback fetch failed')) ===
+            'break'
+          )
+            break;
           continue;
         }
         if (resp.ok) break;
@@ -538,13 +675,20 @@ export async function* chat(args: {
 
     // 5xx / 408 / 425 / 429：可重试
     lastErr = buildChatError(resp, errText);
-    dlog('llm', `req#${reqId} attempt ${attempt} failed [${resp.status}]:`, errText.slice(0, 200));
+    dlog(
+      'llm',
+      `req#${reqId} attempt ${attempt} failed [${resp.status}]:`,
+      errText.slice(0, 200),
+    );
     if (attempt >= DEFAULT_RETRY.maxAttempts) break;
 
     // 429 优先用 Retry-After 头，否则走自适应档位退避
     const retryAfterMs = parseRetryAfter(resp);
     const delay = nextRetryDelayMs(retryAfterMs);
-    dlog('llm', `req#${reqId} retry in ${delay}ms (attempt ${attempt + 1}/${DEFAULT_RETRY.maxAttempts}, tier=${backoffTier}, retryAfter=${retryAfterMs ?? 'tier'})`);
+    dlog(
+      'llm',
+      `req#${reqId} retry in ${delay}ms (attempt ${attempt + 1}/${DEFAULT_RETRY.maxAttempts}, tier=${backoffTier}, retryAfter=${retryAfterMs ?? 'tier'})`,
+    );
     await sleep(delay, signal);
   }
 
@@ -567,7 +711,10 @@ export async function* chat(args: {
   const decoder = new TextDecoder();
   /** 临时缓冲：HTTP chunk 不一定按行切，要自己拼 */
   let buffer = '';
-  const parser = format === 'anthropic' ? createAnthropicSSEParser() : createOpenAISSEParser();
+  const parser =
+    format === 'anthropic'
+      ? createAnthropicSSEParser()
+      : createOpenAISSEParser();
 
   try {
     while (true) {