maka-agent 0.2.0-dev.22.20260905 → 0.2.0-dev.24.20260907

package/node_modules/@maka/storage/dist/context-offload-snapshot.js

@@ -0,0 +1,325 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { chmod, copyFile, lstat, mkdir, realpath } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { backup, DatabaseSync } from 'node:sqlite';
+import { isCanonicalStorageRef } from '@maka/core/events';
+import { discoverMarkedStorageRoot, runWithStorageRootLease, tryAcquireInteractiveRootOwner, } from './root-authority.js';
+import { migrateSqliteContextOffloadDatabase, SQLITE_CONTEXT_OFFLOAD_SCHEMA_VERSION, } from './sqlite-context-offload-schema.js';
+import { CONTEXT_OFFLOAD_DATABASE_NAME, CONTEXT_OFFLOAD_VALUES_DIRECTORY_NAME, } from './sqlite-context-offload-store.js';
+import { syncDirectoryChain, syncFile } from './stable-storage.js';
+import { SQLITE_SESSION_MESSAGE_CHUNK_MARKER } from './sqlite-session-metadata-schema.js';
+/**
+ * Existing artifact-only snapshots keep their old admission contract. Context
+ * snapshots require the root owner: a Session gate does not fence global GC.
+ * The callback must recheck absence before publishing an artifact-only snapshot.
+ */
+export async function withOfflineContextSnapshot(root, operation) {
+    if (!(await exists(join(root, CONTEXT_OFFLOAD_DATABASE_NAME))))
+        return operation(false);
+    const capability = await discoverMarkedStorageRoot({ path: root });
+    const owner = await tryAcquireInteractiveRootOwner(capability);
+    if (!owner)
+        throw new Error('Context snapshot requires an offline Storage Root; stop the Runtime Host first');
+    try {
+        return await runWithStorageRootLease(owner.lease, 'interactive', 'write', () => operation(true));
+    }
+    finally {
+        await owner.close();
+    }
+}
+/** Copies under the offline owner and the caller's Artifact lock; never mutates the source DB. */
+export async function copyContextSnapshot(sourceRoot, targetRoot, contextLocked, sessionId) {
+    const sourcePath = join(sourceRoot, CONTEXT_OFFLOAD_DATABASE_NAME);
+    if (!(await exists(sourcePath)))
+        return false;
+    if (!contextLocked)
+        throw new Error('Context storage appeared during snapshot; retry with the Runtime Host stopped');
+    await assertRegularPath(sourceRoot, CONTEXT_OFFLOAD_DATABASE_NAME);
+    const targetPath = join(targetRoot, CONTEXT_OFFLOAD_DATABASE_NAME);
+    const source = new DatabaseSync(sourcePath, { readOnly: true });
+    try {
+        await backup(source, targetPath);
+    }
+    finally {
+        source.close();
+    }
+    await chmod(targetPath, 0o600);
+    const target = new DatabaseSync(targetPath);
+    try {
+        target.exec('PRAGMA foreign_keys = ON');
+        migrateSqliteContextOffloadDatabase(target);
+        target.exec('BEGIN IMMEDIATE');
+        if (sessionId !== undefined)
+            target.prepare('DELETE FROM context_refs WHERE session_id <> ?').run(sessionId);
+        target.exec(`
+      DELETE FROM context_gc_candidates;
+      DELETE FROM context_file_deletions;
+      DELETE FROM context_blobs WHERE NOT EXISTS (
+        SELECT 1 FROM context_refs WHERE context_refs.blob_id = context_blobs.blob_id
+      );
+      DELETE FROM context_session_usage;
+      INSERT INTO context_session_usage
+        SELECT r.session_id, count(*), sum(b.size_bytes)
+        FROM context_refs r JOIN context_blobs b USING(blob_id) GROUP BY r.session_id;
+      UPDATE context_store_usage SET
+        blob_count = (SELECT count(*) FROM context_blobs),
+        physical_bytes = (SELECT coalesce(sum(size_bytes), 0) FROM context_blobs)
+      WHERE singleton = 1;
+      COMMIT;
+      PRAGMA journal_mode = DELETE;
+      VACUUM;
+    `);
+        // VACUUM on the private destination removes other Sessions' deleted bytes,
+        // including SQLite free pages. It is never run on the live source.
+        for (const row of target
+            .prepare("SELECT blob_id, payload, size_bytes FROM context_blobs WHERE storage_kind = 'managed_file'")
+            .iterate()) {
+            const path = managedPath(row.blob_id, row.payload);
+            await assertRegularPath(sourceRoot, path);
+            const destination = join(targetRoot, path);
+            await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
+            await copyFile(join(sourceRoot, path), destination);
+            await chmod(destination, 0o600);
+            await syncFile(destination);
+            await syncDirectoryChain(dirname(destination), targetRoot);
+        }
+    }
+    finally {
+        target.close();
+    }
+    await syncFile(targetPath);
+    await syncDirectoryChain(targetRoot, targetRoot);
+    return true;
+}
+export async function planContextSnapshotFiles(root, sessionId) {
+    const path = join(root, CONTEXT_OFFLOAD_DATABASE_NAME);
+    if (!(await exists(path)))
+        return [];
+    await assertRegularPath(root, CONTEXT_OFFLOAD_DATABASE_NAME);
+    const database = new DatabaseSync(path, { readOnly: true });
+    try {
+        const version = Number(database.prepare('PRAGMA user_version').get()?.user_version);
+        if (![1, 2, SQLITE_CONTEXT_OFFLOAD_SCHEMA_VERSION].includes(version))
+            throw new Error('Unsupported context snapshot schema');
+        const files = [CONTEXT_OFFLOAD_DATABASE_NAME];
+        if (version < 3)
+            return files;
+        for (const row of database
+            .prepare(`SELECT DISTINCT b.blob_id, b.payload FROM context_refs r
+      JOIN context_blobs b ON b.blob_id = r.blob_id
+      WHERE r.session_id = ? AND b.storage_kind = 'managed_file' ORDER BY b.blob_id`)
+            .iterate(sessionId)) {
+            const file = managedPath(row.blob_id, row.payload);
+            await assertRegularPath(root, file);
+            files.push(file);
+        }
+        return files;
+    }
+    finally {
+        database.close();
+    }
+}
+/** Verifies both payload integrity and typed ledger/message references before publication. */
+export async function validateContextSnapshot(root) {
+    let context;
+    const contextPath = join(root, CONTEXT_OFFLOAD_DATABASE_NAME);
+    try {
+        if (await exists(contextPath)) {
+            await assertRegularPath(root, CONTEXT_OFFLOAD_DATABASE_NAME);
+            context = new DatabaseSync(contextPath, { readOnly: true });
+            if (context.prepare('PRAGMA user_version').get()?.user_version !==
+                SQLITE_CONTEXT_OFFLOAD_SCHEMA_VERSION)
+                throw new Error('Unsupported context snapshot schema');
+            if (context.prepare('PRAGMA integrity_check').get()?.integrity_check !== 'ok' ||
+                context.prepare('PRAGMA foreign_key_check').get())
+                throw new Error('Invalid context snapshot database');
+            for (const row of context
+                .prepare('SELECT blob_id, storage_kind, payload, size_bytes FROM context_blobs')
+                .iterate()) {
+                const digest = blobHash(row.blob_id);
+                if (!Number.isSafeInteger(row.size_bytes) || Number(row.size_bytes) < 0)
+                    throw new Error('Invalid context snapshot size');
+                if (row.storage_kind === 'managed_file') {
+                    const path = managedPath(row.blob_id, row.payload);
+                    await assertRegularPath(root, path);
+                    const info = await lstat(join(root, path));
+                    if (info.size !== row.size_bytes || (await hashFile(join(root, path))) !== digest) {
+                        throw new Error('Context snapshot payload size/hash mismatch');
+                    }
+                }
+                else if (row.storage_kind !== 'inline' ||
+                    !(row.payload instanceof Uint8Array) ||
+                    row.payload.byteLength !== row.size_bytes ||
+                    createHash('sha256').update(row.payload).digest('hex') !== digest) {
+                    throw new Error('Context snapshot inline payload size/hash mismatch');
+                }
+            }
+            const actual = context
+                .prepare('SELECT count(*) AS n, coalesce(sum(size_bytes), 0) AS bytes FROM context_blobs')
+                .get();
+            const usage = context
+                .prepare('SELECT blob_count, physical_bytes FROM context_store_usage WHERE singleton = 1')
+                .get();
+            if (usage?.blob_count !== actual.n || usage.physical_bytes !== actual.bytes)
+                throw new Error('Context snapshot usage mismatch');
+            if (context
+                .prepare(`SELECT 1 FROM (
+        SELECT r.session_id, count(*) AS reference_count, sum(b.size_bytes) AS logical_bytes
+        FROM context_refs r JOIN context_blobs b USING(blob_id) GROUP BY r.session_id
+        EXCEPT SELECT session_id, reference_count, logical_bytes FROM context_session_usage
+      ) LIMIT 1`)
+                .get())
+                throw new Error('Context snapshot Session usage mismatch');
+        }
+        validateLedgerContextRefs(root, context);
+    }
+    finally {
+        context?.close();
+    }
+}
+function validateLedgerContextRefs(root, context) {
+    const runtime = new DatabaseSync(join(root, 'runtime.sqlite'), { readOnly: true });
+    const find = context?.prepare('SELECT 1 FROM context_refs WHERE session_id = ? AND ref_id = ?');
+    const check = (value, sessionId) => {
+        const ref = record(value);
+        if (ref.kind !== 'session_context')
+            return;
+        if (!isCanonicalStorageRef(value) ||
+            ref.sessionId !== sessionId ||
+            !find?.get(sessionId, String(ref.refId)))
+            throw new Error('Snapshot has a missing or cross-Session context reference');
+    };
+    const content = (value, sessionId) => {
+        const item = record(value);
+        if (item.kind === 'image')
+            check(item.ref, sessionId);
+    };
+    const attachments = (value, sessionId) => {
+        const item = record(value);
+        if (Array.isArray(item.attachments)) {
+            for (const attachment of item.attachments)
+                check(record(attachment).ref, sessionId);
+        }
+    };
+    const projection = (value, sessionId) => {
+        const item = record(value);
+        if (item.kind === 'content' && Array.isArray(item.parts)) {
+            for (const part of item.parts) {
+                const entry = record(part);
+                if (entry.kind === 'artifact')
+                    check(entry.ref, sessionId);
+            }
+        }
+    };
+    try {
+        for (const row of runtime
+            .prepare('SELECT session_id, payload_json FROM runtime_events')
+            .iterate()) {
+            const event = record(JSON.parse(String(row.payload_json)));
+            const item = record(event.content);
+            const sessionId = String(row.session_id);
+            if (item.kind === 'text')
+                attachments(item, sessionId);
+            if (item.kind === 'function_response') {
+                content(item.result, sessionId);
+                projection(item.modelProjection, sessionId);
+            }
+        }
+        for (const row of runtime
+            .prepare("SELECT session_id, record_json FROM core_agent_run_events WHERE event_type = 'model_projection_transition_recorded'")
+            .iterate()) {
+            const event = record(JSON.parse(String(row.record_json)));
+            projection(record(record(event.data).transition).replacement, String(row.session_id));
+        }
+        const chunks = runtime.prepare('SELECT data FROM session_message_chunks WHERE session_id = ? AND sequence = ? ORDER BY chunk_index');
+        for (const row of runtime
+            .prepare('SELECT session_id, sequence, record_json FROM session_messages')
+            .iterate()) {
+            const encoded = row.record_json === SQLITE_SESSION_MESSAGE_CHUNK_MARKER
+                ? Buffer.concat(chunks.all(row.session_id, row.sequence).map((chunk) => {
+                    if (!(chunk.data instanceof Uint8Array))
+                        throw new Error('Invalid snapshot message chunk');
+                    return Buffer.from(chunk.data);
+                })).toString('utf8')
+                : String(row.record_json);
+            const message = record(JSON.parse(encoded));
+            const sessionId = String(row.session_id);
+            if (message.type === 'user')
+                attachments(message, sessionId);
+            if (message.type === 'tool_result')
+                content(message.content, sessionId);
+        }
+    }
+    finally {
+        runtime.close();
+    }
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function blobHash(value) {
+    if (!(value instanceof Uint8Array) || value.byteLength !== 32)
+        throw new Error('Invalid context snapshot blob identity');
+    return Buffer.from(value).toString('hex');
+}
+function managedPath(blobId, payload) {
+    const digest = blobHash(blobId);
+    const expected = `sha256/${digest.slice(0, 2)}/${digest}`;
+    if (!(payload instanceof Uint8Array) || !Buffer.from(payload).equals(Buffer.from(expected))) {
+        throw new Error('Invalid context snapshot managed locator');
+    }
+    return `${CONTEXT_OFFLOAD_VALUES_DIRECTORY_NAME}/${expected}`;
+}
+async function assertRegularPath(root, relativePath) {
+    const canonical = await realpath(root);
+    const parts = relativePath.split('/');
+    let path = canonical;
+    for (const [index, part] of parts.entries()) {
+        path = join(path, part);
+        const info = await lstat(path);
+        if (info.isSymbolicLink() ||
+            (index === parts.length - 1 ? !info.isFile() : !info.isDirectory())) {
+            throw new Error('Context snapshot path must not contain symlinks or special files');
+        }
+    }
+    if ((await realpath(path)) !== resolve(canonical, relativePath))
+        throw new Error('Context snapshot path escaped its root');
+}
+async function hashFile(path) {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(path))
+        hash.update(chunk);
+    return hash.digest('hex');
+}
+async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}

