@noodleseed/one 0.138.0 → 0.139.1

package/node_modules/@noodle-borg/connector-http/dist/mcp/types.d.ts

@@ -0,0 +1,52 @@
+import type { FetchLike, Tool } from '@modelcontextprotocol/client';
+import type { CredentialProfile, OperationSignature } from '@noodle-borg/compiler';
+import type { DnsLookup } from '../ssrf.js';
+/** How a broker-minted credential is presented to an upstream MCP server. */
+export type McpAuthScheme = CredentialProfile | {
+    readonly kind: 'cookie';
+};
+/** One curated Noodle operation mapped to one frozen upstream MCP tool. */
+export interface McpOperation {
+    readonly upstreamTool: string;
+    readonly signature: OperationSignature;
+    /** Frozen upstream output schema; omitted when the imported tool had no output schema. */
+    readonly upstreamOutputSchema?: OperationSignature['output'];
+    readonly auth?: McpAuthScheme;
+    /** Inclusive decoded-result limit. Defaults to the connector-wide limit. */
+    readonly maxResponseBytes?: number;
+    readonly fake?: McpOperationFake;
+}
+export type McpOperationFake = {
+    readonly structuredContent: Readonly<Record<string, unknown>>;
+} | {
+    readonly text: string;
+};
+/** Runtime configuration for one remote Streamable HTTP MCP server. */
+export interface McpConnectorConfig {
+    readonly id: string;
+    readonly version: string;
+    /** Literal endpoint or one exact `${env.NAME}` managed-variable reference. */
+    readonly endpoint: string;
+    /** Exact egress origins. Required when `endpoint` is managed. */
+    readonly allowedOrigins?: readonly string[];
+    readonly operations: Readonly<Record<string, McpOperation>>;
+    readonly auth?: McpAuthScheme;
+    /** Total connection + call timeout. Default 10 seconds. */
+    readonly timeoutMs?: number;
+    /** Inclusive decoded MCP response limit. Default 1 MiB, maximum 6 MiB. */
+    readonly maxResponseBytes?: number;
+    /** Protocol-era policy. `auto` safely negotiates modern or legacy and is the default. */
+    readonly protocol?: 'auto' | 'legacy' | 'modern';
+    /** Compiler-owned deterministic mode; bypasses transport and credentials. */
+    readonly fakeMode?: boolean;
+}
+/**
+ * Hermetic-test seams. Production compilation never accepts or emits these values; outbound traffic uses
+ * the guarded transport and system DNS resolver.
+ */
+export interface McpConnectorDependencies {
+    readonly fetch?: FetchLike;
+    readonly lookup?: DnsLookup;
+}
+export declare function toolDefinition(operation: McpOperation): Tool;
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/types.js

@@ -0,0 +1,10 @@
+export function toolDefinition(operation) {
+    return {
+        name: operation.upstreamTool,
+        inputSchema: operation.signature.input,
+        ...(operation.upstreamOutputSchema === undefined
+            ? {}
+            : { outputSchema: operation.upstreamOutputSchema }),
+    };
+}
+//# sourceMappingURL=types.js.map

package/node_modules/@noodle-borg/connector-http/package.json

@@ -22,12 +22,15 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "@modelcontextprotocol/client": "2.0.0",
     "@noodle-borg/compiler": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
     "ipaddr.js": "^2.4.0",
     "undici": "^8.7.0"
   },
   "devDependencies": {
-    "@types/node": "^24.13.1"
+    "@modelcontextprotocol/server": "2.0.0",
+    "@types/node": "^24.13.1",
+    "zod": "^4.4.3"
   }
 }

package/node_modules/@noodle-borg/openapi-import/dist/index.js

@@ -1,5 +1,6 @@
 import YAML from 'yaml';
 import { importResponseSchema, toOutputJsonSchema, } from './response-schema.js';
