zen-code 4.6.1 → 4.6.2

package/dist/shallow-BQy_8shO.mjs

@@ -0,0 +1,331 @@
+import { B as $, u as g } from "./app-Cynj004J.mjs";
+import "./graphBuilder-mpLrx9tk.mjs";
+import { createClient as T } from "redis";
+function k(u) {
+  if (u === null || typeof u != "object") return JSON.stringify(u);
+  if (Array.isArray(u)) return JSON.stringify(u.map((i) => k(i)));
+  const t = {}, e = Object.keys(u).sort();
+  for (const i of e) t[i] = u[i];
+  return JSON.stringify(t, (i, n) => {
+    if (n !== null && typeof n == "object" && !Array.isArray(n)) {
+      const s = {}, c = Object.keys(n).sort();
+      for (const r of c) s[r] = n[r];
+      return s;
+    }
+    return n;
+  });
+}
+const S = [{
+  index: "checkpoints",
+  prefix: "checkpoint:",
+  schema: {
+    "$.thread_id": {
+      type: "TAG",
+      AS: "thread_id"
+    },
+    "$.checkpoint_ns": {
+      type: "TAG",
+      AS: "checkpoint_ns"
+    },
+    "$.checkpoint_id": {
+      type: "TAG",
+      AS: "checkpoint_id"
+    },
+    "$.parent_checkpoint_id": {
+      type: "TAG",
+      AS: "parent_checkpoint_id"
+    },
+    "$.checkpoint_ts": {
+      type: "NUMERIC",
+      AS: "checkpoint_ts"
+    },
+    "$.has_writes": {
+      type: "TAG",
+      AS: "has_writes"
+    },
+    "$.source": {
+      type: "TAG",
+      AS: "source"
+    },
+    "$.step": {
+      type: "NUMERIC",
+      AS: "step"
+    }
+  }
+}, {
+  index: "checkpoint_writes",
+  prefix: "checkpoint_write:",
+  schema: {
+    "$.thread_id": {
+      type: "TAG",
+      AS: "thread_id"
+    },
+    "$.checkpoint_ns": {
+      type: "TAG",
+      AS: "checkpoint_ns"
+    },
+    "$.checkpoint_id": {
+      type: "TAG",
+      AS: "checkpoint_id"
+    },
+    "$.task_id": {
+      type: "TAG",
+      AS: "task_id"
+    },
+    "$.idx": {
+      type: "NUMERIC",
+      AS: "idx"
+    },
+    "$.channel": {
+      type: "TAG",
+      AS: "channel"
+    },
+    "$.type": {
+      type: "TAG",
+      AS: "type"
+    }
+  }
+}];
+var C = class w extends $ {
+  client;
+  ttlConfig;
+  constructor(t, e) {
+    super(), this.client = t, this.ttlConfig = e;
+  }
+  static async fromUrl(t, e) {
+    const i = T({ url: t });
+    await i.connect();
+    const n = new w(i, e);
+    return await n.ensureIndexes(), n;
+  }
+  async get(t) {
+    return (await this.getTuple(t))?.checkpoint;
+  }
+  async put(t, e, i, n) {
+    await this.ensureIndexes();
+    const s = t.configurable?.thread_id, c = t.configurable?.checkpoint_ns ?? "", r = t.configurable?.checkpoint_id;
+    if (!s) throw new Error("thread_id is required");
+    const a = e.id || g(0), l = `checkpoint:${s}:${c}:shallow`;
+    let h = null, p = null;
+    try {
+      h = await this.client.json.get(l), h && typeof h == "object" && (p = h.checkpoint_id);
+    } catch {
+    }
+    p && p !== a && await this.cleanupOldCheckpoint(s, c, p);
+    const o = {
+      ...e,
+      channel_values: e.channel_values || {},
+      channel_blobs: void 0
+    }, d = {
+      thread_id: s,
+      checkpoint_ns: c,
+      checkpoint_id: a,
+      parent_checkpoint_id: r || null,
+      checkpoint: o,
+      metadata: this.sanitizeMetadata(i),
+      checkpoint_ts: Date.now(),
+      has_writes: "false"
+    };
+    return this.addSearchableMetadataFields(d, i), await this.client.json.set(l, "$", d), this.ttlConfig?.defaultTTL && await this.applyTTL(l), { configurable: {
+      thread_id: s,
+      checkpoint_ns: c,
+      checkpoint_id: a
+    } };
+  }
+  async getTuple(t) {
+    const e = t.configurable?.thread_id, i = t.configurable?.checkpoint_ns ?? "", n = t.configurable?.checkpoint_id;
+    if (!e) return;
+    const s = `checkpoint:${e}:${i}:shallow`, c = await this.client.json.get(s);
+    if (!c || n && c.checkpoint_id !== n) return;
+    this.ttlConfig?.refreshOnRead && this.ttlConfig?.defaultTTL && await this.applyTTL(s);
+    const r = await this.serde.loadsTyped("json", JSON.stringify(c.checkpoint));
+    let a;
+    return c.has_writes === "true" && (a = await this.loadPendingWrites(c.thread_id, c.checkpoint_ns, c.checkpoint_id)), await this.createCheckpointTuple(c, r, a);
+  }
+  async *list(t, e) {
+    if (await this.ensureIndexes(), t?.configurable?.thread_id) {
+      const i = await this.getTuple(t);
+      i && (e?.filter ? this.checkMetadataFilterMatch(i.metadata, e.filter) && (yield i) : yield i);
+    } else {
+      const i = [];
+      if (e?.filter)
+        for (const [c, r] of Object.entries(e.filter)) r === void 0 || r === null || (typeof r == "string" ? i.push(`(@${c}:{${r}})`) : typeof r == "number" && i.push(`(@${c}:[${r} ${r}])`));
+      i.length === 0 && i.push("*");
+      const n = i.join(" "), s = e?.limit ?? 10;
+      try {
+        const c = await this.client.ft.search("checkpoints", n, {
+          LIMIT: {
+            from: 0,
+            size: s * 2
+          },
+          SORTBY: {
+            BY: "checkpoint_ts",
+            DIRECTION: "DESC"
+          }
+        }), r = /* @__PURE__ */ new Set();
+        let a = 0;
+        for (const l of c.documents) {
+          if (a >= s) break;
+          const h = l.value, p = `${h.thread_id}:${h.checkpoint_ns}`;
+          if (r.has(p) || (r.add(p), e?.filter && !this.checkMetadataFilterMatch(h.metadata, e.filter)))
+            continue;
+          const o = await this.serde.loadsTyped("json", JSON.stringify(h.checkpoint));
+          yield await this.createCheckpointTuple(h, o), a++;
+        }
+      } catch (c) {
+        if (c.message?.includes("no such index")) {
+          const a = await this.client.keys("checkpoint:*:*:shallow");
+          if (a.length === 0) return;
+          a.sort().reverse();
+          const l = /* @__PURE__ */ new Set();
+          let h = 0;
+          const p = e?.limit ?? 10;
+          for (const o of a) {
+            if (h >= p) break;
+            const d = await this.client.json.get(o);
+            if (!d) continue;
+            const f = `${d.thread_id}:${d.checkpoint_ns}`;
+            if (l.has(f) || (l.add(f), e?.filter && !this.checkMetadataFilterMatch(d.metadata, e.filter)))
+              continue;
+            const y = await this.serde.loadsTyped("json", JSON.stringify(d.checkpoint));
+            yield await this.createCheckpointTuple(d, y), h++;
+          }
+          return;
+        }
+        throw c;
+      }
+    }
+  }
+  async putWrites(t, e, i) {
+    await this.ensureIndexes();
+    const n = t.configurable?.thread_id, s = t.configurable?.checkpoint_ns ?? "", c = t.configurable?.checkpoint_id;
+    if (!n || !c) throw new Error("thread_id and checkpoint_id are required");
+    const r = `checkpoint_write:${n}:${s}:${c}:${i}:*`, a = await this.client.keys(r);
+    a.length > 0 && await this.client.del(a);
+    const l = [];
+    for (let o = 0; o < e.length; o++) {
+      const [d, f] = e[o], y = `checkpoint_write:${n}:${s}:${c}:${i}:${o}`;
+      l.push(y);
+      const _ = {
+        thread_id: n,
+        checkpoint_ns: s,
+        checkpoint_id: c,
+        task_id: i,
+        idx: o,
+        channel: d,
+        type: typeof f == "object" ? "json" : "string",
+        value: f
+      };
+      await this.client.json.set(y, "$", _);
+    }
+    if (l.length > 0) {
+      const o = `write_keys_zset:${n}:${s}:${c}`, d = {};
+      l.forEach((f, y) => {
+        d[f] = y;
+      }), await this.client.zAdd(o, Object.entries(d).map(([f, y]) => ({
+        score: y,
+        value: f
+      }))), this.ttlConfig?.defaultTTL && await this.applyTTL(...l, o);
+    }
+    const h = `checkpoint:${n}:${s}:shallow`;
+    if (await this.client.exists(h)) {
+      const o = await this.client.json.get(h);
+      o && (o.has_writes = "true", await this.client.json.set(h, "$", o));
+    }
+  }
+  async deleteThread(t) {
+    const e = `checkpoint:${t}:*:shallow`, i = await this.client.keys(e);
+    i.length > 0 && await this.client.del(i);
+    const n = `checkpoint_write:${t}:*`, s = await this.client.keys(n);
+    s.length > 0 && await this.client.del(s);
+    const c = `write_keys_zset:${t}:*`, r = await this.client.keys(c);
+    r.length > 0 && await this.client.del(r);
+  }
+  async end() {
+    await this.client.quit();
+  }
+  addSearchableMetadataFields(t, e) {
+    e && ("source" in e && (t.source = e.source), "step" in e && (t.step = e.step), "writes" in e && (t.writes = typeof e.writes == "object" ? JSON.stringify(e.writes) : e.writes), "score" in e && (t.score = e.score));
+  }
+  async createCheckpointTuple(t, e, i) {
+    const n = await this.serde.loadsTyped("json", JSON.stringify(t.metadata));
+    return {
+      config: { configurable: {
+        thread_id: t.thread_id,
+        checkpoint_ns: t.checkpoint_ns,
+        checkpoint_id: t.checkpoint_id
+      } },
+      checkpoint: e,
+      metadata: n,
+      parentConfig: t.parent_checkpoint_id ? { configurable: {
+        thread_id: t.thread_id,
+        checkpoint_ns: t.checkpoint_ns,
+        checkpoint_id: t.parent_checkpoint_id
+      } } : void 0,
+      pendingWrites: i
+    };
+  }
+  async applyTTL(...t) {
+    if (!this.ttlConfig?.defaultTTL) return;
+    const e = Math.floor(this.ttlConfig.defaultTTL * 60), i = await Promise.allSettled(t.map((n) => this.client.expire(n, e)));
+    for (let n = 0; n < i.length; n++) i[n].status === "rejected" && console.warn(`Failed to set TTL for key ${t[n]}:`, i[n].reason);
+  }
+  async loadPendingWrites(t, e, i) {
+    const n = `write_keys_zset:${t}:${e}:${i}`, s = await this.client.zRange(n, 0, -1);
+    if (s.length === 0) return;
+    const c = [];
+    for (const r of s) {
+      const a = await this.client.json.get(r);
+      if (a) {
+        const l = await this.serde.loadsTyped("json", JSON.stringify(a.value));
+        c.push([
+          a.task_id,
+          a.channel,
+          l
+        ]);
+      }
+    }
+    return c;
+  }
+  checkMetadataFilterMatch(t, e) {
+    for (const [i, n] of Object.entries(e)) {
+      const s = t?.[i];
+      if (n === null) {
+        if (!(i in (t || {})) || s !== null) return !1;
+      } else if (typeof n == "object" && !Array.isArray(n)) {
+        if (typeof s != "object" || s === null || k(n) !== k(s)) return !1;
+      } else if (s !== n) return !1;
+    }
+    return !0;
+  }
+  async cleanupOldCheckpoint(t, e, i) {
+    const n = `checkpoint_write:${t}:${e}:${i}:*`, s = await this.client.keys(n);
+    s.length > 0 && await this.client.del(s);
+    const c = `write_keys_zset:${t}:${e}:${i}`;
+    await this.client.del(c);
+    const r = `checkpoint_blob:${t}:${e}:${i}:*`, a = await this.client.keys(r);
+    a.length > 0 && await this.client.del(a);
+  }
+  sanitizeMetadata(t) {
+    if (!t) return {};
+    const e = {};
+    for (const [i, n] of Object.entries(t)) {
+      const s = i.replace(/\x00/g, "");
+      e[s] = typeof n == "string" ? n.replace(/\x00/g, "") : n;
+    }
+    return e;
+  }
+  async ensureIndexes() {
+    for (const t of S) try {
+      await this.client.ft.create(t.index, t.schema, {
+        ON: "JSON",
+        PREFIX: t.prefix
+      });
+    } catch (e) {
+      e.message?.includes("Index already exists") || console.error(`Failed to create index ${t.index}:`, e.message);
+    }
+  }
+};
+export {
+  C as ShallowRedisSaver
+};