package/node_modules/@maka/storage/dist/conversation-operational-state.js

@@ -67,6 +67,10 @@ class SqliteConversationOperationalStateStore {
             database
                 .prepare('DELETE FROM core_root_turn_start_rejections WHERE session_id = ?')
                 .run(sessionId);
+            // Cascades this run's events and the Usage projection's checkpoints.
+            // `usage_model_call_attempts` is deliberately absent from this list:
+            // deleting a conversation must not erase its spend from all-time Usage
+            // totals, so those rows outlive the authority they were projected from.
             database.prepare('DELETE FROM core_agent_runs WHERE session_id = ?').run(sessionId);
             database
                 .prepare('DELETE FROM core_client_capability_session_grants WHERE session_id = ?')

package/node_modules/@maka/storage/dist/execution-stores.js

@@ -29,7 +29,7 @@ const executionStoresReaderKinds = new WeakMap();
 const executionStoresWritersByLease = new WeakMap();
 const executionStoresWritersOpeningByLease = new WeakMap();
 export { normalizeRootTurnAdmissionPayload, rootTurnAdmissionRecordFits, } from './agent-run-store.js';
-export { isSessionNotFoundError, SessionReadMarkerMessageNotFoundError, } from './session-store.js';
+export { isSessionNotFoundError } from './session-store.js';
 export { SessionMetadataConflictError, SessionMetadataVersionConflictError, } from './sqlite-session-metadata-store.js';
 export { submittedTurnIntentsEqual } from './submitted-turn-intent.js';
 export function authenticateExecutionStoresWriter(stores, expectedKind) {
@@ -140,6 +140,7 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             readSandboxBoundaryRequest: (sessionId, requestId) => run(() => sessionStore.readSandboxBoundaryRequest(sessionId, requestId)),
             listPendingSandboxBoundaryRequests: (sessionId) => run(() => sessionStore.listPendingSandboxBoundaryRequests(sessionId)),
             listSandboxBoundaryRestartClosures: (sessionId) => run(() => sessionStore.listSandboxBoundaryRestartClosures(sessionId)),
+            hasExplicitSandboxBoundaryDenial: (identities) => run(() => sessionStore.hasExplicitSandboxBoundaryDenial(identities)),
             settleSandboxBoundaryRequest: (input) => run(() => sessionStore.settleSandboxBoundaryRequest(input)),
             setExecutionBoundaryKind: (sessionId, boundaryKind, projection) => run(() => sessionStore.setExecutionBoundaryKind(sessionId, boundaryKind, projection)),
             list: (filter) => run(() => sessionStore.list(filter)),
@@ -151,19 +152,16 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             readCatalogRecord: (sessionId) => run(() => sessionStore.readCatalogRecord(sessionId)),
             probeSessionRemoval: (sessionId) => run(() => sessionStore.probeSessionRemoval(sessionId)),
             readMessagesSnapshot: (sessionId) => run(() => sessionStore.readMessagesSnapshot(sessionId)),
-            readTranscriptPageSnapshot: (sessionId, request) => run(() => sessionStore.readTranscriptPageSnapshot(sessionId, request)),
-            readTranscriptRecordsSnapshot: (sessionId, request) => run(() => sessionStore.readTranscriptRecordsSnapshot(sessionId, request)),
             readTranscriptMessagesSnapshot: (sessionId, request) => run(() => sessionStore.readTranscriptMessagesSnapshot(sessionId, request)),
             readTranscriptHighWaterSnapshot: (sessionId) => run(() => sessionStore.readTranscriptHighWaterSnapshot(sessionId)),
-            readTurnContributionsSnapshot: (sessionId, throughSequence, position, maxContributions) => run(() => sessionStore.readTurnContributionsSnapshot(sessionId, throughSequence, position, maxContributions)),
-            readTurnLandmarksSnapshot: (sessionId, maxLandmarks) => run(() => sessionStore.readTurnLandmarksSnapshot(sessionId, maxLandmarks)),
-            readMessagesForRecovery: (sessionId) => run(() => sessionStore.readMessagesForRecovery(sessionId)),
             listTurnsSnapshot: (sessionId) => run(() => sessionStore.listTurnsSnapshot(sessionId)),
             readHeader: (sessionId) => run(() => sessionStore.readHeader(sessionId)),
             readMessages: (sessionId) => run(() => sessionStore.readMessages(sessionId)),
+            readMessagesAfter: (sessionId, request) => run(() => sessionStore.readMessagesAfter(sessionId, request)),
             listTurns: (sessionId) => run(() => sessionStore.listTurns(sessionId)),
             appendMessage: (sessionId, message) => run(() => sessionStore.appendMessage(sessionId, message)),
             appendMessages: (sessionId, messages) => run(() => sessionStore.appendMessages(sessionId, messages)),
+            commitMessageCatalogProjection: (sessionId, message) => run(() => sessionStore.commitMessageCatalogProjection(sessionId, message)),
             commitMessageAdmission: (admission) => run(() => sessionStore.commitMessageAdmission(admission)),
             readMessageAdmission: (sessionId, messageId) => run(() => sessionStore.readMessageAdmission(sessionId, messageId)),
             hasCancelledMessageAdmission: (sessionId, messageId) => run(() => sessionStore.hasCancelledMessageAdmission(sessionId, messageId)),
@@ -177,7 +175,6 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             updateHeader: (sessionId, patch) => run(() => sessionStore.updateHeader(sessionId, patch)),
             updateHeaderVersioned: (sessionId, patch, expectedRevision) => run(() => sessionStore.updateHeaderVersioned(sessionId, patch, expectedRevision)),
             updateSessionConfiguration: (sessionId, input) => run(() => sessionStore.updateSessionConfiguration(sessionId, input)),
-            markSessionReadThroughMessage: (sessionId, messageId) => run(() => sessionStore.markSessionReadThroughMessage(sessionId, messageId)),
             setFlagged: (sessionId, isFlagged) => run(() => sessionStore.setFlagged(sessionId, isFlagged)),
             rename: (sessionId, name) => run(() => sessionStore.rename(sessionId, name)),
             setGeneratedTitleIfAbsent: (sessionId, title) => run(() => sessionStore.setGeneratedTitleIfAbsent(sessionId, title)),
@@ -210,6 +207,7 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             repairEventProjection: (sessionId, type, event, options) => run(() => agentRunStore.repairEventProjection(sessionId, type, event, options)),
             admitRootTurn: (input) => run(() => agentRunStore.admitRootTurn(input)),
             readRootTurnAdmission: (sessionId, turnId) => run(() => agentRunStore.readRootTurnAdmission(sessionId, turnId)),
+            readRootTurnContinuationAdmission: (sessionId, sourceTurnId, sourceRunId) => run(() => agentRunStore.readRootTurnContinuationAdmission(sessionId, sourceTurnId, sourceRunId)),
             readRootTurnStartRejection: (sessionId, turnId) => run(() => agentRunStore.readRootTurnStartRejection(sessionId, turnId)),
             commitRootTurnStartRejection: (input) => run(() => agentRunStore.commitRootTurnStartRejection(input)),
             readRootTurnSourceMessageReceipt: (sessionId, sourceMessageId) => run(() => agentRunStore.readRootTurnSourceMessageReceipt(sessionId, sourceMessageId)),
@@ -235,6 +233,10 @@ async function createExecutionStoresForWrite(lease, kind, extension) {
             readInvocation: (sessionId, invocationId) => run(() => runtimeEventStore.readInvocation(sessionId, invocationId)),
             readSessionRuntimeEvents: (sessionId) => run(() => runtimeEventStore.readSessionRuntimeEvents(sessionId)),
             readSessionRuntimeEventEntries: (sessionId) => run(() => runtimeEventStore.readSessionRuntimeEventEntries(sessionId)),
+            resequenceSessionEventOrdinals: (sessionId) => run(() => runtimeEventStore.resequenceSessionEventOrdinals(sessionId)),
+            readTranscriptHighWater: (sessionId) => run(() => runtimeEventStore.readTranscriptHighWater(sessionId)),
+            readTranscriptInvocations: (sessionId, request) => run(() => runtimeEventStore.readTranscriptInvocations(sessionId, request)),
+            readTranscriptLandmarks: (sessionId, throughOrdinal, limit) => run(() => runtimeEventStore.readTranscriptLandmarks(sessionId, throughOrdinal, limit)),
             claimContinuation: (input) => run(() => runtimeEventStore.claimContinuation(input)),
             readContinuationClaimByBoundary: (boundaryDigest) => run(() => runtimeEventStore.readContinuationClaimByBoundary(boundaryDigest)),
             readContinuationClaimStateByBoundary: (boundaryDigest) => run(() => runtimeEventStore.readContinuationClaimStateByBoundary(boundaryDigest)),
@@ -302,6 +304,7 @@ async function openExecutionStoresForRead(lease, kind, extension) {
             readEventsByTypeBounded: (sessionId, runId, type, budget) => run(() => agentRunStore.readEventsByTypeBounded(sessionId, runId, type, budget)),
             readEventProjection: (sessionId, type) => run(() => agentRunStore.readEventProjection(sessionId, type)),
             readRootTurnAdmission: (sessionId, turnId) => run(() => agentRunStore.readRootTurnAdmission(sessionId, turnId)),
+            readRootTurnContinuationAdmission: (sessionId, sourceTurnId, sourceRunId) => run(() => agentRunStore.readRootTurnContinuationAdmission(sessionId, sourceTurnId, sourceRunId)),
             readRootTurnSourceMessageReceipt: (sessionId, sourceMessageId) => run(() => agentRunStore.readRootTurnSourceMessageReceipt(sessionId, sourceMessageId)),
         },
         runtimeEventStore: {
@@ -314,6 +317,7 @@ async function openExecutionStoresForRead(lease, kind, extension) {
             listSessionInvocationsPage: (sessionId, input) => run(() => runtimeEventStore.listSessionInvocationsPage(sessionId, input)),
             readInvocation: (sessionId, invocationId) => run(() => runtimeEventStore.readInvocation(sessionId, invocationId)),
             readSessionRuntimeEvents: (sessionId) => run(() => runtimeEventStore.readSessionRuntimeEvents(sessionId)),
+            readSessionRuntimeEventEntries: (sessionId) => run(() => runtimeEventStore.readSessionRuntimeEventEntries(sessionId)),
         },
     };
     freezeExecutionStoresFacade(stores);