@noodleseed/one 0.138.0 → 0.139.1

package/node_modules/@noodle-borg/assistant-gateway/package.json

@@ -40,7 +40,7 @@
     "@noodle-borg/module": "0.0.0",
     "@noodle-borg/protocol": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
-    "@noodleseed/assistant": "1.23.0"
+    "@noodleseed/assistant": "1.24.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.1",

package/node_modules/@noodle-borg/authoring/dist/connections.js

@@ -20,6 +20,7 @@ export function bind(connector, options) {
             : {}),
         ...(connector.definitions !== undefined ? { definitions: connector.definitions } : {}),
         ...(connector.httpDef !== undefined ? { httpDef: connector.httpDef } : {}),
+        ...(connector.mcpDef !== undefined ? { mcpDef: connector.mcpDef } : {}),
         binding: { profile: options.profile, connection: options.connection },
     };
 }

package/node_modules/@noodle-borg/authoring/dist/connectors.d.ts

@@ -1,5 +1,5 @@
 import { type CustomerEndpointRef, type JsonSchema, type OperationSignature } from '@noodle-borg/compiler';
-import { type ConnectorFile, type CredentialProfileDef, type HttpConnectorDef } from '@noodle-borg/connector-defs';
+import { type ConnectorFile, type CredentialProfileDef, type HttpConnectorDef, type McpConnectorDef } from '@noodle-borg/connector-defs';
 import { z } from 'zod';
 import { type ConfigRef } from './config.js';
 import type { ConnectionBinding } from './connection-types.js';
@@ -86,7 +86,24 @@ export type HttpConnectorOptions = Omit<HttpConnectorDef['http'], 'baseUrl' | 'a
     readonly credentialProfiles?: HttpConnectorDef['credentialProfiles'];
     readonly operations: Readonly<Record<string, HttpOperationOptionsWithRefs>>;
 };
