@workclaw/openclaw-workclaw 1.0.342 → 1.0.343

package/dist/plugins-C54ejDC8-qGQvFNWW.js

@@ -0,0 +1,8 @@
+import { aj as getChannelPlugin } from "./channel-CWeiUgV5.js";
+import { ak, al, am } from "./channel-CWeiUgV5.js";
+export {
+  getChannelPlugin,
+  ak as getLoadedChannelPlugin,
+  al as listChannelPlugins,
+  am as normalizeChannelId
+};

package/dist/provider-discovery.runtime-ZgcVwu5_.js

@@ -0,0 +1,4 @@
+import { at } from "./channel-CWeiUgV5.js";
+export {
+  at as resolvePluginDiscoveryProvidersRuntime
+};

package/dist/runtime-api-DU-e2Pen.js

@@ -0,0 +1,391 @@
+const LOG_LEVEL = {
+  // 测试环境
+  Test: "test",
+  // 生产环境
+  Production: "production"
+};
+function isLogLevel(value) {
+  return value === LOG_LEVEL.Test || value === LOG_LEVEL.Production;
+}
+class Logger {
+  logLevel = LOG_LEVEL.Production;
+  pluginApi = null;
+  /**
+   * 设置插件 API
+   *
+   * @param pluginApi - OpenClaw 插件 API
+   */
+  setApi(pluginApi) {
+    this.pluginApi = pluginApi;
+  }
+  /**
+   * 设置日志级别
+   *
+   * @param logLevel - 日志级别
+   */
+  setLevel(logLevel) {
+    this.logLevel = logLevel;
+  }
+  /**
+   * 记录信息日志（仅在 test 场景输出）
+   *
+   * @param message - 日志消息
+   */
+  info(message) {
+    if (this.logLevel === LOG_LEVEL.Production) {
+      return;
+    }
+    this.pluginApi?.logger?.info(message);
+  }
+  /**
+   * 记录警告日志（任何场景都输出）
+   *
+   * @param message - 日志消息
+   */
+  warn(message) {
+    this.pluginApi?.logger?.warn(message);
+  }
+  /**
+   * 记录错误日志（任何场景都输出）
+   *
+   * @param message - 日志消息
+   */
+  error(message) {
+    this.pluginApi?.logger?.error(message);
+  }
+}
+const logger = new Logger();
+let runtime = null;
+const wsByKey = /* @__PURE__ */ new Map();
+const accountIdsByAppKey = /* @__PURE__ */ new Map();
+const appKeyByAccountId = /* @__PURE__ */ new Map();
+const reconnectSchedulers = /* @__PURE__ */ new Map();
+const dispatchersByAppKey = /* @__PURE__ */ new Map();
+const connectingPromises = /* @__PURE__ */ new Map();
+const lastMessageAtByKey = /* @__PURE__ */ new Map();
+function setWorkclawRuntime(next) {
+  runtime = next;
+}
+function getWorkclawRuntime() {
+  if (!runtime) {
+    throw new Error("Workclaw runtime not initialized");
+  }
+  return runtime;
+}
+function setWorkclawWsConnection(key, ws) {
+  wsByKey.set(key, ws);
+}
+function clearWorkclawWsConnection(key) {
+  wsByKey.delete(key);
+}
+function getWorkclawWsConnection(key) {
+  return wsByKey.get(key);
+}
+function setLastInboundAt(key, timestamp) {
+  lastMessageAtByKey.set(key, timestamp);
+}
+function getLastInboundAt(key) {
+  return lastMessageAtByKey.get(key);
+}
+const lastOutboundAtByKey = /* @__PURE__ */ new Map();
+const connectionConfigCache = /* @__PURE__ */ new Map();
+function setWorkclawConnectionConfig(accountId, config) {
+  connectionConfigCache.set(accountId, {
+    appKey: config.appKey,
+    appSecret: config.appSecret,
+    baseUrl: config.baseUrl ?? "",
+    websocketUrl: config.websocketUrl,
+    localIp: config.localIp,
+    allowInsecureTls: config.allowInsecureTls,
+    requestTimeout: config.requestTimeout
+  });
+}
+function getWorkclawConnectionConfig(accountId) {
+  return connectionConfigCache.get(accountId);
+}
+function clearWorkclawConnectionConfig(accountId) {
+  connectionConfigCache.delete(accountId);
+}
+function setLastOutboundAt(key, timestamp) {
+  lastOutboundAtByKey.set(key, timestamp);
+}
+function getLastOutboundAt(key) {
+  return lastOutboundAtByKey.get(key);
+}
+function registerAccountContext(appKey, accountId, ctx) {
+  if (!accountIdsByAppKey.has(appKey)) {
+    accountIdsByAppKey.set(appKey, /* @__PURE__ */ new Set());
+  }
+  accountIdsByAppKey.get(appKey).add(accountId);
+  appKeyByAccountId.set(accountId, appKey);
+  if (!dispatchersByAppKey.has(appKey)) {
+    dispatchersByAppKey.set(appKey, /* @__PURE__ */ new Map());
+  }
+  dispatchersByAppKey.get(appKey).set(accountId, { ctx });
+}
+function unregisterAccountContext(appKey, accountId) {
+  accountIdsByAppKey.get(appKey)?.delete(accountId);
+  appKeyByAccountId.delete(accountId);
+  dispatchersByAppKey.get(appKey)?.delete(accountId);
+}
+function getAccountIdsByAppKey(appKey) {
+  return Array.from(accountIdsByAppKey.get(appKey) ?? []);
+}
+function getAppKeyByAccountId(accountId) {
+  return appKeyByAccountId.get(accountId);
+}
+function getDispatcherByAppKeyAndAccountId(appKey, accountId) {
+  return dispatchersByAppKey.get(appKey)?.get(accountId);
+}
+function getAllDispatchersByAppKey(appKey) {
+  return dispatchersByAppKey.get(appKey);
+}
+function setReconnectScheduler(appKey, scheduler) {
+  reconnectSchedulers.set(appKey, scheduler);
+}
+function getReconnectScheduler(appKey) {
+  return reconnectSchedulers.get(appKey);
+}
+function clearReconnectScheduler(appKey) {
+  reconnectSchedulers.delete(appKey);
+}
+function tryStartConnecting(appKey) {
+  const existingPromise = connectingPromises.get(appKey);
+  if (existingPromise !== void 0) {
+    return {
+      isConnector: false,
+      existingWs: wsByKey.get(appKey),
+      connectingPromise: existingPromise
+    };
+  }
+  let resolvePromise = () => {
+  };
+  const promise = new Promise((resolve) => {
+    resolvePromise = resolve;
+  });
+  promise._resolve = resolvePromise;
+  connectingPromises.set(appKey, promise);
+  return { isConnector: true, existingWs: void 0, connectingPromise: promise };
+}
+function finishConnecting(appKey, ws) {
+  const promise = connectingPromises.get(appKey);
+  if (promise) {
+    promise._resolve?.(ws ?? null);
+    connectingPromises.delete(appKey);
+  }
+  if (ws) {
+    wsByKey.set(appKey, ws);
+  }
+}
+const runIdToToolContext = /* @__PURE__ */ new Map();
+const toolCallIdToRunId = /* @__PURE__ */ new Map();
+function getToolContext(runId) {
+  return runIdToToolContext.get(runId);
+}
+function setToolContext(runId, ctx) {
+  runIdToToolContext.set(runId, ctx);
+}
+function setToolCallIdToRunIdMapping(toolCallId, runId) {
+  toolCallIdToRunId.set(toolCallId, runId);
+}
+function getRunIdByToolCallId(toolCallId) {
+  return toolCallIdToRunId.get(toolCallId);
+}
+function deleteToolContext(runId) {
+  runIdToToolContext.delete(runId);
+}
+function clearAllToolContexts() {
+  runIdToToolContext.clear();
+  toolCallIdToRunId.clear();
+}
+async function spawnSubAgent(params) {
+  if (!runtime) {
+    throw new Error("Workclaw runtime not initialized");
+  }
+  try {
+    const sessionsSpawn = runtime?.sessions_spawn;
+    if (!sessionsSpawn || typeof sessionsSpawn !== "function") {
+      logger.warn(`【智小途-运行时】未提供 sessions_spawn，为智能体 ${params.agentId} 返回模拟响应`);
+      return {
+        ok: true,
+        summary: `[模拟] Agent ${params.agentId} 完成任务: ${params.task.substring(0, 50)}...`
+      };
+    }
+    const result = await sessionsSpawn({
+      agentId: params.agentId,
+      task: params.task,
+      label: params.label,
+      model: params.model
+    });
+    return {
+      ok: true,
+      sessionKey: result.sessionKey,
+      summary: result.summary
+    };
+  } catch (error) {
+    logger.error(`【智小途-运行时】创建子智能体失败: ${error.message}`);
+    return {
+      ok: false,
+      error: error.message
+    };
+  }
+}
+const __openclaw_workclaw_runtime_emitted = true;
+function getToolStartHint(toolName) {
+  if (!toolName)
+    return "🔄 正在执行工具...";
+  const normalizedToolName = toolName.toLowerCase().trim();
+  const toolMap = {
+    // 📁 文件操作
+    "read": { emoji: "📖", title: "读取文件", hint: "正在读取文件", aliases: ["file_read", "read_file"] },
+    "write": { emoji: "✍️", title: "写入文件", hint: "正在写入文件", aliases: ["file_write", "write_file"] },
+    "edit": { emoji: "✏️", title: "编辑文件", hint: "正在编辑文件", aliases: ["file_edit", "modify"] },
+    // 💻 系统命令
+    "exec": { emoji: "⚡", title: "执行命令", hint: "正在执行命令", aliases: ["bash", "shell", "cmd", "command"] },
+    "process": { emoji: "🔄", title: "进程管理", hint: "正在处理进程", aliases: ["process_manager"] },
+    // 🌐 网络/浏览器
+    "web_fetch": { emoji: "🕸️", title: "获取网页", hint: "正在获取网页内容", aliases: ["fetch", "http_get", "http_request", "curl"] },
+    "web_search": { emoji: "🔍", title: "搜索网页", hint: "正在搜索网页", aliases: ["search", "google_search", "brave_search"] },
+    "browser": { emoji: "🌐", title: "浏览器控制", hint: "正在控制浏览器", aliases: ["browser_control", "playwright"] },
+    // 💬 消息/通信
+    "message": { emoji: "💌", title: "发送消息", hint: "正在发送消息", aliases: ["send_message", "mcp_deliver", "deliver", "notify"] },
+    "tts": { emoji: "🔊", title: "文字转语音", hint: "正在转换语音", aliases: ["text_to_speech", "speak"] },
+    // 🎭 会话管理
+    "sessions_spawn": { emoji: "🧬", title: "创建子代理", hint: "正在创建子代理", aliases: ["spawn", "create_agent", "new_session"] },
+    "sessions_send": { emoji: "📤", title: "跨会话发消息", hint: "正在发送跨会话消息", aliases: ["send_to_session", "forward"] },
+    "sessions_list": { emoji: "📋", title: "列出会话", hint: "正在列出会话", aliases: ["list_sessions"] },
+    "sessions_history": { emoji: "📜", title: "获取历史", hint: "正在获取历史消息", aliases: ["get_history", "history"] },
+    "sessions_yield": { emoji: "⏸️", title: "暂停让出", hint: "正在暂停等待", aliases: ["yield", "pause"] },
+    "subagents": { emoji: "🐛", title: "子代理管理", hint: "正在管理子代理", aliases: ["subagent_manager"] },
+    "agents_list": { emoji: "🤖", title: "列出代理", hint: "正在列出可用代理", aliases: ["list_agents"] },
+    // 🧠 记忆/知识
+    "memory_search": { emoji: "🔎", title: "搜索记忆", hint: "正在搜索记忆", aliases: ["search_memory", "recall"] },
+    "memory_get": { emoji: "📝", title: "读取记忆", hint: "正在读取记忆片段", aliases: ["get_memory", "read_memory"] },
+    // ⏰ 定时任务
+    "openclaw-workclaw-cron-add-params": { emoji: "⏱️", title: "创建定时任务", hint: "正在创建定时任务", aliases: ["cron_add", "add_timer"] },
+    "openclaw-workclaw-cron-update-params": { emoji: "🔧", title: "修改定时任务", hint: "正在修改定时任务", aliases: ["cron_update", "update_timer"] },
+    "openclaw-workclaw-cron-remove-params": { emoji: "🗑️", title: "删除定时任务", hint: "正在删除定时任务", aliases: ["cron_remove", "remove_timer"] },
+    "openclaw-workclaw-cron-notify-sync": { emoji: "🔔", title: "定时触发通知", hint: "定时任务已触发", aliases: ["cron_trigger", "notify"] },
+    "openclaw-workclaw-cron-add-sync": { emoji: "✅", title: "同步定时任务", hint: "正在同步到后端", aliases: [] },
+    "openclaw-workclaw-cron-update-sync": { emoji: "✅", title: "同步定时更新", hint: "正在同步更新", aliases: [] },
+    "openclaw-workclaw-cron-remove-sync": { emoji: "✅", title: "同步定时删除", hint: "正在同步删除", aliases: [] },
+    "openclaw-workclaw-cron-disable-params": { emoji: "⏸️", title: "禁用定时任务", hint: "正在禁用定时任务", aliases: ["cron_disable"] },
+    "openclaw-workclaw-cron-enable-params": { emoji: "▶️", title: "启用定时任务", hint: "正在启用定时任务", aliases: ["cron_enable"] },
+    // 📊 其他
+    "session_status": { emoji: "📊", title: "会话状态", hint: "正在获取会话状态", aliases: ["status", "get_status"] },
+    "canvas": { emoji: "🎨", title: "画布控制", hint: "正在控制画布", aliases: ["canvas_control", "draw"] }
+  };
+  if (toolMap[normalizedToolName]) {
+    const tool = toolMap[normalizedToolName];
+    return `${tool.emoji} ${tool.hint}...`;
+  }
+  for (const [_key, tool] of Object.entries(toolMap)) {
+    if (tool.aliases.includes(normalizedToolName)) {
+      return `${tool.emoji} ${tool.hint}...`;
+    }
+  }
+  return `🔄 正在执行 ${toolName}...`;
+}
+function getToolResultHint(toolName) {
+  if (!toolName)
+    return "✅ 工具执行完成";
+  const normalizedToolName = toolName.toLowerCase().trim();
+  const toolMap = {
+    // 📁 文件操作
+    "read": { emoji: "📖", title: "读取文件", hint: "已读取文件", aliases: ["file_read", "read_file"] },
+    "write": { emoji: "✍️", title: "写入文件", hint: "已写入文件", aliases: ["file_write", "write_file"] },
+    "edit": { emoji: "✏️", title: "编辑文件", hint: "已编辑文件", aliases: ["file_edit", "modify"] },
+    // 💻 系统命令
+    "exec": { emoji: "⚡", title: "执行命令", hint: "已执行命令", aliases: ["bash", "shell", "cmd", "command"] },
+    "process": { emoji: "🔄", title: "进程管理", hint: "已处理进程", aliases: ["process_manager"] },
+    // 🌐 网络/浏览器
+    "web_fetch": { emoji: "🕸️", title: "获取网页", hint: "已获取网页", aliases: ["fetch", "http_get", "http_request", "curl"] },
+    "web_search": { emoji: "🔍", title: "搜索网页", hint: "已搜索网页", aliases: ["search", "google_search", "brave_search"] },
+    "browser": { emoji: "🌐", title: "浏览器控制", hint: "已控制浏览器", aliases: ["browser_control", "playwright"] },
+    // 💬 消息/通信
+    "message": { emoji: "💌", title: "发送消息", hint: "已发送消息", aliases: ["send_message", "mcp_deliver", "deliver", "notify"] },
+    "tts": { emoji: "🔊", title: "文字转语音", hint: "已转换语音", aliases: ["text_to_speech", "speak"] },
+    // 🎭 会话管理
+    "sessions_spawn": { emoji: "🧬", title: "创建子代理", hint: "已创建子代理", aliases: ["spawn", "create_agent", "new_session"] },
+    "sessions_send": { emoji: "📤", title: "跨会话发消息", hint: "已发送跨会话消息", aliases: ["send_to_session", "forward"] },
+    "sessions_list": { emoji: "📋", title: "列出会话", hint: "已列出会话", aliases: ["list_sessions"] },
+    "sessions_history": { emoji: "📜", title: "获取历史", hint: "已获取历史消息", aliases: ["get_history", "history"] },
+    "sessions_yield": { emoji: "⏸️", title: "暂停让出", hint: "已暂停等待", aliases: ["yield", "pause"] },
+    "subagents": { emoji: "🐛", title: "子代理管理", hint: "已管理子代理", aliases: ["subagent_manager"] },
+    "agents_list": { emoji: "🤖", title: "列出代理", hint: "已列出代理", aliases: ["list_agents"] },
+    // 🧠 记忆/知识
+    "memory_search": { emoji: "🔎", title: "搜索记忆", hint: "已搜索记忆", aliases: ["search_memory", "recall"] },
+    "memory_get": { emoji: "📝", title: "读取记忆", hint: "已读取记忆", aliases: ["get_memory", "read_memory"] },
+    // ⏰ 定时任务
+    "openclaw-workclaw-cron-add-params": { emoji: "⏱️", title: "创建定时任务", hint: "已创建定时任务", aliases: ["cron_add", "add_timer"] },
+    "openclaw-workclaw-cron-update-params": { emoji: "🔧", title: "修改定时任务", hint: "已修改定时任务", aliases: ["cron_update", "update_timer"] },
+    "openclaw-workclaw-cron-remove-params": { emoji: "🗑️", title: "删除定时任务", hint: "已删除定时任务", aliases: ["cron_remove", "remove_timer"] },
+    "openclaw-workclaw-cron-notify-sync": { emoji: "🔔", title: "定时触发通知", hint: "定时任务已触发", aliases: ["cron_trigger", "notify"] },
+    "openclaw-workclaw-cron-add-sync": { emoji: "✅", title: "同步定时任务", hint: "已同步定时任务", aliases: [] },
+    "openclaw-workclaw-cron-update-sync": { emoji: "✅", title: "同步定时更新", hint: "已同步更新", aliases: [] },
+    "openclaw-workclaw-cron-remove-sync": { emoji: "✅", title: "同步定时删除", hint: "已同步删除", aliases: [] },
+    "openclaw-workclaw-cron-disable-params": { emoji: "⏸️", title: "禁用定时任务", hint: "已禁用定时任务", aliases: ["cron_disable"] },
+    "openclaw-workclaw-cron-enable-params": { emoji: "▶️", title: "启用定时任务", hint: "已启用定时任务", aliases: ["cron_enable"] },
+    // 📊 其他
+    "session_status": { emoji: "📊", title: "会话状态", hint: "已获取会话状态", aliases: ["status", "get_status"] },
+    "canvas": { emoji: "🎨", title: "画布控制", hint: "已控制画布", aliases: ["canvas_control", "draw"] }
+  };
+  if (toolMap[normalizedToolName]) {
+    const tool = toolMap[normalizedToolName];
+    return `${tool.emoji} ${tool.hint}`;
+  }
+  for (const [_key, tool] of Object.entries(toolMap)) {
+    if (tool.aliases.includes(normalizedToolName)) {
+      return `${tool.emoji} ${tool.hint}`;
+    }
+  }
+  return `✅ 已执行 ${toolName}`;
+}
+async function getWorkclawSecrets(params) {
+  const secrets = {};
+  if (params.appKey) {
+    secrets.appKey = params.appKey;
+  }
+  if (params.appSecret) {
+    secrets.appSecret = params.appSecret;
+  }
+  return secrets;
+}
+export {
+  getDispatcherByAppKeyAndAccountId as A,
+  getLastInboundAt as B,
+  getLastOutboundAt as C,
+  clearAllToolContexts as D,
+  getAccountIdsByAppKey as E,
+  getToolStartHint as F,
+  getWorkclawSecrets as G,
+  setLastInboundAt as H,
+  spawnSubAgent as I,
+  __openclaw_workclaw_runtime_emitted as _,
+  getWorkclawRuntime as a,
+  setWorkclawRuntime as b,
+  setToolCallIdToRunIdMapping as c,
+  deleteToolContext as d,
+  getToolContext as e,
+  getToolResultHint as f,
+  getWorkclawConnectionConfig as g,
+  getRunIdByToolCallId as h,
+  isLogLevel as i,
+  setToolContext as j,
+  getWorkclawWsConnection as k,
+  logger as l,
+  setWorkclawWsConnection as m,
+  clearWorkclawWsConnection as n,
+  getAppKeyByAccountId as o,
+  getAllDispatchersByAppKey as p,
+  getReconnectScheduler as q,
+  clearReconnectScheduler as r,
+  setLastOutboundAt as s,
+  clearWorkclawConnectionConfig as t,
+  unregisterAccountContext as u,
+  registerAccountContext as v,
+  tryStartConnecting as w,
+  setReconnectScheduler as x,
+  finishConnecting as y,
+  setWorkclawConnectionConfig as z
+};

