@noodleseed/one 0.161.2 → 0.163.0

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

@@ -7,7 +7,7 @@ import { compileExpr, compileExprMap, evalMap, } from './compile-expr.js';
 import { catalogCredentialMetadata } from './credential-profiles.js';
 import { toHeaderRecord, validateHeaderNames } from './http-headers.js';
 import { collectVariableExpression, collectVariablesFromExpr, collectVariablesFromExprMap, isVariableExpression, } from './variables.js';
-const REQUEST_ROOTS = new Set(['args', 'env']);
+const REQUEST_ROOTS = new Set(['args', 'env', 'execution']);
 const RESPONSE_ROOTS = new Set(['args', 'response']);
 const PROJECTION_ROOTS = new Set(['args', 'response', 'output']);
 const PAGINATION_ROOTS = RESPONSE_ROOTS;
@@ -45,6 +45,29 @@ export function compileHttpConnector(def, mode, errors, catalog, connectors, sec
             message: 'http.allowedOrigins is required when http.baseUrl is a managed variable',
         });
     }
+    if (def.http.transportAuth !== undefined) {
+        if (def.http.auth !== undefined ||
+            Object.values(def.operations).some((op) => op.auth !== undefined) ||
+            routedBase) {
+            errors.push({
+                code: 'transport_auth_conflict',
+                path: `connectors.${def.id}.http.transportAuth`,
+                message: 'transportAuth requires a fixed/managed origin and account credential profiles, without legacy auth',
+            });
+            return;
+        }
+        const transportHeader = def.http.transportAuth.header.toLowerCase();
+        const profiles = Object.values(def.credentialProfiles ?? {});
+        if (profiles.length === 0 ||
+            profiles.some((profile) => profile.kind === 'apiKey' && profile.header.toLowerCase() === transportHeader)) {
+            errors.push({
+                code: 'transport_auth_conflict',
+                path: `connectors.${def.id}.http.transportAuth`,
+                message: 'transportAuth requires account profiles with distinct credential headers',
+            });
+            return;
+        }
+    }
     for (const [opName, op] of Object.entries(def.operations)) {
         const base = `connectors.${def.id}.operations.${opName}`;
         if (op.type === 'action' && op.resilience?.retry !== undefined) {
@@ -79,6 +102,14 @@ export function compileHttpConnector(def, mode, errors, catalog, connectors, sec
                 message: 'HTTP paths take {name} placeholders (authored as ${args.name}); other ${...} expressions are not supported in a path',
             });
         }
+        if (def.http.transportAuth !== undefined &&
+            Object.keys(op.headers ?? {}).some((name) => name.toLowerCase() === def.http.transportAuth?.header.toLowerCase())) {
+            errors.push({
+                code: 'transport_auth_header_conflict',
+                path: `${base}.headers`,
+                message: 'operation headers cannot write the transport credential header',
+            });
+        }
         validateFakeShape(op, `${base}.fake`, errors);
         const signature = toSignature(op.type, op.input, op.output);
         signatures[opName] = signature;
