@noodleseed/one 0.137.0 → 0.139.0

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