@noodleseed/one 0.164.0 → 0.166.0

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

@@ -15,7 +15,34 @@ export function variable(name, options) {
     const errors = validateVariableDeclaration(declaration);
     if (errors.length > 0)
         throw new Error(`variable("${name}") ${errors.map((error) => `${error.path}: ${error.message}`).join('; ')}`);
-    return { ...ref, kind: 'variable', declaration: structuredClone(declaration) };
+    return {
+        ...makeVariableValueRef(name, [], declaration.valueSchema),
+        declaration: structuredClone(declaration),
+    };
+}
+function makeVariableValueRef(name, fields, schema) {
+    const expression = () => `\${env.${[name, ...fields].join('.')}}`;
+    return {
+        ...makeConfigRef('variable', name),
+        kind: 'variable',
+        toExpression: expression,
+        toString: expression,
+        field(key) {
+            const properties = schema.properties;
+            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) ||
+                ['__proto__', 'constructor', 'prototype'].includes(key) ||
+                schema.type !== 'object' ||
+                !properties ||
+                typeof properties !== 'object' ||
+                Array.isArray(properties) ||
+                !Object.hasOwn(properties, key))
+                throw new Error('variable.field() requires a declared object field with a safe identifier');
+            const child = properties[key];
+            if (!child || typeof child !== 'object' || Array.isArray(child))
+                throw new Error('variable.field() requires a declared object field schema');
+            return makeVariableValueRef(name, [...fields, key], child);
+        },
+    };
 }
 export function manifestVariables(refs) {
     if (refs === undefined || refs.length === 0)

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

@@ -125,6 +125,35 @@ export interface ComputeLimits {
     readonly maxHostCalls?: number;
 }
 export interface ComputeHost {
+    /** Trusted external-operation identity; unavailable outside governed action execution. */
+    readonly execution?: {
+        readonly id: string;
+    };
+    readonly coordination?: {
+        readonly acquired: boolean;
+        readonly previous?: {
+            readonly reference: string;
+            readonly operationDigest: string;
+        };
+    };
+    reportOutcome(evidence: {
+        readonly outcome: 'completed' | 'rejected' | 'unknown';
+        readonly reference?: string;
+    }): unknown;
+    resolveCoordination(): unknown;
+    /** Pure helpers over explicit instants, with no access to the current clock. */
+    readonly time: {
+        parse(instant: string): number;
+        format(epochMilliseconds: number): string;
+        parts(epochMilliseconds: number, timeZone: string): {
+            readonly date: string;
+            readonly weekday: number;
+            readonly hour: number;
+            readonly minute: number;
+        };
+    };
+    /** Bounded SHA-256 over explicit input; no keys, secrets or randomness. */
+    digest(value: string, encoding?: 'hex' | 'base32hex'): string;
     callOperation(name: string, args: Readonly<Record<string, unknown>>): unknown;
 }
 /**
@@ -142,6 +171,13 @@ export interface ComputeOperationOptions {
     readonly run: (input: any, host: ComputeHost) => unknown;
     readonly limits?: ComputeLimits;
     readonly calls?: Readonly<Record<string, string>>;
+    /** Serialize one externally coordinated resource; host owns durable custody and exact release. */
+    readonly coordination?: {
+        readonly connectionId: string;
+        readonly namespace: string;
+        readonly key: string;
+        readonly reference: string;
+    };
 }
 /** A connector operation's fulfilment, carried by the builder so it can be emitted to a catalog. */
 export interface ConnectorOpDefinition {
@@ -152,6 +188,7 @@ export interface ConnectorOpDefinition {
     readonly code: string;
     readonly limits?: ComputeLimits;
     readonly calls?: Readonly<Record<string, string>>;
+    readonly coordination?: ComputeOperationOptions['coordination'];
 }
 export interface ConnectorRef<CredentialProfileKey extends string = string> {
     readonly id: string;

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

@@ -213,6 +213,7 @@ export class ConnectorBuilder {
                 code: serializeRun(options.run),
                 ...(options.limits ? { limits: options.limits } : {}),
                 ...(options.calls ? { calls: options.calls } : {}),
+                ...(options.coordination ? { coordination: options.coordination } : {}),
             },
         }, undefined, this.credentialProfiles, undefined);
     }
