@wu529778790/open-im 1.9.4-beta.4 → 1.9.4-beta.6

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

@@ -459,8 +459,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 +507,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/centrifuge-client.d.ts

@@ -32,6 +32,8 @@ export interface CentrifugeCallbacks {
     onDisconnected?: (reason?: string) => void;
     onError?: (error: Error) => void;
     onMessage?: (chatId: string, msgId: string, content: string) => void;
+    /** Called when reconnection has failed too many times — caller should do a full re-registration */
+    onPersistentFailure?: () => void;
 }
 export declare class WorkBuddyCentrifugeClient {
     private config;
@@ -41,6 +43,9 @@ export declare class WorkBuddyCentrifugeClient {
     private extraSubs;
     private state;
     private processedMsgIds;
+    private consecutiveErrors;
+    private pendingReplies;
+    private flushing;
     private static readonly MAX_MSG_ID_CACHE;
     constructor(config: CentrifugeClientConfig, callbacks?: CentrifugeCallbacks);
     get logPrefix(): string;
@@ -83,4 +88,12 @@ export declare class WorkBuddyCentrifugeClient {
      * Clean up old message IDs from cache
      */
     private cleanMsgIdCache;
+    /**
+     * Enqueue a failed reply for later delivery
+     */
+    private enqueuePendingReply;
+    /**
+     * Retry all pending replies after a successful reconnection
+     */
+    private flushPendingReplies;
 }

package/dist/workbuddy/centrifuge-client.js

@@ -6,6 +6,12 @@ import { WebSocket } from 'ws';
 import { randomUUID } from 'node:crypto';
 import { createLogger } from '../logger.js';
 const log = createLogger('WorkBuddyCentrifuge');
+/** Max consecutive errors before triggering full re-registration */
+const PERSISTENT_FAILURE_THRESHOLD = 5;
+/** Max queued replies awaiting delivery */
+const MAX_PENDING_REPLIES = 20;
+/** Max age (ms) of a queued reply before it's discarded */
+const PENDING_REPLY_TTL_MS = 5 * 60_000;
 export class WorkBuddyCentrifugeClient {
     config;
     callbacks;
@@ -14,6 +20,9 @@ export class WorkBuddyCentrifugeClient {
     extraSubs = [];
     state = 'disconnected';
     processedMsgIds = new Set();
+    consecutiveErrors = 0;
+    pendingReplies = [];
+    flushing = false;
     static MAX_MSG_ID_CACHE = 1000;
     constructor(config, callbacks = {}) {
         this.config = config;
@@ -39,7 +48,9 @@ export class WorkBuddyCentrifugeClient {
         this.client.on('connected', (ctx) => {
             log.info(`${this.logPrefix} Connected (transport=${ctx.transport})`);
             this.state = 'connected';
+            this.consecutiveErrors = 0;
             this.callbacks.onConnected?.();
+            this.flushPendingReplies();
         });
         this.client.on('disconnected', (ctx) => {
             log.info(`${this.logPrefix} Disconnected: code=${ctx.code}, reason=${ctx.reason}`);
@@ -56,7 +67,15 @@ export class WorkBuddyCentrifugeClient {
         });
         this.client.on('error', (ctx) => {
             log.error(`${this.logPrefix} Error: ${ctx.error.message}`);
+            this.consecutiveErrors++;
             this.callbacks.onError?.(new Error(ctx.error.message));
+            if (this.consecutiveErrors >= PERSISTENT_FAILURE_THRESHOLD) {
+                log.warn(`${this.logPrefix} ${this.consecutiveErrors} consecutive errors — triggering full re-registration`);
+                this.consecutiveErrors = 0;
+                // Stop the current Centrifuge instance so client.ts can create a fresh one
+                this.stop();
+                this.callbacks.onPersistentFailure?.();
+            }
         });
         // Create channel subscription
         this.sub = this.client.newSubscription(this.config.channel, {
@@ -216,7 +235,7 @@ export class WorkBuddyCentrifugeClient {
                 }
             }
             if (!sent) {
-                log.error(`${this.logPrefix} Failed to send COPILOT_RESPONSE after retries`);
+                this.enqueuePendingReply(url, httpPayload, this.config.httpAccessToken);
             }
             // Release the heartbeat lock so the periodic registration can resume
             this.config.releaseChannelLockFn?.();
@@ -325,4 +344,57 @@ export class WorkBuddyCentrifugeClient {
             });
         }
     }
+    /**
+     * Enqueue a failed reply for later delivery
+     */
+    enqueuePendingReply(url, payload, accessToken) {
+        // Evict expired entries
+        const now = Date.now();
+        this.pendingReplies = this.pendingReplies.filter((r) => now - r.addedAt < PENDING_REPLY_TTL_MS);
+        if (this.pendingReplies.length >= MAX_PENDING_REPLIES) {
+            const evicted = this.pendingReplies.shift();
+            log.warn(`${this.logPrefix} Pending replies full, evicting oldest (msgId=${evicted?.payload.msgId})`);
+        }
+        this.pendingReplies.push({ url, payload, accessToken, addedAt: now });
+        log.warn(`${this.logPrefix} Queued pending reply (queue=${this.pendingReplies.length}, msgId=${payload.msgId})`);
+    }
+    /**
+     * Retry all pending replies after a successful reconnection
+     */
+    async flushPendingReplies() {
+        if (this.flushing || this.pendingReplies.length === 0)
+            return;
+        this.flushing = true;
+        const now = Date.now();
+        // Take only non-expired replies
+        const toSend = this.pendingReplies.filter((r) => now - r.addedAt < PENDING_REPLY_TTL_MS);
+        this.pendingReplies = [];
+        if (toSend.length > 0) {
+            log.info(`${this.logPrefix} Flushing ${toSend.length} pending reply(ies)`);
+        }
+        for (const reply of toSend) {
+            try {
+                const res = await fetch(reply.url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${reply.accessToken}`,
+                    },
+                    body: JSON.stringify(reply.payload),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                const body = await res.text().catch(() => '');
+                if (res.ok) {
+                    log.info(`${this.logPrefix} Flushed pending reply ok: msgId=${reply.payload.msgId}`);
+                }
+                else {
+                    log.error(`${this.logPrefix} Flushed pending reply failed: ${res.status} ${body.substring(0, 200)}`);
+                }
+            }
+            catch (err) {
+                log.error(`${this.logPrefix} Flushed pending reply error: msgId=${reply.payload.msgId}`, err);
+            }
+        }
+        this.flushing = false;
+    }
 }

package/dist/workbuddy/client.js

@@ -198,6 +198,15 @@ async function connect() {
             log.error(`WorkBuddy Centrifuge error: ${error instanceof Error ? error.message : JSON.stringify(error)}`);
             updateState('error');
         },
+        onPersistentFailure: () => {
+            log.warn('WorkBuddy Centrifuge persistent failure detected — doing full re-registration');
+            if (heartbeatTimer) {
+                clearInterval(heartbeatTimer);
+                heartbeatTimer = null;
+            }
+            updateState('disconnected');
+            scheduleReconnect();
+        },
         onMessage: async (chatId, msgId, content) => {
             if (messageHandler) {
                 try {

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.4",
+  "version": "1.9.4-beta.6",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",