@alfe.ai/openclaw-mcp-bundler 0.0.1

package/dist/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_plugin = require("./plugin2.cjs");
+exports.default = require_plugin.plugin;
+exports.detectNativeBundleMcp = require_plugin.detectNativeBundleMcp;

package/dist/index.d.cts

@@ -0,0 +1,45 @@
+import { t as plugin } from "./plugin.cjs";
+
+//#region src/cli-backend-detect.d.ts
+
+/**
+ * Determine whether the active agent's CLI backend already has native bundle-MCP
+ * support. If so, our plugin should no-op so we don't double-register tools.
+ *
+ * As of OpenClaw 2026.4 only `claude-cli` and `codex-cli` ship with
+ * `bundleMcp: true`. We hardcode that allowlist for now; future backends
+ * shipping with bundleMcp:true will need to be added here (or, ideally,
+ * OpenClaw exposes a public API to query the resolved backend's bundleMcp
+ * flag and we call that instead — see project_openclaw_mcp_bundler.md TODO).
+ *
+ * This detection is best-effort: if we can't determine the backend (no
+ * runtime config available), we default to "no native MCP" (return false)
+ * so our plugin DOES register. Worst case is benign duplicate tool names
+ * with `-2` suffix on claude-cli, which is recoverable; missing tools on
+ * MiniMax is the bug we exist to fix.
+ */
+interface ConfigLike {
+  agents?: {
+    defaults?: {
+      model?: string;
+      cliBackends?: Record<string, unknown>;
+    };
+  };
+}
+/**
+ * Read the active agent's primary model and infer its CLI backend.
+ * Returns true if that backend has native bundleMcp support.
+ *
+ * Heuristic mapping (matches what OpenClaw's plugin-setup-cli-backend
+ * registry resolves to today):
+ *   - model id containing "claude" or "anthropic" → claude-cli
+ *   - model id containing "codex" or "gpt-5-codex" or "openai/codex" → codex-cli
+ *   - everything else → no native bundle-mcp
+ *
+ * If `agents.defaults.cliBackends` explicitly configures one of the native
+ * backends, we trust that override.
+ */
+declare function detectNativeBundleMcp(cfg: ConfigLike | undefined): boolean;
+//#endregion
+export { plugin as default, detectNativeBundleMcp };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/cli-backend-detect.ts"],"mappings":";;;;;;;;AAyCA;;;;;;;;;;;;UAtBU,UAAA;;;;oBAIU;;;;;;;;;;;;;;;;;iBAkBJ,qBAAA,MAA2B"}

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+import { t as plugin } from "./plugin.js";
+
+//#region src/cli-backend-detect.d.ts
+
+/**
+ * Determine whether the active agent's CLI backend already has native bundle-MCP
+ * support. If so, our plugin should no-op so we don't double-register tools.
+ *
+ * As of OpenClaw 2026.4 only `claude-cli` and `codex-cli` ship with
+ * `bundleMcp: true`. We hardcode that allowlist for now; future backends
+ * shipping with bundleMcp:true will need to be added here (or, ideally,
+ * OpenClaw exposes a public API to query the resolved backend's bundleMcp
+ * flag and we call that instead — see project_openclaw_mcp_bundler.md TODO).
+ *
+ * This detection is best-effort: if we can't determine the backend (no
+ * runtime config available), we default to "no native MCP" (return false)
+ * so our plugin DOES register. Worst case is benign duplicate tool names
+ * with `-2` suffix on claude-cli, which is recoverable; missing tools on
+ * MiniMax is the bug we exist to fix.
+ */
+interface ConfigLike {
+  agents?: {
+    defaults?: {
+      model?: string;
+      cliBackends?: Record<string, unknown>;
+    };
+  };
+}
+/**
+ * Read the active agent's primary model and infer its CLI backend.
+ * Returns true if that backend has native bundleMcp support.
+ *
+ * Heuristic mapping (matches what OpenClaw's plugin-setup-cli-backend
+ * registry resolves to today):
+ *   - model id containing "claude" or "anthropic" → claude-cli
+ *   - model id containing "codex" or "gpt-5-codex" or "openai/codex" → codex-cli
+ *   - everything else → no native bundle-mcp
+ *
+ * If `agents.defaults.cliBackends` explicitly configures one of the native
+ * backends, we trust that override.
+ */
+declare function detectNativeBundleMcp(cfg: ConfigLike | undefined): boolean;
+//#endregion
+export { plugin as default, detectNativeBundleMcp };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/cli-backend-detect.ts"],"mappings":";;;;;;;;AAyCA;;;;;;;;;;;;UAtBU,UAAA;;;;oBAIU;;;;;;;;;;;;;;;;;iBAkBJ,qBAAA,MAA2B"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import { n as detectNativeBundleMcp, t as plugin } from "./plugin2.js";
+export { plugin as default, detectNativeBundleMcp };

package/dist/plugin.cjs

@@ -0,0 +1,2 @@
+const require_plugin = require("./plugin2.cjs");
+module.exports = require_plugin.plugin;

package/dist/plugin.d.cts

@@ -0,0 +1,88 @@
+//#region ../mcp-bundler/dist/index.d.ts
+//#region src/types.d.ts
+/**
+ * Shape of a single MCP server entry — matches OpenClaw `mcp.servers.{name}`.
+ * Either a stdio child process spec or a remote URL spec.
+ */
+type McpServerConfig = StdioServerConfig | RemoteServerConfig;
+interface StdioServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+}
+interface RemoteServerConfig {
+  url: string;
+  transport?: 'sse' | 'streamable-http';
+  headers?: Record<string, string>;
+  connectionTimeoutMs?: number;
+}
+//#endregion
+//#region src/plugin.d.ts
+
+interface Logger {
+  debug(msg: string, ...args: unknown[]): void;
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+}
+interface ConfigSnapshot {
+  agents?: {
+    defaults?: {
+      model?: string;
+      cliBackends?: Record<string, unknown>;
+    };
+  };
+  mcp?: {
+    servers?: Record<string, McpServerConfig>;
+    sessionIdleTtlMs?: number;
+  };
+}
+interface AgentToolResult {
+  content: Record<string, unknown>[];
+  details?: Record<string, unknown>;
+}
+interface AgentTool {
+  name: string;
+  label?: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  execute: (toolCallId: string, params: unknown, signal?: AbortSignal, onUpdate?: (update: unknown) => void) => Promise<AgentToolResult>;
+}
+interface ToolFactoryContext {
+  config?: ConfigSnapshot;
+  runtimeConfig?: ConfigSnapshot;
+  getRuntimeConfig?: () => ConfigSnapshot | undefined;
+}
+interface OpenClawPluginApi {
+  logger: Logger;
+  config?: ConfigSnapshot;
+  pluginConfig?: {
+    disabled?: boolean;
+  };
+  registrationMode?: string;
+  runtime?: {
+    config?: {
+      current?: () => ConfigSnapshot | undefined;
+    };
+  };
+  registerTool: (tool: AgentTool | ((ctx: ToolFactoryContext) => AgentTool | AgentTool[] | null | undefined), opts?: {
+    name?: string;
+    names?: string[];
+    optional?: boolean;
+  }) => void;
+}
+declare const plugin: {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  contracts: {
+    tools: string[];
+  };
+  activate(api: OpenClawPluginApi): void;
+  deactivate(api: OpenClawPluginApi): void;
+};
+//#endregion
+export { plugin as t };
+//# sourceMappingURL=plugin.d.cts.map

