@kafca/agentdock 0.1.42 → 0.1.44

package/dist-electron/services/local-ai-core/src/channel/lark/cards.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildInteractiveCard = buildInteractiveCard;
 exports.renderPermissionCard = renderPermissionCard;
 exports.renderPendingPairingCard = renderPendingPairingCard;
+exports.buildSessionCommandCard = buildSessionCommandCard;
 exports.extractCardActionMessageId = extractCardActionMessageId;
 exports.extractCardActionValue = extractCardActionValue;
+exports.extractSessionCommandActionValue = extractSessionCommandActionValue;
 exports.formatPermissionButtonLabel = formatPermissionButtonLabel;
 exports.formatPermissionResponseLabel = formatPermissionResponseLabel;
 const desktop_js_1 = require("../../../../../shared/desktop.js");
@@ -80,6 +82,37 @@ function renderPendingPairingCard(code) {
     }
     return lines.join('\n\n');
 }
+function buildSessionCommandCard(text, actionRows = [], sessionKey, threadId) {
+    const elements = [];
+    if (text) {
+        elements.push({ tag: 'markdown', content: text });
+    }
+    for (const row of actionRows) {
+        const actions = row
+            .filter((button) => button.label && button.command)
+            .map((button) => ({
+            tag: 'button',
+            text: {
+                tag: 'plain_text',
+                content: button.label,
+            },
+            type: button.type || 'default',
+            value: {
+                action: 'session_command',
+                command: button.command,
+                session_key: sessionKey || '',
+                thread_id: threadId || '',
+            },
+        }));
+        if (actions.length) {
+            elements.push({ tag: 'action', actions });
+        }
+    }
+    return {
+        config: { wide_screen_mode: true },
+        elements,
+    };
+}
 function extractCardActionMessageId(...payloads) {
     for (const payload of payloads) {
         const messageId = extractKnownCardActionMessageId(payload);
@@ -117,6 +150,28 @@ function extractCardActionValue(payload) {
         sessionKey,
     };
 }
+function extractSessionCommandActionValue(payload) {
+    const event = (payload?.event && typeof payload.event === 'object')
+        ? payload.event
+        : payload;
+    const value = event?.action?.value;
+    if (!value || value.action !== 'session_command') {
+        return null;
+    }
+    const command = String(value.command || '').trim();
+    const threadId = String(value.thread_id || '').trim();
+    const sessionKey = String(value.session_key || '').trim();
+    if (!command || !threadId) {
+        return null;
+    }
+    return {
+        event,
+        value: value,
+        command,
+        threadId,
+        sessionKey,
+    };
+}
 function formatPermissionButtonLabel(button) {
     return formatPermissionResponseLabel(button.data || button.text);
 }

package/dist-electron/services/local-ai-core/src/channel/lark/config.js

@@ -45,6 +45,8 @@ function collectLarkWorkspaceBindings(config, options) {
                     || platform.options.card_actions === true
                     || platform.options.enable_card_actions === true
                     || options.defaultCardActionsEnabled,
+                groupReplyAll: String(platform.options.group_reply_all || '').trim().toLowerCase() === 'true'
+                    || platform.options.group_reply_all === true,
                 brand: String(platform.options.brand || platform.options.lark_brand || '').trim().toLowerCase() === 'lark' ? 'lark' : 'feishu',
                 enabled: Boolean(String(platform.options.app_id || '').trim() && String(platform.options.app_secret || '').trim()),
                 project,

package/dist-electron/services/local-ai-core/src/channel/lark/inbound.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLarkInboundMessageEvent = normalizeLarkInboundMessageEvent;
+exports.isLarkBotMentioned = isLarkBotMentioned;
+exports.stripLarkMentions = stripLarkMentions;
+exports.summarizeLarkInboundPayload = summarizeLarkInboundPayload;
+const node_crypto_1 = require("node:crypto");
+function normalizeLarkInboundMessageEvent(data, options = {}) {
+    const payload = (data?.event && typeof data.event === 'object')
+        ? data.event
+        : data;
+    const message = payload?.message;
+    const sender = payload?.sender;
+    if (!message || !sender) {
+        return { ok: false, reason: 'missing-message-or-sender', detail: JSON.stringify(Object.keys(data || {})) };
+    }
+    let parsedContent = {};
+    try {
+        parsedContent = JSON.parse(String(message.content || '{}'));
+    }
+    catch {
+        parsedContent = {};
+    }
+    const messageType = String(message.message_type || '').trim().toLowerCase();
+    const chatType = String(message.chat_type || '').trim().toLowerCase();
+    const mentions = Array.isArray(message.mentions) ? message.mentions : [];
+    const botOpenId = String(options.botOpenId || '').trim();
+    if (chatType === 'group' && !options.groupReplyAll && botOpenId && !isLarkBotMentioned(mentions, botOpenId)) {
+        return {
+            ok: false,
+            reason: 'group-message-without-bot-mention',
+            detail: `chat=${String(message.chat_id || '')} message=${String(message.message_id || '')}`,
+        };
+    }
+    const text = stripLarkMentions(String(parsedContent.text || '').trim(), mentions, botOpenId);
+    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) {
+        return {
+            ok: false,
+            reason: 'missing-sender-or-chat',
+            detail: `senderKeys=${JSON.stringify(Object.keys(sender?.sender_id || {}))} chat=${String(message.chat_id || '')}`,
+        };
+    }
+    return {
+        ok: true,
+        message: {
+            payload,
+            message,
+            sender,
+            parsedContent,
+            messageType,
+            chatType,
+            mentions,
+            text,
+            platformUserId,
+            chatId,
+            displayName: String(sender.sender_id?.user_id ||
+                sender.sender_id?.open_id ||
+                `Lark ${platformUserId.slice(-6)}`),
+            messageId: String(message.message_id || (0, node_crypto_1.randomUUID)()),
+        },
+    };
+}
+function isLarkBotMentioned(mentions, botOpenId) {
+    if (!botOpenId) {
+        return false;
+    }
+    return mentions.some((mention) => {
+        const item = mention && typeof mention === 'object' ? mention : {};
+        return getMentionOpenId(item) === botOpenId;
+    });
+}
+function stripLarkMentions(text, mentions, botOpenId) {
+    let next = String(text || '');
+    for (const mention of mentions) {
+        const item = mention && typeof mention === 'object' ? mention : {};
+        const key = String(item.key || '').trim();
+        if (!key) {
+            continue;
+        }
+        const openId = getMentionOpenId(item);
+        const name = String(item.name || item.display_name || item.displayName || '').trim();
+        if (botOpenId && openId === botOpenId) {
+            next = next.split(key).join('');
+            continue;
+        }
+        next = next.split(key).join(name ? `@${name}` : '');
+    }
+    return next.trim();
+}
+function summarizeLarkInboundPayload(payload) {
+    const eventPayload = (payload?.event && typeof payload.event === 'object')
+        ? payload.event
+        : payload;
+    const message = eventPayload?.message || {};
+    const sender = eventPayload?.sender || {};
+    const senderId = sender?.sender_id || {};
+    const content = typeof message.content === 'string' ? message.content : '';
+    return [
+        `message=${String(message.message_id || '') || 'missing'}`,
+        `type=${String(message.message_type || '') || 'missing'}`,
+        `chat=${String(message.chat_id || '') || 'missing'}`,
+        `chatType=${String(message.chat_type || '') || 'missing'}`,
+        `sender=${String(senderId.user_id || senderId.open_id || '') || 'missing'}`,
+        `mentions=${Array.isArray(message.mentions) ? message.mentions.length : 0}`,
+        `contentBytes=${Buffer.byteLength(content, 'utf8')}`,
+        `keys=${JSON.stringify(Object.keys(eventPayload || {}))}`,
+    ].join(' ');
+}
+function getMentionOpenId(item) {
+    const id = item.id || item.user_id || item.userId || {};
+    return String(id.open_id || id.openId || item.open_id || item.openId || '').trim();
+}

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

@@ -41,11 +41,15 @@ const node_path_1 = require("node:path");
 const desktop_js_1 = require("../../../../../shared/desktop.js");
 const content_js_1 = require("../shared/content.js");
 const file_utils_js_1 = require("../shared/file-utils.js");
+const session_command_runtime_js_1 = require("../shared/session-command-runtime.js");
+const thread_routing_js_1 = require("../shared/thread-routing.js");
 const cards_js_1 = require("./cards.js");
 const config_js_1 = require("./config.js");
 const registration_js_1 = require("./registration.js");
 const messages_js_1 = require("./rendering/messages.js");
+const inbound_js_1 = require("./inbound.js");
 const runtime_state_js_1 = require("./runtime-state.js");
+const session_command_service_js_1 = require("../../thread/session-command-service.js");
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 const LARK_FINAL_PATCH_INTERVAL_MS = 900;
@@ -62,12 +66,37 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     outboundEventChains = new Map();
     outboundTurns = new Map();
     mutedThreadBridgeCounts = new Map();
+    sessionCommandRuntime;
     larkModulePromise = null;
     platform = 'lark';
     routeType = 'channel.chat';
     constructor(options) {
         super();
         this.options = options;
+        const sessionCommandService = new session_command_service_js_1.SessionCommandService({
+            listThreads: (workspaceId) => this.options.getWorkspaceRouter().listThreads(workspaceId),
+            getThread: (threadId) => this.options.getWorkspaceRouter().getThread(threadId),
+            createThread: (workspaceId, title) => this.options.getWorkspaceRouter().createThread(workspaceId, title),
+            renameThread: (threadId, title) => this.options.getWorkspaceRouter().renameThread(threadId, title),
+            deleteThread: (threadId) => this.options.getWorkspaceRouter().deleteThread(threadId),
+        });
+        this.sessionCommandRuntime = new session_command_runtime_js_1.ChannelSessionCommandRuntime({
+            service: sessionCommandService,
+            store: this.options.store,
+            getThreadSessionKey: (threadId) => this.options.getWorkspaceRouter().getThreadSessionKey(threadId),
+            setThreadRoute: (sessionKey, route) => {
+                this.threadRouting.set(sessionKey, route);
+            },
+            createRoute: (input, threadId) => ({
+                workspaceId: input.workspaceId,
+                instanceId: input.instanceId,
+                platformKey: input.platformKey,
+                platformUserId: input.platformUserId,
+                chatId: input.chatId,
+                threadId,
+            }),
+            sendResult: (input, result) => this.sendSessionCommandResult(input, result),
+        });
     }
     async refreshBindings() {
         const config = await this.options.readConfig();
@@ -97,6 +126,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                         appId: binding.appId,
                         autoApprove: binding.autoApprove,
                         cardActionsEnabled: binding.cardActionsEnabled,
+                        groupReplyAll: binding.groupReplyAll,
+                        botOpenId: binding.botOpenId,
                     });
                 }
                 continue;
