@wu529778790/open-im 1.9.4-beta.5 → 1.9.4-beta.7

package/dist/dingtalk/event-handler.js

@@ -199,9 +199,9 @@ export function setupDingTalkHandlers(config, sessionManager) {
     async function enqueuePrompt(userId, chatId, prompt, dingtalkTarget) {
         const workDir = sessionManager.getWorkDir(userId);
         const convId = sessionManager.getConvId(userId);
-        return requestQueue.enqueue(userId, convId, prompt, async (nextPrompt) => {
+        return requestQueue.enqueue(userId, convId, prompt, async (nextPrompt, signal) => {
             senderCtx.dingtalkTarget = dingtalkTarget;
-            await handleAIRequest({ userId, chatId, prompt: nextPrompt, workDir, convId });
+            await handleAIRequest({ userId, chatId, prompt: nextPrompt, workDir, convId, signal });
         });
     }
     async function handleEvent(data) {

package/dist/feishu/event-handler.js

@@ -1,5 +1,5 @@
 import { resolvePlatformAiCommand } from '../config.js';
-import { sendTextReply, startTypingLoop, sendImageReply, sendThinkingCard, streamContentUpdate, } from './message-sender.js';
+import { sendTextReply, startTypingLoop, sendImageReply, sendThinkingCard, streamContentUpdate, sendFinalCards, sendErrorCard, } from './message-sender.js';
 import { buildCardV2 } from './card-builder.js';
 import { disableStreaming, updateCardFull, destroySession } from './cardkit-manager.js';
 import { CARDKIT_THROTTLE_MS } from '../constants.js';
@@ -172,33 +172,6 @@ export function setupFeishuHandlers(config, sessionManager) {
             await sendImageReply(chatId, imagePath);
         },
     };
-    // Feishu-specific task callbacks for CardKit streaming
-    const feishuTaskCallbacks = {
-        streamUpdate: async (content, toolNote) => {
-            if (consecutiveStreamErrors >= MAX_STREAM_ERRORS)
-                return; // Stop trying
-            const note = buildProgressNote(toolNote);
-            // Note: cardId is passed via taskKey format: userId:cardId
-            const cardId = content; // Placeholder, will be overridden via context
-            streamContentUpdate(cardId, content, note).then(() => {
-                consecutiveStreamErrors = 0;
-            }).catch((e) => {
-                consecutiveStreamErrors++;
-                if (consecutiveStreamErrors >= MAX_STREAM_ERRORS) {
-                    log.warn(`Stream update failed ${consecutiveStreamErrors} times consecutively, giving up: ${e?.message ?? e}`);
-                }
-                else {
-                    log.debug('Stream update failed (will retry on next update):', e?.message ?? e);
-                }
-            });
-        },
-        sendComplete: async (content, note) => {
-            // Will be customized via context
-        },
-        sendError: async (error) => {
-            // Will be customized via context
-        },
-    };
     // Create platform-specific AI request handler
     const handleAIRequest = createPlatformAIRequestHandler({
         platform: 'feishu',
@@ -214,6 +187,31 @@ export function setupFeishuHandlers(config, sessionManager) {
             const resetCard = buildCardV2({ content: content || '...', status: 'streaming', toolName: resolvePlatformAiCommand(config, 'feishu') }, cardId);
             updateCardFull(cardId, resetCard).catch((e) => log.warn('Thinking→text transition update failed:', e?.message ?? e));
         },
+        taskCallbacksFactory: ({ msgId: cardId, toolId }) => ({
+            streamUpdate: async (content, toolNote) => {
+                if (consecutiveStreamErrors >= MAX_STREAM_ERRORS)
+                    return;
+                const note = buildProgressNote(toolNote);
+                streamContentUpdate(cardId, content, note).then(() => {
+                    consecutiveStreamErrors = 0;
+                }).catch((e) => {
+                    consecutiveStreamErrors++;
+                    if (consecutiveStreamErrors >= MAX_STREAM_ERRORS) {
+                        log.warn(`Stream update failed ${consecutiveStreamErrors} times consecutively, giving up: ${e?.message ?? e}`);
+                    }
+                    else {
+                        log.debug('Stream update failed (will retry on next update):', e?.message ?? e);
+                    }
+                });
+            },
+            sendComplete: async (content, note, thinkingText) => {
+                const aiTool = resolvePlatformAiCommand(config, 'feishu');
+                await sendFinalCards('', cardId, cardId, content, note ?? '', thinkingText, aiTool);
+            },
+            sendError: async (error) => {
+                await sendErrorCard(cardId, error);
+            },
+        }),
     });
     /**
      * 解析 action value（兼容对象、JSON 字符串）
@@ -459,8 +457,8 @@ export function setupFeishuHandlers(config, sessionManager) {
                         });
                         const work = sessionManager.getWorkDir(senderId);
                         const convId = sessionManager.getConvId(senderId);
-                        const enqueueResult = ctx.requestQueue.enqueue(senderId, convId, prompt, async (p) => {
-                            await handleAIRequest({ userId: senderId, chatId, prompt: p, workDir: work, convId, replyToMessageId: messageId });
+                        const enqueueResult = ctx.requestQueue.enqueue(senderId, convId, prompt, async (p, signal) => {
+                            await handleAIRequest({ userId: senderId, chatId, prompt: p, workDir: work, convId, replyToMessageId: messageId, signal });
                         });
                         if (enqueueResult === 'rejected') {
                             sendTextReply(chatId, 'Request queue is full. Please try again later.').catch((sendErr) => {
@@ -507,8 +505,8 @@ export function setupFeishuHandlers(config, sessionManager) {
                         });
                         const workDir = sessionManager.getWorkDir(senderId);
                         const convId = sessionManager.getConvId(senderId);
-                        const enqueueResult = ctx.requestQueue.enqueue(senderId, convId, prompt, async (p) => {
-                            await handleAIRequest({ userId: senderId, chatId, prompt: p, workDir, convId, replyToMessageId: messageId });
+                        const enqueueResult = ctx.requestQueue.enqueue(senderId, convId, prompt, async (p, signal) => {
+                            await handleAIRequest({ userId: senderId, chatId, prompt: p, workDir, convId, replyToMessageId: messageId, signal });
                         });
                         if (enqueueResult === 'rejected') {
                             sendTextReply(chatId, 'Request queue is full. Please try again later.').catch((sendErr) => {

package/dist/platform/handle-ai-request.d.ts

@@ -92,6 +92,8 @@ export interface HandleAIRequestParams {
     workDir: string;
     convId?: string;
     replyToMessageId?: string;
+    /** AbortSignal from the request queue; fires on task timeout */
+    signal?: AbortSignal;
 }
 /**
  * Creates a platform-specific handleAIRequest function.

package/dist/platform/handle-ai-request.js

@@ -29,7 +29,7 @@ const log = createLogger('PlatformAI');
 export function createPlatformAIRequestHandler(deps) {
     const { platform, config, sessionManager, sender, throttleMs, runningTasks, minContentDeltaChars, taskKeyBuilder, onThinkingToText, extraInit, taskCallbacks, taskCallbacksFactory, } = deps;
     async function handleAIRequest(params) {
-        const { userId, chatId, prompt, workDir, convId, replyToMessageId } = params;
+        const { userId, chatId, prompt, workDir, convId, replyToMessageId, signal } = params;
         log.info(`[${platform}] AI request: userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
         // 1. Resolve AI command and adapter
         const aiCommand = resolvePlatformAiCommand(config, platform);
@@ -156,6 +156,7 @@ export function createPlatformAIRequestHandler(deps) {
                 convId,
                 platform,
                 taskKey,
+                signal,
             }, prompt, toolAdapter, mergedCallbacks);
         }
         catch (err) {

package/dist/platform/handle-text-flow.js

@@ -92,7 +92,7 @@ export async function handleTextFlow(params) {
         const { requestQueue } = ctx;
         const workDir = workDirOverride;
         const convId = convIdOverride;
-        const enqueueResult = requestQueue.enqueue(userId, convId ?? '', text, async (prompt) => {
+        const enqueueResult = requestQueue.enqueue(userId, convId ?? '', text, async (prompt, signal) => {
             await handleAIRequest({
                 userId,
                 chatId,
@@ -100,6 +100,7 @@ export async function handleTextFlow(params) {
                 workDir: workDir ?? '',
                 convId,
                 replyToMessageId,
+                signal,
             });
         });
         if (enqueueResult === 'rejected') {

package/dist/qq/event-handler.js

@@ -167,7 +167,7 @@ export function setupQQHandlers(config, sessionManager) {
     });
     // Wrap factory handleAIRequest to match ClaudeRequestHandler signature
     // (used by commandHandler.dispatch and handleTextFlow)
-    async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
+    async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId, signal) {
         await factoryHandleAIRequest({
             userId,
             chatId,
@@ -175,6 +175,7 @@ export function setupQQHandlers(config, sessionManager) {
             workDir,
             convId,
             replyToMessageId,
+            signal,
         });
     }
     function cleanupRecentEvents(now) {
@@ -264,8 +265,8 @@ export function setupQQHandlers(config, sessionManager) {
                 setActiveChatId("qq", chatId);
                 setChatUser(chatId, userId, "qq");
                 // Enqueue attachment prompt
-                const enqueueResult = requestQueue.enqueue(userId, convId ?? '', attachmentPrompt, async (prompt) => {
-                    await handleAIRequest(userId, chatId, prompt, workDir, convId, undefined, event.id);
+                const enqueueResult = requestQueue.enqueue(userId, convId ?? '', attachmentPrompt, async (prompt, signal) => {
+                    await handleAIRequest(userId, chatId, prompt, workDir, convId, undefined, event.id, signal);
                 });
                 if (enqueueResult === "rejected") {
                     await sendTextReply(chatId, "Request queue is full. Please try again later.");

package/dist/queue/request-queue.d.ts

@@ -1,7 +1,7 @@
 export type EnqueueResult = 'running' | 'queued' | 'rejected';
 export declare class RequestQueue {
     private queues;
-    enqueue(userId: string, convId: string, prompt: string, execute: (prompt: string) => Promise<void>): EnqueueResult;
+    enqueue(userId: string, convId: string, prompt: string, execute: (prompt: string, signal: AbortSignal) => Promise<void>): EnqueueResult;
     /** 清除指定用户会话的所有排队任务（不中止正在运行的任务） */
     clear(userId: string, convId: string): number;
     private run;

package/dist/queue/request-queue.js

@@ -35,12 +35,16 @@ export class RequestQueue {
         return cleared;
     }
     async run(key, prompt, execute) {
+        const controller = new AbortController();
         let timer;
         try {
             const timeoutPromise = new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(`Task timed out after ${TASK_TIMEOUT_MS / 1000}s`)), TASK_TIMEOUT_MS);
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error(`Task timed out after ${TASK_TIMEOUT_MS / 1000}s`));
+                }, TASK_TIMEOUT_MS);
             });