-type DeclaredCredentialProfileKeys<Options extends HttpConnectorOptions> = Options extends {
+export type McpAuthOptions = Extract<HttpAuthOptions, {
+    readonly kind: 'bearer' | 'apiKey' | 'clientCredentials';
+}>;
+type McpOperationOptionsWithRefs = Omit<McpConnectorDef['operations'][string], 'auth' | 'input' | 'output'> & {
+    readonly auth?: McpAuthOptions;
+    readonly input?: OperationIoOptions;
+    readonly output?: OperationIoOptions;
+};
+export type McpConnectorOptions = Omit<McpConnectorDef['mcp'], 'endpoint' | 'allowedOrigins' | 'auth'> & {
+    readonly endpoint: string | ConfigRef;
+    readonly allowedOrigins?: readonly (string | ConfigRef)[];
+    readonly auth?: McpAuthOptions;
+    readonly credentialProfiles?: McpConnectorDef['credentialProfiles'];
+    readonly operations: Readonly<Record<string, McpOperationOptionsWithRefs>>;
+};
+type DeclaredCredentialProfileKeys<Options extends {
+    readonly credentialProfiles?: unknown;
+}> = Options extends {
     readonly credentialProfiles: infer Profiles;
 } ? Extract<keyof Profiles, string> : never;
 export interface ConnectorOperationOptions {
@@ -142,6 +159,8 @@ export interface ConnectorRef<CredentialProfileKey extends string = string> {
     readonly definitions?: Readonly<Record<string, ConnectorOpDefinition>>;
     /** HTTP fulfilment (present for connectors declared with `.http()`), emitted to the catalog verbatim. */
     readonly httpDef?: HttpConnectorDef;
+    /** MCP fulfilment (present for connectors declared with `.mcp()`), emitted to the catalog verbatim. */
+    readonly mcpDef?: McpConnectorDef;
 }
 /**
  * The connector-catalog document the SDK emits for the compiler. It is the canonical `ConnectorFile` from
@@ -160,8 +179,9 @@ export declare class ConnectorBuilder<CredentialProfileKey extends string = neve
     readonly operations: Readonly<Record<string, OperationSignature>>;
     readonly definitions: Readonly<Record<string, ConnectorOpDefinition>>;
     readonly httpDef?: HttpConnectorDef;
+    readonly mcpDef?: McpConnectorDef;
     readonly credentialProfiles?: Readonly<Record<CredentialProfileKey, CredentialProfileDef>>;
-    constructor(id: string, version: string, operations?: Readonly<Record<string, OperationSignature>>, definitions?: Readonly<Record<string, ConnectorOpDefinition>>, httpDef?: HttpConnectorDef, credentialProfiles?: Readonly<Record<CredentialProfileKey, CredentialProfileDef>>);
+    constructor(id: string, version: string, operations?: Readonly<Record<string, OperationSignature>>, definitions?: Readonly<Record<string, ConnectorOpDefinition>>, httpDef?: HttpConnectorDef, credentialProfiles?: Readonly<Record<CredentialProfileKey, CredentialProfileDef>>, mcpDef?: McpConnectorDef);
     /** Declare the credential profiles supported by a curated signature ref or compute connector. */
     credentials<const Profiles extends Readonly<Record<string, CredentialProfileDef>>>(profiles: Profiles): ConnectorBuilder<Extract<keyof Profiles, string>>;
     /** Declare an operation by signature only (fulfilment supplied elsewhere, e.g. a catalog by `id@version`). */
@@ -173,6 +193,8 @@ export declare class ConnectorBuilder<CredentialProfileKey extends string = neve
      * `.provides()`-d. The typed options are validated against the canonical schema at author time.
      */
     http<const Options extends HttpConnectorOptions>(options: Options): ConnectorBuilder<DeclaredCredentialProfileKeys<Options>>;
+    /** Declare a governed remote MCP connector from an imported, frozen upstream tool snapshot. */
+    mcp<const Options extends McpConnectorOptions>(options: Options): ConnectorBuilder<DeclaredCredentialProfileKeys<Options>>;
     /** Declare a sandboxed-compute operation: `run` is your function, shipped as the connector's `code`. */
     compute(name: string, options: ComputeOperationOptions): ConnectorBuilder<CredentialProfileKey>;
 }

package/node_modules/@noodle-borg/authoring/dist/connectors.js

@@ -48,8 +48,9 @@ export class ConnectorBuilder {
     operations;
     definitions;
     httpDef;
+    mcpDef;
     credentialProfiles;
-    constructor(id, version, operations = {}, definitions = {}, httpDef, credentialProfiles) {
+    constructor(id, version, operations = {}, definitions = {}, httpDef, credentialProfiles, mcpDef) {
         this.id = id;
         this.version = version;
         this.operations = operations;
@@ -57,20 +58,22 @@ export class ConnectorBuilder {
         // Assign conditionally (not `= undefined`) to satisfy exactOptionalPropertyTypes.
         if (httpDef !== undefined)
             this.httpDef = httpDef;
-        const declaredProfiles = credentialProfiles ?? httpDef?.credentialProfiles;
+        if (mcpDef !== undefined)
+            this.mcpDef = mcpDef;
+        const declaredProfiles = credentialProfiles ?? httpDef?.credentialProfiles ?? mcpDef?.credentialProfiles;
         if (declaredProfiles !== undefined) {
             this.credentialProfiles = declaredProfiles;
         }
     }
     /** Declare the credential profiles supported by a curated signature ref or compute connector. */
     credentials(profiles) {
-        if (this.httpDef !== undefined) {
-            throw new Error(`connector "${this.id}" is HTTP — declare credentialProfiles inside .http(...)`);
+        if (this.httpDef !== undefined || this.mcpDef !== undefined) {
+            throw new Error(`connector "${this.id}" owns its transport — declare credentialProfiles inside the transport options`);
         }
         if (this.credentialProfiles !== undefined) {
             throw new Error(`connector "${this.id}" already declares credential profiles`);
         }
-        return new ConnectorBuilder(this.id, this.version, this.operations, this.definitions, undefined, { ...profiles });
+        return new ConnectorBuilder(this.id, this.version, this.operations, this.definitions, undefined, { ...profiles }, undefined);
     }
     /** Declare an operation by signature only (fulfilment supplied elsewhere, e.g. a catalog by `id@version`). */
     operation(name, options) {
@@ -81,7 +84,7 @@ export class ConnectorBuilder {
                 input: toOperationIoSchema(options.input, 'input', `${this.id}.${name}`),
                 output: toOperationIoSchema(options.output, 'output', `${this.id}.${name}`),
             },
-        }, this.definitions, this.httpDef, this.credentialProfiles);
+        }, this.definitions, this.httpDef, this.credentialProfiles, this.mcpDef);
     }
     /**
      * Declare this as an **HTTP connector**: transport (`baseUrl`/`allowedOrigins`), `bearer`/`apiKey` auth
@@ -93,6 +96,9 @@ export class ConnectorBuilder {
         if (this.credentialProfiles !== undefined) {
             throw new Error(`connector "${this.id}" already uses .credentials(...) — HTTP connectors declare credentialProfiles inside .http(...)`);
         }
+        if (this.mcpDef !== undefined) {
+            throw new Error(`connector "${this.id}" is already an .mcp() connector — a connector has one engine`);
+        }
         if (Object.keys(this.definitions).length > 0) {
             throw new Error(`connector "${this.id}" already has .compute() operations — a connector is HTTP or compute, not both`);
         }
@@ -120,11 +126,80 @@ export class ConnectorBuilder {
         }
         return new ConnectorBuilder(this.id, this.version, signatures, this.definitions, def);
     }
+    /** Declare a governed remote MCP connector from an imported, frozen upstream tool snapshot. */
+    mcp(options) {
+        if (this.credentialProfiles !== undefined) {
+            throw new Error(`connector "${this.id}" already uses .credentials(...) — MCP connectors declare credentialProfiles inside .mcp(...)`);
+        }
+        if (this.httpDef !== undefined) {
+            throw new Error(`connector "${this.id}" is already an .http() connector — a connector has one engine`);
+        }
+        if (Object.keys(this.definitions).length > 0) {
+            throw new Error(`connector "${this.id}" already has .compute() operations — a connector is MCP or compute, not both`);
+        }
+        const operations = {};
+        for (const [name, operation] of Object.entries(options.operations)) {
+            const output = operation.result === 'text' && operation.output === undefined
+                ? {
+                    type: 'object',
+                    properties: { text: { type: 'string' } },
+                    required: ['text'],
+                    additionalProperties: false,
+                }
+                : toOperationIoSchema(operation.output, 'output', `${this.id}.${name}`);
+            operations[name] = {
+                ...operation,
+                result: operation.result ?? 'structured',
+                input: toOperationIoSchema(operation.input, 'input', `${this.id}.${name}`),
+                output,
+                ...(operation.auth === undefined
+                    ? {}
+                    : {
+                        auth: normalizeAuth(operation.auth, `connectors.${this.id}.operations.${name}.auth`),
+                    }),
+            };
+        }
+        const { credentialProfiles, operations: _operations, ...mcpOptions } = options;
+        const def = {
+            id: this.id,
+            version: this.version,
+            kind: 'custom',
+            ...(credentialProfiles === undefined ? {} : { credentialProfiles }),
+            mcp: {
+                ...mcpOptions,
+                endpoint: normalizeVariableOrString(options.endpoint, `connectors.${this.id}.mcp.endpoint`),
+                ...(options.allowedOrigins === undefined
+                    ? {}
+                    : {
+                        allowedOrigins: options.allowedOrigins.map((origin, index) => normalizeVariableOrString(origin, `connectors.${this.id}.mcp.allowedOrigins.${index}`)),
+                    }),
+                ...(options.auth === undefined
+                    ? {}
+                    : {
+                        auth: normalizeAuth(options.auth, `connectors.${this.id}.mcp.auth`),
+                    }),
+            },
+            operations,
+        };
+        validateCatalog({ connectors: [def] });
+        const signatures = {};
+        for (const [name, operation] of Object.entries(operations)) {
+            signatures[name] = {
+                type: operation.type,
+                input: normalizeOperationIoSchema(operation.input),
+                output: normalizeOperationIoSchema(operation.output),
+            };
+        }
+        return new ConnectorBuilder(this.id, this.version, signatures, this.definitions, undefined, undefined, def);
+    }
     /** Declare a sandboxed-compute operation: `run` is your function, shipped as the connector's `code`. */
     compute(name, options) {
         if (this.httpDef) {
             throw new Error(`connector "${this.id}" is already an .http() connector — a connector is HTTP or compute, not both`);
         }
+        if (this.mcpDef) {
+            throw new Error(`connector "${this.id}" is already an .mcp() connector — a connector is MCP or compute, not both`);
+        }
         const type = options.type ?? 'read';
         const input = toOperationIoSchema(options.input, 'input', `${this.id}.${name}`);
         const output = toOperationIoSchema(options.output, 'output', `${this.id}.${name}`);
@@ -139,7 +214,7 @@ export class ConnectorBuilder {
                 ...(options.limits ? { limits: options.limits } : {}),
                 ...(options.calls ? { calls: options.calls } : {}),
             },
-        }, undefined, this.credentialProfiles);
+        }, undefined, this.credentialProfiles, undefined);
     }
 }
 function rejectUnsafeActionRetry(id, options) {

package/node_modules/@noodle-borg/authoring/dist/index.d.ts

@@ -5,7 +5,7 @@ export type { AgentCapabilityKind, AgentCapabilityRef, AgentExampleSource, Agent
 export { type AssistantAccess, type AssistantCapability, type AssistantLabels, type AssistantLayoutMode, type AssistantModel, type AssistantPosition, type AssistantPresentationOptions, type AssistantPresentationTone, type AssistantSurfaceConfig, type AssistantSurfaceMode, type AssistantThemeMode, type AssistantUiOptions, type AuthenticatedWebsiteAccess, type AuthenticatedWebsiteInput, authenticatedWebsite, type CapabilityRef, type EmbeddedAssistantConfig, type EmbeddedAssistantOptions, embeddedAssistant, type NoodleManagedModel, noodleManaged, type OpenAICompatibleModel, type OpenAICompatibleModelInput, openAICompatible, type PublicWebsiteAccess, type PublicWebsiteInput, publicWebsite, } from './assistant.js';
 export { type ConfigRef, type ConfigRefKind, secret, variable, } from './config.js';
 export { type BoundConnectorRef, bind, type ConnectionBinding, type ConnectionRef, type ConnectionSource, clientCredentials, connection, externalExchange, type GoogleWorkloadIdentityAccess, googleWorkloadIdentity, managedSecret, } from './connections.js';
-export { type ComputeHost, type ComputeLimits, type ComputeOperationOptions, ConnectorBuilder, type ConnectorCatalogDoc, type ConnectorOpDefinition, type ConnectorOperationOptions, type ConnectorRef, connector, type HttpConnectorOptions, } from './connectors.js';
+export { type ComputeHost, type ComputeLimits, type ComputeOperationOptions, ConnectorBuilder, type ConnectorCatalogDoc, type ConnectorOpDefinition, type ConnectorOperationOptions, type ConnectorRef, connector, type HttpConnectorOptions, type McpAuthOptions, type McpConnectorOptions, } from './connectors.js';
 export type { AmbientContextOptions, AmbientProviderContext, ServerContextOptions, } from './context.js';
 export { type CustomerAuth, type CustomerAuthClaimMap, type CustomerAuthRouting, type CustomerEndpointClaimMapping, customerAuth, type FederatedOidcIssuer, } from './customer-auth.js';
 export { type CustomerEndpointPolicy, type CustomerEndpointRef, customerEndpoint, } from './customer-endpoint.js';

package/node_modules/@noodle-borg/authoring/dist/model-tool-visibility.js

@@ -0,0 +1,33 @@
+const ANNOTATION = 'x-noodleseed-model-latest-message-includes-any';
+const MAX_PHRASES = 32;
+const MAX_PHRASE_CHARS = 128;
+export function manifestToolAnnotations(options) {
+    if (Object.hasOwn(options.annotations ?? {}, ANNOTATION)) {
+        throw new Error(`Use modelVisibility.latestMessageIncludesAny instead of the reserved ${ANNOTATION} annotation.`);
+    }
+    if (options.modelVisibility === undefined) {
+        return options.annotations ? { annotations: { ...options.annotations } } : {};
+    }
+    const phrases = options.modelVisibility.latestMessageIncludesAny;
+    if (phrases.length < 1 || phrases.length > MAX_PHRASES) {
+        throw new Error(`modelVisibility.latestMessageIncludesAny must contain 1-${MAX_PHRASES} literal phrases.`);
+    }
+    const trimmed = phrases.map((phrase) => phrase.trim());
+    const normalized = trimmed.map(normalize);
+    if (trimmed.some((phrase, index) => phrase.length > MAX_PHRASE_CHARS || normalized[index]?.length === 0)) {
+        throw new Error(`modelVisibility.latestMessageIncludesAny phrases must contain text and be at most ${MAX_PHRASE_CHARS} characters.`);
+    }
+    if (new Set(normalized).size !== normalized.length) {
+        throw new Error('modelVisibility.latestMessageIncludesAny phrases must be unique.');
+    }
+    return { annotations: { ...options.annotations, [ANNOTATION]: trimmed } };
+}
+function normalize(value) {
+    return value
+        .normalize('NFKC')
+        .toLocaleLowerCase('en-US')
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .trim()
+        .replace(/\s+/gu, ' ');
+}
+//# sourceMappingURL=model-tool-visibility.js.map

package/node_modules/@noodle-borg/authoring/dist/server.d.ts

@@ -132,6 +132,11 @@ export interface ToolOptions {
     readonly input: JsonSchema | z.ZodType;
     readonly output?: JsonSchema | z.ZodType;
     readonly annotations?: Readonly<Record<string, unknown>>;
+    /** Deterministic model-discovery constraints. These do not grant invocation authority. */
+    readonly modelVisibility?: {
+        /** Show this tool to the model only when the latest user message contains one of these literals. */
+        readonly latestMessageIncludesAny: readonly string[];
+    };
     /**
      * Tool-surface visibility (SEP-1865 `_meta.ui.visibility`). Default `['model', 'app']`. Set `['app']`
      * for a **UI-only helper** — discoverable with app-only metadata so hosts can hide it from the model

package/node_modules/@noodle-borg/authoring/dist/server.js

@@ -10,6 +10,7 @@ import { manifestContext } from './context.js';
 import { manifestCustomerAuth } from './customer-auth.js';
 import { toJsonSchema } from './json-schema.js';
 import { manifestKnowledge } from './knowledge.js';
+import { manifestToolAnnotations } from './model-tool-visibility.js';
 import { recordFulfilment, recordTool, } from './recording.js';
 const WIDGET_RESULT_META_KEY = '__noodleResultMeta';
 export function server(name, options, definitions = []) {
@@ -142,7 +143,7 @@ class ServerBuilder {
                 ...(tool.options.contextProvider ? { contextProvider: true } : {}),
                 inputSchema: toJsonSchema(tool.options.input, 'input'),
                 ...(tool.options.output ? { outputSchema: toJsonSchema(tool.options.output) } : {}),
-                ...(tool.options.annotations ? { annotations: { ...tool.options.annotations } } : {}),
+                ...manifestToolAnnotations(tool.options),
                 ...(tool.options.visibility?.length ? { visibility: [...tool.options.visibility] } : {}),
                 fulfilment: {
                     steps: recorded.steps,
@@ -251,7 +252,7 @@ class ServerBuilder {
     }
     toConnectorCatalog() {
         // `use ∪ provides` is the authoritative emit set: each connector carries its own fulfilment — an
-        // HTTP def (`.http()`) or compute definitions (`.compute()`). Signature-only connectors are skipped.
+        // HTTP/MCP transport def or compute definitions. Signature-only connectors are skipped.
         const connectors = [];
         const seen = new Set();
         for (const c of [...Object.values(this.connectors), ...Object.values(this.provided)]) {
@@ -262,6 +263,10 @@ class ServerBuilder {
                 connectors.push(c.httpDef);
                 continue;
             }
+            if (c.mcpDef) {
+                connectors.push(c.mcpDef);
+                continue;
+            }
             const definitions = c.definitions;
             if (definitions && Object.keys(definitions).length > 0) {
                 const credentialProfiles = c.credentialProfiles;

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-account.js

@@ -110,7 +110,7 @@ export const CATALOG_ACCOUNT = [
             },
             {
                 name: 'init',
-                summary: 'Write a noodle.service.yaml from a named profile.',
+                summary: 'Initialize a service profile or the local open-core Compose stack.',
                 arguments: [],
                 flags: [
                     {
@@ -128,6 +128,18 @@ export const CATALOG_ACCOUNT = [
                         type: 'boolean',
                         summary: 'Overwrite a changed existing config.',
                     },
+                    {
+                        ...OPTIONAL_FLAG,
+                        name: 'compose',
+                        type: 'boolean',
+                        summary: 'Generate the local Docker Compose state for the open-core profile.',
+                    },
+                    {
+                        ...OPTIONAL_FLAG,
+                        name: 'replace-secrets',
+                        type: 'boolean',
+                        summary: 'Rotate all generated secrets; requires --compose.',
+                    },
                 ],
             },
             {

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-bootstrap-authoring.js

@@ -129,7 +129,7 @@ export const CATALOG_BOOTSTRAP_AUTHORING = [
         name: 'import',
         section: 'build',
         helpRank: 8,
-        summary: 'Scaffold starter code from an OpenAPI spec.',
+        summary: 'Scaffold starter code from OpenAPI or a frozen upstream MCP tool snapshot.',
         arguments: [],
         flags: [],
         subcommands: [
@@ -158,6 +158,35 @@ export const CATALOG_BOOTSTRAP_AUTHORING = [
                     FORCE_FLAG,
                 ],
             },
+            {
+                name: 'mcp',
+                summary: 'Import a remote MCP tool snapshot into a governed TypeScript project.',
+                arguments: [
+                    {
+                        name: 'url',
+                        type: 'string',
+                        summary: 'Remote Streamable HTTP MCP endpoint.',
+                        required: true,
+                        variadic: false,
+                        sensitive: false,
+                        constraints: {},
+                    },
+                ],
+                flags: [
+                    stringFlag('output', '<dir>', 'Generated project directory.', {
+                        constraints: { default: 'noodle-mcp-app' },
+                    }),
+                    stringFlag('name', '<slug>', 'Generated server and connector name.', {
+                        constraints: { default: 'mcp-app' },
+                    }),
+                    stringFlag('prefix', '<name>', 'Prefix imported operation and outward tool names.'),
+                    stringFlag('header-env', '<header>=<ENV_NAME>', 'Read one import credential from the named environment variable; never persist its value.'),
+                    booleanFlag('check', 'Compare the live tool surface with the saved snapshot without writing.'),
+                    FORCE_FLAG,
+                    JSON_FLAG,
+                ],
+                jsonOutput: { mode: 'single' },
+            },
         ],
         local: true,
     },

package/node_modules/@noodle-borg/connector-defs/dist/call-graph.js

@@ -8,7 +8,7 @@ export function validateComputeCallGraph(defs, targets, errors) {
             graph.set(key, graph.get(key) ?? new Set());
             paths.set(key, `connectors.${def.id}.operations.${opName}.calls`);
         }
-        if ('http' in def)
+        if ('http' in def || 'mcp' in def)
             continue;
         for (const [opName, op] of Object.entries(def.operations)) {
             const from = operationIdentityKey(def.id, def.version, opName);

package/node_modules/@noodle-borg/connector-defs/dist/compile-mcp.js

@@ -0,0 +1,95 @@
+import { McpConnector, } from '@noodle-borg/connector-http';
+import { collectVariablesFromHttpAuth } from './auth-variables.js';
+import { addAuthBinding, toAuthScheme } from './compile-auth.js';
+import { toSignature } from './compile-http.js';
+import { catalogCredentialMetadata } from './credential-profiles.js';
+import { collectVariableExpression, isVariableExpression } from './variables.js';
+/** Compile one frozen upstream MCP tool snapshot into the ordinary Connector runtime port. */
+export function compileMcpConnector(def, mode, errors, catalog, connectors, secretBindings, variableBindings) {
+    const endpoint = def.mcp.endpoint;
+    const allowedOrigins = def.mcp.allowedOrigins ?? (isVariableExpression(endpoint) ? [] : [endpoint]);
+    collectVariableExpression(endpoint, variableBindings);
+    for (const origin of allowedOrigins)
+        collectVariableExpression(origin, variableBindings);
+    if (def.mcp.auth !== undefined)
+        collectVariablesFromHttpAuth(def.mcp.auth, variableBindings);
+    if (isVariableExpression(endpoint) && def.mcp.allowedOrigins === undefined) {
+        errors.push({
+            code: 'variable_mcp_endpoint_requires_allowed_origins',
+            path: `connectors.${def.id}.mcp.allowedOrigins`,
+            message: 'mcp.allowedOrigins is required when mcp.endpoint is a managed variable',
+        });
+        return;
+    }
+    const signatures = {};
+    const operations = {};
+    for (const [operationName, operation] of Object.entries(def.operations)) {
+        const base = `connectors.${def.id}.operations.${operationName}`;
+        const signature = toSignature(operation.type, operation.input, operation.output);
+        signatures[operationName] = signature;
+        if (operation.auth !== undefined)
+            collectVariablesFromHttpAuth(operation.auth, variableBindings);
+        operations[operationName] = {
+            upstreamTool: operation.tool,
+            signature,
+            ...(operation.result === 'structured' ? { upstreamOutputSchema: signature.output } : {}),
+            ...(operation.auth === undefined ? {} : { auth: mcpAuthScheme(operation.auth) }),
+            ...(operation.limits?.maxResponseBytes === undefined
+                ? {}
+                : { maxResponseBytes: operation.limits.maxResponseBytes }),
+            ...(operation.fake === undefined ? {} : { fake: operation.fake }),
+        };
+        addAuthBinding({
+            auth: operation.auth,
+            connectorId: def.id,
+            connectorVersion: def.version,
+            operation: operationName,
+            path: `${base}.auth`,
+            allowedOrigins: literalOrigins(allowedOrigins),
+            secretBindings,
+            errors,
+        });
+    }
+    catalog.push({
+        id: def.id,
+        version: def.version,
+        kind: def.kind ?? 'custom',
+        ...catalogCredentialMetadata(def),
+        operations: signatures,
+    });
+    addAuthBinding({
+        auth: def.mcp.auth,
+        connectorId: def.id,
+        connectorVersion: def.version,
+        path: `connectors.${def.id}.mcp.auth`,
+        allowedOrigins: literalOrigins(allowedOrigins),
+        secretBindings,
+        errors,
+    });
+    const config = {
+        id: def.id,
+        version: def.version,
+        endpoint,
+        ...(def.mcp.allowedOrigins === undefined ? {} : { allowedOrigins: def.mcp.allowedOrigins }),
+        ...(def.mcp.auth === undefined ? {} : { auth: mcpAuthScheme(def.mcp.auth) }),
+        ...(def.mcp.timeoutMs === undefined ? {} : { timeoutMs: def.mcp.timeoutMs }),
+        ...(def.mcp.maxResponseBytes === undefined
+            ? {}
+            : { maxResponseBytes: def.mcp.maxResponseBytes }),
+        ...(def.mcp.protocol === undefined ? {} : { protocol: def.mcp.protocol }),
+        ...(mode === 'fake' ? { fakeMode: true } : {}),
+        operations,
+    };
+    connectors.push(new McpConnector(config));
+}
+function mcpAuthScheme(auth) {
+    const scheme = toAuthScheme(auth);
+    if (scheme.kind === 'cookie') {
+        throw new Error('delegated session cookie auth is not valid for an MCP connector');
+    }
+    return scheme;
+}
+function literalOrigins(origins) {
+    return origins.filter((origin) => !isVariableExpression(origin));
+}
+//# sourceMappingURL=compile-mcp.js.map

package/node_modules/@noodle-borg/connector-defs/dist/compile.js

@@ -3,6 +3,7 @@ import { CodeConnector, DEFAULT_LIMITS, QuickJsComputeEngine, } from '@noodle-bo
 import { parse as parseYaml } from 'yaml';
 import { validateComputeCallGraph } from './call-graph.js';
 import { compileHttpConnector, toSignature } from './compile-http.js';
+import { compileMcpConnector } from './compile-mcp.js';
 import { catalogCredentialMetadata } from './credential-profiles.js';
 import { collectCatalogCustomerRouting } from './customer-routing.js';
 import { connectorIdentityKey } from './identity-key.js';
@@ -62,6 +63,9 @@ export function compileConnectors(source, options = {}) {
         if ('http' in def) {
             compileHttpConnector(def, mode, errors, catalog, connectors, secretBindings, variableBindings);
         }
+        else if ('mcp' in def) {
+            compileMcpConnector(def, mode, errors, catalog, connectors, secretBindings, variableBindings);
+        }
         else {
             compileComputeConnector(def, computeEngine, targets, errors, catalog, connectors);
         }

package/node_modules/@noodle-borg/connector-defs/dist/customer-routing.js

@@ -57,7 +57,7 @@ export function collectCatalogCustomerRouting(definitions, errors) {
                     actionEndpoints.add(def.http.baseUrl.name);
             }
         }
-        else {
+        else if (!('mcp' in def)) {
             const computeOperation = def.operations[operationName];
             if (computeOperation?.calls === undefined) {
                 visiting.delete(key);

package/node_modules/@noodle-borg/connector-defs/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { type ClientCredentialsBinding, type ClientCredentialsCustomBinding, type CompileConnectorsOptions, type CompileConnectorsResult, type ConnectorCompileError, compileConnectors, type DelegatedOAuthBinding, type DelegatedTokenExchangeBinding, type SecretBinding, } from './compile.js';
 export { type DelegatedTokenExchangeIdentityContext, delegatedTokenExchangeIdentityErrors, type ServerCustomerIdentitySources, } from './delegated-token-exchange-identity.js';
-export { type ComputeConnectorDef, type ComputeOperationDef, type ConnectorDef, type ConnectorFile, type CredentialProfileDef, connectorFileSchema, type HttpAuthDef, type HttpConnectorDef, type HttpOperationDef, } from './schema.js';
+export { type ComputeConnectorDef, type ComputeOperationDef, type ConnectorDef, type ConnectorFile, type CredentialProfileDef, connectorFileSchema, type HttpAuthDef, type HttpConnectorDef, type HttpOperationDef, type McpConnectorDef, type McpOperationDef, } from './schema.js';
 //# sourceMappingURL=index.d.ts.map