@objectstack/connector-mcp 7.4.0

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+
+> @objectstack/connector-mcp@7.4.0 build /home/runner/work/framework/framework/packages/connectors/connector-mcp
+> tsup --config ../../../tsup.config.ts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/framework/framework/tsup.config.ts
+CLI Target: es2020
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist/index.mjs     5.69 KB
+ESM dist/index.mjs.map 18.22 KB
+ESM ⚡️ Build success in 101ms
+CJS dist/index.js     7.33 KB
+CJS dist/index.js.map 19.61 KB
+CJS ⚡️ Build success in 103ms
+DTS Build start
+DTS ⚡️ Build success in 14765ms
+DTS dist/index.d.mts 6.71 KB
+DTS dist/index.d.ts  6.71 KB

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# @objectstack/connector-mcp
+
+## 7.4.0
+
+### Minor Changes
+
+- 6e4b3f2: MCP Connector (ADR-0024) — adopt any Model Context Protocol server as a connector.
+
+  Adds `@objectstack/connector-mcp`, a single generic adapter that turns _any_
+  MCP server into an ordinary `type: 'api'` connector on the automation engine —
+  no per-server code:
+
+  - `createMcpConnector({ transport, include?, … })` connects over **stdio** or
+    **streamable-HTTP**, calls `tools/list`, and maps each tool to a connector
+    action (`name → key`, `description → label/description`,
+    `inputSchema → inputSchema`). Handlers dispatch to `tools/call` and normalise
+    the result to the shared `{ ok, content, … }` envelope (logical tool errors
+    surface as `ok: false` rather than throwing).
+  - `ConnectorMcpPlugin` registers the connector via the existing
+    `engine.registerConnector()` path (no new engine surface, no `mcp_call` node)
+    and tears the MCP connection down on shutdown. Fail-soft: an unreachable
+    server or missing automation engine is logged and skipped.
+  - Credentials live with the MCP server (transport `env`/`headers`), never in
+    `ConnectorSchema` and never in the serialized, discovery-exposed `def`.
+
+  Open-tier scope: client adapter + operator-supplied static credentials. A
+  curated server registry, managed secrets, per-tenant lifecycle, and sandboxed
+  stdio execution remain the enterprise tier.
+
+### Patch Changes
+
+- Updated dependencies [23c7107]
+- Updated dependencies [c72daad]
+- Updated dependencies [f115182]
+- Updated dependencies [2faf9f2]
+- Updated dependencies [2faf9f2]
+- Updated dependencies [2faf9f2]
+- Updated dependencies [58b450b]
+- Updated dependencies [82eb6cf]
+- Updated dependencies [13d8653]
+- Updated dependencies [ff3d006]
+- Updated dependencies [5e831de]
+  - @objectstack/spec@7.4.0
+  - @objectstack/core@7.4.0

package/LICENSE

@@ -0,0 +1,93 @@
+License text copyright (c) 2020 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             ObjectStack AI LLC
+Licensed Work:        ObjectStack Runtime: the BSL-licensed packages
+                      of the ObjectStack monorepo as listed in LICENSING.md.
+                      Copyright (c) 2026 ObjectStack AI LLC.
+Additional Use Grant: You may make production use of the Licensed Work, provided
+                      Your use does not include offering the Licensed Work to third
+                      parties on a hosted or embedded basis in order to compete with 
+                      ObjectStack AI LLC's paid version(s) of the Licensed Work. For purposes 
+                      of this license:
+
+                      A "competitive offering" is a Product that is offered to third
+                      parties on a paid basis, including through paid support 
+                      arrangements, that significantly overlaps with the capabilities 
+                      of ObjectStack AI LLC's paid version(s) of the Licensed Work. If Your 
+                      Product is not a competitive offering when You first make it 
+                      generally available, it will not become a competitive offering
+                      later due to ObjectStack AI LLC releasing a new version of the Licensed 
+                      Work with additional capabilities. In addition, Products that 
+                      are not provided on a paid basis are not competitive.
+
+                      "Product" means software that is offered to end users to manage 
+                      in their own environments or offered as a service on a hosted 
+                      basis.
+
+                      "Embedded" means including the source code or executable code 
+                      from the Licensed Work in a competitive offering. "Embedded" 
+                      also means packaging the competitive offering in such a way 
+                      that the Licensed Work must be accessed or downloaded for the 
+                      competitive offering to operate.
+
+                      Hosting or using the Licensed Work(s) for internal purposes 
+                      within an organization is not considered a competitive 
+                      offering. ObjectStack AI LLC considers your organization to include all 
+                      of your affiliates under common control.
+
+                      For binding interpretive guidance on using ObjectStack AI LLC products 
+                      under the Business Source License, please visit our FAQ. 
+                      (see LICENSING.md in this repository)
+Change Date:          Four years from the date the Licensed Work is published.
+Change License:       Apache License, Version 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact licensing@objectstack.dev.
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.

