@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/runtime/request/approval-wait/park.js

@@ -0,0 +1,89 @@
+import { randomUUID } from "node:crypto";
+import { captureRequestContextCompaction } from "../../context/semantic-compaction/snapshot.js";
+import { captureRequestSessionMemory } from "../../context/session-memory/snapshot.js";
+import { REQUEST_APPROVAL_SNAPSHOT, snapshotRequestSeed, } from "./snapshot.js";
+import { captureApprovalSnapshotData } from "./snapshot-data.js";
+export async function parkRequestApproval(params) {
+    const { prepared, continuation } = params;
+    if (!prepared.durable)
+        throw new Error("request_durable_approval_not_enabled");
+    params.lifecycle.beginToolApprovalWait();
+    await params.steering.close();
+    await prepared.events.drain();
+    params.lifecycle.signal.throwIfAborted();
+    const compaction = prepared.seed.contextCompactionStore;
+    if (!compaction)
+        throw new Error("request_approval_compaction_missing");
+    const snapshot = captureApprovalSnapshotData({
+        kind: REQUEST_APPROVAL_SNAPSHOT,
+        originalPrompt: params.originalPrompt,
+        seed: snapshotRequestSeed(prepared.seed),
+        requestWorkingDirectory: prepared.requestWorkingDirectory,
+        toolAttachments: prepared.toolAttachments,
+        runner: continuation,
+        resources: params.resources.snapshot(),
+        compaction: captureRequestContextCompaction(compaction),
+        ...(prepared.seed.sessionMemory
+            ? {
+                sessionMemory: captureRequestSessionMemory(prepared.seed.sessionMemory),
+            }
+            : {}),
+        presentation: prepared.callbacks.snapshot(),
+        steering: params.steering.snapshot(),
+        budgets: params.lifecycle.snapshotBudgets(),
+    });
+    const stored = await params.store.writeContinuation(prepared.seed.sessionId, {
+        schema: REQUEST_APPROVAL_SNAPSHOT,
+        version: 1,
+        value: snapshot,
+    });
+    params.lifecycle.signal.throwIfAborted();
+    const waitId = randomUUID();
+    const approvalCaller = continuation.ledger.state.calls.find((call) => call.callId === continuation.preparedGroup.callId);
+    const approvals = continuation.preparedGroup.entries.flatMap((entry) => {
+        if (!entry.approvalRequest)
+            return [];
+        return [
+            {
+                approvalId: entry.approvalRequest.approvalId,
+                actionFingerprint: entry.actionFingerprint,
+                presentation: captureApprovalSnapshotData({
+                    ...entry.approvalRequest,
+                    executionId: entry.executionId,
+                    roleCallId: continuation.preparedGroup.callId,
+                    executorRole: approvalCaller?.roleId,
+                    tool: entry.approvalRequest.call.tool,
+                }),
+            },
+        ];
+    });
+    const initialDecisions = continuation.preparedGroup.initialDecisions?.map((receipt) => ({
+        approvalId: receipt.approvalId,
+        approved: receipt.decision.approved,
+        ...(receipt.decision.reason ? { reason: receipt.decision.reason } : {}),
+        commandId: `initial:${waitId}:${receipt.approvalId}`,
+    }));
+    const approvalIntents = continuation.preparedGroup.entries.flatMap((entry) => {
+        if (!entry.approvalRequest)
+            return [];
+        const intent = entry.intent.trim();
+        return intent ? [intent] : [];
+    });
+    const approvalPresentation = [...new Set(approvalIntents)].join("\n\n") || "Tool approval required.";
+    const committed = await prepared.durable.commit((expected) => params.store.commitWait(prepared.seed.sessionId, {
+        expected,
+        waitId,
+        approvals,
+        continuation: stored,
+        presentationText: [
+            prepared.callbacks.getAnswerText().trim(),
+            approvalPresentation,
+        ]
+            .filter(Boolean)
+            .join("\n\n"),
+        ...(initialDecisions?.length ? { initialDecisions } : {}),
+    }));
+    // If an explicit Stop won during the commit, failure reconciliation cancels the saved wait.
+    params.lifecycle.signal.throwIfAborted();
+    return committed.current;
+}

