@ixo/oracle-runtime-workers 0.12.0 → 0.15.0

package/src/sqlite/page-tier.ts

@@ -71,11 +71,24 @@ export const DEFAULT_TIER_MAX_SEGMENTS_PER_PASS = 64;
  * with a clear error rather than thrashing the clean cache.
  */
 export const DEFAULT_TIER_MISS_PIN_BYTES = 32 * 1024 * 1024;
-/** Orphan sweep (list + delete unreferenced keys) every this many maintenance runs. */
-const ORPHAN_SWEEP_EVERY = 16;
+/**
+ * A complete orphan sweep (list the prefix, delete segment objects the map
+ * does not reference) at most this often. The time of the last complete
+ * sweep is persisted, so isolate restarts and object evictions do not
+ * postpone it. Orphans are rare (a crash between a segment upload and its
+ * map commit, a failed delete batch, deletes queued in memory by a
+ * truncate/import that never reached maintenance), so a weekly listing is
+ * enough: each sweep step is one R2 list (Class A).
+ */
+export const DEFAULT_TIER_ORPHAN_SWEEP_INTERVAL_MS = 7 * 24 * 60 * 60_000;
+/** Keys one sweep step lists (one R2 list page) — and so at most deletes. */
+const SWEEP_STEP_KEYS = 1000;
 /** R2 `delete()` accepts up to 1000 keys per call. */
 const R2_DELETE_BATCH = 1000;
 
+/** What `PageTier.maintenance` sweeps besides the queued deletes. */
+export type SweepStep = 'none' | 'step' | 'full';
+
 export interface PageTierOptions {
   bucket: R2Bucket;
   /** Key prefix owned by this object (the DO id string); everything under it is ours to delete. */
@@ -86,6 +99,8 @@ export interface PageTierOptions {
   maxSegmentsPerPass?: number;
   /** Cold bytes one statement/transaction may pin while it is retried (default 32 MiB). */
   missPinBytes?: number;
+  /** Minimum time between complete orphan sweeps (default 7 days). */
+  orphanSweepIntervalMs?: number;
   /** Clock, injectable for tests. */
   now?: () => number;
 }
@@ -98,6 +113,7 @@ export interface ResolvedPageTierOptions {
   evictAfterPeriods: number;
   maxSegmentsPerPass: number;
   missPinBytes: number;
+  orphanSweepIntervalMs: number;
   now: () => number;
 }
 
@@ -114,6 +130,8 @@ export function resolvePageTierOptions(
     maxSegmentsPerPass:
       options.maxSegmentsPerPass ?? DEFAULT_TIER_MAX_SEGMENTS_PER_PASS,
     missPinBytes: options.missPinBytes ?? DEFAULT_TIER_MISS_PIN_BYTES,
+    orphanSweepIntervalMs:
+      options.orphanSweepIntervalMs ?? DEFAULT_TIER_ORPHAN_SWEEP_INTERVAL_MS,
     now: options.now ?? (() => Date.now()),
   };
 }
@@ -152,6 +170,11 @@ interface AccessRow extends Record<string, SqlStorageValue> {
   bits: ArrayBuffer;
 }
 
+interface SweepRow extends Record<string, SqlStorageValue> {
+  last_complete_at: number | null;
+  after_key: string | null;
+}
+
 export function segmentOf(chunkno: number): number {
   return Math.floor(chunkno / SEGMENT_CHUNKS);
 }
