@keyou007/agent-bot 0.1.14 → 0.1.15-alpha.0

package/dist/proxy/ProxySessionController.js

@@ -7,6 +7,7 @@ import { CommandRouter } from "../commands/CommandRouter.js";
 import { baseChatContextKey, isThreadContextKey } from "../feishu/contextKey.js";
 import { CardRenderer, } from "../feishu/CardRenderer.js";
 import { generateGroupAvatarPng, resolveGroupAvatarProjectName } from "../feishu/GroupAvatarGenerator.js";
+import { normalizeFeishuPostText } from "../feishu/InboundText.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import { createId } from "../utils/id.js";
@@ -23,6 +24,9 @@ const RESET_HISTORY_PAGE_SIZE = 10;
 const MAX_LLM_TURN_RETRIES = 3;
 const RECOVERY_ACTIVITY_WINDOW_MS = 5 * 60 * 1_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
+const FORWARD_ATTACHMENT_WINDOW_MS = 800;
+const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
+const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
 const REMOTE_SESSION_REFERENCE_PREFIX = "agent-runtime:";
 const WINDOWS_DRIVES_DIRECTORY = "agentbot://windows-drives";
 const IMAGE_FILE_EXTENSIONS = new Set([
@@ -175,6 +179,9 @@ export class ProxySessionController {
     llmRetryingSessions = new Set();
     retriedFailureTurnIds = new Set();
     recoveryRetryTimers = new Map();
+    pendingMergedForwards = new Map();
+    pendingResourceForwards = new Map();
+    relatedReactionMessageIds = new Map();
     unsubscribe = [];
     recoveryActivityHeartbeat;
     startupRecovery;
@@ -203,6 +210,9 @@ export class ProxySessionController {
         this.recoveryActivityHeartbeat.unref?.();
     }
     async onMessage(message) {
+        let forwardedImages = [];
+        let forwardedFiles = [];
+        let coalescedForwardAttachment = false;
         if (!message.contextKey.startsWith("console:") && !allowsFeishuUser(this.config, message.userId)) {
             this.logger.debug({ messageId: message.messageId }, "Ignored a Feishu message from a non-owner before acknowledgement.");
             return;
@@ -217,6 +227,15 @@ export class ProxySessionController {
         // retries cannot add duplicate reactions.
         if (!this.store.claimInboundEvent(message.messageId, "message"))
             return;
+        const attachmentReservation = message.mergedForwardMessageId
+            ? undefined
+            : this.reserveForwardAttachment(message);
+        const pendingMergedForward = message.mergedForwardMessageId
+            ? this.registerPendingForwardAttachment(message, this.pendingMergedForwards)
+            : undefined;
+        const pendingResourceForward = !attachmentReservation && isStandaloneResourceMessage(message)
+            ? this.registerPendingForwardAttachment(message, this.pendingResourceForwards)
+            : undefined;
         try {
             const reactionId = await this.outbound.addReaction(message.contextKey, message.messageId, MESSAGE_RECEIVED_REACTION);
             if (reactionId) {
@@ -226,6 +245,13 @@ export class ProxySessionController {
         catch (error) {
             this.logger.warn({ error, messageId: message.messageId, contextKey: message.contextKey }, "Failed to acknowledge the incoming Feishu message with a reaction.");
         }
+        if (attachmentReservation && this.completeForwardAttachment(message, attachmentReservation)) {
+            this.store.audit(message.contextKey, `${attachmentReservation.sourceKind}_attachment_coalesced`, {
+                messageId: message.messageId,
+                parentMessageId: message.parentMessageId,
+            });
+            return;
+        }
         if (message.chatType === "p2p" && message.userId?.startsWith("ou_")) {
             try {
                 await this.lifecycle?.rememberFeishuUserOpenId?.(message.userId);
@@ -239,19 +265,135 @@ export class ProxySessionController {
             this.store.recordChatContext(chatContextKey, message.chatType);
             this.store.markChatActive(chatContextKey);
         }
+        if (pendingResourceForward) {
+            const resourceMessage = message;
+            const attachment = await this.waitForForwardAttachment(message.messageId, pendingResourceForward, this.pendingResourceForwards);
+            if (attachment) {
+                coalescedForwardAttachment = true;
+                const instruction = normalizeFeishuPostText(attachment.text) || defaultResourcePrompt(resourceMessage);
+                forwardedImages = (resourceMessage.images ?? []).map((image) => ({
+                    messageId: resourceMessage.messageId,
+                    imageKey: image.imageKey,
+                }));
+                forwardedFiles = (resourceMessage.files ?? []).map((file) => ({
+                    messageId: resourceMessage.messageId,
+                    fileKey: file.fileKey,
+                    fileName: file.fileName,
+                }));
+                message = {
+                    ...attachment,
+                    text: instruction,
+                    displayText: instruction,
+                };
+                this.relatedReactionMessageIds.set(message.messageId, [resourceMessage.messageId]);
+            }
+        }
+        if (message.mergedForwardMessageId) {
+            const mergedForwardMessage = message;
+            const mergedForwardResult = this.outbound.readMergedForward(message.contextKey, message.mergedForwardMessageId).then((content) => ({ content }), (error) => ({ error }));
+            const attachment = pendingMergedForward
+                ? await this.waitForForwardAttachment(message.messageId, pendingMergedForward, this.pendingMergedForwards)
+                : undefined;
+            if (attachment) {
+                coalescedForwardAttachment = true;
+                const instruction = normalizeFeishuPostText(attachment.text)
+                    || ((attachment.images?.length ?? 0) > 0 ? "请查看附带的内容。" : "请结合参考聊天记录处理。");
+                message = {
+                    ...attachment,
+                    text: instruction,
+                    displayText: instruction,
+                };
+                this.relatedReactionMessageIds.set(message.messageId, [mergedForwardMessage.messageId]);
+            }
+            const result = await mergedForwardResult;
+            if ("error" in result) {
+                const replyTarget = message.replyInThread
+                    ? { messageId: message.messageId, replyInThread: true }
+                    : undefined;
+                await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
+                const detail = result.error instanceof Error ? result.error.message : String(result.error);
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取合并转发消息：${detail}`)));
+                return;
+            }
+            const instruction = message.displayText ?? DEFAULT_MERGED_FORWARD_INSTRUCTION;
+            forwardedImages = result.content.images;
+            forwardedFiles = result.content.files;
+            message = {
+                ...message,
+                displayText: instruction,
+                text: mergedForwardPrompt(instruction, result.content.text),
+            };
+        }
+        const referencedMessageId = coalescedForwardAttachment ? undefined : quotedMessageId(message);
+        if (referencedMessageId) {
+            try {
+                const referenced = await this.resolveReferencedMessage(message.contextKey, referencedMessageId);
+                const instruction = normalizeFeishuPostText(message.displayText ?? message.text)
+                    || DEFAULT_REFERENCED_MESSAGE_INSTRUCTION;
+                forwardedImages = [...referenced.images, ...forwardedImages];
+                forwardedFiles = [...referenced.files, ...forwardedFiles];
+                message = {
+                    ...message,
+                    displayText: instruction,
+                    text: referencedMessagePrompt(instruction, referenced.text),
+                };
+            }
+            catch (error) {
+                const replyTarget = message.replyInThread
+                    ? { messageId: message.messageId, replyInThread: true }
+                    : undefined;
+                await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
+                const detail = error instanceof Error ? error.message : String(error);
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取引用消息：${detail}`)));
+                return;
+            }
+        }
         const replyTarget = message.replyInThread
             ? { messageId: message.messageId, replyInThread: true }
             : undefined;
-        const imageCount = message.images?.length ?? 0;
+        const imageReferences = deduplicateImageReferences([
+            ...forwardedImages,
+            ...(message.images ?? []).map((image) => ({ messageId: message.messageId, imageKey: image.imageKey })),
+        ]);
+        const fileReferences = deduplicateFileReferences([
+            ...forwardedFiles,
+            ...(message.files ?? []).map((file) => ({
+                messageId: message.messageId,
+                fileKey: file.fileKey,
+                fileName: file.fileName,
+            })),
+        ]);
+        const imageCount = imageReferences.length;
+        const fileCount = fileReferences.length;
         this.store.audit(message.contextKey, "incoming_message", {
             messageId: message.messageId,
             text: message.text,
             ...(imageCount > 0 ? { imageCount } : {}),
+            ...(fileCount > 0 ? { fileCount } : {}),
         });
         let localImagePaths;
         if (imageCount > 0) {
             try {
-                localImagePaths = await Promise.all(message.images.map((image) => this.outbound.downloadImage(message.contextKey, message.messageId, image.imageKey)));
+                localImagePaths = await Promise.all(imageReferences.map((image) => this.outbound.downloadImage(message.contextKey, image.messageId, image.imageKey)));
+            }
+            catch (error) {
+                await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error));
+                return;
+            }
+        }
+        if (fileCount > 0) {
+            try {
+                const downloadedFiles = await Promise.all(fileReferences.map(async (file) => ({
+                    fileName: file.fileName,
+                    filePath: await this.outbound.downloadFile(message.contextKey, file.messageId, file.fileKey, file.fileName),
+                })));
+                const instruction = message.text.trim() || defaultResourcePromptFromCounts(imageCount, fileCount);
+                message = {
+                    ...message,
+                    displayText: message.displayText ?? instruction,
+                    text: appendDownloadedFiles(instruction, downloadedFiles),
+                };
             }
             catch (error) {
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
@@ -261,8 +403,9 @@ export class ProxySessionController {
         }
         let command;
         try {
-            command = imageCount > 0 && !message.text.trimStart().startsWith("/")
-                ? { type: "prompt", text: message.text.trim() || "请查看这张图片" }
+            const resourceCount = imageCount + fileCount;
+            command = resourceCount > 0 && !message.text.trimStart().startsWith("/")
+                ? { type: "prompt", text: message.text.trim() || defaultResourcePromptFromCounts(imageCount, fileCount) }
                 : this.router.parse(message.text);
         }
         catch (error) {
@@ -567,6 +710,13 @@ export class ProxySessionController {
         this.queuedPromptCards.clear();
         this.queuedPromptCardWrites.clear();
         this.sessionResets.clear();
+        for (const pending of this.pendingMergedForwards.values())
+            pending.resolveAttachment(undefined);
+        this.pendingMergedForwards.clear();
+        for (const pending of this.pendingResourceForwards.values())
+            pending.resolveAttachment(undefined);
+        this.pendingResourceForwards.clear();
+        this.relatedReactionMessageIds.clear();
         for (const timer of this.recoveryRetryTimers.values())
             clearTimeout(timer);
         this.recoveryRetryTimers.clear();
@@ -1102,7 +1252,7 @@ export class ProxySessionController {
                 await this.setTitle(contextKey, command.title);
                 return;
             case "prompt":
-                await this.prompt(contextKey, command.text, messageId, replyTarget, localImagePaths);
+                await this.prompt(contextKey, command.text, messageId, replyTarget, localImagePaths, incomingMessage?.displayText);
                 return;
             case "nosteer":
                 await this.enqueueNoSteerPrompt(contextKey, command.text, messageId, replyTarget);
@@ -1513,22 +1663,23 @@ export class ProxySessionController {
             await this.finalizeTurnMessageReactions(turnId, status);
         }
     }
-    async prompt(contextKey, text, messageId, replyTarget, localImagePaths) {
+    async prompt(contextKey, text, messageId, replyTarget, localImagePaths, displayPrompt) {
         if (!text.trim())
             throw new Error("请输入要交给 Agent 的内容。");
         let record = this.currentSession(contextKey);
         if (!record) {
             const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent);
-            record = await this.createSession(contextKey, context.defaultAgent, this.inheritedNewTaskCwd(contextKey), false, true, text, replyTarget);
+            record = await this.createSession(contextKey, context.defaultAgent, this.inheritedNewTaskCwd(contextKey), false, true, displayPrompt ?? text, replyTarget);
         }
-        await this.promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths);
+        await this.promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths, displayPrompt);
     }
-    async promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths) {
+    async promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths, displayPrompt) {
         if (this.llmRetryingSessions.has(record.localSessionId)) {
             const queued = this.persistQueuedPrompt(record.localSessionId, contextKey, text, {
                 localImagePaths,
                 messageId,
                 replyTarget,
+                displayPrompt,
             });
             this.store.audit(contextKey, "queued_prompt_added_during_llm_retry", {
                 promptId: queued.promptId,
@@ -1540,7 +1691,7 @@ export class ProxySessionController {
         const configuredRuntime = this.runtimes.forAgent(record.agentName);
         if (!configuredRuntime.getSession(record.localSessionId)) {
             this.outbound.registerSession(record.localSessionId, contextKey, record.title, record.cwd, this.agentLabel(record.agentName));
-            await this.outbound.startPendingTurn(record.localSessionId, contextKey, record.title, replyTarget, text);
+            await this.outbound.startPendingTurn(record.localSessionId, contextKey, record.title, replyTarget, displayPrompt ?? text);
         }
         let loaded;
         try {
@@ -1574,12 +1725,13 @@ export class ProxySessionController {
                     localImagePaths,
                     messageId,
                     replyTarget,
+                    displayPrompt,
                 });
                 return;
             }
             try {
                 await loaded.runtime.steerTurn(record.localSessionId, activeTurnId, runtimePrompt(text, localImagePaths));
-                await this.presentSteerMessage(record.localSessionId, activeTurnId, text, messageId);
+                await this.presentSteerMessage(record.localSessionId, activeTurnId, displayPrompt ?? text, messageId);
                 if (messageId)
                     await this.bindMessageReactionToTurn(messageId, record.localSessionId, activeTurnId);
                 return;
@@ -1594,7 +1746,7 @@ export class ProxySessionController {
                     this.logger.warn({ error: syncError, sessionId: record.localSessionId }, "Failed to synchronize after steering failure.");
                 }
                 if (!current?.activeTurnId) {
-                    const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId });
+                    const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId, displayPrompt });
                     if (messageId)
                         await this.bindMessageReactionToTurn(messageId, record.localSessionId, turnId);
                     return;
@@ -1602,7 +1754,7 @@ export class ProxySessionController {
                 if (current.activeTurnId !== activeTurnId) {
                     try {
                         await loaded.runtime.steerTurn(record.localSessionId, current.activeTurnId, runtimePrompt(text, localImagePaths));
-                        await this.presentSteerMessage(record.localSessionId, current.activeTurnId, text, messageId);
+                        await this.presentSteerMessage(record.localSessionId, current.activeTurnId, displayPrompt ?? text, messageId);
                         if (messageId)
                             await this.bindMessageReactionToTurn(messageId, record.localSessionId, current.activeTurnId);
                         return;
@@ -1615,11 +1767,12 @@ export class ProxySessionController {
                     localImagePaths,
                     messageId,
                     replyTarget,
+                    displayPrompt,
                 });
                 return;
             }
         }
-        const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId });
+        const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId, displayPrompt });
         if (messageId)
             await this.bindMessageReactionToTurn(messageId, record.localSessionId, turnId);
     }
@@ -1651,6 +1804,7 @@ export class ProxySessionController {
             localImagePaths: options.localImagePaths,
             messageId: options.messageId,
             replyMessageId: options.replyTarget?.messageId,
+            displayPrompt: options.displayPrompt,
         });
     }
     async cancelQueuedPrompt(action) {
@@ -1711,7 +1865,7 @@ export class ProxySessionController {
             contextKey,
             prompts: this.store.listQueuedPrompts(localSessionId).map((prompt) => ({
                 id: prompt.promptId,
-                text: prompt.text,
+                text: prompt.displayPrompt ?? prompt.text,
             })),
         });
     }
@@ -2128,7 +2282,7 @@ export class ProxySessionController {
     }
     async startTurn(loaded, text, replyTarget, localImagePaths, options = {}) {
         const currentRecord = this.store.getSession(loaded.record.localSessionId);
-        const title = currentRecord?.title ?? normalizeTaskTitle(text);
+        const title = currentRecord?.title ?? normalizeTaskTitle(options.displayPrompt ?? text);
         if (!currentRecord?.title && title)
             this.store.updateRuntimeSession(loaded.record.localSessionId, { title });
         if (title)
@@ -2607,7 +2761,7 @@ export class ProxySessionController {
             const record = this.store.getSessionForContext(sessionId, prompt.contextKey) ?? baseRecord;
             loaded = { ...loaded, record };
             await this.refreshPromptQueueCards(sessionId);
-            const turnId = await this.startTurn(loaded, prompt.text, prompt.replyMessageId ? { messageId: prompt.replyMessageId, replyInThread: true } : undefined, prompt.localImagePaths, { messageId: prompt.messageId });
+            const turnId = await this.startTurn(loaded, prompt.text, prompt.replyMessageId ? { messageId: prompt.replyMessageId, replyInThread: true } : undefined, prompt.localImagePaths, { messageId: prompt.messageId, displayPrompt: prompt.displayPrompt });
             if (prompt.messageId)
                 await this.bindMessageReactionToTurn(prompt.messageId, sessionId, turnId);
         }
@@ -2633,13 +2787,17 @@ export class ProxySessionController {
             : this.store.findLatestCompletedTurnId(source.localSessionId, source.contextKey);
     }
     async finalizeStandaloneMessageReaction(messageId, status) {
-        const reaction = this.store.claimMessageReaction(messageId);
-        if (reaction)
-            await this.replaceMessageReaction(reaction, status);
+        for (const relatedMessageId of this.takeRelatedReactionMessageIds(messageId)) {
+            const reaction = this.store.claimMessageReaction(relatedMessageId);
+            if (reaction)
+                await this.replaceMessageReaction(reaction, status);
+        }
     }
     async bindMessageReactionToTurn(messageId, sessionId, turnId) {
-        this.store.bindMessageToTurn(messageId, sessionId, turnId);
-        this.store.bindMessageReaction(messageId, sessionId, turnId);
+        for (const relatedMessageId of this.takeRelatedReactionMessageIds(messageId)) {
+            this.store.bindMessageToTurn(relatedMessageId, sessionId, turnId);
+            this.store.bindMessageReaction(relatedMessageId, sessionId, turnId);
+        }
         const session = this.store.getSession(sessionId);
         if (session?.lastTurnId !== turnId)
             return;
@@ -2647,6 +2805,90 @@ export class ProxySessionController {
             await this.finalizeTurnMessageReactions(turnId, session.lastTurnStatus);
         }
     }
+    registerPendingForwardAttachment(message, registry) {
+        let resolveAttachment;
+        const attachmentPromise = new Promise((resolve) => {
+            resolveAttachment = resolve;
+        });
+        const pending = {
+            contextKey: message.contextKey,
+            attachmentPromise,
+            resolveAttachment,
+        };
+        registry.set(message.messageId, pending);
+        return pending;
+    }
+    reserveForwardAttachment(message) {
+        if (!message.parentMessageId)
+            return undefined;
+        const candidates = [
+            { sourceKind: "merged_forward", registry: this.pendingMergedForwards },
+            { sourceKind: "resource", registry: this.pendingResourceForwards },
+        ];
+        for (const candidate of candidates) {
+            const pending = candidate.registry.get(message.parentMessageId);
+            if (!pending || pending.contextKey !== message.contextKey || pending.attachmentMessageId)
+                continue;
+            pending.attachmentMessageId = message.messageId;
+            return {
+                sourceMessageId: message.parentMessageId,
+                sourceKind: candidate.sourceKind,
+                pending,
+                registry: candidate.registry,
+            };
+        }
+        return undefined;
+    }
+    completeForwardAttachment(message, reservation) {
+        if (!message.parentMessageId)
+            return false;
+        if (reservation.sourceMessageId !== message.parentMessageId)
+            return false;
+        if (reservation.registry.get(message.parentMessageId) !== reservation.pending)
+            return false;
+        if (reservation.pending.attachmentMessageId !== message.messageId)
+            return false;
+        reservation.pending.resolveAttachment(message);
+        return true;
+    }
+    async waitForForwardAttachment(messageId, pending, registry) {
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(undefined), FORWARD_ATTACHMENT_WINDOW_MS);
+            timer.unref?.();
+        });
+        try {
+            return await Promise.race([pending.attachmentPromise, timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            if (registry.get(messageId) === pending) {
+                registry.delete(messageId);
+            }
+        }
+    }
+    async resolveReferencedMessage(contextKey, messageId) {
+        const local = this.store.findAgentBotTurnMessageById(messageId);
+        if (local) {
+            const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(local.turnId));
+            const text = snapshot ? renderLocalTurnReference(snapshot, local.messageKind) : undefined;
+            if (text) {
+                return {
+                    text,
+                    messageType: local.messageKind === "final" ? "agent_bot_reply" : "agent_bot_progress",
+                    images: [],
+                    files: [],
+                };
+            }
+        }
+        return this.outbound.readReferencedMessage(contextKey, messageId);
+    }
+    takeRelatedReactionMessageIds(messageId) {
+        const related = this.relatedReactionMessageIds.get(messageId) ?? [];
+        this.relatedReactionMessageIds.delete(messageId);
+        return [...new Set([messageId, ...related])];
+    }
     async finalizeTurnMessageReactions(turnId, status) {
         for (const reaction of this.store.claimMessageReactionsForTurn(turnId)) {
             await this.replaceMessageReaction(reaction, status);
@@ -4941,6 +5183,86 @@ function isPromptCommand(command) {
 function runtimePrompt(text, localImagePaths) {
     return localImagePaths?.length ? { text, localImagePaths } : text;
 }
+function mergedForwardPrompt(instruction, transcript) {
+    return `${instruction}\n\n参考聊天记录：\n${transcript}`;
+}
+function referencedMessagePrompt(instruction, referencedMessage) {
+    return `${instruction}\n\n引用消息：\n${referencedMessage}`;
+}
+function quotedMessageId(message) {
+    const messageId = message.parentMessageId?.trim();
+    if (!messageId || message.contextKey.startsWith("console:"))
+        return undefined;
+    if (message.mergedForwardMessageId)
+        return undefined;
+    const text = message.text.trimStart();
+    if (text.startsWith("/") || text.startsWith("!"))
+        return undefined;
+    if (message.threadContext && message.rootMessageId === messageId)
+        return undefined;
+    return messageId;
+}
+function renderLocalTurnReference(snapshot, messageKind) {
+    if (messageKind === "final") {
+        const response = snapshot.finalResponse?.trim() || snapshot.assistantText?.trim();
+        return response
+            ? `[消息类型：AgentBot 回复]\n${truncateMiddle(response, 48_000)}`
+            : undefined;
+    }
+    const activityText = (snapshot.activities ?? [])
+        .filter((activity) => activity.kind === "assistant" || activity.kind === "reasoning")
+        .map((activity) => activity.text.trim())
+        .filter(Boolean)
+        .join("\n\n");
+    const content = [
+        snapshot.prompt?.trim() ? `用户请求：\n${snapshot.prompt.trim()}` : "",
+        activityText,
+        snapshot.progressText?.trim() || "",
+        snapshot.finalResponse?.trim() || snapshot.assistantText?.trim() || "",
+        snapshot.error?.trim() ? `错误：${snapshot.error.trim()}` : "",
+    ].filter(Boolean).join("\n\n");
+    return content
+        ? `[消息类型：AgentBot 思考卡片]\n${truncateMiddle(content, 48_000)}`
+        : undefined;
+}
+function appendDownloadedFiles(prompt, files) {
+    return `${prompt}\n\n参考文件（已下载到本地）：\n${files.map((file, index) => `[文件 ${index + 1}：${file.fileName}] ${file.filePath}`).join("\n")}`;
+}
+function defaultResourcePrompt(message) {
+    return defaultResourcePromptFromCounts(message.images?.length ?? 0, message.files?.length ?? 0);
+}
+function defaultResourcePromptFromCounts(imageCount, fileCount) {
+    if (imageCount > 0 && fileCount > 0)
+        return "请查看附带的图片和文件";
+    if (fileCount > 0)
+        return fileCount === 1 ? "请查看这个文件" : "请查看这些文件";
+    return imageCount === 1 ? "请查看这张图片" : "请查看这些图片";
+}
+function isStandaloneResourceMessage(message) {
+    return !message.mergedForwardMessageId
+        && message.text.trim().length === 0
+        && ((message.images?.length ?? 0) > 0 || (message.files?.length ?? 0) > 0);
+}
+function deduplicateImageReferences(images) {
+    const seen = new Set();
+    return images.filter((image) => {
+        const key = `${image.messageId}:${image.imageKey}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function deduplicateFileReferences(files) {
+    const seen = new Set();
+    return files.filter((file) => {
+        const key = `${file.messageId}:${file.fileKey}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
 function recoveryCardPrompt(prompt) {
     return `恢复重启前的任务：${prompt}`;
 }