minimal-agent 0.12.0 → 0.14.0

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) {

package/src/llm/gatewayClient.js

@@ -0,0 +1,201 @@
+import { randomUUID } from 'node:crypto';
+import { onlineToolCategory } from '../team/toolPolicy.js';
+import { prepareMessagesForProvider } from './messageProvenance.js';
+const IDLE_TIMEOUT_MS = Number(process.env.MINIMAL_AGENT_GATEWAY_IDLE_TIMEOUT_MS) > 0
+    ? Number(process.env.MINIMAL_AGENT_GATEWAY_IDLE_TIMEOUT_MS)
+    : 120_000;
+const DEADLINE_MS = Number(process.env.MINIMAL_AGENT_GATEWAY_DEADLINE_MS) > 0
+    ? Number(process.env.MINIMAL_AGENT_GATEWAY_DEADLINE_MS)
+    : 15 * 60_000;
+function gatewayTools(tools, allowedCategories) {
+    const allowed = allowedCategories ? new Set(allowedCategories) : null;
+    return tools.flatMap((tool) => {
+        const category = onlineToolCategory(tool.name);
+        if (!category || (allowed && !allowed.has(category)))
+            return [];
+        return [
+            {
+                type: 'function',
+                category,
+                function: {
+                    name: tool.name,
+                    ...(typeof tool.description === 'string'
+                        ? { description: tool.description }
+                        : {}),
+                    parameters: tool.parameters,
+                },
+            },
+        ];
+    });
+}
+function safeMessages(messages) {
+    return messages.map((message) => {
+        const { id: _id, timestamp: _timestamp, attachments: _attachments, browserReferences: _browserReferences, provenance: _provenance, display_metadata: _displayMetadata, tool_result_policy: _toolResultPolicy, _ephemeral, ...safe } = message;
+        return safe;
+    });
+}
+export class GatewayClientError extends Error {
+    code;
+    retryable;
+    constructor(code, retryable, message) {
+        // ⚠️ code 必须烘进 message 文本，不能只存在 .code 属性上：这个错误穿过
+        // loop.ts（只取 `.message`）→ 引擎 runner（转成纯字符串 blocker）→
+        // workflowController 的 isUsageLimitError 文本兜底，每一层都只剩字符串。
+        // 不烘进去，`isUsageLimitError` 的「同时认 code 与文本」这句注释就是一句空话——
+        // 之前正是这样：message 是纯人话（如「设备授权不存在或已过期」），从不包含
+        // DEVICE_REVOKED 之类的码，文本兜底恒为 false，usage_limited 在真实调用链上
+        // 从未被触发过。
+        super(`[${code}] ${message}`);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = 'GatewayClientError';
+    }
+}
+/**
+ * 服务端「配额/授权不给了」的错误码 —— **唯一真值**。
+ *
+ * 与 Goal 的 `usage_limited` 状态一一对应，也正是它与 `budget_limited` 的分界：
+ *  · `budget_limited` = **用户自己设的** token 额度用完 → 加预算即可继续。
+ *  · `usage_limited`  = **服务端配额/授权**不给了 → 加预算没用，要去解决授权或等周期重置。
+ * 两者都可 resume，但恢复动作完全不同，所以不能合并成一个状态。
+ *
+ * 服务端侧的产出点：`minimal-server/src/core/gatewayInference.ts`。
+ */
+const USAGE_LIMIT_CODES = new Set([
+    'REQUEST_QUOTA_EXHAUSTED',
+    'TOKEN_QUOTA_EXHAUSTED',
+    'CONCURRENCY_EXCEEDED',
+    'GRANT_REVOKED',
+    'DEVICE_REVOKED',
+]);
+/**
+ * 判断一个错误是不是「服务端配额/授权不给了」。
+ *
+ * ⚠️ 同时认 `GatewayClientError.code` 与错误文本：错误穿过 loop → 引擎 → 工作流
+ * 这几层之后往往只剩一个字符串（`llm_error` 事件带的是 message），
+ * 只认 code 会在真实链路上恒为 false。
+ */
+export function isUsageLimitError(error) {
+    if (error instanceof GatewayClientError)
+        return USAGE_LIMIT_CODES.has(error.code);
+    const text = error instanceof Error ? error.message : String(error ?? '');
+    return [...USAGE_LIMIT_CODES].some((code) => text.includes(code));
+}
+function combinedSignal(signal) {
+    const timeout = AbortSignal.timeout(DEADLINE_MS);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+async function readWithIdleTimeout(promise, signal) {
+    let timer;
+    let onAbort;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new GatewayClientError('PROVIDER_TIMEOUT', true, '在线模型流式响应超时')), IDLE_TIMEOUT_MS);
+                onAbort = () => reject(new DOMException('aborted', 'AbortError'));
+                signal.addEventListener('abort', onAbort, { once: true });
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}
+/** Gateway transport only. The caller retains the existing Agent/tool loop. */
+export async function* chatGateway(args) {
+    const { provider, messages, tools, signal: parentSignal, conversationMode, responseFormat, } = args;
+    if (!provider.gatewayUrl || !provider.gatewayToken || !provider.remoteModelId)
+        throw new GatewayClientError('DEVICE_REVOKED', false, '在线模型设备授权不存在或已过期');
+    const url = `${provider.gatewayUrl.replace(/\/$/, '')}/api/inference/chat/stream`;
+    const payload = JSON.stringify({
+        requestId: randomUUID(),
+        modelId: provider.remoteModelId,
+        // Keep the gateway payload limited to provider-facing protocol content.
+        // Session IDs, provenance metadata, display metadata, and local-only
+        // fields must never cross the remote inference boundary.
+        messages: safeMessages(prepareMessagesForProvider(messages, conversationMode ?? 'private')),
+        tools: gatewayTools(tools, provider.gatewayToolCategories ??
+            provider.gatewayDefaultToolCategories ??
+            provider.gatewayMaxToolCategories),
+        toolCategories: provider.gatewayToolCategories ?? provider.gatewayMaxToolCategories ?? [],
+        ...(responseFormat ? { responseFormat } : {}),
+    });
+    let activeReader;
+    const signal = combinedSignal(parentSignal);
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            signal,
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${provider.gatewayToken}`,
+            },
+            body: payload,
+        });
+        if (!response.ok) {
+            const body = (await response.json().catch(() => ({})));
+            // ⚠️ 服务端**明确表态**优先，状态码只是它没表态时的推断。
+            // 曾经写成 `body.retryable === true || status === 429 || …`：服务端发
+            // `{code:'TOKEN_QUOTA_EXHAUSTED', retryable:false}` 配 HTTP 429 时，
+            // `retryable:false` 被 `|| 429` 直接覆盖 —— 于是「额度用完了，别重试」
+            // 被当成限流反复重试，既拖慢失败反馈，也把真正的原因埋掉。
+            // 配额耗尽与限流是两回事：前者要去加额度，后者等一会儿就好。
+            const retryable = typeof body.retryable === 'boolean'
+                ? body.retryable
+                : response.status === 408 ||
+                    response.status === 425 ||
+                    response.status === 429 ||
+                    response.status >= 500;
+            throw new GatewayClientError(body.code ?? `HTTP_${response.status}`, retryable, body.error ?? `在线模型请求失败（${response.status}）`);
+        }
+        if (!response.body)
+            throw new GatewayClientError('PROVIDER_UNAVAILABLE', true, '在线模型未返回流式响应');
+        const reader = response.body.getReader();
+        activeReader = reader;
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const next = await readWithIdleTimeout(reader.read(), signal);
+            if (next.done)
+                break;
+            buffer += decoder.decode(next.value, { stream: true });
+            const frames = buffer.split(/\n\n/);
+            buffer = frames.pop() ?? '';
+            for (const frame of frames) {
+                const line = frame
+                    .split(/\r?\n/)
+                    .find((item) => item.startsWith('data:'));
+                if (!line)
+                    continue;
+                let event;
+                try {
+                    event = JSON.parse(line.slice(5).trim());
+                }
+                catch {
+                    continue;
+                }
+                if (event.type === 'error')
+                    throw new GatewayClientError(event.code ?? 'PROVIDER_UNAVAILABLE', event.retryable === true, event.message ?? '在线模型流式调用失败');
+                if (event.type === 'usage') {
+                    yield event;
+                    continue;
+                }
+                if (event.type === 'done')
+                    return;
+                yield event;
+            }
+        }
+        return;
+    }
+    finally {
+        // Release the response body on both normal `done` and error/abort paths.
+        // Without this, a completed stream can keep an HTTP connection/socket
+        // alive until the runtime's garbage collector notices it.
+        await activeReader?.cancel().catch(() => { });
+        activeReader = undefined;
+    }
+}