package/dist/plugin.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.cts","names":["McpServerConfig","StdioServerConfig","RemoteServerConfig","Record","McpTransportKind","McpToolDescriptor","ReconcileDiff","Logger","McpToolCallResult","BundlerOptions","STDIO_ENV_DENYLIST","Set","sanitizeStdioEnv","ConnectionDeps","McpClientHandle","Promise","AbortSignal","Connection","defaultConnect","McpBundler","sanitizeNameSegment","buildNamespacedToolName","disambiguateAgainst","ReadonlySet"],"sources":["../../mcp-bundler/dist/index.d.ts","../src/plugin.ts"],"sourcesContent":["//#region src/types.d.ts\n/**\n * Shape of a single MCP server entry — matches OpenClaw `mcp.servers.{name}`.\n * Either a stdio child process spec or a remote URL spec.\n */\ntype McpServerConfig = StdioServerConfig | RemoteServerConfig;\ninterface StdioServerConfig {\n  command: string;\n  args?: string[];\n  env?: Record<string, string>;\n  cwd?: string;\n}\ninterface RemoteServerConfig {\n  url: string;\n  transport?: 'sse' | 'streamable-http';\n  headers?: Record<string, string>;\n  connectionTimeoutMs?: number;\n}\ntype McpTransportKind = 'stdio' | 'sse' | 'streamable-http';\n/**\n * One tool surfaced from one MCP server, after namespacing.\n */\ninterface McpToolDescriptor {\n  /** Namespaced name as the LLM sees it: `{serverName}__{originalName}`, sanitized + max 64 chars. */\n  prefixed: string;\n  /** Server name (key in `mcp.servers.*`). */\n  server: string;\n  /** Original tool name as advertised by the MCP server. */\n  original: string;\n  /** Human label for the tool (truncated description, suitable for UI). */\n  label: string;\n  /** Full description from the MCP server. */\n  description: string;\n  /** JSON Schema (object) for tool parameters. */\n  parameters: Record<string, unknown>;\n}\ninterface ReconcileDiff {\n  added: string[];\n  removed: string[];\n  changed: string[];\n  unchanged: string[];\n}\ninterface Logger {\n  debug: (msg: string, meta?: Record<string, unknown>) => void;\n  info: (msg: string, meta?: Record<string, unknown>) => void;\n  warn: (msg: string, meta?: Record<string, unknown>) => void;\n  error: (msg: string, meta?: Record<string, unknown>) => void;\n}\ninterface McpToolCallResult {\n  content: Record<string, unknown>[];\n  isError?: boolean;\n}\ninterface BundlerOptions {\n  logger?: Logger;\n  /** Idle TTL for spawned children (ms). 0 disables. Default: 600_000 (10 min). */\n  idleTtlMs?: number;\n  /** Sweep interval for idle reaping (ms). Default: 60_000 (1 min). */\n  idleSweepIntervalMs?: number;\n}\n//# sourceMappingURL=types.d.ts.map\n//#endregion\n//#region src/connection.d.ts\n/** Env keys OpenClaw rejects from stdio MCP env blocks. Filter them out before spawning. */\ndeclare const STDIO_ENV_DENYLIST: Set<string>;\ndeclare function sanitizeStdioEnv(env: Record<string, string> | undefined): Record<string, string>;\ninterface ConnectionDeps {\n  /**\n   * Factory for an MCP Client connected to the given config. Injected so tests\n   * can mock without spawning real processes. In production this wraps\n   * `@modelcontextprotocol/sdk/client`.\n   */\n  connect: (server: McpServerConfig) => Promise<McpClientHandle>;\n}\n/**\n * Minimal interface our connection layer needs from an MCP client. Mirrors\n * the @modelcontextprotocol/sdk Client surface but kept narrow so we can\n * mock cleanly in tests.\n */\ninterface McpClientHandle {\n  listTools(): Promise<{\n    name: string;\n    description?: string;\n    inputSchema: Record<string, unknown>;\n  }[]>;\n  callTool(name: string, args: unknown, opts?: {\n    signal?: AbortSignal;\n  }): Promise<McpToolCallResult>;\n  close(): Promise<void>;\n}\n/**\n * One Connection per MCP server. Owns lifecycle (lazy-spawn, close, refresh-lock).\n * Refresh-lock pattern adapted from AIWerk `index.ts:219-250` — prevents\n * reconnect + `notifications/tools/list_changed` race.\n */\ndeclare class Connection {\n  readonly name: string;\n  readonly config: McpServerConfig;\n  private readonly deps;\n  private readonly logger;\n  private client;\n  private tools;\n  private connectInFlight;\n  private refreshInFlight;\n  private refreshQueued;\n  private lastUsedAt;\n  constructor(params: {\n    name: string;\n    config: McpServerConfig;\n    deps: ConnectionDeps;\n    logger?: Logger;\n  });\n  /** Returns the most recent known tool list. May be empty if the server hasn't connected yet. */\n  snapshotTools(): McpToolDescriptor[];\n  /** Whether an MCP child process / remote connection has been established. */\n  isConnected(): boolean;\n  /** Idle timestamp for reaping. */\n  idleSinceMs(): number;\n  /**\n   * Lazy connect + tool discovery. Safe to call concurrently; in-flight\n   * connects coalesce.\n   */\n  ensureConnected(): Promise<void>;\n  private connectAndDiscover;\n  /**\n   * Re-discover tools. Used on reconnect or `tools/list_changed` notification.\n   * Refresh-lock collapses concurrent refreshes; if one is in flight, the next\n   * is queued (max 1 queued, since N>1 queued provides no extra freshness).\n   */\n  refresh(): Promise<void>;\n  callTool(originalName: string, args: unknown, signal?: AbortSignal): Promise<McpToolCallResult>;\n  /**\n   * Close the underlying transport. Idempotent. If a connect is in flight\n   * (warmup racing with reconcile-removal), wait for it to settle and then\n   * close the client it produced — otherwise the child process is orphaned.\n   */\n  close(): Promise<void>;\n  /**\n   * Stable hash of the config for diff detection in `reconcile`.\n   * Two configs with the same hash are equivalent (no restart needed).\n   */\n  configFingerprint(): string;\n}\n/**\n * Build the production `connect` factory using the official MCP SDK.\n * Kept in a separate function so tests can substitute a mock without\n * pulling the SDK into the test bundle.\n */\ndeclare function defaultConnect(server: McpServerConfig): Promise<McpClientHandle>;\n//# sourceMappingURL=connection.d.ts.map\n//#endregion\n//#region src/bundler.d.ts\n/**\n * Provider-agnostic MCP server bundler. Holds N MCP server connections,\n * exposes a unified namespaced tool catalog, and routes calls to the right\n * server.\n *\n * Designed to be embedded in any host (OpenClaw plugin, AI proxy, Lambda).\n * Public surface is intentionally synchronous where the host needs sync\n * (snapshot, listTools), async only where I/O is unavoidable.\n */\ndeclare class McpBundler {\n  private readonly logger;\n  private readonly connections;\n  private readonly idleTtlMs;\n  private readonly idleSweepIntervalMs;\n  private idleSweepTimer;\n  private readonly deps;\n  private disposed;\n  private reconcileLatch;\n  constructor(opts?: BundlerOptions, deps?: ConnectionDeps);\n  /**\n   * Diff `desired` against current connections, spawn newcomers, dispose\n   * removals, hot-restart on config change. Pull-based — call whenever the\n   * host's config snapshot may have changed. Cheap if no diff.\n   *\n   * Lazy: newly-added servers are NOT eagerly connected; they connect on the\n   * first `callTool()` (or first `listTools()` after `forceDiscover()`).\n   * This avoids paying spawn cost for servers the agent never uses.\n   */\n  reconcile(desired: Record<string, McpServerConfig>): Promise<ReconcileDiff>;\n  private doReconcile;\n  /**\n   * Synchronous snapshot of all currently-known tools across connected servers.\n   * Servers that have not connected yet contribute nothing. Intended for use\n   * inside OpenClaw's plugin tool factory which must be sync.\n   *\n   * Tool names are namespaced and disambiguated (suffix `-2`, `-3` on collision)\n   * so cross-server name clashes never produce duplicate registrations.\n   */\n  listTools(): McpToolDescriptor[];\n  /**\n   * Eagerly connect to every configured server and discover tools. Used by\n   * hosts that want a hot list rather than the lazy default. Errors are\n   * swallowed per-server (logged), so one bad server doesn't fail the batch.\n   */\n  warmup(): Promise<void>;\n  /**\n   * Invoke a tool by its namespaced name. Routes to the originating server.\n   * Errors are returned as `{ isError: true, content: [...] }` so a failing\n   * tool doesn't crash the host.\n   */\n  callTool(prefixed: string, args: unknown, signal?: AbortSignal): Promise<McpToolCallResult>;\n  /**\n   * Resolve a namespaced tool name back to its server connection and original\n   * tool name. Returns undefined if the tool is not currently advertised.\n   */\n  private routeToolName;\n  /**\n   * Tear down all connections and stop background tasks. Idempotent.\n   * Call from `registerRuntimeLifecycle({ cleanup })` in the host plugin.\n   */\n  dispose(): Promise<void>;\n  private startIdleSweep;\n  private sweepIdle;\n}\n//# sourceMappingURL=bundler.d.ts.map\n//#endregion\n//#region src/tool-naming.d.ts\n/**\n * Tool name sanitization and collision handling.\n *\n * OpenClaw constraint: tool names must match `[A-Za-z0-9_-]` and be ≤64 chars.\n * Pattern mirrored from `openclaw/src/agents/pi-bundle-mcp-names.ts`.\n *\n * Strategy: prefix every tool with its server name (`{server}__{tool}`),\n * sanitize disallowed chars to `_`, truncate, then suffix-disambiguate\n * (`-2`, `-3`, ...) on collision.\n */\ndeclare function sanitizeNameSegment(value: string): string;\ndeclare function buildNamespacedToolName(server: string, tool: string): string;\n/**\n * Disambiguate a candidate name against an existing set by appending `-2`, `-3`, etc.\n * Mutates nothing; returns the chosen name. Caller is responsible for inserting it\n * into the set.\n */\ndeclare function disambiguateAgainst(candidate: string, taken: ReadonlySet<string>): string;\n//# sourceMappingURL=tool-naming.d.ts.map\n\n//#endregion\nexport { type BundlerOptions, Connection, type ConnectionDeps, type Logger, McpBundler, type McpClientHandle, type McpServerConfig, type McpToolCallResult, type McpToolDescriptor, type McpTransportKind, type ReconcileDiff, type RemoteServerConfig, STDIO_ENV_DENYLIST, type StdioServerConfig, buildNamespacedToolName, defaultConnect, disambiguateAgainst, sanitizeNameSegment, sanitizeStdioEnv };\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;KAKKA,eAAAA,GAAkBC,iBAAsC,GAAlBC,kBAAkB;AAAA,UACnDD,iBAAAA,CAAiB;EAGb,OAGJC,EAAAA,MAAAA;;QAHFC;;ACGwF;AAUhF,UDVND,kBAAAA,CCiBc;EAAA,GAAA,EAAA,MAAA;WACgC,CAAA,EAAA,KAAA,GAAA,iBAAA;SACrB,CAAA,EDhBvBC,MCgBuB,CAAA,MAAA,EAAA,MAAA,CAAA;qBAAf,CAAA,EAAA,MAAA;;;;;AATJ,UAAN,MAAA,CAOA;EAAc,KAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;MACgC,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;MACrB,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;OAAf,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;;AAAM,UAFhB,cAAA,CAKe;EAAA,MAAA,CAAA,EAAA;IACd,QAAA,CAAA,EAAA;MACC,KAAA,CAAA,EAAA,MAAA;MAAM,WAAA,CAAA,EANsC,MAMtC,CAAA,MAAA,EAAA,OAAA,CAAA;IAGR,CAAA;EAAS,CAAA;KAIL,CAAA,EAAA;IAID,OAAA,CAAA,EAhBO,MAgBP,CAAA,MAAA,EAhBsB,eAgBtB,CAAA;IAEE,gBAAA,CAAA,EAAA,MAAA;;;AAAD,UAfJ,eAAA,CAkBkB;EAAA,OAAA,EAjBjB,MAiBiB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA;SACjB,CAAA,EAjBC,MAiBD,CAAA,MAAA,EAAA,OAAA,CAAA;;UAdD,SAAA,CAgBiB;EAAc,IAAA,EAAA,MAAA;EAG/B,KAAA,CAAA,EAAA,MAAA;EAAiB,WAAA,EAAA,MAAA;YACjB,EAhBI,MAgBJ,CAAA,MAAA,EAAA,OAAA,CAAA;SACC,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EAbE,WAaF,EAAA,QAAA,CAAA,EAAA,CAAA,MAAA,EAAA,OAAA,EAAA,GAAA,IAAA,EAAA,GAXJ,OAWI,CAXI,eAWJ,CAAA;;UARD,kBAAA,CAaA;QAAmB,CAAA,EAZlB,cAYkB;eAAuB,CAAA,EAXlC,cAWkC;kBAAY,CAAA,EAAA,GAAA,GAVrC,cAUqC,GAAA,SAAA;;AAAS,UAP/D,iBAAA,CAgJT;EAAA,MAAA,EA/IS,MA+IT;QApEe,CAAA,EA1EL,cA0EK;cA0DE,CAAA,EAAA;IAAiB,QAAA,CAAA,EAAA,OAAA;;;;;sBAjIM;;;uBAE/B,mBAAmB,uBAAuB,YAAY;;;;;;cAqD1D;;;;;;;;gBAgBU;kBA0DE"}