-            await Promise.race([execute(prompt), timeoutPromise]);
+            await Promise.race([execute(prompt, controller.signal), timeoutPromise]);
         }
         catch (err) {
             log.error(`Error executing task for ${key}:`, err);

package/dist/queue/request-queue.test.js

@@ -8,7 +8,7 @@ describe('RequestQueue', () => {
         expect(result).toBe('running');
         // Allow microtask queue to settle
         await new Promise((r) => setTimeout(r, 10));
-        expect(execute).toHaveBeenCalledWith('hello');
+        expect(execute).toHaveBeenCalledWith('hello', expect.any(AbortSignal));
     });
     it('returns "queued" when a task is already running', () => {
         const queue = new RequestQueue();
@@ -37,11 +37,11 @@ describe('RequestQueue', () => {
         queue.enqueue('user1', 'conv1', 'first', execute);
         queue.enqueue('user1', 'conv1', 'second', execute);
         expect(execute).toHaveBeenCalledTimes(1);
-        expect(execute).toHaveBeenCalledWith('first');
+        expect(execute).toHaveBeenCalledWith('first', expect.any(AbortSignal));
         resolveFirst();
         await new Promise((r) => setTimeout(r, 20));
         expect(execute).toHaveBeenCalledTimes(2);
-        expect(execute).toHaveBeenCalledWith('second');
+        expect(execute).toHaveBeenCalledWith('second', expect.any(AbortSignal));
     });
     it('isolates queues per user:convId', () => {
         const queue = new RequestQueue();
@@ -90,7 +90,25 @@ describe('RequestQueue', () => {
         queue.enqueue('user1', 'conv1', 'second', execute);
         await new Promise((r) => setTimeout(r, 20));
         expect(execute).toHaveBeenCalledTimes(2);
-        expect(execute).toHaveBeenCalledWith('first');
-        expect(execute).toHaveBeenCalledWith('second');
+        expect(execute).toHaveBeenCalledWith('first', expect.any(AbortSignal));
+        expect(execute).toHaveBeenCalledWith('second', expect.any(AbortSignal));
+    });
+    it('aborts the AbortSignal on timeout', async () => {
+        vi.useFakeTimers();
+        const queue = new RequestQueue();
+        let receivedSignal;
+        const execute = vi.fn().mockImplementation(async (_prompt, signal) => {
+            receivedSignal = signal;
+            // Never resolve — simulates a stuck task
+            await new Promise(() => { });
+        });
+        queue.enqueue('user1', 'conv1', 'hello', execute);
+        await vi.advanceTimersByTimeAsync(10);
+        expect(receivedSignal?.aborted).toBe(false);
+        // Advance past timeout
+        vi.advanceTimersByTime(10 * 60 * 1000 + 1);
+        await vi.advanceTimersByTimeAsync(100);
+        expect(receivedSignal?.aborted).toBe(true);
+        vi.useRealTimers();
     });
 });

package/dist/shared/ai-task.d.ts

@@ -17,6 +17,8 @@ export interface TaskContext {
     threadId?: string;
     platform: string;
     taskKey: string;
+    /** AbortSignal from the request queue; fires on task timeout to abort the running SDK session */
+    signal?: AbortSignal;
 }
 export interface TaskAdapter {
     streamUpdate(content: string, toolNote?: string): void;

package/dist/shared/ai-task.js

@@ -255,5 +255,14 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
             return;
         }
         platformAdapter.onTaskReady(taskState);
+        // Wire queue abort signal to the running task's abort handle
+        if (ctx.signal) {
+            if (ctx.signal.aborted) {
+                taskState.handle.abort();
+            }
+            else {
+                ctx.signal.addEventListener('abort', () => taskState.handle.abort(), { once: true });
+            }
+        }
     });
 }

