@noodleseed/one 0.163.0 → 0.165.0

package/node_modules/@noodle-borg/compiler/dist/nested-operations.js

@@ -0,0 +1,71 @@
+import { computeSignatureHash } from './catalog/signature.js';
+/** Resolve reachable system-derived dependency identities without guessing between account aliases. */
+export function resolveNestedOperations(input) {
+    const calls = input.connector.operationCalls?.[input.operation];
+    if (calls === undefined)
+        return undefined;
+    const identity = JSON.stringify([input.connector.id, input.connector.version, input.operation]);
+    const traversal = input.traversal ?? { ancestors: [], budget: { remaining: 1024 } };
+    if (!Array.isArray(calls) ||
+        traversal.ancestors.includes(identity) ||
+        traversal.ancestors.length >= 32 ||
+        traversal.budget.remaining-- <= 0) {
+        input.errors.push({
+            code: 'invalid_connector_call_graph',
+            path: input.path,
+            message: 'Nested connector calls must be acyclic and within the compiler graph bounds',
+        });
+        return [];
+    }
+    const next = { ancestors: [...traversal.ancestors, identity], budget: traversal.budget };
+    const output = [];
+    const seen = new Set();
+    for (const target of calls) {
+        if (traversal.budget.remaining-- <= 0) {
+            input.errors.push({
+                code: 'invalid_connector_call_graph',
+                path: input.path,
+                message: 'Nested connector call graph exceeds the compiler bound',
+            });
+            break;
+        }
+        const targetConnector = input.catalog.get(target.connectorId, target.connectorVersion);
+        const signature = targetConnector?.operations[target.operation];
+        if (signature === undefined ||
+            computeSignatureHash(target.operation, signature) !== target.signatureHash) {
+            input.errors.push({
+                code: 'invalid_connector_call_graph',
+                path: input.path,
+                message: 'Nested connector identity or signature does not match the declared catalog',
+            });
+            continue;
+        }
+        const key = JSON.stringify([target.connectorId, target.connectorVersion, target.operation]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const aliases = Object.entries(input.declared).filter(([, ref]) => ref.id === target.connectorId && ref.version === target.connectorVersion);
+        if (aliases.length > 1) {
+            input.errors.push({
+                code: 'ambiguous_nested_connector_binding',
+                path: input.path,
+                message: `Nested connector "${target.connectorId}@${target.connectorVersion}" matches multiple aliases; declare one unambiguous account binding for this connector`,
+            });
+            continue;
+        }
+        // Unbound catalog-only dependencies retain their existing behavior; credential-required targets
+        // still fail normal profile validation when no exact manifest account binding exists.
+        const alias = aliases[0]?.[0] ?? `#${target.connectorId}@${target.connectorVersion}`;
+        const declared = aliases.length === 0
+            ? {
+                ...input.declared,
+                [alias]: { id: target.connectorId, version: target.connectorVersion },
+            }
+            : input.declared;
+        const resolved = input.resolve({ connectorAlias: alias, operation: target.operation, args: {}, path: `${input.path}.calls` }, declared, next);
+        if (resolved.resolved)
+            output.push(resolved);
+    }
+    return output;
+}
+//# sourceMappingURL=nested-operations.js.map

package/node_modules/@noodle-borg/compute/dist/code-connector.js

@@ -24,6 +24,13 @@ export class CodeConnector {
     signature(operation) {
         return this.#operations[operation]?.signature;
     }
+    executionBoundMs(operation) {
+        const op = this.#operations[operation];
+        return op === undefined ? undefined : (op.limits ?? DEFAULT_LIMITS).timeoutMs;
+    }
+    coordination(operation) {
+        return this.#operations[operation]?.coordination;
+    }
     async invoke(call) {
         const op = this.#operations[call.operation];
         if (!op)
@@ -31,7 +38,7 @@ export class CodeConnector {
         const instance = await this.#engine.instantiate(op.module);
         let timings;
         try {
-            const output = await instance.invoke(call.args, op.limits ?? DEFAULT_LIMITS, op.calls ? computeHost(op.calls, call.host) : undefined, (t) => {
+            const output = await instance.invoke(call.args, op.limits ?? DEFAULT_LIMITS, computeHost(op.calls ?? {}, call), (t) => {
                 timings = t;
             });
             // Queue wait and execution are recorded independently so burst head-of-line blocking is
@@ -79,8 +86,13 @@ function classifyInvocationFailure(error, timings) {
             }),
     });
 }
-function computeHost(calls, host) {
+function computeHost(calls, call) {
+    const host = call.host;
     return {
+        ...(call.execution ? { execution: call.execution } : {}),
+        ...(call.coordination ? { coordination: call.coordination } : {}),
+        ...(call.resolveCoordination ? { resolveCoordination: call.resolveCoordination } : {}),
+        ...(call.reportOutcome ? { reportOutcome: call.reportOutcome } : {}),
         callOperation(name, args) {
             if (!host) {
                 throw new ComputeError('host_call_failed', 'host call unavailable');

package/node_modules/@noodle-borg/compute/dist/deterministic-helpers.js

@@ -0,0 +1,138 @@
+import { createHash } from 'node:crypto';
+/** Worker-local pure capabilities: bounded arguments and calls, never an ambient host clock. */
+export function installDeterministicHelpers(context) {
+    let calls = 0;
+    const formatters = new Map();
+    const fn = context.newFunction('__explicitHelper', (operationHandle, argsHandle) => {
+        try {
+            calls += 1;
+            if (calls > 4096)
+                throw new Error('explicit helper call budget exceeded');
+            const operation = context.getString(operationHandle);
+            const json = context.getString(argsHandle);
+            if (json.length > 16_384)
+                throw new Error('explicit helper input exceeds its bound');
+            const args = JSON.parse(json);
+            if (!Array.isArray(args))
+                throw new Error('explicit helper arguments are invalid');
+            let result;
+            if (operation === 'parse') {
+                const value = args[0];
+                if (typeof value !== 'string' ||
+                    value.length > 64 ||
+                    !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{1,9})?(?:Z|[+-]\d\d:\d\d)$/.test(value))
+                    throw new Error('explicit instant is invalid');
+                const year = Number(value.slice(0, 4));
+                const month = Number(value.slice(5, 7));
+                const day = Number(value.slice(8, 10));
+                const maxDay = new Date(`${value.slice(0, 7)}-01T00:00:00Z`);
+                maxDay.setUTCMonth(month);
+                maxDay.setUTCDate(0);
+                const millis = Date.parse(value);
+                if (!Number.isFinite(millis) ||
+                    month < 1 ||
+                    month > 12 ||
+                    day < 1 ||
+                    day > maxDay.getUTCDate() ||
+                    year < 1 ||
+                    Number(value.slice(11, 13)) > 23 ||
+                    Number(value.slice(14, 16)) > 59 ||
+                    Number(value.slice(17, 19)) > 59)
+                    throw new Error('explicit instant is invalid');
+                result = millis;
+            }
+            else if (operation === 'format' || operation === 'parts') {
+                const epoch = args[0];
+                if (typeof epoch !== 'number' ||
+                    !Number.isInteger(epoch) ||
+                    epoch < -62135596800000 ||
+                    epoch > 253402300799999)
+                    throw new Error('explicit instant is invalid');
+                if (operation === 'format')
+                    result = new Date(epoch).toISOString();
+                else {
+                    const zone = args[1];
+                    if (typeof zone !== 'string' ||
+                        zone.length < 1 ||
+                        zone.length > 64 ||
+                        zone.trim() !== zone)
+                        throw new Error('explicit time zone is invalid');
+                    let formatter = formatters.get(zone);
+                    if (!formatter) {
+                        if (formatters.size >= 16)
+                            throw new Error('explicit time zone count exceeds its bound');
+                        formatter = new Intl.DateTimeFormat('en-US', {
+                            timeZone: zone,
+                            weekday: 'short',
+                            year: 'numeric',
+                            month: '2-digit',
+                            day: '2-digit',
+                            hour: '2-digit',
+                            minute: '2-digit',
+                            hourCycle: 'h23',
+                        });
+                        formatters.set(zone, formatter);
+                    }
+                    const parts = Object.fromEntries(formatter.formatToParts(epoch).map(({ type, value }) => [type, value]));
+                    const weekday = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'].indexOf(parts.weekday ?? '') + 1;
+                    result = {
+                        date: `${parts.year}-${parts.month}-${parts.day}`,
+                        weekday,
+                        hour: Number(parts.hour),
+                        minute: Number(parts.minute),
+                    };
+                }
+            }
+            else if (operation === 'digest') {
+                const value = args[0];
+                const encoding = args[1] ?? 'hex';
+                if (typeof value !== 'string' ||
+                    value.length > 8192 ||
+                    (encoding !== 'hex' && encoding !== 'base32hex'))
+                    throw new Error('explicit digest input is invalid');
+                const digest = createHash('sha256').update(value, 'utf8').digest();
+                if (encoding === 'hex')
+                    result = digest.toString('hex');
+                else {
+                    let bits = 0;
+                    let value = 0;
+                    let output = '';
+                    const alphabet = '0123456789abcdefghijklmnopqrstuv';
+                    for (const byte of digest) {
+                        value = (value << 8) | byte;
+                        bits += 8;
+                        while (bits >= 5) {
+                            output += alphabet[(value >>> (bits - 5)) & 31];
+                            bits -= 5;
+                        }
+                    }
+                    if (bits > 0)
+                        output += alphabet[(value << (5 - bits)) & 31];
+                    result = output;
+                }
+            }
+            else
+                throw new Error('explicit helper is not available');
+            return context.newString(JSON.stringify({ ok: true, value: result }));
+        }
+        catch {
+            return context.newString(JSON.stringify({ ok: false, error: 'invalid or exhausted explicit helper request' }));
+        }
+    });
+    context.setProp(context.global, '__explicitHelper', fn);
+    fn.dispose();
+}
+export const helperPrelude = `
+var __helper = function(operation, args) {
+  var result = JSON.parse(globalThis.__explicitHelper(operation, JSON.stringify(args)));
+  if (!result.ok) throw new Error(result.error);
+  return result.value;
+};
+var __timeHelpers = Object.freeze({
+  parse: function(value) { return __helper('parse', [value]); },
+  format: function(value) { return __helper('format', [value]); },
+  parts: function(value, timeZone) { return __helper('parts', [value, timeZone]); }
+});
+var __digestHelper = function(value, encoding) { return __helper('digest', [value, encoding]); };
+`;
+//# sourceMappingURL=deterministic-helpers.js.map

package/node_modules/@noodle-borg/compute/dist/quickjs-engine.js

@@ -111,6 +111,54 @@ class QuickJsComputeInstance {
  */
 function envelopeBridge(host) {
     return {
+        ...(host.execution === undefined ? {} : { execution: { id: host.execution.id } }),
+        ...(host.coordination === undefined
+            ? {}
+            : {
+                coordination: {
+                    acquired: host.coordination.acquired,
+                    ...(host.coordination.previous
+                        ? {
+                            previous: {
+                                reference: host.coordination.previous.reference,
+                                operationDigest: host.coordination.previous.operationDigest,
+                            },
+                        }
+                        : {}),
+                },
+            }),
+        async control(name, argsJson) {
+            try {
+                const args = JSON.parse(argsJson);
+                if (name === 'resolveCoordination' && host.resolveCoordination) {
+                    await host.resolveCoordination();
+                }
+                else if (name === 'reportOutcome' &&
+                    host.reportOutcome &&
+                    args !== null &&
+                    typeof args === 'object' &&
+                    !Array.isArray(args)) {
+                    const evidence = args;
+                    if (!['completed', 'rejected', 'unknown'].includes(String(evidence.outcome)) ||
+                        (evidence.reference !== undefined &&
+                            (typeof evidence.reference !== 'string' || evidence.reference.length > 1024)))
+                        throw new Error('invalid execution evidence');
+                    await host.reportOutcome({
+                        outcome: evidence.outcome,
+                        ...(typeof evidence.reference === 'string' ? { reference: evidence.reference } : {}),
+                    });
+                }
+                else
+                    throw new Error('host control unavailable');
+                return JSON.stringify({ ok: true, output: null });
+            }
+            catch {
+                return JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_denied', message: 'host control unavailable or invalid' },
+                });
+            }
+        },
         async callOperation(name, argsJson) {
             const envelope = await (async () => {
                 try {

package/node_modules/@noodle-borg/compute/dist/sandbox-eval.js

@@ -1,4 +1,5 @@
 import { shouldInterruptAfterDeadline } from 'quickjs-emscripten';
+import { helperPrelude, installDeterministicHelpers } from './deterministic-helpers.js';
 import { ComputeError, } from './engine.js';
 /**
  * Normalize a host-call failure into a bounded error envelope. The code/path pass through only as
@@ -24,6 +25,7 @@ export function runPure(wasm, source, input, limits) {
     runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + limits.timeoutMs));
     const context = runtime.newContext();
     try {
+        installDeterministicHelpers(context);
         const wrapper = buildWrapper(source, input);
         const result = context.evalCode(wrapper, 'module.js');
         if (result.error) {
@@ -47,10 +49,11 @@ export async function runHosted(wasm, source, input, limits, bridge) {
     runtime.setMemoryLimit(limits.memoryBytes);
     runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + limits.timeoutMs));
     try {
+        installDeterministicHelpers(context);
         installHostCall(context, bridge, limits);
         if (bridge.log !== undefined)
             installConsole(context, bridge);
-        const result = await context.evalCodeAsync(buildWrapper(source, input, true, bridge.log !== undefined), 'module.js');
+        const result = await context.evalCodeAsync(buildWrapper(source, input, true, bridge.log !== undefined, bridge.execution, bridge.coordination), 'module.js');
         if (result.error) {
             const described = describeError(context, result.error);
             result.error.dispose();
@@ -91,9 +94,14 @@ async function drainPendingJobs(runtime, context) {
  * nondeterministic globals so "deterministic by default" holds for the future resume/idempotency
  * model ([ADR 0004](../../../docs/decisions/0004-code-as-sandboxed-connector.md)).
  */
-function buildWrapper(source, input, hostEnabled = false, consoleEnabled = false) {
+function buildWrapper(source, input, hostEnabled = false, consoleEnabled = false, execution, coordination) {
     const callOperationPrelude = hostEnabled
         ? `
+var __control = function(name, args) {
+  var result = JSON.parse(globalThis.__hostControl(name, JSON.stringify(args)));
+  if (!result.ok) { var error = new Error(result.error.message); error.name = result.error.code; throw error; }
+  return result.output;
+};
 var callOperation = function(name, args) {
   var __hostEnvelope = JSON.parse(globalThis.__hostCallOperation(String(name), JSON.stringify(args ?? {})));
   if (!__hostEnvelope.ok) {
@@ -107,9 +115,16 @@ var callOperation = function(name, args) {
 };
 `
         : '';
-    const handlerArgs = hostEnabled
-        ? `${jsLiteral(input ?? null)}, { callOperation: callOperation }`
-        : jsLiteral(input ?? null);
+    const handlerArgs = `${jsLiteral(input ?? null)}, Object.freeze({
+    time: __timeHelpers, digest: __digestHelper,
+    ${hostEnabled
+        ? `callOperation: callOperation,
+      reportOutcome: function(evidence) { return __control('reportOutcome', evidence); },
+      resolveCoordination: function() { return __control('resolveCoordination', {}); },`
+        : ''}
+    ${coordination === undefined ? '' : `coordination: Object.freeze(${jsLiteral(coordination)}),`}
+    ${execution === undefined ? '' : `execution: Object.freeze(${jsLiteral(execution)}),`}
+  })`;
     const consolePrelude = consoleEnabled
         ? `
 var console = Object.freeze({
@@ -123,7 +138,9 @@ var console = Object.freeze({
         : '';
     const bodyPrefix = `"use strict";
 delete globalThis.Date;
+delete globalThis.Intl;
 delete Math.random;
+${helperPrelude}
 ${callOperationPrelude}
 ${consolePrelude}
 var __handler = (${source});
@@ -141,6 +158,23 @@ var __out = JSON.stringify(__handler(${handlerArgs}));
 }
 function installHostCall(context, bridge, limits) {
     let calls = 0;
+    let controls = 0;
+    const control = context.newAsyncifiedFunction('__hostControl', async (name, args) => {
+        if (++controls > 4 || !bridge.control)
+            return context.newString(JSON.stringify({
+                ok: false,
+                error: { code: 'host_call_denied', message: 'host control budget exceeded' },
+            }));
+        const argsJson = context.getString(args);
+        if (argsJson.length > 2048)
+            return context.newString(JSON.stringify({
+                ok: false,
+                error: { code: 'host_call_denied', message: 'host control input exceeds bound' },
+            }));
+        return context.newString(await bridge.control(context.getString(name), argsJson));
+    });
+    context.setProp(context.global, '__hostControl', control);
+    control.dispose();
     const fn = context.newAsyncifiedFunction('__hostCallOperation', async (nameHandle, argsJsonHandle) => {
         const envelopeJson = await (async () => {
             if (calls >= limits.maxHostCalls) {

package/node_modules/@noodle-borg/compute/dist/worker-entry.js

@@ -29,6 +29,13 @@ function startWorker(port) {
     });
     function bridgeFor(run) {
         return {
+            ...(run.execution === undefined ? {} : { execution: run.execution }),
+            ...(run.coordination === undefined ? {} : { coordination: run.coordination }),
+            control: (name, argsJson) => new Promise((resolve) => {
+                const callId = nextCallId++;
+                pendingHostReplies.set(callId, resolve);
+                post({ t: 'host_control', id: run.id, callId, name, argsJson });
+            }),
             callOperation: (name, argsJson) => new Promise((resolve) => {
                 const callId = nextCallId;
                 nextCallId += 1;

package/node_modules/@noodle-borg/compute/dist/worker-pool.js

@@ -107,6 +107,8 @@ export class ComputeWorkerPool {
             limits: { ...job.limits, timeoutMs: remainingMs },
             hostEnabled: job.host !== undefined,
             consoleEnabled: job.consoleEnabled,
+            ...(job.host?.execution === undefined ? {} : { execution: job.host.execution }),
+            ...(job.host?.coordination === undefined ? {} : { coordination: job.host.coordination }),
         };
         slot.worker.postMessage(message);
     }
@@ -129,7 +131,7 @@ export class ComputeWorkerPool {
             this.#release(slot);
             return;
         }
-        if (message.t === 'host_call') {
+        if (message.t === 'host_call' || message.t === 'host_control') {
             const host = active.job.host;
             const respond = (envelopeJson) => {
                 if (slot.active === active && !active.settled && !slot.dropped) {
@@ -148,8 +150,15 @@ export class ComputeWorkerPool {
                 }));
                 return;
             }
-            host
-                .callOperation(message.name, message.argsJson)
+            const invoke = message.t === 'host_control' ? host.control : host.callOperation;
+            if (!invoke) {
+                respond(JSON.stringify({
+                    ok: false,
+                    error: { code: 'host_call_denied', message: 'host control unavailable' },
+                }));
+                return;
+            }
+            invoke(message.name, message.argsJson)
                 .then(respond)
                 .catch(() => respond(JSON.stringify({
                 ok: false,
@@ -157,6 +166,8 @@ export class ComputeWorkerPool {
             })));
             return;
         }
+        if (message.t !== 'log')
+            return;
         // 'log': deliver to the sink (fire-and-forget failures) and always release the sandbox.
         const ack = () => {
             if (slot.active === active && !active.settled && !slot.dropped) {

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

@@ -139,7 +139,7 @@ export function compileHttpConnector(def, mode, errors, catalog, connectors, sec
         const pagination = compilePagination(op, `${base}.pagination`, errors);
         const projection = compileProjection(op, `${base}.projection`, errors);
         const fake = httpFake(op.fake);
-        operations[opName] = buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst);
+        operations[opName] = buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst, compileStatusResponses(op.responses, `${base}.responses`, errors));
         // Per-operation auth declares its own secret reference (overrides any connector-level default).
         addAuthBinding({
             auth: op.auth,
@@ -268,7 +268,7 @@ function compileRequest(request, path, errors) {
 function isRecord(value) {
     return value !== null && typeof value === 'object';
 }
-function buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst) {
+function buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst, responses) {
     const resilience = httpResilience(op.resilience);
     return {
         method: op.method ?? 'GET',
@@ -287,6 +287,7 @@ function buildOperation(op, signature, requestAst, responseAst, headersAst, pagi
         ...(op.limits !== undefined ? { maxResponseBytes: op.limits.maxResponseBytes } : {}),
         ...(op.responseType !== undefined ? { responseType: op.responseType } : {}),
         ...(op.requestEncoding !== undefined ? { requestEncoding: op.requestEncoding } : {}),
+        ...(responses !== undefined ? { responses } : {}),
         ...(evidenceAst === undefined
             ? {}
             : {
@@ -321,6 +322,34 @@ function buildOperation(op, signature, requestAst, responseAst, headersAst, pagi
             : {}),
     };
 }
+function compileStatusResponses(responses, path, errors) {
+    if (responses === undefined)
+        return undefined;
+    return Object.fromEntries(Object.entries(responses).map(([status, response]) => {
+        const responseAst = compileExprMap(response.response, RESPONSE_ROOTS, `${path}.${status}.response`, errors);
+        const evidenceAst = response.evidence === undefined
+            ? undefined
+            : compileExprMap(response.evidence, new Set(['response']), `${path}.${status}.evidence`, errors);
+        return [
+            status,
+            {
+                ...(response.responseType === undefined ? {} : { responseType: response.responseType }),
+                mapResponse: (json, args) => evalMap(responseAst, { args, response: json }),
+                ...(evidenceAst === undefined
+                    ? {}
+                    : {
+                        evidence: (json) => {
+                            const value = evalMap(evidenceAst, { response: json });
+                            return {
+                                outcome: value.outcome === 'rejected' ? 'rejected' : 'unknown',
+                                ...(typeof value.reference === 'string' ? { reference: value.reference } : {}),
+                            };
+                        },
+                    }),
+            },
+        ];
+    }));
+}
 function usesExecutionIdentity(node) {
     if (node.kind === 'path')
         return node.root === 'execution';

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

@@ -1,6 +1,6 @@
 import { type CatalogConnector } from '@noodle-borg/compiler';
 import type { Connector } from '@noodle-borg/runtime';
-import type { ConnectorCompileError } from './compile-expr.js';
+import { type ConnectorCompileError } from './compile-expr.js';
 export type { ConnectorCompileError } from './compile-expr.js';
 /**
  * A binding from a connector operation to the *named* secret its auth scheme needs. It carries the

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

@@ -2,6 +2,7 @@ import { computeSignatureHash, } from '@noodle-borg/compiler';
 import { CodeConnector, DEFAULT_LIMITS, QuickJsComputeEngine, } from '@noodle-borg/compute';
 import { parse as parseYaml } from 'yaml';
 import { validateComputeCallGraph } from './call-graph.js';
+import { compileExpr } from './compile-expr.js';
 import { compileHttpConnector, toSignature } from './compile-http.js';
 import { compileMcpConnector } from './compile-mcp.js';
 import { catalogCredentialMetadata } from './credential-profiles.js';
@@ -119,6 +120,16 @@ function compileComputeConnector(def, engine, targets, errors, catalog, connecto
             module: engine.registerSource(op.code),
             limits,
             ...(calls ? { calls } : {}),
+            ...(op.coordination
+                ? {
+                    coordination: {
+                        connectionId: op.coordination.connectionId,
+                        namespace: op.coordination.namespace,
+                        key: compileExpr(op.coordination.key, new Set(['args', 'env', 'execution']), `${base}.coordination.key`, errors),
+                        reference: compileExpr(op.coordination.reference, new Set(['args', 'env', 'execution']), `${base}.coordination.reference`, errors),
+                    },
+                }
+                : {}),
         };
     }
     catalog.push({
@@ -127,6 +138,15 @@ function compileComputeConnector(def, engine, targets, errors, catalog, connecto
         kind: def.kind ?? 'custom',
         ...catalogCredentialMetadata(def),
         operations: signatures,
+        operationCalls: Object.fromEntries(Object.entries(operations).map(([name, operation]) => [
+            name,
+            Object.values(operation.calls ?? {}).map(({ connectorId, connectorVersion, operation, signatureHash }) => ({
+                connectorId,
+                connectorVersion,
+                operation,
+                signatureHash,
+            })),
+        ])),
     });
     connectors.push(new CodeConnector({ id: def.id, version: def.version, engine, operations }));
 }