@nextclaw/openclaw-compat 0.1.5 → 0.1.7

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '@nextclaw/core';
+import { Config, ExtensionChannel } from '@nextclaw/core';
 
 type PluginConfigUiHint = {
     label?: string;
@@ -105,6 +105,7 @@ type OpenClawChannelPlugin = {
     id: string;
     meta?: Record<string, unknown>;
     capabilities?: Record<string, unknown>;
+    nextclaw?: ExtensionChannel["nextclaw"];
     configSchema?: OpenClawChannelConfigSchema;
     config?: OpenClawChannelConfigAdapter;
     setup?: OpenClawChannelSetup;
@@ -136,6 +137,7 @@ type OpenClawPluginDefinition = {
     description?: string;
     version?: string;
     kind?: PluginKind;
+    configSchema?: Record<string, unknown>;
     register?: (api: OpenClawPluginApi) => void | Promise<void>;
     activate?: (api: OpenClawPluginApi) => void | Promise<void>;
 };
@@ -518,6 +520,43 @@ declare function createPluginRuntime(params: {
     config?: Config;
 }): PluginRuntime;
 
+type PluginRegisterRuntime = {
+    config: Config;
+    workspaceDir: string;
+    logger: PluginLogger;
+    registry: PluginRegistry;
+    toolNameOwners: Map<string, string>;
+    channelIdOwners: Map<string, string>;
+    providerIdOwners: Map<string, string>;
+    resolvedToolNames: Set<string>;
+    reservedToolNames: Set<string>;
+    reservedChannelIds: Set<string>;
+    reservedProviderIds: Set<string>;
+};
+declare function createPluginRegisterRuntime(params: {
+    config: Config;
+    workspaceDir: string;
+    logger: PluginLogger;
+    registry: PluginRegistry;
+    reservedToolNames: Set<string>;
+    reservedChannelIds: Set<string>;
+    reservedProviderIds: Set<string>;
+}): PluginRegisterRuntime;
+declare function registerPluginWithApi(params: {
+    runtime: PluginRegisterRuntime;
+    record: PluginRecord;
+    pluginId: string;
+    source: string;
+    rootDir: string;
+    register: (api: OpenClawPluginApi) => void | Promise<void>;
+    pluginConfig?: Record<string, unknown>;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+
 declare function validateJsonSchemaValue(params: {
     schema: Record<string, unknown>;
     cacheKey: string;
@@ -576,4 +615,4 @@ declare function uninstallPlugin(params: {
     extensionsDir?: string;
 }): Promise<UninstallPluginResult>;
 
-export { DEFAULT_ACCOUNT_ID, type InstallPluginResult, type NormalizedPluginsConfig, type OpenClawChannelAgentPrompt, type OpenClawChannelConfigAdapter, type OpenClawChannelConfigSchema, type OpenClawChannelGateway, type OpenClawChannelGatewayStartContext, type OpenClawChannelPlugin, type OpenClawChannelSetup, type OpenClawPluginApi, type OpenClawPluginChannelRegistration, type OpenClawPluginConfigSchema, type OpenClawPluginDefinition, type OpenClawPluginModule, type OpenClawPluginTool, type OpenClawPluginToolContext, type OpenClawPluginToolFactory, type OpenClawPluginToolOptions, type OpenClawProviderPlugin, PLUGIN_MANIFEST_FILENAME, PLUGIN_MANIFEST_FILENAMES, type PackageManifest, type PluginCandidate, type PluginChannelBinding, type PluginChannelGatewayHandle, type PluginChannelRegistration, type PluginConfigUiHint, type PluginDiagnostic, type PluginDiscoveryResult, type PluginInstallLogger, type PluginInstallSource, type PluginInstallUpdate, type PluginKind, type PluginLoadOptions, type PluginLogger, type PluginManifest, type PluginManifestLoadResult, type PluginManifestRecord, type PluginManifestRegistry, type PluginOrigin, type PluginProviderRegistration, type PluginRecord, type PluginRegistry, type PluginReplyDispatchParams, type PluginRuntime, type PluginRuntimeBridge, type PluginStatusReport, type PluginToolRegistration, type PluginUiMetadata, type UninstallActions, type UninstallPluginResult, type _CompatOnly, __nextclawPluginSdkCompat, addPluginLoadPath, buildChannelConfigSchema, buildOauthProviderAuthResult, buildPluginStatusReport, createPluginRuntime, disablePluginInConfig, discoverOpenClawPlugins, emptyPluginConfigSchema, enablePluginInConfig, getPackageManifestMetadata, getPluginChannelBindings, getPluginUiMetadataFromRegistry, installPluginFromArchive, installPluginFromDir, installPluginFromFile, installPluginFromNpmSpec, installPluginFromPath, loadOpenClawPlugins, loadPluginManifest, loadPluginManifestRegistry, loadPluginUiMetadata, normalizeAccountId, normalizePluginHttpPath, normalizePluginsConfig, recordPluginInstall, removePluginFromConfig, resolveEnableState, resolvePluginChannelMessageToolHints, resolvePluginInstallDir, resolvePluginManifestPath, resolveUninstallDirectoryTarget, setPluginRuntimeBridge, sleep, startPluginChannelGateways, stopPluginChannelGateways, toPluginUiMetadata, uninstallPlugin, validateJsonSchemaValue };
+export { DEFAULT_ACCOUNT_ID, type InstallPluginResult, type NormalizedPluginsConfig, type OpenClawChannelAgentPrompt, type OpenClawChannelConfigAdapter, type OpenClawChannelConfigSchema, type OpenClawChannelGateway, type OpenClawChannelGatewayStartContext, type OpenClawChannelPlugin, type OpenClawChannelSetup, type OpenClawPluginApi, type OpenClawPluginChannelRegistration, type OpenClawPluginConfigSchema, type OpenClawPluginDefinition, type OpenClawPluginModule, type OpenClawPluginTool, type OpenClawPluginToolContext, type OpenClawPluginToolFactory, type OpenClawPluginToolOptions, type OpenClawProviderPlugin, PLUGIN_MANIFEST_FILENAME, PLUGIN_MANIFEST_FILENAMES, type PackageManifest, type PluginCandidate, type PluginChannelBinding, type PluginChannelGatewayHandle, type PluginChannelRegistration, type PluginConfigUiHint, type PluginDiagnostic, type PluginDiscoveryResult, type PluginInstallLogger, type PluginInstallSource, type PluginInstallUpdate, type PluginKind, type PluginLoadOptions, type PluginLogger, type PluginManifest, type PluginManifestLoadResult, type PluginManifestRecord, type PluginManifestRegistry, type PluginOrigin, type PluginProviderRegistration, type PluginRecord, type PluginRegisterRuntime, type PluginRegistry, type PluginReplyDispatchParams, type PluginRuntime, type PluginRuntimeBridge, type PluginStatusReport, type PluginToolRegistration, type PluginUiMetadata, type UninstallActions, type UninstallPluginResult, type _CompatOnly, __nextclawPluginSdkCompat, addPluginLoadPath, buildChannelConfigSchema, buildOauthProviderAuthResult, buildPluginStatusReport, createPluginRegisterRuntime, createPluginRuntime, disablePluginInConfig, discoverOpenClawPlugins, emptyPluginConfigSchema, enablePluginInConfig, getPackageManifestMetadata, getPluginChannelBindings, getPluginUiMetadataFromRegistry, installPluginFromArchive, installPluginFromDir, installPluginFromFile, installPluginFromNpmSpec, installPluginFromPath, loadOpenClawPlugins, loadPluginManifest, loadPluginManifestRegistry, loadPluginUiMetadata, normalizeAccountId, normalizePluginHttpPath, normalizePluginsConfig, recordPluginInstall, registerPluginWithApi, removePluginFromConfig, resolveEnableState, resolvePluginChannelMessageToolHints, resolvePluginInstallDir, resolvePluginManifestPath, resolveUninstallDirectoryTarget, setPluginRuntimeBridge, sleep, startPluginChannelGateways, stopPluginChannelGateways, toPluginUiMetadata, uninstallPlugin, validateJsonSchemaValue };

package/dist/index.js

@@ -224,10 +224,10 @@ function resolvePluginChannelMessageToolHints(params) {
   }
 }
 function getPluginUiMetadataFromRegistry(registry) {
-  return registry.plugins.map((plugin) => ({
-    id: plugin.id,
-    configSchema: plugin.configJsonSchema,
-    configUiHints: plugin.configUiHints
+  return registry.plugins.map((plugin10) => ({
+    id: plugin10.id,
+    configSchema: plugin10.configJsonSchema,
+    configUiHints: plugin10.configUiHints
   }));
 }
 async function startPluginChannelGateways(params) {
@@ -1057,11 +1057,10 @@ 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 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 +1207,169 @@ 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/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}`);
+  }
+  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
+          }
+        }
+      });
+    }
+  };
+}
+
+// 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/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,37 +1422,337 @@ 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) {
+  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);
+  }
+}
+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);
+  }
+}
+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 };
   }
-  return { ok: false, errors: formatAjvErrors(cached.validate.errors) };
 }
 
 // src/plugins/loader.ts
@@ -1305,17 +1767,17 @@ 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;
       }
@@ -1345,19 +1807,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,
@@ -1378,46 +1827,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;
@@ -1446,17 +1855,68 @@ function validatePluginConfig(params) {
   }
   return { ok: false, errors: result.errors };
 }
-function loadOpenClawPlugins(options) {
-  if (process.env.NEXTCLAW_ENABLE_OPENCLAW_PLUGINS === "0") {
-    return {
-      plugins: [],
-      tools: [],
-      channels: [],
-      providers: [],
-      diagnostics: [],
-      resolvedTools: []
-    };
+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"}`;
+    if (!pluginId) {
+      params.registry.diagnostics.push({
+        level: "error",
+        source,
+        message: "bundled plugin definition missing id"
+      });
+      continue;
+    }
+    const record = createPluginRecord({
+      id: pluginId,
+      name: definition.name ?? pluginId,
+      description: definition.description,
+      version: definition.version,
+      kind: definition.kind,
+      source,
+      origin: "bundled",
+      workspaceDir: params.runtime.workspaceDir,
+      enabled: true,
+      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";
+      params.registry.plugins.push(record);
+      params.registry.diagnostics.push({
+        level: "error",
+        pluginId,
+        source,
+        message: record.error
+      });
+      continue;
+    }
+    const result = registerPluginWithApi({
+      runtime: params.runtime,
+      record,
+      pluginId,
+      source,
+      rootDir: params.runtime.workspaceDir,
+      register,
+      pluginConfig: void 0
+    });
+    if (!result.ok) {
+      record.status = "error";
+      record.error = result.error;
+      params.registry.diagnostics.push({
+        level: "error",
+        pluginId,
+        source,
+        message: result.error
+      });
+    }
+    params.registry.plugins.push(record);
   }
+}
+function loadOpenClawPlugins(options) {
+  const loadExternalPlugins = process.env.NEXTCLAW_ENABLE_OPENCLAW_PLUGINS !== "0";
   const logger = options.logger ?? defaultLogger2;
   const workspaceDir = options.workspaceDir?.trim() || getWorkspacePathFromConfig(options.config);
   const normalized = normalizePluginsConfig(options.config.plugins);
@@ -1469,13 +1929,25 @@ 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 ?? []);
+  const registerRuntime = createPluginRegisterRuntime({
+    config: options.config,
+    workspaceDir,
+    logger,
+    registry,
+    reservedToolNames,
+    reservedChannelIds,
+    reservedProviderIds
+  });
+  appendBundledChannelPlugins({
+    registry,
+    runtime: registerRuntime
+  });
+  if (!loadExternalPlugins) {
+    return registry;
+  }
   const discovery = discoverOpenClawPlugins({
     config: options.config,
     workspaceDir,
@@ -1630,264 +2102,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;
 }
@@ -1912,7 +2150,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;
@@ -1920,7 +2158,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) {
@@ -1939,7 +2177,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;
@@ -2065,6 +2303,7 @@ export {
   buildChannelConfigSchema,
   buildOauthProviderAuthResult,
   buildPluginStatusReport,
+  createPluginRegisterRuntime,
   createPluginRuntime,
   disablePluginInConfig,
   discoverOpenClawPlugins,
@@ -2086,6 +2325,7 @@ export {
   normalizePluginHttpPath,
   normalizePluginsConfig,
   recordPluginInstall,
+  registerPluginWithApi,
   removePluginFromConfig,
   resolveEnableState,
   resolvePluginChannelMessageToolHints,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/openclaw-compat",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "private": false,
   "description": "OpenClaw plugin compatibility layer for NextClaw.",
   "type": "module",
@@ -18,7 +18,7 @@
     "jiti": "^1.21.7",
     "jszip": "^3.10.1",
     "tar": "^7.4.3",
-    "@nextclaw/core": "^0.6.2"
+    "@nextclaw/core": "^0.6.16"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",