+export * from './mcp/index.js';
 export { importResponseSchema, MAX_RESPONSE_SCHEMA_DEPTH, MAX_RESPONSE_SCHEMA_NODES, toOutputJsonSchema, } from './response-schema.js';
 const METHODS = new Set(['get', 'post', 'put', 'patch', 'delete']);
 export function parseOpenApiToIr(source, options) {

package/node_modules/@noodle-borg/openapi-import/dist/mcp/index.js

@@ -0,0 +1,4 @@
+export { probeMcpServer } from './probe.js';
+export { renderMcpServerSource } from './render.js';
+export { diffSnapshots, parseMcpImportSnapshot, snapshotFromTools } from './snapshot.js';
+//# sourceMappingURL=index.js.map

package/node_modules/@noodle-borg/openapi-import/dist/mcp/probe.js

@@ -0,0 +1,165 @@
+import { Client, SdkHttpError, StreamableHTTPClientTransport, } from '@modelcontextprotocol/client';
+import { guardedFetch } from '@noodle-borg/connector-http';
+import { snapshotFromTools } from './snapshot.js';
+const DEFAULT_TIMEOUT_MS = 15_000;
+const DEFAULT_MAX_RESPONSE_BYTES = 6 * 1024 * 1024;
+const MAX_TIMEOUT_MS = 300_000;
+export async function probeMcpServer(options) {
+    const endpoint = safeEndpoint(options.endpoint);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_TIMEOUT_MS) {
+        throw new Error(`MCP import timeout must be between 1 and ${MAX_TIMEOUT_MS} milliseconds`);
+    }
+    const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+    if (!Number.isSafeInteger(maxResponseBytes) ||
+        maxResponseBytes < 1 ||
+        maxResponseBytes > DEFAULT_MAX_RESPONSE_BYTES) {
+        throw new Error(`MCP import response limit must be between 1 and ${DEFAULT_MAX_RESPONSE_BYTES} bytes`);
+    }
+    const signal = AbortSignal.timeout(timeoutMs);
+    const fetch = importFetch(endpoint.origin, options.headers ?? {}, maxResponseBytes, options.fetch);
+    const client = new Client({ name: 'noodle-mcp-import', version: '1.0.0' }, {
+        capabilities: {},
+        versionNegotiation: { mode: protocolMode(options.protocol) },
+        inputRequired: { autoFulfill: false },
+        listMaxPages: 32,
+    });
+    const transport = new StreamableHTTPClientTransport(endpoint, {
+        fetch,
+        onInsufficientScope: 'throw',
+    });
+    const closeTransportOnAbort = () => {
+        void transport.close().catch(() => undefined);
+    };
+    signal.addEventListener('abort', closeTransportOnAbort, { once: true });
+    if (signal.aborted)
+        closeTransportOnAbort();
+    let tools;
+    try {
+        await client.connect(transport, { signal, timeout: timeoutMs });
+        const result = await client.listTools(undefined, {
+            signal,
+            timeout: timeoutMs,
+            cacheMode: 'bypass',
+        });
+        tools = result.tools.map((tool) => ({
+            name: tool.name,
+            ...(tool.description === undefined ? {} : { description: tool.description }),
+            inputSchema: tool.inputSchema,
+            ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
+            ...(tool.annotations === undefined ? {} : { annotations: tool.annotations }),
+        }));
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw new Error('MCP import probe timed out');
+        if (SdkHttpError.isInstance(error)) {
+            throw new Error(`MCP import probe rejected with HTTP ${error.status}`);
+        }
+        throw new Error('MCP import probe failed');
+    }
+    finally {
+        signal.removeEventListener('abort', closeTransportOnAbort);
+        await client.close().catch(() => undefined);
+    }
+    return snapshotFromTools({
+        endpoint: options.endpoint,
+        name: options.name,
+        ...(options.prefix === undefined ? {} : { prefix: options.prefix }),
+        ...(options.auth === undefined ? {} : { auth: options.auth }),
+        tools,
+    });
+}
+function importFetch(allowedOrigin, configuredHeaders, maxBytes, injected) {
+    const safeHeaders = validatedHeaders(configuredHeaders);
+    return async (input, init = {}) => {
+        const url = new URL(input);
+        if (url.origin !== allowedOrigin)
+            throw new Error('MCP import egress origin rejected');
+        const headers = new Headers(init.headers);
+        for (const [name, value] of Object.entries(safeHeaders))
+            headers.set(name, value);
+        const response = injected === undefined
+            ? await guardedFetch(url, { ...init, headers, redirect: 'manual' })
+            : await injected(url, { ...init, headers, redirect: 'manual' });
+        if (response.status >= 300 && response.status <= 399) {
+            throw new Error('MCP import redirect rejected');
+        }
+        return boundedResponse(response, maxBytes);
+    };
+}
+function boundedResponse(response, maxBytes) {
+    const length = Number(response.headers.get('content-length') ?? '0');
+    if (length > maxBytes)
+        throw new Error('MCP import response exceeds the size limit');
+    if (response.body === null)
+        return response;
+    const reader = response.body.getReader();
+    let size = 0;
+    return new Response(new ReadableStream({
+        async pull(controller) {
+            const chunk = await reader.read();
+            if (chunk.done) {
+                controller.close();
+                return;
+            }
+            size += chunk.value.byteLength;
+            if (size > maxBytes) {
+                await reader.cancel().catch(() => undefined);
+                controller.error(new Error('MCP import response exceeds the size limit'));
+                return;
+            }
+            controller.enqueue(chunk.value);
+        },
+        async cancel(reason) {
+            await reader.cancel(reason).catch(() => undefined);
+        },
+    }), { status: response.status, statusText: response.statusText, headers: response.headers });
+}
+function safeEndpoint(value) {
+    const url = new URL(value);
+    if (url.username !== '' || url.password !== '' || url.hash !== '') {
+        throw new Error('MCP endpoint contains forbidden URL components');
+    }
+    const loopback = url.protocol === 'http:' &&
+        (url.hostname === 'localhost' || url.hostname === '127.0.0.1' || url.hostname === '[::1]');
+    if (url.protocol !== 'https:' && !loopback)
+        throw new Error('MCP endpoint must use HTTPS');
+    return url;
+}
+function validatedHeaders(input) {
+    if (Object.keys(input).length > 32)
+        throw new Error('MCP import accepts at most 32 headers');
+    const headers = Object.create(null);
+    const seen = new Set();
+    for (const [name, value] of Object.entries(input)) {
+        const lower = name.toLowerCase();
+        if (seen.has(lower))
+            throw new Error(`MCP import header "${name}" is duplicated`);
+        seen.add(lower);
+        if (lower === 'host' ||
+            lower === 'cookie' ||
+            lower === 'content-type' ||
+            lower === 'content-length' ||
+            lower.startsWith('mcp-')) {
+            throw new Error(`MCP import header "${name}" is transport-owned`);
+        }
+        if (value.length > 8_192 || /[\r\n]/.test(value)) {
+            throw new Error(`MCP import header "${name}" has an invalid value`);
+        }
+        try {
+            new Headers({ [name]: value });
+        }
+        catch {
+            throw new Error(`MCP import header "${name}" is invalid`);
+        }
+        headers[lower] = value;
+    }
+    return headers;
+}
+function protocolMode(value) {
+    if (value === 'modern')
+        return { pin: '2026-07-28' };
+    return value ?? 'auto';
+}
+//# sourceMappingURL=probe.js.map

