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

package/dist/channels/capabilities.js

@@ -5,6 +5,7 @@ const PLATFORM_LABELS = {
     wechat: "微信",
     wework: "企业微信",
     dingtalk: "钉钉",
+    workbuddy: "WorkBuddy",
 };
 export const CHANNEL_CAPABILITIES = {
     telegram: {
@@ -31,6 +32,10 @@ export const CHANNEL_CAPABILITIES = {
         inbound: { text: "native", image: "fallback", file: "fallback", voice: "fallback", video: "fallback" },
         outbound: { streamEdit: "native", streamPush: "fallback", image: "fallback", card: "native", typing: "native" },
     },
+    workbuddy: {
+        inbound: { text: "native", image: "none", file: "none", voice: "none", video: "none" },
+        outbound: { streamEdit: "none", streamPush: "none", image: "none", card: "none", typing: "none" },
+    },
 };
 function listPreferredPlatforms(kind) {
     return Object.entries(CHANNEL_CAPABILITIES)

package/dist/commands/handler.d.ts

@@ -18,7 +18,7 @@ export type ClaudeRequestHandler = (userId: string, chatId: string, prompt: stri
 export declare class CommandHandler {
     private deps;
     constructor(deps: CommandHandlerDeps);
-    dispatch(text: string, chatId: string, userId: string, platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework', handleClaudeRequest: ClaudeRequestHandler): Promise<boolean>;
+    dispatch(text: string, chatId: string, userId: string, platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework' | 'workbuddy', handleClaudeRequest: ClaudeRequestHandler): Promise<boolean>;
     private getClearHistoryHint;
     private handleHelp;
     private handleNew;

package/dist/commands/handler.js

@@ -40,7 +40,9 @@ export class CommandHandler {
                 ? '💡 提示：如需清除本对话的历史消息，请清除聊天记录'
                 : platform === 'dingtalk'
                     ? '💡 提示：如需清除本对话的历史消息，请在钉钉中清空聊天记录'
-                    : '💡 提示：如需清除本对话的历史消息，请点击 Telegram 聊天右上角 ⋮ → 清除历史';
+                    : platform === 'workbuddy'
+                        ? '💡 提示：如需清除本对话的历史消息，请清除聊天记录'
+                        : '💡 提示：如需清除本对话的历史消息，请点击 Telegram 聊天右上角 ⋮ → 清除历史';
     }
     async handleHelp(chatId, platform) {
         const help = [

package/dist/config-web.js

@@ -359,6 +359,7 @@ function createProbeConfig(values) {
         wechatAllowedUserIds: [],
         weworkAllowedUserIds: [],
         dingtalkAllowedUserIds: [],
+        workbuddyAllowedUserIds: [],
         aiCommand: "claude",
         codexCliPath: "codex",
         claudeWorkDir: process.cwd(),

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 import { type LogLevel } from './logger.js';
-export type Platform = 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework';
+export type Platform = 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework' | 'workbuddy';
 export type AiCommand = 'claude' | 'codex' | 'codebuddy';
 export interface Config {
     enabledPlatforms: Platform[];
@@ -29,6 +29,7 @@ export interface Config {
     wechatAllowedUserIds: string[];
     weworkAllowedUserIds: string[];
     dingtalkAllowedUserIds: string[];
+    workbuddyAllowedUserIds: string[];
     aiCommand: AiCommand;
     codexCliPath: string;
     codebuddyCliPath: string;
@@ -82,6 +83,17 @@ export interface Config {
             allowedUserIds: string[];
             cardTemplateId?: string;
         };
+        workbuddy?: {
+            enabled: boolean;
+            aiCommand?: AiCommand;
+            allowedUserIds: string[];
+            accessToken?: string;
+            refreshToken?: string;
+            userId?: string;
+            baseUrl?: string;
+            guid?: string;
+            workspacePath?: string;
+        };
     };
 }
 export interface FilePlatformTelegram {
@@ -134,6 +146,17 @@ export interface FilePlatformDingtalk {
     allowedUserIds?: string[];
     cardTemplateId?: string;
 }
+interface FilePlatformWorkBuddy {
+    enabled?: boolean;
+    aiCommand?: AiCommand;
+    allowedUserIds?: string[];
+    accessToken?: string;
+    refreshToken?: string;
+    userId?: string;
+    baseUrl?: string;
+    guid?: string;
+    workspacePath?: string;
+}
 export interface FileToolClaude {
     cliPath?: string;
     workDir?: string;
@@ -167,6 +190,7 @@ export interface FileConfig {
         wechat?: FilePlatformWechat;
         wework?: FilePlatformWework;
         dingtalk?: FilePlatformDingtalk;
+        workbuddy?: FilePlatformWorkBuddy;
     };
     env?: Record<string, string>;
     aiCommand?: string;

package/dist/config.js

@@ -233,6 +233,7 @@ export function loadConfig() {
     const fileWechat = file.platforms?.wechat;
     const fileWework = file.platforms?.wework;
     const fileDingtalk = file.platforms?.dingtalk;
+    const fileWorkBuddy = file.platforms?.workbuddy;
     // 1. 加载各平台凭证（env 优先，其次新结构，最后旧字段）
     const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN ??
         fileTelegram?.botToken ??
@@ -276,6 +277,19 @@ export function loadConfig() {
         fileDingtalk?.clientSecret;
     const dingtalkCardTemplateId = process.env.DINGTALK_CARD_TEMPLATE_ID ??
         fileDingtalk?.cardTemplateId;
+    // WorkBuddy credentials
+    const workbuddyAccessToken = process.env.WORKBUDDY_ACCESS_TOKEN ??
+        fileWorkBuddy?.accessToken;
+    const workbuddyRefreshToken = process.env.WORKBUDDY_REFRESH_TOKEN ??
+        fileWorkBuddy?.refreshToken;
+    const workbuddyUserId = process.env.WORKBUDDY_USER_ID ??
+        fileWorkBuddy?.userId;
+    const workbuddyBaseUrl = process.env.WORKBUDDY_BASE_URL ??
+        fileWorkBuddy?.baseUrl;
+    const workbuddyGuid = process.env.WORKBUDDY_GUID ??
+        fileWorkBuddy?.guid;
+    const workbuddyWorkspacePath = process.env.WORKBUDDY_WORKSPACE_PATH ??
+        fileWorkBuddy?.workspacePath;
     // 2. 计算启用平台
     const enabledPlatforms = [];
     const telegramEnabledFlag = fileTelegram?.enabled;
@@ -284,6 +298,7 @@ export function loadConfig() {
     const wechatEnabledFlag = fileWechat?.enabled;
     const weworkEnabledFlag = fileWework?.enabled;
     const dingtalkEnabledFlag = fileDingtalk?.enabled;
+    const workbuddyEnabledFlag = fileWorkBuddy?.enabled;
     const telegramEnabled = !!telegramBotToken && (telegramEnabledFlag !== false);
     const feishuEnabled = !!(feishuAppId && feishuAppSecret) && (feishuEnabledFlag !== false);
     const qqEnabled = !!(qqAppId && qqSecret) && (qqEnabledFlag !== false);
@@ -294,6 +309,8 @@ export function loadConfig() {
     // 企业微信只需要 corpId (botId) 和 secret
     const weworkEnabled = !!(weworkCorpId && weworkSecret) && (weworkEnabledFlag !== false);
     const dingtalkEnabled = !!(dingtalkClientId && dingtalkClientSecret) && (dingtalkEnabledFlag !== false);
+    // WorkBuddy 需要 OAuth 凭证
+    const workbuddyEnabled = !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId) && (workbuddyEnabledFlag !== false);
     if (telegramEnabled)
         enabledPlatforms.push('telegram');
     if (feishuEnabled)
@@ -306,6 +323,8 @@ export function loadConfig() {
         enabledPlatforms.push('wework');
     if (dingtalkEnabled)
         enabledPlatforms.push('dingtalk');
+    if (workbuddyEnabled)
+        enabledPlatforms.push('workbuddy');
     if (enabledPlatforms.length === 0) {
         throw new Error('至少需要配置 Telegram、Feishu、WeChat、WeWork 或 DingTalk 其中一个平台（可以通过环境变量或 config.json）');
     }
@@ -332,6 +351,9 @@ export function loadConfig() {
     const dingtalkAllowedUserIds = process.env.DINGTALK_ALLOWED_USER_IDS !== undefined
         ? parseCommaSeparated(process.env.DINGTALK_ALLOWED_USER_IDS)
         : fileDingtalk?.allowedUserIds ?? allowedUserIds;
+    const workbuddyAllowedUserIds = process.env.WORKBUDDY_ALLOWED_USER_IDS !== undefined
+        ? parseCommaSeparated(process.env.WORKBUDDY_ALLOWED_USER_IDS)
+        : fileWorkBuddy?.allowedUserIds ?? allowedUserIds;
     // 5. AI / 工作目录 / 安全配置（从 tools 读取）
     const aiCommand = normalizeAiCommand(process.env.AI_COMMAND ?? file.aiCommand, 'claude');
     const tc = file.tools?.claude ?? {};
@@ -579,6 +601,29 @@ export function loadConfig() {
                 allowedUserIds: dingtalkAllowedUserIds,
                 cardTemplateId: dingtalkCardTemplateId,
             },
+        workbuddy: workbuddyEnabled
+            ? {
+                enabled: true,
+                aiCommand: normalizeAiCommand(file.platforms?.workbuddy?.aiCommand, aiCommand),
+                allowedUserIds: workbuddyAllowedUserIds,
+                accessToken: workbuddyAccessToken,
+                refreshToken: workbuddyRefreshToken,
+                userId: workbuddyUserId,
+                baseUrl: workbuddyBaseUrl,
+                guid: workbuddyGuid,
+                workspacePath: workbuddyWorkspacePath,
+            }
+            : {
+                enabled: false,
+                aiCommand: normalizeAiCommand(file.platforms?.workbuddy?.aiCommand, aiCommand),
+                allowedUserIds: workbuddyAllowedUserIds,
+                accessToken: workbuddyAccessToken,
+                refreshToken: workbuddyRefreshToken,
+                userId: workbuddyUserId,
+                baseUrl: workbuddyBaseUrl,
+                guid: workbuddyGuid,
+                workspacePath: workbuddyWorkspacePath,
+            },
     };
     return {
         enabledPlatforms,
@@ -608,6 +653,7 @@ export function loadConfig() {
         wechatAllowedUserIds,
         weworkAllowedUserIds,
         dingtalkAllowedUserIds,
+        workbuddyAllowedUserIds,
         aiCommand,
         codexCliPath,
         codebuddyCliPath,

package/dist/constants.d.ts

@@ -11,6 +11,8 @@ export declare const CARDKIT_THROTTLE_MS = 80;
 export declare const TELEGRAM_THROTTLE_MS = 200;
 /** WeChat 流式更新节流：1000ms（AGP 协议建议值） */
 export declare const WECHAT_THROTTLE_MS = 1000;
+/** WorkBuddy 流式更新节流：1000ms（Centrifuge 协议建议值） */
+export declare const WORKBUDDY_THROTTLE_MS = 1000;
 export declare const WEWORK_THROTTLE_MS = 500;
 export declare const MAX_TELEGRAM_MESSAGE_LENGTH = 4000;
 export declare const MAX_FEISHU_MESSAGE_LENGTH = 4000;

package/dist/constants.js

@@ -32,6 +32,8 @@ export const CARDKIT_THROTTLE_MS = 80;
 export const TELEGRAM_THROTTLE_MS = 200;
 /** WeChat 流式更新节流：1000ms（AGP 协议建议值） */
 export const WECHAT_THROTTLE_MS = 1000;
+/** WorkBuddy 流式更新节流：1000ms（Centrifuge 协议建议值） */
+export const WORKBUDDY_THROTTLE_MS = 1000;
 export const WEWORK_THROTTLE_MS = 500;
 export const MAX_TELEGRAM_MESSAGE_LENGTH = 4000;
 export const MAX_FEISHU_MESSAGE_LENGTH = 4000;

package/dist/index.js

@@ -23,6 +23,8 @@ import { setupWeWorkHandlers } from "./wework/event-handler.js";
 import { sendProactiveTextReply as sendWeWorkTextReply } from "./wework/message-sender.js";
 import { initDingTalk, stopDingTalk, formatDingTalkInitError } from "./dingtalk/client.js";
 import { setupDingTalkHandlers } from "./dingtalk/event-handler.js";
+import { initWorkBuddy, stopWorkBuddy } from "./workbuddy/client.js";
+import { setupWorkBuddyHandlers } from "./workbuddy/event-handler.js";
 import { initAdapters, cleanupAdapters } from "./adapters/registry.js";
 import { SessionManager } from "./session/session-manager.js";
 import { loadActiveChats, getActiveChatId, flushActiveChats, } from "./shared/active-chats.js";
@@ -34,8 +36,8 @@ const require = createRequire(import.meta.url);
 const { version: APP_VERSION } = require("../package.json");
 const log = createLogger("Main");
 async function sendLifecycleNotification(platform, message) {
-    // DingTalk 不支持主动发消息（OpenAPI 需 robotCode 等，易报 robot 不存在），跳过启动/关闭通知
-    if (platform === "dingtalk")
+    // DingTalk 和 WorkBuddy 不支持主动发消息（OpenAPI 需 robotCode 等，易报 robot 不存在），跳过启动/关闭通知
+    if (platform === "dingtalk" || platform === "workbuddy")
         return;
     const telegramChatId = getActiveChatId("telegram");
     const feishuChatId = getActiveChatId("feishu");
@@ -174,6 +176,7 @@ export async function main() {
     let wechatHandle = null;
     let weworkHandle = null;
     let dingtalkHandle = null;
+    let workbuddyHandle = null;
     // Track successfully initialized platforms
     const successfulPlatforms = [];
     if (config.enabledPlatforms.includes("telegram")) {
@@ -237,6 +240,16 @@ export async function main() {
             log.error("Failed to initialize DingTalk:", formatDingTalkInitError(err));
         }
     }
+    if (config.enabledPlatforms.includes("workbuddy")) {
+        try {
+            workbuddyHandle = setupWorkBuddyHandlers(config, sessionManager);
+            await initWorkBuddy(config, workbuddyHandle.handleEvent);
+            successfulPlatforms.push("workbuddy");
+        }
+        catch (err) {
+            log.error("Failed to initialize WorkBuddy:", err);
+        }
+    }
     // Require at least one platform to start successfully
     if (successfulPlatforms.length === 0) {
         throw new Error("No platforms initialized successfully. Service cannot start.");
@@ -283,6 +296,8 @@ export async function main() {
         stopWeWork();
         dingtalkHandle?.stop();
         stopDingTalk();
+        workbuddyHandle?.stop();
+        stopWorkBuddy();
         sessionManager.destroy();
         cleanupAdapters();
         flushActiveChats();

package/dist/setup.js

@@ -940,8 +940,9 @@ const PLATFORM_LABELS = {
     wework: "企业微信",
     dingtalk: "钉钉",
     wechat: "微信（测试中）",
+    workbuddy: "WorkBuddy",
 };
-const ALL_PLATFORMS = ["telegram", "feishu", "qq", "wework", "dingtalk", "wechat"];
+const ALL_PLATFORMS = ["telegram", "feishu", "qq", "wework", "dingtalk", "wechat", "workbuddy"];
 /**
  * 启动时让用户选择要启用的平台（无论单通道还是多通道）
  * 显示全部 4 个平台，已配置的预选；若用户选择未配置的，引导运行 init

package/dist/shared/active-chats.d.ts

@@ -6,8 +6,8 @@ export interface DingTalkActiveTarget {
     updatedAt: number;
 }
 export declare function loadActiveChats(): void;
-export declare function getActiveChatId(platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework'): string | undefined;
-export declare function setActiveChatId(platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework', chatId: string): void;
+export declare function getActiveChatId(platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework' | 'workbuddy'): string | undefined;
+export declare function setActiveChatId(platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework' | 'workbuddy', chatId: string): void;
 export declare function getDingTalkActiveTarget(): DingTalkActiveTarget | undefined;
 export declare function setDingTalkActiveTarget(target: Omit<DingTalkActiveTarget, 'updatedAt'>): void;
 export declare function flushActiveChats(): void;

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

@@ -0,0 +1,74 @@
+/**
+ * WorkBuddy Centrifuge Client - WebSocket connection for WeChat KF messages
+ */
+import type { WorkBuddyState, PromptResponsePayload } from './types.js';
+/** Centrifuge client configuration */
+export interface CentrifugeClientConfig {
+    url: string;
+    connectionToken: string;
+    subscriptionToken: string;
+    channel: string;
+    guid: string;
+    userId: string;
+    httpBaseUrl?: string;
+    httpAccessToken?: string;
+    workspaceSessionId?: string;
+}
+/** Client callbacks */
+export interface CentrifugeCallbacks {
+    onConnected?: () => void;
+    onDisconnected?: (reason?: string) => void;
+    onError?: (error: Error) => void;
+    onMessage?: (chatId: string, msgId: string, content: string) => void;
+}
+export declare class WorkBuddyCentrifugeClient {
+    private config;
+    private callbacks;
+    private client;
+    private sub;
+    private extraSubs;
+    private state;
+    private processedMsgIds;
+    private static readonly MAX_MSG_ID_CACHE;
+    constructor(config: CentrifugeClientConfig, callbacks?: CentrifugeCallbacks);
+    get logPrefix(): string;
+    getState(): WorkBuddyState;
+    start(): void;
+    stop(): void;
+    setCallbacks(callbacks: Partial<CentrifugeCallbacks>): void;
+    /**
+     * Subscribe to additional channel
+     */
+    subscribeChannel(channel: string, subscriptionToken: string): void;
+    /**
+     * Send message chunk through Centrifuge
+     */
+    sendMessageChunk(sessionId: string, promptId: string, content: {
+        type: string;
+        text?: string;
+    }, guid?: string, userId?: string): void;
+    /**
+     * Send tool call through Centrifuge
+     */
+    sendToolCall(sessionId: string, promptId: string, toolCall: {
+        id: string;
+        name: string;
+        input?: Record<string, unknown>;
+    }, guid?: string, userId?: string): void;
+    /**
+     * Send prompt response (for WeChat KF, use HTTP instead)
+     */
+    sendPromptResponse(payload: PromptResponsePayload, _guid?: string, _userId?: string): void;
+    /**
+     * Handle incoming publication from Centrifuge
+     */
+    private handlePublication;
+    /**
+     * Send AGP envelope through Centrifuge
+     */
+    private sendEnvelope;
+    /**
+     * Clean up old message IDs from cache
+     */
+    private cleanMsgIdCache;
+}

package/dist/workbuddy/centrifuge-client.js

@@ -0,0 +1,272 @@
+/**
+ * WorkBuddy Centrifuge Client - WebSocket connection for WeChat KF messages
+ */
+import { Centrifuge } from 'centrifuge';
+import { WebSocket } from 'ws';
+import { randomUUID } from 'node:crypto';
+import { createLogger } from '../logger.js';
+const log = createLogger('WorkBuddyCentrifuge');
+export class WorkBuddyCentrifugeClient {
+    config;
+    callbacks;
+    client = null;
+    sub = null;
+    extraSubs = [];
+    state = 'disconnected';
+    processedMsgIds = new Set();
+    static MAX_MSG_ID_CACHE = 1000;
+    constructor(config, callbacks = {}) {
+        this.config = config;
+        this.callbacks = callbacks;
+    }
+    get logPrefix() {
+        return `[workbuddy:${this.config.userId}]`;
+    }
+    getState() {
+        return this.state;
+    }
+    start() {
+        if (this.state === 'connected' || this.state === 'connecting') {
+            log.info(`${this.logPrefix} Already connected or connecting`);
+            return;
+        }
+        this.state = 'connecting';
+        log.info(`${this.logPrefix} Connecting to: ${this.config.url}, channel=${this.config.channel}`);
+        this.client = new Centrifuge(this.config.url, {
+            token: this.config.connectionToken,
+            websocket: WebSocket,
+        });
+        this.client.on('connected', (ctx) => {
+            log.info(`${this.logPrefix} Connected (transport=${ctx.transport})`);
+            this.state = 'connected';
+            this.callbacks.onConnected?.();
+        });
+        this.client.on('disconnected', (ctx) => {
+            log.info(`${this.logPrefix} Disconnected: code=${ctx.code}, reason=${ctx.reason}`);
+            if (this.state !== 'disconnected') {
+                this.state = 'disconnected';
+                this.callbacks.onDisconnected?.(ctx.reason || `code=${ctx.code}`);
+            }
+        });
+        this.client.on('connecting', (ctx) => {
+            log.info(`${this.logPrefix} Reconnecting: code=${ctx.code}, reason=${ctx.reason}`);
+            if (this.state === 'connected') {
+                this.state = 'reconnecting';
+            }
+        });
+        this.client.on('error', (ctx) => {
+            log.error(`${this.logPrefix} Error: ${ctx.error.message}`);
+            this.callbacks.onError?.(new Error(ctx.error.message));
+        });
+        // Create channel subscription
+        this.sub = this.client.newSubscription(this.config.channel, {
+            token: this.config.subscriptionToken,
+        });
+        this.sub.on('publication', (ctx) => {
+            this.handlePublication(ctx.data);
+        });
+        this.sub.on('error', (ctx) => {
+            log.error(`${this.logPrefix} Subscription error: ${ctx.error.message}`);
+        });
+        this.sub.subscribe();
+        this.client.connect();
+    }
+    stop() {
+        log.info(`${this.logPrefix} Stopping...`);
+        this.state = 'disconnected';
+        this.processedMsgIds.clear();
+        for (const sub of this.extraSubs) {
+            sub.unsubscribe();
+        }
+        this.extraSubs = [];
+        if (this.sub) {
+            this.sub.unsubscribe();
+            this.sub = null;
+        }
+        if (this.client) {
+            this.client.disconnect();
+            this.client = null;
+        }
+        log.info(`${this.logPrefix} Stopped`);
+    }
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+    /**
+     * Subscribe to additional channel
+     */
+    subscribeChannel(channel, subscriptionToken) {
+        if (!this.client) {
+            log.warn(`${this.logPrefix} Cannot subscribe: client not initialized`);
+            return;
+        }
+        log.info(`${this.logPrefix} Subscribing to additional channel: ${channel}`);
+        const sub = this.client.newSubscription(channel, { token: subscriptionToken });
+        sub.on('publication', (ctx) => {
+            this.handlePublication(ctx.data);
+        });
+        sub.on('error', (ctx) => {
+            log.error(`${this.logPrefix} Extra subscription error (${channel}): ${ctx.error.message}`);
+        });
+        sub.on('subscribed', () => {
+            log.info(`${this.logPrefix} Extra channel subscribed: ${channel}`);
+        });
+        this.extraSubs.push(sub);
+        sub.subscribe();
+    }
+    /**
+     * Send message chunk through Centrifuge
+     */
+    sendMessageChunk(sessionId, promptId, content, guid, userId) {
+        const payload = {
+            session_id: sessionId,
+            prompt_id: promptId,
+            update_type: 'message_chunk',
+            content: [content],
+        };
+        this.sendEnvelope('session.update', payload, guid, userId);
+    }
+    /**
+     * Send tool call through Centrifuge
+     */
+    sendToolCall(sessionId, promptId, toolCall, guid, userId) {
+        const payload = {
+            session_id: sessionId,
+            prompt_id: promptId,
+            update_type: 'tool_call',
+            tool_call: toolCall,
+        };
+        this.sendEnvelope('session.update', payload, guid, userId);
+    }
+    /**
+     * Send prompt response (for WeChat KF, use HTTP instead)
+     */
+    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 httpPayload = {
+                type: 'COPILOT_RESPONSE',
+                msgId: payload.prompt_id,
+                chatId: payload.session_id,
+                success: payload.stop_reason === 'end_turn',
+                message,
+                metadata: {
+                    sessionId: this.config.workspaceSessionId || payload.session_id,
+                    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`;
+            fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.httpAccessToken}`,
+                },
+                body: JSON.stringify(httpPayload),
+                signal: AbortSignal.timeout(30_000),
+            })
+                .then(async (res) => {
+                if (!res.ok) {
+                    const body = await res.text().catch(() => '');
+                    log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE failed: ${res.status} ${body.substring(0, 200)}`);
+                }
+            })
+                .catch((err) => {
+                log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE error:`, err);
+            });
+            return;
+        }
+        this.sendEnvelope('session.promptResponse', payload, _guid, _userId);
+    }
+    /**
+     * Handle incoming publication from Centrifuge
+     */
+    handlePublication(data) {
+        try {
+            const raw = data;
+            // AGP format message (from QClaw gateway)
+            if (raw?.method && raw?.msg_id) {
+                const envelope = raw;
+                if (this.processedMsgIds.has(envelope.msg_id)) {
+                    log.debug(`${this.logPrefix} Duplicate message, skipping: ${envelope.msg_id}`);
+                    return;
+                }
+                this.processedMsgIds.add(envelope.msg_id);
+                this.cleanMsgIdCache();
+                log.debug(`${this.logPrefix} Received AGP message: method=${envelope.method}, msg_id=${envelope.msg_id}`);
+                if (envelope.method === 'session.prompt') {
+                    const payload = envelope.payload;
+                    const content = payload.content?.find((c) => c.type === 'text')?.text || '';
+                    this.callbacks.onMessage?.(payload.session_id, envelope.msg_id, content);
+                }
+                return;
+            }
+            // WeChat KF format message (from WorkBuddy Centrifuge)
+            if (raw?.chatId && raw?.msgId) {
+                const msgId = String(raw.msgId);
+                if (this.processedMsgIds.has(msgId)) {
+                    log.debug(`${this.logPrefix} Duplicate message, skipping: ${msgId}`);
+                    return;
+                }
+                this.processedMsgIds.add(msgId);
+                this.cleanMsgIdCache();
+                const content = String(raw.content ?? '');
+                const chatId = String(raw.chatId);
+                log.info(`${this.logPrefix} Received WeChat KF message: msgId=${msgId}, chatId=${chatId}, content=${content.substring(0, 50)}`);
+                this.callbacks.onMessage?.(chatId, msgId, content);
+                return;
+            }
+            const preview = JSON.stringify(data).substring(0, 500);
+            log.warn(`${this.logPrefix} Unknown message format: ${preview}`);
+        }
+        catch (error) {
+            log.error(`${this.logPrefix} Message handling failed:`, error);
+            this.callbacks.onError?.(error instanceof Error ? error : new Error(`Message handling failed: ${String(error)}`));
+        }
+    }
+    /**
+     * Send AGP envelope through Centrifuge
+     */
+    sendEnvelope(method, payload, guid, userId) {
+        if (!this.client || this.state !== 'connected') {
+            log.warn(`${this.logPrefix} Cannot send message, state: ${this.state}`);
+            return;
+        }
+        const envelope = {
+            msg_id: randomUUID(),
+            guid: guid ?? this.config.guid,
+            user_id: userId ?? this.config.userId,
+            method: method,
+            payload,
+        };
+        try {
+            this.client.publish(this.config.channel, envelope).catch((err) => {
+                log.error(`${this.logPrefix} Message send failed:`, err);
+                this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+            });
+            const json = JSON.stringify(envelope);
+            const preview = json.length > 500 ? json.substring(0, 500) + `...(truncated)` : json;
+            log.debug(`${this.logPrefix} Sent message: method=${method}, msg_id=${envelope.msg_id}`);
+        }
+        catch (error) {
+            log.error(`${this.logPrefix} Message send failed:`, error);
+            this.callbacks.onError?.(error instanceof Error ? error : new Error(`Message send failed: ${String(error)}`));
+        }
+    }
+    /**
+     * Clean up old message IDs from cache
+     */
+    cleanMsgIdCache() {
+        if (this.processedMsgIds.size > WorkBuddyCentrifugeClient.MAX_MSG_ID_CACHE) {
+            const entries = [...this.processedMsgIds];
+            this.processedMsgIds.clear();
+            entries
+                .slice(-WorkBuddyCentrifugeClient.MAX_MSG_ID_CACHE / 2)
+                .forEach((id) => {
+                this.processedMsgIds.add(id);
+            });
+        }
+    }
+}