@noodleseed/one 0.137.0 → 0.139.0

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

@@ -2,10 +2,10 @@ import type { ConnectorFile, HttpConnectorDef } from '@noodle-borg/connector-def
 import { z } from 'zod';
 export type { PackagedAssetReference } from '@noodle-borg/compiler';
 export type { AgentCapabilityKind, AgentCapabilityRef, AgentExampleSource, AgentGuideSource, AgentWorkflowSource, AgentWorkflowStepSource, } from './agent-guide.js';
-export { type AssistantAccess, type AssistantCapability, type AssistantLabels, type AssistantLayoutMode, 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 OpenAICompatibleModel, type OpenAICompatibleModelInput, openAICompatible, type PublicWebsiteAccess, type PublicWebsiteInput, publicWebsite, } from './assistant.js';
+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/index.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export { authenticatedWebsite, embeddedAssistant, openAICompatible, publicWebsite, } from './assistant.js';
+export { authenticatedWebsite, embeddedAssistant, noodleManaged, openAICompatible, publicWebsite, } from './assistant.js';
 export { secret, variable, } from './config.js';
 export { bind, clientCredentials, connection, externalExchange, googleWorkloadIdentity, managedSecret, } from './connections.js';
 export { ConnectorBuilder, connector, } from './connectors.js';

package/node_modules/@noodle-borg/authoring/dist/load-authored.js

@@ -33,7 +33,7 @@ export function prepareAuthoringRuntimeDir(dir, options) {
             './react': './react.mjs',
         },
     }));
-    writeFileSync(join(self, 'index.mjs'), "export { annotations, asset, authenticatedWebsite, bind, clientCredentials, connector, connection, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedSecret, openAICompatible, prompt, publicWebsite, resource, secret, server, site, tool, variable, when, z } from '@noodle-borg/authoring';\n");
+    writeFileSync(join(self, 'index.mjs'), "export { annotations, asset, authenticatedWebsite, bind, clientCredentials, connector, connection, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedSecret, noodleManaged, openAICompatible, prompt, publicWebsite, resource, secret, server, site, tool, variable, when, z } from '@noodle-borg/authoring';\n");
     writeFileSync(join(self, 'platform.mjs'), "export { noodlePlatform, noodlePlatformCatalog } from '@noodle-borg/authoring';\n");
     writeFileSync(join(self, 'react.mjs'), "export { generateHelpers } from '@noodle-borg/authoring/react';\n");
 }

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 (options.modelVisibility === undefined) {
+        return options.annotations ? { annotations: { ...options.annotations } } : {};
+    }
+    if (Object.hasOwn(options.annotations ?? {}, ANNOTATION)) {
+        throw new Error(`Use modelVisibility.latestMessageIncludesAny instead of the reserved ${ANNOTATION} annotation.`);
+    }
+    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-assistant.js