package/dist/sqlite-adapter-BKOLSdoL-5XOA6_0i.mjs

@@ -0,0 +1,71 @@
+import { sql as e } from "kysely";
+class L {
+  db;
+  constructor(t) {
+    this.db = t;
+  }
+  dateToDb(t) {
+    return t.toISOString();
+  }
+  dbToDate(t) {
+    return new Date(t);
+  }
+  jsonToDb(t) {
+    return JSON.stringify(t);
+  }
+  dbToJson(t) {
+    if (typeof t == "string")
+      try {
+        return JSON.parse(t);
+      } catch {
+        return t;
+      }
+    return t;
+  }
+  buildJsonQuery(t, s, a, T) {
+    const E = `$.${a.includes("-") || a.includes(".") || a.includes(" ") ? `"${a}"` : a}`;
+    let r;
+    if (typeof T == "string" || typeof T == "number" ? r = T : typeof T == "boolean" ? r = T ? 1 : 0 : T === null ? r = null : r = JSON.stringify(T), T === null) {
+      const n = `"${a}":null`;
+      return e`
+                json_extract(${e.ref(s)}, ${e.lit(E)}) IS NULL
+                AND ${e.ref(s)} LIKE ${e.lit(`%${n}%`)}
+            `;
+    }
+    return e`json_extract(${e.ref(s)}, ${e.lit(E)}) = ${e.lit(r)}`;
+  }
+  now() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async createTables(t) {
+    await e`
+            CREATE TABLE IF NOT EXISTS threads (
+                thread_id TEXT PRIMARY KEY,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                metadata TEXT NOT NULL DEFAULT '{}',
+                status TEXT NOT NULL DEFAULT 'idle',
+                "values" TEXT,
+                interrupts TEXT NOT NULL DEFAULT '{}'
+            )
+        `.execute(t), await e`
+            CREATE TABLE IF NOT EXISTS runs (
+                run_id TEXT PRIMARY KEY,
+                thread_id TEXT NOT NULL,
+                assistant_id TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'pending',
+                metadata TEXT NOT NULL DEFAULT '{}',
+                multitask_strategy TEXT NOT NULL DEFAULT 'reject',
+                FOREIGN KEY (thread_id) REFERENCES threads(thread_id) ON DELETE CASCADE
+            )
+        `.execute(t);
+  }
+  async createIndexes(t) {
+    await e`CREATE INDEX IF NOT EXISTS idx_threads_status ON threads(status)`.execute(t), await e`CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at)`.execute(t), await e`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`.execute(t), await e`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`.execute(t), await e`CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`.execute(t);
+  }
+}
+export {
+  L as SQLiteAdapter
+};

package/dist/{subTasks-5KLIr9iy.mjs → subTasks-Bt97OwvY.mjs}

@@ -1,8 +1,8 @@
 import { tool as g, HumanMessage as h, SystemMessage as p } from "langchain";
 import { Command as m, Annotation as f } from "@langchain/langgraph";
 import { z as n } from "zod";
-import { createState as b } from "@langgraph-js/pro";
-import { l as y, m as w } from "./graphBuilder-B3IJ7dB2.mjs";
+import { m as b, n as y, o as w } from "./graphBuilder-mpLrx9tk.mjs";
+import "@langchain/openai";
 n.object({
   task_store: n.record(n.string(), n.any()).default({})
 });