@@ -204,6 +235,17 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             }
         };
     }
+    async executeSessionCommand(input) {
+        return this.sessionCommandRuntime.execute(input);
+    }
+    async sendSessionCommandResult(input, result) {
+        const state = this.resolveRuntimeState(input.workspaceId, input.instanceId).state;
+        if (state?.client && state.connected && result.card?.actions?.length && state.cardActionsEnabled) {
+            await this.sendSessionCommandCard(state, input.chatId, result.displayText, result.card.actions, this.options.getWorkspaceRouter().getThreadSessionKey(input.currentThreadId), input.currentThreadId);
+            return;
+        }
+        await this.sendImmediateCard(input.workspaceId, input.chatId, result.displayText, input.instanceId);
+    }
     async sendOutboundMessage(workspaceId, input) {
         const state = this.resolveRuntimeState(workspaceId, input.route?.instanceId).state;
         if (!state?.client || !state.connected) {
@@ -621,25 +663,17 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             return { paired: false };
         }
         const router = this.options.getWorkspaceRouter();
-        const threadBinding = this.options.store.getPlatformThreadBinding(input.workspaceId, input.chatId, input.platformUserId, platformKey);
-        let threadId = threadBinding?.thread_id || authorized.thread_id || '';
-        if (!threadId) {
-            const thread = await router.createThread(input.workspaceId, input.displayName || `Lark ${input.chatId}`);
-            threadId = thread.id;
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, platformKey);
-            const now = new Date().toISOString();
-            this.options.store.upsertPlatformThreadBinding({
-                workspace_id: input.workspaceId,
-                platform: platformKey,
-                chat_id: input.chatId,
-                platform_user_id: input.platformUserId,
-                thread_id: threadId,
-                last_platform_message_id: null,
-                created_at: now,
-                updated_at: now,
-            });
-        }
-        const sessionKey = this.options.getWorkspaceRouter().getThreadSessionKey(threadId);
+        let { threadId } = await (0, thread_routing_js_1.resolveChannelThreadRoute)({
+            store: this.options.store,
+            router,
+            workspaceId: input.workspaceId,
+            platformKey,
+            chatId: input.chatId,
+            platformUserId: input.platformUserId,
+            displayName: input.displayName,
+            fallbackTitlePrefix: 'Lark',
+            authorized,
+        });
         const normalizedText = String(input.text || '').trim().toLowerCase();
         const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny')
             ? this.findAwaitingPermissionThreadId(input.workspaceId, input.chatId, input.platformUserId)
