@botbotgo/agent-harness 0.0.251 → 0.0.252

package/dist/runtime/harness/run/stream-run.js

@@ -2,7 +2,7 @@ import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from ".
 import { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
 import { createContentBlocksItem, createToolResultKey, } from "../events/streaming.js";
-import { consumeRunInspectionUpstreamEvent, projectRuntimeSurfaceFromSingleUpstreamEvent } from "./inspection.js";
+import { projectRuntimeSurfaceFromSingleUpstreamEvent } from "./inspection.js";
 import { formatAgentName } from "../../../utils/agent-display.js";
 function normalizeStreamChunk(chunk) {
     if (typeof chunk === "string") {
@@ -73,44 +73,55 @@ export async function* streamHarnessRun(options) {
             const normalizedChunk = normalizeStreamChunk(rawChunk);
             if (normalizedChunk.kind === "upstream-event") {
                 upstreamEventOrdinal += 1;
+                const projectionBinding = options.getBinding(currentAgentId) ?? options.binding;
                 const surfaceProjection = projectRuntimeSurfaceFromSingleUpstreamEvent({
                     event: {
                         agentId: currentAgentId,
                         agentName: currentAgentName,
                         event: normalizedChunk.event,
                     },
-                    binding: options.binding,
+                    binding: projectionBinding,
                     currentAgentId,
                     currentAgentName,
-                    sourceEventId: `upstream:${upstreamEventOrdinal}`,
-                });
-                const inspection = consumeRunInspectionUpstreamEvent({
-                    event: normalizedChunk.event,
-                    currentAgentId,
                     delegationChain,
-                    binding: options.binding,
+                    sourceEventId: `upstream:${upstreamEventOrdinal}`,
                 });
-                currentAgentId = inspection.currentAgentId;
-                currentAgentName = formatAgentName(currentAgentId);
-                delegationChain = inspection.delegationChain;
+                currentAgentId = surfaceProjection.currentAgentId;
+                currentAgentName = surfaceProjection.currentAgentName;
+                delegationChain = surfaceProjection.delegationChain;
                 await options.updateRunInspection(options.threadId, options.runId, {
                     currentAgentId,
                     delegationChain,
-                    appendUpstreamEvent: {
+                });
+                if (surfaceProjection.items.length === 0) {
+                    await options.appendRunTraceItem(options.threadId, options.runId, {
                         agentId: currentAgentId,
                         agentName: currentAgentName,
                         event: normalizedChunk.event,
-                    },
-                });
-                yield {
-                    type: "upstream-event",
-                    threadId: options.threadId,
-                    runId: options.runId,
-                    agentId: currentAgentId,
-                    agentName: currentAgentName,
-                    surfaceItems: surfaceProjection.items,
-                    event: normalizedChunk.event,
-                };
+                    });
+                    yield {
+                        type: "upstream-event",
+                        threadId: options.threadId,
+                        runId: options.runId,
+                        event: normalizedChunk.event,
+                    };
+                    continue;
+                }
+                for (const surfaceItem of surfaceProjection.items) {
+                    await options.appendRunTraceItem(options.threadId, options.runId, {
+                        agentId: surfaceItem.agentId ?? currentAgentId,
+                        agentName: surfaceItem.agentName ?? currentAgentName,
+                        surfaceItem,
+                        event: normalizedChunk.event,
+                    });
+                    yield {
+                        type: "upstream-event",
+                        threadId: options.threadId,
+                        runId: options.runId,
+                        surfaceItem,
+                        event: normalizedChunk.event,
+                    };
+                }
                 continue;
             }
             nonUpstreamStreamActivityObserved = true;

package/dist/runtime/harness/run/surface-semantics.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledAgentBinding, RuntimeSurfaceKind } from "../../../contracts/types.js";
+export declare function normalizeSurfaceToken(value: string): string;
+export declare function buildSurfaceId(kind: RuntimeSurfaceKind, value: string): string;
+export declare function stripStepPrefix(label: string): string;
+export declare function resolveSurfaceDisplayName(input: {
+    kind: RuntimeSurfaceKind;
+    step: string;
+    binding?: CompiledAgentBinding;
+}): string;
+export declare function resolveSurfaceAction(input: {
+    kind: RuntimeSurfaceKind;
+    step?: string;
+    event?: unknown;
+}): string;

package/dist/runtime/harness/run/surface-semantics.js

@@ -0,0 +1,106 @@
+import { readSkillMetadata } from "../../support/skill-metadata.js";
+import { formatAgentName } from "../../../utils/agent-display.js";
+import { getBindingMemorySources, getBindingSkills, } from "../../support/compiled-binding.js";
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+function normalizeLabel(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function normalizeSurfaceToken(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80) || "item";
+}
+export function buildSurfaceId(kind, value) {
+    void kind;
+    return normalizeSurfaceToken(value);
+}
+export function stripStepPrefix(label) {
+    return normalizeLabel(label)
+        .replace(/^Calling LLM\s+/i, "")
+        .replace(/^Completed LLM\s+/i, "")
+        .replace(/^Calling tool\s+/i, "")
+        .replace(/^Completed tool\s+/i, "")
+        .replace(/^Tool\s+/i, "")
+        .replace(/\s+failed$/i, "")
+        .replace(/^Calling skill\s+/i, "")
+        .replace(/^Completed skill\s+/i, "")
+        .replace(/^Accessing memory\s+/i, "")
+        .replace(/^Completed memory\s+/i, "");
+}
+function isGenericMemoryMiddlewareName(value) {
+    return /^(memorymiddleware\.before[_\s]?agent|memory middleware before agent)$/i.test(normalizeLabel(value));
+}
+function canonicalMemoryName(memorySource) {
+    const normalized = normalizeLabel(memorySource.replace(/^memory\//i, ""));
+    const segments = normalized.split(/[\\/]/).filter(Boolean);
+    return (segments.at(-1) ?? normalized).toLowerCase() || "memory";
+}
+function isGenericSkillMiddlewareName(value) {
+    return /^(skillsmiddleware\.before[_\s]?agent|skills middleware before agent)$/i.test(normalizeLabel(value));
+}
+export function resolveSurfaceDisplayName(input) {
+    const baseName = stripStepPrefix(input.step) || formatAgentName(input.kind);
+    if (input.kind === "memory" && input.binding && isGenericMemoryMiddlewareName(baseName)) {
+        const memorySources = getBindingMemorySources(input.binding).filter((name) => name.trim().length > 0);
+        return memorySources.length === 1 ? canonicalMemoryName(memorySources[0]) : baseName;
+    }
+    if (input.kind !== "skill" || !input.binding || !isGenericSkillMiddlewareName(baseName)) {
+        return baseName;
+    }
+    const skillNames = getBindingSkills(input.binding)
+        .map((skillPath) => readSkillMetadata(skillPath).name)
+        .filter((name) => typeof name === "string" && name.trim().length > 0);
+    return skillNames.length === 1 ? skillNames[0] : baseName;
+}
+function normalizeActionHint(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[.:/]+/g, " ")
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function resolveMemoryAction(event, step) {
+    const typed = asObject(event);
+    const hints = [
+        typeof typed?.event === "string" ? typed.event : "",
+        typeof typed?.name === "string" ? typed.name : "",
+        typeof typed?.run_type === "string" ? typed.run_type : "",
+        ...readStringArray(typed?.tags),
+        ...readStringArray(typed?.ns),
+        step,
+    ].map(normalizeActionHint);
+    if (hints.some((value) => /\b(store|memorize|sync|formation|ingestion|archive|write)\b/.test(value))) {
+        return "memorize";
+    }
+    if (hints.some((value) => /\b(recall|retrieve|memorymiddleware|before agent|checkpoint|context)\b/.test(value)
+        || value.includes("accessing memory")
+        || value.includes("access memory"))) {
+        return "recall";
+    }
+    return "access";
+}
+export function resolveSurfaceAction(input) {
+    switch (input.kind) {
+        case "agent":
+            return "handoff";
+        case "llm":
+            return "call";
+        case "tool":
+            return "execute";
+        case "skill":
+            return "apply";
+        case "memory":
+            return resolveMemoryAction(input.event, input.step ?? "");
+        default:
+            return "run";
+    }
+}

package/dist/runtime/harness/run/thread-records.js

@@ -1,41 +1,13 @@
 import { isTerminalRunState, toInspectableApprovalRecord } from "./helpers.js";
 import { projectRuntimeTimeline } from "../events/timeline.js";
-import { createUpstreamTimelineReducer } from "../../../upstream-events.js";
-import { projectRuntimeSurfaceFromUpstreamEvents } from "./inspection.js";
-function unwrapPersistedUpstreamEvent(event) {
-    if (typeof event !== "object" || event === null || Array.isArray(event)) {
-        return event;
-    }
-    const typed = event;
-    if (Object.prototype.hasOwnProperty.call(typed, "event")
-        && typeof typed.event === "object"
-        && typed.event !== null
-        && !Array.isArray(typed.event)) {
-        return typed.event;
-    }
-    return event;
-}
 function selectLatestPendingApproval(approvals) {
     return approvals
         .filter((approval) => approval.status === "pending")
         .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
 }
-function buildRunInspectionProjection(upstreamEvents) {
-    const reducer = createUpstreamTimelineReducer();
-    const history = upstreamEvents.flatMap((event) => reducer.consume(unwrapPersistedUpstreamEvent(event)));
-    return {
-        upstreamEvents,
-        history,
-    };
-}
 export async function buildRequestInspectionRecord(persistence, request) {
     const inspection = await persistence.getRunInspection(request.threadId, request.runId);
     const runtimeEvents = await persistence.listRunEvents(request.threadId, request.runId);
-    const { upstreamEvents, history } = buildRunInspectionProjection(inspection.upstreamEvents);
-    const runtimeSurface = projectRuntimeSurfaceFromUpstreamEvents({
-        upstreamEvents,
-        initialAgentId: request.agentId ?? inspection.currentAgentId ?? "agent",
-    });
     return {
         requestId: request.runId,
         sessionId: request.threadId,
@@ -54,9 +26,7 @@ export async function buildRequestInspectionRecord(persistence, request) {
         currentAgentId: request.currentAgentId,
         delegationChain: request.delegationChain,
         runtimeSnapshot: request.runtimeSnapshot,
-        upstreamEvents,
-        history,
-        runtimeSurface,
+        traceItems: inspection.traceItems,
         runtimeTimeline: projectRuntimeTimeline(runtimeEvents, {
             threadId: request.threadId,
             runId: request.runId,
@@ -82,9 +52,7 @@ function toRunRecord(request) {
         currentAgentId: request.currentAgentId,
         delegationChain: request.delegationChain,
         runtimeSnapshot: request.runtimeSnapshot,
-        upstreamEvents: request.upstreamEvents,
-        history: request.history,
-        runtimeSurface: request.runtimeSurface,
+        traceItems: request.traceItems,
         runtimeTimeline: request.runtimeTimeline,
     };
 }

package/dist/runtime/harness/system/store.d.ts

@@ -51,8 +51,13 @@ export declare class FileBackedStore {
 }
 export declare class SqliteBackedStore {
     readonly filePath: string;
-    private readonly db;
+    private client;
+    private initialized;
+    private initialization;
     constructor(filePath: string);
+    private getClient;
+    private ensureInitialized;
+    private selectAll;
     batch(operations: Array<Record<string, unknown>>): Promise<readonly unknown[]>;
     get(namespace: string[], key: string): Promise<{
         value: unknown;
@@ -61,7 +66,6 @@ export declare class SqliteBackedStore {
         createdAt: Date;
         updatedAt: Date;
     } | null>;
-    private getSync;
     search(namespacePrefix: string[]): Promise<Array<{
         value: unknown;
         key: string;
@@ -71,9 +75,7 @@ export declare class SqliteBackedStore {
         score?: number;
     }>>;
     put(namespace: string[], key: string, value: Record<string, any>, _index?: false | string[]): Promise<void>;
-    private putSync;
     delete(namespace: string[], key: string): Promise<void>;
-    private deleteSync;
     listNamespaces(): Promise<string[][]>;
 }
 export declare function createInMemoryStore(): StoreLike;

package/dist/runtime/harness/system/store.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { mkdirSync } from "node:fs";
 import path from "node:path";
 import { InMemoryStore } from "@langchain/langgraph";
-import { loadBetterSqlite3 } from "../../support/sqlite-drivers.js";
+import { createClient } from "@libsql/client";
 const NAMESPACE_SEPARATOR = "\u001f";
 function encodeValue(value) {
     if (value instanceof Date) {
@@ -148,83 +148,117 @@ export class FileBackedStore {
 }
 export class SqliteBackedStore {
     filePath;
-    db;
+    client = null;
+    initialized = false;
+    initialization = null;
     constructor(filePath) {
         this.filePath = filePath;
         mkdirSync(path.dirname(filePath), { recursive: true });
-        const SqliteDatabase = loadBetterSqlite3();
-        this.db = new SqliteDatabase(filePath);
-        this.db.pragma("journal_mode = WAL");
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS store_entries (
-        namespace TEXT NOT NULL,
-        namespace_json TEXT NOT NULL,
-        key TEXT NOT NULL,
-        value_json TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL,
-        PRIMARY KEY (namespace, key)
-      );
-      CREATE INDEX IF NOT EXISTS idx_store_entries_namespace ON store_entries(namespace);
-    `);
+    }
+    async getClient() {
+        if (!this.client) {
+            this.client = createClient({ url: `file:${this.filePath}` });
+        }
+        return this.client;
+    }
+    async ensureInitialized() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.initialization) {
+            await this.initialization;
+            return;
+        }
+        this.initialization = (async () => {
+            const client = await this.getClient();
+            await client.execute("PRAGMA journal_mode=WAL");
+            await client.execute("PRAGMA foreign_keys=ON");
+            await client.execute("PRAGMA busy_timeout=5000");
+            await client.execute(`
+        CREATE TABLE IF NOT EXISTS store_entries (
+          namespace TEXT NOT NULL,
+          namespace_json TEXT NOT NULL,
+          key TEXT NOT NULL,
+          value_json TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (namespace, key)
+        )
+      `);
+            await client.execute("CREATE INDEX IF NOT EXISTS idx_store_entries_namespace ON store_entries(namespace)");
+            this.initialized = true;
+            this.initialization = null;
+        })();
+        await this.initialization;
+    }
+    async selectAll(sql, args = []) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        const result = await client.execute({ sql, args });
+        return result.rows;
     }
     async batch(operations) {
-        const results = this.db.transaction((items) => items.map((operation) => {
+        const results = [];
+        for (const operation of operations) {
             const namespace = Array.isArray(operation.namespace) ? operation.namespace.filter((item) => typeof item === "string") : [];
             const key = typeof operation.key === "string" ? operation.key : "";
             if ("value" in operation) {
-                this.putSync(namespace, key, operation.value);
-                return undefined;
+                await this.put(namespace, key, operation.value);
+                results.push(undefined);
+                continue;
             }
             if (operation.delete === true) {
-                this.deleteSync(namespace, key);
-                return undefined;
+                await this.delete(namespace, key);
+                results.push(undefined);
+                continue;
             }
-            return this.getSync(namespace, key);
-        }))(operations);
+            results.push(await this.get(namespace, key));
+        }
         return results;
     }
     async get(namespace, key) {
-        return this.getSync(namespace, key);
-    }
-    getSync(namespace, key) {
-        const row = this.db.prepare(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+        const rows = await this.selectAll(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
        FROM store_entries
-       WHERE namespace = ? AND key = ?`).get(serializeNamespace(namespace), key);
+       WHERE namespace = ? AND key = ?`, [serializeNamespace(namespace), key]);
+        const row = rows[0];
         return row ? parseRow(row) : null;
     }
     async search(namespacePrefix) {
         const prefix = serializeNamespace(namespacePrefix);
-        const rows = this.db.prepare(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+        const rows = await this.selectAll(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
        FROM store_entries
        WHERE namespace = ? OR namespace LIKE ?
-       ORDER BY namespace ASC, key ASC`).all(prefix, `${prefix}${NAMESPACE_SEPARATOR}%`);
+       ORDER BY namespace ASC, key ASC`, [prefix, `${prefix}${NAMESPACE_SEPARATOR}%`]);
         return rows.map((row) => parseRow(row));
     }
     async put(namespace, key, value, _index) {
-        this.putSync(namespace, key, value);
-    }
-    putSync(namespace, key, value) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
         const now = new Date().toISOString();
         const serializedNamespace = serializeNamespace(namespace);
         const encodedValue = JSON.stringify(encodeValue(value));
-        this.db.prepare(`INSERT INTO store_entries (namespace, namespace_json, key, value_json, created_at, updated_at)
+        await client.execute({
+            sql: `INSERT INTO store_entries (namespace, namespace_json, key, value_json, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(namespace, key) DO UPDATE SET
          namespace_json = excluded.namespace_json,
          value_json = excluded.value_json,
-         updated_at = excluded.updated_at`).run(serializedNamespace, JSON.stringify(namespace), key, encodedValue, now, now);
+         updated_at = excluded.updated_at`,
+            args: [serializedNamespace, JSON.stringify(namespace), key, encodedValue, now, now],
+        });
     }
     async delete(namespace, key) {
-        this.deleteSync(namespace, key);
-    }
-    deleteSync(namespace, key) {
-        this.db.prepare(`DELETE FROM store_entries WHERE namespace = ? AND key = ?`).run(serializeNamespace(namespace), key);
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        await client.execute({
+            sql: `DELETE FROM store_entries WHERE namespace = ? AND key = ?`,
+            args: [serializeNamespace(namespace), key],
+        });
     }
     async listNamespaces() {
-        const rows = this.db.prepare(`SELECT DISTINCT namespace_json
+        const rows = await this.selectAll(`SELECT DISTINCT namespace_json
        FROM store_entries
-       ORDER BY namespace ASC`).all();
+       ORDER BY namespace ASC`);
         return rows.map((row) => JSON.parse(row.namespace_json));
     }
 }

package/dist/runtime/harness.js

@@ -618,8 +618,7 @@ export class AgentHarnessRuntime {
                 currentAgentId: request.currentAgentId,
                 delegationChain: request.delegationChain,
                 runtimeSnapshot: request.runtimeSnapshot,
-                upstreamEvents: request.upstreamEvents,
-                history: request.history,
+                traceItems: request.traceItems,
                 runtimeTimeline: request.runtimeTimeline,
             }
             : null;
@@ -687,8 +686,7 @@ export class AgentHarnessRuntime {
                     currentAgentId: request.currentAgentId,
                     delegationChain: request.delegationChain,
                     runtimeSnapshot: request.runtimeSnapshot,
-                    upstreamEvents: request.upstreamEvents,
-                    history: request.history,
+                    traceItems: request.traceItems,
                     runtimeTimeline: request.runtimeTimeline,
                 })),
                 pendingDecision: session.pendingDecision,
@@ -1662,6 +1660,7 @@ export class AgentHarnessRuntime {
             isNewThread,
             runCreatedEventPromise,
             releaseRunSlotPromise,
+            getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
             loadPriorHistory: (threadId, runId) => this.loadPriorHistory(threadId, runId),
             stream: (binding, message, threadId, priorHistory, streamOptions) => this.runtimeAdapter.stream(binding, message, threadId, priorHistory, streamOptions),
             invokeWithHistory: (binding, input, threadId, runId) => this.invokeWithHistory(binding, input, threadId, runId),
@@ -1671,6 +1670,7 @@ export class AgentHarnessRuntime {
             appendAssistantMessage: (threadId, runId, content) => appendLifecycleAssistantMessage(this.persistence, threadId, runId, content),
             clearRunRequest: (threadId, runId) => this.persistence.clearRunRequest(threadId, runId),
             updateRunInspection: (threadId, runId, patch) => this.persistence.updateRunInspection(threadId, runId, patch),
+            appendRunTraceItem: (threadId, runId, item) => this.persistence.appendRunTraceItem(threadId, runId, item),
             emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
         });
         for await (const item of stream) {
@@ -1837,9 +1837,7 @@ function toSessionRecord(record) {
 function toRequestRecord(record) {
     return {
         ...toRequestSummary(record),
-        upstreamEvents: record.upstreamEvents,
-        history: record.history,
-        runtimeSurface: record.runtimeSurface,
+        traceItems: record.traceItems,
         runtimeTimeline: record.runtimeTimeline,
     };
 }

package/dist/runtime/maintenance/checkpoint-maintenance.js

@@ -1,9 +1,6 @@
 import path from "node:path";
-import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
-import { listProtectedCheckpointThreadIds } from "../../persistence/sqlite-store.js";
 import { fileExists } from "../../utils/fs.js";
 import { getRuntimeDefaults } from "../../workspace/support/workspace-ref-utils.js";
-import { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
 function asObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
@@ -72,128 +69,16 @@ export function discoverCheckpointMaintenanceTargets(workspace) {
     }
     return Array.from(deduped.values());
 }
-function backfillCheckpointMetadata(db, nowMs = Date.now()) {
-    db.exec(`
-CREATE TABLE IF NOT EXISTS checkpoint_maintenance_meta (
-  thread_id TEXT NOT NULL,
-  checkpoint_ns TEXT NOT NULL DEFAULT '',
-  checkpoint_id TEXT NOT NULL,
-  created_at_ms INTEGER NOT NULL,
-  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
-);`);
-    db.prepare(`INSERT OR IGNORE INTO checkpoint_maintenance_meta
-     (thread_id, checkpoint_ns, checkpoint_id, created_at_ms)
-     SELECT thread_id, checkpoint_ns, checkpoint_id, ?
-     FROM checkpoints`).run(nowMs);
-}
-function deleteCheckpointRows(db, rows) {
-    if (rows.length === 0) {
-        return 0;
-    }
-    const deleteCheckpoint = db.prepare(`DELETE FROM checkpoints
-     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
-    const deleteWrites = db.prepare(`DELETE FROM writes
-     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
-    const deleteMeta = db.prepare(`DELETE FROM checkpoint_maintenance_meta
-     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
-    db.transaction((items) => {
-        for (const row of items) {
-            deleteCheckpoint.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
-            deleteWrites.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
-            deleteMeta.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
-        }
-    })(rows);
-    return rows.length;
-}
-function selectOldestRows(db, limit) {
-    return db
-        .prepare(`SELECT
-         meta.thread_id,
-         meta.checkpoint_ns,
-         meta.checkpoint_id,
-         meta.created_at_ms,
-         COALESCE(LENGTH(cp.checkpoint), 0) + COALESCE(LENGTH(cp.metadata), 0) + COALESCE(SUM(LENGTH(w.value)), 0) AS size_bytes
-       FROM checkpoint_maintenance_meta AS meta
-       JOIN checkpoints AS cp
-         ON cp.thread_id = meta.thread_id
-        AND cp.checkpoint_ns = meta.checkpoint_ns
-        AND cp.checkpoint_id = meta.checkpoint_id
-       LEFT JOIN writes AS w
-         ON w.thread_id = meta.thread_id
-        AND w.checkpoint_ns = meta.checkpoint_ns
-        AND w.checkpoint_id = meta.checkpoint_id
-       GROUP BY meta.thread_id, meta.checkpoint_ns, meta.checkpoint_id, meta.created_at_ms, cp.checkpoint, cp.metadata
-       ORDER BY meta.created_at_ms ASC, meta.checkpoint_id ASC
-       LIMIT ?`)
-        .all(limit);
-}
-function totalCheckpointBytes(db) {
-    const checkpointsBytes = db
-        .prepare(`SELECT COALESCE(SUM(LENGTH(checkpoint) + LENGTH(metadata)), 0) AS total FROM checkpoints`)
-        .get();
-    const writesBytes = db
-        .prepare(`SELECT COALESCE(SUM(LENGTH(value)), 0) AS total FROM writes`)
-        .get();
-    return Number(checkpointsBytes.total ?? 0) + Number(writesBytes.total ?? 0);
-}
 export function maintainSqliteCheckpoints(dbPath, config, nowMs = Date.now()) {
     return maintainSqliteCheckpointsInternal(dbPath, config, nowMs);
 }
-async function maintainSqliteCheckpointsInternal(dbPath, config, nowMs) {
+async function maintainSqliteCheckpointsInternal(dbPath, config, _nowMs) {
     if (!(await fileExists(dbPath))) {
         return { deletedCount: 0 };
     }
-    const saver = new ManagedSqliteSaver(SqliteSaver.fromConnString(dbPath).db);
-    const db = saver.db;
-    try {
-        saver.prepareMaintenance();
-        backfillCheckpointMetadata(db, nowMs);
-        const protectedThreadIds = await listProtectedCheckpointThreadIds(path.join(path.dirname(dbPath), "runtime.sqlite"));
-        let deletedCount = 0;
-        if (config.policies.maxAgeSeconds !== undefined) {
-            const cutoffMs = nowMs - config.policies.maxAgeSeconds * 1000;
-            const expired = db
-                .prepare(`SELECT
-             meta.thread_id,
-             meta.checkpoint_ns,
-             meta.checkpoint_id,
-             meta.created_at_ms,
-             0 AS size_bytes
-           FROM checkpoint_maintenance_meta AS meta
-           WHERE meta.created_at_ms <= ?
-           ORDER BY meta.created_at_ms ASC, meta.checkpoint_id ASC
-           LIMIT ?`)
-                .all(cutoffMs, config.sqlite.sweepBatchSize * 4);
-            deletedCount += deleteCheckpointRows(db, expired.filter((row) => !protectedThreadIds.has(row.thread_id)).slice(0, config.sqlite.sweepBatchSize));
-        }
-        if (config.policies.maxBytes !== undefined) {
-            let currentBytes = totalCheckpointBytes(db);
-            while (currentBytes > config.policies.maxBytes) {
-                const oldest = selectOldestRows(db, config.sqlite.sweepBatchSize * 4).filter((row) => !protectedThreadIds.has(row.thread_id));
-                if (oldest.length === 0) {
-                    break;
-                }
-                let reclaimed = 0;
-                const toDelete = [];
-                for (const row of oldest) {
-                    toDelete.push(row);
-                    reclaimed += Number(row.size_bytes ?? 0);
-                    if (currentBytes - reclaimed <= config.policies.maxBytes) {
-                        break;
-                    }
-                }
-                deletedCount += deleteCheckpointRows(db, toDelete);
-                currentBytes = totalCheckpointBytes(db);
-            }
-        }
-        if (deletedCount > 0 && config.sqlite.vacuum) {
-            db.exec("VACUUM");
-        }
-        return { deletedCount };
-    }
-    finally {
-        db.close();
-    }
+    void config;
+    void path.dirname(dbPath);
+    throw new Error("Checkpoint maintenance for SqliteSaver is not supported in this runtime right now");
 }
 export class CheckpointMaintenanceLoop {
     targets;

package/dist/runtime/maintenance/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./checkpoint-maintenance.js";
 export * from "./file-checkpoint-saver.js";
 export * from "./runtime-record-maintenance.js";
-export * from "./sqlite-maintained-checkpoint-saver.js";