@@ -203,6 +203,23 @@ export const ASSISTANT_COMMAND = {
         CLIENTS_SUBCOMMAND,
         EMBEDS_SUBCOMMAND,
         BUDGET_SUBCOMMAND,
+        subcommand({
+            ...SUBCOMMAND_FIELDS,
+            name: 'usage',
+            summary: 'Show assistant sessions, conversation depth, engagement, latency, and model tokens.',
+            flags: [
+                flag({
+                    ...FLAG_FIELDS,
+                    name: 'window',
+                    type: 'string',
+                    value: '<window>',
+                    summary: 'Aggregation window.',
+                    constraints: { choices: ['24h', '7d', '30d'], default: '7d' },
+                }),
+                ...TENANT_FLAGS,
+            ],
+            jsonOutput: { mode: 'single' },
+        }),
         subcommand({
             ...SUBCOMMAND_FIELDS,
             name: 'embed',

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/cli-catalog/dist/catalog-data-hosted-deployment.js

@@ -132,6 +132,13 @@ export const CATALOG_HOSTED_DEPLOYMENT = [
                 summary: 'Identity access mode for the deployment.',
                 constraints: { choices: ACCESS_MODES },
             }),
+            flag({
+                ...FLAG_FIELDS,
+                name: 'owner-subject',
+                type: 'string',
+                value: '<subject>',
+                summary: 'Exact OAuth subject bound when access is owner-only.',
+            }),
             flag({
                 ...FLAG_FIELDS,
                 name: 'connectors',
@@ -318,6 +325,13 @@ export const CATALOG_HOSTED_DEPLOYMENT = [
                         value: '<version>',
                         summary: 'Server version whose access mode is changed.',
                     }),
+                    flag({
+                        ...FLAG_FIELDS,
+                        name: 'owner-subject',
+                        type: 'string',
+                        value: '<subject>',
+                        summary: 'Exact OAuth subject to bind or transfer for owner-only access.',
+                    }),
                     ...TENANT_TARGET_FLAGS,
                 ],
                 jsonOutput: { mode: 'single' },

package/node_modules/@noodle-borg/compiler/dist/artifact/types.d.ts

@@ -227,13 +227,7 @@ export interface ArtifactServer {
     /** Compiled knowledge components (ADR 0202, Core v2): descriptors + generated tool metadata, never bytes. */
     readonly knowledge?: readonly CompiledKnowledgeComponent[];
     readonly assistant?: {
-        readonly model: {
-            readonly kind: 'openai-compatible';
-            readonly baseUrl: string;
-            readonly model: string;
-            /** Managed secret name, never the secret value. */
-            readonly apiKey: string;
-        };
+        readonly model: NonNullable<Manifest['server']['assistant']>['model'];
         readonly allowedOrigins: readonly string[];
     } & Omit<NonNullable<Manifest['server']['assistant']>, 'model' | 'allowedOrigins'>;
     readonly branding?: {

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.d.ts

@@ -231,6 +231,7 @@ export declare const manifestV1Schema: z.ZodObject<{
                 copy: z.ZodOptional<z.ZodString>;
                 newMessages: z.ZodOptional<z.ZodString>;
                 reconnect: z.ZodOptional<z.ZodString>;
+                newConversation: z.ZodOptional<z.ZodString>;
                 retry: z.ZodOptional<z.ZodString>;
                 unavailable: z.ZodOptional<z.ZodString>;
                 sessionExpired: z.ZodOptional<z.ZodString>;
@@ -325,12 +326,14 @@ export declare const manifestV1Schema: z.ZodObject<{
                 ltr: "ltr";
                 rtl: "rtl";
             }>>;
-            model: z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"openai-compatible">;
                 baseUrl: z.ZodString;
                 model: z.ZodString;
                 apiKey: z.ZodString;
-            }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"noodle-managed">;
+            }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
             surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 mode: z.ZodEnum<{
@@ -682,6 +685,7 @@ export declare const manifestV2Schema: z.ZodObject<{
                 copy: z.ZodOptional<z.ZodString>;
                 newMessages: z.ZodOptional<z.ZodString>;
                 reconnect: z.ZodOptional<z.ZodString>;
+                newConversation: z.ZodOptional<z.ZodString>;
                 retry: z.ZodOptional<z.ZodString>;
                 unavailable: z.ZodOptional<z.ZodString>;
                 sessionExpired: z.ZodOptional<z.ZodString>;
@@ -776,12 +780,14 @@ export declare const manifestV2Schema: z.ZodObject<{
                 ltr: "ltr";
                 rtl: "rtl";
             }>>;
-            model: z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"openai-compatible">;
                 baseUrl: z.ZodString;
                 model: z.ZodString;
                 apiKey: z.ZodString;
-            }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"noodle-managed">;
+            }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
             surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 mode: z.ZodEnum<{
@@ -1343,6 +1349,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 copy: z.ZodOptional<z.ZodString>;
                 newMessages: z.ZodOptional<z.ZodString>;
                 reconnect: z.ZodOptional<z.ZodString>;
+                newConversation: z.ZodOptional<z.ZodString>;
                 retry: z.ZodOptional<z.ZodString>;
                 unavailable: z.ZodOptional<z.ZodString>;
                 sessionExpired: z.ZodOptional<z.ZodString>;
@@ -1437,12 +1444,14 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 ltr: "ltr";
                 rtl: "rtl";
             }>>;
-            model: z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"openai-compatible">;
                 baseUrl: z.ZodString;
                 model: z.ZodString;
                 apiKey: z.ZodString;
-            }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"noodle-managed">;
+            }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
             surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 mode: z.ZodEnum<{
@@ -1793,6 +1802,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 copy: z.ZodOptional<z.ZodString>;
                 newMessages: z.ZodOptional<z.ZodString>;
                 reconnect: z.ZodOptional<z.ZodString>;
+                newConversation: z.ZodOptional<z.ZodString>;
                 retry: z.ZodOptional<z.ZodString>;
                 unavailable: z.ZodOptional<z.ZodString>;
                 sessionExpired: z.ZodOptional<z.ZodString>;
@@ -1887,12 +1897,14 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 ltr: "ltr";
                 rtl: "rtl";
             }>>;
-            model: z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"openai-compatible">;
                 baseUrl: z.ZodString;
                 model: z.ZodString;
                 apiKey: z.ZodString;
-            }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"noodle-managed">;
+            }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
             surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 mode: z.ZodEnum<{

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -310,6 +310,7 @@ const assistantUiSchema = z
         copy: z.string().trim().min(1).max(80).optional(),
         newMessages: z.string().trim().min(1).max(80).optional(),
         reconnect: z.string().trim().min(1).max(80).optional(),
+        newConversation: z.string().trim().min(1).max(80).optional(),
         retry: z.string().trim().min(1).max(80).optional(),
         unavailable: z.string().trim().min(1).max(240).optional(),
         sessionExpired: z.string().trim().min(1).max(240).optional(),
@@ -343,14 +344,17 @@ const MAX_SERVER_INSTRUCTIONS = 4000;
 const sessionClaimsSchema = z.record(z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/, 'claim keys are identifier-style'), z.object({ exposeToModel: z.boolean().optional() }).strict());
 const embeddedAssistantSchema = z
     .object({
-    model: z
-        .object({
-        kind: z.literal('openai-compatible'),
-        baseUrl: z.string().trim().min(1),
-        model: z.string().trim().min(1),
-        apiKey: z.string().regex(/^[A-Za-z0-9_]+$/),
-    })
-        .strict(),
+    model: z.union([
+        z
+            .object({
+            kind: z.literal('openai-compatible'),
+            baseUrl: z.string().trim().min(1),
+            model: z.string().trim().min(1),
+            apiKey: z.string().regex(/^[A-Za-z0-9_]+$/),
+        })
+            .strict(),
+        z.object({ kind: z.literal('noodle-managed') }).strict(),
+    ]),
     allowedOrigins: z.array(assistantOriginOrVariableSchema).min(1),
     // The front doors this assistant serves (ADR 0201, amended 2026-08-12). Absent means the pre-0201
     // authenticated shape, so released artifacts keep their meaning; `allowedOrigins` stays the union

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);