@workclaw/openclaw-workclaw 1.0.18 → 1.0.20

package/src/gateway/message-dispatcher.ts

@@ -1,641 +0,0 @@
-/**
- * Message Dispatcher - handles all WorkClaw WebSocket message types
- */
-
-import type { ResolvedWorkclawAccount, WorkClawBaseConfig, WorkClawAccountConfig } from "../types.js";
-import { parseWorkClawMessage, type ParseWorkClawResult } from "./message-context.js";
-import { buildInboundContext, type InboundMessage } from "./message-context.js";
-import { handleAgentCreated, handleAgentUpdated, handleAgentDeleted } from "./agent-handlers.js";
-import { saveOpenConversationId, saveWorkClawAgentId, saveWorkClawApiKey, saveWorkClawUserId } from "./config-writer.js";
-import { getWorkclawWsConnection, setLastInboundAt } from "../runtime.js";
-import { getWorkclawRuntime } from "../runtime.js";
-import { sendMessageWorkclaw } from "../outbound/index.js";
-import { resolveAccountByUserIdAndAgentId, resolveWorkclawAccountWithCache } from "../accounts.js";
-import { getWorkclawAccessToken, getWorkclawModelConfigByAppKey } from "../connection/workclaw-client.js";
-import { setToolContext } from "../runtime.js";
-import { handleSkillsEvent } from "./skills-handler.js";
-import { handleToolsListEvent as doHandleToolsListEvent } from "./tools-list-handler.js";
-import { handleSkillsListEvent as doHandleSkillsListEvent } from "./skills-list-handler.js";
-import { request } from "undici";
-
-export interface MessageDispatcherContext {
-    accountId: string;
-    account: ResolvedWorkclawAccount;
-    cfg: any;
-    baseConfig: WorkClawBaseConfig;
-    accountConfig: WorkClawAccountConfig;
-    log?: {
-        info?: (msg: string) => void;
-        warn?: (msg: string) => void;
-        error?: (msg: string) => void;
-        debug?: (msg: string) => void;
-    };
-    scheduleReconnect: () => void;
-}
-
-/** Log an error safely */
-function logError(log: MessageDispatcherContext["log"], context: string, err: unknown): void {
-    const errAny = err as { stack?: string };
-    const stack = typeof errAny?.stack === "string" ? `\nStack: ${errAny.stack}` : "";
-    log?.error?.(`Dispatcher ${context}: ${String(err)}${stack}`);
-}
-
-// ---------------------------------------------------------------------------
-// Individual message handlers
-// ---------------------------------------------------------------------------
-
-async function handlePing(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-    const { accountId, log } = ctx;
-    const ws = getWorkclawWsConnection(accountId);
-    if (!ws) return;
-
-    try {
-        const pongResponse = {
-            code: 200,
-            message: "pong",
-            metadata: { contentType: "application/json" },
-            data: JSON.stringify(result.pongData),
-        };
-        ws.send(JSON.stringify(pongResponse));
-        log?.debug?.(`pong`);
-    } catch (err) {
-        logError(log, "Failed to send pong", err);
-    }
-}
-
-async function handleDisconnect(ctx: MessageDispatcherContext): Promise<void> {
-    const { accountId, log, scheduleReconnect } = ctx;
-    const ws = getWorkclawWsConnection(accountId);
-    if (ws) {
-        try {
-            ws.close();
-            log?.info?.(`Closed WebSocket due to disconnect command`);
-        } catch (err) {
-            logError(log, "Failed to close WebSocket", err);
-        }
-    } else {
-        log?.info?.(`WebSocket already cleared, triggering reconnect...`);
-        scheduleReconnect();
-    }
-}
-
-async function handleAgentEvent(
-    ctx: MessageDispatcherContext,
-    result: ParseWorkClawResult,
-): Promise<void> {
-    const { cfg, log, baseConfig, accountId } = ctx;
-    const eventData = result.eventData;
-    if (!eventData) {
-        log?.warn?.(`Received ${result.type} event but no data`);
-        return;
-    }
-
-    const agentId = String(eventData.id || "");
-    const userId = String(eventData.futureId || "");
-
-    if (!agentId) {
-        log?.warn?.(`Received ${result.type} event but missing agent id`);
-        return;
-    }
-
-    log?.info?.(`Processing ${result.type} event for agent ${agentId}, userId: ${userId}`);
-
-    const accountData = {
-        agentId,
-        userId,
-        nickName: eventData.nickName,
-        phone: eventData.phone,
-        status: eventData.status,
-        introduction: eventData.introduction,
-        name: eventData.name,
-        tip: eventData.tip,
-        characterSettings: eventData.characterSettings,
-        personFeatures: eventData.personFeatures,
-        workFeatures: eventData.workFeatures,
-        learningFeatures: eventData.learningFeatures,
-        socializeFeatures: eventData.socializeFeatures,
-        job: eventData.job,
-        city: eventData.city,
-    };
-
-    switch (result.type) {
-        case "agent_created":
-            await handleAgentCreated(accountData, cfg, log);
-            handleAgentCreatedMessage(baseConfig, agentId, accountId, log)
-            break;
-        case "agent_updated":
-            await handleAgentUpdated(accountData, cfg, log);
-            break;
-        case "agent_deleted":
-            await handleAgentDeleted(accountData, cfg, log);
-            break;
-    }
-}
-
-async function handleSkillsProcessingEvent(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-    const { accountId, baseConfig, log } = ctx;
-    if (!result.eventData) return;
-    try {
-        const connConfig = {
-            baseUrl: baseConfig.baseUrl || "",
-            websocketUrl: baseConfig.websocketUrl,
-            appKey: baseConfig.appKey,
-            appSecret: baseConfig.appSecret,
-            localIp: baseConfig.localIp,
-            allowInsecureTls: baseConfig.allowInsecureTls,
-            requestTimeout: baseConfig.requestTimeout,
-        };
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
-        await handleSkillsEvent(result.eventData, token, connConfig.baseUrl, connConfig.appKey || accountId, log);
-    } catch (err) {
-        logError(log, "handleSkillsEvent failed", err);
-    }
-}
-
-async function handleToolsListEvent(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-    const { accountId, baseConfig, log } = ctx;
-    if (!result.eventData) return;
-    try {
-        const connConfig = {
-            baseUrl: baseConfig.baseUrl || "",
-            websocketUrl: baseConfig.websocketUrl,
-            appKey: baseConfig.appKey,
-            appSecret: baseConfig.appSecret,
-            localIp: baseConfig.localIp,
-            allowInsecureTls: baseConfig.allowInsecureTls,
-            requestTimeout: baseConfig.requestTimeout,
-        };
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
-        await doHandleToolsListEvent(result.eventData, connConfig.baseUrl, token, log);
-    } catch (err) {
-        logError(log, "handleToolsListEvent failed", err);
-    }
-}
-
-async function handleSkillsListEvent(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-    const { accountId, baseConfig, log } = ctx;
-    if (!result.eventData) return;
-    try {
-        const connConfig = {
-            baseUrl: baseConfig.baseUrl || "",
-            websocketUrl: baseConfig.websocketUrl,
-            appKey: baseConfig.appKey,
-            appSecret: baseConfig.appSecret,
-            localIp: baseConfig.localIp,
-            allowInsecureTls: baseConfig.allowInsecureTls,
-            requestTimeout: baseConfig.requestTimeout,
-        };
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const token = await getWorkclawAccessToken(tokenCacheKey, connConfig);
-        await doHandleSkillsListEvent(result.eventData, connConfig.baseUrl, token, log);
-    } catch (err) {
-        logError(log, "handleSkillsListEvent failed", err);
-    }
-}
-
-async function handleInitAgentEvent(
-    ctx: MessageDispatcherContext,
-    result: ParseWorkClawResult,
-): Promise<void> {
-    const { accountId, cfg, baseConfig, log } = ctx;
-    const initStartedAt = Date.now();
-    const eventData = result.eventData;
-
-    if (!eventData) {
-        log?.warn?.(`init_agent received but no data`);
-        return;
-    }
-
-    log?.info?.(
-        `init_agent accountId=${accountId} eventDataType=${typeof eventData} preview=${JSON.stringify(eventData).slice(0, 200)}`,
-    );
-
-    const connConfig = {
-        baseUrl: baseConfig.baseUrl || "",
-        websocketUrl: baseConfig.websocketUrl,
-        appKey: baseConfig.appKey,
-        appSecret: baseConfig.appSecret,
-        localIp: baseConfig.localIp,
-        allowInsecureTls: baseConfig.allowInsecureTls,
-        requestTimeout: baseConfig.requestTimeout,
-    };
-
-    // Fetch and save apiKey
-    try {
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const { baseUrl: modelBaseUrl, apiKey } = await getWorkclawModelConfigByAppKey(tokenCacheKey, connConfig);
-        const maskedKey = apiKey ? `${String(apiKey).slice(0, 6)}...(${String(apiKey).length})` : "missing";
-
-        log?.info?.(`init_agent model fetched baseUrl=${modelBaseUrl} apiKey=${maskedKey}`);
-
-
-        await saveWorkClawApiKey(apiKey, cfg, log);
-        log?.info?.(`init_agent model config saved elapsedMs=${Date.now() - initStartedAt}`);
-    } catch (err) {
-        logError(log, "init_agent model fetch/save failed", err);
-    }
-
-    // Save default agentId
-    const agentId = String(eventData?.id || eventData?.agentId || "");
-    if (agentId) {
-        try {
-            await saveWorkClawAgentId("default", agentId, cfg, log);
-            log?.info?.(`init_agent saved default agentId=${agentId}`);
-        } catch (err) {
-            logError(log, "init_agent agentId save failed", err);
-        }
-    }
-
-    // Save default userId
-    const userId = String(eventData?.futureId || eventData?.userId || "");
-    if (userId) {
-        try {
-            await saveWorkClawUserId("default", userId, cfg, log);
-            log?.info?.(`init_agent saved default userId=${userId}`);
-        } catch (err) {
-            logError(log, "init_agent userId save failed", err);
-        }
-    }
-
-    log?.info?.(`init_agent handled elapsedMs=${Date.now() - initStartedAt}`);
-}
-
-async function handleAgentMessage(
-    ctx: MessageDispatcherContext,
-    data: string,
-    result: ParseWorkClawResult,
-): Promise<void> {
-    const { accountId, account, cfg, accountConfig, log } = ctx;
-    const { message } = result;
-    if (!message) return;
-
-    // 这里的msgAgentId是云平台的agentId
-    const { text, userId, openConversationId, messageId: parsedMessageId, agentId: msgAgentId } = message;
-
-    // Resolve account from message
-    let messageAccountId = accountId;
-    let messageAccount = account;
-
-    if (userId && msgAgentId) {
-        const resolvedAccountId = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(msgAgentId));
-        if (resolvedAccountId) {
-            const resolved = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
-            messageAccountId = resolvedAccountId;
-            messageAccount = resolved;
-            log?.info?.(`Resolved account ${resolvedAccountId} from message (userId=${userId}, agentId=${msgAgentId})`);
-        } else if (String(msgAgentId) !== String(accountConfig.agentId)) {
-            log?.warn?.(`Account not found for userId=${userId}, agentId=${msgAgentId}, ignoring`);
-            return;
-        }
-    }
-
-    const resolvedAccountConfig = messageAccount.config as unknown as WorkClawAccountConfig;
-    const msgAgentIdResolved = msgAgentId ?? accountConfig.agentId;
-
-    // Save agentId if not already set
-    if (msgAgentId && !resolvedAccountConfig.agentId) {
-        try {
-            await saveWorkClawAgentId(messageAccountId, msgAgentId, cfg, log);
-            log?.info?.(`Saved agentId ${msgAgentId} to account ${messageAccountId}`);
-        } catch (err) {
-            logError(log, "saveWorkClawAgentId failed", err);
-        }
-    }
-
-    // Save openConversationId if new
-    if (openConversationId && openConversationId !== resolvedAccountConfig.openConversationId) {
-        try {
-            await saveOpenConversationId(messageAccountId, openConversationId, cfg, log);
-            log?.info?.(`Saved openConversationId ${openConversationId} to account ${messageAccountId}`);
-        } catch (err) {
-            logError(log, "saveOpenConversationId failed", err);
-        }
-    }
-
-    // Save userId if not already set (directly to openclawWorkclaw level)
-    const workclawConfig = cfg?.channels?.['openclaw-workclaw'] || {};
-    if (userId && !workclawConfig.userId) {
-        try {
-            await saveWorkClawUserId(messageAccountId, userId, cfg, log);
-            log?.info?.(`Saved userId ${userId} to workclaw config`);
-        } catch (err) {
-            logError(log, "saveWorkClawUserId failed", err);
-        }
-    }
-
-    const resolvedOpenConversationId = openConversationId || resolvedAccountConfig.openConversationId || "";
-    const to = userId;
-    const bodyText = text || data;
-
-    if (!bodyText) {
-        log?.warn?.(`Empty body, ignoring`);
-        return;
-    }
-
-    // Route via bindings
-    const bindings = cfg?.bindings ?? [];
-    let targetAgentId = "default";
-    const matchedBinding = bindings.find((binding: any) => {
-        const match = binding?.match;
-        if (!match || match.channel !== "openclaw-workclaw") return false;
-        return match.accountId === messageAccountId || match.accountId === "*";
-    });
-    if (matchedBinding) {
-        targetAgentId = matchedBinding.agentId;
-        log?.info?.(`Routing to agent ${targetAgentId} via binding (account: ${messageAccountId})`);
-    }
-
-    if (!targetAgentId) {
-        log?.warn?.(`Missing target, ignoring`);
-        return;
-    }
-
-    // 构建用于解析 sessionKey 的消息对象
-    // to = agentId (智能体/机器人), from = userId (用户)
-    const attachments = message.attachments
-    const inboundMessage: InboundMessage = {
-        text: bodyText,
-        to: to,
-        from: userId,
-        chatType: "dm",
-        messageId: parsedMessageId,
-        rawPayload: data,
-        timestamp: Date.now(),
-        attachments: attachments,
-    };
-    log?.info?.(`handleAgentMessage: text=${bodyText?.substring(0, 50)}, attachments=${attachments?.length || 0}`)
-    const pluginRuntime = getWorkclawRuntime();
-
-    // 使用扩展后的 buildInboundContext，它会处理完整的 session 流程
-    const finalized = await buildInboundContext(
-        inboundMessage,
-        messageAccountId,
-        messageAccount.config,
-        targetAgentId,
-        pluginRuntime,
-        true,
-        log,
-    );
-
-    // 维护当前工具名称状态
-    let currentToolName: string | null = null;
-    // 追踪 final 是否已投递（框架在流式输出时会 drop final，需要手动补发 last: true）
-    let finalDelivered = false;
-
-    // 发送工具消息的辅助函数
-    const sendToolMessage = async (text: string, isStart: boolean = false) => {
-        try {
-            await sendMessageWorkclaw({
-                cfg,
-                to: to,
-                text,
-                accountId: messageAccountId,
-                openConversationId: resolvedOpenConversationId,
-                agentId: msgAgentIdResolved,
-                replyToMessageId: parsedMessageId,
-                last: false,
-            });
-        } catch (err) {
-            logError(log, isStart ? "Tool start message send failed" : "Tool result message send failed", err);
-        }
-    };
-
-    await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-        ctx: finalized,
-        cfg,
-        replyOptions: {
-            onAgentRunStart(runId: string) {
-                // 保存 runId 和 ctx 的关联，供 hook 使用
-                setToolContext(runId, {
-                    target: targetAgentId,
-                    replyToMessageId: parsedMessageId,
-                    openConversationId: resolvedOpenConversationId,
-                    accountId: messageAccountId,
-                    agentId: String(msgAgentIdResolved),
-                    sessionKey: (finalized.SessionKey as string) || "",
-                });
-                log?.info?.(`[AGENT] onAgentRunStart: runId=${runId} target=${targetAgentId}`);
-            },
-            /*onToolStart(payload) {
-                log?.info?.(`[AGENT] onToolStart: ${JSON.stringify(payload)}`);
-                if (payload.phase === "start") {
-                    currentToolName = payload.name ?? null;
-                    const hint = getToolStartHint(currentToolName);
-                    log?.info?.(`[TOOL] Starting tool: ${currentToolName}, sending hint: ${hint}`);
-                    sendToolMessage(hint, true).catch((err) => {
-                        logError(log, "Tool start hint send failed", err);
-                    });
-                }
-            }*/
-        },
-        dispatcherOptions: {
-            deliver: async (payload: any, info?: any) => {
-                // 记录每次 deliver 调用，帮助调试 info.kind 问题
-                log?.info?.(`[DELIVER] deliver called: info.kind=${info?.kind}, payload.text=${String(payload?.text ?? "").substring(0, 100)}`);
-                const resolvedReplyToId = payload?.replyToId || parsedMessageId;
-                let textOut = String(payload.text ?? payload.body ?? "");
-                const target = to || String(payload.to ?? "");
-
-                if (!target) {
-                    log?.warn?.(`Skipping reply: no target`);
-                    return;
-                }
-
-                if (!textOut.trim()) {
-                    log?.warn?.(`Empty reply text, skipping`);
-                    return;
-                }
-
-                if (info?.kind === "tool") return;
-
-                // 处理工具类型的 deliver
-                /*if (info?.kind === "tool") {
-                    // log?.info?.(`[DELIVER] tool reply: ${JSON.stringify(payload)}`);
-                    const toolText = payload.text ?? "";
-                    if (toolText.trim()) {
-                        // 使用 formattedToolOutput 格式发送
-                        try {
-                            await sendMessageWorkclaw({
-                                cfg,
-                                to: targetAgentId,
-                                text: JSON.stringify({
-                                    name: currentToolName || "Unknown",
-                                    content: toolText,
-                                    state: "result",
-                                }),
-                                msgType: "26",
-                                accountId: messageAccountId,
-                                openConversationId: resolvedOpenConversationId,
-                                agentId: msgAgentIdResolved,
-                                replyToMessageId: parsedMessageId,
-                            });
-                        } catch (err) {
-                            logError(log, "Tool result send failed", err);
-                        }
-                    }
-                    return;
-                }*/
-
-                // final 时清空工具状态
-                if (info?.kind === "final") {
-                    currentToolName = null;
-                    finalDelivered = true;
-                    log?.info?.(`[DELIVER] final received, cleared currentToolName`);
-                }
-
-                // 明确设置 last：final 时为 true，否则为 false（显式转换，避免 undefined）
-                const isFinal = info?.kind === "final";
-                const isLast = isFinal ? true : false;
-                log?.info?.(`[DELIVER] is last: ${isLast} (info.kind=${info?.kind})`);
-
-                try {
-                    const result = await sendMessageWorkclaw({
-                        cfg, to: target, text: textOut,
-                        accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
-                        agentId: msgAgentIdResolved, replyToMessageId: resolvedReplyToId,
-                        last: isLast,
-                    });
-                    log?.info?.(`Reply sent messageId=${result.messageId}`);
-                } catch (err) {
-                    logError(log, "Reply send failed", err);
-                    throw err;
-                }
-            },
-        },
-    });
-
-    // 框架在流式输出时会 drop final payload，检测到时应手动补发 last: true
-    if (!finalDelivered) {
-        log?.warn?.(`[DELIVER] final was dropped by framework, sending last: true`);
-        try {
-            // 发送一个空格作为占位内容，确保 last: true 能被服务端接受
-            await sendMessageWorkclaw({
-                cfg, to: to || String(userId || ""),
-                text: "",
-                accountId: messageAccountId, openConversationId: resolvedOpenConversationId,
-                agentId: msgAgentIdResolved, replyToMessageId: parsedMessageId,
-                last: true,
-            });
-        } catch (err) {
-            // 服务端可能拒绝空内容的 last 信号，忽略即可
-            const errStr = String(err);
-            if (errStr.includes("content can't be empty")) {
-                log?.info?.(`[DELIVER] last signal skipped (empty content not supported)`);
-            } else {
-                logError(log, "Final/last signal send failed", err);
-            }
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Main dispatcher
-// ---------------------------------------------------------------------------
-
-export async function dispatchWorkclawMessage(
-    data: string,
-    ctx: MessageDispatcherContext,
-): Promise<void> {
-    const { log } = ctx;
-
-    const rawHasAuthToken =
-        data.includes("authToken") ||
-        data.toLowerCase().includes("authorization") ||
-        data.toLowerCase().includes("bearer ");
-    const rawPreview = data.length > 300 ? `${data.slice(0, 300)}...` : data;
-    /*log?.info?.(
-        `Raw message bytes=${data.length} hasAuthToken=${rawHasAuthToken} preview=${rawPreview}`,
-    );*/
-
-    const result = parseWorkClawMessage(data, log);
-    if (!result) {
-        log?.warn?.(`Failed to parse message`);
-        return;
-    }
-
-    log?.info?.(`Message type=${result.type}`);
-
-    // 更新上次消息时间（始终用 accountId，因为每个账号的入站时间需要独立追踪）
-    const { accountId } = ctx;
-    if (accountId) {
-        setLastInboundAt(accountId, Date.now());
-    }
-
-    switch (result.type) {
-        case "ping":
-            await handlePing(ctx, result);
-            return;
-
-        case "disconnect":
-            await handleDisconnect(ctx);
-            return;
-
-        case "agent_created":
-        case "agent_updated":
-        case "agent_deleted":
-            await handleAgentEvent(ctx, result);
-            return;
-
-        case "skills_event":
-            await handleSkillsProcessingEvent(ctx, result);
-            return;
-
-        case "tools_list":
-            await handleToolsListEvent(ctx, result);
-            return;
-
-        case "skills_list":
-            await handleSkillsListEvent(ctx, result);
-            return;
-
-        case "init_agent":
-            await handleInitAgentEvent(ctx, result);
-            return;
-
-        case "ignored":
-            log?.info?.(`Ignoring message type=${result.type}`);
-            return;
-
-        case "agent_message":
-            await handleAgentMessage(ctx, data, result);
-            return;
-
-        default:
-            log?.info?.(`Unknown message type: ${result.type}, ignoring`);
-    }
-}
-
-
-// 创建成功回调
-async function handleAgentCreatedMessage(baseConfig: WorkClawBaseConfig, agentId: string, accountId: string, log?: any) {
-    // 通知
-    try {
-        const callbackUrl = `${baseConfig.baseUrl}/open-apis/instance/agent-created/status`;
-        const tokenCacheKey = baseConfig.appKey || accountId;
-        const callbackData = {
-            "agentId": agentId,
-            "success": true
-        };
-
-        log?.info?.(`[AgentCreated] Calling callback API: ${callbackUrl}`);
-        const token = await getWorkclawAccessToken(tokenCacheKey, baseConfig);
-
-        const response = await request(callbackUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${token}`,
-            },
-            body: JSON.stringify(callbackData),
-        });
-
-        const responseBody = await response.body.text();
-        log?.info?.(`[AgentCreated] Callback API response: status=${response.statusCode}, body=${responseBody}`);
-
-    } catch (callbackErr) {
-        // 接口调用失败不影响主流程，只记录错误
-        log?.error?.(`[AgentCreated] Callback API failed: ${String(callbackErr)}`);
-    }
-}