@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/runtime/capabilities/request-module-preparation.js

@@ -1,7 +1,8 @@
 import { isDeepStrictEqual } from "node:util";
 import { validateToolModuleDeclarations } from "../../capabilities/tool-definition-validator.js";
+import { isNarrowedInputProperty } from "./request-property-narrowing.js";
 /** Config selection precedes observation. A plugin may narrow, never add authority. */
-export async function prepareRequestToolModules(modules) {
+export async function prepareRequestToolModules(modules, context) {
     const selectedModules = validateToolModuleDeclarations(modules);
     const groups = new Map();
     for (const module of selectedModules) {
@@ -14,7 +15,7 @@ export async function prepareRequestToolModules(modules) {
     const prepared = new Map();
     await Promise.all([...groups].map(async ([prepare, selected]) => {
         const inputs = Object.freeze(selected.map(captureSelectedModule));
-        const output = validateToolModuleDeclarations(await prepare(inputs));
+        const output = validateToolModuleDeclarations(await prepare(inputs, context));
         assertPreparedAuthorityIsNarrowed(selected, output);
         for (const module of output) {
             const { prepareRequest: _prepare, ...bound } = module;
@@ -89,14 +90,3 @@ function assertOperationAuthorityIsNarrowed(original, prepared) {
         }
     }
 }
-function isNarrowedInputProperty(original, prepared) {
-    if (!("enum" in original))
-        return isDeepStrictEqual(original, prepared);
-    if (!("enum" in prepared))
-        return false;
-    const { enum: originalValues, ...originalShape } = original;
-    const { enum: preparedValues, ...preparedShape } = prepared;
-    if (!isDeepStrictEqual(originalShape, preparedShape))
-        return false;
-    return preparedValues.every((value) => originalValues.includes(value));
-}

package/dist/src/runtime/capabilities/request-property-narrowing.d.ts

@@ -0,0 +1,3 @@
+import type { ToolNormalInvocationPropertyInput } from "../../capabilities/normal-invocation/contracts.js";
+/** Only provable subsets of the selected input authority may reach a request. */
+export declare function isNarrowedInputProperty(original: ToolNormalInvocationPropertyInput, prepared: ToolNormalInvocationPropertyInput): boolean;

package/dist/src/runtime/capabilities/request-property-narrowing.js

@@ -0,0 +1,20 @@
+import { isDeepStrictEqual } from "node:util";
+/** Only provable subsets of the selected input authority may reach a request. */
+export function isNarrowedInputProperty(original, prepared) {
+    if (isDeepStrictEqual(original, prepared))
+        return true;
+    if (!("enum" in prepared))
+        return false;
+    if ("enum" in original) {
+        return prepared.enum.every((value) => original.enum.includes(value));
+    }
+    if (original.type !== "string")
+        return false;
+    return prepared.enum.every((value) => {
+        if (value.length < original.minLength)
+            return false;
+        if ("maxLength" in original)
+            return value.length <= original.maxLength;
+        return true;
+    });
+}

package/dist/src/runtime/capabilities/request-tool-resources.d.ts

@@ -0,0 +1,33 @@
+import type { ToolRequestDisposer } from "../../capabilities/tool-media.js";
+import type { ToolRequestWork } from "../../capabilities/tool-request-resources.js";
+import { RequestToolMediaStore } from "../attachments/request-tool-media.js";
+import type { RequestToolMediaSnapshot } from "../attachments/request-tool-media-snapshot.js";
+export type RequestToolResourcesSnapshot = Readonly<{
+    kind: "request_tool_resources_v1";
+    media: RequestToolMediaSnapshot;
+    capsules: Readonly<Record<string, unknown>>;
+}>;
+/** Owns temporary tool resources and tracks effects beyond a tool's return. */
+export declare class RequestToolResources {
+    readonly media: RequestToolMediaStore;
+    private readonly stateOwner;
+    readonly state: Readonly<{
+        read(key: string): unknown;
+        register(key: string, codec: Readonly<{
+            snapshot(): unknown;
+            dispose?(): void | Promise<void>;
+        }>): void;
+    }>;
+    private readonly activeWork;
+    private readonly workListeners;
+    private readonly callbacks;
+    private disposal?;
+    readonly work: ToolRequestWork;
+    hasActiveWork(): boolean;
+    waitForQuiescence(signal?: AbortSignal): Promise<void>;
+    assertRestoredStateClaimed(): void;
+    snapshot(): RequestToolResourcesSnapshot;
+    restore(snapshot: RequestToolResourcesSnapshot): void;
+    readonly onRequestDispose: ToolRequestDisposer;
+    dispose(): Promise<void>;
+}

package/dist/src/runtime/capabilities/request-tool-resources.js

@@ -0,0 +1,92 @@
+import { RequestToolMediaStore } from "../attachments/request-tool-media.js";
+import { RequestToolState } from "./request-tool-state.js";
+/** Owns temporary tool resources and tracks effects beyond a tool's return. */
+export class RequestToolResources {
+    media = new RequestToolMediaStore();
+    stateOwner = new RequestToolState();
+    state = this.stateOwner.port;
+    activeWork = new Set();
+    workListeners = new Set();
+    callbacks = new Set();
+    disposal;
+    work = Object.freeze({
+        trackUntil: (settled) => {
+            if (this.disposal)
+                throw new Error("tool_request_resources_closed");
+            const observed = settled.then(() => undefined, () => undefined);
+            this.activeWork.add(observed);
+            void observed.then(() => {
+                this.activeWork.delete(observed);
+                if (!this.activeWork.size)
+                    for (const notify of this.workListeners)
+                        notify();
+            });
+        },
+    });
+    hasActiveWork() {
+        return this.activeWork.size > 0;
+    }
+    waitForQuiescence(signal) {
+        signal?.throwIfAborted();
+        if (!this.hasActiveWork())
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const clear = () => {
+                this.workListeners.delete(ready);
+                signal?.removeEventListener("abort", aborted);
+            };
+            const ready = () => {
+                if (!this.hasActiveWork()) {
+                    clear();
+                    resolve();
+                }
+            };
+            const aborted = () => {
+                clear();
+                reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+            };
+            this.workListeners.add(ready);
+            signal?.addEventListener("abort", aborted, { once: true });
+            ready();
+        });
+    }
+    assertRestoredStateClaimed() {
+        this.stateOwner.assertRestoredStateClaimed();
+    }
+    snapshot() {
+        if (this.disposal || this.hasActiveWork())
+            throw new Error("tool_request_resources_not_quiescent");
+        return Object.freeze({
+            kind: "request_tool_resources_v1",
+            media: this.media.snapshot(),
+            capsules: this.stateOwner.snapshot(),
+        });
+    }
+    restore(snapshot) {
+        if (this.disposal || snapshot?.kind !== "request_tool_resources_v1")
+            throw new Error("tool_request_resources_invalid");
+        this.media.restore(snapshot.media);
+        this.stateOwner.restore(snapshot.capsules);
+    }
+    onRequestDispose = (callback) => {
+        if (this.disposal) {
+            void Promise.resolve()
+                .then(callback)
+                .catch(() => { });
+            return;
+        }
+        this.callbacks.add(callback);
+    };
+    dispose() {
+        if (this.disposal)
+            return this.disposal;
+        this.media.dispose();
+        const callbacks = [...this.callbacks];
+        this.callbacks.clear();
+        this.disposal = Promise.allSettled([
+            this.stateOwner.dispose(),
+            ...callbacks.map((callback) => Promise.resolve().then(callback)),
+        ]).then(() => undefined);
+        return this.disposal;
+    }
+}

package/dist/src/runtime/capabilities/request-tool-state.d.ts

@@ -0,0 +1,13 @@
+import type { ToolRequestState } from "../../capabilities/tool-request-resources.js";
+/** Pending capsules remain data-only until an owning plugin registers its codec. */
+export declare class RequestToolState {
+    private readonly pending;
+    private readonly owners;
+    private closed;
+    readonly port: ToolRequestState;
+    snapshot(): Readonly<Record<string, unknown>>;
+    restore(value: unknown): void;
+    assertRestoredStateClaimed(): void;
+    dispose(): Promise<void>;
+    private assertOpen;
+}

package/dist/src/runtime/capabilities/request-tool-state.js

@@ -0,0 +1,75 @@
+/** Pending capsules remain data-only until an owning plugin registers its codec. */
+export class RequestToolState {
+    pending = new Map();
+    owners = new Map();
+    closed = false;
+    port = Object.freeze({
+        read: (key) => {
+            this.assertOpen();
+            return structuredClone(this.pending.get(key));
+        },
+        register: (key, codec) => {
+            this.assertOpen();
+            if (!key || this.owners.has(key))
+                throw new Error("tool_request_state_owner_conflict");
+            this.owners.set(key, codec);
+            this.pending.delete(key);
+        },
+    });
+    snapshot() {
+        this.assertOpen();
+        return Object.fromEntries([
+            ...this.pending,
+            ...[...this.owners].map(([key, codec]) => [key, captureJson(codec.snapshot())]),
+        ]);
+    }
+    restore(value) {
+        this.assertOpen();
+        if (!value ||
+            typeof value !== "object" ||
+            Array.isArray(value) ||
+            this.pending.size ||
+            this.owners.size)
+            throw new Error("tool_request_state_invalid");
+        for (const [key, entry] of Object.entries(value))
+            this.pending.set(key, captureJson(entry));
+    }
+    assertRestoredStateClaimed() {
+        if (this.pending.size)
+            throw new Error("tool_request_state_owner_unavailable");
+    }
+    async dispose() {
+        this.closed = true;
+        const owners = [...this.owners.values()];
+        this.pending.clear();
+        this.owners.clear();
+        await Promise.allSettled(owners.map((owner) => Promise.resolve().then(() => owner.dispose?.())));
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error("tool_request_state_closed");
+    }
+}
+function captureJson(value) {
+    const visit = (input, seen) => {
+        if (input === null ||
+            typeof input === "string" ||
+            typeof input === "boolean")
+            return;
+        if (typeof input === "number" && Number.isFinite(input))
+            return;
+        if (typeof input !== "object" || seen.has(input))
+            throw new Error("tool_request_state_not_serializable");
+        const prototype = Object.getPrototypeOf(input);
+        if (!Array.isArray(input) &&
+            prototype !== Object.prototype &&
+            prototype !== null)
+            throw new Error("tool_request_state_not_serializable");
+        seen.add(input);
+        for (const child of Object.values(input))
+            visit(child, seen);
+        seen.delete(input);
+    };
+    visit(value, new Set());
+    return structuredClone(value);
+}

package/dist/src/runtime/capabilities/scheduling/job-list-page.d.ts

@@ -11,7 +11,7 @@ export declare function createSchedulerJobPage(jobs: readonly SchedulerJob[], pa
         title: string;
         modelProfileId: string;
         agentMode: import("../../../shared/types.js").AgentMode;
-        toolPermissionMode: "full_access";
+        toolPermissionMode: import("../../scheduler/tool-permission-mode.js").SchedulerToolPermissionMode;
         timeZone: string;
         schedule: import("../../scheduler/contracts.js").SchedulerSchedule;
         state: import("../../scheduler/contracts.js").SchedulerJobState;

package/dist/src/runtime/composition.d.ts

@@ -8,6 +8,7 @@ import type { LongTermMemoryService } from "./long-term-memory/contracts.js";
 import type { SchedulerRun, SchedulerService } from "./scheduler/contracts.js";
 import { SessionRequestAdmission } from "./request/session-admission.js";
 import type { RequestSteeringAppendResult } from "./request/request-steering.js";
+import type { PassiveLearningService } from "./passive-learning/contracts.js";
 export type RuntimeEnvironmentServices = Readonly<{
     config: RuntimeConfig;
     sessions: SessionStore;
@@ -18,18 +19,20 @@ export type RuntimeEnvironmentServices = Readonly<{
     events: EventSinkFactory;
     sessionMemoryCompactor: SessionMemoryCompactor;
     longTermMemory: LongTermMemoryService;
+    passiveLearning?: PassiveLearningService;
     scheduler?: SchedulerService;
     startScheduler?: () => Promise<void>;
     stopScheduler?: () => Promise<void>;
     requestAdmission?: SessionRequestAdmission;
 }>;
-export type RuntimeRequestOptions = Pick<RequestHandlerOptions, "toolApprovalController" | "requestSteering">;
+export type RuntimeRequestOptions = Pick<RequestHandlerOptions, "toolApprovalController" | "requestSteering" | "abortSignal" | "claimFinalization" | "durableApprovals" | "approvalExecution">;
 export type RuntimeRequestHandler = Readonly<{
+    cancel?: (requestId: string, sessionId: string, wait?: import("./request/cancellation.js").SavedWaitCancellation) => Promise<import("./request/cancellation.js").RequestCancellationResult>;
     steer?: (requestId: string, input: Readonly<{
         steerId: string;
         text: string;
     }>) => Promise<RequestSteeringAppendResult>;
-    handle: (ws: WebSocket, message: RunRequestMessage, options?: RuntimeRequestOptions) => Promise<void>;
+    handle: (ws: WebSocket, message: RunRequestMessage, options?: RuntimeRequestOptions) => Promise<import("./request/handler.js").RequestHandlerOutcome>;
 }>;
 export type RuntimeApplication = Readonly<{
     services: RuntimeEnvironmentServices;
@@ -49,6 +52,7 @@ export type RuntimeDependencies = {
     events: EventSinkFactory;
     sessionMemoryCompactor: SessionMemoryCompactor;
     longTermMemory: LongTermMemoryService;
+    passiveLearning?: PassiveLearningService;
     scheduler?: SchedulerService;
     startScheduler?: () => Promise<void>;
     stopScheduler?: () => Promise<void>;

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

@@ -7,6 +7,8 @@ export type RequestHistoryMessage = Readonly<{
     createdAt: string;
     requestId?: string;
     grounding?: SessionMessageGrounding;
+    /** Trusted persisted assistant-origin turn; never supplied as current user intent. */
+    assistantInitiativeId?: string;
 }>;
 export type RequestContextBudget = Readonly<{
     contextWindowTokens: number;

package/dist/src/runtime/context/request-context.js

@@ -197,6 +197,10 @@ function collectConversationTurns(historyMessages) {
             turns.push(createConversationTurn(message));
             continue;
         }
+        if (message.assistantInitiativeId) {
+            turns.push({ source: [message], messages: [{ role: "assistant", content: message.content }] });
+            continue;
+        }
         const pendingTurn = findPendingConversationTurn(turns, message);
         if (!pendingTurn) {
             continue;
@@ -221,7 +225,7 @@ function createConversationTurn(user, assistant) {
     };
 }
 function findPendingConversationTurn(turns, assistant) {
-    const pendingTurns = turns.filter((turn) => turn.source.length === 1);
+    const pendingTurns = turns.filter((turn) => turn.source.length === 1 && turn.source[0]?.role === "user");
     if (assistant.requestId) {
         const exactMatch = findLastConversationTurn(pendingTurns, (turn) => turn.source[0]?.requestId === assistant.requestId);
         if (exactMatch) {

package/dist/src/runtime/context/semantic-compaction/snapshot.d.ts

@@ -0,0 +1,9 @@
+import type { SemanticCompactionCheckpoint, SemanticCompactionSource } from "./contracts.js";
+import { type RequestContextCompactionStore } from "./store.js";
+export type RequestContextCompactionSnapshot = Readonly<{
+    kind: "request_context_compaction_v1";
+    checkpoints: readonly SemanticCompactionCheckpoint[];
+    sources: readonly SemanticCompactionSource[];
+}>;
+export declare function captureRequestContextCompaction(store: RequestContextCompactionStore): RequestContextCompactionSnapshot;
+export declare function restoreRequestContextCompaction(snapshot: RequestContextCompactionSnapshot): RequestContextCompactionStore;

package/dist/src/runtime/context/semantic-compaction/snapshot.js

@@ -0,0 +1,20 @@
+import { createRequestContextCompactionStore, } from "./store.js";
+export function captureRequestContextCompaction(store) {
+    if (!store.snapshot)
+        throw new Error("context_compaction_snapshot_unavailable");
+    return store.snapshot();
+}
+export function restoreRequestContextCompaction(snapshot) {
+    if (snapshot?.kind !== "request_context_compaction_v1")
+        throw new Error("context_compaction_snapshot_invalid");
+    const store = createRequestContextCompactionStore();
+    store.registerSources(snapshot.sources);
+    for (const checkpoint of snapshot.checkpoints) {
+        for (const source of checkpoint.sourceDigests) {
+            if (!store.materializeSource(source.sourceRef, source.sourceFingerprint))
+                throw new Error("context_compaction_snapshot_source_missing");
+        }
+        store.commit(checkpoint);
+    }
+    return store;
+}

package/dist/src/runtime/context/semantic-compaction/store.d.ts

@@ -1,5 +1,7 @@
 import { SemanticCompactionCheckpoint, type SemanticCompactionSource } from "./contracts.js";
+import type { RequestContextCompactionSnapshot } from "./snapshot.js";
 export type RequestContextCompactionStore = Readonly<{
+    snapshot?(): RequestContextCompactionSnapshot;
     get(scopeId: string): SemanticCompactionCheckpoint | undefined;
     findByCallIds(callIds: readonly string[]): readonly SemanticCompactionCheckpoint[];
     registerSources(sources: readonly SemanticCompactionSource[]): void;

package/dist/src/runtime/context/semantic-compaction/store.js

@@ -3,6 +3,13 @@ export function createRequestContextCompactionStore() {
     const checkpoints = new Map();
     const sources = new Map();
     return Object.freeze({
+        snapshot() {
+            return Object.freeze({
+                kind: "request_context_compaction_v1",
+                checkpoints: Object.freeze([...checkpoints.values()]),
+                sources: Object.freeze([...sources.values()]),
+            });
+        },
         get(scopeId) {
             return checkpoints.get(scopeId);
         },

package/dist/src/runtime/context/session-memory/contracts.d.ts

@@ -4,6 +4,7 @@ import type { SessionRecord } from "../../../sessions/types.js";
 import type { SessionMemorySettledTurn } from "../../../sessions/memory/source.js";
 import type { RequestHistoryMessage } from "../request-context-contracts.js";
 import type { BoundRequestModelInvocationContext } from "../../request/contracts.js";
+import type { RequestSessionMemorySnapshot } from "./snapshot-state.js";
 export declare const SESSION_MEMORY_PROTECTED_TURN_COUNT = 10;
 export type SessionMemoryRequestProjection = Readonly<{
     priorConversationMessages: readonly ChatMessage[];
@@ -19,6 +20,7 @@ export type PreparedSessionMemoryCheckpoint = Readonly<{
     commit(): Promise<void>;
 }>;
 export type RequestSessionMemory = Readonly<{
+    snapshot?(): RequestSessionMemorySnapshot;
     project(): SessionMemoryRequestProjection;
     prepare(request: BoundRequestModelInvocationContext): Promise<PreparedSessionMemoryCheckpoint>;
 }>;
@@ -31,8 +33,11 @@ export type SessionMemoryCompactor = Readonly<{
 }>;
 export type CreateRequestSessionMemoryParams = Readonly<{
     sessionId: string;
-    session: SessionRecord;
     repository: SessionMemoryRepository;
     compactor: SessionMemoryCompactor;
     now?: () => Date;
-}>;
+}> & (Readonly<{
+    session: SessionRecord;
+}> | Readonly<{
+    snapshot: RequestSessionMemorySnapshot;
+}>);

package/dist/src/runtime/context/session-memory/controller.js

@@ -2,6 +2,7 @@ import { SESSION_MEMORY_CHECKPOINT_KIND, } from "../../../sessions/memory/contra
 import { assertValidSessionMemoryCheckpoint, resolveApplicableSessionMemoryCheckpoint, } from "../../../sessions/memory/rules.js";
 import { createSessionMemoryMessageReferences, resolveCoveredTurnCount, snapshotSessionMemorySource, } from "../../../sessions/memory/source.js";
 import { selectSessionMemoryProjection } from "./selection.js";
+import { validateRequestSessionMemorySnapshot, } from "./snapshot-state.js";
 export function createRequestSessionMemory(params) {
     return new RequestSessionMemoryController(params);
 }
@@ -13,11 +14,20 @@ class RequestSessionMemoryController {
     persistedCheckpointRevision;
     constructor(params) {
         this.params = params;
-        this.source = snapshotSessionMemorySource(params.session);
-        this.checkpoint = resolveApplicableSessionMemoryCheckpoint(params.session);
-        this.persistedCheckpointRevision = normalizeCheckpointRevision(params.session.sessionMemoryCheckpoint?.revision);
+        const state = resolveInitialSessionMemoryState(params);
+        this.source = state.source;
+        this.checkpoint = state.checkpoint;
+        this.persistedCheckpointRevision = state.persistedCheckpointRevision;
         this.now = params.now ?? (() => new Date());
     }
+    snapshot() {
+        return Object.freeze({
+            kind: "request_session_memory_v1",
+            source: this.source,
+            ...(this.checkpoint ? { checkpoint: this.checkpoint } : {}),
+            persistedCheckpointRevision: this.persistedCheckpointRevision,
+        });
+    }
     project() {
         return selectSessionMemoryProjection({
             sessionId: this.params.sessionId,
@@ -80,6 +90,17 @@ class RequestSessionMemoryController {
         });
     }
 }
+function resolveInitialSessionMemoryState(params) {
+    if ("snapshot" in params)
+        return validateRequestSessionMemorySnapshot(params.snapshot);
+    const checkpoint = resolveApplicableSessionMemoryCheckpoint(params.session);
+    return Object.freeze({
+        kind: "request_session_memory_v1",
+        source: snapshotSessionMemorySource(params.session),
+        ...(checkpoint ? { checkpoint } : {}),
+        persistedCheckpointRevision: normalizeCheckpointRevision(params.session.sessionMemoryCheckpoint?.revision),
+    });
+}
 function normalizeCheckpointRevision(revision) {
     if (revision === undefined ||
         !Number.isSafeInteger(revision) ||

package/dist/src/runtime/context/session-memory/selection.js

@@ -1,3 +1,4 @@
+import { isAssistantInitiativeMessage } from "../../../sessions/assistant-initiative.js";
 import { resolveCoveredTurnCount, } from "../../../sessions/memory/source.js";
 import { SESSION_MEMORY_PROTECTED_TURN_COUNT, } from "./contracts.js";
 import { buildSessionMemoryCheckpointMessage } from "./projection.js";
@@ -7,6 +8,12 @@ export function selectSessionMemoryProjection(params) {
         throw new Error("session_memory_checkpoint_coverage_invalid");
     }
     const uncoveredTurns = params.source.turns.slice(coveredTurnCount);
+    const uncoveredMessageIds = new Set(uncoveredTurns.flatMap(({ userMessages, assistant }) => [...userMessages, assistant].map(({ id }) => id)));
+    const historyMessages = params.source.historyMessages.filter(function retainsOriginalHistoryMessage(message) {
+        if (isAssistantInitiativeMessage(message))
+            return true;
+        return uncoveredMessageIds.has(message.id);
+    });
     const compactableTurnCount = Math.max(0, uncoveredTurns.length - SESSION_MEMORY_PROTECTED_TURN_COUNT);
     const priorConversationMessages = params.checkpoint
         ? Object.freeze([
@@ -15,10 +22,7 @@ export function selectSessionMemoryProjection(params) {
         : Object.freeze([]);
     return Object.freeze({
         priorConversationMessages,
-        historyMessages: Object.freeze(uncoveredTurns.flatMap(({ userMessages, assistant }) => [
-            ...userMessages.map(toRequestHistoryMessage),
-            toRequestHistoryMessage(assistant),
-        ])),
+        historyMessages: Object.freeze(historyMessages.map(toRequestHistoryMessage)),
         compactableTurnCount,
         checkpointRevision: params.checkpoint?.revision ?? 0,
         sourceRevision: params.source.sourceRevision,
@@ -31,5 +35,6 @@ function toRequestHistoryMessage(message) {
         content: message.content,
         createdAt: message.createdAt,
         ...(message.requestId ? { requestId: message.requestId } : {}),
+        ...(isAssistantInitiativeMessage(message) ? { assistantInitiativeId: message.initiative.proposalId } : {}),
     });
 }

package/dist/src/runtime/context/session-memory/snapshot-state.d.ts

@@ -0,0 +1,9 @@
+import type { SessionMemoryCheckpoint } from "../../../sessions/memory/contracts.js";
+import { type SessionMemorySourceSnapshot } from "../../../sessions/memory/source.js";
+export type RequestSessionMemorySnapshot = Readonly<{
+    kind: "request_session_memory_v1";
+    source: SessionMemorySourceSnapshot;
+    checkpoint?: SessionMemoryCheckpoint;
+    persistedCheckpointRevision: number;
+}>;
+export declare function validateRequestSessionMemorySnapshot(snapshot: RequestSessionMemorySnapshot): RequestSessionMemorySnapshot;

package/dist/src/runtime/context/session-memory/snapshot-state.js

@@ -0,0 +1,21 @@
+import { isDeepStrictEqual } from "node:util";
+import { assertValidSessionMemoryCheckpoint } from "../../../sessions/memory/rules.js";
+import { resolveCoveredTurnCount, snapshotSessionMemorySource, } from "../../../sessions/memory/source.js";
+export function validateRequestSessionMemorySnapshot(snapshot) {
+    if (snapshot?.kind !== "request_session_memory_v1")
+        throw new Error("session_memory_snapshot_invalid");
+    if (!Number.isSafeInteger(snapshot.persistedCheckpointRevision))
+        throw new Error("session_memory_snapshot_revision_invalid");
+    if (snapshot.persistedCheckpointRevision < 0)
+        throw new Error("session_memory_snapshot_revision_invalid");
+    const source = snapshotSessionMemorySource({
+        messages: [...snapshot.source.historyMessages],
+    });
+    if (!isDeepStrictEqual(source, snapshot.source))
+        throw new Error("session_memory_snapshot_source_invalid");
+    if (snapshot.checkpoint)
+        assertValidSessionMemoryCheckpoint(snapshot.checkpoint);
+    if (resolveCoveredTurnCount(source, snapshot.checkpoint) === undefined)
+        throw new Error("session_memory_snapshot_coverage_invalid");
+    return Object.freeze({ ...snapshot, source });
+}

package/dist/src/runtime/context/session-memory/snapshot.d.ts

@@ -0,0 +1,5 @@
+import type { CreateRequestSessionMemoryParams, RequestSessionMemory } from "./contracts.js";
+import type { RequestSessionMemorySnapshot } from "./snapshot-state.js";
+export type { RequestSessionMemorySnapshot } from "./snapshot-state.js";
+export declare function captureRequestSessionMemory(memory: RequestSessionMemory): RequestSessionMemorySnapshot;
+export declare function restoreRequestSessionMemory(snapshot: RequestSessionMemorySnapshot, params: Omit<CreateRequestSessionMemoryParams, "session" | "snapshot">): RequestSessionMemory;

package/dist/src/runtime/context/session-memory/snapshot.js

@@ -0,0 +1,9 @@
+import { createRequestSessionMemory } from "./controller.js";
+export function captureRequestSessionMemory(memory) {
+    if (!memory.snapshot)
+        throw new Error("session_memory_snapshot_unavailable");
+    return memory.snapshot();
+}
+export function restoreRequestSessionMemory(snapshot, params) {
+    return createRequestSessionMemory({ ...params, snapshot });
+}

package/dist/src/runtime/context/tool-media-projection.d.ts

@@ -0,0 +1,10 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { ModelStep } from "../../shared/model-steps.js";
+import type { RequestToolMediaStore } from "../attachments/request-tool-media.js";
+/** Hydrates only exact original evidence in the producing role's existing lane. */
+export declare function projectToolMediaMessages(params: {
+    messages: readonly ChatMessage[];
+    store?: RequestToolMediaStore;
+    modelStep: ModelStep;
+    supportsImages: boolean;
+}): ChatMessage[];