@abot-ai/runtime 1.4.0 → 1.6.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" | "sessionKind" | "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,22 @@
+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,
+        sessionKind: seed.sessionKind,
+        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/approval-wait/super-compaction-restore.d.ts

@@ -0,0 +1,20 @@
+import type { CompiledRequestExecutionPolicy } from "../execution-scope.js";
+import type { RequestContextCompactionSnapshot } from "../../context/semantic-compaction/snapshot.js";
+import type { RoleCallLedgerCheckpoint } from "../../orchestration/role-calls/checkpoint.js";
+/** Compatibility must finish before approved effects or any model continuation. */
+export declare function restoreApprovalCompaction(params: {
+    snapshot: RequestContextCompactionSnapshot;
+    ledgerCheckpoint: RoleCallLedgerCheckpoint;
+    requestId: string;
+    prompt: string;
+    executionPolicy: CompiledRequestExecutionPolicy;
+}): Readonly<{
+    snapshot?(): RequestContextCompactionSnapshot;
+    get(scopeId: string): import("../../context/semantic-compaction/contracts.js").SemanticCompactionCheckpoint | undefined;
+    findByCallIds(callIds: readonly string[]): readonly import("../../context/semantic-compaction/contracts.js").SemanticCompactionCheckpoint[];
+    registerSources(sources: readonly import("../../context/semantic-compaction/contracts.js").SemanticCompactionSource[]): void;
+    registerSourcesAtomically?(sources: readonly import("../../context/semantic-compaction/contracts.js").SemanticCompactionSource[]): void;
+    quarantineScope?(record: import("../../context/semantic-compaction/scope-quarantine.js").InvalidatedCompactionScope): void;
+    materializeSource(sourceRef: string, sourceFingerprint: string): import("../../context/semantic-compaction/contracts.js").SemanticCompactionSource | undefined;
+    commit(checkpoint: import("../../context/semantic-compaction/contracts.js").SemanticCompactionCheckpoint): void;
+}>;

package/dist/src/runtime/request/approval-wait/super-compaction-restore.js

@@ -0,0 +1,61 @@
+import { createRoleCallLedger } from "../../orchestration/role-calls/index.js";
+import { hasSuperContextContract } from "../../context/super-context-policy.js";
+import { createOwnedSuperContextFailure } from "../../context/super-context-failure.js";
+import { restoreRequestContextCompaction } from "../../context/semantic-compaction/snapshot.js";
+import { assertSuperCompactionSourceIntegrity, assertSuperCompactionCheckpointIntegrity, assertSuperCompactionCheckpointBinding, } from "../../context/semantic-compaction/super-source-integrity.js";
+import { createRequestRoleCallPolicy } from "../role-call-policy.js";
+/** Compatibility must finish before approved effects or any model continuation. */
+export function restoreApprovalCompaction(params) {
+    const { snapshot, executionPolicy } = params;
+    if (!hasSuperContextContract(executionPolicy.authority, "supervisor"))
+        return restoreRequestContextCompaction(snapshot);
+    const ledger = createRoleCallLedger({
+        requestId: params.requestId,
+        policy: createRequestRoleCallPolicy(executionPolicy),
+        checkpoint: params.ledgerCheckpoint,
+    });
+    const head = ledger.current();
+    const call = head.state.calls.find((candidate) => candidate.callId === head.state.activeCallId);
+    if (!call)
+        throw new Error("context_compaction_snapshot_call_invalid");
+    try {
+        const store = restoreRequestContextCompaction(snapshot, {
+            restoreSuperQuarantine: true,
+        });
+        const input = {
+            requestId: params.requestId,
+            prompt: params.prompt,
+            head,
+            store,
+        };
+        assertSuperCompactionSourceIntegrity(input);
+        for (const record of snapshot.invalidatedScopes ?? [])
+            assertSuperCompactionCheckpointBinding({
+                ...input,
+                checkpoint: { ...record.binding, scopeId: record.scopeId },
+            });
+        for (const checkpoint of snapshot.checkpoints)
+            assertSuperCompactionCheckpointIntegrity({ ...input, checkpoint });
+        return store;
+    }
+    catch (cause) {
+        throw createOwnedSuperContextFailure({
+            code: "context_compaction_snapshot_source_incompatible",
+            head,
+            cause,
+            binding: {
+                requestId: params.requestId,
+                callId: call.callId,
+                parentCallId: call.parentCallId,
+                invocationAttempt: call.activationCount,
+                sourceRevision: head.revision,
+                contractId: call.roleId === "supervisor"
+                    ? "supervisor"
+                    : `delegated.${call.roleId}`,
+                modelStep: "context.compact",
+                phase: "approval_resume",
+                scopeId: `approval:${call.callId}`,
+            },
+        });
+    }
+}

package/dist/src/runtime/request/automation-output-contract.d.ts

@@ -0,0 +1,6 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../model-gateway/types.js";
+import type { ToolNormalInvocationInput } from "../../capabilities/normal-invocation/contracts.js";
+import type { RawModelValidationResult } from "../model/invoke-raw-step.js";
+/** Request-local, trusted terminal output contract; absent for ordinary chat. */
+export declare function automationResponseFormat(schema: ToolNormalInvocationInput | undefined): ModelGatewayJsonSchemaFormat | undefined;
+export declare function validateAutomationResponse(schema: ToolNormalInvocationInput, text: string): RawModelValidationResult;

package/dist/src/runtime/request/automation-output-contract.js

@@ -0,0 +1,33 @@
+import { validateJsonSchemaValue } from "../model/json-schema-value.js";
+/** Request-local, trusted terminal output contract; absent for ordinary chat. */
+export function automationResponseFormat(schema) {
+    if (!schema)
+        return undefined;
+    return {
+        type: "json_schema",
+        name: "automation_step_result",
+        strict: true,
+        schema,
+    };
+}
+export function validateAutomationResponse(schema, text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return invalid("automation_agent_output_invalid_json", "Return one JSON object only.");
+    }
+    const issue = validateJsonSchemaValue(schema, parsed);
+    if (issue)
+        return invalid("automation_agent_output_invalid_schema", issue.message);
+    return { ok: true, value: text };
+}
+function invalid(code, message) {
+    return {
+        ok: false,
+        stage: "response_contract",
+        issues: [{ code, path: "output", message }],
+        reason: code,
+    };
+}

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 });
+}