package/dist/src/runtime/request/approval-wait/preflight.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeEnvironmentServices } from "../../composition.js";
+import type { SessionRequestLifecycleSnapshot } from "../../../sessions/request-lifecycle/contracts.js";
+import { type RequestApprovalSnapshot } from "./snapshot.js";
+/** Compatibility preflight only. It cannot publish, persist an event, or dispatch. */
+export declare function validateApprovalResume(services: RuntimeEnvironmentServices, snapshot: RequestApprovalSnapshot, current: SessionRequestLifecycleSnapshot): Promise<void>;

package/dist/src/runtime/request/approval-wait/preflight.js

@@ -0,0 +1,155 @@
+import { isDeepStrictEqual } from "node:util";
+import { RequestToolResources } from "../../capabilities/request-tool-resources.js";
+import { RequestLifecycle } from "../../orchestration/lifecycle/request-lifecycle.js";
+import { assertExecutionBudgets } from "../../orchestration/lifecycle/execution-budgets.js";
+import { createRoleCallLedger } from "../../orchestration/role-calls/index.js";
+import { restoreCapabilityApprovalGroup } from "../../orchestration/worker-capabilities/index.js";
+import { captureRequestTemporalContext } from "../../context/request-temporal-context.js";
+import { validateRequestApprovalContinuation } from "../approval-continuation.js";
+import { restoreApprovalExecutionFreshness } from "../capability-execution-freshness.js";
+import { createRequestSteeringInbox } from "../request-steering.js";
+import { resolveRequestDependencies } from "../dependencies.js";
+import { prepareRequestExecution } from "../prepared-execution.js";
+import { createRequestRoleCallPolicy } from "../role-call-policy.js";
+import { REQUEST_APPROVAL_SNAPSHOT, } from "./snapshot.js";
+/** Compatibility preflight only. It cannot publish, persist an event, or dispatch. */
+export async function validateApprovalResume(services, snapshot, current) {
+    assertEnvelope(snapshot, current);
+    assertExecutionBudgets(snapshot.budgets);
+    const resources = new RequestToolResources();
+    const lifecycle = new RequestLifecycle({
+        requestId: current.requestId,
+        requestTimeoutMs: 0,
+        inactivityTimeoutMs: 0,
+    });
+    const steering = createRequestSteeringInbox({ requestId: current.requestId });
+    const events = forbiddenEvents();
+    const models = {
+        invoke: async () => {
+            throw new Error("approval_preflight_model_forbidden");
+        },
+        invokeRaw: async () => {
+            throw new Error("approval_preflight_model_forbidden");
+        },
+    };
+    try {
+        if (!Array.isArray(snapshot.steering?.updates))
+            throw new Error("approval_snapshot_steering_invalid");
+        for (const update of snapshot.steering.updates) {
+            const result = steering.append(update);
+            if (!result.ok ||
+                result.duplicate ||
+                !isDeepStrictEqual(result.update, update))
+                throw new Error("approval_snapshot_steering_invalid");
+        }
+        if (!isDeepStrictEqual(steering.snapshot(), snapshot.steering))
+            throw new Error("approval_snapshot_steering_invalid");
+        const options = {
+            runtimeConfig: services.config,
+            sessionStore: services.sessions,
+            attachmentStore: services.attachments,
+            toolRegistry: services.tools,
+            modelGatewayClient: models,
+            eventSinkFactory: { create: () => events },
+            sessionMemoryCompactor: services.sessionMemoryCompactor,
+            longTermMemory: services.longTermMemory,
+            approvalExecution: {
+                activation: current.activation,
+                resume: { snapshot, current, decisions: [] },
+            },
+        };
+        const prepared = await prepareRequestExecution({
+            ws: { send: forbidden },
+            options,
+            resources,
+            lifecycle,
+            steering,
+            initialEvents: events,
+            dependencies: resolveRequestDependencies(options),
+            input: {
+                requestId: current.requestId,
+                sessionId: current.sessionId,
+                prompt: snapshot.originalPrompt,
+                rawAttachments: [],
+                rawAgentMode: snapshot.seed.agentMode,
+                rawModelPreference: snapshot.seed.modelPreference,
+                toolPermissionMode: snapshot.seed.toolPermissionMode,
+            },
+            temporalContext: snapshot.seed.temporalContext ?? captureRequestTemporalContext(),
+            onEventsReady: () => { },
+        });
+        resources.assertRestoredStateClaimed();
+        const ledger = createRoleCallLedger({
+            requestId: current.requestId,
+            policy: createRequestRoleCallPolicy(prepared.request.executionPolicy),
+            checkpoint: snapshot.runner.ledger,
+        });
+        validateRequestApprovalContinuation(snapshot.runner, ledger, prepared.request.workerCapabilities.provider.getDescriptors());
+        const executionFreshness = restoreApprovalExecutionFreshness(snapshot.runner.preparedGroup.executionFreshnessToken, steering);
+        await restoreCapabilityApprovalGroup({
+            ledger,
+            context: prepared.request.workerCapabilities.executionContext,
+            adapters: prepared.request.workerCapabilities.provider.getAdapters(),
+            group: snapshot.runner.preparedGroup,
+            ...(executionFreshness ? { executionFreshness } : {}),
+        });
+        if (resources.hasActiveWork())
+            throw new Error("approval_preflight_created_active_work");
+        prepared.events.dispose();
+    }
+    finally {
+        lifecycle.dispose();
+        await steering.close();
+        await resources.dispose();
+        events.dispose();
+    }
+}
+function assertEnvelope(snapshot, current) {
+    const validIdentity = snapshot?.kind === REQUEST_APPROVAL_SNAPSHOT &&
+        current.schemaVersion === 1 &&
+        current.status === "awaiting_approval" &&
+        current.wait &&
+        current.activation &&
+        snapshot.seed?.sessionId === current.sessionId &&
+        snapshot.seed.requestId === current.requestId &&
+        snapshot.runner?.preparedGroup?.requestId === current.requestId;
+    if (!validIdentity)
+        throw new Error("approval_snapshot_identity_mismatch");
+    if (typeof snapshot.originalPrompt !== "string" ||
+        typeof snapshot.seed.prompt !== "string" ||
+        typeof snapshot.requestWorkingDirectory !== "string" ||
+        !Array.isArray(snapshot.toolAttachments))
+        throw new Error("approval_snapshot_envelope_invalid");
+    const pending = snapshot.runner.preparedGroup.entries
+        .filter((entry) => entry.approvalRequest)
+        .map((entry) => ({
+        approvalId: entry.approvalRequest.approvalId,
+        actionFingerprint: entry.actionFingerprint,
+    }))
+        .sort((a, b) => a.approvalId.localeCompare(b.approvalId));
+    const described = current
+        .wait.approvals.map((entry) => ({
+        approvalId: entry.approvalId,
+        actionFingerprint: entry.actionFingerprint,
+    }))
+        .sort((a, b) => a.approvalId.localeCompare(b.approvalId));
+    if (!pending.length || !isDeepStrictEqual(pending, described))
+        throw new Error("approval_snapshot_disclosure_mismatch");
+}
+function forbidden() {
+    throw new Error("approval_preflight_event_forbidden");
+}
+function forbiddenEvents() {
+    return {
+        publish: forbidden,
+        event: forbidden,
+        runtimeState: forbidden,
+        token: forbidden,
+        legacyToken: forbidden,
+        thinkingDelta: forbidden,
+        completed: forbidden,
+        failed: forbidden,
+        drain: async () => { },
+        dispose: () => { },
+    };
+}

