@workclaw/openclaw-workclaw 1.0.17 → 1.0.18

package/src/runtime.ts

@@ -1,400 +1,497 @@
-import type { PluginRuntime } from 'openclaw/plugin-sdk'
-import type { WebSocket } from 'undici'
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { WebSocket } from "undici";
 
-let runtime: PluginRuntime | null = null
+let runtime: PluginRuntime | null = null;
 
 // 统一存储: key 可能是 accountId (per-account) 或 appKey (per-appKey)
-const wsByKey = new Map<string, WebSocket>()
+const wsByKey = new Map<string, WebSocket>();
 
 // per-appKey 模式额外需要的映射
-const accountIdsByAppKey = new Map<string, Set<string>>()
-const appKeyByAccountId = new Map<string, string>()
-const reconnectSchedulers = new Map<string, any>()
-const dispatchersByAppKey = new Map<string, Map<string, { ctx: any }>>()
-const connectingApps = new Set<string>() // 正在连接中的 appKey，防止竞态条件
+const accountIdsByAppKey = new Map<string, Set<string>>();
+const appKeyByAccountId = new Map<string, string>();
+const reconnectSchedulers = new Map<string, any>();
+const dispatchersByAppKey = new Map<string, Map<string, { ctx: any }>>();
+// 正在连接中的 appKey → Promise<ws>（成功后 resolve(ws)，失败 resolve(null)）
+const connectingPromises = new Map<string, Promise<WebSocket | null>>();
+// 仅用于 tryStartConnecting 返回 existingWs：ws 已建立成功后，从这里读取
+const wsByAppKey = new Map<string, WebSocket>();
+const lastMessageAtByKey = new Map<string, number>();  // 上次消息时间，key 为 accountId 或 appKey
 