package/node_modules/@noodle-borg/openapi-import/dist/mcp/render.js

@@ -0,0 +1,99 @@
+export function renderMcpServerSource(snapshot) {
+    const needsSecret = snapshot.auth !== undefined;
+    const imports = ['annotations', 'connector', 'server', 'tool', 'variable'];
+    if (needsSecret)
+        imports.push('secret');
+    const operations = snapshot.tools.map(renderOperation).join(',\n      ');
+    const tools = snapshot.tools.map(renderTool).join(',\n  ');
+    const auth = snapshot.auth === undefined ? '' : `\n    auth: ${renderAuth(snapshot.auth)},`;
+    return `import { ${imports.sort().join(', ')} } from '@noodleseed/one';
+
+const upstream = connector(${quote(snapshot.connectorId)})
+  .version('1.0.0')
+  .mcp({
+    endpoint: variable(${quote(snapshot.endpointVariable)}),
+    allowedOrigins: [variable(${quote(snapshot.originVariable)})],${auth}
+    operations: {
+      ${operations}
+    },
+  });
+
+export default server(${quote(snapshot.connectorId)}, {
+  title: ${quote(title(snapshot.connectorId))},
+  version: '1.0.0',
+  use: { upstream },
+}, [
+  ${tools}
+]);
+`;
+}
+function renderOperation(tool) {
+    return `${tool.operationName}: {
+        type: ${quote(tool.operationType)},
+        tool: ${quote(tool.upstreamName)},
+        result: ${quote(tool.result)},
+        input: ${json(tool.inputSchema, 8)},
+        output: ${json(tool.outputSchema, 8)},
+      }`;
+}
+function renderTool(item) {
+    const annotations = item.operationType === 'read'
+        ? 'annotations.readOnly({ openWorld: true })'
+        : `annotations.openAction({ destructive: ${String(item.destructive)}, confirm: true })`;
+    const properties = schemaProperties(item.outputSchema);
+    const input = schemaProperties(item.inputSchema)
+        .map((property) => `${quote(property)}: input[${quote(property)}]`)
+        .join(', ');
+    const operationCall = `connectors.upstream.${item.operationName}({ ${input} })`;
+    const outputSchema = properties.length === 0
+        ? {
+            type: 'object',
+            properties: { result: item.outputSchema },
+            required: ['result'],
+            additionalProperties: false,
+        }
+        : item.outputSchema;
+    const fulfil = properties.length === 0
+        ? `({ input, connectors }) => ({ result: ${operationCall}.raw })`
+        : `({ input, connectors }) => {
+      const result = ${operationCall};
+      return {
+${properties.map((property) => `        ${quote(property)}: result[${quote(property)}],`).join('\n')}
+      };
+    }`;
+    return `tool(${quote(item.operationName)}, {
+    title: ${quote(title(item.operationName))},
+    description: ${quote(item.description)},
+    annotations: ${annotations},
+    input: ${json(item.inputSchema, 4)},
+    output: ${json(outputSchema, 4)},
+    fulfil: ${fulfil},
+  })`;
+}
+function schemaProperties(schema) {
+    const properties = schema.properties;
+    if (typeof properties !== 'object' || properties === null || Array.isArray(properties))
+        return [];
+    return Object.keys(properties).sort();
+}
+function renderAuth(auth) {
+    if (auth.kind === 'bearer') {
+        return `{ kind: 'bearer', secret: secret(${quote(auth.secretRef)}) }`;
+    }
+    return `{ kind: 'apiKey', header: ${quote(auth.header ?? 'x-api-key')}, secret: secret(${quote(auth.secretRef)}) }`;
+}
+function json(value, indentation) {
+    const pad = ' '.repeat(indentation);
+    return JSON.stringify(value, null, 2).replace(/\n/g, `\n${pad}`);
+}
+function quote(value) {
+    return JSON.stringify(value);
+}
+function title(value) {
+    return value
+        .split('_')
+        .filter(Boolean)
+        .map((part) => `${part[0]?.toUpperCase() ?? ''}${part.slice(1)}`)
+        .join(' ');
+}
+//# sourceMappingURL=render.js.map

