dsh-mobile-plugin 0.1.87 → 0.1.88

package/lib/mobile/history-derive.js

@@ -138,6 +138,10 @@ function parseBlocks(blocks, toolResults) {
       // does not expose chain-of-thought. They are known blocks, not unsupported
       // content; silently omit empty placeholders and avoid leaking their JSON.
       if (typeof b.text === 'string' && b.text) out.push({ type: 'reasoning', text: b.text });
+    } else if (b.type === 'image' && b.dataUnavailable === true) {
+      // The image attachment resolver marked this block as unavailable. Keep it out of
+      // visible text; pushMessage projects its retry metadata onto unavailableImages.
+      continue;
     } else if (b.type === 'image' && typeof b.data === 'string' && typeof b.mediaType === 'string') {
       out.push({ type: 'image', mediaType: b.mediaType, data: b.data, name: typeof b.name === 'string' ? b.name : undefined });
     } else if (b.type === 'tool-call') {
@@ -321,12 +325,35 @@ function deriveMessages(events) {
 
   // 普通消息（user/assistant）沿用原折叠逻辑。
   const pushMessage = (msg, e) => {
-    const blocks = parseBlocks(msg.content, toolResults);
+    const parsed = parseBlocks(msg.content, toolResults);
+    // 工具产出的图挂成这条消息的图片附件：App 把它画在气泡上方（缩略图 + 文件名，点开全屏），
+    // 与用户自己发的图同一种形状。工具卡里不再重复画同一张图 —— 一张图两处画会把字节也翻倍。
+    const toolImages = [];
+    const blocks = parsed.map((block) => {
+      if (block.type !== 'tool-call' || !Array.isArray(block.images) || block.images.length === 0) return block;
+      toolImages.push(...block.images);
+      const { images: _movedToAttachments, ...rest } = block;
+      return rest;
+    });
     const text = blocksToText(blocks);
-    const images = blocks.filter((b) => b.type === 'image').map(({ mediaType, data, name }) => ({ mediaType, data, name }));
+    const images = [
+      ...blocks.filter((b) => b.type === 'image'),
+      ...toolImages,
+    ].map(({ mediaType, data, name }) => ({ mediaType, data, name }));
+    const unavailableImages = (Array.isArray(msg.content) ? msg.content : [])
+      .filter((block) => block && block.type === 'image' && block.dataUnavailable === true)
+      .map((block) => {
+        const attachment = block.attachment && typeof block.attachment === 'object' ? block.attachment : {};
+        return {
+          attachmentId: typeof attachment.attachmentId === 'string' ? attachment.attachmentId : '',
+          ...(typeof block.mediaType === 'string' ? { mediaType: block.mediaType } : {}),
+          ...(typeof block.name === 'string' ? { name: block.name } : {}),
+        };
+      })
+      .filter((image) => image.attachmentId !== '');
     // 只要存在可识别或保留的 block 就入列表；纯推理/工具调用也必须保留，
-    // 否则流式标签在重同步后会消失。
-    const hasContent = blocks.length > 0;
+    // 否则流式标签在重同步时会消失。
+    const hasContent = blocks.length > 0 || unavailableImages.length > 0;
     if (!hasContent) return;
     const clientMessageId = msg.role === 'user' ? clientMessageIdFromSource(msg.source, msg) : undefined;
     const item = {
@@ -335,6 +362,7 @@ function deriveMessages(events) {
       text,
       blocks,
       images: images.length > 0 ? images : undefined,
+      ...(unavailableImages.length > 0 ? { unavailableImages } : {}),
       ...(clientMessageId ? { clientMessageId } : {}),
       seq: e.seq,
       time: e.time,

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

@@ -62,8 +62,9 @@ const ENDPOINTS = {
   'sessions.updateQueue': inv('session', 'updateQueue'),
   // 宿主的 fork 请求体只有 sessionId / atSeq，increaseTitle 在 0.2.0 已删除。
   'sessions.fork': inv('session', 'fork', (p) => ({ request: pick(p, ['sessionId', 'atSeq']) })),
-  // 宿主的模型目录是全局的（不再按 session 查），这里翻译成插件/移动端要的形状。
-  'sessions.models': (ctx, payload, signal) => modelCatalog(ctx, signal),
+  // 宿主的模型目录是全局的（不再按 session 查），这里翻译成插件/移动端要的形状；
+  // payload 带 sessionId，供 modelCatalog 叠加会话自己的 modelSelection 投影。
+  'sessions.models': (ctx, payload, signal) => modelCatalog(ctx, payload, signal),
 
   // agentPresets（namespace 是复数 agentPresets）
   'agentPresets.list': inv('agentPresets', 'list', () => ({})),

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

@@ -47,23 +47,49 @@ async function historyViaPage(ctx, payload, signal) {
 }
 
 /**
- * `session.models` → `session.modelCatalog`。
+ * `session.models` → `session.modelCatalog` + 会话自己的 `session/projections`。
  *
  * 宿主改成全局目录了（args 为空），字段也换了名：default → current、
  * routableProviders 变成「能不能用这个 provider」。移动端要的 groups 结构两边一致，
  * 原样带过去即可。
+ *
+ * 但 `default` 是**全局**默认，不是「这个会话实际用的模型」。会话自己的模型记在
+ * `session/projections` 的 `modelSelection` 投影里（`next` 是「下一次请求要用」，
+ * 落到 `lastUsed` 是「最近一次真正跑过的」）；只有会话从没选过模型时，投影里才没有
+ * 这一项，此时才回落到全局默认。桌面端「切到某个对话显示那个对话的模型」读的正是
+ * 这份会话级投影，不是全局默认。移动端这里也要对同一口径，否则 A、B 两个会话各选
+ * 了不同模型，手机却都显示同一个「默认模型」。
+ *
+ * 读不到投影（会话不存在 / 宿主没挂投影能力）时不升级成错误：退回全局默认即可，
+ * 让模型目录照常下发，宁可少一次会话级精修也不让整个模型面板消失。
  */
-async function modelCatalog(ctx, signal) {
-  const result = await invoke(ctx, 'session', 'modelCatalog', {}, signal);
+async function modelCatalog(ctx, payload, signal) {
+  const sessionId = payload && typeof payload.sessionId === 'string' ? payload.sessionId : '';
+  const [result, projection] = await Promise.all([
+    invoke(ctx, 'session', 'modelCatalog', {}, signal),
+    sessionId ? invoke(ctx, 'session', 'projections', { request: { sessionId } }, signal) : Promise.resolve({ error: undefined, value: undefined }),
+  ]);
   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'
     ? pick(catalog.default, ['provider', 'model', 'reasoningEffort'])
     : null;
+  // 会话自己选过模型时，用它覆盖全局默认；读不到或没选过才保留全局默认。
+  const sessionModel = !projection.error && projection.value && typeof projection.value === 'object'
+    ? projection.value.values && typeof projection.value.values === 'object' && projection.value.values.modelSelection
+    : undefined;
+  const sessionSelection = sessionModel && typeof sessionModel === 'object'
+    ? (sessionModel.next && typeof sessionModel.next === 'object'
+      ? pick(sessionModel.next, ['provider', 'model', 'reasoningEffort'])
+      : sessionModel.lastUsed && typeof sessionModel.lastUsed === 'object'
+        ? pick(sessionModel.lastUsed, ['provider', 'model', 'reasoningEffort'])
+        : null)
+    : null;
+  const effective = sessionSelection && sessionSelection.provider && sessionSelection.model ? sessionSelection : current;
   const routable = Array.isArray(catalog.routableProviders) ? catalog.routableProviders : [];
   return ok({
-    ...(current ? { current } : {}),
-    routable: Boolean(current && routable.includes(current.provider)),
+    ...(effective ? { current: effective } : {}),
+    routable: Boolean(effective && routable.includes(effective.provider)),
     groups: Array.isArray(catalog.groups) ? catalog.groups : [],
   });
 }