@xmanrui/dsh-im 4.5.0 → 4.6.0

package/src/channels/feishu/message-utils.mjs

@@ -2,8 +2,14 @@ import { ImagePromptError } from '../shared/image-prompt.mjs';
 import { t } from '../shared/i18n.mjs';
 
 const FEISHU_MISSING_MESSAGE_SCOPE_CODE = 99991672;
+const FEISHU_CARD_MESSAGE_CONTENT_TYPE = 'raw_card_content';
 const FEISHU_ERROR_BODY_LIMIT = 64 * 1024;
 const FEISHU_ERROR_BODY_TIMEOUT_MS = 1_000;
+const FEISHU_CARD_TEXT_MAX_DEPTH = 12;
+const FEISHU_CARD_TEXT_MAX_NODES = 1_000;
+const FEISHU_CARD_UNAVAILABLE_TEXTS = new Set([
+  '请升级至最新版本客户端，以查看内容',
+]);
 const FEISHU_IMAGE_PERMISSION_MESSAGE =
   '飞书机器人缺少图片读取权限 im:message:readonly（飞书显示为“获取单聊、群组消息”）。请私聊机器人执行 /repair 命令，或者在「IM机器人」设置页点击“补全权限”按钮并扫码。按飞书提示发布新版本、完成必要审批后，再重新发送图片。';
 
@@ -56,6 +62,124 @@ function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+function objectRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+
+function jsonRecord(value) {
+  if (objectRecord(value)) return value;
+  if (typeof value !== 'string') return null;
+  try {
+    return objectRecord(JSON.parse(value));
+  } catch {
+    return null;
+  }
+}
+
+function interactiveCardRoot(parsed) {
+  const root = objectRecord(parsed);
+  if (!root) return null;
+  // raw_card_content wraps CardKit entities in json_card. Keep direct Card
+  // 1.0/2.0 payloads readable as well for historical messages and fixtures.
+  return jsonRecord(root.json_card) ?? jsonRecord(root.card) ?? root;
+}
+
+function cardProperty(value) {
+  const record = objectRecord(value);
+  return objectRecord(record?.property) ?? record;
+}
+
+function cardTextContent(property) {
+  const i18n = objectRecord(property?.i18nContent);
+  const content = nonEmptyString(i18n?.zh_cn)
+    ?? nonEmptyString(i18n?.en_us)
+    ?? nonEmptyString(i18n?.ja_jp)
+    ?? nonEmptyString(property?.content)
+    ?? nonEmptyString(property?.text);
+  return content && !FEISHU_CARD_UNAVAILABLE_TEXTS.has(content) ? content : null;
+}
+
+function cardElementText(
+  element,
+  { depth = 0, inline = false, budget = { remaining: FEISHU_CARD_TEXT_MAX_NODES } } = {},
+) {
+  if (depth > FEISHU_CARD_TEXT_MAX_DEPTH || budget.remaining <= 0) return '';
+  budget.remaining -= 1;
+  if (Array.isArray(element)) {
+    return element
+      .map((part) => cardElementText(part, {
+        depth: depth + 1,
+        inline: Array.isArray(part),
+        budget,
+      }))
+      .filter(Boolean)
+      .join(inline ? ' ' : '\n');
+  }
+  const value = objectRecord(element);
+  if (!value) return '';
+  const property = cardProperty(value);
+  if (!property) return '';
+  const tag = String(value.tag ?? '').toLowerCase();
+
+  if (
+    tag === 'markdown'
+    || tag === 'markdown_v1'
+    || tag === 'lark_md'
+    || tag === 'plain_text'
+    || tag === 'text'
+  ) {
+    const content = cardTextContent(property);
+    if (content) return content;
+    const nested = cardElementText(property.elements, {
+      depth: depth + 1,
+      inline: true,
+      budget,
+    });
+    if (nested || tag !== 'markdown_v1') return nested;
+    return cardElementText(value.fallback ?? property.fallback, {
+      depth: depth + 1,
+      inline: true,
+      budget,
+    });
+  }
+  if (tag === 'a' || tag === 'link' || tag === 'button') {
+    if (typeof property.text === 'string') return nonEmptyString(property.text) ?? '';
+    return cardElementText(property.text, { depth: depth + 1, inline: true, budget });
+  }
+  if (tag === 'div') {
+    return [
+      cardElementText(property.text, { depth: depth + 1, budget }),
+      cardElementText(property.fields, { depth: depth + 1, budget }),
+    ].filter(Boolean).join('\n');
+  }
+
+  // Traverse visible layout containers only. Deliberately ignore callback
+  // values, form state, URLs, ids, template variables and other hidden data.
+  return ['elements', 'columns', 'fields', 'children', 'actions']
+    .map((key) => cardElementText(property[key], { depth: depth + 1, budget }))
+    .filter(Boolean)
+    .join('\n');
+}
+
+function interactiveCardText(parsed) {
+  const card = interactiveCardRoot(parsed);
+  if (!card) return '';
+  const budget = { remaining: FEISHU_CARD_TEXT_MAX_NODES };
+  const header = cardProperty(card.header);
+  const title = [
+    cardElementText(header?.title, { inline: true, budget }),
+    cardElementText(header?.subtitle, { inline: true, budget }),
+  ].filter(Boolean).join('\n') || nonEmptyString(card.title) || '';
+  const body = cardProperty(card.body);
+  const elements = Array.isArray(body?.elements)
+    ? body.elements
+    : Array.isArray(card.elements)
+      ? card.elements
+      : null;
+  const content = cardElementText(elements, { budget });
+  return [title, content].filter(Boolean).join('\n');
+}
+
 function postContent(event, parsed = parsedMessageContent(event)) {
   if (event?.message?.message_type !== 'post') return null;
   if (!parsed) return null;
@@ -283,6 +407,109 @@ function feishuFileSource(event, client, file) {
   };
 }
 
