@wu529778790/open-im 1.9.3 → 1.9.4-beta.0

package/dist/workbuddy/centrifuge-client.d.ts

@@ -42,9 +42,18 @@ export declare class WorkBuddyCentrifugeClient {
     private state;
     private processedMsgIds;
     private static readonly MAX_MSG_ID_CACHE;
+    private streamingActive;
+    private subscribedChannels;
+    private lastErrorMsg;
+    private lastErrorTime;
+    private pendingResponses;
     constructor(config: CentrifugeClientConfig, callbacks?: CentrifugeCallbacks);
     get logPrefix(): string;
     getState(): WorkBuddyState;
+    /** Enable/disable streaming mode: skip per-message channel registration during streaming. */
+    setStreamingMode(active: boolean): void;
+    /** Flush pending responses that failed to send. */
+    flushPendingResponses(): Promise<void>;
     start(): void;
     stop(): void;
     setCallbacks(callbacks: Partial<CentrifugeCallbacks>): void;
@@ -71,6 +80,8 @@ export declare class WorkBuddyCentrifugeClient {
      * Send prompt response (for WeChat KF, use HTTP instead)
      */
     sendPromptResponse(payload: PromptResponsePayload, _guid?: string, _userId?: string): Promise<void>;
+    /** Send HTTP COPILOT_RESPONSE with retry and pending queue fallback. */
+    private sendHttpResponse;
     /**
      * Handle incoming publication from Centrifuge
      */

package/dist/workbuddy/centrifuge-client.js

@@ -15,6 +15,11 @@ export class WorkBuddyCentrifugeClient {
     state = 'disconnected';
     processedMsgIds = new Set();
     static MAX_MSG_ID_CACHE = 1000;
+    streamingActive = false;
+    subscribedChannels = new Set();
+    lastErrorMsg = '';
+    lastErrorTime = 0;
+    pendingResponses = [];
     constructor(config, callbacks = {}) {
         this.config = config;
         this.callbacks = callbacks;
@@ -25,6 +30,29 @@ export class WorkBuddyCentrifugeClient {
     getState() {
         return this.state;
     }
+    /** Enable/disable streaming mode: skip per-message channel registration during streaming. */
+    setStreamingMode(active) {
+        this.streamingActive = active;
+        if (!active) {
+            this.config.releaseChannelLockFn?.();
+        }
+    }
+    /** Flush pending responses that failed to send. */
+    async flushPendingResponses() {
+        if (this.pendingResponses.length === 0)
+            return;
+        const pending = [...this.pendingResponses];
+        this.pendingResponses = [];
+        log.info(`${this.logPrefix} Flushing ${pending.length} pending responses`);
+        for (const item of pending) {
+            try {
+                await this.sendHttpResponse(item.payload);
+            }
+            catch {
+                log.warn(`${this.logPrefix} Failed to flush pending response`);
+            }
+        }
+    }
     start() {
         if (this.state === 'connected' || this.state === 'connecting') {
             log.info(`${this.logPrefix} Already connected or connecting`);
@@ -55,8 +83,16 @@ export class WorkBuddyCentrifugeClient {
             }
         });
         this.client.on('error', (ctx) => {
-            log.error(`${this.logPrefix} Error: ${ctx.error.message}`);
-            this.callbacks.onError?.(new Error(ctx.error.message));
+            const msg = ctx.error?.message || String(ctx.error);
+            const now = Date.now();
+            // Suppress duplicate errors within 5 seconds to avoid log flooding
+            if (msg === this.lastErrorMsg && now - this.lastErrorTime < 5000) {
+                return;
+            }
+            this.lastErrorMsg = msg;
+            this.lastErrorTime = now;
+            log.error(`${this.logPrefix} Error: ${msg}`);
+            this.callbacks.onError?.(new Error(msg));
         });
         // Create channel subscription
         this.sub = this.client.newSubscription(this.config.channel, {
@@ -75,6 +111,10 @@ export class WorkBuddyCentrifugeClient {
         log.info(`${this.logPrefix} Stopping...`);
         this.state = 'disconnected';
         this.processedMsgIds.clear();
+        this.streamingActive = false;
+        this.subscribedChannels.clear();
+        this.lastErrorMsg = '';
+        this.pendingResponses = [];
         for (const sub of this.extraSubs) {
             sub.unsubscribe();
         }
@@ -100,6 +140,11 @@ export class WorkBuddyCentrifugeClient {
             log.warn(`${this.logPrefix} Cannot subscribe: client not initialized`);
             return;
         }
+        // Skip if already subscribed to this channel
+        if (this.subscribedChannels.has(channel)) {
+            log.info(`${this.logPrefix} Already subscribed to: ${channel}, skipping duplicate`);
+            return;
+        }
         log.info(`${this.logPrefix} Subscribing to additional channel: ${channel}`);
         const sub = this.client.newSubscription(channel, { token: subscriptionToken });
         sub.on('publication', (ctx) => {
@@ -112,6 +157,7 @@ export class WorkBuddyCentrifugeClient {
             log.info(`${this.logPrefix} Extra channel subscribed: ${channel}`);
         });
         this.extraSubs.push(sub);
+        this.subscribedChannels.add(channel);
         sub.subscribe();
     }
     /**
@@ -144,14 +190,10 @@ export class WorkBuddyCentrifugeClient {
     async sendPromptResponse(payload, _guid, _userId) {
         // WeChat KF messages: send via HTTP COPILOT_RESPONSE
         if (this.config.httpBaseUrl && this.config.httpAccessToken) {
-            const message = payload.content?.map((c) => c.text).join('') || payload.error || '';
-            const sessionId = payload.session_id; // e.g. "wmXXX::origin::wechatkfProxy"
-            // The WorkBuddy server uses the registered channelId as the WeChat KF send_msg
-            // `touser`.  Re-register the channel with the current WeChat user's externalUserId
-            // so that the server sends the reply to the correct customer.
+            const sessionId = payload.session_id;
+            // Register channel before sending (skip during streaming to reduce overhead)
             const externalUserId = sessionId.includes('::') ? sessionId.split('::')[0] : null;
-            if (this.config.registerChannelFn && externalUserId) {
-                // Retry registerChannelFn up to 3 times on network failure
+            if (this.config.registerChannelFn && externalUserId && !this.streamingActive) {
                 for (let attempt = 1; attempt <= 3; attempt++) {
                     try {
                         await this.config.registerChannelFn(externalUserId);
@@ -168,61 +210,74 @@ export class WorkBuddyCentrifugeClient {
                     }
                 }
             }
-            const httpPayload = {
-                type: 'COPILOT_RESPONSE',
-                msgId: payload.prompt_id,
-                chatId: sessionId,
-                success: payload.stop_reason === 'end_turn',
-                message,
-                metadata: {
-                    sessionId: this.config.workspaceSessionId || sessionId,
-                    requestId: payload.prompt_id,
-                    state: payload.stop_reason === 'end_turn' ? 'completed' : payload.stop_reason,
-                },
-            };
-            const url = `${this.config.httpBaseUrl}/v2/backgroundagent/wecom/local-proxy/receive`;
-            log.debug(`${this.logPrefix} HTTP COPILOT_RESPONSE → ${url} chatId=${sessionId} msgLen=${message.length}`);
-            // Retry COPILOT_RESPONSE up to 3 times on network failure
-            let sent = false;
-            for (let attempt = 1; attempt <= 3; attempt++) {
-                try {
-                    const res = await fetch(url, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            Authorization: `Bearer ${this.config.httpAccessToken}`,
-                        },
-                        body: JSON.stringify(httpPayload),
-                        signal: AbortSignal.timeout(30_000),
-                    });
-                    const body = await res.text().catch(() => '');
-                    if (!res.ok) {
-                        log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE failed: ${res.status} ${body.substring(0, 300)}`);
-                    }
-                    else {
-                        log.info(`${this.logPrefix} HTTP COPILOT_RESPONSE ok: ${res.status} ${body.substring(0, 200)}`);
-                    }
-                    sent = true;
-                    break;
+            await this.sendHttpResponse(payload);
+            // Release heartbeat lock (skip during streaming — released when streaming ends)
+            if (!this.streamingActive) {
+                this.config.releaseChannelLockFn?.();
+            }
+            return;
+        }
+        this.sendEnvelope('session.promptResponse', payload, _guid, _userId);
+    }
+    /** Send HTTP COPILOT_RESPONSE with retry and pending queue fallback. */
+    async sendHttpResponse(payload) {
+        const message = payload.content?.map((c) => c.text).join('') || payload.error || '';
+        const sessionId = payload.session_id;
+        const isStreaming = payload.stop_reason === 'streaming';
+        const logLevel = isStreaming ? 'debug' : 'info';
+        const httpPayload = {
+            type: 'COPILOT_RESPONSE',
+            msgId: payload.prompt_id,
+            chatId: sessionId,
+            success: payload.stop_reason === 'end_turn' || isStreaming,
+            message,
+            metadata: {
+                sessionId: this.config.workspaceSessionId || sessionId,
+                requestId: payload.prompt_id,
+                state: payload.stop_reason === 'end_turn' ? 'completed' : payload.stop_reason,
+            },
+        };
+        const url = `${this.config.httpBaseUrl}/v2/backgroundagent/wecom/local-proxy/receive`;
+        log.debug(`${this.logPrefix} HTTP COPILOT_RESPONSE → chatId=${sessionId} msgLen=${message.length} streaming=${isStreaming}`);
+        const maxAttempts = isStreaming ? 2 : 5;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                const res = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${this.config.httpAccessToken}`,
+                    },
+                    body: JSON.stringify(httpPayload),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                const body = await res.text().catch(() => '');
+                if (!res.ok) {
+                    log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE failed: ${res.status} ${body.substring(0, 300)}`);
                 }
-                catch (err) {
-                    if (attempt < 3) {
-                        log.warn(`${this.logPrefix} HTTP COPILOT_RESPONSE attempt ${attempt} failed, retrying in 2s:`, err);
-                        await new Promise((r) => setTimeout(r, 2000));
-                    }
-                    else {
-                        log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE error after 3 attempts:`, err);
-                    }
+                else if (!isStreaming) {
+                    log.info(`${this.logPrefix} HTTP COPILOT_RESPONSE ok: ${res.status} ${body.substring(0, 200)}`);
                 }
+                return; // sent successfully
             }
-            if (!sent) {
-                log.error(`${this.logPrefix} Failed to send COPILOT_RESPONSE after retries`);
+            catch (err) {
+                if (attempt < maxAttempts) {
+                    const delay = 2000 * attempt;
+                    log.warn(`${this.logPrefix} HTTP COPILOT_RESPONSE attempt ${attempt} failed, retrying in ${delay}ms:`, err);
+                    await new Promise((r) => setTimeout(r, delay));
+                }
+                else {
+                    log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE error after ${maxAttempts} attempts:`, err);
+                }
             }
-            // Release the heartbeat lock so the periodic registration can resume
-            this.config.releaseChannelLockFn?.();
-            return;
         }
-        this.sendEnvelope('session.promptResponse', payload, _guid, _userId);
+        // All retries failed — queue for later (only non-streaming responses)
+        if (!isStreaming) {
+            this.pendingResponses.push({ payload, timestamp: Date.now() });
+            if (this.pendingResponses.length > 10)
+                this.pendingResponses.shift();
+            log.warn(`${this.logPrefix} Queued response for retry (queue: ${this.pendingResponses.length})`);
+        }
     }
     /**
      * Handle incoming publication from Centrifuge

package/dist/workbuddy/event-handler.js

@@ -4,7 +4,7 @@
 import { resolvePlatformAiCommand } from '../config.js';
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
-import { sendTextReply, sendErrorReply } from './message-sender.js';
+import { sendTextReply, sendErrorReply, sendStreamingReply } from './message-sender.js';
 import { CommandHandler } from '../commands/handler.js';
 import { getAdapter } from '../adapters/registry.js';
 import { runAITask } from '../shared/ai-task.js';
@@ -12,6 +12,7 @@ import { WORKBUDDY_THROTTLE_MS } from '../constants.js';
 import { setActiveChatId } from '../shared/active-chats.js';
 import { setChatUser } from '../shared/chat-user-map.js';
 import { createLogger } from '../logger.js';
+import { getCentrifugeClient } from './client.js';
 const log = createLogger('WorkBuddyHandler');
 export function setupWorkBuddyHandlers(config, sessionManager) {
     const accessControl = new AccessControl(config.workbuddyAllowedUserIds);
@@ -42,14 +43,20 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
         const taskKey = `${userId}:${msgId}`;
         await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'workbuddy', taskKey }, prompt, toolAdapter, {
             throttleMs: WORKBUDDY_THROTTLE_MS,
+            minContentDeltaChars: 200,
             streamUpdate: async (content) => {
-                // WorkBuddy doesn't support streaming updates via Centrifuge
-                log.debug(`Stream update (not sent): ${content.substring(0, 50)}...`);
+                await sendStreamingReply(null, chatId, content, msgId);
             },
             sendComplete: async (content) => {
+                const client = getCentrifugeClient();
+                if (client)
+                    client.setStreamingMode(false);
                 await sendTextReply(null, chatId, content, msgId);
             },
             sendError: async (error) => {
+                const client = getCentrifugeClient();
+                if (client)
+                    client.setStreamingMode(false);
                 await sendErrorReply(null, chatId, error, msgId);
             },
             extraCleanup: () => {
@@ -62,6 +69,12 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
                 runningTasks.set(taskKey, state);
                 taskKeyByChatId.set(chatId, taskKey);
             },
+            onFirstContent: () => {
+                // Enable streaming mode: register channel once, then skip per-update registration
+                const client = getCentrifugeClient();
+                if (client)
+                    client.setStreamingMode(true);
+            },
         });
     }
     async function handleEvent(chatId, msgId, content) {

package/dist/workbuddy/message-sender.d.ts

@@ -14,3 +14,8 @@ export declare function sendErrorReply(_client: WorkBuddyCentrifugeClient | null
  * Send streaming chunk to WeChat KF
  */
 export declare function sendStreamingChunk(_client: WorkBuddyCentrifugeClient | null, chatId: string, text: string, msgId: string): void;
+/**
+ * Send streaming reply to WeChat KF via HTTP COPILOT_RESPONSE.
+ * Used for intermediate progress updates during AI task execution.
+ */
+export declare function sendStreamingReply(_client: WorkBuddyCentrifugeClient | null, chatId: string, text: string, msgId: string): Promise<void>;

package/dist/workbuddy/message-sender.js

@@ -49,3 +49,20 @@ export function sendStreamingChunk(_client, chatId, text, msgId) {
     }
     client.sendMessageChunk(chatId, msgId, { type: 'text', text });
 }
+/**
+ * Send streaming reply to WeChat KF via HTTP COPILOT_RESPONSE.
+ * Used for intermediate progress updates during AI task execution.
+ */
+export async function sendStreamingReply(_client, chatId, text, msgId) {
+    const client = _client ?? getCentrifugeClient();
+    if (!client) {
+        log.debug('WorkBuddy client not available, skipping streaming reply');
+        return;
+    }
+    await client.sendPromptResponse({
+        session_id: chatId,
+        prompt_id: msgId,
+        content: [{ type: 'text', text }],
+        stop_reason: 'streaming',
+    });
+}

package/dist/workbuddy/types.d.ts

@@ -82,5 +82,5 @@ export interface PromptResponsePayload {
         text?: string;
     }>;
     error?: string;
-    stop_reason: 'end_turn' | 'max_tokens' | 'tool_use' | 'stop_sequence' | 'error';
+    stop_reason: 'end_turn' | 'max_tokens' | 'tool_use' | 'stop_sequence' | 'error' | 'streaming';
 }

package/package.json

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