-export function setOpenclawWorkclawRuntime(next: PluginRuntime): void {
-  runtime = next
+export function setWorkclawRuntime(next: PluginRuntime) {
+  runtime = next;
 }
 
-export function getOpenclawWorkclawRuntime(): PluginRuntime {
+export function getWorkclawRuntime(): PluginRuntime {
   if (!runtime) {
-    throw new Error('OpenclawWorkclaw runtime not initialized')
+    throw new Error("Workclaw runtime not initialized");
   }
-  return runtime
+  return runtime;
 }
 
-export interface OpenclawWorkclawLogger {
-  info: (msg: string, ...args: any[]) => void
-  warn: (msg: string, ...args: any[]) => void
-  error: (msg: string, ...args: any[]) => void
-  debug: (msg: string, ...args: any[]) => void
-}
+export type WorkclawLogger = {
+  info?: (msg: string, ...args: any[]) => void;
+  warn?: (msg: string, ...args: any[]) => void;
+  error?: (msg: string, ...args: any[]) => void;
+  debug?: (msg: string, ...args: any[]) => void;
+};
 
-let _logger: OpenclawWorkclawLogger | null = null
+let _logger: WorkclawLogger | null = null;
 
-function _noop(): void { }
+const _noop = () => {};
 
-function _fallbackLogger(): OpenclawWorkclawLogger {
+function _fallbackLogger(): WorkclawLogger {
   return {
-    // eslint-disable-next-line no-console
     info: console.log.bind(console),
     warn: console.warn.bind(console),
     error: console.error.bind(console),
     debug: _noop,
-  }
+  };
 }
 
 /** Store the gateway's log into runtime. Called from startAccount. */
-export function setOpenclawWorkclawLoggerFromContext(log: OpenclawWorkclawLogger): void {
-  _logger = log
+export function setWorkclawLoggerFromContext(log: WorkclawLogger): void {
+  _logger = log;
 }
 
 /** Get the shared logger. Returns ctx.log from gateway if set, otherwise a console fallback. */
-export function getOpenclawWorkclawLogger(): OpenclawWorkclawLogger {
+export function getWorkclawLogger(): WorkclawLogger {
   if (!_logger) {
-    return _fallbackLogger()
+    return _fallbackLogger();
   }
   // If the stored logger's info is a noop, fall back to console
-  const l = _logger
+  const l = _logger;
   if (l.info === _noop) {
-    return _fallbackLogger()
+    return _fallbackLogger();
   }
-  return _logger
+  return _logger;
 }
 
 /**
  * Wrap a logger with a prefix automatically prepended to every message.
  * All messages logged via the returned logger will have the prefix attached.
  */
-export function createLogger(prefix: string, log?: any): OpenclawWorkclawLogger {
-  const fallback = _fallbackLogger()
+export function createLogger(prefix: string, log?: WorkclawLogger): WorkclawLogger {
+  const fallback = _fallbackLogger();
   return {
-    info: log?.info ? (msg: string, ...args: any[]) => log.info(`${prefix} ${msg}`, ...args) : fallback.info,
-    warn: log?.warn ? (msg: string, ...args: any[]) => log.warn(`${prefix} ${msg}`, ...args) : fallback.warn,
-    error: log?.error ? (msg: string, ...args: any[]) => log.error(`${prefix} ${msg}`, ...args) : fallback.error,
-    debug: log?.debug ? (msg: string, ...args: any[]) => log.debug(`${prefix} ${msg}`, ...args) : fallback.debug,
-  }
+    info: log?.info ? (msg: string, ...args: any[]) => log.info!(`${prefix} ${msg}`, ...args) : fallback.info,
+    warn: log?.warn ? (msg: string, ...args: any[]) => log.warn!(`${prefix} ${msg}`, ...args) : fallback.warn,
+    error: log?.error ? (msg: string, ...args: any[]) => log.error!(`${prefix} ${msg}`, ...args) : fallback.error,
+    debug: log?.debug ? (msg: string, ...args: any[]) => log.debug!(`${prefix} ${msg}`, ...args) : fallback.debug,
+  };
+}
+
+export function setWorkclawWsConnection(key: string, ws: WebSocket) {
+  wsByKey.set(key, ws);
+}
+
+export function clearWorkclawWsConnection(key: string) {
+  wsByKey.delete(key);
+}
+
+export function getWorkclawWsConnection(key: string): WebSocket | undefined {
+  return wsByKey.get(key);
+}
+
+export function setLastInboundAt(key: string, timestamp: number) {
+  lastMessageAtByKey.set(key, timestamp);
+}
+
+export function getLastInboundAt(key: string): number | undefined {
+  return lastMessageAtByKey.get(key);
+}
+
+const lastOutboundAtByKey = new Map<string, number>();
+
+// Cached connection config: accountId -> connection config with stable appKey/appSecret
+// This prevents re-resolving from cfg which may have been mutated
+const connectionConfigCache = new Map<string, {
+  appKey: string;
+  appSecret: string;
+  baseUrl: string;
+  websocketUrl?: string;
+  localIp?: string;
+  allowInsecureTls?: boolean;
+  requestTimeout?: number;
+}>();
+
+export function setWorkclawConnectionConfig(accountId: string, config: {
+  appKey: string;
+  appSecret: string;
+  baseUrl?: string;
+  websocketUrl?: string;
+  localIp?: string;
+  allowInsecureTls?: boolean;
+  requestTimeout?: number;
+}) {
+  connectionConfigCache.set(accountId, {
+    appKey: config.appKey,
+    appSecret: config.appSecret,
+    baseUrl: config.baseUrl ?? "",
+    websocketUrl: config.websocketUrl,
+    localIp: config.localIp,
+    allowInsecureTls: config.allowInsecureTls,
+    requestTimeout: config.requestTimeout,
+  });
+}
+
+export function getWorkclawConnectionConfig(accountId: string): {
+  appKey: string;
+  appSecret: string;
+  baseUrl: string;
+  websocketUrl?: string;
+  localIp?: string;
+  allowInsecureTls?: boolean;
+  requestTimeout?: number;
+} | undefined {
+  return connectionConfigCache.get(accountId);
 }
 
-export function setOpenclawWorkclawWsConnection(key: string, ws: WebSocket): void {
-  wsByKey.set(key, ws)
+export function clearWorkclawConnectionConfig(accountId: string) {
+  connectionConfigCache.delete(accountId);
 }
 
-export function clearOpenclawWorkclawWsConnection(key: string): void {
-  wsByKey.delete(key)
+export function setLastOutboundAt(key: string, timestamp: number) {
+  lastOutboundAtByKey.set(key, timestamp);
 }
 
-export function getOpenclawWorkclawWsConnection(key: string): WebSocket | undefined {
-  return wsByKey.get(key)
+export function getLastOutboundAt(key: string): number | undefined {
+  return lastOutboundAtByKey.get(key);
 }
 
 // per-appKey 模式专用
-export function registerAccountContext(appKey: string, accountId: string, ctx: any): void {
+export function registerAccountContext(appKey: string, accountId: string, ctx: any) {
   if (!accountIdsByAppKey.has(appKey)) {
-    accountIdsByAppKey.set(appKey, new Set())
+    accountIdsByAppKey.set(appKey, new Set());
   }
-  accountIdsByAppKey.get(appKey)!.add(accountId)
-  appKeyByAccountId.set(accountId, appKey)
+  accountIdsByAppKey.get(appKey)!.add(accountId);
+  appKeyByAccountId.set(accountId, appKey);
 
   if (!dispatchersByAppKey.has(appKey)) {
-    dispatchersByAppKey.set(appKey, new Map())
+    dispatchersByAppKey.set(appKey, new Map());
   }
-  dispatchersByAppKey.get(appKey)!.set(accountId, { ctx })
+  dispatchersByAppKey.get(appKey)!.set(accountId, { ctx });
 }
 
-export function unregisterAccountContext(appKey: string, accountId: string): void {
-  accountIdsByAppKey.get(appKey)?.delete(accountId)
-  appKeyByAccountId.delete(accountId)
-  dispatchersByAppKey.get(appKey)?.delete(accountId)
+export function unregisterAccountContext(appKey: string, accountId: string) {
+  accountIdsByAppKey.get(appKey)?.delete(accountId);
+  appKeyByAccountId.delete(accountId);
+  dispatchersByAppKey.get(appKey)?.delete(accountId);
 }
 
 export function getAccountIdsByAppKey(appKey: string): string[] {
-  return Array.from(accountIdsByAppKey.get(appKey) ?? [])
+  return Array.from(accountIdsByAppKey.get(appKey) ?? []);
 }
 
 export function getAppKeyByAccountId(accountId: string): string | undefined {
-  return appKeyByAccountId.get(accountId)
+  return appKeyByAccountId.get(accountId);
 }
 
 export function getDispatcherByAppKeyAndAccountId(appKey: string, accountId: string): { ctx: any } | undefined {
-  return dispatchersByAppKey.get(appKey)?.get(accountId)
+  return dispatchersByAppKey.get(appKey)?.get(accountId);
 }
 
 export function getAllDispatchersByAppKey(appKey: string): Map<string, { ctx: any }> | undefined {
-  return dispatchersByAppKey.get(appKey)
+  return dispatchersByAppKey.get(appKey);
 }
 
-export function setReconnectScheduler(appKey: string, scheduler: any): void {
-  reconnectSchedulers.set(appKey, scheduler)
+export function setReconnectScheduler(appKey: string, scheduler: any) {
+  reconnectSchedulers.set(appKey, scheduler);
 }
 
 export function getReconnectScheduler(appKey: string): any | undefined {
-  return reconnectSchedulers.get(appKey)
+  return reconnectSchedulers.get(appKey);
+}
+
+export function clearReconnectScheduler(appKey: string) {
+  reconnectSchedulers.delete(appKey);
 }
 
-export function clearReconnectScheduler(appKey: string): void {
-  reconnectSchedulers.delete(appKey)
+// 尝试开始连接，返回是否需要自己创建连接
+// exported for workclaw-gateway.ts
+export interface TryStartConnectingResult {
+  isConnector: boolean;
+  /** 如果 ws 已建立完成（非连接中），返回该 ws；否则 undefined */
+  existingWs: WebSocket | undefined;
+  /** 等待连接完成的 Promise：成功时 resolve(ws)，失败时 resolve(null) */
+  connectingPromise: Promise<WebSocket | null>;
 }
 
-// 尝试开始连接，如果已经在连接中则返回 false
-export function tryStartConnecting(appKey: string): boolean {
-  if (connectingApps.has(appKey)) {
-    return false
+// 尝试开始连接
+// 关键：所有并发调用者必须共享同一个 Promise，而不是各自创建新的导致重复建连
+export function tryStartConnecting(appKey: string): TryStartConnectingResult {
+  // 优先查 connectingPromises，确保所有并发调用者共享同一个 Promise
+  const existingPromise = connectingPromises.get(appKey);
+  if (existingPromise !== undefined) {
+    // 已有并发账号在连接，等待同一个 Promise
+    return {
+      isConnector: false,
+      existingWs: wsByAppKey.get(appKey),
+      connectingPromise: existingPromise,
+    };
+  }
+  // Map 里没有 entry，自己是新 connector
+  let resolvePromise: (ws: WebSocket | null) => void;
+  const promise = new Promise<WebSocket | null>((resolve) => { resolvePromise = resolve; });
+  (promise as any)._resolve = resolvePromise;
+  connectingPromises.set(appKey, promise);
+  return { isConnector: true, existingWs: undefined, connectingPromise: promise };
+}
+
+// 标记连接完成（成功或失败都需要调用）
+// ws 不传或传 undefined 表示失败
+export function finishConnecting(appKey: string, ws?: WebSocket) {
+  const promise = connectingPromises.get(appKey);
+  if (promise) {
+    (promise as any)._resolve?.(ws ?? null);
+    connectingPromises.delete(appKey);
+  }
+  // ws 已建立成功时存入 wsByAppKey，供后续 tryStartConnecting 返回 existingWs
+  if (ws) {
+    wsByAppKey.set(appKey, ws);
   }
-  connectingApps.add(appKey)
-  return true
 }
 
 // 工具执行上下文信息，用于关联 runId 和发送目标
 export interface ToolContext {
-  target: string
-  replyToMessageId: string
-  openConversationId: string
-  accountId: string
-  agentId: string
-  sessionKey: string
+    target: string;
+    replyToMessageId: string;
+    openConversationId: string;
+    accountId: string;
+    agentId: string;
+    sessionKey: string;
 }
 
 // runId -> ToolContext 映射表
-const runIdToToolContext = new Map<string, ToolContext>()
+const runIdToToolContext = new Map<string, ToolContext>();
 // toolCallId -> runId 映射表（用于 tool_result_persist 通过 toolCallId 找到 runId，再找到 ctx）
-const toolCallIdToRunId = new Map<string, string>()
+const toolCallIdToRunId = new Map<string, string>();
 
 // 获取工具上下文（通过 runId）
 export function getToolContext(runId: string): ToolContext | undefined {
-  return runIdToToolContext.get(runId)
+    return runIdToToolContext.get(runId);
 }
 
 // 设置工具上下文（仅通过 runId）
 export function setToolContext(runId: string, ctx: ToolContext): void {
-  runIdToToolContext.set(runId, ctx)
+    runIdToToolContext.set(runId, ctx);
 }
 
 // 建立 toolCallId -> runId 的映射（用于 after_tool_call 中）
 export function setToolCallIdToRunIdMapping(toolCallId: string, runId: string): void {
-  toolCallIdToRunId.set(toolCallId, runId)
+    toolCallIdToRunId.set(toolCallId, runId);
 }
 
 // 通过 toolCallId 获取 runId
 export function getRunIdByToolCallId(toolCallId: string): string | undefined {
-  return toolCallIdToRunId.get(toolCallId)
+    return toolCallIdToRunId.get(toolCallId);
 }
 
 // 删除工具上下文
 export function deleteToolContext(runId: string): void {
-  runIdToToolContext.delete(runId)
+    runIdToToolContext.delete(runId);
 }
 
 // 清空所有工具上下文（用于清理）
 export function clearAllToolContexts(): void {
-  runIdToToolContext.clear()
-  toolCallIdToRunId.clear()
-}
-
-// 标记连接完成（成功或失败都需要调用）
-export function finishConnecting(appKey: string): void {
-  connectingApps.delete(appKey)
+    runIdToToolContext.clear();
+    toolCallIdToRunId.clear();
 }
 
 // 调用sub-agent进行协作
 export async function spawnSubAgent(params: {
-  agentId: string
-  task: string
-  label?: string
-  model?: string
-}): Promise<{ ok: boolean, sessionKey?: string, summary?: string, error?: string }> {
+  agentId: string;
+  task: string;
+  label?: string;
+  model?: string;
+}): Promise<{ ok: boolean; sessionKey?: string; summary?: string; error?: string }> {
   if (!runtime) {
-    throw new Error('OpenclawWorkclaw runtime not initialized')
+    throw new Error("Workclaw runtime not initialized");
   }
 
   try {
     // 通过runtime调用sessions_spawn
-    const sessionsSpawn = (runtime as any)?.sessions_spawn
-    if (!sessionsSpawn || typeof sessionsSpawn !== 'function') {
+    const sessionsSpawn = (runtime as any)?.sessions_spawn;
+    if (!sessionsSpawn || typeof sessionsSpawn !== "function") {
       // 如果runtime没有提供sessions_spawn，返回模拟数据
-      getOpenclawWorkclawLogger().warn(`Runtime does not provide sessions_spawn, returning mock response for agent ${params.agentId}`)
+      getWorkclawLogger().warn(`Runtime does not provide sessions_spawn, returning mock response for agent ${params.agentId}`);
       return {
         ok: true,
-        summary: `[模拟] Agent ${params.agentId} 完成任务: ${params.task.substring(0, 50)}...`,
-      }
+        summary: `[模拟] Agent ${params.agentId} 完成任务: ${params.task.substring(0, 50)}...`
+      };
     }
 
     const result = await sessionsSpawn({
       agentId: params.agentId,
       task: params.task,
       label: params.label,
-      model: params.model,
-    })
+      model: params.model
+    });
 
     return {
       ok: true,
       sessionKey: result.sessionKey,
-      summary: result.summary,
-    }
-  }
-  catch (error: any) {
-    getOpenclawWorkclawLogger().error(`Failed to spawn sub-agent: ${error.message}`)
+      summary: result.summary
+    };
+  } catch (error: any) {
+    getWorkclawLogger().error(`Failed to spawn sub-agent: ${error.message}`);
     return {
       ok: false,
-      error: error.message,
-    }
+      error: error.message
+    };
   }
 }
 
-export const __openclaw_workclaw_runtime_emitted = true
+export const __openclaw_workclaw_runtime_emitted = true;
 
 export interface ToolInfo {
-  emoji: string
-  title: string
-  hint: string
-  aliases: string[]
+  emoji: string;
+  title: string;
+  hint: string;
+  aliases: string[];
 }
 
 /**
  * 获取工具执行开始的提示（用于 onToolStart）
  */
 export function getToolStartHint(toolName: string | undefined): string {
-  if (!toolName)
-    return '🔄 正在执行工具...'
+  if (!toolName) return "🔄 正在执行工具...";
 
-  const normalizedToolName = toolName.toLowerCase().trim()
+  const normalizedToolName = toolName.toLowerCase().trim();
 
   const toolMap: Record<string, ToolInfo> = {
     // 📁 文件操作
-    'read': { emoji: '📖', title: '读取文件', hint: '正在读取文件', aliases: ['file_read', 'read_file'] },
-    'write': { emoji: '✍️', title: '写入文件', hint: '正在写入文件', aliases: ['file_write', 'write_file'] },
-    'edit': { emoji: '✏️', title: '编辑文件', hint: '正在编辑文件', aliases: ['file_edit', 'modify'] },
+    read: { emoji: "📖", title: "读取文件", hint: "正在读取文件", aliases: ["file_read", "read_file"] },
+    write: { emoji: "✍️", title: "写入文件", hint: "正在写入文件", aliases: ["file_write", "write_file"] },
+    edit: { emoji: "✏️", title: "编辑文件", hint: "正在编辑文件", aliases: ["file_edit", "modify"] },
 
     // 💻 系统命令
-    'exec': { emoji: '⚡', title: '执行命令', hint: '正在执行命令', aliases: ['bash', 'shell', 'cmd', 'command'] },
-    'process': { emoji: '🔄', title: '进程管理', hint: '正在处理进程', aliases: ['process_manager'] },
+    exec: { emoji: "⚡", title: "执行命令", hint: "正在执行命令", aliases: ["bash", "shell", "cmd", "command"] },
+    process: { emoji: "🔄", title: "进程管理", hint: "正在处理进程", aliases: ["process_manager"] },
 
     // 🌐 网络/浏览器
-    'web_fetch': { emoji: '🕸️', title: '获取网页', hint: '正在获取网页内容', aliases: ['fetch', 'http_get', 'http_request', 'curl'] },
-    'web_search': { emoji: '🔍', title: '搜索网页', hint: '正在搜索网页', aliases: ['search', 'google_search', 'brave_search'] },
-    'browser': { emoji: '🌐', title: '浏览器控制', hint: '正在控制浏览器', aliases: ['browser_control', 'playwright'] },
+    web_fetch: { emoji: "🕸️", title: "获取网页", hint: "正在获取网页内容", aliases: ["fetch", "http_get", "http_request", "curl"] },
+    web_search: { emoji: "🔍", title: "搜索网页", hint: "正在搜索网页", aliases: ["search", "google_search", "brave_search"] },
+    browser: { emoji: "🌐", title: "浏览器控制", hint: "正在控制浏览器", aliases: ["browser_control", "playwright"] },
 
     // 💬 消息/通信
-    'message': { emoji: '💌', title: '发送消息', hint: '正在发送消息', aliases: ['send_message', 'mcp_deliver', 'deliver', 'notify'] },
-    'tts': { emoji: '🔊', title: '文字转语音', hint: '正在转换语音', aliases: ['text_to_speech', 'speak'] },
+    message: { emoji: "💌", title: "发送消息", hint: "正在发送消息", aliases: ["send_message", "mcp_deliver", "deliver", "notify"] },
+    tts: { emoji: "🔊", title: "文字转语音", hint: "正在转换语音", aliases: ["text_to_speech", "speak"] },
 
     // 🎭 会话管理
-    'sessions_spawn': { emoji: '🧬', title: '创建子代理', hint: '正在创建子代理', aliases: ['spawn', 'create_agent', 'new_session'] },
-    'sessions_send': { emoji: '📤', title: '跨会话发消息', hint: '正在发送跨会话消息', aliases: ['send_to_session', 'forward'] },
-    'sessions_list': { emoji: '📋', title: '列出会话', hint: '正在列出会话', aliases: ['list_sessions'] },
-    'sessions_history': { emoji: '📜', title: '获取历史', hint: '正在获取历史消息', aliases: ['get_history', 'history'] },
-    'sessions_yield': { emoji: '⏸️', title: '暂停让出', hint: '正在暂停等待', aliases: ['yield', 'pause'] },
-    'subagents': { emoji: '🐛', title: '子代理管理', hint: '正在管理子代理', aliases: ['subagent_manager'] },
-    'agents_list': { emoji: '🤖', title: '列出代理', hint: '正在列出可用代理', aliases: ['list_agents'] },
+    sessions_spawn: { emoji: "🧬", title: "创建子代理", hint: "正在创建子代理", aliases: ["spawn", "create_agent", "new_session"] },
+    sessions_send: { emoji: "📤", title: "跨会话发消息", hint: "正在发送跨会话消息", aliases: ["send_to_session", "forward"] },
+    sessions_list: { emoji: "📋", title: "列出会话", hint: "正在列出会话", aliases: ["list_sessions"] },
+    sessions_history: { emoji: "📜", title: "获取历史", hint: "正在获取历史消息", aliases: ["get_history", "history"] },
+    sessions_yield: { emoji: "⏸️", title: "暂停让出", hint: "正在暂停等待", aliases: ["yield", "pause"] },
+    subagents: { emoji: "🐛", title: "子代理管理", hint: "正在管理子代理", aliases: ["subagent_manager"] },
+    agents_list: { emoji: "🤖", title: "列出代理", hint: "正在列出可用代理", aliases: ["list_agents"] },
 
     // 🧠 记忆/知识
-    'memory_search': { emoji: '🔎', title: '搜索记忆', hint: '正在搜索记忆', aliases: ['search_memory', 'recall'] },
-    'memory_get': { emoji: '📝', title: '读取记忆', hint: '正在读取记忆片段', aliases: ['get_memory', 'read_memory'] },
+    memory_search: { emoji: "🔎", title: "搜索记忆", hint: "正在搜索记忆", aliases: ["search_memory", "recall"] },
+    memory_get: { emoji: "📝", title: "读取记忆", hint: "正在读取记忆片段", aliases: ["get_memory", "read_memory"] },
 
     // ⏰ 定时任务
-    'openclaw-workclaw-cron-add-params': { emoji: '⏱️', title: '创建定时任务', hint: '正在创建定时任务', aliases: ['cron_add', 'add_timer'] },
-    'openclaw-workclaw-cron-update-params': { emoji: '🔧', title: '修改定时任务', hint: '正在修改定时任务', aliases: ['cron_update', 'update_timer'] },
-    'openclaw-workclaw-cron-remove-params': { emoji: '🗑️', title: '删除定时任务', hint: '正在删除定时任务', aliases: ['cron_remove', 'remove_timer'] },
-    'openclaw-workclaw-cron-notify-sync': { emoji: '🔔', title: '定时触发通知', hint: '定时任务已触发', aliases: ['cron_trigger', 'notify'] },
-    'openclaw-workclaw-cron-add-sync': { emoji: '✅', title: '同步定时任务', hint: '正在同步到后端', aliases: [] },
-    'openclaw-workclaw-cron-update-sync': { emoji: '✅', title: '同步定时更新', hint: '正在同步更新', aliases: [] },
-    'openclaw-workclaw-cron-remove-sync': { emoji: '✅', title: '同步定时删除', hint: '正在同步删除', aliases: [] },
-    'openclaw-workclaw-cron-disable-params': { emoji: '⏸️', title: '禁用定时任务', hint: '正在禁用定时任务', aliases: ['cron_disable'] },
-    'openclaw-workclaw-cron-enable-params': { emoji: '▶️', title: '启用定时任务', hint: '正在启用定时任务', aliases: ['cron_enable'] },
+    "openclaw-workclaw-cron-add-params": { emoji: "⏱️", title: "创建定时任务", hint: "正在创建定时任务", aliases: ["cron_add", "add_timer"] },
+    "openclaw-workclaw-cron-update-params": { emoji: "🔧", title: "修改定时任务", hint: "正在修改定时任务", aliases: ["cron_update", "update_timer"] },
+    "openclaw-workclaw-cron-remove-params": { emoji: "🗑️", title: "删除定时任务", hint: "正在删除定时任务", aliases: ["cron_remove", "remove_timer"] },
+    "openclaw-workclaw-cron-notify-sync": { emoji: "🔔", title: "定时触发通知", hint: "定时任务已触发", aliases: ["cron_trigger", "notify"] },
+    "openclaw-workclaw-cron-add-sync": { emoji: "✅", title: "同步定时任务", hint: "正在同步到后端", aliases: [] },
+    "openclaw-workclaw-cron-update-sync": { emoji: "✅", title: "同步定时更新", hint: "正在同步更新", aliases: [] },
+    "openclaw-workclaw-cron-remove-sync": { emoji: "✅", title: "同步定时删除", hint: "正在同步删除", aliases: [] },
+    "openclaw-workclaw-cron-disable-params": { emoji: "⏸️", title: "禁用定时任务", hint: "正在禁用定时任务", aliases: ["cron_disable"] },
+    "openclaw-workclaw-cron-enable-params": { emoji: "▶️", title: "启用定时任务", hint: "正在启用定时任务", aliases: ["cron_enable"] },
 
     // 📊 其他
-    'session_status': { emoji: '📊', title: '会话状态', hint: '正在获取会话状态', aliases: ['status', 'get_status'] },
-    'canvas': { emoji: '🎨', title: '画布控制', hint: '正在控制画布', aliases: ['canvas_control', 'draw'] },
-  }
+    session_status: { emoji: "📊", title: "会话状态", hint: "正在获取会话状态", aliases: ["status", "get_status"] },
+    canvas: { emoji: "🎨", title: "画布控制", hint: "正在控制画布", aliases: ["canvas_control", "draw"] },
+  };
 
   // 精确匹配
   if (toolMap[normalizedToolName]) {
-    const tool = toolMap[normalizedToolName]
-    return `${tool.emoji} ${tool.hint}...`
+    const tool = toolMap[normalizedToolName];
+    return `${tool.emoji} ${tool.hint}...`;
   }
 
   // 别名匹配
-  for (const [_, tool] of Object.entries(toolMap)) {
+  for (const [key, tool] of Object.entries(toolMap)) {
     if (tool.aliases.includes(normalizedToolName)) {
-      return `${tool.emoji} ${tool.hint}...`
+      return `${tool.emoji} ${tool.hint}...`;
     }
   }
 
   // 默认
-  return `🔄 正在执行 ${toolName}...`
+  return `🔄 正在执行 ${toolName}...`;
 }
 
 /**
  * 获取工具执行完成的提示（用于 after_tool_call）
  */
 export function getToolResultHint(toolName: string | undefined): string {
-  if (!toolName)
-    return '✅ 工具执行完成'
+  if (!toolName) return "✅ 工具执行完成";
 
-  const normalizedToolName = toolName.toLowerCase().trim()
+  const normalizedToolName = toolName.toLowerCase().trim();
 
   const toolMap: Record<string, ToolInfo> = {
     // 📁 文件操作
-    'read': { emoji: '📖', title: '读取文件', hint: '已读取文件', aliases: ['file_read', 'read_file'] },
-    'write': { emoji: '✍️', title: '写入文件', hint: '已写入文件', aliases: ['file_write', 'write_file'] },
-    'edit': { emoji: '✏️', title: '编辑文件', hint: '已编辑文件', aliases: ['file_edit', 'modify'] },
+    read: { emoji: "📖", title: "读取文件", hint: "已读取文件", aliases: ["file_read", "read_file"] },
+    write: { emoji: "✍️", title: "写入文件", hint: "已写入文件", aliases: ["file_write", "write_file"] },
+    edit: { emoji: "✏️", title: "编辑文件", hint: "已编辑文件", aliases: ["file_edit", "modify"] },
 
     // 💻 系统命令
-    'exec': { emoji: '⚡', title: '执行命令', hint: '已执行命令', aliases: ['bash', 'shell', 'cmd', 'command'] },
-    'process': { emoji: '🔄', title: '进程管理', hint: '已处理进程', aliases: ['process_manager'] },
+    exec: { emoji: "⚡", title: "执行命令", hint: "已执行命令", aliases: ["bash", "shell", "cmd", "command"] },
+    process: { emoji: "🔄", title: "进程管理", hint: "已处理进程", aliases: ["process_manager"] },
 
     // 🌐 网络/浏览器
-    'web_fetch': { emoji: '🕸️', title: '获取网页', hint: '已获取网页', aliases: ['fetch', 'http_get', 'http_request', 'curl'] },
-    'web_search': { emoji: '🔍', title: '搜索网页', hint: '已搜索网页', aliases: ['search', 'google_search', 'brave_search'] },
-    'browser': { emoji: '🌐', title: '浏览器控制', hint: '已控制浏览器', aliases: ['browser_control', 'playwright'] },
+    web_fetch: { emoji: "🕸️", title: "获取网页", hint: "已获取网页", aliases: ["fetch", "http_get", "http_request", "curl"] },
+    web_search: { emoji: "🔍", title: "搜索网页", hint: "已搜索网页", aliases: ["search", "google_search", "brave_search"] },
+    browser: { emoji: "🌐", title: "浏览器控制", hint: "已控制浏览器", aliases: ["browser_control", "playwright"] },
 
     // 💬 消息/通信
-    'message': { emoji: '💌', title: '发送消息', hint: '已发送消息', aliases: ['send_message', 'mcp_deliver', 'deliver', 'notify'] },
-    'tts': { emoji: '🔊', title: '文字转语音', hint: '已转换语音', aliases: ['text_to_speech', 'speak'] },
+    message: { emoji: "💌", title: "发送消息", hint: "已发送消息", aliases: ["send_message", "mcp_deliver", "deliver", "notify"] },
+    tts: { emoji: "🔊", title: "文字转语音", hint: "已转换语音", aliases: ["text_to_speech", "speak"] },
 
     // 🎭 会话管理
-    'sessions_spawn': { emoji: '🧬', title: '创建子代理', hint: '已创建子代理', aliases: ['spawn', 'create_agent', 'new_session'] },
-    'sessions_send': { emoji: '📤', title: '跨会话发消息', hint: '已发送跨会话消息', aliases: ['send_to_session', 'forward'] },
-    'sessions_list': { emoji: '📋', title: '列出会话', hint: '已列出会话', aliases: ['list_sessions'] },
-    'sessions_history': { emoji: '📜', title: '获取历史', hint: '已获取历史消息', aliases: ['get_history', 'history'] },
-    'sessions_yield': { emoji: '⏸️', title: '暂停让出', hint: '已暂停等待', aliases: ['yield', 'pause'] },
-    'subagents': { emoji: '🐛', title: '子代理管理', hint: '已管理子代理', aliases: ['subagent_manager'] },
-    'agents_list': { emoji: '🤖', title: '列出代理', hint: '已列出代理', aliases: ['list_agents'] },
+    sessions_spawn: { emoji: "🧬", title: "创建子代理", hint: "已创建子代理", aliases: ["spawn", "create_agent", "new_session"] },
+    sessions_send: { emoji: "📤", title: "跨会话发消息", hint: "已发送跨会话消息", aliases: ["send_to_session", "forward"] },
+    sessions_list: { emoji: "📋", title: "列出会话", hint: "已列出会话", aliases: ["list_sessions"] },
+    sessions_history: { emoji: "📜", title: "获取历史", hint: "已获取历史消息", aliases: ["get_history", "history"] },
+    sessions_yield: { emoji: "⏸️", title: "暂停让出", hint: "已暂停等待", aliases: ["yield", "pause"] },
+    subagents: { emoji: "🐛", title: "子代理管理", hint: "已管理子代理", aliases: ["subagent_manager"] },
+    agents_list: { emoji: "🤖", title: "列出代理", hint: "已列出代理", aliases: ["list_agents"] },
 
     // 🧠 记忆/知识
-    'memory_search': { emoji: '🔎', title: '搜索记忆', hint: '已搜索记忆', aliases: ['search_memory', 'recall'] },
-    'memory_get': { emoji: '📝', title: '读取记忆', hint: '已读取记忆', aliases: ['get_memory', 'read_memory'] },
+    memory_search: { emoji: "🔎", title: "搜索记忆", hint: "已搜索记忆", aliases: ["search_memory", "recall"] },
+    memory_get: { emoji: "📝", title: "读取记忆", hint: "已读取记忆", aliases: ["get_memory", "read_memory"] },
 
     // ⏰ 定时任务
-    'openclaw-workclaw-cron-add-params': { emoji: '⏱️', title: '创建定时任务', hint: '已创建定时任务', aliases: ['cron_add', 'add_timer'] },
-    'openclaw-workclaw-cron-update-params': { emoji: '🔧', title: '修改定时任务', hint: '已修改定时任务', aliases: ['cron_update', 'update_timer'] },
-    'openclaw-workclaw-cron-remove-params': { emoji: '🗑️', title: '删除定时任务', hint: '已删除定时任务', aliases: ['cron_remove', 'remove_timer'] },
-    'openclaw-workclaw-cron-notify-sync': { emoji: '🔔', title: '定时触发通知', hint: '定时任务已触发', aliases: ['cron_trigger', 'notify'] },
-    'openclaw-workclaw-cron-add-sync': { emoji: '✅', title: '同步定时任务', hint: '已同步定时任务', aliases: [] },
-    'openclaw-workclaw-cron-update-sync': { emoji: '✅', title: '同步定时更新', hint: '已同步更新', aliases: [] },
-    'openclaw-workclaw-cron-remove-sync': { emoji: '✅', title: '同步定时删除', hint: '已同步删除', aliases: [] },
-    'openclaw-workclaw-cron-disable-params': { emoji: '⏸️', title: '禁用定时任务', hint: '已禁用定时任务', aliases: ['cron_disable'] },
-    'openclaw-workclaw-cron-enable-params': { emoji: '▶️', title: '启用定时任务', hint: '已启用定时任务', aliases: ['cron_enable'] },
+    "openclaw-workclaw-cron-add-params": { emoji: "⏱️", title: "创建定时任务", hint: "已创建定时任务", aliases: ["cron_add", "add_timer"] },
+    "openclaw-workclaw-cron-update-params": { emoji: "🔧", title: "修改定时任务", hint: "已修改定时任务", aliases: ["cron_update", "update_timer"] },
+    "openclaw-workclaw-cron-remove-params": { emoji: "🗑️", title: "删除定时任务", hint: "已删除定时任务", aliases: ["cron_remove", "remove_timer"] },
+    "openclaw-workclaw-cron-notify-sync": { emoji: "🔔", title: "定时触发通知", hint: "定时任务已触发", aliases: ["cron_trigger", "notify"] },
+    "openclaw-workclaw-cron-add-sync": { emoji: "✅", title: "同步定时任务", hint: "已同步定时任务", aliases: [] },
+    "openclaw-workclaw-cron-update-sync": { emoji: "✅", title: "同步定时更新", hint: "已同步更新", aliases: [] },
+    "openclaw-workclaw-cron-remove-sync": { emoji: "✅", title: "同步定时删除", hint: "已同步删除", aliases: [] },
+    "openclaw-workclaw-cron-disable-params": { emoji: "⏸️", title: "禁用定时任务", hint: "已禁用定时任务", aliases: ["cron_disable"] },
+    "openclaw-workclaw-cron-enable-params": { emoji: "▶️", title: "启用定时任务", hint: "已启用定时任务", aliases: ["cron_enable"] },
 
     // 📊 其他
-    'session_status': { emoji: '📊', title: '会话状态', hint: '已获取会话状态', aliases: ['status', 'get_status'] },
-    'canvas': { emoji: '🎨', title: '画布控制', hint: '已控制画布', aliases: ['canvas_control', 'draw'] },
-  }
+    session_status: { emoji: "📊", title: "会话状态", hint: "已获取会话状态", aliases: ["status", "get_status"] },
+    canvas: { emoji: "🎨", title: "画布控制", hint: "已控制画布", aliases: ["canvas_control", "draw"] },
+  };
 
   // 精确匹配
   if (toolMap[normalizedToolName]) {
-    const tool = toolMap[normalizedToolName]
-    return `${tool.emoji} ${tool.hint}`
+    const tool = toolMap[normalizedToolName];
+    return `${tool.emoji} ${tool.hint}`;
   }
 
   // 别名匹配
-  for (const [_, tool] of Object.entries(toolMap)) {
+  for (const [key, tool] of Object.entries(toolMap)) {
     if (tool.aliases.includes(normalizedToolName)) {
-      return `${tool.emoji} ${tool.hint}`
+      return `${tool.emoji} ${tool.hint}`;
     }
   }
 
   // 默认
-  return `✅ 已执行 ${toolName}`
-}
+  return `✅ 已执行 ${toolName}`;
+}