package/dist/src/runtime/request/approval-wait/snapshot-data.d.ts

@@ -0,0 +1,2 @@
+/** Omit absent optional fields while rejecting values outside the persisted JSON contract. */
+export declare function captureApprovalSnapshotData<T>(input: T): T;

package/dist/src/runtime/request/approval-wait/snapshot-data.js

@@ -0,0 +1,31 @@
+/** Omit absent optional fields while rejecting values outside the persisted JSON contract. */
+export function captureApprovalSnapshotData(input) {
+    return captureValue(input, new Set());
+}
+function captureValue(input, ancestors) {
+    if (input === null || typeof input === "string" || typeof input === "boolean")
+        return input;
+    if (typeof input === "number" && Number.isFinite(input))
+        return input;
+    if (typeof input !== "object" || input === null)
+        throw new Error("approval_snapshot_value_not_serializable");
+    if (ancestors.has(input))
+        throw new Error("approval_snapshot_cycle");
+    ancestors.add(input);
+    try {
+        if (Array.isArray(input))
+            return input.map((value) => captureValue(value, ancestors));
+        const prototype = Object.getPrototypeOf(input);
+        if (prototype !== Object.prototype && prototype !== null)
+            throw new Error("approval_snapshot_object_not_serializable");
+        const result = {};
+        for (const [key, value] of Object.entries(input)) {
+            if (value !== undefined)
+                result[key] = captureValue(value, ancestors);
+        }
+        return result;
+    }
+    finally {
+        ancestors.delete(input);
+    }
+}

