dsh-mobile-plugin 0.1.96 → 0.1.98

package/lib/mobile/history-derive.js

@@ -268,6 +268,26 @@ function lastMessageOf(messages) {
   return null;
 }
 
+/**
+ * 一份历史事件里所有**交付声明**过的路径（`deliverables/presented` 的 `files[].path`）。
+ *
+ * 与下面的按轮归并同一批事件、同一个形状兼容（`entry.event || entry`）：交付文件取字节
+ * 那条路由（`session-file.js`）用它做白名单 —— 只有模型显式交出来的文件才允许手机上取。
+ * 单独一个函数而不是从消息里翻 `presentedFiles`：声明事件可能落在消息窗口之外，按轮挂在
+ * 消息上的那份不一定在。
+ */
+function presentedPathsOf(events) {
+  const paths = new Set();
+  for (const entry of events) {
+    const e = entry && (entry.event || entry);
+    if (!e || e.type !== 'deliverables/presented' || !e.data || !Array.isArray(e.data.files)) continue;
+    for (const raw of e.data.files) {
+      if (raw && typeof raw.path === 'string' && raw.path.trim() !== '') paths.add(raw.path);
+    }
+  }
+  return paths;
+}
+
 /**
  * 从 history 事件折叠出消息与「结构化行」（wire v1 扩展，向后兼容）：
  *  - 普通消息维持现状：{ id, seq, time, role, text, blocks?, images?, clientMessageId? }（user/assistant）；
@@ -296,6 +316,31 @@ function deriveMessages(events) {
     if (e.type !== 'compaction/summary' || !e.data || typeof e.data.compactionId !== 'string') continue;
     summaries.set(e.data.compactionId, e.data);
   }
+  // 交付声明预扫描（`deliverables/presented`）：模型调 `present` 声明「这几份请你收下」时，
+  // 宿主的 dsh-tool-present 会往会话日志追一条这个事件。桌面那张「交付文件」卡只认它 ——
+  // **不是**「这一轮改过哪些文件」。手机第一版从 write/edit 反推，于是「每改一次都冒卡、
+  // 命令行改的却一张都没有」（2026-10-22 用户报的正是这个）。这里按 **turn** 归并，
+  // 同一个路径后声明的覆盖先声明的（桌面 `presentedForClosing` 的 `files.set` 同口径）。
+  const presentedByTurn = new Map();
+  for (const entry of events) {
+    const e = entry.event || entry;
+    if (e.type !== 'deliverables/presented') continue;
+    const data = e.data;
+    if (!data || typeof data !== 'object' || typeof data.turn !== 'number' || !Array.isArray(data.files)) continue;
+    const bucket = presentedByTurn.get(data.turn) || [];
+    for (const raw of data.files) {
+      if (!raw || typeof raw !== 'object' || typeof raw.path !== 'string' || raw.path.trim() === '') continue;
+      const file = {
+        path: raw.path,
+        ...(typeof raw.description === 'string' && raw.description.trim() !== '' ? { description: raw.description } : {}),
+      };
+      const at = bucket.findIndex((item) => item.path === file.path);
+      if (at >= 0) bucket[at] = file;
+      else bucket.push(file);
+    }
+    if (bucket.length > 0) presentedByTurn.set(data.turn, bucket);
+  }
+
   // 单步计时预扫描：为每条 assistant 消息派生「本轮」的 ttft / decode / 输出 token
   // （对齐桌面 turn-metrics/assistant-timing：ttftMs = 首个非空 delta − step/start；
   // decodeMs = 落定 − 首个 delta；outputTokens = assistant/message.usage.outputTokens）。
@@ -420,6 +465,13 @@ function deriveMessages(events) {
        } catch { return null; }
      }).filter((path) => typeof path === 'string');
      if (producedFiles.length > 0) item.producedFiles = [...new Set(producedFiles)];
+     // 这一轮模型显式声明的交付文件：轮尾那张交付卡的唯一依据（与 producedFiles 分开，
+     // 后者只给收尾正文的行内引用解析用）。事件没有 turn 号的（老日志）不挂。
+     const turn = e.data && typeof e.data.turn === 'number' ? e.data.turn : undefined;
+     if (turn !== undefined) {
+       const presented = presentedByTurn.get(turn);
+       if (presented && presented.length > 0) item.presentedFiles = presented.map((file) => ({ ...file }));
+     }
      // 单轮计时只挂 assistant 消息（user/message 无 step 计时）。
     if (item.role !== 'user') {
       const timing = timingOf(e);
@@ -483,6 +535,25 @@ function deriveMessages(events) {
         });
         continue;
       }
+      if (src && typeof src === 'object' && src.kind === 'schedule') {
+        // 定时任务投递的提醒：桌面画成 `turn-trigger` 节点，手机这里落成一行 kind:'wake'
+        // （与 App 的 userMessageOrigin 同口径，见 app/src/utils/structuralItems.ts）。
+        // 以前把它并进下面那条「非 user 来源一律不下发」里丢掉，于是每一轮自动执行在重进
+        // 会话后一点痕迹都没有。正文是宿主拼的提醒框架，原样收下、不解析。
+        const wakeBlocks = parseBlocks(msg.content, toolResults);
+        const wakeText = blocksToText(wakeBlocks);
+        if (wakeText) {
+          out.push({
+            id: String(msg.id),
+            kind: 'wake',
+            wakeSource: 'schedule',
+            text: wakeText,
+            seq: e.seq,
+            time: e.time,
+          });
+        }
+        continue;
+      }
       if (src && typeof src === 'object' && src.kind !== 'user') {
         // 上下文注入/召回（session-reference→召回，其余 kind→注入）：桌面 `isVisibleChatNode`
         // 只放行携带 tool-addition/tool-removal 的上下文节点，这类提示一律不显示 —— 不下发。
@@ -634,7 +705,8 @@ function deriveMessages(events) {
         out.push(done);
       }
     } else if (e.type === 'turn/end' && e.data && e.data.reason && e.data.turn != null) {
-      // turn/end 每轮一次，一条消息只对应一条行：error → turn-error；max-tokens → max-tokens；其余 kind 忽略。
+      // turn/end 每轮一次，一条消息只对应一条行：error → turn-error；max-tokens → max-tokens；
+      // aborted → turn-aborted；其余 kind 忽略。
       if (e.data.reason.kind === 'error') {
         const err = e.data.reason.error;
         if (!err || typeof err.message !== 'string') continue;
@@ -643,6 +715,11 @@ function deriveMessages(events) {
         out.push(item);
       } else if (e.data.reason.kind === 'max-tokens') {
         out.push({ id: `turn-${e.data.turn}`, kind: 'max-tokens', seq, time });
+      } else if (e.data.reason.kind === 'aborted') {
+        // 用户点了停止（或被宿主打断）。这一行不带正文，只让 App 把那一轮标成「已停止」并摊开：
+        // 桌面口径是 aborted / error 不折叠，App 收不到这个信号就只能当成正常结束，把整轮收进
+        // 一行「已完成，用时 …」里 —— 跑了几十步、最后没有收尾答复的那一轮会整轮从屏幕上消失。
+        out.push({ id: `turn-${e.data.turn}`, kind: 'turn-aborted', seq, time });
       }
     }
     // tool/result 等其余类型照旧忽略（工具结果在预扫描里配对回填；compaction 行由 start/end 发出）。
@@ -719,6 +796,7 @@ function clientMessageIdFromSource(source, message) {
 
 module.exports = {
   listTitle,
+  presentedPathsOf,
   deriveMessages,
   unwrap,
   errorDetails,

package/lib/mobile/host-bridge/endpoints.js

@@ -66,6 +66,9 @@ const ENDPOINTS = {
   // 宿主的模型目录是全局的（不再按 session 查），这里翻译成插件/移动端要的形状；
   // payload 带 sessionId，供 modelCatalog 叠加会话自己的 modelSelection 投影。
   'sessions.models': (ctx, payload, signal) => modelCatalog(ctx, payload, signal),
+  // 宿主级的模型目录（与 session 无关）：同一个 modelCatalog，不带 sessionId 就不去读会话选择，
+  // 「AI commit 用哪个模型」这类选择器要的就是这一份（`llm/models` 那条移动路由）。
+  'llm.models': (ctx, payload, signal) => modelCatalog(ctx, {}, signal),
 
   // agentPresets（namespace 是复数 agentPresets）
   'agentPresets.list': inv('agentPresets', 'list', () => ({})),

package/lib/mobile/host-bridge/event-synthesis.js

@@ -52,6 +52,89 @@ async function* tolerate(frames, what, ctx) {
   }
 }
 
+/** 正文 / 推理 / 工具参数的增量：同一块的连续 delta 在基线里可以合并成一帧。 */
+const BASELINE_DELTA_TYPES = new Set(['text-delta', 'reasoning-delta', 'tool-call-delta']);
+
+/**
+ * 展开 follow 首帧里那条「正在跑的那一步已生成的内容」。
+ *
+ * 宿主的 follow 第一帧是 `{type:'snapshot', cursor, assistantStream:{ revision, activeAttempt }}`，
+ * `activeAttempt.stream` 是一份**压缩过的**增量记录（连续同块 delta 被压成
+ * `{type:'text-chunks', index, time0, dt, texts}` 这类一条记录多个成员），
+ * `nextIndex` 是「下一帧实时增量应有的密排位置」，也就是这条前缀展开后应有的成员数。
+ * 中途进入会话的人只有这一份，宿主不会把已发过的实时帧补给他。
+ *
+ * 返回 `[{ time, chunk }]`；形状认不出就跳过那一条记录，绝不让整条流挂掉。
+ */
+function expandBaselineStream(stream, limit) {
+  const out = [];
+  if (!Array.isArray(stream)) return out;
+  const cap = Number.isSafeInteger(limit) && limit >= 0 ? limit : Number.POSITIVE_INFINITY;
+  for (const record of stream) {
+    if (out.length >= cap) break;
+    if (!record || typeof record !== 'object') continue;
+    if (record.type === 'chunk') {
+      if (record.chunk && typeof record.chunk === 'object' && typeof record.chunk.index === 'number') {
+        out.push({ time: Number.isSafeInteger(record.time) ? record.time : 0, chunk: record.chunk });
+      }
+      continue;
+    }
+    const members = record.type === 'tool-call-chunks' ? record.args : record.texts;
+    if (!Array.isArray(members) || typeof record.index !== 'number') continue;
+    const dt = Array.isArray(record.dt) ? record.dt : [];
+    let time = Number.isSafeInteger(record.time0) ? record.time0 : 0;
+    for (let i = 0; i < members.length && out.length < cap; i += 1) {
+      if (i > 0 && Number.isSafeInteger(dt[i - 1])) time += dt[i - 1];
+      if (record.type === 'text-chunks' && typeof members[i] === 'string') {
+        out.push({ time, chunk: { type: 'text-delta', index: record.index, text: members[i] } });
+      } else if (record.type === 'reasoning-chunks' && typeof members[i] === 'string') {
+        out.push({ time, chunk: { type: 'reasoning-delta', index: record.index, text: members[i] } });
+      } else if (record.type === 'tool-call-chunks') {
+        out.push({
+          time,
+          chunk: {
+            type: 'tool-call-delta',
+            index: record.index,
+            ...(typeof record.id === 'string' ? { id: record.id } : {}),
+            ...(typeof record.name === 'string' ? { name: record.name } : {}),
+            argumentsDelta: members[i],
+          },
+        });
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * 同一块的连续增量合成一帧：一条 3k 字的回复展开后是几千帧，逐帧发给手机既占带宽
+ * 又会在 App 的守门缓冲里被挤掉。App 的草稿本来就是按块累积文本，合并后观感一致。
+ */
+function coalesceBaselineStream(members) {
+  const out = [];
+  for (const member of members) {
+    const chunk = member && member.chunk;
+    if (!chunk || typeof chunk !== 'object') continue;
+    const last = out[out.length - 1];
+    const previous = last && last.chunk;
+    if (
+      previous && BASELINE_DELTA_TYPES.has(chunk.type) &&
+      previous.type === chunk.type && previous.index === chunk.index
+    ) {
+      if (typeof chunk.text === 'string' && typeof previous.text === 'string') {
+        last.chunk = { ...previous, text: previous.text + chunk.text };
+        continue;
+      }
+      if (typeof chunk.argumentsDelta === 'string' && typeof previous.argumentsDelta === 'string') {
+        last.chunk = { ...previous, argumentsDelta: previous.argumentsDelta + chunk.argumentsDelta };
+        continue;
+      }
+    }
+    out.push({ time: member.time, chunk });
+  }
+  return out;
+}
+
 /**
  * follow 流的一帧 → 0..n 个 mux 帧（事件原样转发；实时增量通知合成 assistant/chunk）。
  *
@@ -66,10 +149,35 @@ async function* tolerate(frames, what, ctx) {
  * （`lib/mobile/events.js` 的 LIST_EVENT_INNER），合成增量到不了那条通道，不会形成推送风暴。
  *
  * `state` 是这条流的记账（{ turn, step, streaming }），由调用方持有 —— 一帧的处理要看
- * 「之前收到过什么」。snapshot 帧不需要处理：历史走 session.history。
+ * 「之前收到过什么」。历史正文走 session.history，但首帧 snapshot 里那份
+ * `assistantStream.activeAttempt` 不能丢：中途进入会话的人拿不到开跑之前的实时增量，
+ * 那一段只存在于这份基线里（见 expandBaselineStream）。
  */
 function* followFramePayloads(frame, sessionId, state) {
   if (!frame) return;
+  if (frame.type === 'snapshot') {
+    const opening = frame.assistantStream && frame.assistantStream.activeAttempt;
+    if (!opening || !Number.isSafeInteger(opening.turn) || !Number.isSafeInteger(opening.step)) return;
+    // 这条流后面收到的实时增量要靠这两个值带上作用域（App 按「本轮·本步」分家草稿），
+    // 中途进来的客户端收不到 start 通知，基线是唯一来源。
+    state.turn = opening.turn;
+    state.step = opening.step;
+    state.streaming = true;
+    for (const member of coalesceBaselineStream(expandBaselineStream(opening.stream, opening.nextIndex))) {
+      yield {
+        payload: {
+          type: 'session/event',
+          sessionId,
+          event: {
+            type: 'assistant/chunk',
+            time: Number.isSafeInteger(member.time) ? member.time : Date.now(),
+            data: { turn: state.turn, step: state.step, chunk: member.chunk },
+          },
+        },
+      };
+    }
+    return;
+  }
   if (frame.type === 'event') {
     if (!frame.event) return;
     // 增量只交付一次：宿主若同时把 chunk 也当成事件发，以通知为准（通知先到）。

package/lib/mobile/host-bridge/shims.js

@@ -85,6 +85,11 @@ async function historyViaPage(ctx, payload, signal) {
  *
  * 读不到投影（会话不存在 / 宿主没挂投影能力）时不升级成错误：退回全局默认即可，
  * 让模型目录照常下发，宁可少一次会话级精修也不让整个模型面板消失。
+ *
+ * `defaultModel` 单独回一份**全局默认**，与 `current` 分开：宿主的新会话读的就是
+ * 「最近一次成功保存的默认值」（`session.create` 不带模型时落这一条），所以 App 要
+ * 显示「新对话会用哪个模型」只能看它 —— 拿任何一个会话的 `current` 去顶都是猜，
+ * 会话各自选过的模型未必是默认。旧 App 忽略这个字段，行为不变。
  */
 async function modelCatalog(ctx, payload, signal) {
   const sessionId = payload && typeof payload.sessionId === 'string' ? payload.sessionId : '';
@@ -94,7 +99,7 @@ async function modelCatalog(ctx, payload, signal) {
   ]);
   if (result.error) return fail(result.error);
   const catalog = result.value && typeof result.value === 'object' ? result.value : {};
-  const current = catalog.default && typeof catalog.default === 'object'
+  const globalDefault = catalog.default && typeof catalog.default === 'object'
     ? pick(catalog.default, ['provider', 'model', 'reasoningEffort'])
     : null;
   // 会话自己选过模型时，用它覆盖全局默认；读不到或没选过才保留全局默认。
@@ -108,10 +113,12 @@ async function modelCatalog(ctx, payload, signal) {
         ? pick(sessionModel.lastUsed, ['provider', 'model', 'reasoningEffort'])
         : null)
     : null;
-  const effective = sessionSelection && sessionSelection.provider && sessionSelection.model ? sessionSelection : current;
+  const effective = sessionSelection && sessionSelection.provider && sessionSelection.model ? sessionSelection : globalDefault;
   const routableProviders = Array.isArray(catalog.routableProviders) ? catalog.routableProviders : [];
+  const defaultModel = globalDefault && globalDefault.provider && globalDefault.model ? globalDefault : null;
   return ok({
     ...(effective ? { current: effective } : {}),
+    ...(defaultModel ? { defaultModel } : {}),
     routable: Boolean(effective && routableProviders.includes(effective.provider)),
     routableProviders,
     groups: Array.isArray(catalog.groups) ? catalog.groups : [],

package/lib/mobile/host-settings.js

@@ -22,6 +22,7 @@ const { sendJson, readJsonBody } = require('../shared/http-util');
 const { unwrap } = require('./sessions.js');
 
 const HOST_SETTINGS_MAX_NAMESPACES = 60; // 命名空间数量上限（避免异常宿主把响应撑爆）
+const HOST_SETTINGS_MAX_MODELS_PER_GROUP = 200; // 单个提供方下的模型条数上限
 const HOST_SETTINGS_VALUE_DEPTH = 4;     // 值递归深度上限
 const HOST_SETTINGS_VALUE_KEYS = 40;     // 每层键/元素数量上限
 const HOST_SETTINGS_VALUE_CHARS = 4000;  // 单个字符串长度上限
@@ -190,6 +191,45 @@ async function handleLlmProviders(ctx, req, res) {
   sendJson(res, 200, { ok: true, providers });
 }
 
+/** 把 llm.models 的一组渠道压成手机选择器要的形状；没有模型的组丢掉。 */
+function normalizeModelGroup(group) {
+  if (!group || typeof group !== 'object') return null;
+  const provider = typeof group.id === 'string' ? group.id.trim() : '';
+  if (!provider) return null;
+  const displayName = typeof group.name === 'string' && group.name.trim() ? group.name.trim() : provider;
+  const models = (Array.isArray(group.models) ? group.models : [])
+    .map((item) => {
+      if (!item || typeof item !== 'object') return null;
+      const id = typeof item.id === 'string' ? item.id.trim() : '';
+      if (!id) return null;
+      const name = typeof item.name === 'string' && item.name.trim() ? item.name.trim() : id;
+      return { id, name };
+    })
+    .filter(Boolean)
+    .slice(0, HOST_SETTINGS_MAX_MODELS_PER_GROUP);
+  if (models.length === 0) return null;
+  return { provider, displayName, models };
+}
+
+/**
+ * GET /api/mobile/v1/llm/models —— 宿主的模型目录（`llm.models`，与 session 无关）。
+ *
+ * 与 `/llm/providers` 的区别：那条只说「有哪些提供方 / 哪个在生效」，这条给出每个提供方
+ * 下面真正可请求的模型 id。手机上没有活动会话时（比如从 Git 页打开选择器）也能拿到。
+ */
+async function handleLlmModels(ctx, req, res) {
+  const { value, error } = unwrap(await ctx.apiProxy.llm.models({
+    rpcId: 'mobile',
+    method: 'llm.models',
+    payload: {},
+  }));
+  if (error) return sendJson(res, 400, { ok: false, error });
+
+  const list = Array.isArray(value && value.groups) ? value.groups : [];
+  const groups = list.map(normalizeModelGroup).filter(Boolean).slice(0, HOST_SETTINGS_MAX_NAMESPACES);
+  sendJson(res, 200, { ok: true, groups });
+}
+
 const HOST_SETTINGS_MAX_OPS = 40;   // 一次写入的 op 数量上限
 const HOST_SETTINGS_MAX_PATH = 8;   // 单个路径的层数上限
 
@@ -274,6 +314,7 @@ module.exports = {
   handleHostSettings,
   handleHostSettingsMutate,
   handleLlmProviders,
+  handleLlmModels,
   boundValue,
   credentialRefOf,
   normalizeNamespace,