package/dist/plugin.d.ts

@@ -0,0 +1,88 @@
+//#region ../mcp-bundler/dist/index.d.ts
+//#region src/types.d.ts
+/**
+ * Shape of a single MCP server entry — matches OpenClaw `mcp.servers.{name}`.
+ * Either a stdio child process spec or a remote URL spec.
+ */
+type McpServerConfig = StdioServerConfig | RemoteServerConfig;
+interface StdioServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+}
+interface RemoteServerConfig {
+  url: string;
+  transport?: 'sse' | 'streamable-http';
+  headers?: Record<string, string>;
+  connectionTimeoutMs?: number;
+}
+//#endregion
+//#region src/plugin.d.ts
+
+interface Logger {
+  debug(msg: string, ...args: unknown[]): void;
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+}
+interface ConfigSnapshot {
+  agents?: {
+    defaults?: {
+      model?: string;
+      cliBackends?: Record<string, unknown>;
+    };
+  };
+  mcp?: {
+    servers?: Record<string, McpServerConfig>;
+    sessionIdleTtlMs?: number;
+  };
+}
+interface AgentToolResult {
+  content: Record<string, unknown>[];
+  details?: Record<string, unknown>;
+}
+interface AgentTool {
+  name: string;
+  label?: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  execute: (toolCallId: string, params: unknown, signal?: AbortSignal, onUpdate?: (update: unknown) => void) => Promise<AgentToolResult>;
+}
+interface ToolFactoryContext {
+  config?: ConfigSnapshot;
+  runtimeConfig?: ConfigSnapshot;
+  getRuntimeConfig?: () => ConfigSnapshot | undefined;
+}
+interface OpenClawPluginApi {
+  logger: Logger;
+  config?: ConfigSnapshot;
+  pluginConfig?: {
+    disabled?: boolean;
+  };
+  registrationMode?: string;
+  runtime?: {
+    config?: {
+      current?: () => ConfigSnapshot | undefined;
+    };
+  };
+  registerTool: (tool: AgentTool | ((ctx: ToolFactoryContext) => AgentTool | AgentTool[] | null | undefined), opts?: {
+    name?: string;
+    names?: string[];
+    optional?: boolean;
+  }) => void;
+}
+declare const plugin: {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  contracts: {
+    tools: string[];
+  };
+  activate(api: OpenClawPluginApi): void;
+  deactivate(api: OpenClawPluginApi): void;
+};
+//#endregion
+export { plugin as t };
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","names":["McpServerConfig","StdioServerConfig","RemoteServerConfig","Record","McpTransportKind","McpToolDescriptor","ReconcileDiff","Logger","McpToolCallResult","BundlerOptions","STDIO_ENV_DENYLIST","Set","sanitizeStdioEnv","ConnectionDeps","McpClientHandle","Promise","AbortSignal","Connection","defaultConnect","McpBundler","sanitizeNameSegment","buildNamespacedToolName","disambiguateAgainst","ReadonlySet"],"sources":["../../mcp-bundler/dist/index.d.ts","../src/plugin.ts"],"sourcesContent":["//#region src/types.d.ts\n/**\n * Shape of a single MCP server entry — matches OpenClaw `mcp.servers.{name}`.\n * Either a stdio child process spec or a remote URL spec.\n */\ntype McpServerConfig = StdioServerConfig | RemoteServerConfig;\ninterface StdioServerConfig {\n  command: string;\n  args?: string[];\n  env?: Record<string, string>;\n  cwd?: string;\n}\ninterface RemoteServerConfig {\n  url: string;\n  transport?: 'sse' | 'streamable-http';\n  headers?: Record<string, string>;\n  connectionTimeoutMs?: number;\n}\ntype McpTransportKind = 'stdio' | 'sse' | 'streamable-http';\n/**\n * One tool surfaced from one MCP server, after namespacing.\n */\ninterface McpToolDescriptor {\n  /** Namespaced name as the LLM sees it: `{serverName}__{originalName}`, sanitized + max 64 chars. */\n  prefixed: string;\n  /** Server name (key in `mcp.servers.*`). */\n  server: string;\n  /** Original tool name as advertised by the MCP server. */\n  original: string;\n  /** Human label for the tool (truncated description, suitable for UI). */\n  label: string;\n  /** Full description from the MCP server. */\n  description: string;\n  /** JSON Schema (object) for tool parameters. */\n  parameters: Record<string, unknown>;\n}\ninterface ReconcileDiff {\n  added: string[];\n  removed: string[];\n  changed: string[];\n  unchanged: string[];\n}\ninterface Logger {\n  debug: (msg: string, meta?: Record<string, unknown>) => void;\n  info: (msg: string, meta?: Record<string, unknown>) => void;\n  warn: (msg: string, meta?: Record<string, unknown>) => void;\n  error: (msg: string, meta?: Record<string, unknown>) => void;\n}\ninterface McpToolCallResult {\n  content: Record<string, unknown>[];\n  isError?: boolean;\n}\ninterface BundlerOptions {\n  logger?: Logger;\n  /** Idle TTL for spawned children (ms). 0 disables. Default: 600_000 (10 min). */\n  idleTtlMs?: number;\n  /** Sweep interval for idle reaping (ms). Default: 60_000 (1 min). */\n  idleSweepIntervalMs?: number;\n}\n//# sourceMappingURL=types.d.ts.map\n//#endregion\n//#region src/connection.d.ts\n/** Env keys OpenClaw rejects from stdio MCP env blocks. Filter them out before spawning. */\ndeclare const STDIO_ENV_DENYLIST: Set<string>;\ndeclare function sanitizeStdioEnv(env: Record<string, string> | undefined): Record<string, string>;\ninterface ConnectionDeps {\n  /**\n   * Factory for an MCP Client connected to the given config. Injected so tests\n   * can mock without spawning real processes. In production this wraps\n   * `@modelcontextprotocol/sdk/client`.\n   */\n  connect: (server: McpServerConfig) => Promise<McpClientHandle>;\n}\n/**\n * Minimal interface our connection layer needs from an MCP client. Mirrors\n * the @modelcontextprotocol/sdk Client surface but kept narrow so we can\n * mock cleanly in tests.\n */\ninterface McpClientHandle {\n  listTools(): Promise<{\n    name: string;\n    description?: string;\n    inputSchema: Record<string, unknown>;\n  }[]>;\n  callTool(name: string, args: unknown, opts?: {\n    signal?: AbortSignal;\n  }): Promise<McpToolCallResult>;\n  close(): Promise<void>;\n}\n/**\n * One Connection per MCP server. Owns lifecycle (lazy-spawn, close, refresh-lock).\n * Refresh-lock pattern adapted from AIWerk `index.ts:219-250` — prevents\n * reconnect + `notifications/tools/list_changed` race.\n */\ndeclare class Connection {\n  readonly name: string;\n  readonly config: McpServerConfig;\n  private readonly deps;\n  private readonly logger;\n  private client;\n  private tools;\n  private connectInFlight;\n  private refreshInFlight;\n  private refreshQueued;\n  private lastUsedAt;\n  constructor(params: {\n    name: string;\n    config: McpServerConfig;\n    deps: ConnectionDeps;\n    logger?: Logger;\n  });\n  /** Returns the most recent known tool list. May be empty if the server hasn't connected yet. */\n  snapshotTools(): McpToolDescriptor[];\n  /** Whether an MCP child process / remote connection has been established. */\n  isConnected(): boolean;\n  /** Idle timestamp for reaping. */\n  idleSinceMs(): number;\n  /**\n   * Lazy connect + tool discovery. Safe to call concurrently; in-flight\n   * connects coalesce.\n   */\n  ensureConnected(): Promise<void>;\n  private connectAndDiscover;\n  /**\n   * Re-discover tools. Used on reconnect or `tools/list_changed` notification.\n   * Refresh-lock collapses concurrent refreshes; if one is in flight, the next\n   * is queued (max 1 queued, since N>1 queued provides no extra freshness).\n   */\n  refresh(): Promise<void>;\n  callTool(originalName: string, args: unknown, signal?: AbortSignal): Promise<McpToolCallResult>;\n  /**\n   * Close the underlying transport. Idempotent. If a connect is in flight\n   * (warmup racing with reconcile-removal), wait for it to settle and then\n   * close the client it produced — otherwise the child process is orphaned.\n   */\n  close(): Promise<void>;\n  /**\n   * Stable hash of the config for diff detection in `reconcile`.\n   * Two configs with the same hash are equivalent (no restart needed).\n   */\n  configFingerprint(): string;\n}\n/**\n * Build the production `connect` factory using the official MCP SDK.\n * Kept in a separate function so tests can substitute a mock without\n * pulling the SDK into the test bundle.\n */\ndeclare function defaultConnect(server: McpServerConfig): Promise<McpClientHandle>;\n//# sourceMappingURL=connection.d.ts.map\n//#endregion\n//#region src/bundler.d.ts\n/**\n * Provider-agnostic MCP server bundler. Holds N MCP server connections,\n * exposes a unified namespaced tool catalog, and routes calls to the right\n * server.\n *\n * Designed to be embedded in any host (OpenClaw plugin, AI proxy, Lambda).\n * Public surface is intentionally synchronous where the host needs sync\n * (snapshot, listTools), async only where I/O is unavoidable.\n */\ndeclare class McpBundler {\n  private readonly logger;\n  private readonly connections;\n  private readonly idleTtlMs;\n  private readonly idleSweepIntervalMs;\n  private idleSweepTimer;\n  private readonly deps;\n  private disposed;\n  private reconcileLatch;\n  constructor(opts?: BundlerOptions, deps?: ConnectionDeps);\n  /**\n   * Diff `desired` against current connections, spawn newcomers, dispose\n   * removals, hot-restart on config change. Pull-based — call whenever the\n   * host's config snapshot may have changed. Cheap if no diff.\n   *\n   * Lazy: newly-added servers are NOT eagerly connected; they connect on the\n   * first `callTool()` (or first `listTools()` after `forceDiscover()`).\n   * This avoids paying spawn cost for servers the agent never uses.\n   */\n  reconcile(desired: Record<string, McpServerConfig>): Promise<ReconcileDiff>;\n  private doReconcile;\n  /**\n   * Synchronous snapshot of all currently-known tools across connected servers.\n   * Servers that have not connected yet contribute nothing. Intended for use\n   * inside OpenClaw's plugin tool factory which must be sync.\n   *\n   * Tool names are namespaced and disambiguated (suffix `-2`, `-3` on collision)\n   * so cross-server name clashes never produce duplicate registrations.\n   */\n  listTools(): McpToolDescriptor[];\n  /**\n   * Eagerly connect to every configured server and discover tools. Used by\n   * hosts that want a hot list rather than the lazy default. Errors are\n   * swallowed per-server (logged), so one bad server doesn't fail the batch.\n   */\n  warmup(): Promise<void>;\n  /**\n   * Invoke a tool by its namespaced name. Routes to the originating server.\n   * Errors are returned as `{ isError: true, content: [...] }` so a failing\n   * tool doesn't crash the host.\n   */\n  callTool(prefixed: string, args: unknown, signal?: AbortSignal): Promise<McpToolCallResult>;\n  /**\n   * Resolve a namespaced tool name back to its server connection and original\n   * tool name. Returns undefined if the tool is not currently advertised.\n   */\n  private routeToolName;\n  /**\n   * Tear down all connections and stop background tasks. Idempotent.\n   * Call from `registerRuntimeLifecycle({ cleanup })` in the host plugin.\n   */\n  dispose(): Promise<void>;\n  private startIdleSweep;\n  private sweepIdle;\n}\n//# sourceMappingURL=bundler.d.ts.map\n//#endregion\n//#region src/tool-naming.d.ts\n/**\n * Tool name sanitization and collision handling.\n *\n * OpenClaw constraint: tool names must match `[A-Za-z0-9_-]` and be ≤64 chars.\n * Pattern mirrored from `openclaw/src/agents/pi-bundle-mcp-names.ts`.\n *\n * Strategy: prefix every tool with its server name (`{server}__{tool}`),\n * sanitize disallowed chars to `_`, truncate, then suffix-disambiguate\n * (`-2`, `-3`, ...) on collision.\n */\ndeclare function sanitizeNameSegment(value: string): string;\ndeclare function buildNamespacedToolName(server: string, tool: string): string;\n/**\n * Disambiguate a candidate name against an existing set by appending `-2`, `-3`, etc.\n * Mutates nothing; returns the chosen name. Caller is responsible for inserting it\n * into the set.\n */\ndeclare function disambiguateAgainst(candidate: string, taken: ReadonlySet<string>): string;\n//# sourceMappingURL=tool-naming.d.ts.map\n\n//#endregion\nexport { type BundlerOptions, Connection, type ConnectionDeps, type Logger, McpBundler, type McpClientHandle, type McpServerConfig, type McpToolCallResult, type McpToolDescriptor, type McpTransportKind, type ReconcileDiff, type RemoteServerConfig, STDIO_ENV_DENYLIST, type StdioServerConfig, buildNamespacedToolName, defaultConnect, disambiguateAgainst, sanitizeNameSegment, sanitizeStdioEnv };\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;KAKKA,eAAAA,GAAkBC,iBAAsC,GAAlBC,kBAAkB;AAAA,UACnDD,iBAAAA,CAAiB;EAGb,OAGJC,EAAAA,MAAAA;;QAHFC;;ACGwF;AAUhF,UDVND,kBAAAA,CCiBc;EAAA,GAAA,EAAA,MAAA;WACgC,CAAA,EAAA,KAAA,GAAA,iBAAA;SACrB,CAAA,EDhBvBC,MCgBuB,CAAA,MAAA,EAAA,MAAA,CAAA;qBAAf,CAAA,EAAA,MAAA;;;;;AATJ,UAAN,MAAA,CAOA;EAAc,KAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;MACgC,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;MACrB,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;OAAf,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;;AAAM,UAFhB,cAAA,CAKe;EAAA,MAAA,CAAA,EAAA;IACd,QAAA,CAAA,EAAA;MACC,KAAA,CAAA,EAAA,MAAA;MAAM,WAAA,CAAA,EANsC,MAMtC,CAAA,MAAA,EAAA,OAAA,CAAA;IAGR,CAAA;EAAS,CAAA;KAIL,CAAA,EAAA;IAID,OAAA,CAAA,EAhBO,MAgBP,CAAA,MAAA,EAhBsB,eAgBtB,CAAA;IAEE,gBAAA,CAAA,EAAA,MAAA;;;AAAD,UAfJ,eAAA,CAkBkB;EAAA,OAAA,EAjBjB,MAiBiB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA;SACjB,CAAA,EAjBC,MAiBD,CAAA,MAAA,EAAA,OAAA,CAAA;;UAdD,SAAA,CAgBiB;EAAc,IAAA,EAAA,MAAA;EAG/B,KAAA,CAAA,EAAA,MAAA;EAAiB,WAAA,EAAA,MAAA;YACjB,EAhBI,MAgBJ,CAAA,MAAA,EAAA,OAAA,CAAA;SACC,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EAbE,WAaF,EAAA,QAAA,CAAA,EAAA,CAAA,MAAA,EAAA,OAAA,EAAA,GAAA,IAAA,EAAA,GAXJ,OAWI,CAXI,eAWJ,CAAA;;UARD,kBAAA,CAaA;QAAmB,CAAA,EAZlB,cAYkB;eAAuB,CAAA,EAXlC,cAWkC;kBAAY,CAAA,EAAA,GAAA,GAVrC,cAUqC,GAAA,SAAA;;AAAS,UAP/D,iBAAA,CAgJT;EAAA,MAAA,EA/IS,MA+IT;QApEe,CAAA,EA1EL,cA0EK;cA0DE,CAAA,EAAA;IAAiB,QAAA,CAAA,EAAA,OAAA;;;;;sBAjIM;;;uBAE/B,mBAAmB,uBAAuB,YAAY;;;;;;cAqD1D;;;;;;;;gBAgBU;kBA0DE"}