@@ -263,6 +264,9 @@ function normalizeOperation(id, name, operation) {
         ...(operation.response !== undefined
             ? { response: normalizeConfigRefs(operation.response, `${path}.response`) }
             : {}),
+        ...(operation.responses !== undefined
+            ? { responses: normalizeConfigRefs(operation.responses, `${path}.responses`) }
+            : {}),
         ...(operation.headers !== undefined
             ? { headers: normalizeConfigRefs(operation.headers, `${path}.headers`) }
             : {}),

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

@@ -3,7 +3,7 @@ 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 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, type OpenAICompatibleTransport, openAICompatible, type PublicWebsiteAccess, type PublicWebsiteInput, publicWebsite, } from './assistant.js';
-export { type ConfigRef, type ConfigRefKind, type DeclaredVariableRef, secret, type VariableOptions, variable, } from './config.js';
+export { type ConfigRef, type ConfigRefKind, type DeclaredVariableRef, secret, type VariableOptions, type VariableValueRef, 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, type McpAuthOptions, type McpConnectorOptions, } from './connectors.js';
 export type { AmbientContextOptions, AmbientProviderContext, ServerContextOptions, } from './context.js';

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

@@ -288,6 +288,7 @@ class ServerBuilder {
                         code: def.code,
                         ...(def.limits ? { limits: def.limits } : {}),
                         ...(def.calls ? { calls: def.calls } : {}),
+                        ...(def.coordination ? { coordination: def.coordination } : {}),
                     };
                 }
                 const computeConnector = {

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

@@ -0,0 +1,83 @@
+export const OPTIONAL_FLAG = {
+    required: false,
+    repeatable: false,
+    sensitive: false,
+    aliases: [],
+    conflictsWith: [],
+};
+export const REQUIRED_ARGUMENT = {
+    type: 'string',
+    required: true,
+    variadic: false,
+    sensitive: false,
+    constraints: {},
+};
+const ORG = {
+    ...OPTIONAL_FLAG,
+    name: 'org',
+    type: 'string',
+    value: '<slug>',
+    summary: 'Organization slug.',
+};
+export const SERVICE = {
+    ...OPTIONAL_FLAG,
+    name: 'service',
+    type: 'string',
+    value: '<url>',
+    summary: 'Control-plane service URL.',
+};
+export const AUTH_TOKEN = {
+    ...OPTIONAL_FLAG,
+    name: 'auth-token',
+    type: 'string',
+    value: '<token>',
+    summary: 'Control-plane authentication token.',
+    sensitive: true,
+};
+export const JSON_FLAG = {
+    ...OPTIONAL_FLAG,
+    name: 'json',
+    type: 'boolean',
+    summary: 'Emit JSON output.',
+};
+export const INSTALLATION_ARGUMENT = {
+    ...REQUIRED_ARGUMENT,
+    name: 'installation',
+    summary: 'Solution installation identifier.',
+};
+export const SOLUTION_COMMON_FLAGS = [ORG, SERVICE, AUTH_TOKEN, JSON_FLAG];
+export const EXPECTED_REVISION = {
+    ...OPTIONAL_FLAG,
+    name: 'expected-revision',
+    type: 'integer',
+    value: '<revision>',
+    summary: 'Expected current resource revision.',
+    required: true,
+    constraints: { minimum: 1 },
+};
+export const IDEMPOTENCY_KEY = {
+    ...OPTIONAL_FLAG,
+    name: 'idempotency-key',
+    type: 'string',
+    value: '<key>',
+    summary: 'Retry-safe operation key.',
+    required: true,
+};
+export const PAGING_FLAGS = [
+    {
+        ...OPTIONAL_FLAG,
+        name: 'cursor',
+        type: 'string',
+        value: '<cursor>',
+        summary: 'Opaque page cursor.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'limit',
+        type: 'integer',
+        value: '<count>',
+        summary: 'Bounded page size.',
+        constraints: { minimum: 1, maximum: 100 },
+    },
+];
+//# sourceMappingURL=catalog-data-solution-flags.js.map

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

@@ -1,24 +1,5 @@
-const OPTIONAL_FLAG = {
-    required: false,
-    repeatable: false,
-    sensitive: false,
-    aliases: [],
-    conflictsWith: [],
-};
-const REQUIRED_ARGUMENT = {
-    type: 'string',
-    required: true,
-    variadic: false,
-    sensitive: false,
-    constraints: {},
-};
-const ORG = {
-    ...OPTIONAL_FLAG,
-    name: 'org',
-    type: 'string',
-    value: '<slug>',
-    summary: 'Organization slug.',
-};
+/** Solution installation/operator catalog. Imports only dependency-free sibling data. */
+import { AUTH_TOKEN, EXPECTED_REVISION, IDEMPOTENCY_KEY, INSTALLATION_ARGUMENT, JSON_FLAG, OPTIONAL_FLAG, PAGING_FLAGS, REQUIRED_ARGUMENT, SERVICE, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
 const APP = {
     ...OPTIONAL_FLAG,
     name: 'app',
@@ -33,27 +14,6 @@ const ENV = {
     value: '<slug>',
     summary: 'Environment slug.',
 };
-const SERVICE = {
-    ...OPTIONAL_FLAG,
-    name: 'service',
-    type: 'string',
-    value: '<url>',
-    summary: 'Control-plane service URL.',
-};
-const AUTH_TOKEN = {
-    ...OPTIONAL_FLAG,
-    name: 'auth-token',
-    type: 'string',
-    value: '<token>',
-    summary: 'Control-plane authentication token.',
-    sensitive: true,
-};
-const JSON_FLAG = {
-    ...OPTIONAL_FLAG,
-    name: 'json',
-    type: 'boolean',
-    summary: 'Emit JSON output.',
-};
 const RETENTION = {
     ...OPTIONAL_FLAG,
     name: 'retention-days',
@@ -62,11 +22,6 @@ const RETENTION = {
     summary: 'Managed-record retention in days.',
     constraints: { choices: [7, 30, 90], default: 30 },
 };
-const INSTALLATION_ARGUMENT = {
-    ...REQUIRED_ARGUMENT,
-    name: 'installation',
-    summary: 'Solution installation identifier.',
-};
 const COLLECTION_ARGUMENT = {
     ...REQUIRED_ARGUMENT,
     name: 'collection',
@@ -77,41 +32,6 @@ const RECORD_ARGUMENT = {
     name: 'record',
     summary: 'Managed record identifier.',
 };
-const SOLUTION_COMMON_FLAGS = [ORG, SERVICE, AUTH_TOKEN, JSON_FLAG];
-const EXPECTED_REVISION = {
-    ...OPTIONAL_FLAG,
-    name: 'expected-revision',
-    type: 'integer',
-    value: '<revision>',
-    summary: 'Expected current resource revision.',
-    required: true,
-    constraints: { minimum: 1 },
-};
-const IDEMPOTENCY_KEY = {
-    ...OPTIONAL_FLAG,
-    name: 'idempotency-key',
-    type: 'string',
-    value: '<key>',
-    summary: 'Retry-safe operation key.',
-    required: true,
-};
-const PAGING_FLAGS = [
-    {
-        ...OPTIONAL_FLAG,
-        name: 'cursor',
-        type: 'string',
-        value: '<cursor>',
-        summary: 'Opaque page cursor.',
-    },
-    {
-        ...OPTIONAL_FLAG,
-        name: 'limit',
-        type: 'integer',
-        value: '<count>',
-        summary: 'Bounded page size.',
-        constraints: { minimum: 1, maximum: 100 },
-    },
-];
 const RECORD_QUERY_FLAGS = [
     {
         ...OPTIONAL_FLAG,
@@ -285,6 +205,64 @@ export const CATALOG_SOLUTIONS = {
                 },
             ],
         })),
+        {
+            name: 'operations',
+            summary: 'Inspect and recover application operation custody.',
+            arguments: [],
+            flags: [],
+            subcommands: [
+                {
+                    name: 'coordination',
+                    summary: 'Administrator-only review of held external operations.',
+                    arguments: [],
+                    flags: [],
+                    subcommands: ['list', 'resolve'].map((name) => ({
+                        name,
+                        summary: name === 'list'
+                            ? 'List held operations in one installation.'
+                            : 'Release an inactive exact hold after reviewing the external outcome.',
+                        arguments: [INSTALLATION_ARGUMENT],
+                        flags: [
+                            ...SOLUTION_COMMON_FLAGS,
+                            ...(name === 'list'
+                                ? [
+                                    {
+                                        ...OPTIONAL_FLAG,
+                                        name: 'limit',
+                                        type: 'integer',
+                                        value: '<count>',
+                                        summary: 'Maximum records in this page.',
+                                        constraints: { minimum: 1, maximum: 100 },
+                                    },
+                                    {
+                                        ...OPTIONAL_FLAG,
+                                        name: 'before-resource',
+                                        type: 'string',
+                                        value: '<hash>',
+                                        summary: 'Continuation resource returned by the previous list.',
+                                    },
+                                ]
+                                : [
+                                    ...[
+                                        ['resource', 'Exact resource hash from list.'],
+                                        ['token', 'Exact custody token from list.'],
+                                        ['reason', 'Single-line review reason; 1 to 256 characters.'],
+                                    ].map(([flag, summary]) => ({
+                                        ...OPTIONAL_FLAG,
+                                        name: flag,
+                                        summary,
+                                        required: true,
+                                        sensitive: flag === 'token',
+                                        type: 'string',
+                                        value: '<value>',
+                                    })),
+                                ]),
+                        ],
+                        jsonOutput: { mode: 'single' },
+                    })),
+                },
+            ],
+        },
         {
             name: 'activity',
             summary: 'Inspect payload-free operation evidence and its retention policy.',
@@ -485,18 +463,18 @@ export const CATALOG_SOLUTIONS = {
             ],
             jsonOutput: { mode: 'single' },
         },
-        {
-            name: 'inspect',
-            summary: 'Inspect one solution installation.',
-            arguments: [INSTALLATION_ARGUMENT],
-            flags: SOLUTION_COMMON_FLAGS,
-            jsonOutput: { mode: 'single' },
-        },
-        ...['pause', 'resume'].map((name) => ({
+        ...Object.entries({
+            inspect: 'Inspect one solution installation.',
+            activate: 'Retry activation of a saved installation without changing its intake setting.',
+            pause: 'Pause anonymous public intake.',
+            resume: 'Resume anonymous public intake.',
+        }).map(([name, summary]) => ({
             name,
-            summary: `${name === 'pause' ? 'Pause' : 'Resume'} anonymous public intake.`,
+            summary,
             arguments: [INSTALLATION_ARGUMENT],
-            flags: [...SOLUTION_COMMON_FLAGS, EXPECTED_REVISION],
+            flags: ['pause', 'resume'].includes(name)
+                ? [...SOLUTION_COMMON_FLAGS, EXPECTED_REVISION]
+                : SOLUTION_COMMON_FLAGS,
             jsonOutput: { mode: 'single' },
         })),
         {

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

@@ -31,6 +31,8 @@ export interface ResolvedOperationRef {
     readonly operation: string;
     /** Stable hash of the operation signature: `sha256:<hex>`. See catalog/signature.ts. */
     readonly signatureHash: string;
+    /** Exact allowed nested operations with their independently resolved account authority. */
+    readonly calls?: readonly ResolvedOperationRef[];
     /** Core-v2 credential selection resolved from the stable alias; absent on legacy artifacts. */
     readonly credentialBinding?: ResolvedCredentialBinding;
     /** Customer-derived base-URL key for a directly routed HTTP operation; never the resolved URL. */

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

@@ -58,8 +58,11 @@
  * authority or exact resolved read-only connector operations for an external replica.
  *
  * `0.19.0` (Business settings): optional typed managed-variable declarations and definition digests.
+ *
+ * `0.20.0` (Nested operation authority): resolved operation references carry exact declared calls,
+ * including independently validated credential bindings for sandboxed compute dependencies.
  */
-export declare const ARTIFACT_SCHEMA_VERSION = "0.19.0";
+export declare const ARTIFACT_SCHEMA_VERSION = "0.20.0";
 /** mimeType for an MCP Apps UI resource (SEP-1865). Widgets are served under this profile. */
 export declare const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
 //# sourceMappingURL=version.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/artifact/version.js

@@ -58,8 +58,11 @@
  * authority or exact resolved read-only connector operations for an external replica.
  *
  * `0.19.0` (Business settings): optional typed managed-variable declarations and definition digests.
+ *
+ * `0.20.0` (Nested operation authority): resolved operation references carry exact declared calls,
+ * including independently validated credential bindings for sandboxed compute dependencies.
  */
-export const ARTIFACT_SCHEMA_VERSION = '0.19.0';
+export const ARTIFACT_SCHEMA_VERSION = '0.20.0';
 /** mimeType for an MCP Apps UI resource (SEP-1865). Widgets are served under this profile. */
 export const MCP_APP_MIME_TYPE = 'text/html;profile=mcp-app';
 //# sourceMappingURL=version.js.map

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

@@ -58,6 +58,13 @@ export interface CatalogConnector {
     readonly credentialProfiles?: Readonly<Record<string, CredentialProfile>>;
     readonly operationCredentials?: Readonly<Record<string, OperationCredentialRequirement>>;
     readonly operations: Readonly<Record<string, OperationSignature>>;
+    /** System-derived declared compute call graph, including exact resolved target identities. */
+    readonly operationCalls?: Readonly<Record<string, readonly {
+        readonly connectorId: string;
+        readonly connectorVersion: string;
+        readonly operation: string;
+        readonly signatureHash: string;
+    }[]>>;
     readonly customerRouting?: CatalogCustomerRouting;
 }
 /** Read-only lookup of connectors by catalog id and pinned version. */

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

@@ -1,7 +1,7 @@
 import type { AppPackageArtifactV1 } from '@noodle-borg/app-package';
 import type { RuntimeArtifact } from './artifact/types.js';
 import type { PackagedAsset } from './assets.js';
-export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
+export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'ambiguous_nested_connector_binding' | 'invalid_connector_call_graph' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
 export interface CompileError {
     readonly code: CompileErrorCode;
     /** Dotted path to the offending location (e.g. `tools.1.name`); empty string for the document root. */

package/node_modules/@noodle-borg/compiler/dist/fulfilment-emit.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { computeSignatureHash } from './catalog/signature.js';
+import { resolveNestedOperations } from './nested-operations.js';
 import { docAnchorFor, suggestionFields } from './suggest.js';
 const JSON_SCHEMA_2020_12 = 'https://json-schema.org/draft/2020-12/schema';
 /** Build the artifact fulfilment, resolving each operation occurrence against the catalog (if any). */
@@ -31,7 +32,7 @@ export function emitFulfilment(struct, catalog, declared, usedAliases, errors, o
  * Resolve one operation occurrence against the catalog (docs/SPEC.md "Runtime Invariants"). Without a
  * catalog, returns an unresolved reference (shape-only). Pushes a CompileError per failure.
  */
-function resolveOp(op, catalog, declared, usedAliases, errors, options) {
+function resolveOp(op, catalog, declared, usedAliases, errors, options, traversal) {
     const unresolved = {
         connector: op.connectorAlias,
         operation: op.operation,
@@ -85,17 +86,29 @@ function resolveOp(op, catalog, declared, usedAliases, errors, options) {
             got: operation.type,
         });
     }
-    checkArgs(op.args, connector, op.operation, operation, `${op.path}.args`, errors);
+    if (traversal === undefined)
+        checkArgs(op.args, connector, op.operation, operation, `${op.path}.args`, errors);
     const credentialRequirement = connector.operationCredentials?.[op.operation];
     const credentialPresentation = connectorRef.binding === undefined
         ? undefined
         : connector.credentialProfiles?.[connectorRef.binding.profile];
+    const calls = resolveNestedOperations({
+        connector,
+        operation: op.operation,
+        path: op.path,
+        catalog,
+        declared,
+        errors,
+        ...(traversal === undefined ? {} : { traversal }),
+        resolve: (child, childDeclared, childTraversal) => resolveOp(child, catalog, childDeclared, usedAliases, errors, options, childTraversal),
+    });
     return {
         alias: op.connectorAlias,
         connectorId: connector.id,
         connectorVersion: connector.version,
         operation: op.operation,
         signatureHash: computeSignatureHash(op.operation, operation),
+        ...(calls === undefined ? {} : { calls }),
         ...(customerOperationRouting?.directEndpoint === undefined
             ? {}
             : { customerEndpoint: customerOperationRouting.directEndpoint }),

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