@@ -94,6 +125,9 @@ export function compileHttpConnector(def, mode, errors, catalog, connectors, sec
         const responseAst = op.response
             ? compileExprMap(op.response, RESPONSE_ROOTS, `${base}.response`, errors)
             : undefined;
+        const evidenceAst = op.evidence
+            ? compileExprMap(op.evidence, new Set(['response']), `${base}.evidence`, errors)
+            : undefined;
         // Headers use the same roots as the request body (args + env), so a runtime value threaded through
         // args can be attached as dynamic, non-credential request metadata.
         validateHeaderNames(op.headers, `${base}.headers`, errors);
@@ -105,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);
+        operations[opName] = buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst);
         // Per-operation auth declares its own secret reference (overrides any connector-level default).
         addAuthBinding({
             auth: op.auth,
@@ -129,7 +163,7 @@ export function compileHttpConnector(def, mode, errors, catalog, connectors, sec
     });
     // Connector-level default auth binds every operation that doesn't carry its own scheme.
     addAuthBinding({
-        auth: def.http.auth,
+        auth: def.http.transportAuth ?? def.http.auth,
         connectorId: def.id,
         connectorVersion: def.version,
         ...(customerEndpoint === undefined ? {} : { customerEndpoint }),
@@ -145,6 +179,9 @@ export function compileHttpConnector(def, mode, errors, catalog, connectors, sec
         baseUrl: def.http.baseUrl,
         ...(def.http.allowedOrigins ? { allowedOrigins: def.http.allowedOrigins } : {}),
         ...(def.http.auth ? { auth: toAuthScheme(def.http.auth) } : {}),
+        ...(def.http.transportAuth
+            ? { transportAuth: { kind: 'apiKey', header: def.http.transportAuth.header } }
+            : {}),
         ...(mode === 'fake' ? { fakeMode: true } : {}),
         operations,
     };
@@ -231,10 +268,14 @@ function compileRequest(request, path, errors) {
 function isRecord(value) {
     return value !== null && typeof value === 'object';
 }
-function buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection) {
+function buildOperation(op, signature, requestAst, responseAst, headersAst, pagination, fake, projection, evidenceAst) {
     const resilience = httpResilience(op.resilience);
     return {
         method: op.method ?? 'GET',
+        requiresExecution: [
+            ...(requestAst?.kind === 'value' ? [requestAst.node] : Object.values(requestAst?.map ?? {})),
+            ...Object.values(headersAst ?? {}),
+        ].some(usesExecutionIdentity),
         path: op.path,
         ...(op.query ? { query: op.query } : {}),
         signature,
@@ -246,21 +287,55 @@ 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 } : {}),
+        ...(evidenceAst === undefined
+            ? {}
+            : {
+                evidence: (json) => {
+                    const value = evalMap(evidenceAst, { response: json });
+                    const outcome = value.outcome;
+                    if (outcome !== 'completed' &&
+                        outcome !== 'rejected' &&
+                        outcome !== 'accepted' &&
+                        outcome !== 'unknown')
+                        return { outcome: 'unknown' };
+                    return {
+                        outcome,
+                        ...(typeof value.reference === 'string' ? { reference: value.reference } : {}),
+                    };
+                },
+            }),
         ...(requestAst
             ? {
-                body: (args, env) => requestAst.kind === 'map'
-                    ? evalMap(requestAst.map, { args, env })
-                    : evaluateValue(requestAst.node, { args, env }, 'request'),
+                body: (args, env, execution) => requestAst.kind === 'map'
+                    ? evalMap(requestAst.map, { args, env, execution })
+                    : evaluateValue(requestAst.node, { args, env, execution }, 'request'),
             }
             : {}),
         ...(responseAst
             ? { mapResponse: (json, args) => evalMap(responseAst, { args, response: json }) }
             : {}),
         ...(headersAst
-            ? { headers: (args, env) => toHeaderRecord(evalMap(headersAst, { args, env })) }
+            ? {
+                headers: (args, env, execution) => toHeaderRecord(evalMap(headersAst, { args, env, execution })),
+            }
             : {}),
     };
 }
+function usesExecutionIdentity(node) {
+    if (node.kind === 'path')
+        return node.root === 'execution';
+    if (node.kind === 'template')
+        return node.parts.some((part) => part.kind !== 'text' && usesExecutionIdentity(part));
+    if (node.kind === 'array')
+        return node.items.some(usesExecutionIdentity);
+    if (node.kind === 'object')
+        return node.entries.some((entry) => usesExecutionIdentity(entry.value));
+    if (node.kind === 'coalesce')
+        return usesExecutionIdentity(node.left) || usesExecutionIdentity(node.right);
+    if (node.kind === 'function')
+        return node.args.some(usesExecutionIdentity);
+    return false;
+}
 function compileProjection(op, path, errors) {
     const projection = op.projection;
     if (projection === undefined)

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

@@ -99,6 +99,10 @@ declare const httpOperationSchema: z.ZodObject<{
         "form-urlencoded": "form-urlencoded";
     }>>;
     response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    evidence: z.ZodOptional<z.ZodObject<{
+        outcome: z.ZodString;
+        reference: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     responseType: z.ZodOptional<z.ZodEnum<{
         json: "json";
@@ -342,7 +346,6 @@ declare const computeOperationSchema: z.ZodObject<{
         audience: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-/** An outbound HTTP connector: a declared `http` origin + HTTP operations with `${...}` mapping. */
 declare const httpConnectorDefSchema: z.ZodObject<{
     http: z.ZodObject<{
         baseUrl: z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodObject<{
@@ -422,6 +425,11 @@ declare const httpConnectorDefSchema: z.ZodObject<{
                 client_secret_post: "client_secret_post";
             }>>;
         }, z.core.$strict>], "kind">>;
+        transportAuth: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"apiKey">;
+            header: z.ZodString;
+            secret: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     operations: z.ZodRecord<z.ZodString, z.ZodObject<{
         type: z.ZodEnum<{
@@ -445,6 +453,10 @@ declare const httpConnectorDefSchema: z.ZodObject<{
             "form-urlencoded": "form-urlencoded";
         }>>;
         response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        evidence: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodString;
+            reference: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         responseType: z.ZodOptional<z.ZodEnum<{
             json: "json";
@@ -887,6 +899,11 @@ declare const connectorDefSchema: z.ZodUnion<readonly [z.ZodObject<{
                 client_secret_post: "client_secret_post";
             }>>;
         }, z.core.$strict>], "kind">>;
+        transportAuth: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"apiKey">;
+            header: z.ZodString;
+            secret: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     operations: z.ZodRecord<z.ZodString, z.ZodObject<{
         type: z.ZodEnum<{
@@ -910,6 +927,10 @@ declare const connectorDefSchema: z.ZodUnion<readonly [z.ZodObject<{
             "form-urlencoded": "form-urlencoded";
         }>>;
         response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        evidence: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodString;
+            reference: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         responseType: z.ZodOptional<z.ZodEnum<{
             json: "json";
@@ -1345,6 +1366,11 @@ export declare const connectorFileSchema: z.ZodObject<{
                     client_secret_post: "client_secret_post";
                 }>>;
             }, z.core.$strict>], "kind">>;
+            transportAuth: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"apiKey">;
+                header: z.ZodString;
+                secret: z.ZodString;
+            }, z.core.$strict>>;
         }, z.core.$strict>;
         operations: z.ZodRecord<z.ZodString, z.ZodObject<{
             type: z.ZodEnum<{
@@ -1368,6 +1394,10 @@ export declare const connectorFileSchema: z.ZodObject<{
                 "form-urlencoded": "form-urlencoded";
             }>>;
             response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            evidence: z.ZodOptional<z.ZodObject<{
+                outcome: z.ZodString;
+                reference: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             responseType: z.ZodOptional<z.ZodEnum<{
                 json: "json";

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

@@ -308,6 +308,11 @@ const httpOperationSchema = z
     /** How to encode a non-GET request mapping. JSON remains the default. */
     requestEncoding: z.enum(['json', 'form-urlencoded']).optional(),
     response: exprMapSchema.optional(),
+    /** Explicit provider evidence mapping; never infer completion from an HTTP status or tool name. */
+    evidence: z
+        .object({ outcome: z.string().min(1), reference: z.string().min(1).optional() })
+        .strict()
+        .optional(),
     /**
      * Per-operation request headers: header name -> a `${...}` expression (over `args`/`env`) or a
      * literal string. Merged over the connector defaults but *below* the `auth` scheme, so a declared
@@ -491,6 +496,16 @@ const connectorIdentity = {
         .optional(),
 };
 /** An outbound HTTP connector: a declared `http` origin + HTTP operations with `${...}` mapping. */
+const transportAuthSchema = z
+    .object({
+    kind: z.literal('apiKey'),
+    header: z
+        .string()
+        .regex(/^x-[a-z0-9]+(?:-[a-z0-9]+)*$/iu)
+        .refine((header) => !/^x-(?:forwarded(?:-|$)|real-ip$|http-method-override$|original-url$|rewrite-url$)/iu.test(header), 'transport authentication cannot use routing headers'),
+    secret: secretRefSchema,
+})
+    .strict();
 const httpConnectorDefSchema = z
     .object({
     ...connectorIdentity,
@@ -502,6 +517,7 @@ const httpConnectorDefSchema = z
             .optional(),
         /** Connector-default auth scheme; an operation's own `auth` overrides it. */
         auth: httpAuthSchema.optional(),
+        transportAuth: transportAuthSchema.optional(),
     })
         .strict(),
     operations: z.record(z.string(), httpOperationSchema),

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

@@ -1,5 +1,5 @@
 import { type CustomerEndpointRef, type OperationSignature } from '@noodle-borg/compiler';
-import { type Connector, type ConnectorCall, type DownstreamCredential } from '@noodle-borg/runtime';
+import { type Connector, type ConnectorCall, type DownstreamCredential, type OperationEvidence } from '@noodle-borg/runtime';
 import { type HttpRetryPolicy } from './http-response.js';
 import { type HttpOperationProjection } from './projection.js';
 import { type HttpRequestEncoding } from './request-encoding.js';
@@ -57,6 +57,9 @@ export interface HttpOperationFake {
  * declared output fields.
  */
 export interface HttpOperation {
+    readonly evidence?: (json: unknown) => OperationEvidence;
+    /** Compiler-derived requirement for mappings that consume the trusted operation identity. */
+    readonly requiresExecution?: boolean;
     readonly method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
     readonly path: string;
     readonly query?: readonly string[];
@@ -64,7 +67,7 @@ export interface HttpOperation {
     /** Per-operation base URL override. Its resolved request origin must still be in the allowlist. */
     readonly baseUrl?: string;
     /** Build a JSON request body from already-evaluated, validated args. Ignored for `GET`. */
-    readonly body?: (args: Readonly<Record<string, unknown>>, env: Readonly<Record<string, string>>) => unknown;
+    readonly body?: (args: Readonly<Record<string, unknown>>, env: Readonly<Record<string, unknown>>, execution?: ConnectorCall['execution']) => unknown;
     /** Encode the evaluated body as JSON (default) or a WHATWG URLSearchParams form body. */
     readonly requestEncoding?: HttpRequestEncoding;
     /** Per-operation auth scheme; overrides the connector-level `auth`. */
@@ -74,7 +77,7 @@ export interface HttpOperation {
      * defaults but *below* the `auth` scheme, so a declared `auth` block always wins. Lets an operation
      * attach a runtime value — e.g. a token from a prior operation — as `Authorization: Bearer ${args.token}`.
      */
-    readonly headers?: (args: Readonly<Record<string, unknown>>, env: Readonly<Record<string, string>>) => Record<string, string>;
+    readonly headers?: (args: Readonly<Record<string, unknown>>, env: Readonly<Record<string, unknown>>, execution?: ConnectorCall['execution']) => Record<string, string>;
     readonly mapResponse?: (json: unknown, args: Readonly<Record<string, unknown>>) => Record<string, unknown>;
     readonly resilience?: HttpOperationResilience;
     readonly pagination?: HttpOperationPagination;
@@ -105,6 +108,11 @@ export interface HttpConnectorConfig {
     readonly headers?: Readonly<Record<string, string>>;
     /** Connector-default auth scheme (an operation's own `auth` overrides this). */
     readonly auth?: HttpAuthScheme;
+    /** Independent deployment API key; account credentials still use their bound presentation. */
+    readonly transportAuth?: {
+        readonly kind: 'apiKey';
+        readonly header: string;
+    };
     /**
      * Legacy escape hatch: map the broker credential to arbitrary auth headers. Used only when no
      * declarative `auth` scheme resolves for the operation. Omitted for public, no-auth APIs.
@@ -145,6 +153,7 @@ export declare class HttpConnector implements Connector {
     readonly version: string;
     constructor(config: HttpConnectorConfig);
     signature(operation: string): OperationSignature | undefined;
+    executionBoundMs(operation: string): number | undefined;
     invoke(call: ConnectorCall): Promise<unknown>;
 }
 export {};

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

@@ -49,10 +49,19 @@ export class HttpConnector {
     signature(operation) {
         return this.#config.operations[operation]?.signature;
     }
+    executionBoundMs(operation) {
+        const op = this.#config.operations[operation];
+        // Actions never use automatic retry; read retries do not create durable effect evidence.
+        return op?.signature.type === 'action'
+            ? (op.resilience?.timeoutMs ?? this.#config.timeoutMs ?? 10_000)
+            : undefined;
+    }
     async invoke(call) {
         const op = this.#config.operations[call.operation];
         if (!op)
             throw new Error(`connector "${this.id}" has no operation "${call.operation}"`);
+        if (op.requiresExecution && !call.execution?.id)
+            throw new Error('Trusted operation identity unavailable');
         const configuredBase = this.#config.baseUrl;
         const customerBase = this.#customerBase
             ? resolveCustomerBase(this.#customerBase, op, call)
@@ -64,6 +73,8 @@ export class HttpConnector {
             const json = op.pagination === undefined
                 ? this.#fakeJson(call.operation, op)
                 : await this.#fakePaginatedJson(call.operation, op, call.args);
+            if (op.evidence)
+                call.reportOutcome?.(op.evidence(json));
             return this.#mapOutput(op, json, call.args);
         }
         const env = call.env ?? {};
@@ -75,15 +86,20 @@ export class HttpConnector {
             // material is constructed.
             await this.#validateUrl(url, customerBase, allowed);
             const method = op.method ?? 'GET';
-            const payload = requestPayload(op.requestEncoding, method !== 'GET' && op.body !== undefined ? () => op.body?.(call.args, env) : undefined);
+            const payload = requestPayload(op.requestEncoding, method !== 'GET' && op.body !== undefined
+                ? () => op.body?.(call.args, env, call.execution)
+                : undefined);
+            const transportHeaders = await this.#transportHeaders(call);
             const headers = {
                 accept: op.responseType === 'text' ? 'text/plain, text/*;q=0.9, */*;q=0.8' : 'application/json',
                 'user-agent': 'noodle-borg/0.0',
                 ...this.#config.headers,
                 // Per-operation dynamic headers sit below the auth scheme, so a declared `auth` block always wins.
-                ...(op.headers !== undefined ? op.headers(call.args, env) : {}),
+                ...(op.headers !== undefined ? op.headers(call.args, env, call.execution) : {}),
                 ...this.#authHeaders(op, call.credential, call.credentialPresentation),
             };
+            for (const [name, value] of Object.entries(transportHeaders))
+                setOwnedHeader(headers, name, value);
             if (payload !== undefined) {
                 setOwnedHeader(headers, 'content-type', op.requestEncoding === 'form-urlencoded'
                     ? 'application/x-www-form-urlencoded;charset=UTF-8'
@@ -96,11 +112,14 @@ export class HttpConnector {
             const init = {
                 method,
                 headers,
+                ...(call.signal === undefined ? {} : { signal: call.signal }),
                 ...(payload !== undefined ? { body: payload } : {}),
             };
             const json = op.pagination === undefined
                 ? await this.#fetchJsonWithResilience(url, op, init)
                 : await this.#fetchPaginatedJson(op, call.args, base, init, customerBase, allowed);
+            if (op.evidence)
+                call.reportOutcome?.(op.evidence(json));
             return this.#mapOutput(op, json, call.args);
         }
         catch (error) {
@@ -109,6 +128,26 @@ export class HttpConnector {
             throw error;
         }
     }
+    async #transportHeaders(call) {
+        const transport = this.#config.transportAuth;
+        if (transport === undefined)
+            return {};
+        const header = transport.header.toLowerCase();
+        const account = call.credentialPresentation;
+        if (!/^x-[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(header) ||
+            account === undefined ||
+            (account.kind === 'apiKey' && account.header.toLowerCase() === header) ||
+            call.acquireTransportCredential === undefined) {
+            throw new Error('Independent transport authentication is not configured safely');
+        }
+        const credential = await call.acquireTransportCredential();
+        if (credential.kind === 'cookie' ||
+            credential.token.length < 1 ||
+            credential.token.length > 4096 ||
+            /[\r\n]/u.test(credential.token))
+            throw new Error('Independent transport requires a valid bounded token credential');
+        return { [header]: credential.token };
+    }
     #mapOutput(op, json, args) {
         const mapped = op.mapResponse ? op.mapResponse(json, args) : json;
         if (op.projection === undefined)

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

@@ -23,7 +23,8 @@ export async function fetchResponseWithResilience(url, op, init, options) {
     const timeoutMs = op.resilience?.timeoutMs ?? options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     let lastError;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const signal = AbortSignal.timeout(timeoutMs);
+        const timeout = AbortSignal.timeout(timeoutMs);
+        const signal = init.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
         try {
             const response = await guardedFetch(url, {
                 ...init,
@@ -53,7 +54,7 @@ export async function fetchResponseWithResilience(url, op, init, options) {
         catch (error) {
             const normalized = normalizeAttemptError(error, attempt, retry, op.signature.type === 'read', signal.aborted);
             lastError = normalized.error;
-            if (!normalized.retry || attempt >= maxAttempts)
+            if (init.signal?.aborted || !normalized.retry || attempt >= maxAttempts)
                 throw lastError;
             await sleep(retryDelayMs(retry, attempt, normalized.retryAfterMs));
         }

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

@@ -11,7 +11,7 @@ export function resolveManagedString(configured, env) {
         return configured;
     const name = match[1];
     const value = env[name];
-    if (value === undefined || value.length === 0) {
+    if (typeof value !== 'string' || value.length === 0) {
         throw new ConnectorInvocationError(`managed variable "${name}" is unavailable`, {
             category: 'invalid_response',
             retryable: false,

package/node_modules/@noodle-borg/connector-http/dist/url-resolution.js

@@ -8,7 +8,7 @@ export function resolveConfigString(value, env) {
     if (match?.[1] === undefined)
         return value;
     const resolved = env[match[1]];
-    if (resolved === undefined) {
+    if (typeof resolved !== 'string') {
         throw new ConnectorInvocationError(`managed variable "${match[1]}" is not configured`, {
             category: 'invalid_response',
             retryable: false,

package/node_modules/@noodle-borg/control-plane/dist/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { OrganizationAgreementStore } from './organization-agreements.js';
 export type OrgRole = 'owner' | 'developer';
 /** The canonical principal bound to a personal workspace must remain that organization's owner. */
 export declare class PersonalWorkspaceOwnerMutationError extends Error {
@@ -125,7 +126,7 @@ export interface WelcomeEmailRecord {
     readonly providerMessageId?: string;
     readonly lastErrorCode?: 'delivery_failed';
 }
-export interface OrganizationStore {
+export interface OrganizationStore extends OrganizationAgreementStore {
     /** Resolve the one active public MCP label for an immutable organization identity. */
     getActiveMcpSubdomain(org: string): Promise<ActiveMcpSubdomainClaim | undefined>;
     /** Resolve an active public MCP label to its immutable organization identity. */

package/node_modules/@noodle-borg/control-plane/dist/in-memory-organization-store.d.ts

@@ -1,4 +1,5 @@
 import type { ActiveMcpSubdomainClaim, ChangeMcpSubdomainInput, McpSubdomainMutationResult, McpSubdomainSetting, OrganizationStore, OrgDomainRecord, OrgInvitationRecord, OrgMemberRecord, OrgOpenAIAppsChallengeRecord, OrgRecord, OrgRole, SignupAllowlistKind, SignupAllowlistRecord } from './contracts.js';
+import { type AcceptOrganizationAgreementInput } from './organization-agreements.js';
 interface InMemoryOrganizationStoreOptions {
     readonly now?: () => Date;
     readonly orgs?: Map<string, OrgRecord>;
@@ -8,6 +9,8 @@ interface InMemoryOrganizationStoreOptions {
 export declare class InMemoryOrganizationStore {
     #private;
     constructor(options?: InMemoryOrganizationStoreOptions);
+    getOrganizationAgreement(org: string, version: string): Promise<import("./organization-agreements.js").OrganizationAgreementAcceptance | undefined>;
+    acceptOrganizationAgreement(input: AcceptOrganizationAgreementInput): Promise<import("./organization-agreements.js").OrganizationAgreementAcceptance>;
     hasOrg(org: string): boolean;
     isExactOwner(org: string, subject: string): boolean;
     ensureDefaultMcpSubdomain(org: string): ActiveMcpSubdomainClaim | undefined;

package/node_modules/@noodle-borg/control-plane/dist/in-memory-organization-store.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { InMemoryMcpSubdomainClaimStore } from './mcp-subdomain-claims.js';
+import { InMemoryOrganizationAgreements, } from './organization-agreements.js';
 import { domainFromEmail, domainKey, memberKey, normalizeSignupAllowlistValue, signupKey, } from './organization-helpers.js';
 import { validateDomain, validateOpenAIAppsChallenge, validateOrgMembershipDomain, validateOrgRole, validateSignupAllowlistKind, validateSlug, } from './validation.js';
 /** Shared in-memory organization persistence used by service-backed development stores. */
@@ -12,11 +13,19 @@ export class InMemoryOrganizationStore {
     #invitations = new Map();
     #mcpSubdomainClaims;
     #now;
+    #agreements;
     constructor(options = {}) {
         this.#now = options.now ?? (() => new Date());
         this.#orgs = options.orgs ?? new Map();
         this.#members = options.members ?? new Map();
         this.#mcpSubdomainClaims = new InMemoryMcpSubdomainClaimStore(this.#now);
+        this.#agreements = new InMemoryOrganizationAgreements((org, subject) => this.isExactOwner(org, subject), this.#now);
+    }
+    getOrganizationAgreement(org, version) {
+        return this.#agreements.getOrganizationAgreement(org, version);
+    }
+    acceptOrganizationAgreement(input) {
+        return this.#agreements.acceptOrganizationAgreement(input);
     }
     hasOrg(org) {
         return this.#orgs.has(org);
@@ -266,6 +275,8 @@ export class InMemoryOrganizationStore {
 /** Bind standard organization methods for composition with service-owned billing and outbox state. */
 export function bindInMemoryOrganizationStore(store) {
     return {
+        getOrganizationAgreement: store.getOrganizationAgreement.bind(store),
+        acceptOrganizationAgreement: store.acceptOrganizationAgreement.bind(store),
         getActiveMcpSubdomain: store.getActiveMcpSubdomain.bind(store),
         resolveActiveMcpSubdomain: store.resolveActiveMcpSubdomain.bind(store),
         getMcpSubdomainSetting: store.getMcpSubdomainSetting.bind(store),

package/node_modules/@noodle-borg/control-plane/dist/organization-agreements.d.ts

@@ -0,0 +1,45 @@
+export interface AgreementDocument {
+    readonly url: string;
+    readonly sha256: string;
+}
+/** Deployment-approved immutable identities, never supplied authoritatively by a browser. */
+export interface AgreementDocuments {
+    readonly version: string;
+    readonly terms: AgreementDocument;
+    readonly privacy: AgreementDocument;
+    readonly processing: AgreementDocument;
+}
+export interface OrganizationAgreementAcceptance {
+    readonly org: string;
+    readonly actorSubject: string;
+    readonly documents: AgreementDocuments;
+    readonly documentDigest: string;
+    readonly acceptedAt: string;
+}
+export interface AcceptOrganizationAgreementInput {
+    readonly org: string;
+    readonly actorSubject: string;
+    /** Trusted catalog entry selected by service policy after checking the submitted version/digest. */
+    readonly documents: AgreementDocuments;
+}
+export interface OrganizationAgreementStore {
+    getOrganizationAgreement(org: string, version: string): Promise<OrganizationAgreementAcceptance | undefined>;
+    /** Repeats live exact-owner authorization atomically; equal acceptance preserves the first receipt. */
+    acceptOrganizationAgreement(input: AcceptOrganizationAgreementInput): Promise<OrganizationAgreementAcceptance>;
+}
+export declare class OrganizationAgreementError extends Error {
+    readonly code: 'agreement_owner_required' | 'agreement_version_conflict';
+    constructor(code: 'agreement_owner_required' | 'agreement_version_conflict');
+}
+export declare function validateAgreementDocuments(input: AgreementDocuments): AgreementDocuments;
+export declare function agreementDocumentDigest(documents: AgreementDocuments): string;
+/** Synchronous commit boundary keeps membership recheck, catalog registration and receipt indivisible. */
+export declare class InMemoryOrganizationAgreements implements OrganizationAgreementStore {
+    #private;
+    private readonly isOwner;
+    private readonly now;
+    constructor(isOwner: (org: string, subject: string) => boolean, now: () => Date);
+    getOrganizationAgreement(org: string, version: string): Promise<OrganizationAgreementAcceptance | undefined>;
+    acceptOrganizationAgreement(input: AcceptOrganizationAgreementInput): Promise<OrganizationAgreementAcceptance>;
+}
+//# sourceMappingURL=organization-agreements.d.ts.map