dsh-mobile-plugin 0.1.84 → 0.1.85

package/lib/mobile/events.js

@@ -24,6 +24,16 @@ const { sessionSignal: sharedSessionSignal } = require('../shared/session-signal
 
 const SSE_RETRY_MS = 3000;
 const DEDUP_WINDOW = 2048;
+/**
+ * 写缓冲的两道水位（字节），与 `mobile/stream.js` 同一口径。
+ *
+ * `res.write()` 在客户端读得慢时返回 false，字节留在 Node 的写队列里。设备级流以前
+ * 完全不看这个信号，于是「手机挂着一条流、网又慢」时帧无限堆积 —— 2026-10-17 真机
+ * 现场：堆快照里 17.6 万条 SSE 帧（466MB）挂在 `WriteWrap._chunks` 上，宿主 70 分钟
+ * 涨到 3.9G 被 OOM 杀掉。软水位只丢信号帧（幂等、下一条变更会再补），硬水位才收尾。
+ */
+const SSE_SHED_BUFFERED_BYTES = 4 * 1024 * 1024;
+const SSE_CLOSE_BUFFERED_BYTES = 16 * 1024 * 1024;
 /** 心跳帧间隔。App 用它判定「这条流真的还活着」，必须与 app 侧的 SIGNAL_HEARTBEAT_MS 一致。 */
 const HEARTBEAT_MS = 15_000;
 
@@ -56,12 +66,23 @@ function stableEventId(payload, frame) {
   return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
 }
 
+/**
+ * 写一条 SSE 记录。返回值与 `mobile/stream.js` 的同名函数一致：`ok:false` 表示该收尾，
+ * `shed:true` 表示这条帧被主动丢掉（写缓冲超过软水位）。
+ *
+ * 设备级流的帧全是「有东西变了」的信号，本来就幂等：丢掉一帧的代价是那一次刷新要等
+ * 下一次变更或 60s 兜底轮询；而堆在写缓冲里的代价是宿主 OOM（2026-10-17 现场：466MB
+ * 的 SSE 帧挂在 socket 写队列上，宿主撞 4GB 上限被杀）。所以软水位一律 shed。
+ */
 function writeSse(res, payload, frame) {
+  const buffered = Number(res.writableLength) || 0;
+  if (buffered > SSE_CLOSE_BUFFERED_BYTES) return { ok: false };
+  if (buffered > SSE_SHED_BUFFERED_BYTES) return { ok: true, shed: true };
   const id = stableEventId(payload, frame);
   const fields = [`retry: ${SSE_RETRY_MS}`];
   if (id) fields.push(`id: ${id}`);
   fields.push(`data: ${JSON.stringify(payload)}`, '', '');
-  try { res.write(`${fields.join('\n')}\n`); return true; } catch { return false; }
+  try { res.write(`${fields.join('\n')}\n`); return { ok: true }; } catch { return { ok: false }; }
 }
 
 async function* mergeHostAndMux(ctx, signal) {
@@ -153,13 +174,13 @@ async function handleDeviceStream(ctx, req, res) {
   /** 这条连接上真正写出去的帧数，只用于收尾日志（诊断「连着却一帧不发」）。 */
   let framesSent = 0;
   const writeFrame = (devicePayload) => {
-    const written = writeSse(res, {
+    const result = writeSse(res, {
       type: 'device/event',
       version: 1,
       payload: devicePayload,
     }, null);
-    if (written) framesSent += 1;
-    return written;
+    if (result.ok && !result.shed) framesSent += 1;
+    return result.ok;
   };
   /**
    * 自产的「清单变了」帧：镜像推送调度器每 500ms 比一次清单内容哈希，变了就在这里推给手机。
@@ -267,7 +288,9 @@ async function handleDeviceStream(ctx, req, res) {
         payload,
       };
       // Keep the existing device/event JSON envelope unchanged; SSE metadata is additive.
-      if (!writeSse(res, envelope, frame)) { clientGone = true; break; }
+      const sent = writeSse(res, envelope, frame);
+      if (sent.shed) continue;
+      if (!sent.ok) { clientGone = true; break; }
       framesSent += 1;
     }
     if (!clientGone) loopEnded = true;

package/lib/mobile/plugins.js

@@ -10,9 +10,9 @@
  *
  * 关键：这个宿主服务 **不在 apiProxy 上** —— 它是 Typert Remote 服务
  * （dsh-host-plugin-inventory 的 pluginInventory）。手机侧本来就能到它：
- * lib/mobile/sessions.js 早已用 `ctx.get('typertGateway')` 派发 commands.execute，
- * lib/mobile/references.js 通了 fileReferences / sessionReferenceResolver，
- * 这里照搬同一条路。
+ * lib/mobile/sessions.js 早已派发 commands.execute，lib/mobile/references.js 通了
+ * fileReferences / sessionReferenceResolver，这里照搬同一条路 —— 都经
+ * host-bridge/transport.js 的 `invoke`，由它统一补 Peer 身份与网关错误收敛。
  *
  * 接口（只转发宿主的部署快照，不做任何加工）：
  *  - GET /api/mobile/v1/plugins → pluginInventory.list
@@ -32,17 +32,13 @@
  */
 
 const { sendJson } = require('../shared/http-util');
+const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/transport.js');
 
 const PLUGIN_ID_MAX_CHARS = 200;      // entryId 长度上限
 const PLUGIN_NAME_MAX_CHARS = 300;    // moduleName 长度上限
 const PLUGIN_MAX_ITEMS = 500;         // 手机侧兜底上限（真实宿主是几十条）
 const PLUGIN_PHASES = new Set(['failed', 'pending', 'active', 'loading', 'unloading']);
 
-/** 宿主网关；宿主没组合 dsh-api-gateway 时返回 null，调用方回 503。 */
-function gatewayOf(ctx) {
-  return (ctx.get && ctx.get('typertGateway')) || null;
-}
-
 /** 网关缺失/命名空间缺失对客户端是同一件事：宿主这个能力没装。 */
 const UNAVAILABLE = Object.freeze({
   code: 'plugin-inventory-unavailable',
@@ -57,35 +53,33 @@ function errorText(error) {
 }
 
 /**
- * 经 typertGateway 取一次插件清单快照。
+ * 经网关取一次插件清单快照。
+ *
+ * 走 host-bridge/transport.js 的 `invoke`：Peer 身份、`gateway/` 前缀的缺失类错误
+ * 都在那里统一处理，这里只做本域的错误码翻译。**不能直接 `gateway.invoke`** ——
+ * 0.2.1 起网关要求每个请求自带 Peer，绕过去就是对 undefined 读 `.signal`，
+ * 手机端看到的是「插件清单加载失败」。
  *
  * @returns {Promise<{value?: unknown, error?: {code: string, message: string}}>}
  */
 async function callInventory(ctx) {
-  const gateway = gatewayOf(ctx);
-  if (!gateway) return { error: { ...UNAVAILABLE } };
-  let result;
-  try {
-    // 没有声明参数 → args 必须是空对象；这个方法也没声明 cancellation，不能多塞 signal。
-    result = await gateway.invoke({ namespace: 'pluginInventory', method: 'list', args: {} });
-  } catch (error) {
-    // 0.2.0 的网关错误码带 `gateway/` 前缀（dsh-api-gateway/src/types.ts:117-136）；
-    // 0.1.x 时期是不带前缀的。两种都认，否则「宿主没装这个服务」的降级分支形同虚设。
-    const raw = error && typeof error.code === 'string' ? error.code.replace(/^gateway\//, '') : ''
-    const code = raw === 'invocation-unavailable' || raw === 'service-unavailable' || raw === 'method-unavailable'
-      ? UNAVAILABLE.code
-      : 'plugin-inventory-error';
-    return { error: { code, message: errorText(error) } };
+  // 没有声明参数 → args 必须是空对象；这个方法也没声明 cancellation，不能多塞 signal。
+  const result = await invoke(ctx, 'pluginInventory', 'list', {});
+  if (result.error) {
+    // 宿主的服务/方法缺失由传输层收敛成同一个码：对客户端就是「这个能力没装」。
+    if (result.error.code === GATEWAY_UNAVAILABLE.code) return { error: { ...UNAVAILABLE } };
+    return { error: { code: 'plugin-inventory-error', message: errorText(result.error) } };
   }
+  const value = result.value;
   // decode 本体就是 { entries: […] }；另外两种形状只是容错，防宿主以后改成联合。
-  if (result && typeof result === 'object') {
-    if (result.ok === true) return { value: result.value };
-    if (result.ok === false) {
-      const raw = result.error && typeof result.error === 'object' ? result.error : {};
+  if (value && typeof value === 'object') {
+    if (value.ok === true) return { value: value.value };
+    if (value.ok === false) {
+      const raw = value.error && typeof value.error === 'object' ? value.error : {};
       const code = typeof raw.code === 'string' && raw.code ? raw.code : 'plugin-inventory-error';
       return { error: { code, message: errorText(raw) } };
     }
-    return { value: result };
+    return { value };
   }
   return { error: { code: 'plugin-inventory-error', message: '宿主插件清单返回了意外的结果' } };
 }

package/lib/mobile/references.js

@@ -11,8 +11,8 @@
  * 关键：这两个宿主服务 **不在 apiProxy 上** —— 它们是 Typert Remote 服务
  * （dsh-file-reference 的 fileReferences、dsh-session-reference 的
  * sessionReferenceResolver）。手机侧本来就能到它们：dsh-mobile-plugin 与宿主同进程，
- * lib/mobile/sessions.js 已经用 `ctx.get('typertGateway')` 派发过 commands.execute，
- * lib/mobile/plugins.js 也走同一条路读 pluginInventory，这里照搬。
+ * lib/mobile/sessions.js 已经派发过 commands.execute，lib/mobile/plugins.js 也走同一条路
+ * 读 pluginInventory —— 都经 host-bridge/transport.js 的 `invoke`，这里照搬。
  *
  * 两条接口（都只是转发宿主的发现域，不做任何排序或截断之外的加工）：
  *  - GET /api/mobile/v1/file-references?sessionId=…&query=…     → fileReferences.list
@@ -29,17 +29,13 @@
  */
 
 const { sendJson } = require('../shared/http-util');
+const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/transport.js');
 
 const REFERENCE_ID_MAX_CHARS = 200;       // sessionId 长度上限
 const REFERENCE_QUERY_MAX_CHARS = 200;    // 查询串长度上限（宿主 schema 只要求 string）
 const REFERENCE_MAX_ITEMS = 50;           // 与宿主 session-reference 的 candidateLimit 默认值一致
 const REFERENCE_KINDS = new Set(['file', 'directory']);
 
-/** 宿主网关；宿主没组合 dsh-api-gateway 时返回 null，调用方回 503。 */
-function gatewayOf(ctx) {
-  return (ctx.get && ctx.get('typertGateway')) || null;
-}
-
 /** 网关缺失/命名空间缺失对客户端是同一件事：宿主这个能力没装。 */
 const UNAVAILABLE = Object.freeze({
   code: 'reference-unavailable',
@@ -54,9 +50,13 @@ function errorText(error) {
 }
 
 /**
- * 经 typertGateway 调一次引用发现。
+ * 经网关调一次引用发现。
+ *
+ * 走 host-bridge/transport.js 的 `invoke`：Peer 身份与「服务/方法不存在」的收敛都在
+ * 那里，本域只做自己的 503/400 翻译。**不要自己直连网关** —— 0.2.1 起
+ * 要求每个请求自带 Peer，绕过去就是对 undefined 读 `.signal`，手机端 @ 补全整块失效。
  *
- * 注意返回值形状：`gateway.invoke()` 返回的是 **decode 后的业务结果本体**
+ * 注意返回值形状：网关回的是 **decode 后的业务结果本体**
  * （dsh-api-gateway/lib/index.js:112 `return decode(descriptor.result, result, …)`），
  * 那层 `{ok:true,value}` 外壳是浏览器传输（connection.rpc.intercept('/api')）加的，
  * invoke 不负责包。所以形状取决于服务声明的 result schema：
@@ -67,28 +67,15 @@ function errorText(error) {
  * @returns {Promise<{value?: unknown, error?: {code: string, message: string}}>}
  */
 async function callReference(ctx, namespace, method, agentId, query) {
-  const gateway = gatewayOf(ctx);
-  if (!gateway) return { error: { ...UNAVAILABLE } };
-  let result;
-  try {
-    // 两个方法的声明参数都是 agent(wire=agentId) + query(wire=query)，args 必须精确匹配；
-    // 末位 signal 是可选的取消边界（gateway 会补 NEVER_ABORTED_SIGNAL），这里给真的，
-    // 客户端断开时能让宿主那次发现提前收工。
-    result = await gateway.invoke({
-      namespace,
-      method,
-      args: { agentId, query },
-      signal: new AbortController().signal,
-    });
-  } catch (error) {
-    // 0.2.0 的网关错误码带 `gateway/` 前缀（dsh-api-gateway/src/types.ts:117-136）；
-    // 0.1.x 时期是不带前缀的。两种都认，否则「宿主没装这个服务」的降级分支形同虚设。
-    const raw = error && typeof error.code === 'string' ? error.code.replace(/^gateway\//, '') : ''
-    const code = raw === 'invocation-unavailable' || raw === 'service-unavailable' || raw === 'method-unavailable'
-      ? UNAVAILABLE.code
-      : 'reference-error';
-    return { error: { code, message: errorText(error) } };
+  // 两个方法的声明参数都是 agent(wire=agentId) + query(wire=query)，args 必须精确匹配；
+  // 末位 signal 是可选的取消边界（gateway 会补 NEVER_ABORTED_SIGNAL），这里给真的，
+  // 客户端断开时能让宿主那次发现提前收工。
+  const called = await invoke(ctx, namespace, method, { agentId, query }, new AbortController().signal);
+  if (called.error) {
+    if (called.error.code === GATEWAY_UNAVAILABLE.code) return { error: { ...UNAVAILABLE } };
+    return { error: { code: 'reference-error', message: errorText(called.error) } };
   }
+  const result = called.value;
   // 正常形状：裸数组（宿主声明的 result 就是数组）
   if (Array.isArray(result)) return { value: result };
   if (result && typeof result === 'object') {

package/lib/mobile/session-send.js

@@ -21,6 +21,7 @@ const {
 } = require('./session-cache.js');
 const { promptErrorObject, MODEL_UNAVAILABLE_ERROR } = require('./history-derive.js');
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
+const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/transport.js');
 const readReceipt = require('../read-receipt.cjs');
 
 const SEND_MAX_BODY = 8 * 1024 * 1024; // /send 请求体上限（图片 base64）
@@ -34,7 +35,7 @@ function singleTextOf(content) {
 }
 
 /**
- * 经宿主 typertGateway 执行 slash 命令（commands.execute——桌面 Web 端同一条派发路径：
+ * 经网关执行 slash 命令（commands.execute——桌面 Web 端同一条派发路径：
  * 命令注册表命中才执行，绝不经 session.prompt 发给模型；agent 由 agentId 经同一
  * agent 查找器解析，与 session.prompt 的 turnAgentFor 同源，支持冷会话自动 resume）。
  *
@@ -51,18 +52,13 @@ function singleTextOf(content) {
  *   | {error} 查找或派发失败 | {missing} 网关服务未组合（调用方回退普通消息）
  */
 async function executeCommand(ctx, sessionId, line) {
-  const gateway = ctx.get && ctx.get('typertGateway');
-  if (!gateway) return { missing: true };
-  try {
-    const execution = await gateway.invoke({
-      namespace: 'commands',
-      method: 'execute',
-      args: { agentId: sessionId, line, submittedAttachments: [] },
-    });
-    return { execution };
-  } catch (error) {
-    return { error };
+  // 走 host-bridge/transport.js 的 invoke：Peer 身份与「服务/方法不存在」的收敛都在
+  // 那里。这里只把「网关没组合」翻成 {missing}，让调用方回退普通消息。
+  const called = await invoke(ctx, 'commands', 'execute', { agentId: sessionId, line, submittedAttachments: [] });
+  if (called.error) {
+    return called.error.code === GATEWAY_UNAVAILABLE.code ? { missing: true } : { error: called.error };
   }
+  return { execution: called.value };
 }
 
 /**
@@ -172,36 +168,30 @@ async function handleSend(ctx, req, res) {
 }
 
 /** GET /api/mobile/v1/commands?sessionId=…（token）：会话有效命令目录（与桌面 Web 端命令面板
- * 同源——typertGateway commands.list，即服务端命令注册表对该 agent 生效的完整清单）。
+ * 同源——commands.list，即服务端命令注册表对该 agent 生效的完整清单）。
  * 响应：{ ok, items:[{name, description, input?:{hint}}] }；网关未组合或失败时降级为空清单，
- * 客户端菜单据此只展示真实可执行的命令（不再硬编码）。 */
+ * 客户端菜单据此只展示真实可执行的命令（不再硬编码）。
+ *
+ * 失败一律降级成空清单是**刻意设计**：输入区不能因为目录拉不到就报错。代价是这个端点
+ * 出问题时手机上看不出任何提示，「+」菜单静默只剩媒体与文件两行 —— 2026-10 宿主升到
+ * 0.2.1 要求每个请求自带 Peer，这条路径没跟上，用户看到的就是「目标、计划、指令全没了」。 */
 async function handleCommands(ctx, req, res) {
   const sessionId = new URL(req.url, 'http://x').searchParams.get('sessionId');
   if (!sessionId) return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '缺少 sessionId' } });
-  const gateway = ctx.get && ctx.get('typertGateway');
-  if (!gateway) return sendJson(res, 200, { ok: true, items: [] });
-  try {
-    const descriptors = await gateway.invoke({
-      namespace: 'commands',
-      method: 'list',
-      args: { agentId: sessionId },
-    });
-    const items = Array.isArray(descriptors)
-      ? descriptors
-          .filter((d) => d && typeof d.name === 'string' && d.name && typeof d.description === 'string')
-          .map((d) => ({
-            name: d.name,
-            description: d.description,
-            ...(d.input && typeof d.input === 'object' && typeof d.input.hint === 'string' && d.input.hint
-              ? { input: { hint: d.input.hint } }
-              : {}),
-          }))
-      : [];
-    sendJson(res, 200, { ok: true, items });
-  } catch (error) {
-    // 目录拉取失败不阻塞输入区：降级为空清单（等价桌面网关缺失）。
-    sendJson(res, 200, { ok: true, items: [] });
-  }
+  const called = await invoke(ctx, 'commands', 'list', { agentId: sessionId });
+  const descriptors = called.error ? null : called.value;
+  const items = Array.isArray(descriptors)
+    ? descriptors
+        .filter((d) => d && typeof d.name === 'string' && d.name && typeof d.description === 'string')
+        .map((d) => ({
+          name: d.name,
+          description: d.description,
+          ...(d.input && typeof d.input === 'object' && typeof d.input.hint === 'string' && d.input.hint
+            ? { input: { hint: d.input.hint } }
+            : {}),
+        }))
+    : [];
+  sendJson(res, 200, { ok: true, items });
 }
 
 /** POST /api/mobile/v1/session/read（token）{sessionId}：清除完成提醒。 */

package/lib/mobile/stream.js

@@ -30,6 +30,20 @@ const SSE_RETRY_MS = 3000;
 // internal progress threshold. Pad each SSE record so onprogress exposes it
 // promptly; the padding is an SSE comment and is ignored by clients.
 const SSE_FLUSH_PADDING_BYTES = 2048;
+/**
+ * 写缓冲的两道水位（字节）。`res.write()` 在客户端读得慢时返回 false，字节留在 Node
+ * 的写队列里；以前没人看这个返回值，于是「手机停在一个生成中的会话上、网络又慢」时
+ * 帧无限堆积 —— 2026-10-17 真机现场：堆快照里 17.6 万条 SSE 帧（466MB）挂在
+ * `WriteWrap._chunks` 上，宿主 70 分钟涨到 3.9G 被 OOM 杀掉。
+ *
+ * 两道闸分开，因为两种帧的「丢了能不能补」不一样：
+ *  - 软水位：只丢**没有 seq 的增量帧**（`assistant/chunk`）。它本来就是可丢弃的草稿
+ *    增量，同一轮收尾的 `assistant/message` 带完整正文且有 seq，重连回放能补齐；
+ *  - 硬水位：连有 seq 的帧也放不下了，就返回 false 让上层收尾。客户端带 `lastSeq`
+ *    重连后走 `replaySince` 把缺口补齐 —— 断流可恢复，堆内存不会。
+ */
+const SSE_SHED_BUFFERED_BYTES = 4 * 1024 * 1024;
+const SSE_CLOSE_BUFFERED_BYTES = 16 * 1024 * 1024;
 const REPLAY_WINDOW = 3000; // 断线补偿回放的最大事件数
 
 /**
@@ -74,13 +88,27 @@ function stableEventId(payload, frame) {
   return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
 }
 
+/**
+ * 写一条 SSE 记录。
+ *
+ * @returns {{ok: boolean, shed?: boolean}} `ok:false` 表示这条流该收尾了（客户端已经
+ *   走了，或者写缓冲超过硬水位）；`shed:true` 表示这条**增量**帧被主动丢掉、连接还
+ *   活着（见 SSE_SHED_BUFFERED_BYTES）。
+ *
+ * 丢增量必须只丢没有 seq 的帧：有 seq 的帧是客户端水位的一部分，丢了不回放就在手机
+ * 上留一个永久的洞，那比断流更糟。
+ */
 function writeSse(res, payload, frame) {
+  const buffered = Number(res.writableLength) || 0;
+  if (buffered > SSE_CLOSE_BUFFERED_BYTES) return { ok: false };
   const id = stableEventId(payload, frame);
+  const hasSeq = Number.isFinite(payload && payload.seq);
+  if (buffered > SSE_SHED_BUFFERED_BYTES && !hasSeq) return { ok: true, shed: true };
   const fields = [`retry: ${SSE_RETRY_MS}`];
   if (id) fields.push(`id: ${id}`);
   fields.push(`data: ${JSON.stringify(payload)}`);
   fields.push(`: ${' '.repeat(SSE_FLUSH_PADDING_BYTES)}`, '', '');
-  try { res.write(`${fields.join('\n')}\n`); return true; } catch { return false; }
+  try { res.write(`${fields.join('\n')}\n`); return { ok: true }; } catch { return { ok: false }; }
 }
 
 /**
@@ -163,7 +191,7 @@ async function handleStream(ctx, req, res) {
       if (replay.gap && !ac.signal.aborted) {
         const value = { type: 'session/resync-required', sessionId, resumeSeq, oldestSeq: replay.oldestSeq };
         // 旧实现在这里直接 `return`：既不清 keepAlive 也不 end，漏出一条永不收尾的连接。
-        if (!writeSse(res, value, { payload: value })) clientGone = true;
+        if (!writeSse(res, value, { payload: value }).ok) clientGone = true;
       }
     }
 
@@ -181,25 +209,31 @@ async function handleStream(ctx, req, res) {
           // 回放已覆盖该 seq（回放与实时交界处）→ 跳过，避免重复交付。
           if (seq !== null && seq <= lastDeliveredSeq) continue;
           const event = await resolveEventAttachments(ctx, sessionId, p.event);
-          if (!writeSse(res, event, { ...frame, payload: { ...p, event } })) { clientGone = true; break; }
+          // 被 shed 的只可能是没有 seq 的增量（见 writeSse 的软水位闸）；它不推进水位，
+          // 同一轮收尾的 assistant/message 会把完整正文补上。
+          const sent = writeSse(res, event, { ...frame, payload: { ...p, event } });
+          if (sent.shed) continue;
+          if (!sent.ok) { clientGone = true; break; }
           if (seq !== null) lastDeliveredSeq = seq;
         } else if (p.type === 'session/queue' || p.type === 'session/projection') {
           // 队列/投影整帧转发；不假定存在可重放的宿主 API。
-          if (!writeSse(res, p, frame)) { clientGone = true; break; }
+          const sent = writeSse(res, p, frame);
+          if (sent.shed) continue;
+          if (!sent.ok) { clientGone = true; break; }
         } else if (p.type === 'session/jobs') {
           // 后台任务整帧（桌面端会话头部任务面板的数据源）。宿主只在任务有变化时发，
           // 且**空数组也要转发** —— 那是「任务都结束了」的唯一信号，丢掉它就永远清不掉。
           const value = { type: 'session/jobs', sessionId, jobs: normalizeJobs(p.jobs) };
-          if (!writeSse(res, value, frame)) { clientGone = true; break; }
+          if (!writeSse(res, value, frame).ok) { clientGone = true; break; }
         } else if (p.type === 'question/requested') {
           // 问题是可回答的 mux server-request，而非 session/event；保留 rpcId 供回答关联。
           const value = { ...p, rpcId: frame.rpcId };
-          if (!writeSse(res, value, { ...frame, payload: value })) { clientGone = true; break; }
+          if (!writeSse(res, value, { ...frame, payload: value }).ok) { clientGone = true; break; }
         } else if (p.type === 'question/resolved' || p.type === 'approval/requested' || p.type === 'approval/asked' || p.type === 'approval/decided' || p.type === 'approval/resolved') {
           // Approval frames are server requests/resolutions, not session/event frames;
           // forward the rpcId and approval identity so the mobile client can answer safely.
           const value = ANSWERABLE_APPROVAL_TYPES.has(p.type) && frame.rpcId ? { ...p, rpcId: frame.rpcId } : p;
-          if (!writeSse(res, value, { ...frame, payload: value })) { clientGone = true; break; }
+          if (!writeSse(res, value, { ...frame, payload: value }).ok) { clientGone = true; break; }
         }
       }
       if (!clientGone) loopEnded = true;
@@ -255,7 +289,7 @@ async function replaySince(ctx, sessionId, sinceSeq, res, signal, onDelivered) {
       // Keep replay data identical to live SSE data: the client reducer consumes
       // the event's own type (turn/start, assistant/message, etc.).
       const payload = { type: 'session/event', sessionId, event };
-      if (!writeSse(res, event, { payload })) break;
+      if (!writeSse(res, event, { payload }).ok) break;
       if (Number.isFinite(event.seq)) onDelivered(event.seq);
     }
     return { gap, oldestSeq };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (0.2.0-rc.2 compatible, peers resolved by the host)",
   "license": "MIT",
   "type": "module",