package/node_modules/@noodle-borg/openapi-import/dist/mcp/snapshot.js

@@ -0,0 +1,290 @@
+import { normalizeOperationIoSchema } from '@noodle-borg/compiler';
+const NAME = /^[a-z0-9_]+$/;
+const MAX_TOOLS = 256;
+const MAX_UPSTREAM_NAME_LENGTH = 256;
+const MAX_SCHEMA_DEPTH = 64;
+const MAX_SCHEMA_NODES = 50_000;
+export function snapshotFromTools(input) {
+    if (input.tools.length > MAX_TOOLS) {
+        throw new Error(`upstream MCP server exposes more than ${MAX_TOOLS} tools`);
+    }
+    const connectorId = safeBaseName(input.name);
+    const safePrefix = input.prefix === undefined ? undefined : safeBaseName(input.prefix);
+    const prefix = safePrefix === undefined ? '' : `${safePrefix}_`;
+    const warnings = [];
+    const counts = new Map();
+    const tools = [];
+    const discovered = input.tools.map((tool) => ({
+        ...tool,
+        name: upstreamName(tool.name),
+    }));
+    for (const tool of discovered.sort((a, b) => a.name.localeCompare(b.name))) {
+        const base = `${prefix}${safeBaseName(tool.name)}`;
+        const count = (counts.get(base) ?? 0) + 1;
+        counts.set(base, count);
+        const operationName = count === 1 ? base : `${base}_${count}`;
+        if (operationName !== tool.name) {
+            warnings.push(`mapped upstream tool "${tool.name}" to operation "${operationName}"`);
+        }
+        const inputSchema = objectSchema(tool.inputSchema, `${tool.name}.inputSchema`);
+        const result = tool.outputSchema === undefined ? 'text' : 'structured';
+        const outputSchema = tool.outputSchema === undefined
+            ? textOutputSchema()
+            : objectSchema(tool.outputSchema, `${tool.name}.outputSchema`);
+        const operationType = 'action';
+        const destructive = true;
+        if (tool.annotations?.readOnlyHint === true) {
+            warnings.push(`tool "${tool.name}" claims readOnlyHint; imported as a confirmed action until the author verifies its behavior`);
+        }
+        else if (tool.annotations?.readOnlyHint === undefined) {
+            warnings.push(`tool "${tool.name}" has no readOnlyHint; imported conservatively as a confirmed action`);
+        }
+        tools.push({
+            upstreamName: tool.name,
+            operationName,
+            description: cleanDescription(tool.description, tool.name),
+            operationType,
+            destructive,
+            inputSchema,
+            outputSchema,
+            result,
+        });
+    }
+    return {
+        formatVersion: 1,
+        connectorId,
+        ...(safePrefix === undefined ? {} : { prefix: safePrefix }),
+        endpoint: canonicalEndpoint(input.endpoint),
+        endpointVariable: `${constantName(connectorId)}_MCP_ENDPOINT`,
+        originVariable: `${constantName(connectorId)}_MCP_ORIGIN`,
+        ...(input.auth === undefined ? {} : { auth: input.auth }),
+        tools,
+        warnings: [...warnings].sort(),
+    };
+}
+function upstreamName(value) {
+    if (value.length === 0 || value.length > MAX_UPSTREAM_NAME_LENGTH || /\p{Cc}/u.test(value)) {
+        throw new Error(`upstream MCP tool name must contain 1-${MAX_UPSTREAM_NAME_LENGTH} non-control characters`);
+    }
+    return value;
+}
+export function diffSnapshots(before, after) {
+    const lines = [];
+    const prior = new Map(before.tools.map((tool) => [tool.upstreamName, tool]));
+    const next = new Map(after.tools.map((tool) => [tool.upstreamName, tool]));
+    for (const name of [...new Set([...prior.keys(), ...next.keys()])].sort()) {
+        const left = prior.get(name);
+        const right = next.get(name);
+        if (left === undefined)
+            lines.push(`additive: added tool: ${name}`);
+        else if (right === undefined)
+            lines.push(`breaking: removed tool: ${name}`);
+        else if (stableJson(left) !== stableJson(right)) {
+            const metadataOnly = stableJson({ ...left, description: '' }) === stableJson({ ...right, description: '' });
+            lines.push(`${metadataOnly ? 'metadata-only' : 'breaking'}: changed tool: ${name}`);
+        }
+    }
+    if (before.endpoint !== after.endpoint)
+        lines.push('breaking: changed endpoint');
+    if (stableJson(before.auth) !== stableJson(after.auth))
+        lines.push('breaking: changed auth');
+    return { changed: lines.length > 0, lines };
+}
+/** Parse the system-owned drift snapshot without trusting edited local JSON. */
+export function parseMcpImportSnapshot(value) {
+    if (!isRecord(value) || value.formatVersion !== 1) {
+        throw new Error('MCP import snapshot has an unsupported format');
+    }
+    const connectorId = requiredString(value.connectorId, 'connectorId');
+    if (safeBaseName(connectorId) !== connectorId) {
+        throw new Error('MCP import snapshot connectorId is invalid');
+    }
+    const prefix = optionalString(value.prefix, 'prefix');
+    if (prefix !== undefined && safeBaseName(prefix) !== prefix) {
+        throw new Error('MCP import snapshot prefix is invalid');
+    }
+    if (!Array.isArray(value.tools) || value.tools.length > MAX_TOOLS) {
+        throw new Error(`MCP import snapshot tools must contain at most ${MAX_TOOLS} entries`);
+    }
+    const tools = value.tools.map((candidate, index) => {
+        if (!isRecord(candidate))
+            throw new Error(`MCP import snapshot tools[${index}] is invalid`);
+        const upstream = upstreamName(requiredString(candidate.upstreamName, `tools[${index}].upstreamName`));
+        const operationName = requiredString(candidate.operationName, `tools[${index}].operationName`);
+        if (!NAME.test(operationName) || operationName.length > 128) {
+            throw new Error(`MCP import snapshot tools[${index}].operationName is invalid`);
+        }
+        const description = requiredString(candidate.description, `tools[${index}].description`);
+        if (description.length > 2_000) {
+            throw new Error(`MCP import snapshot tools[${index}].description is too long`);
+        }
+        if (candidate.operationType !== 'read' && candidate.operationType !== 'action') {
+            throw new Error(`MCP import snapshot tools[${index}].operationType is invalid`);
+        }
+        if (typeof candidate.destructive !== 'boolean') {
+            throw new Error(`MCP import snapshot tools[${index}].destructive is invalid`);
+        }
+        if (candidate.result !== 'structured' && candidate.result !== 'text') {
+            throw new Error(`MCP import snapshot tools[${index}].result is invalid`);
+        }
+        return {
+            upstreamName: upstream,
+            operationName,
+            description,
+            operationType: candidate.operationType,
+            destructive: candidate.destructive,
+            inputSchema: objectSchema(candidate.inputSchema, `tools[${index}].inputSchema`),
+            outputSchema: objectSchema(candidate.outputSchema, `tools[${index}].outputSchema`),
+            result: candidate.result,
+        };
+    });
+    if (!Array.isArray(value.warnings) || value.warnings.length > MAX_TOOLS * 2) {
+        throw new Error('MCP import snapshot warnings are invalid');
+    }
+    const warnings = value.warnings.map((warning, index) => {
+        const parsed = requiredString(warning, `warnings[${index}]`);
+        if (parsed.length > 2_000)
+            throw new Error(`MCP import snapshot warnings[${index}] is too long`);
+        return parsed;
+    });
+    const endpoint = canonicalEndpoint(requiredString(value.endpoint, 'endpoint'));
+    const endpointVariable = `${constantName(connectorId)}_MCP_ENDPOINT`;
+    const originVariable = `${constantName(connectorId)}_MCP_ORIGIN`;
+    if (value.endpointVariable !== endpointVariable || value.originVariable !== originVariable) {
+        throw new Error('MCP import snapshot managed binding names are invalid');
+    }
+    const auth = parseAuth(value.auth);
+    return {
+        formatVersion: 1,
+        connectorId,
+        ...(prefix === undefined ? {} : { prefix }),
+        endpoint,
+        endpointVariable,
+        originVariable,
+        ...(auth === undefined ? {} : { auth }),
+        tools,
+        warnings,
+    };
+}
+function parseAuth(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value) || (value.kind !== 'bearer' && value.kind !== 'apiKey')) {
+        throw new Error('MCP import snapshot auth is invalid');
+    }
+    const secretRef = requiredString(value.secretRef, 'auth.secretRef');
+    if (!/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(secretRef)) {
+        throw new Error('MCP import snapshot auth.secretRef is invalid');
+    }
+    if (value.kind === 'bearer')
+        return { kind: 'bearer', secretRef };
+    const header = requiredString(value.header, 'auth.header');
+    if (!/^[A-Za-z0-9_-]{1,128}$/.test(header)) {
+        throw new Error('MCP import snapshot auth.header is invalid');
+    }
+    return { kind: 'apiKey', header, secretRef };
+}
+function requiredString(value, path) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`MCP import snapshot ${path} is invalid`);
+    }
+    return value;
+}
+function optionalString(value, path) {
+    if (value === undefined)
+        return undefined;
+    return requiredString(value, path);
+}
+function objectSchema(value, path) {
+    inspectSchema(value, path);
+    if (!isRecord(value))
+        throw new Error(`${path} must be a JSON Schema object`);
+    const type = value.type;
+    if (type !== 'object' && !(Array.isArray(type) && type.includes('object'))) {
+        throw new Error(`${path} must declare an object top-level type`);
+    }
+    if (value.additionalProperties !== undefined && typeof value.additionalProperties !== 'boolean') {
+        throw new Error(`${path}.additionalProperties must be boolean at the top level`);
+    }
+    return normalizeOperationIoSchema(value);
+}
+function inspectSchema(value, path) {
+    let nodes = 0;
+    const visit = (node, depth) => {
+        nodes += 1;
+        if (nodes > MAX_SCHEMA_NODES)
+            throw new Error(`${path} exceeds the schema node limit`);
+        if (depth > MAX_SCHEMA_DEPTH)
+            throw new Error(`${path} exceeds the schema depth limit`);
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visit(item, depth + 1);
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        if (typeof node.$ref === 'string' && !node.$ref.startsWith('#')) {
+            throw new Error(`${path} contains an external $ref, which is never fetched`);
+        }
+        for (const child of Object.values(node))
+            visit(child, depth + 1);
+    };
+    visit(value, 0);
+}
+function safeBaseName(value) {
+    const separated = value
+        .normalize('NFKD')
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .replace(/_+/g, '_');
+    const safe = /^[a-z]/.test(separated) ? separated : `tool_${separated}`;
+    if (!NAME.test(safe) || safe.length === 0)
+        throw new Error(`cannot derive a safe name from "${value}"`);
+    return safe.slice(0, 96).replace(/_+$/g, '');
+}
+function constantName(value) {
+    return value.toUpperCase();
+}
+function cleanDescription(value, name) {
+    const cleaned = value
+        ?.replace(/\p{Cc}/gu, (character) => character === '\n' || character === '\t' ? character : '')
+        .trim()
+        .slice(0, 2_000);
+    return cleaned && cleaned.length > 0 ? cleaned : `Call upstream MCP tool "${name}".`;
+}
+function textOutputSchema() {
+    return {
+        type: 'object',
+        properties: { text: { type: 'string' } },
+        required: ['text'],
+        additionalProperties: false,
+    };
+}
+function canonicalEndpoint(value) {
+    const url = new URL(value);
+    if (url.username !== '' || url.password !== '' || url.hash !== '') {
+        throw new Error('MCP endpoint contains forbidden URL components');
+    }
+    if (url.protocol !== 'https:' &&
+        !(url.protocol === 'http:' &&
+            (url.hostname === 'localhost' || url.hostname === '127.0.0.1' || url.hostname === '[::1]'))) {
+        throw new Error('MCP endpoint must use HTTPS');
+    }
+    return url.toString();
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (!isRecord(value))
+        return JSON.stringify(value);
+    return `{${Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
+        .join(',')}}`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=snapshot.js.map

package/node_modules/@noodle-borg/openapi-import/package.json

@@ -22,11 +22,15 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "@modelcontextprotocol/client": "2.0.0",
+    "@noodle-borg/compiler": "0.0.0",
+    "@noodle-borg/connector-http": "0.0.0",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@noodle-borg/compiler": "0.0.0",
+    "@modelcontextprotocol/server": "2.0.0",
     "@noodle-borg/connector-defs": "0.0.0",
-    "@types/node": "^24.13.1"
+    "@types/node": "^24.13.1",
+    "zod": "^4.4.3"
   }
 }

package/node_modules/@noodle-borg/runtime/dist/connector/types.d.ts

@@ -74,6 +74,8 @@ export interface ConnectorCall {
     readonly args: Readonly<Record<string, unknown>>;
     /** Managed variables resolved for the deployment scope. */
     readonly env?: Readonly<Record<string, string>>;
+    /** Request-scoped cancellation; connectors should propagate it to outbound work. */
+    readonly signal?: AbortSignal;
     /**
      * The downstream-scoped credential minted by the broker — never an inbound bearer token
      * (docs/SPEC.md "Auth And Identity").