@workclaw/openclaw-workclaw 1.0.20 → 1.0.23

package/src/gateway/message-dispatcher.ts

@@ -0,0 +1,688 @@
+/**
+ * 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)}`)
+  }
+}