@workclaw/openclaw-workclaw 1.0.17 → 1.0.18

package/src/gateway/message-dispatcher.ts

@@ -2,38 +2,42 @@
  * 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'
+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: 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
+    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}`)
+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}`);
 }
 
 // ---------------------------------------------------------------------------
@@ -41,377 +45,380 @@ function logError(log: MessageDispatcherContext['log'], context: string, err: un
 // ---------------------------------------------------------------------------
 
 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),
+    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);
     }
-    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)
+    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();
     }
-  }
-  else {
-    log?.info?.(`WebSocket already cleared, triggering reconnect...`)
-    scheduleReconnect()
-  }
 }
 
 async function handleAgentEvent(
-  ctx: MessageDispatcherContext,
-  result: ParseWorkClawResult,
+    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
-  }
+    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 { 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 { 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);
     }
-    const tokenCacheKey = baseConfig.appKey || accountId
-    const token = await getOpenclawWorkclawAccessToken(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 { 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 { 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);
     }
-    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 { 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);
     }
-    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,
+    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)
+    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;
     }
-  }
 
-  // Save default userId
-  const userId = String(eventData?.futureId || eventData?.userId || '')
-  if (userId) {
+    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 {
-      await saveWorkClawUserId('default', userId, cfg, log)
-      log?.info?.(`init_agent saved default userId=${userId}`)
+        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);
     }
-    catch (err) {
-      logError(log, 'init_agent userId 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);
+        }
     }
-  }
 
-  log?.info?.(`init_agent handled elapsedMs=${Date.now() - initStartedAt}`)
+    // 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,
+    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 { 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
+    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}`)
+    // 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);
+        }
     }
-    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 openConversationId if new
-  if (openConversationId && openConversationId !== resolvedAccountConfig.openConversationId) {
-    try {
-      await saveOpenConversationId(messageAccountId, openConversationId, cfg, log)
-      log?.info?.(`Saved openConversationId ${openConversationId} to account ${messageAccountId}`)
+    // 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);
+        }
     }
-    catch (err) {
-      logError(log, 'saveOpenConversationId failed', err)
+
+    const resolvedOpenConversationId = openConversationId || resolvedAccountConfig.openConversationId || "";
+    const to = userId;
+    const bodyText = text || data;
+
+    if (!bodyText) {
+        log?.warn?.(`Empty body, ignoring`);
+        return;
     }
-  }
 
-  // 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`)
+    // 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})`);
     }
-    catch (err) {
-      logError(log, 'saveWorkClawUserId failed', err)
+
+    if (!targetAgentId) {
+        log?.warn?.(`Missing target, ignoring`);
+        return;
     }
-  }
-
-  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) {
+
+    // 构建用于解析 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;
@@ -421,37 +428,36 @@ async function handleAgentMessage(
                         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
-        }
+            }*/
+        },
+        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 (!textOut.trim()) {
+                    log?.warn?.(`Empty reply text, skipping`);
+                    return;
+                }
 
-        if (info?.kind === 'tool')
-          return
+                if (info?.kind === "tool") return;
 
-        // 处理工具类型的 deliver
-        /* if (info?.kind === "tool") {
+                // 处理工具类型的 deliver
+                /*if (info?.kind === "tool") {
                     // log?.info?.(`[DELIVER] tool reply: ${JSON.stringify(payload)}`);
                     const toolText = payload.text ?? "";
                     if (toolText.trim()) {
                         // 使用 formattedToolOutput 格式发送
                         try {
-                            await sendMessageOpenclawWorkclaw({
+                            await sendMessageWorkclaw({
                                 cfg,
                                 to: targetAgentId,
                                 text: JSON.stringify({
@@ -470,132 +476,166 @@ async function handleAgentMessage(
                         }
                     }
                     return;
-                } */
+                }*/
+
+                // final 时清空工具状态
+                if (info?.kind === "final") {
+                    currentToolName = null;
+                    finalDelivered = true;
+                    log?.info?.(`[DELIVER] final received, cleared currentToolName`);
+                }
 
-        log?.info?.(`[DELIVER] is last: ${info?.kind === 'final'}`)
+                // 明确设置 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 {
-          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}`)
+            // 发送一个空格作为占位内容，确保 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);
+            }
         }
-        catch (err) {
-          logError(log, 'Reply send failed', err)
-          throw err
-        }
-      },
-    },
-  })
+    }
 }
 
 // ---------------------------------------------------------------------------
 // Main dispatcher
 // ---------------------------------------------------------------------------
 
-export async function dispatchOpenclawWorkclawMessage(
-  data: string,
-  ctx: MessageDispatcherContext,
+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}`)
-
-  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`)
-  }
-}
+    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;
+    }
 
-// 创建成功回调
-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?.(`Message type=${result.type}`);
+
+    // 更新上次消息时间（始终用 accountId，因为每个账号的入站时间需要独立追踪）
+    const { accountId } = ctx;
+    if (accountId) {
+        setLastInboundAt(accountId, Date.now());
     }
 
-    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)}`)
-  }
+    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)}`);
+    }
+}