zen-code 4.6.2 → 4.7.0

package/dist/{checkpoint-1sAx_j1E-DMtqyBT9.mjs → checkpoint-C5AFBYE--BbnaceZj.mjs}

@@ -1,35 +1,60 @@
-import { Kysely as T, sql as r } from "kysely";
-import { B as f, T as l, c as y, m } from "./app-Cynj004J.mjs";
-import "./graphBuilder-mpLrx9tk.mjs";
-const g = ["source", "step", "parents"];
-const E = g;
-class w extends f {
+import { Kysely as m, sql as d } from "kysely";
+import { B as b, T as l, c as E, m as g } from "./app-CcnStH9S.mjs";
+import "./graphBuilder-skVEY6RJ.mjs";
+const u = {
+  maxRetries: 3,
+  baseDelayMs: 100,
+  isRetryableError: (w) => {
+    const e = w?.message?.toLowerCase() || "";
+    return e.includes("sqlite_busy") || e.includes("database is locked") || e.includes("database disk image is malformed") || e === "sqlite_busy" || e === "database is locked";
+  }
+};
+async function T(w, e) {
+  let i = null;
+  for (let n = 0; n < u.maxRetries; n++)
+    try {
+      return await w();
+    } catch (a) {
+      if (i = a, !u.isRetryableError(a))
+        throw a;
+      if (n < u.maxRetries - 1) {
+        const c = u.baseDelayMs * Math.pow(2, n);
+        console.warn(
+          `SQLite lock detected${e ? ` (${e})` : ""}, retrying in ${c}ms (attempt ${n + 1}/${u.maxRetries})`
+        ), await new Promise((t) => setTimeout(t, c));
+      }
+    }
+  throw i;
+}
+const A = ["source", "step", "parents"];
+const N = A;
+class f extends b {
   db;
   isSetup;
-  constructor(e, n) {
-    super(n), this.db = new T({
+  constructor(e, i) {
+    super(i), this.db = new m({
       dialect: e
     }), this.isSetup = !1;
   }
   static async fromConnStringAsync(e) {
-    let n;
+    let i;
     if (globalThis.Bun) {
       console.log("LG | Using BunWorkerDialect " + e);
-      const { BunWorkerDialect: o } = await import("kysely-bun-worker");
-      n = new w(new o({ url: e }));
+      const { BunWorkerDialect: n } = await import("kysely-bun-worker");
+      i = new f(new n({ url: e }));
     } else {
       console.log("LG | Using NodeWasmDialect");
-      const { default: o } = await import("node-sqlite3-wasm"), { NodeWasmDialect: s } = await import("kysely-wasm");
+      const { default: n } = await import("node-sqlite3-wasm"), { NodeWasmDialect: a } = await import("kysely-wasm");
       console.log(e);
-      const a = new s({
-        database: new o.Database(e)
+      const c = new a({
+        database: new n.Database(e)
       });
-      n = new w(a);
+      i = new f(c);
     }
-    return await n.setup(), n;
+    return await i.setup(), i;
   }
   async setup() {
-    this.isSetup || (await r`PRAGMA journal_mode = WAL`.execute(this.db), await r`
+    this.isSetup || (await d`PRAGMA busy_timeout = 5000`.execute(this.db), await d`PRAGMA journal_mode = WAL`.execute(this.db), await d`PRAGMA synchronous = NORMAL`.execute(this.db), await d`PRAGMA wal_autocheckpoint = 1000`.execute(this.db), await d`
 CREATE TABLE IF NOT EXISTS checkpoints (
   thread_id TEXT NOT NULL,
   checkpoint_ns TEXT NOT NULL DEFAULT '',
@@ -39,7 +64,7 @@ CREATE TABLE IF NOT EXISTS checkpoints (
   checkpoint BLOB,
   metadata BLOB,
   PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
-)`.execute(this.db), await r`
+)`.execute(this.db), await d`
 CREATE TABLE IF NOT EXISTS writes (
   thread_id TEXT NOT NULL,
   checkpoint_ns TEXT NOT NULL DEFAULT '',
@@ -54,8 +79,8 @@ CREATE TABLE IF NOT EXISTS writes (
   }
   async getTuple(e) {
     await this.setup();
-    const { thread_id: n, checkpoint_ns: o = "", checkpoint_id: s } = e.configurable ?? {};
-    let a = this.db.selectFrom("checkpoints").select([
+    const { thread_id: i, checkpoint_ns: n = "", checkpoint_id: a } = e.configurable ?? {};
+    let c = this.db.selectFrom("checkpoints").select([
       "thread_id",
       "checkpoint_ns",
       "checkpoint_id",
@@ -63,7 +88,7 @@ CREATE TABLE IF NOT EXISTS writes (
       "type",
       "checkpoint",
       "metadata",
-      r`(
+      d`(
                     SELECT json_group_array(
                         json_object(
                             'task_id', pw.task_id,
@@ -77,7 +102,7 @@ CREATE TABLE IF NOT EXISTS writes (
                         AND pw.checkpoint_ns = checkpoints.checkpoint_ns
                         AND pw.checkpoint_id = checkpoints.checkpoint_id
                 )`.as("pending_writes"),
-      r`(
+      d`(
                     SELECT json_group_array(
                         json_object(
                             'type', ps.type,
@@ -91,20 +116,20 @@ CREATE TABLE IF NOT EXISTS writes (
                         AND ps.channel = ${l}
                     ORDER BY ps.idx
                 )`.as("pending_sends")
-    ]).where("thread_id", "=", n).where("checkpoint_ns", "=", o);
-    s ? a = a.where("checkpoint_id", "=", s) : a = a.orderBy("checkpoint_id", "desc").limit(1);
-    const t = await a.executeTakeFirst();
+    ]).where("thread_id", "=", i).where("checkpoint_ns", "=", n);
+    a ? c = c.where("checkpoint_id", "=", a) : c = c.orderBy("checkpoint_id", "desc").limit(1);
+    const t = await c.executeTakeFirst();
     if (!t) return;
-    let d = e;
-    if (s || (d = {
+    let r = e;
+    if (a || (r = {
       configurable: {
         thread_id: t.thread_id,
-        checkpoint_ns: o,
+        checkpoint_ns: n,
         checkpoint_id: t.checkpoint_id
       }
-    }), d.configurable?.thread_id === void 0 || d.configurable?.checkpoint_id === void 0)
+    }), r.configurable?.thread_id === void 0 || r.configurable?.checkpoint_id === void 0)
       throw new Error("Missing thread_id or checkpoint_id");
-    const c = await Promise.all(
+    const s = await Promise.all(
       JSON.parse(t.pending_writes).map(async (h) => [
         h.task_id,
         h.channel,
@@ -116,7 +141,7 @@ CREATE TABLE IF NOT EXISTS writes (
     );
     return p.v < 4 && t.parent_checkpoint_id != null && await this.migratePendingSends(p, t.thread_id, t.parent_checkpoint_id), {
       checkpoint: p,
-      config: d,
+      config: r,
       metadata: await this.serde.loadsTyped(
         t.type ?? "json",
         new TextDecoder().decode(t.metadata)
@@ -124,18 +149,18 @@ CREATE TABLE IF NOT EXISTS writes (
       parentConfig: t.parent_checkpoint_id ? {
         configurable: {
           thread_id: t.thread_id,
-          checkpoint_ns: o,
+          checkpoint_ns: n,
           checkpoint_id: t.parent_checkpoint_id
         }
       } : void 0,
-      pendingWrites: c
+      pendingWrites: s
     };
   }
-  async *list(e, n) {
-    const { limit: o, before: s, filter: a } = n ?? {};
+  async *list(e, i) {
+    const { limit: n, before: a, filter: c } = i ?? {};
     await this.setup();
-    const t = e.configurable?.thread_id, d = e.configurable?.checkpoint_ns;
-    let c = this.db.selectFrom("checkpoints").select([
+    const t = e.configurable?.thread_id, r = e.configurable?.checkpoint_ns;
+    let s = this.db.selectFrom("checkpoints").select([
       "thread_id",
       "checkpoint_ns",
       "checkpoint_id",
@@ -143,7 +168,7 @@ CREATE TABLE IF NOT EXISTS writes (
       "type",
       "checkpoint",
       "metadata",
-      r`(
+      d`(
                     SELECT json_group_array(
                         json_object(
                             'task_id', pw.task_id,
@@ -157,7 +182,7 @@ CREATE TABLE IF NOT EXISTS writes (
                         AND pw.checkpoint_ns = checkpoints.checkpoint_ns
                         AND pw.checkpoint_id = checkpoints.checkpoint_id
                 )`.as("pending_writes"),
-      r`(
+      d`(
                     SELECT json_group_array(
                         json_object(
                             'type', ps.type,
@@ -172,147 +197,159 @@ CREATE TABLE IF NOT EXISTS writes (
                     ORDER BY ps.idx
                 )`.as("pending_sends")
     ]);
-    t && (c = c.where("thread_id", "=", t)), d != null && (c = c.where("checkpoint_ns", "=", d)), s?.configurable?.checkpoint_id !== void 0 && (c = c.where("checkpoint_id", "<", s.configurable.checkpoint_id));
+    t && (s = s.where("thread_id", "=", t)), r != null && (s = s.where("checkpoint_ns", "=", r)), a?.configurable?.checkpoint_id !== void 0 && (s = s.where("checkpoint_id", "<", a.configurable.checkpoint_id));
     const p = Object.fromEntries(
-      Object.entries(a ?? {}).filter(
-        ([i, _]) => _ !== void 0 && E.includes(i)
+      Object.entries(c ?? {}).filter(
+        ([o, _]) => _ !== void 0 && N.includes(o)
       )
     );
-    for (const [i, _] of Object.entries(p))
-      c = c.where(
-        r`json_extract(CAST(metadata AS TEXT), ${r.lit("$." + i)})`,
+    for (const [o, _] of Object.entries(p))
+      s = s.where(
+        d`json_extract(CAST(metadata AS TEXT), ${d.lit("$." + o)})`,
         "=",
-        r.lit(JSON.stringify(_))
+        d.lit(JSON.stringify(_))
       );
-    c = c.orderBy("checkpoint_id", "desc"), o && (c = c.limit(parseInt(o, 10)));
-    const h = await c.execute();
-    for (const i of h) {
+    s = s.orderBy("checkpoint_id", "desc"), n && (s = s.limit(parseInt(n, 10)));
+    const h = await s.execute();
+    for (const o of h) {
       const _ = await Promise.all(
-        JSON.parse(i.pending_writes).map(async (k) => [
+        JSON.parse(o.pending_writes).map(async (k) => [
           k.task_id,
           k.channel,
           await this.serde.loadsTyped(k.type ?? "json", k.value ?? "")
         ])
-      ), u = await this.serde.loadsTyped(
-        i.type ?? "json",
-        new TextDecoder().decode(i.checkpoint)
+      ), y = await this.serde.loadsTyped(
+        o.type ?? "json",
+        new TextDecoder().decode(o.checkpoint)
       );
-      u.v < 4 && i.parent_checkpoint_id != null && await this.migratePendingSends(u, i.thread_id, i.parent_checkpoint_id), yield {
+      y.v < 4 && o.parent_checkpoint_id != null && await this.migratePendingSends(y, o.thread_id, o.parent_checkpoint_id), yield {
         config: {
           configurable: {
-            thread_id: i.thread_id,
-            checkpoint_ns: i.checkpoint_ns,
-            checkpoint_id: i.checkpoint_id
+            thread_id: o.thread_id,
+            checkpoint_ns: o.checkpoint_ns,
+            checkpoint_id: o.checkpoint_id
           }
         },
-        checkpoint: u,
+        checkpoint: y,
         metadata: await this.serde.loadsTyped(
-          i.type ?? "json",
-          new TextDecoder().decode(i.metadata)
+          o.type ?? "json",
+          new TextDecoder().decode(o.metadata)
         ),
-        parentConfig: i.parent_checkpoint_id ? {
+        parentConfig: o.parent_checkpoint_id ? {
           configurable: {
-            thread_id: i.thread_id,
-            checkpoint_ns: i.checkpoint_ns,
-            checkpoint_id: i.parent_checkpoint_id
+            thread_id: o.thread_id,
+            checkpoint_ns: o.checkpoint_ns,
+            checkpoint_id: o.parent_checkpoint_id
           }
         } : void 0,
         pendingWrites: _
       };
     }
   }
-  async put(e, n, o) {
+  async put(e, i, n) {
     if (await this.setup(), !e.configurable)
       throw new Error("Empty configuration supplied.");
-    const s = e.configurable?.thread_id, a = e.configurable?.checkpoint_ns ?? "", t = e.configurable?.checkpoint_id;
-    if (!s)
+    const a = e.configurable?.thread_id, c = e.configurable?.checkpoint_ns ?? "", t = e.configurable?.checkpoint_id;
+    if (!a)
       throw new Error('Missing "thread_id" field in passed "config.configurable".');
-    const d = y(n), [[c, p], [h, i]] = await Promise.all([
-      this.serde.dumpsTyped(d),
-      this.serde.dumpsTyped(o)
+    const r = E(i), [[s, p], [h, o]] = await Promise.all([
+      this.serde.dumpsTyped(r),
+      this.serde.dumpsTyped(n)
     ]);
-    if (c !== h)
+    if (s !== h)
       throw new Error("Failed to serialized checkpoint and metadata to the same type.");
-    return await this.db.insertInto("checkpoints").values({
-      thread_id: s,
-      checkpoint_ns: a,
-      checkpoint_id: n.id,
-      parent_checkpoint_id: t ?? null,
-      type: c,
-      checkpoint: new Uint8Array(Buffer.from(p)),
-      metadata: new Uint8Array(Buffer.from(i))
-    }).onConflict(
-      (_) => _.columns(["thread_id", "checkpoint_ns", "checkpoint_id"]).doUpdateSet({
-        parent_checkpoint_id: t ?? null,
-        type: c,
-        checkpoint: new Uint8Array(Buffer.from(p)),
-        metadata: new Uint8Array(Buffer.from(i))
-      })
-    ).execute(), {
+    return await T(
+      async () => {
+        await this.db.insertInto("checkpoints").values({
+          thread_id: a,
+          checkpoint_ns: c,
+          checkpoint_id: i.id,
+          parent_checkpoint_id: t ?? null,
+          type: s,
+          checkpoint: new Uint8Array(Buffer.from(p)),
+          metadata: new Uint8Array(Buffer.from(o))
+        }).onConflict(
+          (_) => _.columns(["thread_id", "checkpoint_ns", "checkpoint_id"]).doUpdateSet({
+            parent_checkpoint_id: t ?? null,
+            type: s,
+            checkpoint: new Uint8Array(Buffer.from(p)),
+            metadata: new Uint8Array(Buffer.from(o))
+          })
+        ).execute();
+      },
+      `put(${a}/${i.id})`
+    ), {
       configurable: {
-        thread_id: s,
-        checkpoint_ns: a,
-        checkpoint_id: n.id
+        thread_id: a,
+        checkpoint_ns: c,
+        checkpoint_id: i.id
       }
     };
   }
-  async putWrites(e, n, o) {
+  async putWrites(e, i, n) {
     if (await this.setup(), !e.configurable)
       throw new Error("Empty configuration supplied.");
     if (!e.configurable?.thread_id)
       throw new Error("Missing thread_id field in config.configurable.");
     if (!e.configurable?.checkpoint_id)
       throw new Error("Missing checkpoint_id field in config.configurable.");
-    const s = await Promise.all(
-      n.map(async (a, t) => {
-        const [d, c] = await this.serde.dumpsTyped(a[1]);
+    const a = await Promise.all(
+      i.map(async (r, s) => {
+        const [p, h] = await this.serde.dumpsTyped(r[1]);
         return {
           thread_id: e.configurable.thread_id,
           checkpoint_ns: e.configurable.checkpoint_ns ?? "",
           checkpoint_id: e.configurable.checkpoint_id,
-          task_id: o,
-          idx: t,
-          channel: a[0],
-          type: d,
-          value: new Uint8Array(Buffer.from(c))
+          task_id: n,
+          idx: s,
+          channel: r[0],
+          type: p,
+          value: new Uint8Array(Buffer.from(h))
         };
       })
     );
-    s.length > 0 && await this.db.transaction().execute(async (a) => {
-      for (const t of s)
-        await a.insertInto("writes").values(t).onConflict(
-          (d) => d.columns(["thread_id", "checkpoint_ns", "checkpoint_id", "task_id", "idx"]).doUpdateSet({
-            channel: t.channel,
-            type: t.type,
-            value: t.value
-          })
-        ).execute();
-    });
+    if (a.length === 0) return;
+    const c = e.configurable.thread_id, t = e.configurable.checkpoint_id;
+    await T(
+      async () => {
+        await this.db.transaction().execute(async (r) => {
+          await r.deleteFrom("writes").where("thread_id", "=", c).where("checkpoint_ns", "=", a[0].checkpoint_ns).where("checkpoint_id", "=", t).where("task_id", "=", n).execute();
+          for (const s of a)
+            await r.insertInto("writes").values(s).execute();
+        });
+      },
+      `putWrites(${c}/${t}/${n})`
+    );
   }
   async deleteThread(e) {
-    await this.db.transaction().execute(async (n) => {
-      await n.deleteFrom("checkpoints").where("thread_id", "=", e).execute(), await n.deleteFrom("writes").where("thread_id", "=", e).execute();
-    });
+    await T(
+      async () => {
+        await this.db.transaction().execute(async (i) => {
+          await i.deleteFrom("checkpoints").where("thread_id", "=", e).execute(), await i.deleteFrom("writes").where("thread_id", "=", e).execute();
+        });
+      },
+      `deleteThread(${e})`
+    );
   }
-  async migratePendingSends(e, n, o) {
-    const s = await this.db.selectFrom("writes as ps").select([
+  async migratePendingSends(e, i, n) {
+    const a = await this.db.selectFrom("writes as ps").select([
       "ps.checkpoint_id",
-      r`json_group_array(
+      d`json_group_array(
                     json_object(
                         'type', ps.type,
                         'value', CAST(ps.value AS TEXT)
                     )
                 )`.as("pending_sends")
-    ]).where("ps.thread_id", "=", n).where("ps.checkpoint_id", "=", o).where("ps.channel", "=", l).orderBy("ps.idx").executeTakeFirst();
-    if (!s) return;
-    const a = e;
-    a.channel_values ??= {}, a.channel_values[l] = await Promise.all(
-      JSON.parse(s.pending_sends).map(
-        ({ type: t, value: d }) => this.serde.loadsTyped(t, d)
+    ]).where("ps.thread_id", "=", i).where("ps.checkpoint_id", "=", n).where("ps.channel", "=", l).orderBy("ps.idx").executeTakeFirst();
+    if (!a) return;
+    const c = e;
+    c.channel_values ??= {}, c.channel_values[l] = await Promise.all(
+      JSON.parse(a.pending_sends).map(
+        ({ type: t, value: r }) => this.serde.loadsTyped(t, r)
       )
-    ), a.channel_versions[l] = Object.keys(e.channel_versions).length > 0 ? m(...Object.values(e.channel_versions)) : this.getNextVersion(void 0);
+    ), c.channel_versions[l] = Object.keys(e.channel_versions).length > 0 ? g(...Object.values(e.channel_versions)) : this.getNextVersion(void 0);
   }
 }
 export {
-  w as SqliteSaver
+  f as SqliteSaver
 };

package/dist/{checkpoint-DxiUsHMy-DqfBiLDW.mjs → checkpoint-DxiUsHMy-Cep4XMTK.mjs}

@@ -1,5 +1,5 @@
-import { T as l, B as N, W as k, m as y } from "./app-Cynj004J.mjs";
-import "./graphBuilder-mpLrx9tk.mjs";
+import { T as l, B as N, W as k, m as y } from "./app-CcnStH9S.mjs";
+import "./graphBuilder-skVEY6RJ.mjs";
 import w from "pg";
 const S = (h) => [
   "checkpoints",