package/dist/runtime-api.d.ts

@@ -0,0 +1,2 @@
+export { setWorkclawRuntime } from './src/runtime.js';
+//# sourceMappingURL=runtime-api.d.ts.map

package/dist/runtime-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-api.d.ts","sourceRoot":"","sources":["../runtime-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/runtime-api.js

@@ -0,0 +1,4 @@
+import { b } from "./runtime-api-DU-e2Pen.js";
+export {
+  b as setWorkclawRuntime
+};

package/dist/{session-archive.runtime-BAljnZWW.js → session-archive.runtime-SvY1eJq4.js}

@@ -1,5 +1,5 @@
-import { m as resolveRequiredHomeDir } from "./plugin-load-profile-DOnG9jJ5-zOQuKNoi.js";
-import { aC as parseSessionArchiveTimestamp, aD as formatSessionArchiveTimestamp, aE as emitSessionTranscriptUpdate, aF as resolveSessionFilePath, aG as resolveSessionTranscriptPathInDir, aH as resolveSessionTranscriptPath } from "./index-ZWLWkJXc.js";
+import { w as resolveRequiredHomeDir } from "./plugin-load-profile-DOnG9jJ5-B0ymqOTX.js";
+import { aC as parseSessionArchiveTimestamp, aD as formatSessionArchiveTimestamp, aE as emitSessionTranscriptUpdate, aF as resolveSessionFilePath, aG as resolveSessionTranscriptPathInDir, aH as resolveSessionTranscriptPath } from "./channel-CWeiUgV5.js";
 import fs__default from "node:fs";
 import path__default from "node:path";
 import os__default from "node:os";