package/dist/src/runtime/request/approval-wait/snapshot.d.ts

@@ -0,0 +1,38 @@
+import type { ToolRequestAttachment } from "../../../capabilities/tool-types.js";
+import type { SessionActivation, SessionRequestLifecycleSnapshot } from "../../../sessions/request-lifecycle/contracts.js";
+import type { RequestExecutionSeed } from "../contracts.js";
+import type { RequestSteeringSnapshot } from "../request-steering.js";
+import type { RequestPresentationSnapshot } from "../../streaming/request-callbacks.js";
+import type { RequestExecutionBudgets } from "../../orchestration/lifecycle/execution-budgets.js";
+import type { BoundApprovalDecision } from "../../orchestration/worker-capabilities/approval-contracts.js";
+import type { captureRequestContextCompaction } from "../../context/semantic-compaction/snapshot.js";
+import type { captureRequestSessionMemory } from "../../context/session-memory/snapshot.js";
+import type { RequestToolResources } from "../../capabilities/request-tool-resources.js";
+import type { RequestApprovalContinuation } from "../approval-continuation.js";
+export declare const REQUEST_APPROVAL_SNAPSHOT = "request_approval_snapshot_v1";
+/** Frozen data consumed by the existing request constructor; no service objects. */
+export type PersistedRequestSeed = Pick<RequestExecutionSeed, "requestId" | "sessionId" | "prompt" | "temporalContext" | "historyMessages" | "sessionArtifactPaths" | "shouldGenerateSessionTitle" | "runnerConfig" | "executionPolicySelection" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy" | "toolPermissionMode" | "memoryRecallLimit">;
+export type RequestApprovalSnapshot = Readonly<{
+    kind: typeof REQUEST_APPROVAL_SNAPSHOT;
+    originalPrompt: string;
+    seed: PersistedRequestSeed;
+    requestWorkingDirectory: string;
+    toolAttachments: readonly ToolRequestAttachment[];
+    runner: RequestApprovalContinuation;
+    resources: ReturnType<RequestToolResources["snapshot"]>;
+    compaction: ReturnType<typeof captureRequestContextCompaction>;
+    sessionMemory?: ReturnType<typeof captureRequestSessionMemory>;
+    presentation: RequestPresentationSnapshot;
+    steering: RequestSteeringSnapshot;
+    budgets: RequestExecutionBudgets;
+}>;
+/** Trusted owner input. Never deserialized from request.run client options. */
+export type RequestApprovalExecution = Readonly<{
+    activation: SessionActivation;
+    resume?: Readonly<{
+        snapshot: RequestApprovalSnapshot;
+        current: SessionRequestLifecycleSnapshot;
+        decisions: readonly BoundApprovalDecision[];
+    }>;
+}>;
+export declare function snapshotRequestSeed(seed: RequestExecutionSeed): PersistedRequestSeed;

package/dist/src/runtime/request/approval-wait/snapshot.js

@@ -0,0 +1,21 @@
+import { captureApprovalSnapshotData } from "./snapshot-data.js";
+export const REQUEST_APPROVAL_SNAPSHOT = "request_approval_snapshot_v1";
+export function snapshotRequestSeed(seed) {
+    return captureApprovalSnapshotData({
+        requestId: seed.requestId,
+        sessionId: seed.sessionId,
+        prompt: seed.prompt,
+        temporalContext: seed.temporalContext,
+        historyMessages: seed.historyMessages,
+        sessionArtifactPaths: seed.sessionArtifactPaths,
+        shouldGenerateSessionTitle: seed.shouldGenerateSessionTitle,
+        runnerConfig: seed.runnerConfig,
+        executionPolicySelection: seed.executionPolicySelection,
+        attachments: seed.attachments,
+        agentMode: seed.agentMode,
+        modelPreference: seed.modelPreference,
+        modelPolicy: seed.modelPolicy,
+        toolPermissionMode: seed.toolPermissionMode,
+        memoryRecallLimit: seed.memoryRecallLimit,
+    });
+}