package/dist/index.d.mts

@@ -0,0 +1,155 @@
+import { Connector } from '@objectstack/spec/integration';
+import { Plugin, PluginContext } from '@objectstack/core';
+
+/**
+ * MCP connector — a *generic* adapter that turns any Model Context Protocol
+ * server into a {@link Connector} (ADR-0024). Where `connector-rest` and
+ * `connector-slack` are concrete, per-service connectors, this one is a single
+ * adapter that adopts the entire MCP ecosystem with **no per-server code**:
+ *
+ *   1. connect to the MCP server over the configured transport,
+ *   2. call `tools/list` and map each tool to a connector action
+ *      (`name → key`, `description → label/description`, `inputSchema → inputSchema`),
+ *   3. build an ordinary `type: 'api'` {@link Connector} once, and
+ *   4. dispatch each `connector_action` call to the server's `tools/call`.
+ *
+ * After construction the registry, the `connector_action` node, the discovery
+ * route, and the Studio palette all see a plain connector — they never know it
+ * is backed by MCP (ADR-0024 §2).
+ *
+ * **Credentials live with the MCP server, not in `ConnectorSchema`** (ADR-0024
+ * §3). The operator supplies `env` (stdio) / `headers` (http) which we pass
+ * straight to the transport; they are never copied into the serialized `def`
+ * (which is exposed via discovery) and must never be logged.
+ *
+ * **Trust:** launching a stdio server runs a local process. Sandboxed,
+ * multi-tenant execution and managed secrets are the enterprise tier (ADR-0024
+ * §4); the open adapter runs an operator-provided server with operator-provided
+ * credentials and documents that trust assumption.
+ */
+/** How to reach the MCP server. */
+type McpTransport = {
+    kind: 'stdio';
+    /** Executable to launch (e.g. `npx`). */
+    command: string;
+    /** Arguments passed to the command. */
+    args?: string[];
+    /** Environment variables for the child process — carries credentials. */
+    env?: Record<string, string>;
+} | {
+    kind: 'http';
+    /** Streamable-HTTP endpoint of the MCP server. */
+    url: string;
+    /** Headers sent on every request — carries credentials (e.g. a bearer token). */
+    headers?: Record<string, string>;
+};
+/** A tool as advertised by an MCP server's `tools/list`. */
+interface McpToolDescriptor {
+    name: string;
+    description?: string;
+    /** JSON Schema for the tool's arguments. */
+    inputSchema?: Record<string, unknown>;
+    /** JSON Schema for the tool's result (optional — many servers omit it). */
+    outputSchema?: Record<string, unknown>;
+}
+/**
+ * The minimal slice of an MCP client the adapter needs. Kept structural so
+ * tests can inject a fake and the real SDK stays an implementation detail
+ * (mirrors `fetchImpl` injection in `connector-rest`).
+ */
+interface McpClientLike {
+    /** List the server's tools (`tools/list`). */
+    listTools(): Promise<McpToolDescriptor[]>;
+    /** Invoke a tool (`tools/call`); returns the raw MCP result. */
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    /** Close the connection / tear down the transport. */
+    close(): Promise<void>;
+}
+interface McpConnectorOptions {
+    /** Connector machine name (snake_case). Defaults to a slug of `label`, else `mcp`. */
+    name?: string;
+    /** Human-readable label. Defaults to a title derived from `name`. */
+    label?: string;
+    /** Connector description for the palette. */
+    description?: string;
+    /** Icon identifier. Defaults to `plug`. */
+    icon?: string;
+    /** How to reach the MCP server. */
+    transport: McpTransport;
+    /** Only expose tools whose name matches (allowlist) — keeps the palette lean. */
+    include?: (toolName: string) => boolean;
+    /** Identifies this client to the MCP server during the handshake. */
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+    /**
+     * Injected for tests; defaults to the real SDK-backed client. Receives the
+     * configured transport and returns a connected {@link McpClientLike}.
+     */
+    clientFactory?: (transport: McpTransport, clientInfo: {
+        name: string;
+        version: string;
+    }) => Promise<McpClientLike>;
+}
+/**
+ * A connector definition + handlers, ready for `engine.registerConnector()`,
+ * plus a `close()` for the connection lifecycle (called by the plugin's stop()).
+ */
+interface McpConnectorBundle {
+    def: Connector;
+    handlers: Record<string, (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>>;
+    /** Tear down the MCP client/connection. */
+    close(): Promise<void>;
+}
+/**
+ * Connect to an MCP server, discover its tools, and build a {@link Connector}
+ * whose actions dispatch to the server's `tools/call`. The connection is held
+ * open for the lifetime of the bundle; call {@link McpConnectorBundle.close} to
+ * tear it down.
+ */
+declare function createMcpConnector(opts: McpConnectorOptions): Promise<McpConnectorBundle>;
+
+/**
+ * Minimal surface of the automation engine this plugin depends on — the
+ * connector registry from ADR-0018 §Addendum. Kept structural so the plugin
+ * needs no runtime dependency on `@objectstack/service-automation`.
+ */
+interface ConnectorRegistrySurface {
+    registerConnector(def: Connector, handlers: Record<string, (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>>): void;
+    unregisterConnector(name: string): void;
+}
+interface ConnectorMcpPluginOptions extends McpConnectorOptions {
+}
+/**
+ * ConnectorMcpPlugin — connects to an MCP server, discovers its tools, and
+ * registers them as a single connector on the automation engine (ADR-0024).
+ * One generic adapter, configured per server (transport + `include`), never
+ * per-server code.
+ *
+ * Lifecycle: on `start()` it connects and builds the connector once; on
+ * `stop()` it tears the MCP connection down. If no automation engine is present
+ * — or the server is unreachable at boot — the plugin logs and skips: a missing
+ * optional connector is not a fatal error (same posture as `ConnectorRestPlugin`).
+ */
+declare class ConnectorMcpPlugin implements Plugin {
+    name: string;
+    version: string;
+    type: "standard";
+    dependencies: string[];
+    private readonly options;
+    private connectorName?;
+    private automation?;
+    private close?;
+    constructor(options: ConnectorMcpPluginOptions);
+    init(_ctx: PluginContext): Promise<void>;
+    start(ctx: PluginContext): Promise<void>;
+    /**
+     * Destroy phase — the kernel's shutdown hook (the `Plugin` lifecycle exposes
+     * `destroy()`, not `stop()`). Unregister the connector and tear the MCP
+     * connection down so no child process / socket is leaked.
+     */
+    destroy(): Promise<void>;
+}
+
+export { ConnectorMcpPlugin, type ConnectorMcpPluginOptions, type ConnectorRegistrySurface, type McpClientLike, type McpConnectorBundle, type McpConnectorOptions, type McpToolDescriptor, type McpTransport, createMcpConnector };

package/dist/index.d.ts

@@ -0,0 +1,155 @@
+import { Connector } from '@objectstack/spec/integration';
+import { Plugin, PluginContext } from '@objectstack/core';
+
+/**
+ * MCP connector — a *generic* adapter that turns any Model Context Protocol
+ * server into a {@link Connector} (ADR-0024). Where `connector-rest` and
+ * `connector-slack` are concrete, per-service connectors, this one is a single
+ * adapter that adopts the entire MCP ecosystem with **no per-server code**:
+ *
+ *   1. connect to the MCP server over the configured transport,
+ *   2. call `tools/list` and map each tool to a connector action
+ *      (`name → key`, `description → label/description`, `inputSchema → inputSchema`),
+ *   3. build an ordinary `type: 'api'` {@link Connector} once, and
+ *   4. dispatch each `connector_action` call to the server's `tools/call`.
+ *
+ * After construction the registry, the `connector_action` node, the discovery
+ * route, and the Studio palette all see a plain connector — they never know it
+ * is backed by MCP (ADR-0024 §2).
+ *
+ * **Credentials live with the MCP server, not in `ConnectorSchema`** (ADR-0024
+ * §3). The operator supplies `env` (stdio) / `headers` (http) which we pass
+ * straight to the transport; they are never copied into the serialized `def`
+ * (which is exposed via discovery) and must never be logged.
+ *
+ * **Trust:** launching a stdio server runs a local process. Sandboxed,
+ * multi-tenant execution and managed secrets are the enterprise tier (ADR-0024
+ * §4); the open adapter runs an operator-provided server with operator-provided
+ * credentials and documents that trust assumption.
+ */
+/** How to reach the MCP server. */
+type McpTransport = {
+    kind: 'stdio';
+    /** Executable to launch (e.g. `npx`). */
+    command: string;
+    /** Arguments passed to the command. */
+    args?: string[];
+    /** Environment variables for the child process — carries credentials. */
+    env?: Record<string, string>;
+} | {
+    kind: 'http';
+    /** Streamable-HTTP endpoint of the MCP server. */
+    url: string;
+    /** Headers sent on every request — carries credentials (e.g. a bearer token). */
+    headers?: Record<string, string>;
+};
+/** A tool as advertised by an MCP server's `tools/list`. */
+interface McpToolDescriptor {
+    name: string;
+    description?: string;
+    /** JSON Schema for the tool's arguments. */
+    inputSchema?: Record<string, unknown>;
+    /** JSON Schema for the tool's result (optional — many servers omit it). */
+    outputSchema?: Record<string, unknown>;
+}
+/**
+ * The minimal slice of an MCP client the adapter needs. Kept structural so
+ * tests can inject a fake and the real SDK stays an implementation detail
+ * (mirrors `fetchImpl` injection in `connector-rest`).
+ */
+interface McpClientLike {
+    /** List the server's tools (`tools/list`). */
+    listTools(): Promise<McpToolDescriptor[]>;
+    /** Invoke a tool (`tools/call`); returns the raw MCP result. */
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    /** Close the connection / tear down the transport. */
+    close(): Promise<void>;
+}
+interface McpConnectorOptions {
+    /** Connector machine name (snake_case). Defaults to a slug of `label`, else `mcp`. */
+    name?: string;
+    /** Human-readable label. Defaults to a title derived from `name`. */
+    label?: string;
+    /** Connector description for the palette. */
+    description?: string;
+    /** Icon identifier. Defaults to `plug`. */
+    icon?: string;
+    /** How to reach the MCP server. */
+    transport: McpTransport;
+    /** Only expose tools whose name matches (allowlist) — keeps the palette lean. */
+    include?: (toolName: string) => boolean;
+    /** Identifies this client to the MCP server during the handshake. */
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+    /**
+     * Injected for tests; defaults to the real SDK-backed client. Receives the
+     * configured transport and returns a connected {@link McpClientLike}.
+     */
+    clientFactory?: (transport: McpTransport, clientInfo: {
+        name: string;
+        version: string;
+    }) => Promise<McpClientLike>;
+}
+/**
+ * A connector definition + handlers, ready for `engine.registerConnector()`,
+ * plus a `close()` for the connection lifecycle (called by the plugin's stop()).
+ */
+interface McpConnectorBundle {
+    def: Connector;
+    handlers: Record<string, (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>>;
+    /** Tear down the MCP client/connection. */
+    close(): Promise<void>;
+}
+/**
+ * Connect to an MCP server, discover its tools, and build a {@link Connector}
+ * whose actions dispatch to the server's `tools/call`. The connection is held
+ * open for the lifetime of the bundle; call {@link McpConnectorBundle.close} to
+ * tear it down.
+ */
+declare function createMcpConnector(opts: McpConnectorOptions): Promise<McpConnectorBundle>;
+
+/**
+ * Minimal surface of the automation engine this plugin depends on — the
+ * connector registry from ADR-0018 §Addendum. Kept structural so the plugin
+ * needs no runtime dependency on `@objectstack/service-automation`.
+ */
+interface ConnectorRegistrySurface {
+    registerConnector(def: Connector, handlers: Record<string, (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>>): void;
+    unregisterConnector(name: string): void;
+}
+interface ConnectorMcpPluginOptions extends McpConnectorOptions {
+}
+/**
+ * ConnectorMcpPlugin — connects to an MCP server, discovers its tools, and
+ * registers them as a single connector on the automation engine (ADR-0024).
+ * One generic adapter, configured per server (transport + `include`), never
+ * per-server code.
+ *
+ * Lifecycle: on `start()` it connects and builds the connector once; on
+ * `stop()` it tears the MCP connection down. If no automation engine is present
+ * — or the server is unreachable at boot — the plugin logs and skips: a missing
+ * optional connector is not a fatal error (same posture as `ConnectorRestPlugin`).
+ */
+declare class ConnectorMcpPlugin implements Plugin {
+    name: string;
+    version: string;
+    type: "standard";
+    dependencies: string[];
+    private readonly options;
+    private connectorName?;
+    private automation?;
+    private close?;
+    constructor(options: ConnectorMcpPluginOptions);
+    init(_ctx: PluginContext): Promise<void>;
+    start(ctx: PluginContext): Promise<void>;
+    /**
+     * Destroy phase — the kernel's shutdown hook (the `Plugin` lifecycle exposes
+     * `destroy()`, not `stop()`). Unregister the connector and tear the MCP
+     * connection down so no child process / socket is leaked.
+     */
+    destroy(): Promise<void>;
+}
+
+export { ConnectorMcpPlugin, type ConnectorMcpPluginOptions, type ConnectorRegistrySurface, type McpClientLike, type McpConnectorBundle, type McpConnectorOptions, type McpToolDescriptor, type McpTransport, createMcpConnector };

package/dist/index.js

@@ -0,0 +1,212 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConnectorMcpPlugin: () => ConnectorMcpPlugin,
+  createMcpConnector: () => createMcpConnector
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/mcp-connector.ts
+var DEFAULT_CLIENT_INFO = { name: "objectstack-connector-mcp", version: "1.0.0" };
+function slugify(input) {
+  const slug = input.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (!slug) return "mcp";
+  return /^[a-z_]/.test(slug) ? slug : `mcp_${slug}`;
+}
+function titleize(name) {
+  return name.split("_").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function normalizeResult(raw) {
+  const result = raw ?? {};
+  const isError = result.isError === true;
+  const out = {
+    ok: !isError,
+    content: result.content ?? []
+  };
+  if (result.structuredContent !== void 0) out.structuredContent = result.structuredContent;
+  if (isError) out.isError = true;
+  return out;
+}
+async function defaultClientFactory(transport, clientInfo) {
+  const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+  const client = new Client(clientInfo, { capabilities: {} });
+  if (transport.kind === "stdio") {
+    const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+    await client.connect(
+      new StdioClientTransport({
+        command: transport.command,
+        args: transport.args,
+        env: transport.env
+      })
+    );
+  } else {
+    const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    await client.connect(
+      new StreamableHTTPClientTransport(new URL(transport.url), {
+        requestInit: transport.headers ? { headers: transport.headers } : void 0
+      })
+    );
+  }
+  return {
+    async listTools() {
+      const res = await client.listTools();
+      return res.tools ?? [];
+    },
+    async callTool(name, args) {
+      return client.callTool({ name, arguments: args });
+    },
+    async close() {
+      await client.close();
+    }
+  };
+}
+async function createMcpConnector(opts) {
+  const clientInfo = opts.clientInfo ?? DEFAULT_CLIENT_INFO;
+  const factory = opts.clientFactory ?? defaultClientFactory;
+  const client = await factory(opts.transport, clientInfo);
+  let tools;
+  try {
+    tools = await client.listTools();
+  } catch (err) {
+    await client.close().catch(() => {
+    });
+    throw err;
+  }
+  const include = opts.include ?? (() => true);
+  const selected = tools.filter((t) => include(t.name));
+  const name = opts.name ?? slugify(opts.label ?? "mcp");
+  const label = opts.label ?? titleize(name);
+  const handlers = {};
+  const def = {
+    name,
+    label,
+    type: "api",
+    description: opts.description ?? `MCP connector exposing ${selected.length} tool(s) from a Model Context Protocol server.`,
+    icon: opts.icon ?? "plug",
+    // MCP servers own their own auth (passed via transport env/headers); we
+    // do not model the upstream's credentials in ConnectorSchema (ADR-0024 §3).
+    authentication: { type: "none" },
+    // Defaulted by ConnectorSchema; set explicitly so the literal satisfies
+    // the (post-parse) Connector output type.
+    status: "active",
+    enabled: true,
+    connectionTimeoutMs: 3e4,
+    requestTimeoutMs: 3e4,
+    actions: selected.map((tool) => ({
+      key: tool.name,
+      // MCP tool names are machine names; derive a readable label and keep
+      // the server's description verbatim (ADR-0024 `description → label/description`).
+      label: titleize(slugify(tool.name)),
+      description: tool.description,
+      // The MCP inputSchema is already JSON Schema — pass it straight through.
+      inputSchema: tool.inputSchema,
+      // Many servers omit outputSchema; leave it unset when absent (as the
+      // REST connector does for untyped responses).
+      outputSchema: tool.outputSchema
+    }))
+  };
+  for (const tool of selected) {
+    handlers[tool.name] = async (input) => normalizeResult(await client.callTool(tool.name, input));
+  }
+  return {
+    def,
+    handlers,
+    close: () => client.close()
+  };
+}
+
+// src/connector-mcp-plugin.ts
+var ConnectorMcpPlugin = class {
+  constructor(options) {
+    this.name = "com.objectstack.connector.mcp";
+    this.version = "1.0.0";
+    this.type = "standard";
+    // Ensure the automation engine (and its connector registry) is started first.
+    this.dependencies = ["com.objectstack.service-automation"];
+    this.options = options;
+  }
+  async init(_ctx) {
+  }
+  async start(ctx) {
+    let automation;
+    try {
+      automation = ctx.getService("automation");
+    } catch {
+      automation = void 0;
+    }
+    if (!automation || typeof automation.registerConnector !== "function") {
+      ctx.logger.info("ConnectorMcpPlugin: no automation engine \u2014 MCP connector not registered");
+      return;
+    }
+    let bundle;
+    try {
+      bundle = await createMcpConnector(this.options);
+    } catch (err) {
+      ctx.logger.warn(
+        `ConnectorMcpPlugin: could not connect to MCP server \u2014 connector not registered: ${err.message}`
+      );
+      return;
+    }
+    automation.registerConnector(bundle.def, bundle.handlers);
+    this.automation = automation;
+    this.connectorName = bundle.def.name;
+    this.close = bundle.close;
+    ctx.logger.info(
+      `ConnectorMcpPlugin: MCP connector '${bundle.def.name}' registered with ${bundle.def.actions?.length ?? 0} action(s)`
+    );
+  }
+  /**
+   * Destroy phase — the kernel's shutdown hook (the `Plugin` lifecycle exposes
+   * `destroy()`, not `stop()`). Unregister the connector and tear the MCP
+   * connection down so no child process / socket is leaked.
+   */
+  async destroy() {
+    if (this.automation && this.connectorName) {
+      try {
+        this.automation.unregisterConnector(this.connectorName);
+      } catch {
+      }
+    }
+    if (this.close) {
+      try {
+        await this.close();
+      } catch {
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectorMcpPlugin,
+  createMcpConnector
+});
+//# sourceMappingURL=index.js.map