@@ -659,35 +693,18 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const acknowledgement = this.createTurnState(effectiveSessionKey, input.messageId);
         await this.addAcknowledgementReaction(input.workspaceId, input.messageId, acknowledgement, instanceId);
         const slashCommand = this.parseSlashCommand(input.text);
-        if (slashCommand?.name === 'new') {
-            const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`;
-            const nextThread = await router.createThread(input.workspaceId, title);
-            const inheritedMode = this.options.store.getThreadRow?.(threadId)?.agent_mode || '';
-            if (inheritedMode && inheritedMode !== 'default') {
-                this.options.store.updateThreadAgentMode?.(nextThread.id, inheritedMode);
-            }
-            const now = new Date().toISOString();
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, platformKey);
-            this.options.store.upsertPlatformThreadBinding({
-                workspace_id: input.workspaceId,
-                platform: platformKey,
-                chat_id: input.chatId,
-                platform_user_id: input.platformUserId,
-                thread_id: nextThread.id,
-                last_platform_message_id: null,
-                created_at: now,
-                updated_at: now,
-            });
-            this.threadRouting.set(this.options.getWorkspaceRouter().getThreadSessionKey(nextThread.id), {
-                workspaceId: input.workspaceId,
-                instanceId,
-                platformKey,
-                platformUserId: input.platformUserId,
-                chatId: input.chatId,
-                threadId: nextThread.id,
-            });
-            await this.sendImmediateCard(input.workspaceId, input.chatId, '**已开始新会话**', instanceId);
-            return { paired: true, threadId: nextThread.id };
+        const sessionCommand = await this.executeSessionCommand({
+            workspaceId: input.workspaceId,
+            currentThreadId: threadId,
+            text: input.text,
+            defaultTitle: `${input.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`,
+            chatId: input.chatId,
+            platformUserId: input.platformUserId,
+            platformKey,
+            instanceId,
+        });
+        if (sessionCommand.handled) {
+            return { paired: true, threadId: sessionCommand.threadId || threadId };
         }
         const latestRun = this.options.store.getLatestRunForThread(threadId);
         if ((normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny')
@@ -768,6 +785,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             appId: binding.appId,
             autoApprove: binding.autoApprove,
             cardActionsEnabled: binding.cardActionsEnabled,
+            groupReplyAll: binding.groupReplyAll,
+            botOpenId: binding.botOpenId,
         };
         this.runtime.set(key, status);
         this.notifyRuntimeStateChanged();
@@ -780,6 +799,14 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 appType: mod.AppType.SelfBuild,
                 domain: mod.Domain.Feishu,
             });
+            try {
+                status.botOpenId = await this.fetchBotOpenId(status);
+                binding.botOpenId = status.botOpenId;
+                this.options.log?.(`localcore-lark bot identified for ${binding.workspaceId}/${binding.instanceId}: ${status.botOpenId}`);
+            }
+            catch (error) {
+                this.options.log?.(`localcore-lark bot identity lookup failed for ${binding.workspaceId}/${binding.instanceId}; group mention filtering may be limited: ${error instanceof Error ? error.message : String(error)}`);
+            }
             status.eventDispatcher = new mod.EventDispatcher({
                 encryptKey: binding.encryptKey || '',
                 verificationToken: binding.verificationToken || '',
@@ -854,6 +881,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             appId: state.appId,
             autoApprove: state.autoApprove,
             cardActionsEnabled: state.cardActionsEnabled,
+            groupReplyAll: state.groupReplyAll,
+            botOpenId: state.botOpenId,
         });
         this.notifyRuntimeStateChanged();
     }
@@ -870,25 +899,17 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const instanceId = legacyCall ? 'default' : instanceIdOrData;
         const platformKey = legacyCall ? 'lark' : String(platformKeyOrData || (0, config_js_1.channelPlatformKey)('lark', instanceId));
         const data = (legacyCall ? instanceIdOrData : maybeData) || {};
-        const payload = (data?.event && typeof data.event === 'object')
-            ? data.event
-            : data;
-        const message = payload?.message;
-        const sender = payload?.sender;
-        this.options.log?.(`localcore-lark handling message event for ${workspaceId}: ${this.summarizeLarkPayload(payload)}`);
-        if (!message || !sender) {
-            this.options.log?.(`localcore-lark ignored event without message/sender for ${workspaceId}: ${JSON.stringify(Object.keys(data || {}))}`);
+        const runtimeState = this.resolveRuntimeState(workspaceId, instanceId).state;
+        const normalized = (0, inbound_js_1.normalizeLarkInboundMessageEvent)(data, {
+            botOpenId: runtimeState?.botOpenId,
+            groupReplyAll: runtimeState?.groupReplyAll,
+        });
+        this.options.log?.(`localcore-lark handling message event for ${workspaceId}: ${(0, inbound_js_1.summarizeLarkInboundPayload)(data)}`);
+        if (!normalized.ok) {
+            this.options.log?.(`localcore-lark ignored message event for ${workspaceId}: reason=${normalized.reason}${normalized.detail ? ` ${normalized.detail}` : ''}`);
             return;
         }
-        let parsedContent = {};
-        try {
-            parsedContent = JSON.parse(String(message.content || '{}'));
-        }
-        catch {
-            parsedContent = {};
-        }
-        const messageType = String(message.message_type || '').trim().toLowerCase();
-        const text = String(parsedContent.text || '').trim();
+        const { message, parsedContent, messageType, chatType, mentions, text, platformUserId, chatId, displayName, messageId, } = normalized.message;
         const contentParts = [];
         if (text) {
             contentParts.push({ type: 'text', text });
@@ -924,24 +945,16 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             return;
         }
         const displayText = text || this.summarizeInboundContentParts(contentParts);
-        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} type=${messageType || 'unknown'} text=${JSON.stringify(displayText.slice(0, 120))}`);
+        this.options.log?.(`localcore-lark inbound message for ${workspaceId}: chat=${chatId} user=${platformUserId} chatType=${chatType || 'unknown'} mentions=${mentions.length} type=${messageType || 'unknown'} text=${JSON.stringify(displayText.slice(0, 120))}`);
         await this.handleInboundMessage({
             workspaceId,
             instanceId,
             platformKey,
             platformUserId,
             chatId,
-            displayName: String(payload?.sender?.sender_id?.user_id ||
-                payload?.sender?.sender_id?.open_id ||
-                `Lark ${platformUserId.slice(-6)}`),
+            displayName,
             text: displayText,
-            messageId: String(message.message_id || (0, node_crypto_1.randomUUID)()),
+            messageId,
             contentParts,
         });
     }
