@workclaw/openclaw-workclaw 1.0.32 → 1.0.33

package/dist/packages/plugin/src/gateway/message-dispatcher.js

@@ -0,0 +1,517 @@
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/command-registration-Dxq1bCXM.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/utils-DGFSjtQF.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/ids-By7Nkc8R.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/registry-DE4nHTjg.js";
+import { n as maybeResolveTextAlias } from "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/commands-registry-normalize-Bk0WYUI0.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/strip-inbound-meta-WCHWW8is.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/bundled-Cuj8sKt6.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/subsystem-BHv2zSx6.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/paths-LCYGfrV7.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/workspace-oVBetctb.js";
+import "node:fs";
+import "node:path";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/model-selection-cli-U7l5Ifek.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/message-channel-DXsjCySM.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/facade-runtime-B04URCVZ.js";
+import "node:os";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/file-lock-D016H3tC.js";
+import "node:fs/promises";
+import "node:crypto";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/logger-BMuqDP66.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/theme-CVJvORNs.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/runtime-Clo2XF6T.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/conversation-binding-C3EIaK9Z.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/dispatch-2DAqwFVE.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/exec-defaults-DBnaZeLQ.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/skills-Djbt9HGh.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/io-DDkf_FUu.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/models-config-B-YHRI3g.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/redact-D4nea1HF.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/provider-runtime-O-n0cjZo.js";
+import "node:child_process";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/host-env-security-B-Ebh6At.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/provider-env-vars-DDfJbkrO.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/setup-registry-BPL6c_Zk.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/model-auth-markers-YVQDqG1J.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/auth-profiles-Db4Eg6ht.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/order-6WHL2fZu.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/version-b06Uhxnq.js";
+import "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/bundled-dir-Cq5y_NKM.js";
+import "node:process";
+import { t as resolveNativeCommandSessionTargets } from "../../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/native-command-session-targets-BW3SPx-T.js";
+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, setToolContext, getWorkclawWsConnection } from "../../../../src/runtime.js";
+import { handleAgentDeleted, handleAgentUpdated, handleAgentCreated } from "./agent-handlers.js";
+import { saveOpenConversationId, initWorkclawAgent } from "./config-writer.js";
+import { parseWorkClawMessage, buildInboundContext } from "./message-context.js";
+import { handleSkillsEvent } from "./skills-handler.js";
+import { handleSkillsListEvent as handleSkillsListEvent$1 } from "./skills-list-handler.js";
+import { handleToolsListEvent as handleToolsListEvent$1 } from "./tools-list-handler.js";
+function logError(log, context, err) {
+  const errAny = err;
+  const stack = typeof errAny?.stack === "string" ? `
+Stack: ${errAny.stack}` : "";
+  log?.error?.(`Dispatcher ${context}: ${String(err)}${stack}`);
+}
+async function handlePing(ctx, result) {
+  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) {
+  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, result) {
+  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, result) {
+  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, result) {
+  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 handleToolsListEvent$1(result.eventData, connConfig.baseUrl, token, log);
+  } catch (err) {
+    logError(log, "handleToolsListEvent failed", err);
+  }
+}
+async function handleSkillsListEvent(ctx, result) {
+  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 handleSkillsListEvent$1(result.eventData, connConfig.baseUrl, token, log);
+  } catch (err) {
+    logError(log, "handleSkillsListEvent failed", err);
+  }
+}
+async function handleInitAgentEvent(ctx, result) {
+  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
+  };
+  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, result) {
+  const { accountId, baseConfig, log } = ctx;
+  if (!result.cronTaskEvent)
+    return;
+  try {
+    const { handleCronTaskEvent: handleCronTaskEvent2 } = 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 handleCronTaskEvent2(result.cronTaskEvent, token, connConfig.baseUrl, connConfig.appKey || accountId, log);
+  } catch (err) {
+    logError(log, "handleCronTaskEvent failed", err);
+  }
+}
+async function handleAgentMessage(ctx, data, result) {
+  const { accountId, account, cfg, accountConfig, log } = ctx;
+  const { message } = result;
+  if (!message)
+    return;
+  const { text, userId, openConversationId, messageId: parsedMessageId, agentId: msgAgentId } = 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;
+  const msgAgentIdResolved = msgAgentId ?? accountConfig.agentId;
+  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;
+  }
+  const bindings = cfg?.bindings ?? [];
+  let targetAgentId = "default";
+  const matchedBinding = bindings.find((binding) => {
+    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;
+  }
+  const attachments = message.attachments;
+  const 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();
+  const textForCommandCheck = bodyText?.replace(/^\[引用[^\]]*\]\s*/, "").trim() || "";
+  const resolvedCommand = maybeResolveTextAlias(textForCommandCheck, messageAccount.config);
+  const isFrameworkCommand = resolvedCommand !== null;
+  if (isFrameworkCommand) {
+    log?.info?.(`[DELIVER] Framework command detected: ${bodyText}, will set CommandSource=native`);
+  }
+  const finalized = await buildInboundContext(
+    inboundMessage,
+    messageAccountId,
+    messageAccount.config,
+    targetAgentId,
+    pluginRuntime,
+    true,
+    log
+  );
+  if (isFrameworkCommand) {
+    const targetSessionKey = finalized.SessionKey;
+    const { sessionKey: commandSessionKey, commandTargetSessionKey } = resolveNativeCommandSessionTargets({
+      agentId: targetAgentId,
+      sessionPrefix: "openclaw-workclaw:new",
+      userId: String(userId ?? ""),
+      targetSessionKey
+    });
+    finalized.SessionKey = commandSessionKey;
+    finalized.CommandTargetSessionKey = commandTargetSessionKey;
+    finalized.CommandSource = "native";
+    finalized.CommandAuthorized = true;
+    log?.info?.(`[DELIVER] Set CommandSource=native, commandSessionKey=${commandSessionKey}, targetSessionKey=${targetSessionKey}`);
+  }
+  let textDelivered = false;
+  await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: finalized,
+    cfg,
+    replyOptions: {
+      onAgentRunStart(runId) {
+        setToolContext(runId, {
+          target: targetAgentId,
+          replyToMessageId: parsedMessageId,
+          openConversationId: resolvedOpenConversationId,
+          accountId: messageAccountId,
+          agentId: String(msgAgentIdResolved),
+          sessionKey: finalized.SessionKey || ""
+        });
+        log?.info?.(`[AGENT] onAgentRunStart: runId=${runId} target=${targetAgentId}`);
+      }
+    },
+    dispatcherOptions: {
+      deliver: async (payload, info) => {
+        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") {
+          return;
+        }
+        if (!textOut.trim()) {
+          log?.warn?.(`[DELIVER] skip: empty text (kind=${kind})`);
+          return;
+        }
+        try {
+          const result2 = 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=${result2.messageId}`);
+        } catch (err) {
+          logError(log, "Reply send failed", err);
+          throw err;
+        }
+      }
+    }
+  });
+  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);
+    }
+  }
+  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);
+    }
+  }
+}
+async function dispatchWorkclawMessage(data, ctx) {
+  const { log } = ctx;
+  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, agentId, accountId, log) {
+  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)}`);
+  }
+}
+export {
+  dispatchWorkclawMessage
+};