package/dist/setup-entry.js

@@ -1,200 +1,8 @@
-import { s as shouldProfilePluginLoader, t as toSafeImportPath, q as formatPluginLoadProfileLine, u as openRootFileSync, l as normalizeLowercaseStringOrEmpty, v as getCachedPluginSourceModuleLoader, w as resolveLoaderPackageRoot } from "./plugin-load-profile-DOnG9jJ5-zOQuKNoi.js";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-import fs__default from "node:fs";
-import path__default from "node:path";
-const nodeRequire = createRequire(import.meta.url);
-const moduleLoaders = /* @__PURE__ */ new Map();
-const loadedModuleExports = /* @__PURE__ */ new Map();
-const disableBundledEntrySourceFallbackEnv = "OPENCLAW_DISABLE_BUNDLED_ENTRY_SOURCE_FALLBACK";
-function isTruthyEnvFlag(value) {
-  return value !== void 0 && !/^(?:0|false)$/iu.test(value.trim());
-}
-function resolveSpecifierCandidates(modulePath) {
-  const ext = normalizeLowercaseStringOrEmpty(path__default.extname(modulePath));
-  if (ext === ".js") return [modulePath, modulePath.slice(0, -3) + ".ts"];
-  if (ext === ".mjs") return [modulePath, modulePath.slice(0, -4) + ".mts"];
-  if (ext === ".cjs") return [modulePath, modulePath.slice(0, -4) + ".cts"];
-  return [modulePath];
-}
-function resolveEntryBoundaryRoot(importMetaUrl) {
-  return path__default.dirname(fileURLToPath(importMetaUrl));
-}
-function addBundledEntryCandidates(candidates, basePath, boundaryRoot) {
-  for (const candidate of resolveSpecifierCandidates(basePath)) {
-    if (candidates.some((entry) => entry.path === candidate && entry.boundaryRoot === boundaryRoot)) continue;
-    candidates.push({
-      path: candidate,
-      boundaryRoot
-    });
-  }
-}
-function resolveBundledEntryModuleCandidates(importMetaUrl, specifier) {
-  const importerPath = fileURLToPath(importMetaUrl);
-  const importerDir = path__default.dirname(importerPath);
-  const boundaryRoot = resolveEntryBoundaryRoot(importMetaUrl);
-  const candidates = [];
-  addBundledEntryCandidates(candidates, path__default.resolve(importerDir, specifier), boundaryRoot);
-  const sourceRelativeSpecifier = specifier.replace(/^\.\/src\//u, "./");
-  if (sourceRelativeSpecifier !== specifier) addBundledEntryCandidates(candidates, path__default.resolve(importerDir, sourceRelativeSpecifier), boundaryRoot);
-  const packageRoot = resolveLoaderPackageRoot({
-    modulePath: importerPath,
-    moduleUrl: importMetaUrl,
-    cwd: importerDir,
-    argv1: process.argv[1]
-  });
-  if (!packageRoot) return candidates;
-  const distExtensionsRoot = path__default.join(packageRoot, "dist", "extensions") + path__default.sep;
-  if (!importerPath.startsWith(distExtensionsRoot)) return candidates;
-  if (isTruthyEnvFlag(process.env[disableBundledEntrySourceFallbackEnv])) return candidates;
-  const pluginDirName = path__default.basename(importerDir);
-  const sourcePluginRoot = path__default.join(packageRoot, "extensions", pluginDirName);
-  if (sourcePluginRoot === boundaryRoot) return candidates;
-  addBundledEntryCandidates(candidates, path__default.resolve(sourcePluginRoot, specifier), sourcePluginRoot);
-  if (sourceRelativeSpecifier !== specifier) addBundledEntryCandidates(candidates, path__default.resolve(sourcePluginRoot, sourceRelativeSpecifier), sourcePluginRoot);
-  return candidates;
-}
-function formatBundledEntryUnknownError(error) {
-  if (typeof error === "string") return error;
-  if (error === void 0) return "boundary validation failed";
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return "non-serializable error";
-  }
-}
-function formatBundledEntryModuleOpenFailure(params) {
-  const importerPath = fileURLToPath(params.importMetaUrl);
-  const errorDetail = params.failure.error instanceof Error ? params.failure.error.message : formatBundledEntryUnknownError(params.failure.error);
-  return [
-    `bundled plugin entry "${params.specifier}" failed to open`,
-    `from "${importerPath}"`,
-    `(resolved "${params.resolvedPath}", plugin root "${params.boundaryRoot}",`,
-    `reason "${params.failure.reason}"): ${errorDetail}`
-  ].join(" ");
-}
-function resolveBundledEntryModulePath(importMetaUrl, specifier) {
-  const candidates = resolveBundledEntryModuleCandidates(importMetaUrl, specifier);
-  const fallbackCandidate = candidates[0] ?? {
-    path: path__default.resolve(path__default.dirname(fileURLToPath(importMetaUrl)), specifier),
-    boundaryRoot: resolveEntryBoundaryRoot(importMetaUrl)
-  };
-  let firstFailure = null;
-  for (const candidate of candidates) {
-    const opened = openRootFileSync({
-      absolutePath: candidate.path,
-      rootPath: candidate.boundaryRoot,
-      boundaryLabel: "plugin root",
-      rejectHardlinks: false,
-      skipLexicalRootCheck: true
-    });
-    if (opened.ok) {
-      fs__default.closeSync(opened.fd);
-      return opened.path;
-    }
-    firstFailure ??= {
-      candidate,
-      failure: opened
-    };
-  }
-  const failure = firstFailure;
-  if (!failure) throw new Error(formatBundledEntryModuleOpenFailure({
-    importMetaUrl,
-    specifier,
-    resolvedPath: fallbackCandidate.path,
-    boundaryRoot: fallbackCandidate.boundaryRoot,
-    failure: {
-      ok: false,
-      reason: "path",
-      error: /* @__PURE__ */ new Error(`ENOENT: no such file or directory, lstat '${fallbackCandidate.path}'`)
-    }
-  }));
-  throw new Error(formatBundledEntryModuleOpenFailure({
-    importMetaUrl,
-    specifier,
-    resolvedPath: failure.candidate.path,
-    boundaryRoot: failure.candidate.boundaryRoot,
-    failure: failure.failure
-  }));
-}
-function getSourceModuleLoader(modulePath, options) {
-  return getCachedPluginSourceModuleLoader({
-    cache: moduleLoaders,
-    modulePath,
-    importerUrl: import.meta.url,
-    preferBuiltDist: true,
-    loaderFilename: import.meta.url,
-    ...options.createLoaderForTest ? { createLoader: options.createLoaderForTest } : {}
-  });
-}
-function canTryNodeRequireBuiltModule(modulePath) {
-  return (modulePath.includes(`${path__default.sep}dist${path__default.sep}`) || modulePath.includes(`${path__default.sep}dist-runtime${path__default.sep}`)) && [
-    ".js",
-    ".mjs",
-    ".cjs"
-  ].includes(normalizeLowercaseStringOrEmpty(path__default.extname(modulePath)));
-}
-function loadBundledEntryModuleSync(importMetaUrl, specifier, options = {}) {
-  const modulePath = resolveBundledEntryModulePath(importMetaUrl, specifier);
-  const cached = loadedModuleExports.get(modulePath);
-  if (cached !== void 0) return cached;
-  let loaded;
-  const profile = shouldProfilePluginLoader();
-  const loadStartMs = profile ? performance.now() : 0;
-  let sourceLoaderReadyMs = 0;
-  if (canTryNodeRequireBuiltModule(modulePath)) try {
-    loaded = nodeRequire(modulePath);
-  } catch {
-    const moduleLoader = getSourceModuleLoader(modulePath, options);
-    sourceLoaderReadyMs = profile ? performance.now() : 0;
-    loaded = moduleLoader(toSafeImportPath(modulePath));
-  }
-  else {
-    const moduleLoader = getSourceModuleLoader(modulePath, options);
-    sourceLoaderReadyMs = profile ? performance.now() : 0;
-    loaded = moduleLoader(toSafeImportPath(modulePath));
-  }
-  if (profile) {
-    const endMs = performance.now();
-    console.error(formatPluginLoadProfileLine({
-      phase: "bundled-entry-module-load",
-      pluginId: "(bundled-entry)",
-      source: modulePath,
-      elapsedMs: endMs - loadStartMs,
-      extras: [["sourceLoaderCreateMs", sourceLoaderReadyMs ? sourceLoaderReadyMs - loadStartMs : 0], ["sourceLoaderCallMs", sourceLoaderReadyMs ? endMs - sourceLoaderReadyMs : 0]]
-    }));
-  }
-  loadedModuleExports.set(modulePath, loaded);
-  return loaded;
-}
-function loadBundledEntryExportSync(importMetaUrl, reference, options) {
-  const loaded = loadBundledEntryModuleSync(importMetaUrl, reference.specifier, options);
-  const resolved = loaded && typeof loaded === "object" && "default" in loaded ? loaded.default : loaded;
-  if (!reference.exportName) return resolved;
-  const record = resolved ?? loaded;
-  if (!record || !(reference.exportName in record)) throw new Error(`missing export "${reference.exportName}" from bundled entry module ${reference.specifier}`);
-  return record[reference.exportName];
-}
-function defineBundledChannelSetupEntry({ importMetaUrl, plugin, secrets, runtime, legacyStateMigrations, legacySessionSurface, features }) {
-  const setChannelRuntime = runtime ? (pluginRuntime) => {
-    loadBundledEntryExportSync(importMetaUrl, runtime)(pluginRuntime);
-  } : void 0;
-  const loadLegacyStateMigrationDetector = legacyStateMigrations ? (options) => loadBundledEntryExportSync(importMetaUrl, legacyStateMigrations, options) : void 0;
-  const loadLegacySessionSurface = legacySessionSurface ? (options) => loadBundledEntryExportSync(importMetaUrl, legacySessionSurface, options) : void 0;
-  return {
-    kind: "bundled-channel-setup-entry",
-    loadSetupPlugin: (options) => loadBundledEntryExportSync(importMetaUrl, plugin, options),
-    ...secrets ? { loadSetupSecrets: (options) => loadBundledEntryExportSync(importMetaUrl, secrets, options) } : {},
-    ...loadLegacyStateMigrationDetector ? { loadLegacyStateMigrationDetector } : {},
-    ...loadLegacySessionSurface ? { loadLegacySessionSurface } : {},
-    ...setChannelRuntime ? { setChannelRuntime } : {},
-    ...features ? { features } : {}
-  };
-}
+import { a as defineBundledChannelSetupEntry } from "./channel-entry-contract-BDMmGZzs-4ZlSsA7g.js";
 const setupEntry = defineBundledChannelSetupEntry({
   importMetaUrl: import.meta.url,
   plugin: {
-    specifier: "./api.js",
+    specifier: "./channel-plugin-api.js",
     exportName: "workclawPlugin"
   },
   secrets: {

package/dist/src/runtime.js

@@ -0,0 +1,37 @@
+import { _, D, r, t, n, d, y, E, p, o, A, B, C, q, h, e, f, F, g, a, G, k, v, H, s, x, c, j, z, b, m, I, w, u } from "../runtime-api-DU-e2Pen.js";
+export {
+  _ as __openclaw_workclaw_runtime_emitted,
+  D as clearAllToolContexts,
+  r as clearReconnectScheduler,
+  t as clearWorkclawConnectionConfig,
+  n as clearWorkclawWsConnection,
+  d as deleteToolContext,
+  y as finishConnecting,
+  E as getAccountIdsByAppKey,
+  p as getAllDispatchersByAppKey,
+  o as getAppKeyByAccountId,
+  A as getDispatcherByAppKeyAndAccountId,
+  B as getLastInboundAt,
+  C as getLastOutboundAt,
+  q as getReconnectScheduler,
+  h as getRunIdByToolCallId,
+  e as getToolContext,
+  f as getToolResultHint,
+  F as getToolStartHint,
+  g as getWorkclawConnectionConfig,
+  a as getWorkclawRuntime,
+  G as getWorkclawSecrets,
+  k as getWorkclawWsConnection,
+  v as registerAccountContext,
+  H as setLastInboundAt,
+  s as setLastOutboundAt,
+  x as setReconnectScheduler,
+  c as setToolCallIdToRunIdMapping,
+  j as setToolContext,
+  z as setWorkclawConnectionConfig,
+  b as setWorkclawRuntime,
+  m as setWorkclawWsConnection,
+  I as spawnSubAgent,
+  w as tryStartConnecting,
+  u as unregisterAccountContext
+};