openclaw-vchat-plugin 0.0.1

package/src/message-handler.ts

@@ -0,0 +1,419 @@
+import { SessionManager } from './session-manager';
+import { handleBuiltinCommand, handleBuiltinCommandAsync, parseCommandInput, ParsedSlashCommand } from './commands';
+import { MessageType, PluginConfig, Message, CommandExecutionContext } from './types';
+import { GatewayClient } from './gateway-client';
+import { buildWeChatGatewaySessionKey } from './session-key';
+
+type CommandRouteHint = 'local' | 'gateway-rpc' | 'gateway-passthrough' | 'model';
+
+interface RoutingHint {
+    commandRoute?: CommandRouteHint;
+    routeSource?: string;
+    requestId?: string;
+}
+
+/**
+ * 流式回调
+ */
+export interface StreamCallbacks {
+    onThinking?: (text: string) => void;
+    onChunk?: (text: string) => void;
+    onDone?: (userMessage: Message, assistantMessage: Message) => void;
+    onError?: (error: string) => void;
+}
+
+/**
+ * 消息处理器
+ * 通过 GatewayClient 实现流式输出，支持多 Agent 路由
+ */
+export class MessageHandler {
+    private config: PluginConfig;
+    private sessionManager: SessionManager;
+    private gateway: GatewayClient;
+
+    constructor(config: PluginConfig, sessionManager: SessionManager, gateway: GatewayClient) {
+        this.config = config;
+        this.sessionManager = sessionManager;
+        this.gateway = gateway;
+    }
+
+    /**
+     * 同步处理消息（HTTP fallback）
+     */
+    async handleMessage(
+        userId: string, sessionId: string, content: string,
+        type: MessageType = 'text', mediaUrl?: string, duration?: number,
+        agentId: string = 'main', groupId?: string,
+        routingHint?: RoutingHint
+    ): Promise<{ userMessage: Message; assistantMessage: Message }> {
+        const { userMessage, sid, builtinResponse, parsedCommand } = this.prepareMessage(
+            userId, sessionId, content, type, mediaUrl, duration, agentId, groupId, routingHint
+        );
+        const commandContext = this.buildCommandContext(userId, sid, agentId, groupId);
+        const routeSource = routingHint?.commandRoute ? (routingHint.routeSource || 'backend') : 'plugin-fallback';
+
+        if (builtinResponse) {
+            const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', builtinResponse);
+            return { userMessage, assistantMessage };
+        }
+
+        // Gateway RPC 命令（秒回路径）
+        if (parsedCommand && parsedCommand.route === 'gateway-rpc') {
+            console.log(`[MessageHandler] 命令路由 cmd=${parsedCommand.command} route=gateway-rpc source=${routeSource} agent=${commandContext.agentId || agentId} session=${commandContext.gatewaySessionKey} requestId=${routingHint?.requestId || '-'}`);
+            const asyncResult = await handleBuiltinCommandAsync(parsedCommand.command, parsedCommand.args, commandContext);
+            if (asyncResult) {
+                const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', asyncResult);
+                return { userMessage, assistantMessage };
+            }
+        }
+
+        try {
+            // 图片消息使用 streamAgent 传递附件
+            if (type === 'image' && mediaUrl) {
+                const aiResponse = await this.callWithAttachments(
+                    content || '请查看这张图片',
+                    mediaUrl,
+                    commandContext.gatewaySessionKey,
+                    commandContext.agentId || agentId || 'main',
+                    groupId,
+                );
+                const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', aiResponse);
+                return { userMessage, assistantMessage };
+            }
+            if (parsedCommand && parsedCommand.route === 'gateway-passthrough') {
+                console.log(`[MessageHandler] 命令路由 cmd=${parsedCommand.command} route=gateway-passthrough source=${routeSource} agent=${commandContext.agentId || agentId} session=${commandContext.gatewaySessionKey} requestId=${routingHint?.requestId || '-'}`);
+                const commandResponse = await this.callGatewayText(
+                    content,
+                    commandContext.gatewaySessionKey,
+                );
+                const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', commandResponse);
+                return { userMessage, assistantMessage };
+            }
+            const aiResponse = await this.callGatewayAgentSync(
+                content,
+                type,
+                commandContext.gatewaySessionKey,
+                commandContext.agentId || agentId || 'main',
+                groupId,
+            );
+            const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', aiResponse);
+            return { userMessage, assistantMessage };
+        } catch (err: any) {
+            console.error('[MessageHandler] OpenClaw 调用失败:', err);
+            const normalized = this.normalizeImageErrorMessage(type, err?.message || '未知错误');
+            const errorMsg = normalized === (err?.message || '未知错误')
+                ? `⚠️ AI 回复失败: ${normalized}`
+                : normalized;
+            const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'system', errorMsg);
+            return { userMessage, assistantMessage };
+        }
+    }
+
+    /**
+     * 流式处理消息（WebSocket 模式）
+     * @param agentId — 目标 Agent，默认 'main'
+     * @param groupId — 虚拟群 ID（可选，用于多代理群聊）
+     */
+    handleMessageStream(
+        userId: string, sessionId: string, content: string,
+        type: MessageType = 'text', callbacks: StreamCallbacks,
+        agentId: string = 'main',
+        mediaUrl?: string, duration?: number,
+        groupId?: string,
+        routingHint?: RoutingHint
+    ): () => void {
+        const { userMessage, sid, builtinResponse, parsedCommand } = this.prepareMessage(
+            userId, sessionId, content, type, mediaUrl, duration, agentId, groupId, routingHint
+        );
+        const commandContext = this.buildCommandContext(userId, sid, agentId, groupId);
+        const routeSource = routingHint?.commandRoute ? (routingHint.routeSource || 'backend') : 'plugin-fallback';
+
+        // 内置命令立即返回
+        if (builtinResponse) {
+            const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', builtinResponse);
+            callbacks.onChunk?.(builtinResponse);
+            callbacks.onDone?.(userMessage, assistantMessage);
+            return () => { };
+        }
+
+        // Gateway 透传命令（例如 /restart /context /approve）
+        if (parsedCommand && parsedCommand.route === 'gateway-passthrough') {
+            console.log(`[MessageHandler] 命令路由 cmd=${parsedCommand.command} route=gateway-passthrough source=${routeSource} agent=${agentId} session=${commandContext.gatewaySessionKey} requestId=${routingHint?.requestId || '-'}`);
+            const abort = this.gateway.streamChatSend(
+                content,
+                {
+                    onThinking: (text) => callbacks.onThinking?.(text),
+                    onChunk: (delta) => callbacks.onChunk?.(delta),
+                    onDone: (fullText) => {
+                        const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', fullText);
+                        callbacks.onDone?.(userMessage, assistantMessage);
+                    },
+                    onError: (error) => callbacks.onError?.(error),
+                },
+                { sessionKey: commandContext.gatewaySessionKey || 'main' }
+            );
+            return abort;
+        }
+
+        if (parsedCommand) {
+            console.log(`[MessageHandler] 命令路由 cmd=${parsedCommand.command} route=${parsedCommand.route} source=${routeSource} agent=${agentId} session=${commandContext.gatewaySessionKey} requestId=${routingHint?.requestId || '-'}`);
+        }
+
+        // Gateway RPC 命令（秒回路径）
+        if (parsedCommand && parsedCommand.route === 'gateway-rpc') {
+            handleBuiltinCommandAsync(parsedCommand.command, parsedCommand.args, commandContext).then(result => {
+                if (result) {
+                    const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', result);
+                    callbacks.onChunk?.(result);
+                    callbacks.onDone?.(userMessage, assistantMessage);
+                    return;
+                }
+                callbacks.onError?.(`命令执行失败: ${parsedCommand.command} 未返回结果`);
+            }).catch(err => {
+                console.error('[MessageHandler] 异步命令错误:', err);
+                callbacks.onError?.(`命令执行失败: ${err.message}`);
+            });
+            return () => { };
+        }
+
+        // 准备输入文本和附件
+        let inputText = content;
+        const streamOpts: any = {
+            sessionKey: commandContext.gatewaySessionKey,
+        };
+        if (groupId) {
+            streamOpts.groupId = groupId;
+            streamOpts.groupChannel = 'wechat';
+        }
+
+        if (type === 'voice') {
+            inputText = `[语音消息] ${content}`;
+        } else if (type === 'image' && mediaUrl) {
+            // 将图片作为附件传给 Gateway（和电报一样）
+            inputText = content || '请查看这张图片';
+            try {
+                const fs = require('fs');
+                const path = require('path');
+                // mediaUrl 格式: /uploads/image/xxx.png
+                const uploadDir = this.config.uploadDir;
+                const relativePath = mediaUrl.replace(/^\/uploads\//, '');
+                const filePath = path.join(uploadDir, relativePath);
+                if (fs.existsSync(filePath)) {
+                    const imageBuffer = fs.readFileSync(filePath);
+                    const base64Data = imageBuffer.toString('base64');
+                    const ext = path.extname(filePath).replace('.', '') || 'png';
+                    const mimeType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`;
+                    streamOpts.attachments = [{
+                        type: 'image',
+                        mimeType,
+                        content: base64Data,
+                        fileName: path.basename(filePath),
+                    }];
+                    console.log(`[MessageHandler] 图片附件已准备: ${filePath} (${(base64Data.length / 1024).toFixed(1)}KB base64)`);
+                } else {
+                    console.error(`[MessageHandler] 图片文件不存在: ${filePath}`);
+                    inputText = `[用户发送了一张图片，但文件未找到] ${content}`;
+                }
+            } catch (imgErr: any) {
+                console.error('[MessageHandler] 读取图片失败:', imgErr);
+                inputText = `[用户发送了一张图片] ${content}`;
+            }
+        }
+
+        console.log(`[MessageHandler] 流式调用 (agent=${agentId}): ${inputText.substring(0, 80)}...`);
+
+        // 使用 GatewayClient.streamAgent() — 替代原来的内联 WS 代码
+        const abort = this.gateway.streamAgent(
+            inputText,
+            agentId,
+            {
+                onThinking: (text) => {
+                    callbacks.onThinking?.(text);
+                },
+                onChunk: (delta) => {
+                    callbacks.onChunk?.(delta);
+                },
+                onDone: (fullText) => {
+                    const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'text', fullText);
+                    console.log(`[MessageHandler] 完成 (agent=${agentId}):`, fullText.substring(0, 100));
+                    callbacks.onDone?.(userMessage, assistantMessage);
+                },
+                onError: (error) => {
+                    const normalized = this.normalizeImageErrorMessage(type, error);
+                    if (normalized !== error) {
+                        const assistantMessage = this.sessionManager.addMessage(sid, 'assistant', 'system', normalized);
+                        callbacks.onChunk?.(normalized);
+                        callbacks.onDone?.(userMessage, assistantMessage);
+                        return;
+                    }
+                    callbacks.onError?.(error);
+                },
+            },
+            Object.keys(streamOpts).length > 0 ? streamOpts : undefined
+        );
+
+        return abort;
+    }
+
+    // --- 公共逻辑 ---
+
+    /**
+     * 通过 streamAgent 发送带附件的消息（Promise 包装）
+     */
+    private callWithAttachments(
+        content: string,
+        mediaUrl: string,
+        sessionKey?: string,
+        agentId: string = 'main',
+        groupId?: string,
+    ): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const fs = require('fs');
+            const path = require('path');
+            const uploadDir = this.config.uploadDir;
+            const relativePath = mediaUrl.replace(/^\/uploads\//, '');
+            const filePath = path.join(uploadDir, relativePath);
+
+            const attachments: any[] = [];
+            try {
+                if (fs.existsSync(filePath)) {
+                    const imageBuffer = fs.readFileSync(filePath);
+                    const base64Data = imageBuffer.toString('base64');
+                    const ext = path.extname(filePath).replace('.', '') || 'png';
+                    const mimeType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`;
+                    attachments.push({
+                        type: 'image',
+                        mimeType,
+                        content: base64Data,
+                        fileName: path.basename(filePath),
+                    });
+                    console.log(`[MessageHandler] 图片附件: ${filePath} (${(base64Data.length / 1024).toFixed(1)}KB)`);
+                }
+            } catch (e: any) {
+                console.error('[MessageHandler] 读取图片失败:', e);
+            }
+
+            this.gateway.streamAgent(
+                content, agentId,
+                {
+                    onDone: (fullText) => resolve(fullText),
+                    onError: (error) => reject(new Error(error)),
+                },
+                {
+                    sessionKey,
+                    groupId,
+                    groupChannel: groupId ? 'wechat' : undefined,
+                    attachments: attachments.length > 0 ? attachments : undefined,
+                }
+            );
+        });
+    }
+
+    private callGatewayAgentSync(
+        content: string,
+        type: MessageType,
+        sessionKey?: string,
+        agentId: string = 'main',
+        groupId?: string,
+    ): Promise<string> {
+        let inputText = content;
+        if (type === 'voice') inputText = `[语音消息] ${content}`;
+        else if (type === 'image') inputText = `[用户发送了一张图片] ${content}`;
+
+        return new Promise((resolve, reject) => {
+            this.gateway.streamAgent(
+                inputText,
+                agentId,
+                {
+                    onDone: (fullText) => resolve(fullText),
+                    onError: (error) => reject(new Error(error)),
+                },
+                {
+                    sessionKey,
+                    groupId,
+                    groupChannel: groupId ? 'wechat' : undefined,
+                }
+            );
+        });
+    }
+
+    private callGatewayText(
+        content: string,
+        sessionKey?: string,
+    ): Promise<string> {
+        return new Promise((resolve, reject) => {
+            this.gateway.streamChatSend(
+                content,
+                {
+                    onDone: (fullText) => resolve(fullText),
+                    onError: (error) => reject(new Error(error)),
+                },
+                { sessionKey: sessionKey || 'main' }
+            );
+        });
+    }
+
+    private prepareMessage(
+        userId: string, sessionId: string, content: string,
+        type: MessageType, mediaUrl?: string, duration?: number,
+        agentId: string = 'main',
+        groupId?: string,
+        routingHint?: RoutingHint
+    ): { userMessage: Message; sid: string; builtinResponse: string | null; parsedCommand: ParsedSlashCommand | null } {
+        const incomingSessionId = String(sessionId || '').trim();
+        const session = incomingSessionId
+            ? this.sessionManager.ensureSessionBinding(
+                userId,
+                incomingSessionId,
+                agentId,
+                buildWeChatGatewaySessionKey(userId, incomingSessionId, agentId, groupId),
+            )
+            : this.sessionManager.createSession(userId, undefined, agentId);
+        if (!incomingSessionId) {
+            this.sessionManager.ensureSessionBinding(
+                userId,
+                session.id,
+                agentId,
+                buildWeChatGatewaySessionKey(userId, session.id, agentId, groupId),
+            );
+        }
+        sessionId = session.id;
+
+        const userMessage = this.sessionManager.addMessage(sessionId, 'user', type, content, mediaUrl, duration);
+        let builtinResponse: string | null = null;
+        let parsedCommand = type === 'text' ? parseCommandInput(content) : null;
+        if (parsedCommand && routingHint?.commandRoute) {
+            parsedCommand = {
+                ...parsedCommand,
+                route: routingHint.commandRoute,
+            };
+        }
+        if (parsedCommand && parsedCommand.route === 'local') {
+            builtinResponse = handleBuiltinCommand(parsedCommand.command, parsedCommand.args);
+        }
+        return { userMessage, sid: sessionId, builtinResponse, parsedCommand };
+    }
+
+    private buildCommandContext(
+        userId: string,
+        sessionId: string,
+        agentId: string,
+        groupId?: string
+    ): CommandExecutionContext {
+        return {
+            agentId,
+            gatewaySessionKey: buildWeChatGatewaySessionKey(userId, sessionId, agentId, groupId),
+        };
+    }
+
+    private normalizeImageErrorMessage(type: MessageType, error: string): string {
+        if (type !== 'image') return error;
+        const source = (error || '').toLowerCase();
+        const imageUnsupported =
+            /image|vision|multimodal|unsupported|does not support|invalid_image|图片|图像|视觉/.test(source)
+            && /support|不支持|unsupported|invalid/.test(source);
+        if (!imageUnsupported) return error;
+        return '⚠️ 当前模型不支持图片输入，请切换支持视觉的模型后重试。';
+    }
+
+}