package/dist/plugin.js

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin2.js";
+export { plugin as default };

package/dist/plugin2.cjs

@@ -0,0 +1,162 @@
+let _alfe_ai_mcp_bundler = require("@alfe.ai/mcp-bundler");
+let node_module = require("node:module");
+//#region src/cli-backend-detect.ts
+/**
+* Determine whether the active agent's CLI backend already has native bundle-MCP
+* support. If so, our plugin should no-op so we don't double-register tools.
+*
+* As of OpenClaw 2026.4 only `claude-cli` and `codex-cli` ship with
+* `bundleMcp: true`. We hardcode that allowlist for now; future backends
+* shipping with bundleMcp:true will need to be added here (or, ideally,
+* OpenClaw exposes a public API to query the resolved backend's bundleMcp
+* flag and we call that instead — see project_openclaw_mcp_bundler.md TODO).
+*
+* This detection is best-effort: if we can't determine the backend (no
+* runtime config available), we default to "no native MCP" (return false)
+* so our plugin DOES register. Worst case is benign duplicate tool names
+* with `-2` suffix on claude-cli, which is recoverable; missing tools on
+* MiniMax is the bug we exist to fix.
+*/
+const NATIVE_BUNDLE_MCP_BACKENDS = new Set(["claude-cli", "codex-cli"]);
+/**
+* Read the active agent's primary model and infer its CLI backend.
+* Returns true if that backend has native bundleMcp support.
+*
+* Heuristic mapping (matches what OpenClaw's plugin-setup-cli-backend
+* registry resolves to today):
+*   - model id containing "claude" or "anthropic" → claude-cli
+*   - model id containing "codex" or "gpt-5-codex" or "openai/codex" → codex-cli
+*   - everything else → no native bundle-mcp
+*
+* If `agents.defaults.cliBackends` explicitly configures one of the native
+* backends, we trust that override.
+*/
+function detectNativeBundleMcp(cfg) {
+	if (!cfg) return false;
+	const defaults = cfg.agents?.defaults;
+	if (!defaults) return false;
+	const configured = defaults.cliBackends ?? {};
+	for (const key of Object.keys(configured)) if (NATIVE_BUNDLE_MCP_BACKENDS.has(key)) return true;
+	const model = (defaults.model ?? "").toLowerCase();
+	if (!model) return false;
+	if (model.includes("claude") || model.includes("anthropic")) return true;
+	if (model.includes("codex") || model.startsWith("gpt-5-codex")) return true;
+	return false;
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw-mcp-bundler — OpenClaw plugin entry
+*
+* Reads `cfg.mcp.servers` from openclaw.json and surfaces each MCP server's
+* tools to the agent via `api.registerTool(factory)`. This works for ANY
+* LLM backend, closing the gap that OpenClaw's native `bundleMcp:true`
+* leaves open (only claude-cli/codex-cli have it shipped today).
+*
+* On `claude-cli`/`codex-cli` agents the plugin detects the native wiring
+* and no-ops, avoiding double-registered tools.
+*/
+const pkg = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
+let bundler;
+let lastFingerprint = "";
+function resolveLiveConfig(api, ctx) {
+	return ctx?.runtimeConfig ?? ctx?.getRuntimeConfig?.() ?? api.runtime?.config?.current?.() ?? ctx?.config ?? api.config;
+}
+function fingerprintServers(servers) {
+	const keys = Object.keys(servers).sort();
+	return JSON.stringify(keys.map((k) => [k, servers[k]]));
+}
+function toAgentTool(api, tool) {
+	return {
+		name: tool.prefixed,
+		label: tool.label,
+		description: tool.description || `MCP tool ${tool.original} from server ${tool.server}`,
+		parameters: tool.parameters,
+		async execute(_toolCallId, params, signal) {
+			if (!bundler) return errorResult(`mcp-bundler not initialized for tool ${tool.prefixed}`);
+			const result = await bundler.callTool(tool.prefixed, params, signal);
+			return {
+				content: result.content,
+				details: { isError: result.isError ?? false }
+			};
+		}
+	};
+}
+function errorResult(message) {
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		details: { isError: true }
+	};
+}
+const plugin = {
+	id: "@alfe.ai/openclaw-mcp-bundler",
+	name: "Alfe MCP Bundler",
+	description: "Surfaces mcp.servers tools to the agent for any LLM backend",
+	version: pkg.version,
+	contracts: { tools: ["mcp__*"] },
+	activate(api) {
+		const log = api.logger;
+		if (api.pluginConfig?.disabled) {
+			log.info("[mcp-bundler] disabled via plugin config — no-op");
+			return;
+		}
+		if (api.registrationMode && api.registrationMode !== "full" && api.registrationMode !== "discovery" && api.registrationMode !== "tool-discovery") {
+			log.info(`[mcp-bundler] skipped — registrationMode=${api.registrationMode}`);
+			return;
+		}
+		const initialCfg = resolveLiveConfig(api);
+		if (detectNativeBundleMcp(initialCfg)) {
+			log.info("[mcp-bundler] native bundle-mcp detected on this backend (claude-cli/codex-cli) — standing by as no-op to avoid double-registered tools");
+			return;
+		}
+		bundler = new _alfe_ai_mcp_bundler.McpBundler({
+			logger: log,
+			idleTtlMs: initialCfg?.mcp?.sessionIdleTtlMs ?? 600 * 1e3
+		});
+		const initialServers = initialCfg?.mcp?.servers ?? {};
+		bundler.reconcile(initialServers).then(() => bundler?.warmup()).catch((err) => {
+			log.warn("[mcp-bundler] initial reconcile/warmup failed", { err: err instanceof Error ? err.message : String(err) });
+		});
+		lastFingerprint = fingerprintServers(initialServers);
+		api.registerTool((ctx) => {
+			const live = resolveLiveConfig(api, ctx);
+			if (!live || detectNativeBundleMcp(live)) return null;
+			const servers = live.mcp?.servers ?? {};
+			const fp = fingerprintServers(servers);
+			if (fp !== lastFingerprint) {
+				lastFingerprint = fp;
+				bundler?.reconcile(servers).then(() => bundler?.warmup()).catch((err) => {
+					log.warn("[mcp-bundler] reconcile failed", { err: err instanceof Error ? err.message : String(err) });
+				});
+			}
+			return (bundler?.listTools() ?? []).map((t) => toAgentTool(api, t));
+		}, { optional: true });
+		log.info(`[mcp-bundler] activated v${pkg.version}, ${Object.keys(initialServers).length.toString()} server(s) configured`);
+	},
+	deactivate(api) {
+		api.logger.info("[mcp-bundler] deactivating");
+		if (bundler) {
+			bundler.dispose().catch((err) => {
+				api.logger.warn("[mcp-bundler] dispose error", { err: err instanceof Error ? err.message : String(err) });
+			});
+			bundler = void 0;
+		}
+		lastFingerprint = "";
+	}
+};
+//#endregion
+Object.defineProperty(exports, "detectNativeBundleMcp", {
+	enumerable: true,
+	get: function() {
+		return detectNativeBundleMcp;
+	}
+});
+Object.defineProperty(exports, "plugin", {
+	enumerable: true,
+	get: function() {
+		return plugin;
+	}
+});

