@kafca/agentdock 0.1.20 → 0.1.22

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-backend.js

@@ -7,6 +7,7 @@ const local_core_acp_transport_js_1 = require("./local-core-acp-transport.js");
 const local_core_acp_turn_coordinator_js_1 = require("./local-core-acp-turn-coordinator.js");
 const local_core_acp_session_coordinator_js_1 = require("./local-core-acp-session-coordinator.js");
 const local_core_acp_response_processor_js_1 = require("./local-core-acp-response-processor.js");
+const local_core_acp_content_js_1 = require("./local-core-acp-content.js");
 const command_risk_js_1 = require("../security/command-risk.js");
 const ACP_PROMPT_TIMEOUT_MS = 15 * 60 * 1000;
 class LocalCoreAcpBackend {
@@ -126,7 +127,7 @@ class LocalCoreAcpBackend {
         this.options.store.deleteThread(threadId);
         return { deleted: true };
     }
-    async sendThreadMessage(threadId, content, config) {
+    async sendThreadMessage(threadId, input, config) {
         if (!config) {
             throw new Error('localcore-acp message send requires a workspace config.');
         }
@@ -134,6 +135,8 @@ class LocalCoreAcpBackend {
         if (!row) {
             throw new Error(`Thread not found: ${threadId}`);
         }
+        const message = (0, local_core_acp_content_js_1.normalizeThreadMessageInput)(input);
+        const content = message.displayText;
         this.options.store.appendMessage(threadId, 'user', content, 'final');
         this.options.eventBus.emit({
             type: 'thread.message.accepted',
@@ -169,7 +172,7 @@ class LocalCoreAcpBackend {
                 sessionKey: row.bridge_session_key,
             },
         });
-        void this.runPrompt(threadId, runId, row.bridge_session_key, config, content).catch((error) => {
+        void this.runPrompt(threadId, runId, row.bridge_session_key, config, message).catch((error) => {
             this.options.log?.(`localcore-acp prompt failed for ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
         });
         return { runId };
@@ -219,7 +222,7 @@ class LocalCoreAcpBackend {
     async interruptRun(runId) {
         return this.sessionCoordinator.interruptRun(runId);
     }
-    async runPrompt(threadId, runId, bridgeSessionKey, config, content) {
+    async runPrompt(threadId, runId, bridgeSessionKey, config, input) {
         const row = this.options.store.getThreadRow(threadId);
         if (!row) {
             throw new Error(`Thread not found: ${threadId}`);
@@ -229,6 +232,8 @@ class LocalCoreAcpBackend {
             sessionKey: bridgeSessionKey,
             replyCtx: runId,
         });
+        const message = (0, local_core_acp_content_js_1.normalizeThreadMessageInput)(input);
+        const content = message.displayText;
         let session = null;
         try {
             session = await this.sessionCoordinator.ensureSession(threadId, bridgeSessionKey, config);
@@ -256,12 +261,7 @@ class LocalCoreAcpBackend {
             const promptPromise = this.transport.request(session, 'session/prompt', {
                 sessionId: session.sessionId,
                 messageId: (0, node_crypto_1.randomUUID)(),
-                prompt: [
-                    {
-                        type: 'text',
-                        text: content,
-                    },
-                ],
+                prompt: message.contentParts,
             }, ACP_PROMPT_TIMEOUT_MS);
             session.promptPromise = promptPromise;
             const result = await promptPromise;

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-content.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeThreadMessageInput = normalizeThreadMessageInput;
+exports.createTextMessageInput = createTextMessageInput;
+function normalizeThreadMessageInput(input) {
+    if (typeof input === 'string') {
+        return {
+            displayText: input,
+            contentParts: [{ type: 'text', text: input }],
+        };
+    }
+    const displayText = String(input.displayText || '').trim();
+    const contentParts = Array.isArray(input.contentParts)
+        ? input.contentParts.filter(isSupportedContentPart)
+        : [];
+    if (contentParts.length > 0) {
+        return {
+            displayText: displayText || summarizeContentParts(contentParts),
+            contentParts,
+        };
+    }
+    const fallbackText = displayText || '';
+    return {
+        displayText: fallbackText,
+        contentParts: [{ type: 'text', text: fallbackText }],
+    };
+}
+function createTextMessageInput(text) {
+    return normalizeThreadMessageInput(text);
+}
+function isSupportedContentPart(part) {
+    if (!part || typeof part !== 'object') {
+        return false;
+    }
+    const type = String(part.type || '');
+    if (type === 'text') {
+        return Boolean(String(part.text || ''));
+    }
+    if (type === 'image') {
+        const image = part;
+        return Boolean(String(image.data || image.uri || ''));
+    }
+    return false;
+}
+function summarizeContentParts(parts) {
+    const text = parts
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text.trim())
+        .filter(Boolean)
+        .join('\n\n')
+        .trim();
+    if (text) {
+        return text;
+    }
+    const imageCount = parts.filter((part) => part.type === 'image').length;
+    if (imageCount > 0) {
+        return imageCount === 1 ? '[Image]' : `[${imageCount} images]`;
+    }
+    return '';
+}

package/dist-electron/services/local-ai-core/src/{gateway → channel/lark}/local-core-lark-gateway.js

@@ -36,8 +36,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreLarkGateway = void 0;
 const node_events_1 = require("node:events");
 const node_crypto_1 = require("node:crypto");
-const desktop_js_1 = require("../../../../shared/desktop.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const file_utils_js_1 = require("../shared/file-utils.js");
+function foldToolResultForLark(content) {
+    const normalized = String(content || '').trim();
+    if (!normalized.startsWith('🔧 '))
+        return normalized;
+    const parts = normalized.split(' - ');
+    if (parts.length <= 2)
+        return normalized;
+    return parts.slice(0, 2).join(' - ');
+}
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
+const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     options;
     // Lark returns 200340 when card action events are not enabled in the app's
@@ -115,6 +128,111 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     async sendScheduledMessage(workspaceId, route, text) {
         return this.sendScheduledCard(workspaceId, route.channelId, text);
     }
+    async sendOutboundMessage(workspaceId, input) {
+        const state = this.runtime.get(workspaceId);
+        if (!state?.client || !state.connected) {
+            throw new Error(`Lark workspace is not connected: ${workspaceId}`);
+        }
+        const channelId = String(input.route?.channelId || '').trim();
+        if (!channelId) {
+            throw new Error('Missing Lark target channel id');
+        }
+        const messageIds = [];
+        const attachments = [];
+        for (const part of input.parts || []) {
+            if (part.type === 'text') {
+                const text = String(part.text || '').trim();
+                if (text) {
+                    messageIds.push(await this.sendTextAsCard(state, channelId, text));
+                }
+                continue;
+            }
+            if (part.type === 'file') {
+                const sent = await this.sendFilePart(state, channelId, part);
+                messageIds.push(sent.messageId);
+                attachments.push({
+                    kind: 'file',
+                    attachmentId: sent.fileKey,
+                    fileName: sent.file.fileName,
+                    fileSize: sent.file.fileSize,
+                    metadata: {
+                        fileKey: sent.fileKey,
+                    },
+                });
+            }
+        }
+        return {
+            platform: 'lark',
+            workspaceId,
+            channelId,
+            participantId: input.route.participantId,
+            messageIds: messageIds.filter(Boolean),
+            attachments,
+        };
+    }
+    async sendFile(workspaceId, input) {
+        const result = await this.sendOutboundMessage(workspaceId, {
+            route: {
+                type: 'channel.chat',
+                channelId: input.channelId,
+                participantId: input.participantId,
+            },
+            parts: [{
+                    type: 'file',
+                    path: input.path,
+                    fileName: input.fileName,
+                }],
+        });
+        const attachment = result.attachments?.[0];
+        return {
+            platform: 'lark',
+            workspaceId,
+            channelId: result.channelId,
+            messageId: result.messageIds[0] || '',
+            fileKey: String(attachment?.metadata?.fileKey || attachment?.attachmentId || ''),
+            fileName: attachment?.fileName || input.fileName || '',
+            fileSize: attachment?.fileSize || 0,
+        };
+    }
+    async sendFilePart(state, channelId, part) {
+        const file = await (0, file_utils_js_1.prepareChannelFile)({
+            path: part.path,
+            fileName: part.fileName,
+            maxBytes: LARK_MAX_UPLOAD_FILE_SIZE,
+            platformLabel: 'Lark',
+        });
+        const upload = await state.client.im.file.create({
+            data: {
+                file_type: this.resolveLarkUploadFileType(file.fileName),
+                file_name: file.fileName,
+                file: (0, node_fs_1.createReadStream)(file.path),
+            },
+        });
+        const fileKey = String(upload?.file_key || upload?.data?.file_key || '').trim();
+        if (!fileKey) {
+            throw new Error('Lark file upload did not return a file key');
+        }
+        const response = await state.client.im.message.create({
+            params: {
+                receive_id_type: this.resolveReceiveIdType(channelId),
+            },
+            data: {
+                receive_id: channelId,
+                msg_type: 'file',
+                content: JSON.stringify({ file_key: fileKey }),
+            },
+        });
+        const messageId = String(response?.data?.message_id || '').trim();
+        if (!messageId) {
+            throw new Error('Lark file message did not return a message id');
+        }
+        this.options.log?.(`localcore-lark sent file ${file.fileName} (${file.fileSize} bytes) to ${channelId}`);
+        return {
+            messageId,
+            fileKey,
+            file,
+        };
+    }
     muteThreadBridge(threadId) {
         const current = this.mutedThreadBridgeCounts.get(threadId) || 0;
         this.mutedThreadBridgeCounts.set(threadId, current + 1);
@@ -453,7 +571,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             return { paired: true, threadId };
         }
         this.options.store.clearPlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId);
-        await router.sendThreadMessage(threadId, (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text));
+        const wrappedText = (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
+        await router.sendThreadMessage(threadId, this.createThreadMessageInput(wrappedText, input.contentParts));
         return { paired: true, threadId };
     }
     close() {
@@ -610,18 +729,41 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         catch {
             parsedContent = {};
         }
+        const messageType = String(message.message_type || '').trim().toLowerCase();
         const text = String(parsedContent.text || '').trim();
-        if (!text) {
-            this.options.log?.(`localcore-lark ignored non-text message for ${workspaceId}: type=${String(message.message_type || 'unknown')} contentKeys=${JSON.stringify(Object.keys(parsedContent))}`);
+        const contentParts = [];
+        if (text) {
+            contentParts.push({ type: 'text', text });
+        }
+        if (messageType === 'image') {
+            const imageKey = String(parsedContent.image_key || parsedContent.file_key || '').trim();
+            if (imageKey) {
+                try {
+                    contentParts.push(await this.downloadMessageImage(workspaceId, String(message.message_id || ''), imageKey));
+                }
+                catch (error) {
+                    const errorText = `[Image download failed: ${error instanceof Error ? error.message : String(error)}]`;
+                    contentParts.push({ type: 'text', text: errorText });
+                    this.options.log?.(`localcore-lark image download failed for ${workspaceId}: message=${String(message.message_id || '')} imageKey=${imageKey} error=${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        if (contentParts.length === 0) {
+            this.options.log?.(`localcore-lark ignored unsupported message for ${workspaceId}: type=${String(message.message_type || 'unknown')} contentKeys=${JSON.stringify(Object.keys(parsedContent))}`);
             return;
         }
+        const displayText = text || (contentParts.some((part) => part.type === 'image') ? '[Image]' : contentParts
+            .filter((part) => part.type === 'text')
+            .map((part) => part.text)
+            .join('\n\n')
+            .trim());
         const platformUserId = String(sender.sender_id?.user_id || sender.sender_id?.open_id || '').trim();
         const chatId = String(message.chat_id || platformUserId).trim();
         if (!platformUserId || !chatId) {
             this.options.log?.(`localcore-lark ignored message without sender/chat for ${workspaceId}: senderKeys=${JSON.stringify(Object.keys(sender?.sender_id || {}))} chat=${String(message.chat_id || '')}`);
             return;
         }
-        this.options.log?.(`localcore-lark inbound message for ${workspaceId}: chat=${chatId} user=${platformUserId} text=${JSON.stringify(text.slice(0, 120))}`);
+        this.options.log?.(`localcore-lark inbound message for ${workspaceId}: chat=${chatId} user=${platformUserId} type=${messageType || 'unknown'} text=${JSON.stringify(displayText.slice(0, 120))}`);
         await this.handleInboundMessage({
             workspaceId,
             platformUserId,
@@ -629,10 +771,103 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             displayName: String(payload?.sender?.sender_id?.user_id ||
                 payload?.sender?.sender_id?.open_id ||
                 `Lark ${platformUserId.slice(-6)}`),
-            text,
+            text: displayText,
             messageId: String(message.message_id || (0, node_crypto_1.randomUUID)()),
+            contentParts,
         });
     }
+    createWrappedContentParts(wrappedText, parts) {
+        const nonTextParts = Array.isArray(parts)
+            ? parts.filter((part) => part.type !== 'text')
+            : [];
+        return [
+            { type: 'text', text: wrappedText },
+            ...nonTextParts,
+        ];
+    }
+    createThreadMessageInput(wrappedText, parts) {
+        const hasNonTextPart = Array.isArray(parts) && parts.some((part) => part.type !== 'text');
+        if (!hasNonTextPart) {
+            return wrappedText;
+        }
+        return {
+            displayText: wrappedText,
+            contentParts: this.createWrappedContentParts(wrappedText, parts),
+        };
+    }
+    async downloadMessageImage(workspaceId, messageId, imageKey) {
+        const state = this.runtime.get(workspaceId);
+        if (!state?.client) {
+            throw new Error('Lark client is not connected');
+        }
+        if (!messageId) {
+            throw new Error('Lark image message is missing message_id');
+        }
+        const resource = await state.client.im.messageResource.get({
+            path: {
+                message_id: messageId,
+                file_key: imageKey,
+            },
+            params: {
+                type: 'image',
+            },
+        });
+        const buffer = await this.readLarkResourceBuffer(resource);
+        if (buffer.length === 0) {
+            throw new Error('Lark image resource is empty');
+        }
+        const headerMime = this.extractHeaderMimeType(resource?.headers);
+        return {
+            type: 'image',
+            data: buffer.toString('base64'),
+            mimeType: headerMime || this.sniffImageMimeType(buffer),
+            fileName: `${imageKey}.${this.sniffImageExtension(buffer)}`,
+        };
+    }
+    async readLarkResourceBuffer(resource) {
+        const readable = resource?.getReadableStream?.();
+        if (!readable || typeof readable.on !== 'function') {
+            throw new Error('Lark resource did not provide a readable stream');
+        }
+        const chunks = [];
+        await new Promise((resolve, reject) => {
+            readable.on('data', (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            readable.on('error', reject);
+            readable.on('end', resolve);
+        });
+        return Buffer.concat(chunks);
+    }
+    extractHeaderMimeType(headers) {
+        const value = headers && typeof headers === 'object'
+            ? headers['content-type'] || headers['Content-Type']
+            : '';
+        return String(value || '').split(';')[0]?.trim() || '';
+    }
+    sniffImageMimeType(buffer) {
+        if (buffer[0] === 0xff && buffer[1] === 0xd8)
+            return 'image/jpeg';
+        if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47)
+            return 'image/png';
+        if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46)
+            return 'image/gif';
+        if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46)
+            return 'image/webp';
+        return 'application/octet-stream';
+    }
+    sniffImageExtension(buffer) {
+        const mimeType = this.sniffImageMimeType(buffer);
+        if (mimeType === 'image/jpeg')
+            return 'jpg';
+        if (mimeType === 'image/png')
+            return 'png';
+        if (mimeType === 'image/gif')
+            return 'gif';
+        if (mimeType === 'image/webp')
+            return 'webp';
+        return 'bin';
+    }
     attachWsDiagnostics(workspaceId, wsClient) {
         const on = typeof wsClient?.on === 'function' ? wsClient.on.bind(wsClient) : null;
         if (!on) {
@@ -764,10 +999,9 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         };
     }
     async sendTextAsCard(state, chatId, text, buttonRows = [], sessionKey, threadId) {
-        const receiveIdType = chatId.startsWith('oc_') ? 'chat_id' : chatId.startsWith('ou_') ? 'open_id' : 'user_id';
         const response = await state.client.im.message.create({
             params: {
-                receive_id_type: receiveIdType,
+                receive_id_type: this.resolveReceiveIdType(chatId),
             },
             data: {
                 receive_id: chatId,
@@ -777,6 +1011,33 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         });
         return String(response?.data?.message_id || '').trim();
     }
+    resolveReceiveIdType(receiveId) {
+        return receiveId.startsWith('oc_') ? 'chat_id' : receiveId.startsWith('ou_') ? 'open_id' : 'user_id';
+    }
+    resolveLarkUploadFileType(fileName) {
+        switch ((0, node_path_1.extname)(fileName).toLowerCase()) {
+            case '.opus':
+                return 'opus';
+            case '.mp4':
+            case '.mov':
+            case '.m4v':
+                return 'mp4';
+            case '.pdf':
+                return 'pdf';
+            case '.doc':
+            case '.docx':
+                return 'doc';
+            case '.xls':
+            case '.xlsx':
+            case '.csv':
+                return 'xls';
+            case '.ppt':
+            case '.pptx':
+                return 'ppt';
+            default:
+                return 'stream';
+        }
+    }
     async patchTextCard(state, messageId, text, buttonRows = [], sessionKey, threadId) {
         await state.client.im.message.patch({
             path: {
@@ -854,7 +1115,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         return turn;
     }
     consumeBridgeEvent(turn, event) {
-        const content = String(event.content || '').trim();
+        const content = foldToolResultForLark(String(event.content || '').trim());
         if (event.type === 'typing_start') {
             // Always start a fresh card for each generation phase.
             // This keeps Feishu message order aligned with user-visible timeline.
@@ -913,7 +1174,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         turn.previewText = content;
     }
     renderBridgeEventMessage(turn, event) {
-        const content = String(event.content || '').trim();
+        const content = foldToolResultForLark(String(event.content || '').trim());
         if (event.type === 'preview_start' || event.type === 'update_message') {
             if (content.startsWith('💭 ')) {
                 return this.renderProgressMessage(event.previewHandle || 'thinking-preview', content);
@@ -1042,12 +1303,107 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             }
             const router = this.options.getWorkspaceRouter();
             await router.sendThreadAction(threadId, response);
+            await this.markPermissionCardActionHandled(workspaceId, data, payload, value, response, threadId);
             this.options.log?.(`localcore-lark processed card action for ${workspaceId}: ${response}`);
         }
         catch (error) {
             this.options.log?.(`localcore-lark card action failed for ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    async markPermissionCardActionHandled(workspaceId, rootPayload, payload, value, response, threadId) {
+        const state = this.runtime.get(workspaceId);
+        if (!state?.client) {
+            return;
+        }
+        const sessionKey = String(value.session_key || '').trim();
+        const turn = sessionKey ? this.outboundTurns.get(sessionKey) : undefined;
+        const messageId = this.extractCardActionMessageId(rootPayload, payload, value) || turn?.permissionMessageId;
+        if (!messageId) {
+            this.options.log?.(`localcore-lark could not find permission card message id for workspace=${workspaceId} sessionKey=${sessionKey || 'missing'}`);
+            return;
+        }
+        try {
+            await this.patchTextCard(state, messageId, [
+                '**工具确认已处理**',
+                `已选择：${this.formatPermissionResponseLabel(response)}`,
+                '等待代理继续执行...',
+            ].join('\n\n'), [], sessionKey || undefined, threadId);
+            if (turn) {
+                turn.awaitingPermission = false;
+                turn.buttonRows = [];
+            }
+        }
+        catch (error) {
+            this.options.log?.(`localcore-lark failed to patch handled permission card ${messageId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    extractCardActionMessageId(...payloads) {
+        for (const payload of payloads) {
+            const messageId = this.extractKnownCardActionMessageId(payload);
+            if (messageId) {
+                return messageId;
+            }
+        }
+        for (const payload of payloads) {
+            const messageId = this.findNestedCardActionMessageId(payload);
+            if (messageId) {
+                return messageId;
+            }
+        }
+        return '';
+    }
+    extractKnownCardActionMessageId(payload) {
+        const source = payload;
+        if (!source || typeof source !== 'object') {
+            return '';
+        }
+        const candidates = [
+            source?.permission_message_id,
+            source?.action_message_id,
+            source?.context?.open_message_id,
+            source?.context?.message_id,
+            source?.event?.context?.open_message_id,
+            source?.event?.context?.message_id,
+            source?.event_context?.open_message_id,
+            source?.event_context?.message_id,
+            source?.message?.message_id,
+            source?.message?.open_message_id,
+            source?.event?.message?.message_id,
+            source?.event?.message?.open_message_id,
+            source?.message_id,
+            source?.open_message_id,
+        ];
+        return candidates
+            .map((candidate) => String(candidate || '').trim())
+            .find(Boolean) || '';
+    }
+    findNestedCardActionMessageId(payload, seen = new Set()) {
+        if (!payload || typeof payload !== 'object' || seen.has(payload)) {
+            return '';
+        }
+        seen.add(payload);
+        if (Array.isArray(payload)) {
+            for (const item of payload) {
+                const nested = this.findNestedCardActionMessageId(item, seen);
+                if (nested)
+                    return nested;
+            }
+            return '';
+        }
+        const source = payload;
+        for (const key of ['open_message_id', 'message_id', 'permission_message_id', 'action_message_id']) {
+            const value = source[key];
+            if (typeof value === 'string' && value.trim()) {
+                return value.trim();
+            }
+        }
+        for (const value of Object.values(source)) {
+            const nested = this.findNestedCardActionMessageId(value, seen);
+            if (nested)
+                return nested;
+        }
+        return '';
+    }
     pushUnique(target, value) {
         const normalized = value.trim();
         if (!normalized) {
@@ -1062,8 +1418,10 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
     }
     formatPermissionButtonLabel(button) {
-        const response = (0, desktop_js_1.normalizePermissionResponse)(button.data) || (0, desktop_js_1.normalizePermissionResponse)(button.text);
-        switch (response) {
+        return this.formatPermissionResponseLabel(button.data || button.text);
+    }
+    formatPermissionResponseLabel(response) {
+        switch ((0, desktop_js_1.normalizePermissionResponse)(response) || response) {
             case 'allow':
                 return '允许一次';
             case 'allow all':
@@ -1071,7 +1429,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             case 'deny':
                 return '拒绝';
             default:
-                return button.text;
+                return response;
         }
     }
     resolveLarkButtonType(button, index) {

package/dist-electron/services/local-ai-core/src/channel/shared/file-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareChannelFile = prepareChannelFile;
+exports.sanitizeChannelFileName = sanitizeChannelFileName;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+async function prepareChannelFile(input) {
+    const filePath = String(input.path || '').trim();
+    if (!filePath) {
+        throw new Error('Missing file path');
+    }
+    const fileStat = await (0, promises_1.stat)(filePath).catch((error) => {
+        throw new Error(`Cannot read file "${filePath}": ${error instanceof Error ? error.message : String(error)}`);
+    });
+    if (!fileStat.isFile()) {
+        throw new Error(`Path is not a file: ${filePath}`);
+    }
+    if (fileStat.size <= 0) {
+        throw new Error(`File is empty: ${filePath}`);
+    }
+    if (input.maxBytes && fileStat.size > input.maxBytes) {
+        throw new Error(`File is too large for ${input.platformLabel} upload: ${fileStat.size} bytes`);
+    }
+    return {
+        path: filePath,
+        fileName: sanitizeChannelFileName(input.fileName || (0, node_path_1.basename)(filePath)),
+        fileSize: fileStat.size,
+    };
+}
+function sanitizeChannelFileName(fileName) {
+    const normalized = String(fileName || '').trim().replace(/[\/\\]+/g, '_');
+    return normalized || 'file';
+}