@workclaw/openclaw-workclaw 1.0.0

package/src/gateway/message-dispatcher.ts

@@ -0,0 +1,601 @@
+/**
+ * Message Dispatcher - handles all WorkClaw WebSocket message types
+ */
+
+import type { ResolvedOpenclawWorkclawAccount, WorkClawAccountConfig, WorkClawBaseConfig } from '../types.js'
+import type { InboundMessage, ParseWorkClawResult } from './message-context.js'
+
+import { resolveAccountByUserIdAndAgentId, resolveOpenclawWorkclawAccount } from '../accounts.js'
+import { getOpenclawWorkclawAccessToken } from '../connection/workclaw-client.js'
+
+import { sendMessageOpenclawWorkclaw } from '../outbound/index.js'
+import { getOpenclawWorkclawRuntime, getOpenclawWorkclawWsConnection, setToolContext } from '../runtime.js'
+import { handleAgentCreated, handleAgentDeleted, handleAgentUpdated } from './agent-handlers.js'
+import { saveOpenConversationId, saveWorkClawAgentId, saveWorkClawApiKey, saveWorkClawUserId } from './config-writer.js'
+import { buildInboundContext, parseWorkClawMessage } from './message-context.js'
+
+export interface MessageDispatcherContext {
+  accountId: string
+  account: ResolvedOpenclawWorkclawAccount
+  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 = getOpenclawWorkclawWsConnection(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 = getOpenclawWorkclawWsConnection(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.skillsEvent)
+    return
+  try {
+    const { handleSkillsEvent } = await import('./skills-handler.js')
+    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 getOpenclawWorkclawAccessToken(tokenCacheKey, connConfig)
+    await handleSkillsEvent(result.skillsEvent, 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 { handleToolsListEvent } = await import('./tools-list-handler.js')
+    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 getOpenclawWorkclawAccessToken(tokenCacheKey, connConfig)
+    await handleToolsListEvent(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 { handleSkillsListEvent } = await import('./skills-list-handler.js')
+    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 getOpenclawWorkclawAccessToken(tokenCacheKey, connConfig)
+    await handleSkillsListEvent(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 { getOpenclawWorkclawModelConfigByAppKey } = await import('../connection/workclaw-client.js')
+    const tokenCacheKey = baseConfig.appKey || accountId
+    const { baseUrl: modelBaseUrl, apiKey } = await getOpenclawWorkclawModelConfigByAppKey(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 = resolveOpenclawWorkclawAccount({ 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 openclawWorkclawConfig = cfg?.channels?.['openclaw-workclaw'] || {}
+  if (userId && !openclawWorkclawConfig.userId) {
+    try {
+      await saveWorkClawUserId(messageAccountId, userId, cfg, log)
+      log?.info?.(`Saved userId ${userId} to openclawWorkclaw 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 inboundMessage: InboundMessage = {
+    text: bodyText,
+    to,
+    from: userId,
+    chatType: 'dm',
+    messageId: parsedMessageId,
+    rawPayload: data,
+    timestamp: Date.now(),
+  }
+
+  const pluginRuntime = getOpenclawWorkclawRuntime()
+
+  // 使用扩展后的 buildInboundContext，它会处理完整的 session 流程
+  const finalized = await buildInboundContext(
+    inboundMessage,
+    messageAccountId,
+    messageAccount.config,
+    targetAgentId,
+    pluginRuntime,
+    true,
+    log,
+  )
+
+  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
+        const 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 sendMessageOpenclawWorkclaw({
+                                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;
+                } */
+
+        log?.info?.(`[DELIVER] is last: ${info?.kind === 'final'}`)
+
+        try {
+          const result = await sendMessageOpenclawWorkclaw({
+            cfg,
+            to: target,
+            text: textOut,
+            accountId: messageAccountId,
+            openConversationId: resolvedOpenConversationId,
+            agentId: msgAgentIdResolved,
+            replyToMessageId: resolvedReplyToId,
+            last: info?.kind === 'final',
+          })
+          log?.info?.(`Reply sent messageId=${result.messageId}`)
+        }
+        catch (err) {
+          logError(log, 'Reply send failed', err)
+          throw err
+        }
+      },
+    },
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Main dispatcher
+// ---------------------------------------------------------------------------
+
+export async function dispatchOpenclawWorkclawMessage(
+  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}`)
+
+  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): Promise<void> {
+  // 通知
+  try {
+    const callbackUrl = `${baseConfig.baseUrl}/open-apis/instance/agent-created/status`
+    const tokenCacheKey = baseConfig.appKey || accountId
+    const callbackData = {
+      agentId,
+      success: true,
+    }
+
+    log?.info?.(`[AgentCreated] Calling callback API: ${callbackUrl}`)
+    const token = await getOpenclawWorkclawAccessToken(tokenCacheKey, baseConfig)
+
+    const { request } = await import('undici')
+    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)}`)
+  }
+}