@noodleseed/one 0.169.0 → 0.170.0

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

@@ -1,4 +1,5 @@
 import type { CredentialProfile, OperationSignature, ResolvedOperationRef } from '@noodle-borg/compiler';
+import type { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import type { DownstreamCredential } from '../broker/types.js';
 import type { CustomerConnectorRoute } from '../customer-routing.js';
 import type { OperationCoordinationDeclaration, OperationCoordinationSnapshot } from '../operation-coordination.js';
@@ -81,6 +82,7 @@ export interface ConnectorCallHost {
 }
 /** A single connector-operation invocation, fully resolved and credentialed by the runtime. */
 export interface ConnectorCall {
+    readonly capabilityBudget?: CapabilityBudget;
     readonly operation: string;
     /** Runtime-generated, deployment/step-bound identity. Not a business input or recovery authority. */
     readonly execution?: Readonly<{

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

@@ -1,4 +1,5 @@
 import type { ArtifactFulfilment, RuntimeArtifact } from '@noodle-borg/compiler';
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import type { CredentialBroker } from './broker/types.js';
 import type { CallerIdentity, ConnectorRegistry, ExecutionTraceSink } from './connector/types.js';
 import type { FrozenCustomerRoutes } from './customer-routing.js';
@@ -18,6 +19,8 @@ export { evalExprMap, validateAgainstSchema, validateAgainstSchemaWithDefaults,
  * [ADR 0005](../../../docs/decisions/0005-runtime-execution-boundary.md)).
  */
 export interface ExecuteDeps {
+    /** Trusted shared assistant-turn / MCP-invocation budget; never part of the expression scope. */
+    readonly capabilityBudget?: CapabilityBudget;
     readonly connectors: ConnectorRegistry;
     readonly broker: CredentialBroker;
     readonly policy?: PolicyGate;

package/node_modules/@noodle-borg/runtime/dist/execute.js

@@ -1,3 +1,4 @@
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { resolveVariableEnvironment } from './business-variables.js';
 import { preflightFulfilmentSignatures } from './connector-snapshot.js';
 import { preflightFulfilmentCustomerRoutes } from './customer-routing.js';
@@ -29,7 +30,11 @@ export async function executeTool(artifact, toolName, input, deps) {
     const variables = resolveVariableEnvironment(artifact.server.variables ?? [], await resolveEnv(deps), toolName);
     if (!variables.ok)
         return variables;
-    return runFulfilment(tool.fulfilment, input, toolName, { ...deps, env: variables.env }, deps.beforeDispatch);
+    return runFulfilment(tool.fulfilment, input, toolName, {
+        ...deps,
+        env: variables.env,
+        capabilityBudget: deps.capabilityBudget ?? new CapabilityBudget(),
+    }, deps.beforeDispatch);
 }
 /**
  * Execute a resource read against a resolved artifact. `input` is the resource's variable scope — the

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

@@ -20,8 +20,9 @@ export type { OperationEvidence, OperationEvidenceIntent, OperationEvidencePort,
 export { AllowAllPolicy } from './policy/allow-all.js';
 export type { PolicyContext, PolicyDecision, PolicyGate } from './policy/types.js';
 export { type ConfirmationActionReview, type ConfirmationPreparationResult, type ConfirmationReview, type ConnectorFailureAttribution, type ElicitationRequest, type ElicitationResponse, type ExecutionError, type ExecutionErrorCode, type ExecutionResult, type InteractiveExecutionResult, isConfirmationRequired, isInputRequired, isInputRequiredForConfirmation, type PreparedOperationAction, type PreparedToolContinuation, type ToolContinuation, type ToolPreparationContinuation, } from './result.js';
-export { splitResultMeta } from './result-meta.js';
+export { hasEphemeralEvidence, splitResultMeta } from './result-meta.js';
 export { type CallerStateAdoptionInput, type CallerStateAdoptionResult, claimableStateHandleNames, } from './state-handle-ownership.js';
 export { assertExpectedStateRevision, assertNoSecretValue, assertSchemaValue, assertStateHandleNotCompleted, COMPLETE_STATE_OPERATION, createMutableStateHandleRecord, createStateConnector, InMemoryStateHandleStore, type MutableStateHandleRecord, PATCH_STATE_OPERATION, READ_STATE_OPERATION, STATE_CONNECTOR_ID, STATE_CONNECTOR_VERSION, STATE_OPERATION_SIGNATURES, StateConnector, type StateHandleRecord, type StateHandleStore, type StateInput, type StateMutationInput, type StatePatchInput, stateHandleRecordForMutation, toPublicStateHandleRecord, } from './state-handles.js';
 export type { ToolDispatchContext, ToolDispatchDecision, ToolDispatchHook, } from './tool-dispatch.js';
+export { WebCapabilityConnector, type WebCapabilityExecutionPort } from './web-capabilities.js';
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@noodle-borg/runtime/dist/index.js

@@ -15,7 +15,8 @@ export { executeToolInteractive, resumeTool } from './interactive.js';
 export { resolveManagedOrigins, } from './managed-origins.js';
 export { AllowAllPolicy } from './policy/allow-all.js';
 export { isConfirmationRequired, isInputRequired, isInputRequiredForConfirmation, } from './result.js';
-export { splitResultMeta } from './result-meta.js';
+export { hasEphemeralEvidence, splitResultMeta } from './result-meta.js';
 export { claimableStateHandleNames, } from './state-handle-ownership.js';
 export { assertExpectedStateRevision, assertNoSecretValue, assertSchemaValue, assertStateHandleNotCompleted, COMPLETE_STATE_OPERATION, createMutableStateHandleRecord, createStateConnector, InMemoryStateHandleStore, PATCH_STATE_OPERATION, READ_STATE_OPERATION, STATE_CONNECTOR_ID, STATE_CONNECTOR_VERSION, STATE_OPERATION_SIGNATURES, StateConnector, stateHandleRecordForMutation, toPublicStateHandleRecord, } from './state-handles.js';
+export { WebCapabilityConnector } from './web-capabilities.js';
 //# sourceMappingURL=index.js.map

package/node_modules/@noodle-borg/runtime/dist/interactive.js

@@ -1,3 +1,4 @@
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { resolveVariableEnvironment, validateVariableContinuation } from './business-variables.js';
 import { preflightFulfilmentCustomerRoutes } from './customer-routing.js';
 import { validateElicitationContent } from './elicitation-response.js';
@@ -17,7 +18,11 @@ export async function executeToolInteractive(artifact, toolName, input, deps) {
     const variables = resolveVariableEnvironment(artifact.server.variables ?? [], await resolveEnv(deps), toolName);
     if (!variables.ok)
         return { status: 'failed', error: variables.error };
-    deps = { ...deps, env: variables.env };
+    deps = {
+        ...deps,
+        env: variables.env,
+        capabilityBudget: deps.capabilityBudget ?? new CapabilityBudget(),
+    };
     if (tool.fulfilment.kind !== 'flow' || !tool.fulfilment.steps.some((s) => s.kind === 'elicit')) {
         return toInteractive(await runFulfilment(tool.fulfilment, input, toolName, deps, deps.beforeDispatch));
     }
@@ -32,6 +37,7 @@ export async function executeToolInteractive(artifact, toolName, input, deps) {
 }
 /** Resume one server-held continuation with the user's reviewed response. */
 export async function resumeTool(artifact, continuation, response, deps) {
+    deps = { ...deps, capabilityBudget: new CapabilityBudget(continuation.capabilityBudget) };
     if (!sameArtifact(artifact, continuation) || continuation.version !== 1) {
         return interactiveFail('invalid_continuation', 'tool continuation does not match the artifact');
     }
@@ -84,6 +90,9 @@ async function runInteractiveFlow(artifact, toolName, flow, input, startIndex, s
                     status: 'input_required',
                     request,
                     continuation: {
+                        ...(deps.capabilityBudget === undefined
+                            ? {}
+                            : { capabilityBudget: deps.capabilityBudget.snapshot() }),
                         version: 1,
                         artifact: artifactIdentity(artifact),
                         toolName,

package/node_modules/@noodle-borg/runtime/dist/operation-execution.js

@@ -224,6 +224,9 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
                     if (signal?.aborted)
                         return fail('execution_cancelled', 'Execution deadline elapsed before connector dispatch.');
                     output = await connector.invoke({
+                        ...(deps.capabilityBudget === undefined
+                            ? {}
+                            : { capabilityBudget: deps.capabilityBudget }),
                         operation: ref.operation,
                         execution,
                         reportOutcome: (value) => {

package/node_modules/@noodle-borg/runtime/dist/result-meta.d.ts

@@ -1,3 +1,5 @@
+/** Ephemeral extraction evidence is usable in the current turn but never replay/persistence data. */
+export declare function hasEphemeralEvidence(output: unknown): boolean;
 /** @internal Shared with suspension-aware execution and surface adapters. */
 export declare function splitResultMeta(output: unknown): {
     readonly visible: unknown;

package/node_modules/@noodle-borg/runtime/dist/result-meta.js

@@ -1,4 +1,8 @@
 const RESULT_META_KEY = '__noodleResultMeta';
+/** Ephemeral extraction evidence is usable in the current turn but never replay/persistence data. */
+export function hasEphemeralEvidence(output) {
+    return splitResultMeta(output).meta?.['noodle/ephemeralEvidence'] === true;
+}
 /** @internal Shared with suspension-aware execution and surface adapters. */
 export function splitResultMeta(output) {
     if (output === null || typeof output !== 'object' || Array.isArray(output)) {
@@ -31,6 +35,8 @@ export function attachResultMeta(output, metas) {
 }
 function mergeRecords(target, source) {
     for (const [key, value] of Object.entries(source)) {
+        if (key === 'noodle/ephemeralEvidence' && target[key] === true)
+            continue;
         const existing = target[key];
         if (isPlainRecord(existing) && isPlainRecord(value)) {
             mergeRecords(existing, value);

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

@@ -1,4 +1,5 @@
 import type { CredentialProfile } from '@noodle-borg/compiler';
+import type { CapabilityBudgetSnapshot } from '@noodle-borg/managed-capabilities';
 import type { ConnectorFailureCategory } from './connector/types.js';
 import type { CustomerRouteBinding } from './customer-routing.js';
 /** Why a tool call could not be fulfilled. Protocol and embedded adapters map this internal contract. */
@@ -60,6 +61,7 @@ export type ElicitationResponse = {
  * never be serialized into MCP or embedded-assistant client payloads.
  */
 export interface ToolContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly version: 1;
     readonly artifact: {
         readonly manifestName: string;
@@ -86,6 +88,7 @@ interface ContinuationArtifactIdentity {
  * can evaluate pure maps and request more input, but cannot execute a connector operation.
  */
 export interface ToolPreparationContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly kind: 'confirmation_preparation';
     readonly version: 1;
     readonly artifact: ContinuationArtifactIdentity;
@@ -102,6 +105,7 @@ export interface ToolPreparationContinuation {
  * behind an opaque interaction id and release it to {@code executePreparedTool} only after approval.
  */
 export interface PreparedToolContinuation {
+    readonly capabilityBudget?: CapabilityBudgetSnapshot;
     readonly kind: 'prepared_confirmation';
     /** Private hosting snapshot; never projected into a model-visible confirmation. */
     readonly executionRevision?: string;

package/node_modules/@noodle-borg/runtime/dist/web-capabilities.d.ts

@@ -0,0 +1,71 @@
+import type { WebCapability, WebExtractResult } from '@noodle-borg/managed-capabilities';
+import { type Connector, type ConnectorCall } from './connector/types.js';
+export type WebCapabilityExecutionPort = (declaration: WebCapability, request: unknown, call: ConnectorCall) => Promise<WebExtractResult>;
+/** Thin ordinary connector; deployment binding and policy authority are injected by the service. */
+export declare class WebCapabilityConnector implements Connector {
+    private readonly declarations;
+    private readonly execute;
+    readonly id = "noodle_web";
+    readonly version = "1.0.0";
+    constructor(declarations: readonly WebCapability[], execute: WebCapabilityExecutionPort);
+    signature(operation: string): {
+        type: "read";
+        input: import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            request: import("zod").ZodObject<{
+                urls: import("zod").ZodArray<import("zod").ZodString>;
+                domains: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>>;
+        output: import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{
+            status: import("zod").ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+            }>;
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                requestIndex: import("zod").ZodNumber;
+                sourceRef: import("zod").ZodString;
+                content: import("zod").ZodObject<{
+                    format: import("zod").ZodLiteral<"text">;
+                    text: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                links: import("zod").ZodArray<import("zod").ZodObject<{
+                    url: import("zod").ZodString;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>>;
+                truncated: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strict>>;
+            sources: import("zod").ZodArray<import("zod").ZodObject<{
+                ref: import("zod").ZodString;
+                url: import("zod").ZodString;
+                title: import("zod").ZodOptional<import("zod").ZodString>;
+                retrievedAt: import("zod").ZodISODateTime;
+                publishedAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                observedAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                expiresAt: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+                attribution: import("zod").ZodOptional<import("zod").ZodString>;
+                rights: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            warnings: import("zod").ZodArray<import("zod").ZodObject<{
+                requestIndex: import("zod").ZodNumber;
+                code: import("zod").ZodEnum<{
+                    capability_unavailable: "capability_unavailable";
+                    capability_binding_invalid: "capability_binding_invalid";
+                    capability_requirement_unsupported: "capability_requirement_unsupported";
+                    capability_policy_denied: "capability_policy_denied";
+                    capability_budget_exhausted: "capability_budget_exhausted";
+                    capability_source_rejected: "capability_source_rejected";
+                    capability_provider_failed: "capability_provider_failed";
+                    capability_result_invalid: "capability_result_invalid";
+                    capability_cancelled: "capability_cancelled";
+                    content_truncated: "content_truncated";
+                }>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>>;
+    } | undefined;
+    executionBoundMs(): number;
+    invoke(call: ConnectorCall): Promise<WebExtractResult & {
+        readonly __noodleResultMeta: Readonly<Record<string, unknown>>;
+    }>;
+}
+//# sourceMappingURL=web-capabilities.d.ts.map

package/node_modules/@noodle-borg/runtime/dist/web-capabilities.js

@@ -0,0 +1,41 @@
+import { CapabilityError, WEB_CONNECTOR_ID, WEB_CONNECTOR_VERSION, WEB_OPERATION_SIGNATURE, webOperationInputSchema, } from '@noodle-borg/managed-capabilities';
+import { ConnectorInvocationError } from './connector/types.js';
+/** Thin ordinary connector; deployment binding and policy authority are injected by the service. */
+export class WebCapabilityConnector {
+    declarations;
+    execute;
+    id = WEB_CONNECTOR_ID;
+    version = WEB_CONNECTOR_VERSION;
+    constructor(declarations, execute) {
+        this.declarations = declarations;
+        this.execute = execute;
+    }
+    signature(operation) {
+        return operation === 'extract' ? WEB_OPERATION_SIGNATURE : undefined;
+    }
+    executionBoundMs() {
+        return 30_000;
+    }
+    async invoke(call) {
+        const input = webOperationInputSchema.safeParse(call.args);
+        const declaration = input.success
+            ? this.declarations.find((value) => value.name === input.data.name)
+            : undefined;
+        if (call.operation !== 'extract' ||
+            declaration === undefined ||
+            !input.success ||
+            call.capabilityBudget === undefined) {
+            throw new ConnectorInvocationError('capability_policy_denied', { retryable: false });
+        }
+        try {
+            return {
+                ...(await this.execute(declaration, input.data.request, call)),
+                __noodleResultMeta: { 'noodle/ephemeralEvidence': true },
+            };
+        }
+        catch (error) {
+            throw new ConnectorInvocationError(error instanceof CapabilityError ? error.code : 'capability_unavailable', { retryable: false });
+        }
+    }
+}
+//# sourceMappingURL=web-capabilities.js.map

package/node_modules/@noodle-borg/runtime/package.json

@@ -26,6 +26,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "@noodle-borg/managed-capabilities": "0.0.0",
     "@noodle-borg/compiler": "0.0.0",
     "@noodle-borg/module": "0.0.0"
   },

package/node_modules/@noodle-borg/service/dist/local-options.d.ts

@@ -6,6 +6,7 @@ import type { LocalDevtoolsDelegatedExchangeRuntime } from './local-devtools-del
 import type { ServerRegistry } from './registry.js';
 import type { ConfigStore, TenantBridgeAuthConfig } from './store.js';
 type LocalRuntimeOptions = {
+    readonly capabilities?: import('@noodle-borg/managed-capabilities').CapabilityService;
     readonly assistantStore?: import('@noodle-borg/assistant-gateway/portable').AssistantStore;
     readonly assistantAppearance?: import('@noodle-borg/assistant-gateway/portable').AssistantAppearanceSettingsStore;
     readonly publicEmbeds?: import('@noodle-borg/assistant-gateway/portable').PublicEmbedStore;

package/node_modules/@noodle-borg/service/dist/local-web-capabilities.js

@@ -0,0 +1,13 @@
+import { InMemoryDailyCounterStore } from '@noodle-borg/admission-limits/portable';
+import { PublicPageReader } from '@noodle-borg/knowledge-crawl';
+import { CapabilityService, InMemoryCapabilityPolicyStore, } from '@noodle-borg/managed-capabilities';
+/** Loopback-only composition. Keep PostgreSQL imports out of the published CLI graph. */
+export function localWebCapabilities() {
+    return new CapabilityService({
+        profile: 'development',
+        policies: new InMemoryCapabilityPolicyStore(),
+        counters: new InMemoryDailyCounterStore(),
+        reader: new PublicPageReader(),
+    });
+}
+//# sourceMappingURL=local-web-capabilities.js.map

package/node_modules/@noodle-borg/service/dist/mcp-protocol-runtime.js

@@ -0,0 +1,21 @@
+import { RequestStateManager, requestStateSecretBox, } from '@noodle-borg/protocol';
+/**
+ * Build the fleet-shared request-state manager. Static-key deployments use an HKDF domain-separated key;
+ * KMS deployments reuse the configured envelope-encryption custodian because its raw KEK cannot be
+ * exported for HKDF.
+ */
+export function createHostedMcpRequestStateManager(input) {
+    if (input.secretMasterKey !== undefined) {
+        return new RequestStateManager(requestStateSecretBox(Buffer.from(input.secretMasterKey, 'base64')));
+    }
+    return input.secretBox === undefined ? undefined : new RequestStateManager(input.secretBox);
+}
+/** Resolve the temporary origin-wide rollout gate from operator configuration. */
+export function resolveMcpProtocolMode(value) {
+    if (value === undefined || value === 'dual')
+        return 'dual';
+    if (value === 'legacy-only')
+        return value;
+    throw new Error('NOODLE_MCP_PROTOCOL_MODE must be dual or legacy-only');
+}
+//# sourceMappingURL=mcp-protocol-runtime.js.map

package/node_modules/@noodle-borg/service/dist/modules/route-dispatch.js

@@ -14,6 +14,19 @@ export function createModuleRouteContext(hostRequest, deps) {
         logger: deps.logger ?? noopModuleLogger,
         controlPlane: deps.gate,
         audit: deps.audit,
+        capabilityDeployments: {
+            get: async (request, scope) => {
+                if (request !== hostRequest || !authorizedOrgs.has(scope.org))
+                    return undefined;
+                const target = await deps.registry.getActiveByTenant(scope);
+                if (target?.deploymentId === undefined)
+                    return undefined;
+                return {
+                    deploymentId: target.deploymentId,
+                    declarations: target.served.artifact.server.capabilities ?? [],
+                };
+            },
+        },
         platformIdentityRecovery: {
             reconcile: (plan) => deps.registry.reconcilePlatformAccountReset(plan),
             customerAuthRestoreProjections: async (deploymentIds) => (await deps.registry.customerAuthRestoreProjections(deploymentIds)).map((projection) => ({

package/node_modules/@noodle-borg/service/dist/registry-compile.js

@@ -14,6 +14,7 @@ import { missingCapabilityErrors, missingSecretErrors, missingVariableErrors, }
 import { servedTargetFor } from './registry-targets.js';
 import { createDeploymentStateConnector, } from './state-connector-factory.js';
 import { resolveConfigScope, } from './store.js';
+import { deploymentWebConnector } from './web-capabilities.js';
 /** Reject unsupported persisted semantics before constructing executable runtime dependencies. */
 export async function compilePersistedRegistryRecord(record, compileTarget) {
     const versionError = deploymentRecordVersionError(record);
@@ -197,11 +198,13 @@ export async function compileRegistryTarget(context, input) {
             artifact,
             ...(boundDeploymentId === undefined ? {} : { deploymentId: boundDeploymentId }),
         });
+        const webConnector = deploymentWebConnector(artifact, tenant, boundDeploymentId, context.capabilities);
         return {
             artifact,
             deps: {
                 connectors: new InMemoryConnectorRegistry([
                     ...context.platformConnectors,
+                    ...(webConnector === undefined ? [] : [webConnector]),
                     ...(nativeRecords === undefined ? [] : [nativeRecords]),
                     ...(stateConnector !== undefined ? [stateConnector] : []),
                     ...httpConnectors,

package/node_modules/@noodle-borg/service/dist/registry-types.d.ts

@@ -96,6 +96,7 @@ export interface AccessUpdateOptions {
     readonly serverVersion?: string | undefined;
 }
 export interface ServerRegistryOptions {
+    readonly capabilities?: import('@noodle-borg/managed-capabilities').CapabilityService;
     readonly nativeRecords?: NativeRecordConnectorFactory;
     /** Pure renderer injection used for deployment-bound package construction and failure testing. */
     readonly renderAppPackage?: AppPackageRenderer;

package/node_modules/@noodle-borg/service/dist/registry.js

@@ -32,6 +32,7 @@ export class ServerRegistry {
     #platformCatalog;
     #platformConnectors;
     #nativeRecords;
+    #capabilities;
     #stateHandleStoreFactory;
     #delegatedCredentialStore;
     #sealCustomerCredential;
@@ -61,6 +62,7 @@ export class ServerRegistry {
         this.#platformCatalog = withBuiltinStateCatalog(options.platformCatalog ?? []);
         this.#platformConnectors = options.platformConnectors ?? [];
         this.#nativeRecords = options.nativeRecords;
+        this.#capabilities = options.capabilities;
         this.#stateHandleStoreFactory = options.stateHandleStoreFactory;
         this.#delegatedCredentialStore = options.delegatedCredentialStore;
         this.#sealCustomerCredential = options.sealCustomerCredential;
@@ -311,6 +313,7 @@ export class ServerRegistry {
             stateHandleStoreFactory: this.#stateHandleStoreFactory,
             platformConnectors: this.#platformConnectors,
             nativeRecords: this.#nativeRecords,
+            capabilities: this.#capabilities,
             policyGate: this.#policyGate,
             appPackageRenderer: this.#appPackageRenderer,
             knowledgeSearch: this.#knowledgeSearch,

package/node_modules/@noodle-borg/service/dist/routes/assistant-agent.js

@@ -3,6 +3,7 @@ import { assistantCoreModelMessages, assistantTurnModelContextMessages, requestA
 import { assistantGuideModelContext, assistantModelToolOncePerSession, assistantModelToolRequiredWhenVisible, assistantOmittedToolResult, assistantViewAvailableData, dispatchAssistantTool, projectAssistantGuide, publicSurfaceOf, recoverableAssistantView, remainingTurnTokens, selectAssistantModelTools, toolTouchesDelegatedAuth, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
 import { guardedFetch } from '@noodle-borg/connector-http';
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { evaluateToolAuthorization } from '@noodle-borg/protocol';
 import { interceptForElevation, offersSignIn } from './assistant-elevation.js';
 import { assistantKnowledgeModelTools, executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, KNOWLEDGE_CITATION_GUIDANCE, resolveAssistantKnowledge, } from './assistant-knowledge.js';
@@ -98,6 +99,7 @@ export async function runAgentTurn(target, session, message, context, deps, emit
     // Across every step of this turn, not per step: eight tool calls is eight, however the model splits
     // them, or a model that loops one call per step would spend the budget a step at a time.
     let toolCallsThisTurn = 0;
+    const capabilityBudget = new CapabilityBudget();
     let omittedToolRecoveries = 0;
     let remainingTokens = binding.requestPolicy?.maxTokensPerTurn;
     const turnSignal = binding.requestPolicy?.maxTurnMs === undefined
@@ -247,7 +249,7 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                 artifact: target.served.artifact,
                 tool,
                 arguments: args,
-                executeDeps: withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
+                executeDeps: withAssistantSessionExecutionAuthority({ ...target.served.deps, capabilityBudget }, target.served.artifact, session),
                 caller: session.caller,
                 context,
                 session,
@@ -273,7 +275,8 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                 arguments: args,
             }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }));
             if (view) {
-                await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
+                if (!dispatch.ephemeral)
+                    await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
                 emit({ event: 'view_available', data: { ...view } });
             }
             messages.push({

package/node_modules/@noodle-borg/service/dist/routes/assistant-interactions.js

@@ -1,5 +1,5 @@
 import { AssistantInteractionCapacityError, assistantConfirmationReview, assistantConfirmationTransition, assistantInputTransition, assistantInteractionTool, assistantPreparedArgumentReview, assistantPreparedToolContinuation, assistantSafeOutput, assistantToolContinuation, assistantViewAvailableData, auditAssistantInteraction, boundedAssistantExecution, recoverableAssistantView, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
-import { executePreparedTool, executeToolInteractive, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
+import { executePreparedTool, executeToolInteractive, hasEphemeralEvidence, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { applyBrowserCors, authenticateSession, now, } from './assistant.js';
 import { replayOrConflict, writeUnknownOutcome } from './assistant-interaction-replay.js';
@@ -347,7 +347,9 @@ async function finishExecution(res, deps, session, interaction, context, result,
     }
     const completedTool = target.served.artifact.tools.find((tool) => tool.name === toolName);
     const safeOutput = assistantSafeOutput(completedTool?.outputSchema, result.output);
-    const completed = await completeAssistantInteractionExecution(deps, session, interaction, 'succeeded', 'tool_completed', toolName, { result: safeOutput });
+    const ephemeral = hasEphemeralEvidence(result.output);
+    const retainedOutput = ephemeral ? { evidenceRetained: false } : safeOutput;
+    const completed = await completeAssistantInteractionExecution(deps, session, interaction, 'succeeded', 'tool_completed', toolName, { result: retainedOutput });
     if (!completed)
         return writeUnknownOutcome(res, deps, session, interaction, 'accept');
     await auditAssistantInteraction({
@@ -364,7 +366,7 @@ async function finishExecution(res, deps, session, interaction, context, result,
         // Model-facing scaffolding: the panel saw the tool_completed card, never this row's tool JSON.
         {
             role: 'assistant',
-            content: `Completed ${toolName}: ${JSON.stringify(safeOutput)}`,
+            content: `Completed ${toolName}: ${JSON.stringify(retainedOutput)}`,
             kind: 'narration',
         },
     ]);
@@ -377,7 +379,8 @@ async function finishExecution(res, deps, session, interaction, context, result,
         result: safeOutput,
     }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }));
     if (view) {
-        await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
+        if (!ephemeral)
+            await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
         writeViewAvailable(res, view);
     }
     await narrateResolvedInteraction(res, deps, target, session, toolName, 'accept', safeOutput, context, suggestions);

package/node_modules/@noodle-borg/service/dist/serve-local.js

@@ -3,6 +3,7 @@ import { InMemoryControlPlaneStore } from '@noodle-borg/control-plane/portable';
 import { InMemoryAssetStore } from './assets.js';
 import { createCustomerVerifierFactory, createHostedCustomerVerifierFactory, createLocalDevtoolsCustomerVerifierFactory, } from './customer-verifier.js';
 import { createLocalDevtoolsDelegatedCredentialSource } from './local-devtools-delegated-credentials.js';
+import { localWebCapabilities } from './local-web-capabilities.js';
 import { ServerRegistry } from './registry.js';
 import { isLoopbackHost } from './serve-resource-auth.js';
 import { createServiceHandler } from './service.js';
@@ -48,7 +49,9 @@ export async function serveLocalService(options = {}) {
     const delegatedCredentials = directCustomerAuth
         ? createLocalDevtoolsDelegatedCredentialSource()
         : undefined;
+    const capabilities = options.runtime?.capabilities ?? localWebCapabilities();
     const registry = new ServerRegistry(undefined, undefined, configStore, {
+        capabilities,
         customerVerifierFactory,
         ...(delegatedCredentials === undefined
             ? {}
@@ -62,6 +65,17 @@ export async function serveLocalService(options = {}) {
             : { localDevtoolsDelegatedExchange: options.localDevtoolsDelegatedExchange }),
     });
     const handler = createServiceHandler(registry, {
+        capabilities,
+        deployGate: {
+            authorize: () => ({
+                ok: true,
+                identity: {
+                    subject: 'local-operator',
+                    email: 'local-operator@localhost',
+                    superAdmin: true,
+                },
+            }),
+        },
         controlPlaneStore,
         configStore,
         assetStore: new InMemoryAssetStore(),

package/node_modules/@noodle-borg/service/dist/serve-resource-auth.js

@@ -1,10 +1,20 @@
 import { resolveMcpSubdomainTenant } from '@noodle-borg/control-plane/portable';
 import { normalizePublicBaseDomain, parseCanonicalPublicMcpUrl, parseLegacyTenantMcpPath, } from '@noodle-borg/module';
 import { resolveTenantBridgeAuthVariables } from './managed-config-expressions.js';
+import { createHostedMcpRequestStateManager } from './mcp-protocol-runtime.js';
 import { resolveConfigScope, } from './store.js';
 export function isLoopbackHost(host) {
     return host === '127.0.0.1' || host === '::1' || host === 'localhost';
 }
+export function resolveMcpRequestState(options, secretBox) {
+    return (options.mcpRequestState ??
+        createHostedMcpRequestStateManager({
+            ...(options.wrappingMasterKey === undefined && options.secretMasterKey !== undefined
+                ? { secretMasterKey: options.secretMasterKey }
+                : {}),
+            ...(secretBox === undefined ? {} : { secretBox }),
+        }));
+}
 export function assertLocalDevtoolsServiceBoundary(host, options) {
     if (options.localDevtoolsDirectFirebaseAuth === true && !isLoopbackHost(host)) {
         throw new Error('local Devtools Firebase verification requires a loopback service bind');

package/node_modules/@noodle-borg/service/dist/service.js

@@ -2,6 +2,7 @@ import { InMemoryDailyCounterStore } from '@noodle-borg/admission-limits/portabl
 import { InMemoryAssistantAppearanceSettingsStore, InMemoryAssistantStore, } from '@noodle-borg/assistant-gateway/portable';
 import { allowAllGate, InMemoryControlPlaneStore } from '@noodle-borg/control-plane/portable';
 import { dispatchKnowledgeRequest } from '@noodle-borg/knowledge-operations/portable';
+import { capabilityOperatorRoute } from '@noodle-borg/managed-capabilities';
 import { OPENAI_APPS_CHALLENGE_PATH } from '@noodle-borg/module';
 import { applySecurityHeaders, createMcpRouter, enforceHttps, noopLogger, sendJson, } from '@noodle-borg/transport-http';
 import { AnonymousConsumerLimiter, createAdmissionGate } from './admission.js';
@@ -163,7 +164,12 @@ export function createServiceHandler(registry, options = {}) {
     });
     archiveSweeper.maybeSweep();
     const moduleRouteDeps = {
-        routes: moduleHost.routes,
+        routes: [
+            ...moduleHost.routes,
+            ...(options.capabilities === undefined
+                ? []
+                : [capabilityOperatorRoute(options.capabilities)]),
+        ],
         logger,
         gate,
         controlPlane,

package/node_modules/@noodle-borg/service/dist/web-capabilities.js

@@ -0,0 +1,39 @@
+import { CapabilityError } from '@noodle-borg/managed-capabilities';
+import { evaluateToolAuthorization } from '@noodle-borg/protocol';
+import { WebCapabilityConnector } from '@noodle-borg/runtime';
+export function deploymentWebConnector(artifact, tenant, deploymentId, service) {
+    if (!artifact.server.capabilities?.length)
+        return undefined;
+    return new WebCapabilityConnector(artifact.server.capabilities, async (declaration, request, call) => {
+        if (service === undefined ||
+            deploymentId === undefined ||
+            call.execution === undefined ||
+            call.capabilityBudget === undefined) {
+            throw new CapabilityError('capability_unavailable');
+        }
+        return service.execute(declaration, request, {
+            tenant,
+            deploymentId,
+            executionId: call.execution.id,
+            authorized: evaluateToolAuthorization(declaration.authorization === undefined
+                ? undefined
+                : {
+                    ...(declaration.authorization.discovery === 'public'
+                        ? { discovery: 'public' }
+                        : {}),
+                    ...(declaration.authorization.requiredScopes === undefined
+                        ? {}
+                        : { requiredScopes: declaration.authorization.requiredScopes }),
+                    ...(declaration.authorization.allowedRoles === undefined
+                        ? {}
+                        : { allowedRoles: declaration.authorization.allowedRoles }),
+                }, call.caller).allow,
+            anonymous: call.caller === undefined || call.caller.identityKind === 'anonymous',
+            ...(call.caller === undefined ? {} : { subject: call.caller.subject }),
+            ...(call.publicAdmission === undefined ? {} : { network: call.publicAdmission.network }),
+            budget: call.capabilityBudget,
+            ...(call.signal === undefined ? {} : { signal: call.signal }),
+        });
+    });
+}
+//# sourceMappingURL=web-capabilities.js.map