@workclaw/openclaw-workclaw 1.0.32 → 1.0.33

package/dist/packages/plugin/src/gateway/tools-list-handler.js

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fetch } from "undici";
+const WORKCLAW_CRON_TOOLS = [
+  { typeStr: "function", name: "openclaw-workclaw-cron-add-params", description: "Generate the first-step cron parameters for creating a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-add-sync", description: "Sync a newly created reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-update-params", description: "Generate the first-step cron parameters for updating a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-update-sync", description: "Sync an updated reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-remove-params", description: "Generate the first-step parameters for removing a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-remove-sync", description: "Sync a removed reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-enable-params", description: "Generate the first-step parameters for enabling a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-enable-sync", description: "Sync an enabled reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-disable-params", description: "Generate the first-step parameters for disabling a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-disable-sync", description: "Sync a disabled reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-notify-sync", description: "Sync reminder trigger notifications back to the Workclaw backend." }
+];
+async function handleToolsListEvent(event, baseUrl, token, log) {
+  const agentId = Number(event.agentId);
+  const userId = Number(event.userId);
+  log?.info?.(`ToolsList: Handling TOOLS_LIST event for agentId: ${agentId}, userId: ${userId}`);
+  try {
+    const tools = await fetchToolsFromOpenClaw(agentId, userId, log);
+    const callbackPayload = {
+      userId,
+      agentId,
+      dataList: tools
+    };
+    const callbackUrl = `${baseUrl.replace(/\/$/, "")}/open-apis/v1/claw/push/tools`;
+    await sendToolsListCallback(callbackUrl, callbackPayload, token, log);
+    log?.info?.(`ToolsList: Successfully processed TOOLS_LIST event, sent ${tools.length} tools`);
+  } catch (error) {
+    log?.error?.(`ToolsList: Failed to handle TOOLS_LIST event: ${String(error)}`);
+    throw error;
+  }
+}
+async function fetchToolsFromOpenClaw(agentId, userId, log) {
+  log?.info?.(`ToolsList: Fetching tools from OpenClaw for agentId: ${agentId}`);
+  const allTools = [
+    { typeStr: "function", name: "web_search", description: "Search the web for information using Brave Search API." },
+    { typeStr: "function", name: "web_fetch", description: "Fetch and read content from a URL." },
+    { typeStr: "function", name: "sessions_list", description: "List all active agent sessions." },
+    { typeStr: "function", name: "sessions_history", description: "Get the history of a specific session." },
+    { typeStr: "function", name: "memory_search", description: "Search memory for past conversations and information." },
+    { typeStr: "function", name: "memory_get", description: "Get specific memory by ID." },
+    { typeStr: "function", name: "gateway", description: "Gateway control operations." },
+    { typeStr: "function", name: "exec", description: "Execute shell commands." },
+    ...WORKCLAW_CRON_TOOLS
+  ];
+  try {
+    const configPath = path.join(homedir(), ".openclaw", "openclaw.json");
+    const configContent = await readFile(configPath, "utf-8");
+    const config = JSON.parse(configContent);
+    const agentConfig = config.agents?.list?.find(
+      (agent) => String(agent.id) === String(agentId) || agent.id === `openclaw-workclaw-${agentId}`
+    );
+    const allowTools = agentConfig?.tools?.allow;
+    if (!allowTools || allowTools.length === 0 || allowTools.includes("*")) {
+      log?.info?.(`ToolsList: Agent has no allow restriction or allow=[*], returning all ${allTools.length} tools`);
+      return allTools;
+    }
+    const filteredTools = allTools.filter((tool) => allowTools.includes(tool.name));
+    log?.info?.(`ToolsList: Agent allow=${JSON.stringify(allowTools)}, returning ${filteredTools.length} tools`);
+    return filteredTools;
+  } catch (error) {
+    log?.error?.(`ToolsList: Error reading agent config: ${String(error)}, returning all tools`);
+    return allTools;
+  }
+}
+async function sendToolsListCallback(callbackUrl, payload, token, log) {
+  log?.info?.(`ToolsList: Sending callback to ${callbackUrl}`);
+  const response = await fetch(callbackUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Callback failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  log?.info?.(`ToolsList: Callback sent successfully: ${response.status}`);
+}
+export {
+  handleToolsListEvent
+};

package/dist/packages/plugin/src/gateway/workclaw-gateway.js

@@ -0,0 +1,208 @@
+import { buildAccountMap, resolveAccountByUserIdAndAgentId } from "../accounts.js";
+import { getAppKeyByAccountId, unregisterAccountContext, getAllDispatchersByAppKey, getWorkclawWsConnection, clearWorkclawWsConnection, getReconnectScheduler, clearReconnectScheduler, clearWorkclawConnectionConfig, createLogger, registerAccountContext, tryStartConnecting, setReconnectScheduler, finishConnecting, setWorkclawConnectionConfig, setWorkclawLoggerFromContext, getDispatcherByAppKeyAndAccountId } from "../../../../src/runtime.js";
+import { parseWorkClawMessage } from "./message-context.js";
+import { dispatchWorkclawMessage } from "./message-dispatcher.js";
+import { createReconnectScheduler } from "./reconnect.js";
+async function startWorkclawGateway(options) {
+  const { log } = options;
+  const logger = createLogger("", log);
+  setWorkclawLoggerFromContext(logger);
+  await startSharedWebSocket(options);
+}
+async function startSharedWebSocket(options) {
+  const { accountId, account, cfg, log } = options;
+  const logger = createLogger("", log);
+  const rawConfig = account.config;
+  const baseConfig = {
+    baseUrl: rawConfig.baseUrl,
+    websocketUrl: rawConfig.websocketUrl,
+    appKey: rawConfig.appKey,
+    appSecret: rawConfig.appSecret,
+    localIp: rawConfig.localIp,
+    allowInsecureTls: rawConfig.allowInsecureTls,
+    requestTimeout: rawConfig.requestTimeout
+  };
+  const accountConfig = {
+    agentId: rawConfig.agentId,
+    userId: rawConfig.userId,
+    openConversationId: rawConfig.openConversationId
+  };
+  const appKey = baseConfig.appKey || accountId;
+  const appKeyRaw = baseConfig.appKey ?? "";
+  buildAccountMap(cfg);
+  logger.info(
+    `Gateway start accountId=${accountId} appKey=${appKeyRaw ? `${appKeyRaw.slice(0, 8)}...` : "missing"} baseUrl=${baseConfig.baseUrl ?? ""} websocketUrl=${baseConfig.websocketUrl ?? ""}`
+  );
+  const ctx = {
+    accountId,
+    account,
+    cfg,
+    baseConfig,
+    accountConfig,
+    log: logger,
+    scheduleReconnect: () => {
+      const scheduler2 = getReconnectScheduler(appKey);
+      scheduler2?.scheduleReconnect();
+    }
+  };
+  registerAccountContext(appKey, accountId, ctx);
+  const existingWs = getWorkclawWsConnection(appKey);
+  if (existingWs) {
+    logger.info(`Gateway using existing WebSocket for appKey=${appKey}`);
+    return;
+  }
+  const startResult = tryStartConnecting(appKey);
+  if (!startResult.isConnector) {
+    logger.info(`Gateway another account is connecting, waiting... appKey=${appKey}`);
+    const resultWs = await startResult.connectingPromise;
+    if (resultWs) {
+      logger.info(`Gateway connection established by another account, using it appKey=${appKey}`);
+      return;
+    }
+    logger.warn(`Gateway connection attempt failed, will create own connection appKey=${appKey}`);
+  } else {
+    logger.info(`Gateway acquired connector lock, creating connection appKey=${appKey}`);
+  }
+  const scheduler = createReconnectScheduler({
+    key: appKey,
+    config: baseConfig,
+    log: logger,
+    onMessage: (data) => {
+      handleSharedMessage(appKey, data, cfg, logger);
+    },
+    onClose: () => {
+      scheduler.scheduleReconnect();
+    },
+    // 旧代码在 setWorkclawWsConnection 后、ws.onopen 前就调用 finishConnecting，
+    // 这个回调模拟同样的时机：ws 已存入 runtime，通知所有等待者
+    onConnectingStarted: (ws) => {
+      finishConnecting(appKey, ws);
+    }
+  });
+  setReconnectScheduler(appKey, scheduler);
+  try {
+    await scheduler.connect();
+  } catch (err) {
+    finishConnecting(appKey);
+    throw err;
+  }
+  setWorkclawConnectionConfig(accountId, {
+    appKey: baseConfig.appKey ?? "",
+    appSecret: baseConfig.appSecret ?? "",
+    baseUrl: baseConfig.baseUrl,
+    websocketUrl: baseConfig.websocketUrl,
+    localIp: baseConfig.localIp,
+    allowInsecureTls: baseConfig.allowInsecureTls,
+    requestTimeout: baseConfig.requestTimeout
+  });
+}
+function handleSharedMessage(appKey, data, cfg, logger) {
+  const parsed = parseWorkClawMessage(data, logger);
+  logger.info?.(`Gateway received message: ${JSON.stringify(parsed)}`);
+  if (!parsed) {
+    logger.warn?.(`Gateway failed to parse message`);
+    return;
+  }
+  if (parsed.type === "ping") {
+    const ws = getWorkclawWsConnection(appKey);
+    if (ws && ws.readyState === 1) {
+      const pongResponse = {
+        code: 200,
+        message: "pong",
+        metadata: { contentType: "application/json" },
+        data: JSON.stringify(parsed.pongData)
+      };
+      ws.send(JSON.stringify(pongResponse));
+    }
+    return;
+  }
+  if (parsed.type === "disconnect") {
+    const ws = getWorkclawWsConnection(appKey);
+    ws?.close();
+    return;
+  }
+  let userId = "";
+  let agentId = "";
+  if (parsed.type === "agent_message" && parsed.message) {
+    userId = String(parsed.message.userId || "");
+    agentId = String(parsed.message.agentId || "");
+  } else if (parsed.type === "agent_created") {
+    const allDispatchers = getAllDispatchersByAppKey(appKey);
+    if (allDispatchers && allDispatchers.size > 0) {
+      const firstDispatcher = allDispatchers.values().next().value;
+      if (firstDispatcher) {
+        dispatchWorkclawMessage(data, firstDispatcher.ctx).catch((err) => {
+          logger.error?.(`Dispatch error: ${String(err)}`);
+        });
+      }
+    }
+    return;
+  } else if (parsed.type === "agent_updated" || parsed.type === "agent_deleted") {
+    userId = String(parsed.eventData?.futureId || parsed.eventData?.userId || "");
+    agentId = String(parsed.eventData?.id || parsed.eventData?.agentId || "");
+  } else if (parsed.type === "tools_list") {
+    userId = String(parsed.eventData?.userId || "");
+    agentId = String(parsed.eventData?.agentId || "");
+  } else if (parsed.type === "skills_list" || parsed.type === "skills_event") {
+    userId = String(parsed.eventData?.data?.userId || parsed.eventData?.userId || "");
+    agentId = String(parsed.eventData?.data?.agentIds?.[0] || parsed.eventData?.data?.agentId || parsed.eventData?.agentId || "");
+  } else if (parsed.type === "init_agent") {
+    userId = String(parsed.eventData?.futureId || parsed.eventData?.userId || "");
+    agentId = String(parsed.eventData?.id || parsed.eventData?.agentId || "");
+    const accountId2 = "default";
+    const dispatcher2 = getDispatcherByAppKeyAndAccountId(appKey, accountId2);
+    if (dispatcher2) {
+      dispatchWorkclawMessage(data, dispatcher2.ctx).catch((err) => {
+        logger.error?.(`Dispatch error: ${String(err)}`);
+      });
+    } else {
+      logger.warn?.(`Gateway no dispatcher for accountId=${accountId2}`);
+    }
+    return;
+  } else if (parsed.type === "cron_task_event") {
+    const accountId2 = "default";
+    const dispatcher2 = getDispatcherByAppKeyAndAccountId(appKey, accountId2);
+    if (dispatcher2) {
+      dispatchWorkclawMessage(data, dispatcher2.ctx).catch((err) => {
+        logger.error?.(`Dispatch error: ${String(err)}`);
+      });
+    } else {
+      logger.warn?.(`Gateway (per-appKey) no dispatcher for accountId=${accountId2}`);
+    }
+    return;
+  } else {
+    return;
+  }
+  const accountId = resolveAccountByUserIdAndAgentId(cfg, userId, agentId);
+  if (!accountId) {
+    logger.warn?.(`Gateway no account found for userId=${userId} agentId=${agentId}`);
+    return;
+  }
+  const dispatcher = getDispatcherByAppKeyAndAccountId(appKey, accountId);
+  if (dispatcher) {
+    dispatchWorkclawMessage(data, dispatcher.ctx).catch((err) => {
+      logger.error?.(`Dispatch error: ${String(err)}`);
+    });
+  } else {
+    logger.warn?.(`Gateway no dispatcher for accountId=${accountId}`);
+  }
+}
+function stopWorkclawGateway(accountId) {
+  const appKey = getAppKeyByAccountId(accountId);
+  if (!appKey)
+    return;
+  unregisterAccountContext(appKey, accountId);
+  if (getAllDispatchersByAppKey(appKey)?.size === 0) {
+    const ws = getWorkclawWsConnection(appKey);
+    ws?.close();
+    clearWorkclawWsConnection(appKey);
+    const scheduler = getReconnectScheduler(appKey);
+    scheduler?.stopReconnect();
+    clearReconnectScheduler(appKey);
+  }
+  clearWorkclawConnectionConfig(accountId);
+}
+export {
+  startWorkclawGateway,
+  stopWorkclawGateway
+};

package/dist/packages/plugin/src/media/upload.js

@@ -0,0 +1,126 @@
+import { stat, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Agent, fetch } from "undici";
+function isLocalMediaSource(value) {
+  const trimmed = value.trim();
+  return trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("~") || trimmed.startsWith("file://");
+}
+function resolveLocalPath(input) {
+  if (input.startsWith("file://")) {
+    return fileURLToPath(input);
+  }
+  if (input.startsWith("~")) {
+    return path.join(os.homedir(), input.slice(1));
+  }
+  return path.resolve(input);
+}
+function readResponseUrlPath(data, pathValue) {
+  if (!pathValue)
+    return void 0;
+  const parts = pathValue.split(".").filter(Boolean);
+  let current = data;
+  for (const part of parts) {
+    if (!current || typeof current !== "object")
+      return void 0;
+    current = current[part];
+  }
+  return typeof current === "string" ? current : void 0;
+}
+function extractUploadedUrl(responseText, responseData, pathValue) {
+  const fromPath = readResponseUrlPath(responseData, pathValue);
+  if (fromPath)
+    return fromPath;
+  const direct = responseData.url ?? responseData.mediaUrl;
+  if (typeof direct === "string" && direct.trim())
+    return direct;
+  const dataObj = responseData.data;
+  if (dataObj && typeof dataObj === "object") {
+    const dataUrl = dataObj.url;
+    const dataMedia = dataObj.mediaUrl;
+    if (typeof dataUrl === "string" && dataUrl.trim())
+      return dataUrl;
+    if (typeof dataMedia === "string" && dataMedia.trim())
+      return dataMedia;
+  }
+  const resultObj = responseData.result;
+  if (resultObj && typeof resultObj === "object") {
+    const resultUrl = resultObj.url;
+    const resultMedia = resultObj.mediaUrl;
+    if (typeof resultUrl === "string" && resultUrl.trim())
+      return resultUrl;
+    if (typeof resultMedia === "string" && resultMedia.trim())
+      return resultMedia;
+  }
+  if (responseText.trim() && /^https?:\/\//i.test(responseText.trim())) {
+    return responseText.trim();
+  }
+  return void 0;
+}
+async function uploadLocalMedia(params) {
+  const stats = await stat(params.filePath);
+  if (!stats.isFile()) {
+    throw new Error(`mediaUrl is not a file: ${params.filePath}`);
+  }
+  const content = await readFile(params.filePath);
+  const form = new FormData();
+  const fieldName = params.uploadFieldName?.trim() || "file";
+  const fileName = path.basename(params.filePath);
+  form.set(fieldName, new Blob([content], { type: "application/octet-stream" }), fileName);
+  if (params.uploadFormFields) {
+    for (const [key, value] of Object.entries(params.uploadFormFields)) {
+      form.set(key, String(value));
+    }
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), params.requestTimeout);
+  let dispatcher;
+  let doFetch = globalThis.fetch.bind(globalThis);
+  if (params.allowInsecureTls) {
+    try {
+      dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+      doFetch = fetch;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`allowInsecureTls requires undici. ${message}`);
+    }
+  }
+  try {
+    const response = await doFetch(params.uploadUrl, {
+      method: "POST",
+      headers: params.uploadHeaders ?? {},
+      body: form,
+      signal: controller.signal,
+      ...dispatcher ? { dispatcher } : {}
+    });
+    const responseText = await response.text().catch(() => "");
+    if (!response.ok) {
+      throw new Error(`Upload failed: ${response.status} ${responseText}`);
+    }
+    let data = {};
+    if (responseText) {
+      try {
+        data = JSON.parse(responseText);
+      } catch {
+        data = {};
+      }
+    }
+    const uploadedUrl = extractUploadedUrl(
+      responseText,
+      data,
+      params.uploadResponseUrlPath
+    );
+    if (!uploadedUrl) {
+      throw new Error("Upload response missing file URL");
+    }
+    return uploadedUrl;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+export {
+  isLocalMediaSource,
+  resolveLocalPath,
+  uploadLocalMedia
+};

package/dist/packages/plugin/src/outbound/index.js

@@ -0,0 +1,88 @@
+import { stat } from "node:fs/promises";
+import { resolveWorkclawAccountWithCache, resolveAccountByUserIdAndAgentId } from "../accounts.js";
+import { loadOpenConversationId } from "../gateway/config-writer.js";
+import { isLocalMediaSource, resolveLocalPath, uploadLocalMedia } from "../media/upload.js";
+import { getWorkclawLogger, setLastOutboundAt } from "../../../../src/runtime.js";
+import { sendWorkclawOutboundMessage } from "./workclaw-sender.js";
+function findAccountIdByTarget(cfg, target, agentId) {
+  if (agentId !== void 0 && agentId !== null) {
+    return resolveAccountByUserIdAndAgentId(cfg, target, String(agentId)) ?? void 0;
+  }
+  return void 0;
+}
+async function resolveMediaUrl(mediaUrl, config) {
+  if (!mediaUrl)
+    return void 0;
+  if (!isLocalMediaSource(mediaUrl))
+    return mediaUrl;
+  const uploadUrl = config.uploadUrl;
+  if (!uploadUrl) {
+    throw new Error("uploadUrl not configured for local mediaUrl");
+  }
+  const filePath = resolveLocalPath(mediaUrl);
+  if (typeof config.mediaMaxMb === "number" && config.mediaMaxMb > 0) {
+    const stats = await stat(filePath);
+    const maxBytes = config.mediaMaxMb * 1024 * 1024;
+    if (stats.size > maxBytes) {
+      throw new Error(`mediaUrl exceeds limit (${config.mediaMaxMb} MB)`);
+    }
+  }
+  return uploadLocalMedia({
+    uploadUrl,
+    filePath,
+    uploadFieldName: config.uploadFieldName,
+    uploadHeaders: config.uploadHeaders,
+    uploadFormFields: config.uploadFormFields,
+    uploadResponseUrlPath: config.uploadResponseUrlPath,
+    requestTimeout: config.requestTimeout ?? 3e4,
+    allowInsecureTls: config.allowInsecureTls
+  });
+}
+async function sendMessageWorkclaw(params) {
+  const { cfg, to, text, mediaUrl, replyToMessageId, accountId, openConversationId, agentId, messageType, msgType, last } = params;
+  const resolvedMessageType = messageType ?? (replyToMessageId ? "reply" : "push");
+  let resolvedAccountId = accountId;
+  if (!resolvedAccountId) {
+    const foundAccountId = findAccountIdByTarget(cfg, to, agentId);
+    if (foundAccountId) {
+      resolvedAccountId = foundAccountId;
+    }
+  }
+  const account = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
+  if (!account.configured) {
+    throw new Error(`Workclaw account "${account.accountId}" not configured`);
+  }
+  const resolvedMediaUrl = await resolveMediaUrl(mediaUrl, account.config);
+  const cfgChannel = cfg.channels?.["openclaw-workclaw"] ?? {};
+  const cfgAccounts = cfgChannel.accounts ?? {};
+  const cfgAccount = resolvedAccountId ? cfgAccounts[resolvedAccountId] ?? {} : {};
+  const cfgOpenConversationId = cfgAccount?.openConversationId ?? cfgChannel?.openConversationId;
+  const stateOpenConversationId = resolvedAccountId ? loadOpenConversationId(resolvedAccountId, to) : void 0;
+  const effectiveOpenConversationId = openConversationId ?? cfgOpenConversationId ?? stateOpenConversationId;
+  getWorkclawLogger().info(`[SEND] source=${params.source || "?"} type=${resolvedMessageType} conv=${effectiveOpenConversationId || "(none)"} replyTo=${replyToMessageId}`);
+  const tokenCacheKey = account.config.appKey || account.accountId;
+  const result = await sendWorkclawOutboundMessage({
+    cacheKey: tokenCacheKey,
+    to,
+    text,
+    msgType,
+    mediaUrl: resolvedMediaUrl,
+    replyToMessageId,
+    openConversationId: effectiveOpenConversationId,
+    agentId,
+    config: account.config,
+    messageType: resolvedMessageType,
+    last,
+    source: params.source
+  });
+  if (resolvedAccountId) {
+    setLastOutboundAt(resolvedAccountId, Date.now());
+  }
+  return {
+    messageId: result.messageId,
+    chatId: to
+  };
+}
+export {
+  sendMessageWorkclaw
+};

package/dist/packages/plugin/src/outbound/workclaw-sender.js

@@ -0,0 +1,79 @@
+import { resolveWorkclawMessage, sendWorkclawReplyMessage, sendWorkclawMessage } from "../connection/workclaw-client.js";
+import { getWorkclawLogger } from "../../../../src/runtime.js";
+async function sendWorkclawOutboundMessage(params) {
+  const {
+    cacheKey,
+    to,
+    mediaUrl,
+    replyToMessageId,
+    openConversationId,
+    agentId,
+    config,
+    messageType = "reply",
+    last,
+    source
+  } = params;
+  let msgType = params.msgType;
+  let content = params.text;
+  const resolvedAgentId = agentId ?? config.agentId;
+  if (resolvedAgentId === void 0 || resolvedAgentId === null || String(resolvedAgentId).trim() === "") {
+    throw new Error(
+      "agentId is required for sending messages. Please create an account via cloud platform command or configure accounts in openclaw.json"
+    );
+  }
+  if (!msgType) {
+    ({ msgType, content } = resolveWorkclawMessage(content, mediaUrl));
+  }
+  const messageTypeCode = msgType === "text" ? "1" : msgType;
+  const workclawConfig = {
+    baseUrl: config.baseUrl ?? "",
+    appKey: config.appKey ?? "",
+    appSecret: config.appSecret ?? "",
+    localIp: config.localIp,
+    allowInsecureTls: config.allowInsecureTls,
+    requestTimeout: config.requestTimeout
+  };
+  const receiveId = config.userId ?? to;
+  const replyEndpoint = "/open-apis/im/v1/messages/{messageId}/reply";
+  const pushEndpoint = "/open-apis/im/v1/messages";
+  if (messageType === "reply") {
+    if (!replyToMessageId) {
+      throw new Error("replyToMessageId is required for reply message");
+    }
+    const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
+    const msgId = await sendWorkclawReplyMessage({
+      cacheKey,
+      config: workclawConfig,
+      agentId: resolvedAgentId,
+      receiveId,
+      msgType: messageTypeCode,
+      content,
+      messageId: replyToMessageId,
+      openConversationId: resolvedOpenConversationId,
+      endpoint: replyEndpoint.replace("{messageId}", String(replyToMessageId)),
+      last,
+      source
+    });
+    return { messageId: msgId };
+  } else {
+    getWorkclawLogger().info(` Sending proactive message`);
+    const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
+    getWorkclawLogger().info(` Resolved openConversationId: ${resolvedOpenConversationId}`);
+    getWorkclawLogger().info(` Config openConversationId: ${config.openConversationId}`);
+    const msgId = await sendWorkclawMessage({
+      cacheKey,
+      config: workclawConfig,
+      agentId: resolvedAgentId,
+      receiveId,
+      msgType: messageTypeCode,
+      content,
+      openConversationId: resolvedOpenConversationId,
+      endpoint: pushEndpoint,
+      last
+    });
+    return { messageId: msgId };
+  }
+}
+export {
+  sendWorkclawOutboundMessage
+};

package/dist/packages/plugin/src/setup-core.js

@@ -0,0 +1,22 @@
+import "node:path";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/utils-DGFSjtQF.js";
+import { t as DEFAULT_ACCOUNT_ID } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/account-id-C6v13Xic.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/setup-helpers-ChrkNnYE.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/exec-jRxy02_4.js";
+import "node:fs/promises";
+import { resolveDefaultWorkclawAccountId } from "./accounts.js";
+import { patchWorkclawConfig } from "./setup-surface.js";
+function setWorkclawNamedAccountEnabled(cfg, accountId, enabled) {
+  return patchWorkclawConfig(cfg, accountId, { enabled });
+}
+const workclawSetupAdapter = {
+  resolveAccountId: ({ cfg, accountId }) => accountId?.trim() || resolveDefaultWorkclawAccountId(cfg),
+  applyAccountConfig: ({ cfg, accountId }) => {
+    const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+    return patchWorkclawConfig(cfg, isDefault ? DEFAULT_ACCOUNT_ID : accountId, { enabled: true });
+  }
+};
+export {
+  setWorkclawNamedAccountEnabled,
+  workclawSetupAdapter
+};