package/dist/plugin2.d.cts

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin.cjs";
+export { plugin as default };

package/dist/plugin2.d.ts

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin.js";
+export { plugin as default };

package/dist/plugin2.js

@@ -0,0 +1,153 @@
+import { createRequire } from "node:module";
+import { McpBundler } from "@alfe.ai/mcp-bundler";
+//#region src/cli-backend-detect.ts
+/**
+* Determine whether the active agent's CLI backend already has native bundle-MCP
+* support. If so, our plugin should no-op so we don't double-register tools.
+*
+* As of OpenClaw 2026.4 only `claude-cli` and `codex-cli` ship with
+* `bundleMcp: true`. We hardcode that allowlist for now; future backends
+* shipping with bundleMcp:true will need to be added here (or, ideally,
+* OpenClaw exposes a public API to query the resolved backend's bundleMcp
+* flag and we call that instead — see project_openclaw_mcp_bundler.md TODO).
+*
+* This detection is best-effort: if we can't determine the backend (no
+* runtime config available), we default to "no native MCP" (return false)
+* so our plugin DOES register. Worst case is benign duplicate tool names
+* with `-2` suffix on claude-cli, which is recoverable; missing tools on
+* MiniMax is the bug we exist to fix.
+*/
+const NATIVE_BUNDLE_MCP_BACKENDS = new Set(["claude-cli", "codex-cli"]);
+/**
+* Read the active agent's primary model and infer its CLI backend.
+* Returns true if that backend has native bundleMcp support.
+*
+* Heuristic mapping (matches what OpenClaw's plugin-setup-cli-backend
+* registry resolves to today):
+*   - model id containing "claude" or "anthropic" → claude-cli
+*   - model id containing "codex" or "gpt-5-codex" or "openai/codex" → codex-cli
+*   - everything else → no native bundle-mcp
+*
+* If `agents.defaults.cliBackends` explicitly configures one of the native
+* backends, we trust that override.
+*/
+function detectNativeBundleMcp(cfg) {
+	if (!cfg) return false;
+	const defaults = cfg.agents?.defaults;
+	if (!defaults) return false;
+	const configured = defaults.cliBackends ?? {};
+	for (const key of Object.keys(configured)) if (NATIVE_BUNDLE_MCP_BACKENDS.has(key)) return true;
+	const model = (defaults.model ?? "").toLowerCase();
+	if (!model) return false;
+	if (model.includes("claude") || model.includes("anthropic")) return true;
+	if (model.includes("codex") || model.startsWith("gpt-5-codex")) return true;
+	return false;
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw-mcp-bundler — OpenClaw plugin entry
+*
+* Reads `cfg.mcp.servers` from openclaw.json and surfaces each MCP server's
+* tools to the agent via `api.registerTool(factory)`. This works for ANY
+* LLM backend, closing the gap that OpenClaw's native `bundleMcp:true`
+* leaves open (only claude-cli/codex-cli have it shipped today).
+*
+* On `claude-cli`/`codex-cli` agents the plugin detects the native wiring
+* and no-ops, avoiding double-registered tools.
+*/
+const pkg = createRequire(import.meta.url)("../package.json");
+let bundler;
+let lastFingerprint = "";
+function resolveLiveConfig(api, ctx) {
+	return ctx?.runtimeConfig ?? ctx?.getRuntimeConfig?.() ?? api.runtime?.config?.current?.() ?? ctx?.config ?? api.config;
+}
+function fingerprintServers(servers) {
+	const keys = Object.keys(servers).sort();
+	return JSON.stringify(keys.map((k) => [k, servers[k]]));
+}
+function toAgentTool(api, tool) {
+	return {
+		name: tool.prefixed,
+		label: tool.label,
+		description: tool.description || `MCP tool ${tool.original} from server ${tool.server}`,
+		parameters: tool.parameters,
+		async execute(_toolCallId, params, signal) {
+			if (!bundler) return errorResult(`mcp-bundler not initialized for tool ${tool.prefixed}`);
+			const result = await bundler.callTool(tool.prefixed, params, signal);
+			return {
+				content: result.content,
+				details: { isError: result.isError ?? false }
+			};
+		}
+	};
+}
+function errorResult(message) {
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		details: { isError: true }
+	};
+}
+const plugin = {
+	id: "@alfe.ai/openclaw-mcp-bundler",
+	name: "Alfe MCP Bundler",
+	description: "Surfaces mcp.servers tools to the agent for any LLM backend",
+	version: pkg.version,
+	contracts: { tools: ["mcp__*"] },
+	activate(api) {
+		const log = api.logger;
+		if (api.pluginConfig?.disabled) {
+			log.info("[mcp-bundler] disabled via plugin config — no-op");
+			return;
+		}
+		if (api.registrationMode && api.registrationMode !== "full" && api.registrationMode !== "discovery" && api.registrationMode !== "tool-discovery") {
+			log.info(`[mcp-bundler] skipped — registrationMode=${api.registrationMode}`);
+			return;
+		}
+		const initialCfg = resolveLiveConfig(api);
+		if (detectNativeBundleMcp(initialCfg)) {
+			log.info("[mcp-bundler] native bundle-mcp detected on this backend (claude-cli/codex-cli) — standing by as no-op to avoid double-registered tools");
+			return;
+		}
+		bundler = new McpBundler({
+			logger: log,
+			idleTtlMs: initialCfg?.mcp?.sessionIdleTtlMs ?? 600 * 1e3
+		});
+		const initialServers = initialCfg?.mcp?.servers ?? {};
+		bundler.reconcile(initialServers).then(() => bundler?.warmup()).catch((err) => {
+			log.warn("[mcp-bundler] initial reconcile/warmup failed", { err: err instanceof Error ? err.message : String(err) });
+		});
+		lastFingerprint = fingerprintServers(initialServers);
+		api.registerTool((ctx) => {
+			const live = resolveLiveConfig(api, ctx);
+			if (!live || detectNativeBundleMcp(live)) return null;
+			const servers = live.mcp?.servers ?? {};
+			const fp = fingerprintServers(servers);
+			if (fp !== lastFingerprint) {
+				lastFingerprint = fp;
+				bundler?.reconcile(servers).then(() => bundler?.warmup()).catch((err) => {
+					log.warn("[mcp-bundler] reconcile failed", { err: err instanceof Error ? err.message : String(err) });
+				});
+			}
+			return (bundler?.listTools() ?? []).map((t) => toAgentTool(api, t));
+		}, { optional: true });
+		log.info(`[mcp-bundler] activated v${pkg.version}, ${Object.keys(initialServers).length.toString()} server(s) configured`);
+	},
+	deactivate(api) {
+		api.logger.info("[mcp-bundler] deactivating");
+		if (bundler) {
+			bundler.dispose().catch((err) => {
+				api.logger.warn("[mcp-bundler] dispose error", { err: err instanceof Error ? err.message : String(err) });
+			});
+			bundler = void 0;
+		}
+		lastFingerprint = "";
+	}
+};
+//#endregion
+export { detectNativeBundleMcp as n, plugin as t };
+
+//# sourceMappingURL=plugin2.js.map