@@ -1088,24 +1101,19 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
     }
     summarizeLarkEvent(data) {
-        const payload = (data?.event && typeof data.event === 'object')
-            ? data.event
-            : data;
-        return this.summarizeLarkPayload(payload);
-    }
-    summarizeLarkPayload(payload) {
-        const message = payload?.message || {};
-        const sender = payload?.sender || {};
-        const senderId = sender?.sender_id || {};
-        const content = typeof message.content === 'string' ? message.content : '';
-        return [
-            `message=${String(message.message_id || '') || 'missing'}`,
-            `type=${String(message.message_type || '') || 'missing'}`,
-            `chat=${String(message.chat_id || '') || 'missing'}`,
-            `sender=${String(senderId.user_id || senderId.open_id || '') || 'missing'}`,
-            `contentBytes=${Buffer.byteLength(content, 'utf8')}`,
-            `keys=${JSON.stringify(Object.keys(payload || {}))}`,
-        ].join(' ');
+        return (0, inbound_js_1.summarizeLarkInboundPayload)(data);
+    }
+    async fetchBotOpenId(state) {
+        const response = await state.client.request({
+            url: '/open-apis/bot/v3/info',
+            method: 'GET',
+        });
+        const bot = response?.bot || response?.data?.bot;
+        const openId = String(bot?.open_id || bot?.openId || '').trim();
+        if (!openId) {
+            throw new Error('Lark bot info response did not include bot.open_id');
+        }
+        return openId;
     }
     summarizeWsArgs(args) {
         if (args.length === 0) {
@@ -1157,6 +1165,21 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         this.options.log?.(`localcore-lark card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
         return String(response?.data?.message_id || '').trim();
     }
+    async sendSessionCommandCard(state, chatId, text, actionRows, sessionKey, threadId) {
+        const startedAt = Date.now();
+        const response = await state.client.im.message.create({
+            params: {
+                receive_id_type: this.resolveReceiveIdType(chatId),
+            },
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: JSON.stringify((0, cards_js_1.buildSessionCommandCard)(text, actionRows, sessionKey, threadId)),
+            },
+        });
+        this.options.log?.(`localcore-lark session card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
+        return String(response?.data?.message_id || '').trim();
+    }
     async sendTextAsMessage(state, chatId, text) {
         const startedAt = Date.now();
         const rendered = (0, messages_js_1.renderLarkTextMessage)(text);
@@ -1272,6 +1295,27 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const instanceId = legacyCall ? 'default' : instanceIdOrData;
         const data = (legacyCall ? instanceIdOrData : maybeData) || {};
         try {
+            const sessionAction = (0, cards_js_1.extractSessionCommandActionValue)(data);
+            if (sessionAction) {
+                const route = this.threadRouting.get(sessionAction.sessionKey)
+                    || this.routeFromThreadBinding(sessionAction.threadId, instanceId);
+                if (!route) {
+                    this.options.log?.(`localcore-lark session card action ignored without route for thread=${sessionAction.threadId}`);
+                    return;
+                }
+                await this.executeSessionCommand({
+                    workspaceId,
+                    currentThreadId: sessionAction.threadId,
+                    text: sessionAction.command,
+                    defaultTitle: `Lark ${new Date().toLocaleTimeString()}`,
+                    chatId: route.chatId,
+                    platformUserId: route.platformUserId,
+                    platformKey: route.platformKey,
+                    instanceId: route.instanceId,
+                });
+                this.options.log?.(`localcore-lark processed session card action for ${workspaceId}/${instanceId}: ${sessionAction.command}`);
+                return;
+            }
             const action = (0, cards_js_1.extractCardActionValue)(data);
             if (!action) {
                 return;
@@ -1285,6 +1329,21 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             this.options.log?.(`localcore-lark card action failed for ${workspaceId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    routeFromThreadBinding(threadId, instanceId) {
+        const binding = this.options.store.getPlatformThreadBindingByThreadId(threadId);
+        if (!binding || (binding.platform !== 'lark' && !binding.platform.startsWith('lark:'))) {
+            return undefined;
+        }
+        const bindingInstanceId = getLarkInstanceId(binding.platform) || instanceId || 'default';
+        return {
+            workspaceId: binding.workspace_id,
+            instanceId: bindingInstanceId,
+            platformKey: binding.platform,
+            platformUserId: binding.platform_user_id,
+            chatId: binding.chat_id,
+            threadId: binding.thread_id,
+        };
+    }
     async markPermissionCardActionHandled(workspaceId, instanceId, rootPayload, payload, value, response, threadId) {
         const state = this.resolveRuntimeState(workspaceId, instanceId).state;
         if (!state?.client) {

package/dist-electron/services/local-ai-core/src/channel/shared/session-command-runtime.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSessionCommandRuntime = void 0;
+class ChannelSessionCommandRuntime {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(input) {
+        const result = await this.options.service.execute(input.text, {
+            workspaceId: input.workspaceId,
+            currentThreadId: input.currentThreadId,
+            defaultTitle: input.defaultTitle,
+        });
+        if (!result.handled) {
+            return { handled: false, threadId: input.currentThreadId };
+        }
+        let activeThreadId = input.currentThreadId;
+        for (const effect of result.effects || []) {
+            if (effect.type === 'created_thread') {
+                this.inheritAgentMode(input.currentThreadId, effect.threadId);
+            }
+            if (effect.type === 'activate_thread') {
+                activeThreadId = effect.threadId;
+                this.activateThread(input, effect.threadId);
+            }
+        }
+        await this.options.sendResult(input, result);
+        return { handled: true, threadId: activeThreadId, result };
+    }
+    inheritAgentMode(sourceThreadId, targetThreadId) {
+        const inheritedMode = this.options.store.getThreadRow?.(sourceThreadId)?.agent_mode || '';
+        if (inheritedMode && inheritedMode !== 'default') {
+            this.options.store.updateThreadAgentMode?.(targetThreadId, inheritedMode);
+        }
+    }
+    activateThread(input, threadId) {
+        const now = new Date().toISOString();
+        this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, input.platformKey);
+        this.options.store.upsertPlatformThreadBinding({
+            workspace_id: input.workspaceId,
+            platform: input.platformKey,
+            chat_id: input.chatId,
+            platform_user_id: input.platformUserId,
+            thread_id: threadId,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        this.options.setThreadRoute(this.options.getThreadSessionKey(threadId), this.options.createRoute(input, threadId));
+    }
+}
+exports.ChannelSessionCommandRuntime = ChannelSessionCommandRuntime;

package/dist-electron/services/local-ai-core/src/channel/shared/thread-routing.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveChannelThreadRoute = resolveChannelThreadRoute;
+async function resolveChannelThreadRoute(input) {
+    const threadBinding = input.store.getPlatformThreadBinding(input.workspaceId, input.chatId, input.platformUserId, input.platformKey);
+    let threadId = threadBinding?.thread_id || (input.authorized.chat_id === input.chatId ? input.authorized.thread_id : '') || '';
+    let createdThread = false;
+    if (!threadId) {
+        const thread = await input.router.createThread(input.workspaceId, input.displayName || `${input.fallbackTitlePrefix} ${input.chatId}`);
+        threadId = thread.id;
+        createdThread = true;
+        input.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, input.platformKey);
+    }
+    let createdBinding = false;
+    if (!threadBinding) {
+        const now = new Date().toISOString();
+        input.store.upsertPlatformThreadBinding({
+            workspace_id: input.workspaceId,
+            platform: input.platformKey,
+            chat_id: input.chatId,
+            platform_user_id: input.platformUserId,
+            thread_id: threadId,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        createdBinding = true;
+    }
+    return {
+        threadId,
+        createdThread,
+        createdBinding,
+    };
+}