+function feishuReplyTargetId(event) {
+  const parentId = nonEmptyString(event?.message?.parent_id);
+  if (parentId) return parentId;
+  const rootId = nonEmptyString(event?.message?.root_id);
+  const messageId = nonEmptyString(event?.message?.message_id);
+  return rootId && rootId !== messageId ? rootId : null;
+}
+
+function feishuReplyAttachments(messageType, parsed, post) {
+  if (messageType === 'post') {
+    return (post?.imageKeys ?? []).map(() => ({ kind: 'image' }));
+  }
+  if (messageType === 'image') return [{ kind: 'image' }];
+  if (messageType === 'file') {
+    return [{
+      kind: 'file',
+      ...(nonEmptyString(parsed?.file_name) ? { name: nonEmptyString(parsed.file_name) } : {}),
+    }];
+  }
+  if (messageType === 'audio') return [{ kind: 'audio' }];
+  if (messageType === 'media') {
+    return [{
+      kind: 'video',
+      ...(nonEmptyString(parsed?.file_name) ? { name: nonEmptyString(parsed.file_name) } : {}),
+    }];
+  }
+  if (messageType === 'sticker') return [{ kind: 'other' }];
+  return [];
+}
+
+function feishuReplyReference(event, client) {
+  const messageId = feishuReplyTargetId(event);
+  if (!messageId) return null;
+  const chatId = nonEmptyString(event?.message?.chat_id);
+  return {
+    messageId,
+    async load({ signal } = {}) {
+      signal?.throwIfAborted();
+      let response;
+      try {
+        response = await client?.im?.v1?.message?.get?.({
+          path: { message_id: messageId },
+          params: {
+            with_sender_name: true,
+            card_msg_content_type: FEISHU_CARD_MESSAGE_CONTENT_TYPE,
+          },
+        });
+      } catch (error) {
+        signal?.throwIfAborted();
+        if (await feishuProviderCode(error, signal) === FEISHU_MISSING_MESSAGE_SCOPE_CODE) {
+          return { messageId, unavailableReason: 'permission-denied' };
+        }
+        throw error;
+      }
+      signal?.throwIfAborted();
+      if (providerCode(response) === FEISHU_MISSING_MESSAGE_SCOPE_CODE) {
+        return { messageId, unavailableReason: 'permission-denied' };
+      }
+      if (providerCode(response) !== null && providerCode(response) !== 0) {
+        return { messageId, unavailableReason: 'not-delivered' };
+      }
+      const item = response?.data?.items?.find?.(
+        (candidate) => nonEmptyString(candidate?.message_id) === messageId,
+      );
+      if (!item) return { messageId, unavailableReason: 'not-found' };
+      if (item.deleted) return { messageId, unavailableReason: 'deleted' };
+      const itemChatId = nonEmptyString(item.chat_id);
+      if (!chatId || !itemChatId || itemChatId !== chatId) {
+        return { messageId, unavailableReason: 'not-found' };
+      }
+
+      const messageType = nonEmptyString(item.msg_type) ?? '';
+      const quotedEvent = {
+        message: {
+          message_id: messageId,
+          message_type: messageType,
+          content: item.body?.content,
+          mentions: item.mentions ?? [],
+        },
+      };
+      const parsed = parsedMessageContent(quotedEvent);
+      const post = postContent(quotedEvent, parsed);
+      const quoted = extractInboundMessage(quotedEvent, client);
+      const content = messageType === 'interactive'
+        ? interactiveCardText(parsed)
+        : quoted.content;
+      const attachments = feishuReplyAttachments(messageType, parsed, post);
+      return {
+        messageId,
+        ...(nonEmptyString(item.sender?.id) ? { authorId: nonEmptyString(item.sender.id) } : {}),
+        ...(nonEmptyString(item.sender?.sender_name)
+          ? { authorName: nonEmptyString(item.sender.sender_name) }
+          : {}),
+        ...(content ? { content } : {}),
+        attachments,
+        ...(messageType === 'interactive' && !content && attachments.length === 0
+          ? { unavailableReason: 'unsupported' }
+          : {}),
+      };
+    },
+  };
+}
+
 export function extractInboundMessage(event, client) {
   const messageType = event?.message?.message_type;
   const parsed = parsedMessageContent(event);
@@ -292,10 +519,12 @@ export function extractInboundMessage(event, client) {
     : null;
   const imageKeys = standaloneImageKey ? [standaloneImageKey] : post?.imageKeys ?? [];
   const file = messageType === 'file' ? feishuFileSource(event, client, parsed) : null;
+  const replyTo = feishuReplyReference(event, client);
   return {
     content: messageType === 'text' ? extractText(event) ?? '' : post?.text ?? '',
     images: imageKeys.map((key) => feishuImageSource(event, client, key)),
     files: file ? [file] : [],
+    ...(replyTo ? { replyTo } : {}),
   };
 }
 

package/src/channels/qq/qq-bridge.mjs

@@ -33,7 +33,6 @@ import {
   hasInboundImages,
   imagePromptDiagnostic,
   imagePromptUserMessage,
-  promptContentForMessage,
 } from '../shared/image-prompt.mjs';
 import {
   hasInboundFiles,
@@ -44,6 +43,10 @@ import {
   trackOutboundArtifactProviderPromise,
 } from '../shared/semantic/artifact.mjs';
 import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
+import {
+  hasReplyReference,
+  promptContentForInboundMessage,
+} from '../shared/semantic/reply-reference.mjs';
 import {
   createDeliveryReceipt,
   providerMessageIdsFor,
@@ -145,6 +148,37 @@ function hasQqFileAttachments(message) {
     && message.attachments.some((attachment) => !isQqImageAttachment(attachment));
 }
 
+function qqAttachmentKind(attachment) {
+  const mediaType = attachmentMediaType(attachment);
+  if (mediaType?.startsWith('image/')) return 'image';
+  if (mediaType?.startsWith('audio/')) return 'audio';
+  if (mediaType?.startsWith('video/')) return 'video';
+  return 'file';
+}
+
+function qqReplyReference(message) {
+  const refMsgIdx = nonEmptyString(message?.refMsgIdx);
+  if (!refMsgIdx) return null;
+  const element = Array.isArray(message?.msgElements) ? message.msgElements[0] : null;
+  const sourceAttachments = Array.isArray(element?.attachments) ? element.attachments : [];
+  const attachments = sourceAttachments.map((attachment) => {
+    const name = nonEmptyString(attachment?.filename);
+    return { kind: qqAttachmentKind(attachment), ...(name ? { name } : {}) };
+  });
+  const asrText = sourceAttachments
+    .filter((attachment) => qqAttachmentKind(attachment) === 'audio')
+    .map((attachment) => nonEmptyString(attachment?.asr_refer_text))
+    .filter(Boolean)
+    .join('\n');
+  const content = asrText || nonEmptyString(element?.content);
+  return {
+    messageId: refMsgIdx,
+    ...(content ? { content } : {}),
+    ...(attachments.length > 0 ? { attachments } : {}),
+    ...(!content && attachments.length === 0 ? { unavailableReason: 'not-delivered' } : {}),
+  };
+}
+
 async function fetchQqFileBuffer(url, { fetchImpl, signal }) {
   const normalizedUrl = url.startsWith('//') ? `https:${url}` : url;
   const response = await fetchImpl(new URL(normalizedUrl), {
@@ -196,7 +230,13 @@ export function qqInboundMessage(message, { fetchImpl = fetch } = {}) {
       },
     });
   }
-  return { content: safeText(message), images, files };
+  const replyTo = qqReplyReference(message);
+  return {
+    content: safeText(message),
+    images,
+    files,
+    ...(replyTo ? { replyTo } : {}),
+  };
 }
 
 function nonEmptyString(value) {
@@ -493,7 +533,8 @@ export class QqHarnessBridge {
         : this.#batchInputs.handle(key, commandText, {
             plainText: Boolean(commandText)
               && !hasQqImageAttachments(message)
-              && !hasQqFileAttachments(message),
+              && !hasQqFileAttachments(message)
+              && !qqReplyReference(message),
           });
       if (result.handled) {
         if (result.kind === 'submit') {
@@ -785,10 +826,11 @@ export class QqHarnessBridge {
     const text = promptMessage.content;
     const hasImages = hasInboundImages(promptMessage);
     const hasFiles = hasInboundFiles(promptMessage);
+    const hasReply = hasReplyReference(promptMessage);
     let stream = null;
     let batchSettled = batchSubmission === null;
     try {
-      if (!text && !hasImages && !hasFiles) {
+      if (!text && !hasImages && !hasFiles && !hasReply) {
         await this.#bot.sendText(target, t('目前支持文字、图片和文件消息。'));
         await markMessageSeen();
         return;
@@ -836,8 +878,8 @@ export class QqHarnessBridge {
         return;
       }
 
-      let content = hasImages
-        ? await promptContentForMessage(promptMessage, { signal: this.#signal })
+      let content = hasImages || hasReply
+        ? await promptContentForInboundMessage(promptMessage, { signal: this.#signal })
         : undefined;
       const snapshot = this.#acceptedMessageIds.get(messageId);
       let contextEnhanced = false;

package/src/channels/shared/batch-input.mjs

@@ -74,7 +74,7 @@ export class BatchInputManager {
     if (!batch) {
       if (!name) return { handled: false };
       if (!plainText) {
-        return result('unsupported-content', t('批量输入命令仅支持纯文字，请移除图片或文件后重试。'));
+        return result('unsupported-content', t('批量输入命令仅支持纯文字，请移除图片、文件或引用消息后重试。'));
       }
       if (name === 'send') {
         return result('no-batch', t('当前没有待提交的批量内容，请先发送 /batch。'));
@@ -91,7 +91,7 @@ export class BatchInputManager {
     }
 
     if (!plainText && (batch.phase === 'collecting' || name)) {
-      return result('unsupported-content', t(`批量输入模式目前仅支持文字，这条消息未收录。
+      return result('unsupported-content', t(`批量输入模式目前仅支持文字，不支持图片、文件或引用消息，这条消息未收录。
 请继续发送文字，或使用 /send、/cancel。`), {
         count: batch.messages.length,
         limit: BATCH_INPUT_LIMIT,
@@ -146,7 +146,7 @@ export class BatchInputManager {
     }
 
     if (typeof text !== 'string') {
-      return result('unsupported-content', t(`批量输入模式目前仅支持文字，这条消息未收录。
+      return result('unsupported-content', t(`批量输入模式目前仅支持文字，不支持图片、文件或引用消息，这条消息未收录。
 请继续发送文字，或使用 /send、/cancel。`), {
         count: batch.messages.length,
         limit: BATCH_INPUT_LIMIT,

package/src/channels/shared/harness-client.mjs

@@ -7,6 +7,12 @@ import {
   appendInboundFilesToPrompt,
   InboundFileError,
 } from './inbound-file.mjs';
+import {
+  IMAGE_FILE_FALLBACK_PROMPT,
+  contentWithoutImages,
+  imageFileSourcesFromContent,
+  isModelImageRejection,
+} from './image-prompt.mjs';
 import { outboundArtifactRegistry } from './semantic/artifact.mjs';
 import { t } from './i18n.mjs';
 import { watchHarnessMux } from './harness-mux.mjs';
@@ -1242,6 +1248,31 @@ export class HarnessClient {
     return ownership ? { ownership, recovered: true } : null;
   }
 
+  /** Stage inbound file sources into the Session workspace via the Host executor. */
+  async #stageWorkspaceFiles(sessionId, files, signal) {
+    if (!this.#fileIngressExecutor) {
+      throw new InboundFileError(
+        'inbound-file-ingress-unavailable',
+        'Harness file ingress is unavailable in this Host process.',
+      );
+    }
+    const sessionList = await this.rpc(
+      'session.list',
+      {},
+      30_000,
+      { signal },
+    );
+    const sessionWorkspace = sessionList?.items?.find(
+      (item) => item?.sessionId === sessionId,
+    )?.cwd;
+    return this.#fileIngressExecutor({
+      sessionId,
+      workspace: sessionWorkspace,
+      files,
+      signal,
+    });
+  }
+
   async ask(sessionId, prompt, options = {}) {
     if (typeof options === 'number') options = { timeoutMs: options };
     const timeoutMs = options.timeoutMs ?? 600_000;
@@ -1298,7 +1329,7 @@ export class HarnessClient {
     let interactionTask = null;
     let artifactsDelivered = false;
     let deliveredArtifactCount = 0;
-    let stagedInboundFiles = null;
+    const stagedBatches = [];
     let promptAccepted = false;
     let turnFinished = false;
 
@@ -1329,29 +1360,11 @@ export class HarnessClient {
     const closeArtifactConsumer = outboundArtifactRegistry.openConsumer(sessionId, promptRpcId);
 
     try {
+      const basePrompt = prompt;
       if (inboundFiles.length > 0) {
-        if (!this.#fileIngressExecutor) {
-          throw new InboundFileError(
-            'inbound-file-ingress-unavailable',
-            'Harness file ingress is unavailable in this Host process.',
-          );
-        }
-        const sessionList = await this.rpc(
-          'session.list',
-          {},
-          30_000,
-          { signal },
-        );
-        const sessionWorkspace = sessionList?.items?.find(
-          (item) => item?.sessionId === sessionId,
-        )?.cwd;
-        stagedInboundFiles = await this.#fileIngressExecutor({
-          sessionId,
-          workspace: sessionWorkspace,
-          files: inboundFiles,
-          signal,
-        });
-        prompt = appendInboundFilesToPrompt(prompt, stagedInboundFiles);
+        const staged = await this.#stageWorkspaceFiles(sessionId, inboundFiles, signal);
+        stagedBatches.push(staged);
+        prompt = appendInboundFilesToPrompt(prompt, staged);
       }
       if (interactionSignal) {
         let markOpen;
@@ -1378,12 +1391,47 @@ export class HarnessClient {
       if (!Array.isArray(content) || content.length === 0) {
         throw new TypeError('Harness prompt content is required');
       }
-      await this.rpc('session.prompt', {
+      const clientTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const sendPrompt = (promptContent) => this.rpc('session.prompt', {
         sessionId,
         mode: 'queue',
-        content,
-        clientTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        content: promptContent,
+        clientTimeZone,
       }, 30_000, { rpcId: promptRpcId, signal });
+      try {
+        await sendPrompt(content);
+      } catch (error) {
+        // The Host refuses image blocks for a non-vision model before any
+        // durable user message exists. Re-deliver the same bytes the way
+        // ordinary uploads (zip, documents) already travel — staged into the
+        // Session workspace and named in a text manifest — then retry once
+        // with a text-only prompt. The retry reuses promptRpcId so reply
+        // tracking, control and interaction ownership stay bound to this ask.
+        const imageSources = isModelImageRejection(error)
+          ? imageFileSourcesFromContent(content)
+          : [];
+        if (imageSources.length === 0) throw error;
+        let stagedImages;
+        try {
+          stagedImages = await this.#stageWorkspaceFiles(sessionId, imageSources, signal);
+        } catch (stagingError) {
+          if (signal?.aborted) throw signal.reason ?? stagingError;
+          console.warn(
+            `[${this.#logPrefix}] unable to restage rejected images as workspace files:`,
+            stagingError?.message ?? String(stagingError),
+          );
+          throw error;
+        }
+        stagedBatches.push(stagedImages);
+        const baseContent = typeof basePrompt === 'string'
+          ? [{ type: 'text', text: basePrompt }]
+          : basePrompt;
+        const fallbackPrompt = appendInboundFilesToPrompt([
+          ...contentWithoutImages(baseContent),
+          { type: 'text', text: t(IMAGE_FILE_FALLBACK_PROMPT) },
+        ], { files: stagedBatches.flatMap((batch) => batch?.files ?? []) });
+        await sendPrompt(fallbackPrompt);
+      }
       promptAccepted = true;
 
       try {
@@ -1441,10 +1489,14 @@ export class HarnessClient {
         throw turnStoppedError();
       }
     } finally {
-      if (stagedInboundFiles && (!promptAccepted || turnFinished)) {
-        await stagedInboundFiles.cleanup().catch((error) => {
-          console.warn(`[${this.#logPrefix}] unable to clean inbound files:`, error.message);
-        });
+      if (!promptAccepted || turnFinished) {
+        for (const staged of stagedBatches) {
+          try {
+            await staged?.cleanup?.();
+          } catch (error) {
+            console.warn(`[${this.#logPrefix}] unable to clean inbound files:`, error.message);
+          }
+        }
       }
       closeArtifactConsumer();
       if (ownership) {

package/src/channels/shared/i18n-en/shared-c.mjs

@@ -81,6 +81,8 @@ export default {
   // image-prompt.mjs
   '当前模型不支持图片，请用 /models 查看可用模型，再用 /model <序号> 切换后重发。':
     'The current model does not support images. Use /models to list available models, switch with /model <number>, then resend.',
+  '当前会话模型不支持直接接收图片输入。用户发送的图片已作为文件保存到工作区（见下方文件清单）。请使用可用工具分析这些图片文件后回答，例如 run_code 或 pwsh 读取字节、解析元数据、调用图像处理或 OCR 库；不要假设自己能直接看到图片内容。':
+    'The current session model does not accept direct image input. The images sent by the user were saved into the workspace as files (see the file manifest below). Answer by analyzing those image files with the available tools — for example run_code or pwsh to read bytes, parse metadata, or call image-processing or OCR libraries — and do not assume you can see the images directly.',
   '图片超过宿主允许的大小，请压缩后重试。':
     'The image exceeds the size allowed by the host; compress it and try again.',
   '图片分辨率过高，请压缩后重试。':
@@ -157,15 +159,15 @@ export default {
   '当前聊天有正在运行的任务、待回答问题或待审批请求。\n请先完成当前交互或发送 /stop，再使用 /batch。':
     'This chat has a running task, unanswered question, or pending approval.\nFinish the current interaction or send /stop before using /batch.',
   '用法：/{command}（不带参数）': 'Usage: /{command} (without arguments)',
-  '批量输入命令仅支持纯文字，请移除图片或文件后重试。':
-    'Batch input commands support text only. Remove the image or file and try again.',
+  '批量输入命令仅支持纯文字，请移除图片、文件或引用消息后重试。':
+    'Batch input commands support text only. Remove the image, file, or quoted message and try again.',
   '当前没有待提交的批量内容，请先发送 /batch。':
     'There is no batch to submit. Send /batch first.',
   '当前没有正在进行的批量输入。': 'There is no active batch input.',
   '已进入批量输入模式，最多可发送 {limit} 条文字。\n完成后发送 /send，取消请发送 /cancel。':
     'Batch input started. You can send up to {limit} text messages.\nSend /send when finished or /cancel to cancel.',
-  '批量输入模式目前仅支持文字，这条消息未收录。\n请继续发送文字，或使用 /send、/cancel。':
-    'Batch input currently supports text only, so this message was not collected.\nContinue with text, or use /send or /cancel.',
+  '批量输入模式目前仅支持文字，不支持图片、文件或引用消息，这条消息未收录。\n请继续发送文字，或使用 /send、/cancel。':
+    'Batch input currently supports text only, not images, files, or quoted messages, so this message was not collected.\nContinue with text, or use /send or /cancel.',
   '当前批次正在提交，请勿重复发送 /send。':
     'The current batch is being submitted. Do not send /send again.',
   '批量内容已经提交，无法取消。\n如需停止当前任务，请发送 /stop。':

package/src/channels/shared/image-prompt.mjs

@@ -6,6 +6,12 @@ const DEFAULT_MAX_TOTAL_IMAGE_BYTES = 20 * 1024 * 1024;
 
 export const DEFAULT_IMAGE_PROMPT = '请分析这张图片。';
 
+/**
+ * Model-facing guidance appended when the Host refuses image input for the
+ * current model and the same images are re-delivered as workspace files.
+ */
+export const IMAGE_FILE_FALLBACK_PROMPT = '当前会话模型不支持直接接收图片输入。用户发送的图片已作为文件保存到工作区（见下方文件清单）。请使用可用工具分析这些图片文件后回答，例如 run_code 或 pwsh 读取字节、解析元数据、调用图像处理或 OCR 库；不要假设自己能直接看到图片内容。';
+
 export class ImagePromptError extends Error {
   constructor(code, message, userMessage, options = {}) {
     super(message, options);
@@ -299,3 +305,48 @@ export function imagePromptDiagnostic(error) {
 export function imagePromptUserMessage(error) {
   return imagePromptDiagnostic(error)?.userMessage ?? null;
 }
+
+const IMAGE_FILE_EXTENSIONS = new Map([
+  ['image/png', '.png'],
+  ['image/jpeg', '.jpg'],
+  ['image/gif', '.gif'],
+  ['image/webp', '.webp'],
+]);
+
+const IMAGE_EXTENSION_PATTERN = /\.(?:png|jpe?g|gif|webp)$/i;
+
+function imageStorageName(name, mediaType, index) {
+  const extension = IMAGE_FILE_EXTENSIONS.get(mediaType) ?? '.img';
+  const cleaned = safeName(name);
+  if (cleaned && IMAGE_EXTENSION_PATTERN.test(cleaned)) return cleaned;
+  return `${cleaned ?? `image-${index + 1}`}${extension}`;
+}
+
+/**
+ * Convert already-admitted image content blocks into inbound file sources so
+ * the same bytes can reach a non-vision model as workspace files — the path
+ * ordinary uploads such as zip archives already take.
+ */
+export function imageFileSourcesFromContent(content) {
+  if (!Array.isArray(content)) return [];
+  return content
+    .filter((part) => part?.type === 'image')
+    .map((part, index) => ({
+      name: imageStorageName(part.name, part.mediaType, index),
+      ...(typeof part.mediaType === 'string' && part.mediaType.trim()
+        ? { mediaType: part.mediaType.trim() }
+        : {}),
+      data: Buffer.from(typeof part.data === 'string' ? part.data : '', 'base64'),
+    }));
+}
+
+/** Return the same content with every image block removed. */
+export function contentWithoutImages(content) {
+  return Array.isArray(content) ? content.filter((part) => part?.type !== 'image') : content;
+}
+
+/** Whether an error is the Host rejecting image input for a non-vision model. */
+export function isModelImageRejection(error) {
+  return error?.code === 'attachment-error'
+    && error?.details?.reason === 'MODEL_DOES_NOT_SUPPORT_IMAGES';
+}