package/dist/packages/plugin/src/gateway/reconnect.js

@@ -0,0 +1,177 @@
+import { Agent, WebSocket } from "undici";
+import { clearWorkclawTokenCache, openWorkclawConnection } from "../connection/workclaw-client.js";
+import { setWorkclawWsConnection, clearWorkclawWsConnection } from "../../../../src/runtime.js";
+function createReconnectScheduler(options) {
+  const { key, config, log, onMessage, onReconnectSuccess, onClose, onConnectingStarted } = options;
+  let reconnectBackoff = 5e3;
+  let shouldStopReconnect = false;
+  let pendingReconnectTimer = null;
+  let pendingDoConnectPromise = null;
+  async function doConnect() {
+    if (pendingDoConnectPromise !== null) {
+      return pendingDoConnectPromise;
+    }
+    let resolveThis;
+    let rejectThis;
+    const p = new Promise((resolve, reject) => {
+      resolveThis = resolve;
+      rejectThis = reject;
+    });
+    pendingDoConnectPromise = p;
+    const tokenCacheKey = config.appKey || key;
+    clearWorkclawTokenCache(tokenCacheKey);
+    const connConfig = {
+      baseUrl: config.baseUrl || "",
+      websocketUrl: config.websocketUrl,
+      appKey: config.appKey,
+      appSecret: config.appSecret,
+      localIp: config.localIp,
+      allowInsecureTls: config.allowInsecureTls,
+      requestTimeout: config.requestTimeout
+    };
+    let endpoint;
+    let ticket;
+    try {
+      const result = await openWorkclawConnection(tokenCacheKey, connConfig);
+      endpoint = result.endpoint;
+      ticket = result.ticket;
+    } catch (err) {
+      const willRetry = handleConnectError(String(err));
+      if (!willRetry) {
+        pendingDoConnectPromise = null;
+        rejectThis(err);
+      }
+      throw err;
+    }
+    const url = `${endpoint}?ticket=${encodeURIComponent(ticket)}`;
+    const dispatcher = connConfig.allowInsecureTls ? new Agent({ connect: { rejectUnauthorized: false } }) : void 0;
+    const wsOptions = dispatcher ? { dispatcher } : void 0;
+    const ws = new WebSocket(url, wsOptions);
+    setWorkclawWsConnection(key, ws);
+    onConnectingStarted?.(ws);
+    ws.onopen = () => {
+      log?.info?.(`Gateway WebSocket connected endpoint=${endpoint}`);
+      reconnectBackoff = 5e3;
+      onReconnectSuccess?.();
+      resolveThis();
+    };
+    ws.onerror = (event) => {
+      log?.error?.(`Gateway WebSocket error: ${String(event?.message ?? event)}`);
+      rejectThis(new Error(String(event?.message ?? event)));
+    };
+    ws.onclose = (event) => {
+      const code = String(event?.code ?? "");
+      const reason = String(event?.reason ?? "");
+      log?.warn?.(`Gateway WebSocket closed code=${code} reason=${reason}`);
+      clearWorkclawWsConnection(key);
+      if (onClose) {
+        onClose();
+      } else {
+        scheduleReconnect();
+      }
+      rejectThis(new Error(`WebSocket closed code=${code} reason=${reason}`));
+    };
+    ws.onmessage = (event) => {
+      const data = typeof event.data === "string" ? event.data : String(event.data ?? "");
+      log?.debug?.(`Gateway WebSocket message received bytes=${data.length}`);
+      onMessage(data);
+    };
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("websocket connection timeout")), 3e4);
+      ws.addEventListener("open", () => {
+        clearTimeout(timeout);
+        resolve();
+      }, { once: true });
+      ws.addEventListener("error", (event) => {
+        clearTimeout(timeout);
+        reject(new Error(String(event?.message ?? event)));
+      }, { once: true });
+      ws.addEventListener("close", (event) => {
+        clearTimeout(timeout);
+        reject(new Error(`websocket closed before ready code=${event?.code ?? ""} reason=${event?.reason ?? ""}`));
+      }, { once: true });
+    });
+  }
+  const scheduleReconnect = () => {
+    if (shouldStopReconnect) {
+      log?.info?.(`Reconnect: Stopped due to previous auth failure`);
+      return;
+    }
+    if (pendingReconnectTimer !== null) {
+      log?.info?.(`Reconnect: Already scheduled, skipping duplicate`);
+      return;
+    }
+    const jitter = Math.floor(Math.random() * 3e3);
+    const delayMs = reconnectBackoff + jitter;
+    log?.info?.(`Reconnect: Scheduling in ${delayMs}ms (base=${reconnectBackoff} + jitter=${jitter}) key=${key}`);
+    pendingReconnectTimer = setTimeout(async () => {
+      pendingReconnectTimer = null;
+      pendingDoConnectPromise = null;
+      try {
+        log?.info?.(`Reconnect: Attempting... key=${key}`);
+        await doConnect();
+        log?.info?.(`Reconnect: Success`);
+      } catch (err) {
+        const errorStr = String(err);
+        log?.error?.(`Reconnect: Failed: ${errorStr}`);
+        const willRetry = handleConnectError(errorStr);
+        if (!willRetry) {
+          pendingDoConnectPromise = null;
+        } else {
+          scheduleReconnect();
+        }
+      }
+    }, delayMs);
+  };
+  function handleConnectError(errorStr) {
+    if (errorStr.includes("访问过于频繁")) {
+      log?.warn?.(`Reconnect: Rate limited, retrying with minimal backoff`);
+      if (pendingReconnectTimer !== null) {
+        clearTimeout(pendingReconnectTimer);
+        pendingReconnectTimer = null;
+      }
+      reconnectBackoff = 1e3;
+      scheduleReconnect();
+      return true;
+    }
+    const isAuthError = errorStr.includes('"errCode":2001') || errorStr.includes('"code":2001') || errorStr.includes("鉴权失败") || errorStr.includes("invalid credentials") || errorStr.includes("unauthorized");
+    if (isAuthError) {
+      log?.error?.(`Reconnect: Authentication failed, stopping`);
+      shouldStopReconnect = true;
+      if (pendingReconnectTimer !== null) {
+        clearTimeout(pendingReconnectTimer);
+        pendingReconnectTimer = null;
+      }
+      return false;
+    }
+    return true;
+  }
+  async function connect() {
+    if (pendingDoConnectPromise !== null) {
+      return pendingDoConnectPromise;
+    }
+    try {
+      return await doConnect();
+    } catch (err) {
+      const errorStr = String(err);
+      log?.error?.(`Gateway connect failed: ${errorStr}`);
+      const willRetry = handleConnectError(errorStr);
+      if (!willRetry) {
+        pendingDoConnectPromise = null;
+        throw err;
+      }
+      scheduleReconnect();
+    }
+  }
+  const stopReconnect = () => {
+    shouldStopReconnect = true;
+    if (pendingReconnectTimer !== null) {
+      clearTimeout(pendingReconnectTimer);
+      pendingReconnectTimer = null;
+    }
+  };
+  return { connect, scheduleReconnect, stopReconnect };
+}
+export {
+  createReconnectScheduler
+};