package/dist/src/runtime/request/bound-runtime-handler.js

@@ -11,15 +11,21 @@ export function createBoundRuntimeRequestHandler(services) {
         longTermMemory: services.longTermMemory,
     };
     return Object.freeze({
-        handle(ws, message, requestOptions = {}) {
+        async handle(ws, message, requestOptions = {}) {
+            const releaseLearning = services.passiveLearning?.beginInteractive();
             const invoke = () => handleRunRequest(ws, message, {
                 ...environmentOptions,
                 ...requestOptions,
             });
-            if (services.requestAdmission) {
-                return services.requestAdmission.run(typeof message.sessionId === "string" ? message.sessionId : "", invoke);
+            try {
+                if (services.requestAdmission) {
+                    return await services.requestAdmission.run(typeof message.sessionId === "string" ? message.sessionId : "", invoke, Boolean(requestOptions.approvalExecution?.resume));
+                }
+                return await invoke();
+            }
+            finally {
+                releaseLearning?.();
             }
-            return invoke();
         },
     });
 }

package/dist/src/runtime/request/cancellation.d.ts

@@ -0,0 +1,15 @@
+/** User cancellation is a terminal control signal, never a model instruction. */
+export declare const REQUEST_CANCELLED = "request_cancelled";
+export type SavedWaitCancellation = Readonly<{
+    generation: string;
+    waitId: string;
+    revision: number;
+    commandId: string;
+}>;
+export type RequestCancellationResult = Readonly<{
+    accepted: boolean;
+    reason?: "request_not_active" | "session_mismatch" | "cancellation_unavailable";
+}>;
+export declare function createRequestCancellationError(): Error;
+export declare function isRequestCancelled(signal: AbortSignal): boolean;
+export declare function throwIfRequestCancelled(signal: AbortSignal): void;

package/dist/src/runtime/request/cancellation.js

@@ -0,0 +1,14 @@
+/** User cancellation is a terminal control signal, never a model instruction. */
+export const REQUEST_CANCELLED = "request_cancelled";
+export function createRequestCancellationError() {
+    return new Error(REQUEST_CANCELLED);
+}
+export function isRequestCancelled(signal) {
+    return (signal.aborted &&
+        signal.reason instanceof Error &&
+        signal.reason.message === REQUEST_CANCELLED);
+}
+export function throwIfRequestCancelled(signal) {
+    if (isRequestCancelled(signal))
+        throw signal.reason;
+}

package/dist/src/runtime/request/capability-execution-freshness.d.ts

@@ -0,0 +1,8 @@
+import type { WorkerCapabilityExecutionFreshness } from "../orchestration/worker-capabilities/contracts.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+export declare function createRootExecutionFreshness(params: {
+    requestSteering: ReturnType<typeof resolveRequestSteeringInbox>;
+    steeringVersion: number;
+}): WorkerCapabilityExecutionFreshness;
+/** Rebind the persisted token itself after verifying the exact accepted steering prefix. */
+export declare function restoreApprovalExecutionFreshness(token: WorkerCapabilityExecutionFreshness["token"] | undefined, requestSteering: Parameters<typeof resolveRequestSteeringInbox>[0]): WorkerCapabilityExecutionFreshness | undefined;

package/dist/src/runtime/request/capability-execution-freshness.js

@@ -0,0 +1,28 @@
+import { isDeepStrictEqual } from "node:util";
+import { projectRequestSteeringSnapshot, resolveRequestSteeringInbox, } from "./request-steering.js";
+export function createRootExecutionFreshness(params) {
+    const snapshot = projectRequestSteeringSnapshot(params.requestSteering, params.steeringVersion);
+    return Object.freeze({
+        token: Object.freeze({
+            kind: "request_steering_v1",
+            version: snapshot.version,
+            updates: Object.freeze(snapshot.updates.map(({ sequence, text }) => Object.freeze({ sequence, text }))),
+        }),
+        isCurrent: () => params.requestSteering.isCurrent(snapshot.version),
+    });
+}
+/** Rebind the persisted token itself after verifying the exact accepted steering prefix. */
+export function restoreApprovalExecutionFreshness(token, requestSteering) {
+    if (token === undefined)
+        return undefined;
+    const inbox = resolveRequestSteeringInbox(requestSteering);
+    const current = createRootExecutionFreshness({
+        requestSteering: inbox,
+        steeringVersion: token.version,
+    });
+    if (!isDeepStrictEqual(current.token, token))
+        throw new Error("request_approval_steering_mismatch");
+    if (!current.isCurrent())
+        throw new Error("request_approval_steering_superseded");
+    return Object.freeze({ token, isCurrent: current.isCurrent });
+}