package/dist/telegram/event-handler.js

@@ -254,8 +254,8 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         });
         const workDir = sessionManager.getWorkDir(userId);
         const convId = sessionManager.getConvId(userId);
-        return requestQueue.enqueue(userId, convId, prompt, async (nextPrompt) => {
-            await handleAIRequest({ userId, chatId, prompt: nextPrompt, workDir, convId });
+        return requestQueue.enqueue(userId, convId, prompt, async (nextPrompt, signal) => {
+            await handleAIRequest({ userId, chatId, prompt: nextPrompt, workDir, convId, signal });
         });
     }
     bot.on("callback_query", async (ctx) => {

package/dist/wework/event-handler.js

@@ -240,8 +240,8 @@ export function setupWeWorkHandlers(config, sessionManager) {
     async function enqueuePrompt(userId, chatId, prompt, reqId) {
         const workDir = sessionManager.getWorkDir(userId);
         const convId = sessionManager.getConvId(userId);
-        const enqueueResult = ctx.requestQueue.enqueue(userId, convId, prompt, async (nextPrompt) => {
-            await handleAIRequest({ userId, chatId, prompt: nextPrompt, workDir, convId, replyToMessageId: undefined });
+        const enqueueResult = ctx.requestQueue.enqueue(userId, convId, prompt, async (nextPrompt, signal) => {
+            await handleAIRequest({ userId, chatId, prompt: nextPrompt, workDir, convId, replyToMessageId: undefined, signal });
         });
         if (enqueueResult === 'rejected') {
             await sendTextReply(chatId, 'Request queue is full. Please try again later.', reqId);

package/dist/workbuddy/event-handler.js

@@ -83,7 +83,7 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
         extraInit,
     });
     // WorkBuddy-specific wrapper that captures msgId
-    async function handleAIRequest(userId, chatId, msgId, prompt, workDir, convId) {
+    async function handleAIRequest(userId, chatId, msgId, prompt, workDir, convId, signal) {
         log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, msgId=${msgId}, promptLength=${prompt.length}`);
         // WorkBuddy uses incoming msgId as taskKey (no thinking message needed)
         const taskKey = `${userId}:${msgId}`;
@@ -104,7 +104,7 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
         log.info(`[handleAIRequest] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
         // Set up task tracking key mapping
         taskKeyByChatId.set(chatId, taskKey);
-        await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'workbuddy', taskKey }, prompt, toolAdapter, {
+        await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'workbuddy', taskKey, signal }, prompt, toolAdapter, {
             throttleMs: WORKBUDDY_THROTTLE_MS,
             streamUpdate: async (content) => {
                 log.debug(`Stream update (not sent): ${content.substring(0, 50)}...`);
@@ -172,9 +172,9 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
         if (!text) {
             return;
         }
-        const enqueueResult = ctx.requestQueue.enqueue(userId, convId, text, async (nextPrompt) => {
+        const enqueueResult = ctx.requestQueue.enqueue(userId, convId, text, async (nextPrompt, signal) => {
             log.info(`Executing AI request for: ${nextPrompt}`);
-            await handleAIRequest(userId, chatId, msgId, nextPrompt, workDir, convId);
+            await handleAIRequest(userId, chatId, msgId, nextPrompt, workDir, convId, signal);
         });
         if (enqueueResult === 'rejected') {
             await sendErrorReply(null, chatId, 'Request queue is full. Please try again later.', msgId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.9.4-beta.5",
+  "version": "1.9.4-beta.7",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",