@@ -197,7 +220,6 @@ export class PageTier {
   private readonly segments = new Map<string, Map<number, SegmentEntry>>();
   private schemaReady = false;
   private readonly pendingDeletes = new Set<string>();
-  private maintenanceRuns = 0;
   /** Tiny LRU of raw segment bytes for sequential readers (snapshot windows). */
   private readonly segmentCache = new Map<string, Uint8Array>();
   private static readonly SEGMENT_CACHE_ENTRIES = 2;
@@ -243,6 +265,11 @@ export class PageTier {
     this.storage.sql.exec(
       'CREATE TABLE IF NOT EXISTS vfs2_tier_meta (file TEXT PRIMARY KEY, max_gen INTEGER NOT NULL)',
     );
+    // Orphan sweep progress (one row): when the last complete sweep ended,
+    // and the last key a sweep still in progress has examined.
+    this.storage.sql.exec(
+      'CREATE TABLE IF NOT EXISTS vfs2_tier_sweep (id INTEGER PRIMARY KEY CHECK (id = 0), last_complete_at INTEGER, after_key TEXT)',
+    );
     this.schemaReady = true;
   }
 
@@ -474,17 +501,12 @@ export class PageTier {
   // R2 (async)
   // ---------------------------------------------------------------------------
 
-  /** The segment object bytes (exactly SEGMENT_BYTES, zero-padded), or null when the map has no entry. */
-  async getSegment(file: string, segno: number): Promise<Uint8Array | null> {
-    const entry = this.segmentsOf(file).get(segno);
-    if (entry === undefined) return null;
-    return this.getSegmentAt(file, segno, entry);
-  }
-
   /**
-   * The bytes of a specific generation of a segment — what a snapshot took
-   * at open time even if the map has moved on since (the old object is
-   * only deleted once no snapshot is open).
+   * The bytes (exactly SEGMENT_BYTES, zero-padded) of a specific generation
+   * of a segment — what a snapshot took at open time even if the map has
+   * moved on since (the old object is only deleted once no snapshot is
+   * open). Callers that need the CURRENT generation re-check the map after
+   * the await (see `DoVfs.currentSegment`).
    */
   async getSegmentAt(
     file: string,
@@ -543,13 +565,16 @@ export class PageTier {
   }
 
   /**
-   * Delete queued keys (objects the map no longer references) and, every
-   * `ORPHAN_SWEEP_EVERY` runs or when `sweep` is set, list the prefix and
-   * delete anything the map does not reference — the leftovers of a crash
-   * between a put and its map update. Never throws.
+   * Delete queued keys (objects the map no longer references), then sweep
+   * orphans: `'step'` examines one listing page of the prefix (continuing
+   * where the previous step stopped), `'full'` the whole prefix now. Only
+   * keys shaped like this tier's segment objects are ever swept — the
+   * prefix is shared with other users of the bucket (the result store
+   * keeps `<prefix>/results/…`). The CALLER guarantees no segment upload
+   * is in flight while a sweep runs (see `DoVfs`). Never throws.
    */
   async maintenance(
-    opts: { sweep?: boolean } = {},
+    opts: { sweep?: SweepStep } = {},
   ): Promise<{ deleted: number }> {
     let deleted = 0;
     const keys = Array.from(this.pendingDeletes);
@@ -562,13 +587,14 @@ export class PageTier {
         `[page-tier] delete of ${keys.length} object(s) failed: ${errorMessage(err)}`,
       );
     }
-    this.maintenanceRuns++;
-    if (
-      opts.sweep === true ||
-      this.maintenanceRuns % ORPHAN_SWEEP_EVERY === 0
-    ) {
+    const sweep = opts.sweep ?? 'none';
+    if (sweep !== 'none') {
       try {
-        deleted += await this.sweepOrphans();
+        for (;;) {
+          const step = await this.sweepStep(sweep === 'full');
+          deleted += step.deleted;
+          if (sweep === 'step' || step.complete) break;
+        }
       } catch (err) {
         console.warn(`[page-tier] orphan sweep failed: ${errorMessage(err)}`);
       }
@@ -577,6 +603,89 @@ export class PageTier {
     return { deleted };
   }
 
+  /**
+   * Whether a sweep step is due: one is in progress, or the last complete
+   * sweep is older than `orphanSweepIntervalMs` (or there never was one).
+   */
+  sweepDue(now = this.options.now()): boolean {
+    const state = this.sweepState();
+    if (state.after_key !== null) return true;
+    return (
+      state.last_complete_at === null ||
+      now - state.last_complete_at >= this.options.orphanSweepIntervalMs
+    );
+  }
+
+  private sweepState(): SweepRow {
+    this.ensureSchema();
+    return (
+      this.storage.sql
+        .exec<SweepRow>(
+          'SELECT last_complete_at, after_key FROM vfs2_tier_sweep WHERE id = 0',
+        )
+        .toArray()[0] ?? { last_complete_at: null, after_key: null }
+    );
+  }
+
+  /**
+   * One listing page of the prefix: delete the segment-shaped keys the map
+   * does not reference and persist how far the sweep got. `restart` starts
+   * from the beginning of the prefix (a full sweep).
+   */
+  private async sweepStep(
+    restart: boolean,
+  ): Promise<{ deleted: number; complete: boolean }> {
+    const afterKey = restart ? null : this.sweepState().after_key;
+    const page = await this.options.bucket.list({
+      prefix: `${this.options.prefix}/`,
+      limit: SWEEP_STEP_KEYS,
+      ...(afterKey !== null && { startAfter: afterKey }),
+    });
+    this.stats.r2Lists++;
+    // The map is read after the listing: a segment committed meanwhile is
+    // referenced by then (and uploads in flight are excluded by the caller).
+    const referenced = this.referencedKeys();
+    const orphans = page.objects
+      .map((object) => object.key)
+      .filter((key) => this.isSegmentKey(key) && !referenced.has(key));
+    const deleted = await this.deleteKeys(orphans);
+    const lastKey = page.objects.at(-1)?.key;
+    const complete = !page.truncated || lastKey === undefined;
+    if (complete) {
+      this.storage.sql.exec(
+        'INSERT INTO vfs2_tier_sweep (id, last_complete_at, after_key) VALUES (0, ?, NULL) ON CONFLICT(id) DO UPDATE SET last_complete_at = excluded.last_complete_at, after_key = NULL',
+        this.options.now(),
+      );
+    } else {
+      this.storage.sql.exec(
+        'INSERT INTO vfs2_tier_sweep (id, last_complete_at, after_key) VALUES (0, NULL, ?) ON CONFLICT(id) DO UPDATE SET after_key = excluded.after_key',
+        lastKey,
+      );
+    }
+    return { deleted, complete };
+  }
+
+  /** Keys of every segment object the map references, across files. */
+  private referencedKeys(): Set<string> {
+    this.ensureSchema();
+    const referenced = new Set<string>();
+    const rows = this.storage.sql
+      .exec<
+        SegmentRow & { file: string }
+      >('SELECT file, segno, gen, mask FROM vfs2_tier_segments')
+      .toArray();
+    for (const row of rows)
+      referenced.add(this.key(row.file, row.segno, row.gen));
+    return referenced;
+  }
+
+  /** `<prefix>/<file>/<segno>.<gen>` — the only keys a sweep may delete. */
+  private isSegmentKey(key: string): boolean {
+    const head = `${this.options.prefix}/`;
+    if (!key.startsWith(head)) return false;
+    return /^.+\/\d+\.\d+$/.test(key.slice(head.length));
+  }
+
   /** Every object under the prefix (keys). */
   async listKeys(): Promise<string[]> {
     const keys: string[] = [];
@@ -593,22 +702,6 @@ export class PageTier {
     return keys;
   }
 
-  private async sweepOrphans(): Promise<number> {
-    const referenced = new Set<string>();
-    this.ensureSchema();
-    const rows = this.storage.sql
-      .exec<
-        SegmentRow & { file: string }
-      >('SELECT file, segno, gen, mask FROM vfs2_tier_segments')
-      .toArray();
-    for (const row of rows)
-      referenced.add(this.key(row.file, row.segno, row.gen));
-    const orphans = (await this.listKeys()).filter(
-      (key) => !referenced.has(key),
-    );
-    return this.deleteKeys(orphans);
-  }
-
   /** Delete everything under the prefix (the object's working copy is being wiped). */
   async deleteAll(): Promise<number> {
     this.pendingDeletes.clear();

package/src/sqlite/serialization.ts

@@ -12,6 +12,20 @@
  * and LangGraph `Send` objects. `stringify` is fast-safe-stringify's
  * circular-safe variant, typed.
  */
+import { TURN_TIME_NOTE_KWARG } from '../core/turn-time-note';
+
+/**
+ * `additional_kwargs` key of the tool calls a mid-turn summary carries for
+ * the turn it condensed (core/middlewares/turn-boundary.ts).
+ */
+export const TURN_CARRY_KWARG = 'turn_carry';
+
+/**
+ * JSON characters of a carry kept on a stored message. Each carried result
+ * is already cut short by the summarizer; the cap bounds how many calls a
+ * long turn can pile onto one row. The newest calls are kept.
+ */
+export const TURN_CARRY_MAX_CHARS = 64 * 1024;
 
 type Replacer = (this: unknown, key: string, value: unknown) => unknown;
 
@@ -243,6 +257,10 @@ export interface CleanAdditionalKwargs {
   oracleName: string;
   /** Provenance marker set by LangChain middlewares (e.g. `"summarization"`). */
   lc_source?: string;
+  /** The exact time note the turn's content starts with (see core/turn-time-note.ts). */
+  turn_time_note?: string;
+  /** Tool calls of the turn a mid-turn summary condensed (newest kept, capped). */
+  turn_carry?: unknown[];
   reasoning?: string;
   reasoningDetails?: ReasoningDetail[];
   attachment?: AttachmentMeta;
@@ -302,6 +320,21 @@ function extractReasoning(additionalKwargs: Record<string, unknown>): {
     : { reasoning };
 }
 
+/** The newest entries of a carry list whose JSON fits `TURN_CARRY_MAX_CHARS`. */
+function cappedTurnCarry(value: unknown): unknown[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const kept: unknown[] = [];
+  let chars = 2; // the brackets
+  for (let i = value.length - 1; i >= 0; i--) {
+    const entry: unknown = value[i];
+    const size = (JSON.stringify(entry) ?? '').length + (kept.length ? 1 : 0);
+    if (chars + size > TURN_CARRY_MAX_CHARS) break;
+    chars += size;
+    kept.unshift(entry);
+  }
+  return kept;
+}
+
 /**
  * Reduce a message's `additional_kwargs` to the persisted allowlist. An
  * existing `timestamp` is preserved: every checkpoint `put` rewrites every
@@ -324,6 +357,13 @@ export function cleanAdditionalKwargs(
   };
   if (typeof additionalKwargs.lc_source === 'string')
     cleaned.lc_source = additionalKwargs.lc_source;
+  // Kept so readers can take the note off the stored content again.
+  const turnTimeNote = additionalKwargs[TURN_TIME_NOTE_KWARG];
+  if (typeof turnTimeNote === 'string')
+    cleaned[TURN_TIME_NOTE_KWARG] = turnTimeNote;
+  // Kept so a run resumed after the summary still knows what this turn ran.
+  const carry = cappedTurnCarry(additionalKwargs[TURN_CARRY_KWARG]);
+  if (carry !== undefined) cleaned[TURN_CARRY_KWARG] = carry;
   if (isAttachmentMeta(additionalKwargs.attachment))
     cleaned.attachment = additionalKwargs.attachment;
   if (

package/src/sqlite/sessions-store.ts

@@ -201,15 +201,23 @@ export class SessionsStore {
       params.push(excludeIdPrefix.length, excludeIdPrefix);
     }
     const where = clauses.length ? `WHERE ${clauses.join(' AND ')}` : '';
-    params.push(limit, offset);
     const rows = await this.db.exec<SessionRowWithTotal>(
       `SELECT ${SESSION_COLUMNS}, COUNT(*) OVER() AS total
        FROM sessions ${where}
        ORDER BY last_updated_at DESC, rowid DESC
        LIMIT ? OFFSET ?`,
+      [...params, limit, offset],
+    );
+    const first = rows[0];
+    if (first !== undefined)
+      return { sessions: rows.map(rowToSession), total: first.total };
+    // A page past the last row carries no window count: count separately.
+    if (offset <= 0) return { sessions: [], total: 0 };
+    const count = await this.db.get<{ n: number }>(
+      `SELECT COUNT(*) AS n FROM sessions ${where}`,
       params,
     );
-    return { sessions: rows.map(rowToSession), total: rows[0]?.total ?? 0 };
+    return { sessions: [], total: Number(count?.n ?? 0) };
   }
 
   async getSession(sessionId: string): Promise<SessionRecord | undefined> {

package/src/sqlite/sqlite-saver.ts

@@ -19,6 +19,7 @@
  * - `channel_values.messages` is stripped from the stored checkpoint and each
  *   message is upserted into `messages` (keyed by message id, so the table is
  *   the full transcript: rows survive checkpoint pruning and summarization).
+ *   An unchanged message keeps its row in place (see `writeMessageRows`).
  * - `put` prunes a thread to `maxCheckpointsPerThread` newest checkpoints (and
  *   their writes) once it exceeds the cap by `PRUNE_SLACK`.
  * - `pending_sends` migration for pre-v4 checkpoints.
@@ -39,6 +40,7 @@ import {
   type CheckpointMetadata,
   type CheckpointTuple,
   copyCheckpoint,
+  emptyCheckpoint,
   maxChannelVersion,
   type PendingWrite,
   type SerializerProtocol,
@@ -78,6 +80,9 @@ export const PRUNE_SLACK = 5;
 
 const DEFAULT_ORACLE_NAME = 'IXO Oracle';
 
+/** Position of `message_id` in the parameter rows `toMessageRow` returns. */
+const MESSAGE_ID_COLUMN = 3;
+
 type CheckpointRow = {
   thread_id: string;
   checkpoint_ns: string;
@@ -137,7 +142,12 @@ interface CheckpointWithMessages extends Checkpoint {
  * Compile-time guard: the metadata keys `list()` accepts as filters must stay
  * in sync with `CheckpointMetadata`. If this stops compiling, update the list.
  */
-const checkpointMetadataKeys = ['source', 'step', 'parents'] as const;
+const checkpointMetadataKeys = [
+  'source',
+  'step',
+  'parents',
+  'counters_since_delta_snapshot',
+] as const;
 type MetadataKey = keyof CheckpointMetadata;
 type CheckKeys<K extends readonly MetadataKey[]> = [MetadataKey] extends [
   K[number],
@@ -176,7 +186,23 @@ const migration001: Migration = {
   },
 };
 
-const MIGRATIONS: readonly Migration[] = [migration001];
+/**
+ * Migration 002: drop `idx_messages_thread_id` and `idx_messages_checkpoint_id`.
+ * No query uses them — every `messages` query filters on `thread_id` (served
+ * by `idx_messages_thread_created` / `idx_messages_lookup`, whose leading
+ * column it is) or looks a row up by `message_id` — yet every message write
+ * updated both b-trees.
+ */
+const migration002: Migration = {
+  version: 2,
+  name: 'drop_unused_message_indexes',
+  up: async (db) => {
+    await db.run('DROP INDEX IF EXISTS idx_messages_thread_id');
+    await db.run('DROP INDEX IF EXISTS idx_messages_checkpoint_id');
+  },
+};
+
+const MIGRATIONS: readonly Migration[] = [migration001, migration002];
 
 // `writes.value` blobs may be gzipped, so they travel as hex() — a
 // CAST(... AS TEXT) of compressed bytes would mangle them irreversibly.
@@ -228,6 +254,17 @@ export class SqliteSaver extends BaseCheckpointSaver {
   protected readonly maxCheckpointsPerThread: number;
   protected readonly oracleName: string;
   private setupPromise: Promise<void> | undefined;
+  /**
+   * The stored blob of each message object last encoded, with the JSON it
+   * was compressed from. LangGraph hands the same message objects to every
+   * `put` of a run; one whose JSON is unchanged reuses its blob instead of
+   * running a gzip pipeline again. The JSON itself is always recomputed —
+   * it is what proves the object did not change.
+   */
+  private readonly encoded = new WeakMap<
+    BaseMessage,
+    { json: string; blob: Uint8Array }
+  >();
 
   constructor(
     db: DoSqliteDatabase,
@@ -298,12 +335,6 @@ export class SqliteSaver extends BaseCheckpointSaver {
         PRIMARY KEY (message_id)
       )`);
     await this.runMigrations();
-    await db.run(
-      `CREATE INDEX IF NOT EXISTS idx_messages_thread_id ON messages(thread_id)`,
-    );
-    await db.run(
-      `CREATE INDEX IF NOT EXISTS idx_messages_checkpoint_id ON messages(checkpoint_id)`,
-    );
     await db.run(
       `CREATE INDEX IF NOT EXISTS idx_messages_lookup ON messages(thread_id, checkpoint_ns, checkpoint_id)`,
     );
@@ -637,8 +668,10 @@ export class SqliteSaver extends BaseCheckpointSaver {
     checkpointNs: string,
     checkpointId: string,
   ): Promise<BaseMessage[]> {
+    // Rowid order is the order of the checkpoint's message array (see
+    // `writeMessageRows`); the lookup index already yields it, no sort.
     const rows = await this.db.exec<MessageRow>(
-      'SELECT message FROM messages WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?',
+      'SELECT message FROM messages WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ? ORDER BY rowid',
       [threadId, checkpointNs, checkpointId],
     );
     return Promise.all(rows.map((row) => this.loadMessage(row.message)));
@@ -696,6 +729,39 @@ export class SqliteSaver extends BaseCheckpointSaver {
     }
   }
 
+  /** Append a deterministic turn without running or replacing pending graph work. */
+  async appendTurnMessages(
+    threadId: string,
+    messages: BaseMessage[],
+  ): Promise<void> {
+    const config = { configurable: { thread_id: threadId } };
+    const existing = await this.getTupleWithoutMessages(config);
+    if (!existing) {
+      const checkpoint = emptyCheckpoint();
+      checkpoint.channel_values.messages = messages;
+      await this.put(config, checkpoint, {
+        source: 'update',
+        step: -1,
+        parents: {},
+      });
+      return;
+    }
+    const rows = await Promise.all(
+      messages.map((message) =>
+        this.toMessageRow(message, threadId, '', existing.checkpoint.id),
+      ),
+    );
+    await this.db.transaction(async () => {
+      for (const row of rows) {
+        await this.db.run(
+          `INSERT OR IGNORE INTO messages (thread_id, checkpoint_ns, checkpoint_id, message_id, message_type, message_content, message, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+          row,
+        );
+      }
+    });
+  }
+
   async put(
     config: RunnableConfig,
     checkpointIn: Checkpoint,
@@ -748,13 +814,7 @@ export class SqliteSaver extends BaseCheckpointSaver {
           serializedMetadata,
         ],
       );
-      for (const row of messageRows) {
-        await this.db.run(
-          `INSERT OR REPLACE INTO messages (thread_id, checkpoint_ns, checkpoint_id, message_id, message_type, message_content, message, created_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-          row,
-        );
-      }
+      await this.writeMessageRows(messageRows);
     });
 
     await this.pruneThread(threadId, checkpointNs);
@@ -768,6 +828,60 @@ export class SqliteSaver extends BaseCheckpointSaver {
     };
   }
 
+  /**
+   * Upsert a checkpoint's message rows (in array order). A checkpoint's
+   * messages are read back in rowid order (`loadCheckpointMessages`), so
+   * rowids must increase along the array. A message whose row exists keeps
+   * it — updated in place, which leaves the pages whose bytes did not
+   * change untouched — as long as that holds; from the first message that
+   * is new or would break the order (a summary placed before the history
+   * it kept) on, every row is written with `INSERT OR REPLACE`, which
+   * gives it a new rowid after all others, exactly as every row used to be.
+   * Inside the caller's transaction.
+   */
+  private async writeMessageRows(rows: SqlParam[][]): Promise<void> {
+    if (rows.length === 0) return;
+    const ids = rows.map((row) => row[MESSAGE_ID_COLUMN]);
+    const existing = new Map<string, number>();
+    for (const row of await this.db.exec<{
+      message_id: string;
+      rowid: number;
+    }>(
+      'SELECT m.message_id, m.rowid FROM json_each(?) AS j JOIN messages AS m ON m.message_id = j.value',
+      [JSON.stringify(ids)],
+    ))
+      existing.set(row.message_id, row.rowid);
+    let lastRowid = -1;
+    let appending = false;
+    for (const row of rows) {
+      const id = row[MESSAGE_ID_COLUMN];
+      const rowid = typeof id === 'string' ? existing.get(id) : undefined;
+      if (!appending && rowid !== undefined && rowid > lastRowid) {
+        await this.db.run(
+          `INSERT INTO messages (thread_id, checkpoint_ns, checkpoint_id, message_id, message_type, message_content, message, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(message_id) DO UPDATE SET
+             thread_id = excluded.thread_id,
+             checkpoint_ns = excluded.checkpoint_ns,
+             checkpoint_id = excluded.checkpoint_id,
+             message_type = excluded.message_type,
+             message_content = excluded.message_content,
+             message = excluded.message,
+             created_at = excluded.created_at`,
+          row,
+        );
+        lastRowid = rowid;
+        continue;
+      }
+      appending = true;
+      await this.db.run(
+        `INSERT OR REPLACE INTO messages (thread_id, checkpoint_ns, checkpoint_id, message_id, message_type, message_content, message, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        row,
+      );
+    }
+  }
+
   /** Normalize a message's `additional_kwargs` and serialize it exactly as the Node runtime does. */
   private async toMessageRow(
     message: BaseMessage,
@@ -798,9 +912,15 @@ export class SqliteSaver extends BaseCheckpointSaver {
     }
     message.additional_kwargs = merged;
 
-    const serialized = await compressForStorage(
-      stringify(message, (_key, value) => _default(value)),
-    );
+    const json = stringify(message, (_key, value) => _default(value));
+    const cached = this.encoded.get(message);
+    let serialized: Uint8Array;
+    if (cached !== undefined && cached.json === json) {
+      serialized = cached.blob;
+    } else {
+      serialized = await compressForStorage(json);
+      this.encoded.set(message, { json, blob: serialized });
+    }
     const messageId =
       message.id ??
       (typeof message.lc_kwargs.id === 'string'