@workclaw/openclaw-workclaw 1.0.25 → 1.0.26

package/src/gateway/message-dispatcher.ts

@@ -1,688 +0,0 @@
-/**
- * Message Dispatcher - handles all WorkClaw WebSocket message types
- */
-
-import type { ResolvedWorkclawAccount, WorkClawAccountConfig, WorkClawBaseConfig } from '../types.js'
-import type { InboundMessage, ParseWorkClawResult } from './message-context.js'
-
-import { maybeResolveTextAlias, resolveNativeCommandSessionTargets } from 'openclaw/plugin-sdk/command-auth'
-import { request } from 'undici'
-import { resolveAccountByUserIdAndAgentId, resolveWorkclawAccountWithCache } from '../accounts.js'
-import { getWorkclawAccessToken, getWorkclawModelConfigByAppKey } from '../connection/workclaw-client.js'
-import { sendMessageWorkclaw } from '../outbound/index.js'
-import { getWorkclawRuntime, getWorkclawWsConnection, setToolContext } from '../runtime.js'
-
-import { handleAgentCreated, handleAgentDeleted, handleAgentUpdated } from './agent-handlers.js'
-import { initWorkclawAgent, saveOpenConversationId } from './config-writer.js'
-import { buildInboundContext, parseWorkClawMessage } from './message-context.js'
-
-import { handleSkillsEvent } from './skills-handler.js'
-import { handleSkillsListEvent as doHandleSkillsListEvent } from './skills-list-handler.js'
-import { handleToolsListEvent as doHandleToolsListEvent } from './tools-list-handler.js'
-
-export interface MessageDispatcherContext {
-  accountId: string
-  account: ResolvedWorkclawAccount
-  cfg: any
-  baseConfig: WorkClawBaseConfig
-  accountConfig: WorkClawAccountConfig
-  log?: {
-    info?: (msg: string) => void
-    warn?: (msg: string) => void
-    error?: (msg: string) => void
-    debug?: (msg: string) => void
-  }
-  scheduleReconnect: () => void
-}
-
-/** Log an error safely */
-function logError(log: MessageDispatcherContext['log'], context: string, err: unknown): void {
-  const errAny = err as { stack?: string }
-  const stack = typeof errAny?.stack === 'string' ? `\nStack: ${errAny.stack}` : ''
-  log?.error?.(`Dispatcher ${context}: ${String(err)}${stack}`)
-}
-
-// ---------------------------------------------------------------------------
-// Individual message handlers
-// ---------------------------------------------------------------------------
-
-async function handlePing(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-  const { accountId, log } = ctx
-  const ws = getWorkclawWsConnection(accountId)
-  if (!ws)
-    return
-
-  try {
-    const pongResponse = {
-      code: 200,
-      message: 'pong',
-      metadata: { contentType: 'application/json' },
-      data: JSON.stringify(result.pongData),
-    }
-    ws.send(JSON.stringify(pongResponse))
-    log?.debug?.(`pong`)
-  }
-  catch (err) {
-    logError(log, 'Failed to send pong', err)
-  }
-}
-
-async function handleDisconnect(ctx: MessageDispatcherContext): Promise<void> {
-  const { accountId, log, scheduleReconnect } = ctx
-  const ws = getWorkclawWsConnection(accountId)
-  if (ws) {
-    try {
-      ws.close()
-      log?.info?.(`Closed WebSocket due to disconnect command`)
-    }
-    catch (err) {
-      logError(log, 'Failed to close WebSocket', err)
-    }
-  }
-  else {
-    log?.info?.(`WebSocket already cleared, triggering reconnect...`)
-    scheduleReconnect()
-  }
-}
-
-async function handleAgentEvent(
-  ctx: MessageDispatcherContext,
-  result: ParseWorkClawResult,
-): Promise<void> {
-  const { cfg, log, baseConfig, accountId } = ctx
-  const eventData = result.eventData
-  if (!eventData) {
-    log?.warn?.(`Received ${result.type} event but no data`)
-    return
-  }
-
-  const agentId = String(eventData.id || '')
-  const userId = String(eventData.futureId || '')
-
-  if (!agentId) {
-    log?.warn?.(`Received ${result.type} event but missing agent id`)
-    return
-  }
-
-  log?.info?.(`Processing ${result.type} event for agent ${agentId}, userId: ${userId}`)
-
-  const accountData = {
-    agentId,
-    userId,
-    nickName: eventData.nickName,
-    phone: eventData.phone,
-    status: eventData.status,
-    introduction: eventData.introduction,
-    name: eventData.name,
-    tip: eventData.tip,
-    characterSettings: eventData.characterSettings,
-    personFeatures: eventData.personFeatures,
-    workFeatures: eventData.workFeatures,
-    learningFeatures: eventData.learningFeatures,
-    socializeFeatures: eventData.socializeFeatures,
-    job: eventData.job,
-    city: eventData.city,
-  }
-
-  switch (result.type) {
-    case 'agent_created':
-      await handleAgentCreated(accountData, cfg, log)
-      handleAgentCreatedMessage(baseConfig, agentId, accountId, log)
-      break
-    case 'agent_updated':
-      await handleAgentUpdated(accountData, cfg, log)
-      break
-    case 'agent_deleted':
-      await handleAgentDeleted(accountData, cfg, log)
-      break
-  }
-}
-
-async function handleSkillsProcessingEvent(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-  const { accountId, baseConfig, log } = ctx
-  if (!result.eventData)
-    return
-  try {
-    const connConfig = {
-      baseUrl: baseConfig.baseUrl || '',
-      websocketUrl: baseConfig.websocketUrl,
-      appKey: baseConfig.appKey,
-      appSecret: baseConfig.appSecret,
-      localIp: baseConfig.localIp,
-      allowInsecureTls: baseConfig.allowInsecureTls,
-      requestTimeout: baseConfig.requestTimeout,
-    }
-    const tokenCacheKey = baseConfig.appKey || accountId
-    const token = await getWorkclawAccessToken(tokenCacheKey, connConfig)
-    await handleSkillsEvent(result.eventData, token, connConfig.baseUrl, connConfig.appKey || accountId, log)
-  }
-  catch (err) {
-    logError(log, 'handleSkillsEvent failed', err)
-  }
-}
-
-async function handleToolsListEvent(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-  const { accountId, baseConfig, log } = ctx
-  if (!result.eventData)
-    return
-  try {
-    const connConfig = {
-      baseUrl: baseConfig.baseUrl || '',
-      websocketUrl: baseConfig.websocketUrl,
-      appKey: baseConfig.appKey,
-      appSecret: baseConfig.appSecret,
-      localIp: baseConfig.localIp,
-      allowInsecureTls: baseConfig.allowInsecureTls,
-      requestTimeout: baseConfig.requestTimeout,
-    }
-    const tokenCacheKey = baseConfig.appKey || accountId
-    const token = await getWorkclawAccessToken(tokenCacheKey, connConfig)
-    await doHandleToolsListEvent(result.eventData, connConfig.baseUrl, token, log)
-  }
-  catch (err) {
-    logError(log, 'handleToolsListEvent failed', err)
-  }
-}
-
-async function handleSkillsListEvent(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-  const { accountId, baseConfig, log } = ctx
-  if (!result.eventData)
-    return
-  try {
-    const connConfig = {
-      baseUrl: baseConfig.baseUrl || '',
-      websocketUrl: baseConfig.websocketUrl,
-      appKey: baseConfig.appKey,
-      appSecret: baseConfig.appSecret,
-      localIp: baseConfig.localIp,
-      allowInsecureTls: baseConfig.allowInsecureTls,
-      requestTimeout: baseConfig.requestTimeout,
-    }
-    const tokenCacheKey = baseConfig.appKey || accountId
-    const token = await getWorkclawAccessToken(tokenCacheKey, connConfig)
-    await doHandleSkillsListEvent(result.eventData, connConfig.baseUrl, token, log)
-  }
-  catch (err) {
-    logError(log, 'handleSkillsListEvent failed', err)
-  }
-}
-
-async function handleInitAgentEvent(
-  ctx: MessageDispatcherContext,
-  result: ParseWorkClawResult,
-): Promise<void> {
-  const { accountId, cfg, baseConfig, log } = ctx
-  const initStartedAt = Date.now()
-  const eventData = result.eventData
-
-  if (!eventData) {
-    log?.warn?.(`init_agent received but no data`)
-    return
-  }
-
-  log?.info?.(
-    `init_agent accountId=${accountId} eventDataType=${typeof eventData} preview=${JSON.stringify(eventData).slice(0, 200)}`,
-  )
-
-  const connConfig = {
-    baseUrl: baseConfig.baseUrl || '',
-    websocketUrl: baseConfig.websocketUrl,
-    appKey: baseConfig.appKey,
-    appSecret: baseConfig.appSecret,
-    localIp: baseConfig.localIp,
-    allowInsecureTls: baseConfig.allowInsecureTls,
-    requestTimeout: baseConfig.requestTimeout,
-  }
-
-  // Fetch apiKey and init agent config in one write
-  try {
-    const tokenCacheKey = baseConfig.appKey || accountId
-    const { baseUrl: modelBaseUrl, apiKey } = await getWorkclawModelConfigByAppKey(tokenCacheKey, connConfig)
-    const maskedKey = apiKey ? `${String(apiKey).slice(0, 6)}...(${String(apiKey).length})` : 'missing'
-
-    log?.info?.(`init_agent model fetched baseUrl=${modelBaseUrl} apiKey=${maskedKey}`)
-
-    const agentId = String(eventData?.id || eventData?.agentId || '')
-    const userId = String(eventData?.futureId || eventData?.userId || '')
-
-    await initWorkclawAgent({ apiKey, agentId, userId, accountId: 'default' }, cfg, log)
-    log?.info?.(`init_agent config saved elapsedMs=${Date.now() - initStartedAt}`)
-  }
-  catch (err) {
-    logError(log, 'init_agent failed', err)
-  }
-
-  log?.info?.(`init_agent handled elapsedMs=${Date.now() - initStartedAt}`)
-}
-
-async function handleCronTaskEvent(ctx: MessageDispatcherContext, result: ParseWorkClawResult): Promise<void> {
-  const { accountId, baseConfig, log } = ctx
-  if (!result.cronTaskEvent)
-    return
-  try {
-    const { handleCronTaskEvent } = await import('./cron-tasks-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 getWorkclawAccessToken(tokenCacheKey, connConfig)
-    await handleCronTaskEvent(result.cronTaskEvent, token, connConfig.baseUrl, connConfig.appKey || accountId, log)
-  }
-  catch (err) {
-    logError(log, 'handleCronTaskEvent failed', err)
-  }
-}
-
-async function handleAgentMessage(
-  ctx: MessageDispatcherContext,
-  data: string,
-  result: ParseWorkClawResult,
-): Promise<void> {
-  const { accountId, account, cfg, accountConfig, log } = ctx
-  const { message } = result
-  if (!message)
-    return
-
-  // 这里的msgAgentId是云平台的agentId
-  const { text, userId, openConversationId, messageId: parsedMessageId, agentId: msgAgentId } = message
-
-  // Resolve account from message
-  let messageAccountId = accountId
-  let messageAccount = account
-
-  if (userId && msgAgentId) {
-    const resolvedAccountId = resolveAccountByUserIdAndAgentId(cfg, String(userId), String(msgAgentId))
-    if (resolvedAccountId) {
-      const resolved = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId })
-      messageAccountId = resolvedAccountId
-      messageAccount = resolved
-      log?.info?.(`Resolved account ${resolvedAccountId} from message (userId=${userId}, agentId=${msgAgentId})`)
-    }
-    else if (String(msgAgentId) !== String(accountConfig.agentId)) {
-      log?.warn?.(`Account not found for userId=${userId}, agentId=${msgAgentId}, ignoring`)
-      return
-    }
-  }
-
-  const resolvedAccountConfig = messageAccount.config as unknown as WorkClawAccountConfig
-  const msgAgentIdResolved = msgAgentId ?? accountConfig.agentId
-
-  // Save openConversationId if new
-  if (openConversationId && openConversationId !== resolvedAccountConfig.openConversationId) {
-    try {
-      await saveOpenConversationId(messageAccountId, userId, openConversationId, cfg, log)
-      log?.info?.(`Saved openConversationId ${openConversationId} to account ${messageAccountId}`)
-    }
-    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
-  }
-
-  // Route via bindings
-  const bindings = cfg?.bindings ?? []
-  let targetAgentId = 'default'
-  const matchedBinding = bindings.find((binding: any) => {
-    const match = binding?.match
-    if (!match || match.channel !== 'openclaw-workclaw')
-      return false
-    return match.accountId === messageAccountId || match.accountId === '*'
-  })
-  if (matchedBinding) {
-    targetAgentId = matchedBinding.agentId
-    log?.info?.(`Routing to agent ${targetAgentId} via binding (account: ${messageAccountId})`)
-  }
-
-  if (!targetAgentId) {
-    log?.warn?.(`Missing target, ignoring`)
-    return
-  }
-
-  // 构建用于解析 sessionKey 的消息对象
-  // to = agentId (智能体/机器人), from = userId (用户)
-  const attachments = message.attachments
-  const inboundMessage: InboundMessage = {
-    text: bodyText,
-    to,
-    from: userId,
-    chatType: 'dm',
-    messageId: parsedMessageId,
-    rawPayload: data,
-    timestamp: Date.now(),
-    attachments,
-  }
-  log?.info?.(`handleAgentMessage: text=${bodyText?.substring(0, 50)}, attachments=${attachments?.length || 0}, rawPayload=${data.substring(0, 300)}`)
-  const pluginRuntime = getWorkclawRuntime()
-
-  // 检测是否是框架命令（如 /new）
-  const textForCommandCheck = bodyText?.replace(/^\[引用[^\]]*\]\s*/, '').trim() || ''
-  const resolvedCommand = maybeResolveTextAlias(textForCommandCheck, messageAccount.config as any)
-  const isFrameworkCommand = resolvedCommand !== null
-  if (isFrameworkCommand) {
-    log?.info?.(`[DELIVER] Framework command detected: ${bodyText}, will set CommandSource=native`)
-  }
-
-  // 使用扩展后的 buildInboundContext，它会处理完整的 session 流程
-  const finalized = await buildInboundContext(
-    inboundMessage,
-    messageAccountId,
-    messageAccount.config,
-    targetAgentId,
-    pluginRuntime,
-    true,
-    log,
-  )
-
-  // 如果是框架命令，设置 CommandSource 等字段，让 OpenClaw 框架识别为原生命令
-  if (isFrameworkCommand) {
-    const targetSessionKey = finalized.SessionKey as string
-    const { sessionKey: commandSessionKey, commandTargetSessionKey } = resolveNativeCommandSessionTargets({
-      agentId: targetAgentId,
-      sessionPrefix: 'openclaw-workclaw:new',
-      userId: String(userId ?? ''),
-      targetSessionKey,
-    });
-    (finalized as any).SessionKey = commandSessionKey;
-    (finalized as any).CommandTargetSessionKey = commandTargetSessionKey;
-    (finalized as any).CommandSource = 'native';
-    (finalized as any).CommandAuthorized = true
-    log?.info?.(`[DELIVER] Set CommandSource=native, commandSessionKey=${commandSessionKey}, targetSessionKey=${targetSessionKey}`)
-  }
-
-  // 维护当前工具名称状态
-  let currentToolName: string | null = null
-  // 追踪是否有文本被 deliver 过
-  let textDelivered = false
-
-  // 发送工具消息的辅助函数
-  const sendToolMessage = async (text: string, isStart: boolean = false) => {
-    try {
-      await sendMessageWorkclaw({
-        cfg,
-        to,
-        text,
-        accountId: messageAccountId,
-        openConversationId: resolvedOpenConversationId,
-        agentId: msgAgentIdResolved,
-        replyToMessageId: parsedMessageId,
-        last: false,
-        source: 'deliver',
-      })
-    }
-    catch (err) {
-      logError(log, isStart ? 'Tool start message send failed' : 'Tool result message send failed', err)
-    }
-  }
-
-  await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-    ctx: finalized,
-    cfg,
-    replyOptions: {
-      onAgentRunStart(runId: string) {
-        // 保存 runId 和 ctx 的关联，供 hook 使用
-        setToolContext(runId, {
-          target: targetAgentId,
-          replyToMessageId: parsedMessageId,
-          openConversationId: resolvedOpenConversationId,
-          accountId: messageAccountId,
-          agentId: String(msgAgentIdResolved),
-          sessionKey: (finalized.SessionKey as string) || '',
-        })
-        log?.info?.(`[AGENT] onAgentRunStart: runId=${runId} target=${targetAgentId}`)
-      },
-      /* onToolStart(payload) {
-                log?.info?.(`[AGENT] onToolStart: ${JSON.stringify(payload)}`);
-                if (payload.phase === "start") {
-                    currentToolName = payload.name ?? null;
-                    const hint = getToolStartHint(currentToolName);
-                    log?.info?.(`[TOOL] Starting tool: ${currentToolName}, sending hint: ${hint}`);
-                    sendToolMessage(hint, true).catch((err) => {
-                        logError(log, "Tool start hint send failed", err);
-                    });
-                }
-            } */
-    },
-    dispatcherOptions: {
-      deliver: async (payload: any, info?: any) => {
-        const resolvedReplyToId = payload?.replyToId || parsedMessageId
-        const textOut = String(payload.text ?? payload.body ?? '')
-        const target = to || String(payload.to ?? '')
-        const kind = info?.kind
-
-        if (!target) {
-          log?.warn?.(`[DELIVER] skip: no target`)
-          return
-        }
-
-        if (kind === 'tool') {
-          // 工具结果已在工具 hook 中处理，此处跳过避免重复
-          return
-        }
-
-        if (!textOut.trim()) {
-          log?.warn?.(`[DELIVER] skip: empty text (kind=${kind})`)
-          return
-        }
-
-        // 处理工具类型的 deliver
-        /* if (info?.kind === "tool") {
-                    // log?.info?.(`[DELIVER] tool reply: ${JSON.stringify(payload)}`);
-                    const toolText = payload.text ?? "";
-                    if (toolText.trim()) {
-                        // 使用 formattedToolOutput 格式发送
-                        try {
-                            await sendMessageWorkclaw({
-                                cfg,
-                                to: targetAgentId,
-                                text: JSON.stringify({
-                                    name: currentToolName || "Unknown",
-                                    content: toolText,
-                                    state: "result",
-                                }),
-                                msgType: "26",
-                                accountId: messageAccountId,
-                                openConversationId: resolvedOpenConversationId,
-                                agentId: msgAgentIdResolved,
-                                replyToMessageId: parsedMessageId,
-                            });
-                        } catch (err) {
-                            logError(log, "Tool result send failed", err);
-                        }
-                    }
-                    return;
-                } */
-
-        // last: true 统一由最后的 fallback 兜底发送，deliver 阶段全部传 false 避免重复触发
-        try {
-          const result = await sendMessageWorkclaw({
-            cfg,
-            to: target,
-            text: textOut,
-            accountId: messageAccountId,
-            openConversationId: resolvedOpenConversationId,
-            agentId: msgAgentIdResolved,
-            replyToMessageId: resolvedReplyToId,
-            last: false,
-            source: 'deliver',
-          })
-          textDelivered = true
-          log?.info?.(`[DELIVER] sent "${textOut.substring(0, 80)}" (last=false) kind=${kind} msgId=${result.messageId}`)
-        }
-        catch (err) {
-          logError(log, 'Reply send failed', err)
-          throw err
-        }
-      },
-    },
-  })
-
-  currentToolName = null
-
-  // 原始消息是命令但 AI 没有回复文本时，发送"命令已执行"确认
-  if (!textDelivered && bodyText?.startsWith('/')) {
-    log?.info?.(`[DELIVER] command ${bodyText} executed with no text reply, sending confirmation`)
-    try {
-      await sendMessageWorkclaw({
-        cfg,
-        to: to || String(userId || ''),
-        text: `${bodyText} 已执行`,
-        accountId: messageAccountId,
-        openConversationId: resolvedOpenConversationId,
-        agentId: msgAgentIdResolved,
-        replyToMessageId: parsedMessageId,
-        last: false,
-        source: 'deliver',
-      })
-    }
-    catch (err) {
-      logError(log, 'Command confirmation send failed', err)
-    }
-  }
-
-  // last: true 结束信号：每次回复最后都发，确保对话结束
-  log?.info?.(`[DELIVER] sending last=true end signal`)
-  try {
-    await sendMessageWorkclaw({
-      cfg,
-      to: to || String(userId || ''),
-      text: '',
-      accountId: messageAccountId,
-      openConversationId: resolvedOpenConversationId,
-      agentId: msgAgentIdResolved,
-      replyToMessageId: parsedMessageId,
-      last: true,
-      source: 'deliver',
-    })
-  }
-  catch (err) {
-    const errStr = String(err)
-    if (errStr.includes("content can't be empty")) {
-      log?.info?.(`[DELIVER] last=true skipped (empty content not supported)`)
-    }
-    else {
-      logError(log, 'last=true signal send failed', err)
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Main dispatcher
-// ---------------------------------------------------------------------------
-
-export async function dispatchWorkclawMessage(
-  data: string,
-  ctx: MessageDispatcherContext,
-): Promise<void> {
-  const { log } = ctx
-
-  const rawHasAuthToken
-    = data.includes('authToken')
-      || data.toLowerCase().includes('authorization')
-      || data.toLowerCase().includes('bearer ')
-  const rawPreview = data.length > 300 ? `${data.slice(0, 300)}...` : data
-  /* log?.info?.(
-        `Raw message bytes=${data.length} hasAuthToken=${rawHasAuthToken} preview=${rawPreview}`,
-    ); */
-
-  const result = parseWorkClawMessage(data, log)
-  if (!result) {
-    log?.warn?.(`Failed to parse message`)
-    return
-  }
-
-  log?.info?.(`Message type=${result.type}`)
-
-  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 'cron_task_event':
-      await handleCronTaskEvent(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 base = baseConfig.baseUrl.replace(/\/$/, '') // 去掉末尾多余的 /
-    const callbackUrl = `${base}/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 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)}`)
-  }
-}