package/dist/plugin2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin2.js","names":[],"sources":["../src/cli-backend-detect.ts","../src/plugin.ts"],"sourcesContent":["/**\n * Determine whether the active agent's CLI backend already has native bundle-MCP\n * support. If so, our plugin should no-op so we don't double-register tools.\n *\n * As of OpenClaw 2026.4 only `claude-cli` and `codex-cli` ship with\n * `bundleMcp: true`. We hardcode that allowlist for now; future backends\n * shipping with bundleMcp:true will need to be added here (or, ideally,\n * OpenClaw exposes a public API to query the resolved backend's bundleMcp\n * flag and we call that instead — see project_openclaw_mcp_bundler.md TODO).\n *\n * This detection is best-effort: if we can't determine the backend (no\n * runtime config available), we default to \"no native MCP\" (return false)\n * so our plugin DOES register. Worst case is benign duplicate tool names\n * with `-2` suffix on claude-cli, which is recoverable; missing tools on\n * MiniMax is the bug we exist to fix.\n */\n\nconst NATIVE_BUNDLE_MCP_BACKENDS = new Set(['claude-cli', 'codex-cli']);\n\ninterface ConfigLike {\n  agents?: {\n    defaults?: {\n      model?: string;\n      cliBackends?: Record<string, unknown>;\n    };\n  };\n}\n\n/**\n * Read the active agent's primary model and infer its CLI backend.\n * Returns true if that backend has native bundleMcp support.\n *\n * Heuristic mapping (matches what OpenClaw's plugin-setup-cli-backend\n * registry resolves to today):\n *   - model id containing \"claude\" or \"anthropic\" → claude-cli\n *   - model id containing \"codex\" or \"gpt-5-codex\" or \"openai/codex\" → codex-cli\n *   - everything else → no native bundle-mcp\n *\n * If `agents.defaults.cliBackends` explicitly configures one of the native\n * backends, we trust that override.\n */\nexport function detectNativeBundleMcp(cfg: ConfigLike | undefined): boolean {\n  if (!cfg) return false;\n  const defaults = cfg.agents?.defaults;\n  if (!defaults) return false;\n\n  // Explicit per-backend config overrides the heuristic.\n  const configured = defaults.cliBackends ?? {};\n  for (const key of Object.keys(configured)) {\n    if (NATIVE_BUNDLE_MCP_BACKENDS.has(key)) return true;\n  }\n\n  // Otherwise infer from model id.\n  const model = (defaults.model ?? '').toLowerCase();\n  if (!model) return false;\n  if (model.includes('claude') || model.includes('anthropic')) return true;\n  if (model.includes('codex') || model.startsWith('gpt-5-codex')) return true;\n  return false;\n}\n","/**\n * @alfe.ai/openclaw-mcp-bundler — OpenClaw plugin entry\n *\n * Reads `cfg.mcp.servers` from openclaw.json and surfaces each MCP server's\n * tools to the agent via `api.registerTool(factory)`. This works for ANY\n * LLM backend, closing the gap that OpenClaw's native `bundleMcp:true`\n * leaves open (only claude-cli/codex-cli have it shipped today).\n *\n * On `claude-cli`/`codex-cli` agents the plugin detects the native wiring\n * and no-ops, avoiding double-registered tools.\n */\n\nimport { McpBundler, type McpServerConfig, type McpToolDescriptor } from '@alfe.ai/mcp-bundler';\nimport { detectNativeBundleMcp } from './cli-backend-detect.js';\nimport { createRequire } from 'node:module';\nconst require = createRequire(import.meta.url);\nconst pkg = require('../package.json') as { version: string };\n\n// ── Type shims for the OpenClaw plugin SDK ──────────────────────\n// We avoid a hard dep on the SDK to keep this plugin loadable across\n// OpenClaw versions; the surface used here is stable.\n\ninterface Logger {\n  debug(msg: string, ...args: unknown[]): void;\n  info(msg: string, ...args: unknown[]): void;\n  warn(msg: string, ...args: unknown[]): void;\n  error(msg: string, ...args: unknown[]): void;\n}\n\ninterface ConfigSnapshot {\n  agents?: { defaults?: { model?: string; cliBackends?: Record<string, unknown> } };\n  mcp?: { servers?: Record<string, McpServerConfig>; sessionIdleTtlMs?: number };\n}\n\ninterface AgentToolResult {\n  content: Record<string, unknown>[];\n  details?: Record<string, unknown>;\n}\n\ninterface AgentTool {\n  name: string;\n  label?: string;\n  description: string;\n  parameters: Record<string, unknown>;\n  execute: (\n    toolCallId: string,\n    params: unknown,\n    signal?: AbortSignal,\n    onUpdate?: (update: unknown) => void,\n  ) => Promise<AgentToolResult>;\n}\n\ninterface ToolFactoryContext {\n  config?: ConfigSnapshot;\n  runtimeConfig?: ConfigSnapshot;\n  getRuntimeConfig?: () => ConfigSnapshot | undefined;\n}\n\ninterface OpenClawPluginApi {\n  logger: Logger;\n  config?: ConfigSnapshot;\n  pluginConfig?: { disabled?: boolean };\n  registrationMode?: string;\n  runtime?: { config?: { current?: () => ConfigSnapshot | undefined } };\n  registerTool: (\n    tool: AgentTool | ((ctx: ToolFactoryContext) => AgentTool | AgentTool[] | null | undefined),\n    opts?: { name?: string; names?: string[]; optional?: boolean },\n  ) => void;\n}\n\n// ── Plugin state ───────────────────────────────────────────────\nlet bundler: McpBundler | undefined;\nlet lastFingerprint = '';\n\nfunction resolveLiveConfig(api: OpenClawPluginApi, ctx?: ToolFactoryContext): ConfigSnapshot | undefined {\n  // Prefer most-recent → ctx live → ctx snapshot → api.runtime live → api.config snapshot\n  return (\n    ctx?.runtimeConfig ??\n    ctx?.getRuntimeConfig?.() ??\n    api.runtime?.config?.current?.() ??\n    ctx?.config ??\n    api.config\n  );\n}\n\nfunction fingerprintServers(servers: Record<string, McpServerConfig>): string {\n  const keys = Object.keys(servers).sort();\n  return JSON.stringify(keys.map((k) => [k, servers[k]]));\n}\n\nfunction toAgentTool(api: OpenClawPluginApi, tool: McpToolDescriptor): AgentTool {\n  return {\n    name: tool.prefixed,\n    label: tool.label,\n    description: tool.description || `MCP tool ${tool.original} from server ${tool.server}`,\n    // OpenClaw expects a JSON-Schema-shaped object. The MCP server already\n    // gives us one in `tool.parameters`. Pass through unchanged.\n    parameters: tool.parameters,\n    async execute(_toolCallId, params, signal) {\n      if (!bundler) {\n        return errorResult(`mcp-bundler not initialized for tool ${tool.prefixed}`);\n      }\n      const result = await bundler.callTool(tool.prefixed, params, signal);\n      return {\n        content: result.content,\n        details: { isError: result.isError ?? false },\n      };\n    },\n  };\n}\n\nfunction errorResult(message: string): AgentToolResult {\n  return {\n    content: [{ type: 'text', text: message }],\n    details: { isError: true },\n  };\n}\n\nconst plugin = {\n  id: '@alfe.ai/openclaw-mcp-bundler',\n  name: 'Alfe MCP Bundler',\n  description: 'Surfaces mcp.servers tools to the agent for any LLM backend',\n  version: pkg.version,\n  contracts: {\n    // Tool name set is dynamic. We declare a wildcard via the only stable\n    // identifier we can: the plugin id. OpenClaw's manifest registry uses\n    // contracts.tools as a static allowlist; for dynamic tool sets we declare\n    // a sentinel here and the runtime allows any tool name registered at\n    // runtime to pass through. (If OpenClaw enforces strict contracts in a\n    // future version, we'd need to switch to a router-tool pattern: register\n    // one fixed `mcp_call` tool that accepts {server, tool, args} dynamically.)\n    tools: ['mcp__*'],\n  },\n\n  activate(api: OpenClawPluginApi) {\n    const log = api.logger;\n    if (api.pluginConfig?.disabled) {\n      log.info('[mcp-bundler] disabled via plugin config — no-op');\n      return;\n    }\n\n    // Setup-only and metadata-only registration modes shouldn't spawn anything.\n    if (api.registrationMode && api.registrationMode !== 'full' && api.registrationMode !== 'discovery' && api.registrationMode !== 'tool-discovery') {\n      log.info(`[mcp-bundler] skipped — registrationMode=${api.registrationMode}`);\n      return;\n    }\n\n    const initialCfg = resolveLiveConfig(api);\n    if (detectNativeBundleMcp(initialCfg)) {\n      log.info(\n        '[mcp-bundler] native bundle-mcp detected on this backend (claude-cli/codex-cli) — standing by as no-op to avoid double-registered tools',\n      );\n      return;\n    }\n\n    bundler = new McpBundler({\n      logger: log,\n      idleTtlMs: initialCfg?.mcp?.sessionIdleTtlMs ?? 10 * 60 * 1000,\n    });\n\n    // Initial reconcile in the background so the first factory call has tools\n    // ready (it'll be empty if reconcile hasn't completed yet, which is fine —\n    // the next agent turn picks them up).\n    const initialServers = initialCfg?.mcp?.servers ?? {};\n    void bundler.reconcile(initialServers).then(() => bundler?.warmup()).catch((err: unknown) => {\n      log.warn('[mcp-bundler] initial reconcile/warmup failed', { err: err instanceof Error ? err.message : String(err) });\n    });\n    lastFingerprint = fingerprintServers(initialServers);\n\n    api.registerTool((ctx: ToolFactoryContext) => {\n      const live = resolveLiveConfig(api, ctx);\n      if (!live || detectNativeBundleMcp(live)) return null;\n      const servers = live.mcp?.servers ?? {};\n\n      // Detect config drift since last reconcile and trigger a fire-and-forget\n      // reconcile. OpenClaw caches the factory output keyed on config snapshot,\n      // so this only runs when MCP config actually changed.\n      const fp = fingerprintServers(servers);\n      if (fp !== lastFingerprint) {\n        lastFingerprint = fp;\n        void bundler?.reconcile(servers).then(() => bundler?.warmup()).catch((err: unknown) => {\n          log.warn('[mcp-bundler] reconcile failed', { err: err instanceof Error ? err.message : String(err) });\n        });\n      }\n\n      const tools = bundler?.listTools() ?? [];\n      return tools.map((t) => toAgentTool(api, t));\n    }, { optional: true });\n\n    log.info(`[mcp-bundler] activated v${pkg.version}, ${Object.keys(initialServers).length.toString()} server(s) configured`);\n  },\n\n  deactivate(api: OpenClawPluginApi) {\n    api.logger.info('[mcp-bundler] deactivating');\n    if (bundler) {\n      void bundler.dispose().catch((err: unknown) => {\n        api.logger.warn('[mcp-bundler] dispose error', { err: err instanceof Error ? err.message : String(err) });\n      });\n      bundler = undefined;\n    }\n    lastFingerprint = '';\n  },\n};\n\nexport default plugin;\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiBA,MAAM,6BAA6B,IAAI,IAAI,CAAC,cAAc,YAAY,CAAC;;;;;;;;;;;;;;AAwBvE,SAAgB,sBAAsB,KAAsC;AAC1E,KAAI,CAAC,IAAK,QAAO;CACjB,MAAM,WAAW,IAAI,QAAQ;AAC7B,KAAI,CAAC,SAAU,QAAO;CAGtB,MAAM,aAAa,SAAS,eAAe,EAAE;AAC7C,MAAK,MAAM,OAAO,OAAO,KAAK,WAAW,CACvC,KAAI,2BAA2B,IAAI,IAAI,CAAE,QAAO;CAIlD,MAAM,SAAS,SAAS,SAAS,IAAI,aAAa;AAClD,KAAI,CAAC,MAAO,QAAO;AACnB,KAAI,MAAM,SAAS,SAAS,IAAI,MAAM,SAAS,YAAY,CAAE,QAAO;AACpE,KAAI,MAAM,SAAS,QAAQ,IAAI,MAAM,WAAW,cAAc,CAAE,QAAO;AACvE,QAAO;;;;;;;;;;;;;;;ACzCT,MAAM,MADU,cAAc,OAAO,KAAK,IAAI,CAC1B,kBAAkB;AAuDtC,IAAI;AACJ,IAAI,kBAAkB;AAEtB,SAAS,kBAAkB,KAAwB,KAAsD;AAEvG,QACE,KAAK,iBACL,KAAK,oBAAoB,IACzB,IAAI,SAAS,QAAQ,WAAW,IAChC,KAAK,UACL,IAAI;;AAIR,SAAS,mBAAmB,SAAkD;CAC5E,MAAM,OAAO,OAAO,KAAK,QAAQ,CAAC,MAAM;AACxC,QAAO,KAAK,UAAU,KAAK,KAAK,MAAM,CAAC,GAAG,QAAQ,GAAG,CAAC,CAAC;;AAGzD,SAAS,YAAY,KAAwB,MAAoC;AAC/E,QAAO;EACL,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,aAAa,KAAK,eAAe,YAAY,KAAK,SAAS,eAAe,KAAK;EAG/E,YAAY,KAAK;EACjB,MAAM,QAAQ,aAAa,QAAQ,QAAQ;AACzC,OAAI,CAAC,QACH,QAAO,YAAY,wCAAwC,KAAK,WAAW;GAE7E,MAAM,SAAS,MAAM,QAAQ,SAAS,KAAK,UAAU,QAAQ,OAAO;AACpE,UAAO;IACL,SAAS,OAAO;IAChB,SAAS,EAAE,SAAS,OAAO,WAAW,OAAO;IAC9C;;EAEJ;;AAGH,SAAS,YAAY,SAAkC;AACrD,QAAO;EACL,SAAS,CAAC;GAAE,MAAM;GAAQ,MAAM;GAAS,CAAC;EAC1C,SAAS,EAAE,SAAS,MAAM;EAC3B;;AAGH,MAAM,SAAS;CACb,IAAI;CACJ,MAAM;CACN,aAAa;CACb,SAAS,IAAI;CACb,WAAW,EAQT,OAAO,CAAC,SAAS,EAClB;CAED,SAAS,KAAwB;EAC/B,MAAM,MAAM,IAAI;AAChB,MAAI,IAAI,cAAc,UAAU;AAC9B,OAAI,KAAK,mDAAmD;AAC5D;;AAIF,MAAI,IAAI,oBAAoB,IAAI,qBAAqB,UAAU,IAAI,qBAAqB,eAAe,IAAI,qBAAqB,kBAAkB;AAChJ,OAAI,KAAK,4CAA4C,IAAI,mBAAmB;AAC5E;;EAGF,MAAM,aAAa,kBAAkB,IAAI;AACzC,MAAI,sBAAsB,WAAW,EAAE;AACrC,OAAI,KACF,0IACD;AACD;;AAGF,YAAU,IAAI,WAAW;GACvB,QAAQ;GACR,WAAW,YAAY,KAAK,oBAAoB,MAAU;GAC3D,CAAC;EAKF,MAAM,iBAAiB,YAAY,KAAK,WAAW,EAAE;AAChD,UAAQ,UAAU,eAAe,CAAC,WAAW,SAAS,QAAQ,CAAC,CAAC,OAAO,QAAiB;AAC3F,OAAI,KAAK,iDAAiD,EAAE,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EAAE,CAAC;IACpH;AACF,oBAAkB,mBAAmB,eAAe;AAEpD,MAAI,cAAc,QAA4B;GAC5C,MAAM,OAAO,kBAAkB,KAAK,IAAI;AACxC,OAAI,CAAC,QAAQ,sBAAsB,KAAK,CAAE,QAAO;GACjD,MAAM,UAAU,KAAK,KAAK,WAAW,EAAE;GAKvC,MAAM,KAAK,mBAAmB,QAAQ;AACtC,OAAI,OAAO,iBAAiB;AAC1B,sBAAkB;AACb,aAAS,UAAU,QAAQ,CAAC,WAAW,SAAS,QAAQ,CAAC,CAAC,OAAO,QAAiB;AACrF,SAAI,KAAK,kCAAkC,EAAE,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EAAE,CAAC;MACrG;;AAIJ,WADc,SAAS,WAAW,IAAI,EAAE,EAC3B,KAAK,MAAM,YAAY,KAAK,EAAE,CAAC;KAC3C,EAAE,UAAU,MAAM,CAAC;AAEtB,MAAI,KAAK,4BAA4B,IAAI,QAAQ,IAAI,OAAO,KAAK,eAAe,CAAC,OAAO,UAAU,CAAC,uBAAuB;;CAG5H,WAAW,KAAwB;AACjC,MAAI,OAAO,KAAK,6BAA6B;AAC7C,MAAI,SAAS;AACN,WAAQ,SAAS,CAAC,OAAO,QAAiB;AAC7C,QAAI,OAAO,KAAK,+BAA+B,EAAE,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EAAE,CAAC;KACzG;AACF,aAAU,KAAA;;AAEZ,oBAAkB;;CAErB"}

package/openclaw.plugin.json

@@ -0,0 +1,16 @@
+{
+  "id": "@alfe.ai/openclaw-mcp-bundler",
+  "name": "Alfe MCP Bundler",
+  "description": "Bridges mcp.servers config into agent tools for any LLM backend — closes the bundleMcp gap on non-Claude/Codex models",
+  "entry": "./dist/plugin.js",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "disabled": {
+        "type": "boolean",
+        "description": "Force-disable the bundler. When true, the plugin no-ops on activate."
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@alfe.ai/openclaw-mcp-bundler",
+  "version": "0.0.1",
+  "description": "OpenClaw plugin that bridges mcp.servers config into agent tool list via @alfe.ai/mcp-bundler — works for any LLM backend (not just claude-cli/codex-cli)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "require": "./dist/plugin.cjs",
+      "import": "./dist/plugin.js"
+    }
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/plugin.js"
+    ]
+  },
+  "files": [
+    "dist",
+    "openclaw.plugin.json"
+  ],
+  "dependencies": {
+    "@alfe.ai/mcp-bundler": "0.0.1"
+  },
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}