@nextclaw/openclaw-compat 0.1.6 → 0.1.8

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/plugin-sdk/index.ts
+import { listBuiltinChannelPlugins } from "@nextclaw/core";
 function emptyPluginConfigSchema() {
   return {
     type: "object",
@@ -44,6 +45,19 @@ function normalizeAccountId(accountId) {
   const trimmed = accountId?.trim();
   return trimmed || DEFAULT_ACCOUNT_ID;
 }
+function createNextclawBuiltinChannelPlugin(channelId) {
+  const builtin = listBuiltinChannelPlugins().find((entry) => entry.id === channelId);
+  if (!builtin) {
+    throw new Error(`builtin channel plugin not found: ${channelId}`);
+  }
+  return {
+    id: channelId,
+    nextclaw: {
+      isEnabled: builtin.isEnabled,
+      createChannel: builtin.create
+    }
+  };
+}
 var __nextclawPluginSdkCompat = true;
 
 // src/plugins/config-state.ts
@@ -224,10 +238,10 @@ function resolvePluginChannelMessageToolHints(params) {
   }
 }
 function getPluginUiMetadataFromRegistry(registry) {
-  return registry.plugins.map((plugin10) => ({
-    id: plugin10.id,
-    configSchema: plugin10.configJsonSchema,
-    configUiHints: plugin10.configUiHints
+  return registry.plugins.map((plugin) => ({
+    id: plugin.id,
+    configSchema: plugin.configJsonSchema,
+    configUiHints: plugin.configUiHints
   }));
 }
 async function startPluginChannelGateways(params) {
@@ -1057,11 +1071,11 @@ async function installPluginFromPath(params) {
 
 // src/plugins/loader.ts
 import fs5 from "fs";
-import path4 from "path";
+import path5 from "path";
 import { fileURLToPath } from "url";
+import { createRequire } from "module";
 import createJitiImport from "jiti";
 import { getWorkspacePathFromConfig } from "@nextclaw/core";
-import { expandHome as expandHome2 } from "@nextclaw/core";
 
 // src/plugins/manifest-registry.ts
 import fs4 from "fs";
@@ -1208,6 +1222,43 @@ function loadPluginUiMetadata(params) {
   return toPluginUiMetadata(registry.plugins);
 }
 
+// src/plugins/schema-validator.ts
+import AjvPkg from "ajv";
+var AjvCtor = AjvPkg;
+var ajv = new AjvCtor({
+  allErrors: true,
+  strict: false,
+  removeAdditional: false
+});
+var schemaCache = /* @__PURE__ */ new Map();
+function formatAjvErrors(errors) {
+  if (!errors || errors.length === 0) {
+    return ["invalid config"];
+  }
+  return errors.map((error) => {
+    const path7 = error.instancePath?.replace(/^\//, "").replace(/\//g, ".") || "<root>";
+    const message = error.message ?? "invalid";
+    return `${path7}: ${message}`;
+  });
+}
+function validateJsonSchemaValue(params) {
+  let cached = schemaCache.get(params.cacheKey);
+  if (!cached || cached.schema !== params.schema) {
+    const validate = ajv.compile(params.schema);
+    cached = { validate, schema: params.schema };
+    schemaCache.set(params.cacheKey, cached);
+  }
+  const ok = cached.validate(params.value);
+  if (ok) {
+    return { ok: true };
+  }
+  return { ok: false, errors: formatAjvErrors(cached.validate.errors) };
+}
+
+// src/plugins/registry.ts
+import path4 from "path";
+import { expandHome as expandHome2 } from "@nextclaw/core";
+
 // src/plugins/runtime.ts
 import { getPackageVersion } from "@nextclaw/core";
 import { MemoryGetTool, MemorySearchTool } from "@nextclaw/core";
@@ -1260,165 +1311,339 @@ function createPluginRuntime(params) {
   };
 }
 
-// src/plugins/schema-validator.ts
-import AjvPkg from "ajv";
-var AjvCtor = AjvPkg;
-var ajv = new AjvCtor({
-  allErrors: true,
-  strict: false,
-  removeAdditional: false
-});
-var schemaCache = /* @__PURE__ */ new Map();
-function formatAjvErrors(errors) {
-  if (!errors || errors.length === 0) {
-    return ["invalid config"];
+// src/plugins/registry.ts
+function buildPluginLogger(base, pluginId) {
+  const withPrefix = (message) => `[plugins:${pluginId}] ${message}`;
+  return {
+    info: (message) => base.info(withPrefix(message)),
+    warn: (message) => base.warn(withPrefix(message)),
+    error: (message) => base.error(withPrefix(message)),
+    debug: base.debug ? (message) => base.debug?.(withPrefix(message)) : void 0
+  };
+}
+function ensureUniqueNames(params) {
+  const accepted = [];
+  for (const rawName of params.names) {
+    const name = rawName.trim();
+    if (!name) {
+      continue;
+    }
+    if (params.reserved.has(name)) {
+      params.diagnostics.push({
+        level: "error",
+        pluginId: params.pluginId,
+        source: params.source,
+        message: `${params.kind} already registered by core: ${name}`
+      });
+      continue;
+    }
+    const owner = params.owners.get(name);
+    if (owner && owner !== params.pluginId) {
+      params.diagnostics.push({
+        level: "error",
+        pluginId: params.pluginId,
+        source: params.source,
+        message: `${params.kind} already registered: ${name} (${owner})`
+      });
+      continue;
+    }
+    params.owners.set(name, params.pluginId);
+    accepted.push(name);
   }
-  return errors.map((error) => {
-    const path6 = error.instancePath?.replace(/^\//, "").replace(/\//g, ".") || "<root>";
-    const message = error.message ?? "invalid";
-    return `${path6}: ${message}`;
+  return accepted;
+}
+function normalizeToolList(value) {
+  if (!value) {
+    return [];
+  }
+  const list = Array.isArray(value) ? value : [value];
+  return list.filter((entry) => {
+    if (!entry || typeof entry !== "object") {
+      return false;
+    }
+    const candidate = entry;
+    return typeof candidate.name === "string" && candidate.name.trim().length > 0 && candidate.parameters !== void 0 && typeof candidate.execute === "function";
   });
 }
-function validateJsonSchemaValue(params) {
-  let cached = schemaCache.get(params.cacheKey);
-  if (!cached || cached.schema !== params.schema) {
-    const validate = ajv.compile(params.schema);
-    cached = { validate, schema: params.schema };
-    schemaCache.set(params.cacheKey, cached);
+function createPluginRegisterRuntime(params) {
+  return {
+    config: params.config,
+    workspaceDir: params.workspaceDir,
+    logger: params.logger,
+    registry: params.registry,
+    toolNameOwners: /* @__PURE__ */ new Map(),
+    channelIdOwners: /* @__PURE__ */ new Map(),
+    providerIdOwners: /* @__PURE__ */ new Map(),
+    resolvedToolNames: /* @__PURE__ */ new Set(),
+    reservedToolNames: params.reservedToolNames,
+    reservedChannelIds: params.reservedChannelIds,
+    reservedProviderIds: params.reservedProviderIds
+  };
+}
+function registerPluginTool(params) {
+  const toolInput = params.tool;
+  const normalizedNames = [];
+  if (Array.isArray(params.opts?.names)) {
+    for (const name of params.opts?.names ?? []) {
+      const trimmed = String(name).trim();
+      if (trimmed) {
+        normalizedNames.push(trimmed);
+      }
+    }
+  } else if (params.opts?.name && String(params.opts.name).trim()) {
+    normalizedNames.push(String(params.opts.name).trim());
   }
-  const ok = cached.validate(params.value);
-  if (ok) {
-    return { ok: true };
+  if (typeof toolInput !== "function") {
+    const intrinsic = toolInput.name.trim();
+    if (intrinsic) {
+      normalizedNames.push(intrinsic);
+    }
+  }
+  const acceptedNames = ensureUniqueNames({
+    names: normalizedNames,
+    pluginId: params.pluginId,
+    diagnostics: params.runtime.registry.diagnostics,
+    source: params.source,
+    owners: params.runtime.toolNameOwners,
+    reserved: params.runtime.reservedToolNames,
+    kind: "tool"
+  });
+  if (acceptedNames.length === 0) {
+    return;
+  }
+  const factory = typeof toolInput === "function" ? toolInput : () => toolInput;
+  const registration = {
+    pluginId: params.pluginId,
+    factory,
+    names: acceptedNames,
+    optional: params.opts?.optional === true,
+    source: params.source
+  };
+  params.runtime.registry.tools.push(registration);
+  params.record.toolNames.push(...acceptedNames);
+  if (typeof toolInput === "function") {
+    return;
+  }
+  if (!params.runtime.resolvedToolNames.has(toolInput.name)) {
+    params.runtime.resolvedToolNames.add(toolInput.name);
+    params.runtime.registry.resolvedTools.push(toolInput);
   }
-  return { ok: false, errors: formatAjvErrors(cached.validate.errors) };
 }
-
-// src/plugins/bundled/channels/factory.ts
-import { listBuiltinChannelPlugins } from "@nextclaw/core";
-var EMPTY_PLUGIN_CONFIG_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  properties: {}
-};
-function resolveBuiltinChannelPlugin(channelId) {
-  const plugin10 = listBuiltinChannelPlugins().find((entry) => entry.id === channelId);
-  if (!plugin10) {
-    throw new Error(`builtin channel plugin not found: ${channelId}`);
+function registerPluginChannel(params) {
+  const normalizedChannel = params.registration && typeof params.registration === "object" && "plugin" in params.registration ? params.registration.plugin : params.registration;
+  if (!normalizedChannel || typeof normalizedChannel !== "object") {
+    params.runtime.registry.diagnostics.push({
+      level: "error",
+      pluginId: params.pluginId,
+      source: params.source,
+      message: "channel registration missing plugin object"
+    });
+    return;
+  }
+  const channelObj = normalizedChannel;
+  const rawId = typeof channelObj.id === "string" ? channelObj.id : String(channelObj.id ?? "");
+  const accepted = ensureUniqueNames({
+    names: [rawId],
+    pluginId: params.pluginId,
+    diagnostics: params.runtime.registry.diagnostics,
+    source: params.source,
+    owners: params.runtime.channelIdOwners,
+    reserved: params.runtime.reservedChannelIds,
+    kind: "channel"
+  });
+  if (accepted.length === 0) {
+    return;
+  }
+  const channelPlugin = normalizedChannel;
+  params.runtime.registry.channels.push({
+    pluginId: params.pluginId,
+    channel: channelPlugin,
+    source: params.source
+  });
+  const channelId = accepted[0];
+  params.record.channelIds.push(channelId);
+  const configSchema = channelPlugin.configSchema;
+  if (configSchema && typeof configSchema === "object") {
+    const schema = configSchema.schema;
+    if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+      params.record.configJsonSchema = schema;
+      params.record.configSchema = true;
+    }
+    const uiHints = configSchema.uiHints;
+    if (uiHints && typeof uiHints === "object" && !Array.isArray(uiHints)) {
+      params.record.configUiHints = {
+        ...params.record.configUiHints ?? {},
+        ...uiHints
+      };
+    }
+  }
+  const pushChannelTools = (value, optional, sourceLabel, resolveValue) => {
+    const previewTools = normalizeToolList(value);
+    if (previewTools.length === 0) {
+      return;
+    }
+    const declaredNames = previewTools.map((tool) => tool.name);
+    const acceptedNames = ensureUniqueNames({
+      names: declaredNames,
+      pluginId: params.pluginId,
+      diagnostics: params.runtime.registry.diagnostics,
+      source: params.source,
+      owners: params.runtime.toolNameOwners,
+      reserved: params.runtime.reservedToolNames,
+      kind: "tool"
+    });
+    if (acceptedNames.length === 0) {
+      return;
+    }
+    const factory = (ctx) => {
+      const tools = normalizeToolList(resolveValue(ctx));
+      if (tools.length === 0) {
+        return [];
+      }
+      const byName = new Map(tools.map((tool) => [tool.name, tool]));
+      return acceptedNames.map((name) => byName.get(name)).filter(Boolean);
+    };
+    params.runtime.registry.tools.push({
+      pluginId: params.pluginId,
+      factory,
+      names: acceptedNames,
+      optional,
+      source: params.source
+    });
+    params.record.toolNames.push(...acceptedNames);
+    const previewByName = new Map(previewTools.map((tool) => [tool.name, tool]));
+    for (const name of acceptedNames) {
+      const resolvedTool = previewByName.get(name);
+      if (!resolvedTool || params.runtime.resolvedToolNames.has(resolvedTool.name)) {
+        continue;
+      }
+      params.runtime.resolvedToolNames.add(resolvedTool.name);
+      params.runtime.registry.resolvedTools.push(resolvedTool);
+    }
+    params.runtime.registry.diagnostics.push({
+      level: "warn",
+      pluginId: params.pluginId,
+      source: params.source,
+      message: `${sourceLabel} registered channel-owned tools: ${acceptedNames.join(", ")}`
+    });
+  };
+  const agentTools = channelPlugin.agentTools;
+  if (typeof agentTools === "function") {
+    pushChannelTools(
+      normalizeToolList(agentTools()),
+      false,
+      `channel "${channelId}"`,
+      () => agentTools()
+    );
+  } else if (agentTools) {
+    pushChannelTools(normalizeToolList(agentTools), false, `channel "${channelId}"`, () => agentTools);
   }
-  return plugin10;
 }
-function createBundledChannelPlugin(params) {
-  const pluginId = `builtin-channel-${params.channelId}`;
-  const sourceDescription = params.description ?? `Builtin NextClaw channel plugin for ${params.channelId}`;
-  return {
-    id: pluginId,
-    name: params.name,
-    description: sourceDescription,
-    configSchema: EMPTY_PLUGIN_CONFIG_SCHEMA,
-    register(api) {
-      const builtin = resolveBuiltinChannelPlugin(params.channelId);
-      api.registerChannel({
-        plugin: {
-          id: params.channelId,
-          nextclaw: {
-            isEnabled: builtin.isEnabled,
-            createChannel: builtin.create
-          }
-        }
+function registerPluginProvider(params) {
+  const accepted = ensureUniqueNames({
+    names: [params.provider.id],
+    pluginId: params.pluginId,
+    diagnostics: params.runtime.registry.diagnostics,
+    source: params.source,
+    owners: params.runtime.providerIdOwners,
+    reserved: params.runtime.reservedProviderIds,
+    kind: "provider"
+  });
+  if (accepted.length === 0) {
+    return;
+  }
+  params.runtime.registry.providers.push({
+    pluginId: params.pluginId,
+    provider: params.provider,
+    source: params.source
+  });
+  params.record.providerIds.push(accepted[0]);
+}
+function registerPluginWithApi(params) {
+  const pluginRuntime = createPluginRuntime({ workspace: params.runtime.workspaceDir, config: params.runtime.config });
+  const pluginLogger = buildPluginLogger(params.runtime.logger, params.pluginId);
+  const pushUnsupported = (capability) => {
+    params.runtime.registry.diagnostics.push({
+      level: "warn",
+      pluginId: params.pluginId,
+      source: params.source,
+      message: `${capability} is not supported by nextclaw compat layer yet`
+    });
+    pluginLogger.warn(`${capability} is ignored (not supported yet)`);
+  };
+  const api = {
+    id: params.pluginId,
+    name: params.record.name,
+    version: params.record.version,
+    description: params.record.description,
+    source: params.source,
+    config: params.runtime.config,
+    pluginConfig: params.pluginConfig,
+    runtime: pluginRuntime,
+    logger: pluginLogger,
+    registerTool: (tool, opts) => {
+      registerPluginTool({
+        runtime: params.runtime,
+        record: params.record,
+        pluginId: params.pluginId,
+        source: params.source,
+        tool,
+        opts
       });
+    },
+    registerChannel: (registration) => {
+      registerPluginChannel({
+        runtime: params.runtime,
+        record: params.record,
+        pluginId: params.pluginId,
+        source: params.source,
+        registration
+      });
+    },
+    registerProvider: (provider) => {
+      registerPluginProvider({
+        runtime: params.runtime,
+        record: params.record,
+        pluginId: params.pluginId,
+        source: params.source,
+        provider
+      });
+    },
+    registerHook: () => pushUnsupported("registerHook"),
+    registerGatewayMethod: () => pushUnsupported("registerGatewayMethod"),
+    registerCli: () => pushUnsupported("registerCli"),
+    registerService: () => pushUnsupported("registerService"),
+    registerCommand: () => pushUnsupported("registerCommand"),
+    registerHttpHandler: () => pushUnsupported("registerHttpHandler"),
+    registerHttpRoute: () => pushUnsupported("registerHttpRoute"),
+    resolvePath: (input) => {
+      const trimmed = input.trim();
+      if (!trimmed) {
+        return params.rootDir;
+      }
+      if (path4.isAbsolute(trimmed)) {
+        return path4.resolve(expandHome2(trimmed));
+      }
+      return path4.resolve(params.rootDir, trimmed);
     }
   };
+  try {
+    const result = params.register(api);
+    if (result && typeof result === "object" && "then" in result) {
+      params.runtime.registry.diagnostics.push({
+        level: "warn",
+        pluginId: params.pluginId,
+        source: params.source,
+        message: "plugin register returned a promise; async registration is ignored"
+      });
+    }
+    return { ok: true };
+  } catch (err) {
+    const error = `plugin failed during register: ${String(err)}`;
+    return { ok: false, error };
+  }
 }
 
-// src/plugins/bundled/channels/telegram.ts
-var plugin = createBundledChannelPlugin({
-  channelId: "telegram",
-  name: "Builtin Telegram Channel",
-  description: "Builtin NextClaw channel plugin for telegram"
-});
-var telegram_default = plugin;
-
-// src/plugins/bundled/channels/whatsapp.ts
-var plugin2 = createBundledChannelPlugin({
-  channelId: "whatsapp",
-  name: "Builtin WhatsApp Channel",
-  description: "Builtin NextClaw channel plugin for whatsapp"
-});
-var whatsapp_default = plugin2;
-
-// src/plugins/bundled/channels/discord.ts
-var plugin3 = createBundledChannelPlugin({
-  channelId: "discord",
-  name: "Builtin Discord Channel",
-  description: "Builtin NextClaw channel plugin for discord"
-});
-var discord_default = plugin3;
-
-// src/plugins/bundled/channels/feishu.ts
-var plugin4 = createBundledChannelPlugin({
-  channelId: "feishu",
-  name: "Builtin Feishu Channel",
-  description: "Builtin NextClaw channel plugin for feishu"
-});
-var feishu_default = plugin4;
-
-// src/plugins/bundled/channels/mochat.ts
-var plugin5 = createBundledChannelPlugin({
-  channelId: "mochat",
-  name: "Builtin Mochat Channel",
-  description: "Builtin NextClaw channel plugin for mochat"
-});
-var mochat_default = plugin5;
-
-// src/plugins/bundled/channels/dingtalk.ts
-var plugin6 = createBundledChannelPlugin({
-  channelId: "dingtalk",
-  name: "Builtin DingTalk Channel",
-  description: "Builtin NextClaw channel plugin for dingtalk"
-});
-var dingtalk_default = plugin6;
-
-// src/plugins/bundled/channels/email.ts
-var plugin7 = createBundledChannelPlugin({
-  channelId: "email",
-  name: "Builtin Email Channel",
-  description: "Builtin NextClaw channel plugin for email"
-});
-var email_default = plugin7;
-
-// src/plugins/bundled/channels/slack.ts
-var plugin8 = createBundledChannelPlugin({
-  channelId: "slack",
-  name: "Builtin Slack Channel",
-  description: "Builtin NextClaw channel plugin for slack"
-});
-var slack_default = plugin8;
-
-// src/plugins/bundled/channels/qq.ts
-var plugin9 = createBundledChannelPlugin({
-  channelId: "qq",
-  name: "Builtin QQ Channel",
-  description: "Builtin NextClaw channel plugin for qq"
-});
-var qq_default = plugin9;
-
-// src/plugins/bundled/channels/index.ts
-var BUNDLED_CHANNEL_PLUGINS = [
-  telegram_default,
-  whatsapp_default,
-  discord_default,
-  feishu_default,
-  mochat_default,
-  dingtalk_default,
-  email_default,
-  slack_default,
-  qq_default
-];
-function listBundledChannelPluginDefinitions() {
-  return [...BUNDLED_CHANNEL_PLUGINS];
-}
-var BUNDLED_CHANNEL_PLUGIN_IDS = BUNDLED_CHANNEL_PLUGINS.map((plugin10) => plugin10.id).filter((id) => typeof id === "string" && id.trim().length > 0);
-
 // src/plugins/loader.ts
 var createJiti = createJitiImport;
 var defaultLogger2 = {
@@ -1427,21 +1652,47 @@ var defaultLogger2 = {
   error: (message) => console.error(message),
   debug: (message) => console.debug(message)
 };
+var BUNDLED_CHANNEL_PLUGIN_PACKAGES = [
+  "@nextclaw/channel-plugin-telegram",
+  "@nextclaw/channel-plugin-whatsapp",
+  "@nextclaw/channel-plugin-discord",
+  "@nextclaw/channel-plugin-feishu",
+  "@nextclaw/channel-plugin-mochat",
+  "@nextclaw/channel-plugin-dingtalk",
+  "@nextclaw/channel-plugin-email",
+  "@nextclaw/channel-plugin-slack",
+  "@nextclaw/channel-plugin-qq"
+];
+function resolvePackageRootFromEntry(entryFile) {
+  let cursor = path5.dirname(entryFile);
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = path5.join(cursor, "package.json");
+    if (fs5.existsSync(candidate)) {
+      return cursor;
+    }
+    const parent = path5.dirname(cursor);
+    if (parent === cursor) {
+      break;
+    }
+    cursor = parent;
+  }
+  return path5.dirname(entryFile);
+}
 function resolvePluginSdkAliasFile(params) {
   try {
     const modulePath = fileURLToPath(import.meta.url);
     const isProduction = process.env.NODE_ENV === "production";
-    let cursor = path4.dirname(modulePath);
+    let cursor = path5.dirname(modulePath);
     for (let i = 0; i < 6; i += 1) {
-      const srcCandidate = path4.join(cursor, "src", "plugin-sdk", params.srcFile);
-      const distCandidate = path4.join(cursor, "dist", "plugin-sdk", params.distFile);
+      const srcCandidate = path5.join(cursor, "src", "plugin-sdk", params.srcFile);
+      const distCandidate = path5.join(cursor, "dist", "plugin-sdk", params.distFile);
       const candidates = isProduction ? [distCandidate, srcCandidate] : [srcCandidate, distCandidate];
       for (const candidate of candidates) {
         if (fs5.existsSync(candidate)) {
           return candidate;
         }
       }
-      const parent = path4.dirname(cursor);
+      const parent = path5.dirname(cursor);
       if (parent === cursor) {
         break;
       }
@@ -1471,19 +1722,6 @@ function resolvePluginModuleExport(moduleExport) {
   }
   return {};
 }
-function normalizeToolList(value) {
-  if (!value) {
-    return [];
-  }
-  const list = Array.isArray(value) ? value : [value];
-  return list.filter((entry) => {
-    if (!entry || typeof entry !== "object") {
-      return false;
-    }
-    const candidate = entry;
-    return typeof candidate.name === "string" && candidate.name.trim().length > 0 && candidate.parameters !== void 0 && typeof candidate.execute === "function";
-  });
-}
 function createPluginRecord(params) {
   return {
     id: params.id,
@@ -1504,46 +1742,6 @@ function createPluginRecord(params) {
     configJsonSchema: params.configJsonSchema
   };
 }
-function buildPluginLogger(base, pluginId) {
-  const withPrefix = (message) => `[plugins:${pluginId}] ${message}`;
-  return {
-    info: (message) => base.info(withPrefix(message)),
-    warn: (message) => base.warn(withPrefix(message)),
-    error: (message) => base.error(withPrefix(message)),
-    debug: base.debug ? (message) => base.debug?.(withPrefix(message)) : void 0
-  };
-}
-function ensureUniqueNames(params) {
-  const accepted = [];
-  for (const rawName of params.names) {
-    const name = rawName.trim();
-    if (!name) {
-      continue;
-    }
-    if (params.reserved.has(name)) {
-      params.diagnostics.push({
-        level: "error",
-        pluginId: params.pluginId,
-        source: params.source,
-        message: `${params.kind} already registered by core: ${name}`
-      });
-      continue;
-    }
-    const owner = params.owners.get(name);
-    if (owner && owner !== params.pluginId) {
-      params.diagnostics.push({
-        level: "error",
-        pluginId: params.pluginId,
-        source: params.source,
-        message: `${params.kind} already registered: ${name} (${owner})`
-      });
-      continue;
-    }
-    params.owners.set(name, params.pluginId);
-    accepted.push(name);
-  }
-  return accepted;
-}
 function isPlaceholderConfigSchema(schema) {
   if (!schema || typeof schema !== "object") {
     return false;
@@ -1573,9 +1771,37 @@ function validatePluginConfig(params) {
   return { ok: false, errors: result.errors };
 }
 function appendBundledChannelPlugins(params) {
-  for (const definition of listBundledChannelPluginDefinitions()) {
-    const pluginId = typeof definition.id === "string" ? definition.id.trim() : "";
-    const source = `builtin:nextclaw-openclaw-compat/channels/${pluginId || "unknown"}`;
+  const require2 = createRequire(import.meta.url);
+  for (const packageName of BUNDLED_CHANNEL_PLUGIN_PACKAGES) {
+    let entryFile = "";
+    let rootDir = "";
+    try {
+      entryFile = require2.resolve(packageName);
+      rootDir = resolvePackageRootFromEntry(entryFile);
+    } catch (err) {
+      params.registry.diagnostics.push({
+        level: "error",
+        source: packageName,
+        message: `bundled plugin package not resolvable: ${String(err)}`
+      });
+      continue;
+    }
+    let moduleExport = null;
+    try {
+      moduleExport = params.jiti(entryFile);
+    } catch (err) {
+      params.registry.diagnostics.push({
+        level: "error",
+        source: entryFile,
+        message: `failed to load bundled plugin: ${String(err)}`
+      });
+      continue;
+    }
+    const resolved = resolvePluginModuleExport(moduleExport);
+    const definition = resolved.definition;
+    const register = resolved.register;
+    const pluginId = typeof definition?.id === "string" ? definition.id.trim() : "";
+    const source = entryFile;
     if (!pluginId) {
       params.registry.diagnostics.push({
         level: "error",
@@ -1586,18 +1812,17 @@ function appendBundledChannelPlugins(params) {
     }
     const record = createPluginRecord({
       id: pluginId,
-      name: definition.name ?? pluginId,
-      description: definition.description,
-      version: definition.version,
-      kind: definition.kind,
+      name: definition?.name ?? pluginId,
+      description: definition?.description,
+      version: definition?.version,
+      kind: definition?.kind,
       source,
       origin: "bundled",
-      workspaceDir: params.workspaceDir,
+      workspaceDir: params.runtime.workspaceDir,
       enabled: true,
-      configSchema: Boolean(definition.configSchema),
-      configJsonSchema: definition.configSchema
+      configSchema: Boolean(definition?.configSchema),
+      configJsonSchema: definition?.configSchema
     });
-    const register = definition.register ?? definition.activate;
     if (typeof register !== "function") {
       record.status = "error";
       record.error = "plugin export missing register/activate";
@@ -1610,203 +1835,26 @@ function appendBundledChannelPlugins(params) {
       });
       continue;
     }
-    const pluginRuntime = createPluginRuntime({ workspace: params.workspaceDir, config: params.config });
-    const pluginLogger = buildPluginLogger(params.logger, pluginId);
-    const pushUnsupported = (capability) => {
-      params.registry.diagnostics.push({
-        level: "warn",
-        pluginId,
-        source,
-        message: `${capability} is not supported by nextclaw compat layer yet`
-      });
-      pluginLogger.warn(`${capability} is ignored (not supported yet)`);
-    };
-    const api = {
-      id: pluginId,
-      name: record.name,
-      version: record.version,
-      description: record.description,
+    const result = registerPluginWithApi({
+      runtime: params.runtime,
+      record,
+      pluginId,
       source,
-      config: params.config,
-      pluginConfig: void 0,
-      runtime: pluginRuntime,
-      logger: pluginLogger,
-      registerTool: () => pushUnsupported("registerTool"),
-      registerChannel: (registration) => {
-        const normalizedChannel = registration && typeof registration === "object" && "plugin" in registration ? registration.plugin : registration;
-        if (!normalizedChannel || typeof normalizedChannel !== "object") {
-          params.registry.diagnostics.push({
-            level: "error",
-            pluginId,
-            source,
-            message: "channel registration missing plugin object"
-          });
-          return;
-        }
-        const channelObj = normalizedChannel;
-        const rawId = typeof channelObj.id === "string" ? channelObj.id : String(channelObj.id ?? "");
-        const accepted = ensureUniqueNames({
-          names: [rawId],
-          pluginId,
-          diagnostics: params.registry.diagnostics,
-          source,
-          owners: params.channelIdOwners,
-          reserved: params.reservedChannelIds,
-          kind: "channel"
-        });
-        if (accepted.length === 0) {
-          return;
-        }
-        const channelPlugin = normalizedChannel;
-        params.registry.channels.push({
-          pluginId,
-          channel: channelPlugin,
-          source
-        });
-        const channelId = accepted[0];
-        record.channelIds.push(channelId);
-        const configSchema = channelPlugin.configSchema;
-        if (configSchema && typeof configSchema === "object") {
-          const schema = configSchema.schema;
-          if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-            record.configJsonSchema = schema;
-            record.configSchema = true;
-          }
-          const uiHints = configSchema.uiHints;
-          if (uiHints && typeof uiHints === "object" && !Array.isArray(uiHints)) {
-            record.configUiHints = {
-              ...record.configUiHints ?? {},
-              ...uiHints
-            };
-          }
-        }
-        const pushChannelTools = (value, optional, sourceLabel, resolveValue) => {
-          const previewTools = normalizeToolList(value);
-          if (previewTools.length === 0) {
-            return;
-          }
-          const declaredNames = previewTools.map((tool) => tool.name);
-          const acceptedNames = ensureUniqueNames({
-            names: declaredNames,
-            pluginId,
-            diagnostics: params.registry.diagnostics,
-            source,
-            owners: params.toolNameOwners,
-            reserved: params.reservedToolNames,
-            kind: "tool"
-          });
-          if (acceptedNames.length === 0) {
-            return;
-          }
-          const factory = (ctx) => {
-            const tools = normalizeToolList(resolveValue(ctx));
-            if (tools.length === 0) {
-              return [];
-            }
-            const byName = new Map(tools.map((tool) => [tool.name, tool]));
-            return acceptedNames.map((name) => byName.get(name)).filter(Boolean);
-          };
-          params.registry.tools.push({
-            pluginId,
-            factory,
-            names: acceptedNames,
-            optional,
-            source
-          });
-          record.toolNames.push(...acceptedNames);
-          const previewByName = new Map(previewTools.map((tool) => [tool.name, tool]));
-          for (const name of acceptedNames) {
-            const resolvedTool = previewByName.get(name);
-            if (!resolvedTool || params.resolvedToolNames.has(resolvedTool.name)) {
-              continue;
-            }
-            params.resolvedToolNames.add(resolvedTool.name);
-            params.registry.resolvedTools.push(resolvedTool);
-          }
-          params.registry.diagnostics.push({
-            level: "warn",
-            pluginId,
-            source,
-            message: `${sourceLabel} registered channel-owned tools: ${acceptedNames.join(", ")}`
-          });
-        };
-        const agentTools = channelPlugin.agentTools;
-        if (typeof agentTools === "function") {
-          pushChannelTools(
-            normalizeToolList(agentTools()),
-            false,
-            `channel "${channelId}"`,
-            () => agentTools()
-          );
-        } else if (agentTools) {
-          pushChannelTools(
-            normalizeToolList(agentTools),
-            false,
-            `channel "${channelId}"`,
-            () => agentTools
-          );
-        }
-      },
-      registerProvider: (provider) => {
-        const accepted = ensureUniqueNames({
-          names: [provider.id],
-          pluginId,
-          diagnostics: params.registry.diagnostics,
-          source,
-          owners: params.providerIdOwners,
-          reserved: params.reservedProviderIds,
-          kind: "provider"
-        });
-        if (accepted.length === 0) {
-          return;
-        }
-        params.registry.providers.push({
-          pluginId,
-          provider,
-          source
-        });
-        record.providerIds.push(accepted[0]);
-      },
-      registerHook: () => pushUnsupported("registerHook"),
-      registerGatewayMethod: () => pushUnsupported("registerGatewayMethod"),
-      registerCli: () => pushUnsupported("registerCli"),
-      registerService: () => pushUnsupported("registerService"),
-      registerCommand: () => pushUnsupported("registerCommand"),
-      registerHttpHandler: () => pushUnsupported("registerHttpHandler"),
-      registerHttpRoute: () => pushUnsupported("registerHttpRoute"),
-      resolvePath: (input) => {
-        const trimmed = input.trim();
-        if (!trimmed) {
-          return params.workspaceDir;
-        }
-        if (path4.isAbsolute(trimmed)) {
-          return path4.resolve(expandHome2(trimmed));
-        }
-        return path4.resolve(params.workspaceDir, trimmed);
-      }
-    };
-    try {
-      const result = register(api);
-      if (result && typeof result === "object" && "then" in result) {
-        params.registry.diagnostics.push({
-          level: "warn",
-          pluginId,
-          source,
-          message: "plugin register returned a promise; async registration is ignored"
-        });
-      }
-      params.registry.plugins.push(record);
-    } catch (err) {
+      rootDir,
+      register,
+      pluginConfig: void 0
+    });
+    if (!result.ok) {
       record.status = "error";
-      record.error = `plugin failed during register: ${String(err)}`;
-      params.registry.plugins.push(record);
+      record.error = result.error;
       params.registry.diagnostics.push({
         level: "error",
         pluginId,
         source,
-        message: record.error
+        message: result.error
       });
     }
+    params.registry.plugins.push(record);
   }
 }
 function loadOpenClawPlugins(options) {
@@ -1823,26 +1871,33 @@ function loadOpenClawPlugins(options) {
     diagnostics: [],
     resolvedTools: []
   };
-  const toolNameOwners = /* @__PURE__ */ new Map();
-  const channelIdOwners = /* @__PURE__ */ new Map();
-  const providerIdOwners = /* @__PURE__ */ new Map();
-  const resolvedToolNames = /* @__PURE__ */ new Set();
   const reservedToolNames = new Set(options.reservedToolNames ?? []);
   const reservedChannelIds = new Set(options.reservedChannelIds ?? []);
   const reservedProviderIds = new Set(options.reservedProviderIds ?? []);
-  appendBundledChannelPlugins({
-    registry,
+  const registerRuntime = createPluginRegisterRuntime({
     config: options.config,
-    logger,
     workspaceDir,
-    toolNameOwners,
-    channelIdOwners,
-    providerIdOwners,
-    resolvedToolNames,
+    logger,
+    registry,
     reservedToolNames,
     reservedChannelIds,
     reservedProviderIds
   });
+  const pluginSdkAlias = resolvePluginSdkAlias();
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
+    ...pluginSdkAlias ? {
+      alias: {
+        "openclaw/plugin-sdk": pluginSdkAlias
+      }
+    } : {}
+  });
+  appendBundledChannelPlugins({
+    registry,
+    runtime: registerRuntime,
+    jiti
+  });
   if (!loadExternalPlugins) {
     return registry;
   }
@@ -1859,17 +1914,9 @@ function loadOpenClawPlugins(options) {
   });
   registry.diagnostics.push(...manifestRegistry.diagnostics);
   const manifestByRoot = new Map(manifestRegistry.plugins.map((entry) => [entry.rootDir, entry]));
-  const seenIds = /* @__PURE__ */ new Map();
-  const pluginSdkAlias = resolvePluginSdkAlias();
-  const jiti = createJiti(import.meta.url, {
-    interopDefault: true,
-    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
-    ...pluginSdkAlias ? {
-      alias: {
-        "openclaw/plugin-sdk": pluginSdkAlias
-      }
-    } : {}
-  });
+  const seenIds = new Map(
+    registry.plugins.map((entry) => [entry.id, entry.origin])
+  );
   for (const candidate of discovery.candidates) {
     const manifest = manifestByRoot.get(candidate.rootDir);
     if (!manifest) {
@@ -2000,264 +2047,30 @@ function loadOpenClawPlugins(options) {
       });
       continue;
     }
-    const pluginRuntime = createPluginRuntime({ workspace: workspaceDir, config: options.config });
-    const pluginLogger = buildPluginLogger(logger, pluginId);
-    const pushUnsupported = (capability) => {
-      registry.diagnostics.push({
-        level: "warn",
-        pluginId,
-        source: candidate.source,
-        message: `${capability} is not supported by nextclaw compat layer yet`
-      });
-      pluginLogger.warn(`${capability} is ignored (not supported yet)`);
-    };
-    const api = {
-      id: pluginId,
-      name: record.name,
-      version: record.version,
-      description: record.description,
+    const registerResult = registerPluginWithApi({
+      runtime: registerRuntime,
+      record,
+      pluginId,
       source: candidate.source,
-      config: options.config,
-      pluginConfig: validatedConfig.value,
-      runtime: pluginRuntime,
-      logger: pluginLogger,
-      registerTool: (tool, opts) => {
-        const declaredNames = opts && Array.isArray(opts.names) ? opts.names : [];
-        const names = [...declaredNames, ...opts && opts.name ? [opts.name] : []];
-        if (typeof tool !== "function" && typeof tool.name === "string") {
-          names.push(tool.name);
-        }
-        const uniqueNames = Array.from(new Set(names.map((name) => name.trim()).filter(Boolean)));
-        const acceptedNames = ensureUniqueNames({
-          names: uniqueNames,
-          pluginId,
-          diagnostics: registry.diagnostics,
-          source: candidate.source,
-          owners: toolNameOwners,
-          reserved: reservedToolNames,
-          kind: "tool"
-        });
-        if (acceptedNames.length === 0) {
-          registry.diagnostics.push({
-            level: "warn",
-            pluginId,
-            source: candidate.source,
-            message: "tool registration skipped: no available tool names"
-          });
-          return;
-        }
-        const factory = typeof tool === "function" ? tool : (_ctx) => tool;
-        registry.tools.push({
-          pluginId,
-          factory,
-          names: acceptedNames,
-          optional: opts?.optional === true,
-          source: candidate.source
-        });
-        record.toolNames.push(...acceptedNames);
-        try {
-          const previewTools = normalizeToolList(
-            factory({
-              config: options.config,
-              workspaceDir,
-              sandboxed: false
-            })
-          );
-          const byName = new Map(previewTools.map((entry2) => [entry2.name, entry2]));
-          for (const name of acceptedNames) {
-            const resolvedTool = byName.get(name);
-            if (!resolvedTool || resolvedToolNames.has(resolvedTool.name)) {
-              continue;
-            }
-            resolvedToolNames.add(resolvedTool.name);
-            registry.resolvedTools.push(resolvedTool);
-          }
-        } catch (err) {
-          registry.diagnostics.push({
-            level: "warn",
-            pluginId,
-            source: candidate.source,
-            message: `tool preview failed: ${String(err)}`
-          });
-        }
-      },
-      registerChannel: (registration) => {
-        const normalizedChannel = registration && typeof registration === "object" && "plugin" in registration ? registration.plugin : registration;
-        if (!normalizedChannel || typeof normalizedChannel !== "object") {
-          registry.diagnostics.push({
-            level: "error",
-            pluginId,
-            source: candidate.source,
-            message: "channel registration missing plugin object"
-          });
-          return;
-        }
-        const channelObj = normalizedChannel;
-        const rawId = typeof channelObj.id === "string" ? channelObj.id : String(channelObj.id ?? "");
-        const accepted = ensureUniqueNames({
-          names: [rawId],
-          pluginId,
-          diagnostics: registry.diagnostics,
-          source: candidate.source,
-          owners: channelIdOwners,
-          reserved: reservedChannelIds,
-          kind: "channel"
-        });
-        if (accepted.length === 0) {
-          return;
-        }
-        const channelPlugin = normalizedChannel;
-        registry.channels.push({
-          pluginId,
-          channel: channelPlugin,
-          source: candidate.source
-        });
-        const channelId = accepted[0];
-        record.channelIds.push(channelId);
-        const configSchema = channelPlugin.configSchema;
-        if (configSchema && typeof configSchema === "object") {
-          const schema = configSchema.schema;
-          if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-            record.configJsonSchema = schema;
-            record.configSchema = true;
-          }
-          const uiHints = configSchema.uiHints;
-          if (uiHints && typeof uiHints === "object" && !Array.isArray(uiHints)) {
-            record.configUiHints = {
-              ...record.configUiHints ?? {},
-              ...uiHints
-            };
-          }
-        }
-        const pushChannelTools = (value, optional, sourceLabel, resolveValue) => {
-          const previewTools = normalizeToolList(value);
-          if (previewTools.length === 0) {
-            return;
-          }
-          const declaredNames = previewTools.map((tool) => tool.name);
-          const acceptedNames = ensureUniqueNames({
-            names: declaredNames,
-            pluginId,
-            diagnostics: registry.diagnostics,
-            source: candidate.source,
-            owners: toolNameOwners,
-            reserved: reservedToolNames,
-            kind: "tool"
-          });
-          if (acceptedNames.length === 0) {
-            return;
-          }
-          const factory = (ctx) => {
-            const tools = normalizeToolList(resolveValue(ctx));
-            if (tools.length === 0) {
-              return [];
-            }
-            const byName = new Map(tools.map((tool) => [tool.name, tool]));
-            return acceptedNames.map((name) => byName.get(name)).filter(Boolean);
-          };
-          registry.tools.push({
-            pluginId,
-            factory,
-            names: acceptedNames,
-            optional,
-            source: candidate.source
-          });
-          record.toolNames.push(...acceptedNames);
-          const previewByName = new Map(previewTools.map((tool) => [tool.name, tool]));
-          for (const name of acceptedNames) {
-            const resolvedTool = previewByName.get(name);
-            if (!resolvedTool || resolvedToolNames.has(resolvedTool.name)) {
-              continue;
-            }
-            resolvedToolNames.add(resolvedTool.name);
-            registry.resolvedTools.push(resolvedTool);
-          }
-          registry.diagnostics.push({
-            level: "warn",
-            pluginId,
-            source: candidate.source,
-            message: `${sourceLabel} registered channel-owned tools: ${acceptedNames.join(", ")}`
-          });
-        };
-        const agentTools = channelPlugin.agentTools;
-        if (typeof agentTools === "function") {
-          pushChannelTools(
-            normalizeToolList(agentTools()),
-            false,
-            `channel "${channelId}"`,
-            () => agentTools()
-          );
-        } else if (agentTools) {
-          pushChannelTools(
-            normalizeToolList(agentTools),
-            false,
-            `channel "${channelId}"`,
-            () => agentTools
-          );
-        }
-      },
-      registerProvider: (provider) => {
-        const accepted = ensureUniqueNames({
-          names: [provider.id],
-          pluginId,
-          diagnostics: registry.diagnostics,
-          source: candidate.source,
-          owners: providerIdOwners,
-          reserved: reservedProviderIds,
-          kind: "provider"
-        });
-        if (accepted.length === 0) {
-          return;
-        }
-        registry.providers.push({
-          pluginId,
-          provider,
-          source: candidate.source
-        });
-        record.providerIds.push(accepted[0]);
-      },
-      registerHook: () => pushUnsupported("registerHook"),
-      registerGatewayMethod: () => pushUnsupported("registerGatewayMethod"),
-      registerCli: () => pushUnsupported("registerCli"),
-      registerService: () => pushUnsupported("registerService"),
-      registerCommand: () => pushUnsupported("registerCommand"),
-      registerHttpHandler: () => pushUnsupported("registerHttpHandler"),
-      registerHttpRoute: () => pushUnsupported("registerHttpRoute"),
-      resolvePath: (input) => {
-        const trimmed = input.trim();
-        if (!trimmed) {
-          return candidate.rootDir;
-        }
-        if (path4.isAbsolute(trimmed)) {
-          return path4.resolve(expandHome2(trimmed));
-        }
-        return path4.resolve(candidate.rootDir, trimmed);
-      }
-    };
-    try {
-      const result = register(api);
-      if (result && typeof result === "object" && "then" in result) {
-        registry.diagnostics.push({
-          level: "warn",
-          pluginId,
-          source: candidate.source,
-          message: "plugin register returned a promise; async registration is ignored"
-        });
-      }
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
-    } catch (err) {
+      rootDir: candidate.rootDir,
+      register,
+      pluginConfig: validatedConfig.value
+    });
+    if (!registerResult.ok) {
       record.status = "error";
-      record.error = `plugin failed during register: ${String(err)}`;
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
+      record.error = registerResult.error;
       registry.diagnostics.push({
         level: "error",
         pluginId,
         source: candidate.source,
-        message: record.error
+        message: registerResult.error
       });
+      registry.plugins.push(record);
+      seenIds.set(pluginId, candidate.origin);
+      continue;
     }
+    registry.plugins.push(record);
+    seenIds.set(pluginId, candidate.origin);
   }
   return registry;
 }
@@ -2282,7 +2095,7 @@ function buildPluginStatusReport(params) {
 
 // src/plugins/uninstall.ts
 import fs6 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 function isLinkedPathInstall(record) {
   if (!record || record.source !== "path") {
     return false;
@@ -2290,7 +2103,7 @@ function isLinkedPathInstall(record) {
   if (!record.sourcePath || !record.installPath) {
     return true;
   }
-  return path5.resolve(record.sourcePath) === path5.resolve(record.installPath);
+  return path6.resolve(record.sourcePath) === path6.resolve(record.installPath);
 }
 function resolveUninstallDirectoryTarget(params) {
   if (!params.hasInstall) {
@@ -2309,7 +2122,7 @@ function resolveUninstallDirectoryTarget(params) {
   if (!configuredPath) {
     return defaultPath;
   }
-  if (path5.resolve(configuredPath) === path5.resolve(defaultPath)) {
+  if (path6.resolve(configuredPath) === path6.resolve(defaultPath)) {
     return configuredPath;
   }
   return defaultPath;
@@ -2435,6 +2248,8 @@ export {
   buildChannelConfigSchema,
   buildOauthProviderAuthResult,
   buildPluginStatusReport,
+  createNextclawBuiltinChannelPlugin,
+  createPluginRegisterRuntime,
   createPluginRuntime,
   disablePluginInConfig,
   discoverOpenClawPlugins,
@@ -2456,6 +2271,7 @@ export {
   normalizePluginHttpPath,
   normalizePluginsConfig,
   recordPluginInstall,
+  registerPluginWithApi,
   removePluginFromConfig,
   resolveEnableState,
   resolvePluginChannelMessageToolHints,