package/dist/src/runtime/request/contracts.d.ts

@@ -1,3 +1,6 @@
+import type { RequestToolResources } from "../capabilities/request-tool-resources.js";
+import type { CapabilityApprovalGate } from "../orchestration/worker-capabilities/approval-contracts.js";
+import type { RequestApprovalExecution } from "./approval-wait/snapshot.js";
 import type { ModelGatewayAttachment, ModelGatewayPolicyConfig, ModelPreference } from "../../model-gateway/types.js";
 import type { AgentMode } from "../../shared/types.js";
 import type { ScheduleMessageReference } from "../../sessions/schedule-metadata.js";
@@ -26,6 +29,12 @@ export type RunRequestMessage = {
     attachments?: unknown;
 };
 export type RequestHandlerOptions = {
+    /** Opted-in client; the managed owner supplies the trusted activation below. */
+    durableApprovals?: boolean;
+    approvalExecution?: RequestApprovalExecution;
+    abortSignal?: AbortSignal;
+    /** Synchronously close cancellation before final-response persistence starts. */
+    claimFinalization?: () => void;
     runtimeConfig?: RuntimeConfig;
     eventSinkFactory?: EventSinkFactory;
     modelGatewayClient?: ModelGatewayClient;
@@ -39,6 +48,10 @@ export type RequestHandlerOptions = {
 };
 /** Exact provider-free seed used to construct one request execution scope. */
 export type RequestExecutionSeed = Readonly<{
+    toolResources?: RequestToolResources;
+    approvalGate?: CapabilityApprovalGate;
+    /** Disambiguates model invocations across durable execution segments. */
+    modelInvocationScope?: string;
     requestId: string;
     sessionId: string;
     prompt: string;
@@ -94,6 +107,8 @@ export type RequestSessionSnapshot = Readonly<{
 }>;
 /** Model configuration and gateway selected once for this request. */
 export type RequestModelRuntime = Readonly<{
+    toolResources?: RequestExecutionSeed["toolResources"];
+    modelInvocationScope?: RequestExecutionSeed["modelInvocationScope"];
     runnerConfig: RequestExecutionSeed["runnerConfig"];
     modelPreference?: RequestExecutionSeed["modelPreference"];
     modelPolicy?: RequestExecutionSeed["modelPolicy"];
@@ -106,6 +121,7 @@ export type RequestMemoryRuntime = Readonly<{
 }>;
 /** Request-local cancellation, steering, capability controls, and events. */
 export type RequestLifecycleRuntime = Readonly<{
+    approvalGate?: RequestExecutionSeed["approvalGate"];
     requestSteering?: RequestExecutionSeed["requestSteering"];
     toolPermissionMode: RequestExecutionSeed["toolPermissionMode"];
     toolApprovalController?: RequestExecutionSeed["toolApprovalController"];
@@ -121,7 +137,7 @@ export type RequestPresentation = Readonly<{
     onAnswerToken: RequestExecutionSeed["onAnswerToken"];
 }>;
 /** The exact request-owned surface required by model invocation. */
-export type RequestModelInvocationView = Readonly<Pick<RequestExecutionSeed, "requestId" | "runnerConfig" | "agentMode" | "modelPreference" | "modelPolicy" | "modelGatewayClient" | "requestSteering" | "abortSignal" | "onThinkingDelta" | "onThinkingTrace">>;
+export type RequestModelInvocationView = Readonly<Pick<RequestExecutionSeed, "requestId" | "toolResources" | "modelInvocationScope" | "runnerConfig" | "agentMode" | "modelPreference" | "modelPolicy" | "modelGatewayClient" | "requestSteering" | "abortSignal" | "onThinkingDelta" | "onThinkingTrace">>;
 /**
  * Nominal marker for a request that already owns its single model-step port.
  * It is non-enumerable on canonical request views, so it cannot enter model or

package/dist/src/runtime/request/execution-facets.js

@@ -31,6 +31,10 @@ export function createRequestSeedFacets(seed) {
             : {}),
     });
     const model = Object.freeze({
+        ...(seed.toolResources ? { toolResources: seed.toolResources } : {}),
+        ...(seed.modelInvocationScope !== undefined
+            ? { modelInvocationScope: seed.modelInvocationScope }
+            : {}),
         runnerConfig: seed.runnerConfig,
         ...(seed.modelPreference !== undefined
             ? { modelPreference: seed.modelPreference }
@@ -49,6 +53,7 @@ export function createRequestSeedFacets(seed) {
             : {}),
     });
     const lifecycle = Object.freeze({
+        ...(seed.approvalGate ? { approvalGate: seed.approvalGate } : {}),
         ...(seed.requestSteering !== undefined
             ? { requestSteering: seed.requestSteering }
             : {}),
@@ -78,6 +83,14 @@ export function createRequestSeedFacets(seed) {
 }
 export function createModelInvocationView(facets) {
     return createFrozenSurface({
+        ...(facets.model.modelInvocationScope !== undefined
+            ? {
+                modelInvocationScope: enumerableGetter(() => facets.model.modelInvocationScope),
+            }
+            : {}),
+        ...(facets.model.toolResources
+            ? { toolResources: enumerableGetter(() => facets.model.toolResources) }
+            : {}),
         requestId: enumerableGetter(() => facets.identity.requestId),
         runnerConfig: enumerableGetter(() => facets.model.runnerConfig),
         agentMode: enumerableGetter(() => facets.input.agentMode),

package/dist/src/runtime/request/execution-scope-surfaces.js

@@ -3,6 +3,14 @@ import { createFrozenSurface, enumerableGetter, hiddenValue, } from "./immutable
 export const REQUEST_EXECUTION_SCOPE = Symbol("request_execution_scope");
 export function createCapabilityCompositionView(facets, modelSteps) {
     return createFrozenSurface({
+        ...(facets.model.modelInvocationScope !== undefined
+            ? {
+                modelInvocationScope: enumerableGetter(() => facets.model.modelInvocationScope),
+            }
+            : {}),
+        ...(facets.model.toolResources
+            ? { toolResources: enumerableGetter(() => facets.model.toolResources) }
+            : {}),
         requestId: enumerableGetter(() => facets.identity.requestId),
         runnerConfig: enumerableGetter(() => facets.model.runnerConfig),
         agentMode: enumerableGetter(() => facets.input.agentMode),
@@ -92,6 +100,17 @@ export function createScopeSurface(input) {
 }
 function requestSeedDescriptors(facets, executionPolicySelection, includeSessionArtifactPaths) {
     return {
+        ...(facets.lifecycle.approvalGate
+            ? { approvalGate: enumerableGetter(() => facets.lifecycle.approvalGate) }
+            : {}),
+        ...(facets.model.modelInvocationScope !== undefined
+            ? {
+                modelInvocationScope: enumerableGetter(() => facets.model.modelInvocationScope),
+            }
+            : {}),
+        ...(facets.model.toolResources
+            ? { toolResources: enumerableGetter(() => facets.model.toolResources) }
+            : {}),
         requestId: enumerableGetter(() => facets.identity.requestId),
         sessionId: enumerableGetter(() => facets.identity.sessionId),
         prompt: enumerableGetter(() => facets.input.prompt),

package/dist/src/runtime/request/handler.d.ts

@@ -1,3 +1,8 @@
 import type WebSocket from "ws";
 import type { RequestHandlerOptions, RunRequestMessage } from "./contracts.js";
-export declare function handleRunRequest(ws: WebSocket, msg: RunRequestMessage, options?: RequestHandlerOptions): Promise<void>;
+import type { SessionRequestLifecycleSnapshot } from "../../sessions/request-lifecycle/contracts.js";
+export type RequestHandlerOutcome = void | Readonly<{
+    kind: "awaiting_approval";
+    lifecycle: SessionRequestLifecycleSnapshot;
+}>;
+export declare function handleRunRequest(ws: WebSocket, msg: RunRequestMessage, options?: RequestHandlerOptions): Promise<RequestHandlerOutcome>;