zen-code 4.6.1 → 4.7.0

package/dist/queue-DySatFkr-DjaRbjhM.mjs

@@ -0,0 +1,106 @@
+import { a as h, C as d } from "./app-CcnStH9S.mjs";
+import { createClient as m } from "redis";
+class o extends h {
+  // 轮询间隔（毫秒）
+  constructor(e, t = !0, s = 300) {
+    super(e, !0, s), this.id = e, this.compressMessages = t, this.ttl = s, this.streamKey = `stream:${this.id}`, this.listKey = `queue:${this.id}`, this.redis = m({
+      url: process.env.REDIS_URL
+    }), this.cancelSignal = new AbortController(), this.redis.isOpen || this.redis.connect(), this.isConnected = !0;
+  }
+  redis;
+  streamKey;
+  listKey;
+  isConnected = !1;
+  cancelSignal;
+  lastStreamId = "0";
+  // 最后读取的 Stream ID
+  pollInterval = 100;
+  /**
+   * 推送消息到 Redis Stream 和 List
+   * - Stream: 用于实时推送（集群友好）
+   * - List: 用于 getAll() 批量获取历史数据
+   */
+  async push(e) {
+    const t = await this.encodeData(e), s = Buffer.from(t).toString("base64"), a = Buffer.from(t);
+    await this.redis.xAdd(this.streamKey, "*", { data: s }), await this.redis.expire(this.streamKey, this.ttl), await this.redis.rPush(this.listKey, a), await this.redis.expire(this.listKey, this.ttl), this.emit("dataChange", s);
+  }
+  /**
+   * 异步生成器：使用 Redis Streams XREAD 轮询消费队列数据
+   */
+  async *onDataReceive() {
+    let e = !1;
+    if (this.cancelSignal.signal.aborted)
+      return;
+    const t = () => {
+      e = !0;
+    };
+    this.cancelSignal.signal.addEventListener("abort", t);
+    try {
+      for (; !e && !this.cancelSignal.signal.aborted; ) {
+        const s = await this.redis.xRead([{ key: this.streamKey, id: this.lastStreamId }], {
+          BLOCK: this.pollInterval,
+          COUNT: 10
+        });
+        if (s && s.length > 0)
+          for (const a of s) {
+            for (const r of a.messages) {
+              this.lastStreamId = r.id;
+              const n = r.message.data, l = Buffer.from(n, "base64"), i = await this.decodeData(l);
+              if ((i.event === "__stream_end__" || i.event === "__stream_error__" || i.event === "__stream_cancel__") && (await new Promise((c) => setTimeout(c, 300)), e = !0, i.event === "__stream_cancel__" && await this.cancel()), yield i, e)
+                break;
+            }
+            if (e)
+              break;
+          }
+        !e && !this.cancelSignal.signal.aborted && await new Promise((a) => setTimeout(a, this.pollInterval));
+      }
+    } finally {
+      this.cancelSignal.signal.removeEventListener("abort", t);
+    }
+  }
+  /**
+   * 获取队列中的所有数据（从 List 获取历史数据）
+   */
+  async getAll() {
+    const e = await this.redis.lRange(this.listKey, 0, -1);
+    return !e || e.length === 0 ? [] : this.compressMessages ? await Promise.all(
+      e.map((t) => {
+        const s = typeof t == "string" ? Buffer.from(t, "binary") : t;
+        return this.decodeData(s);
+      })
+    ) : e.map((t) => JSON.parse(t));
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.isConnected && (this.redis.del(this.streamKey), this.redis.del(this.listKey));
+  }
+  /**
+   * 取消操作
+   */
+  async cancel() {
+    this.cancelSignal.abort("user cancel this run"), await this.push(new d());
+  }
+  /**
+   * 复制队列到另一个队列
+   */
+  async copyToQueue(e, t) {
+    const s = new o(e, this.compressMessages, t ?? this.ttl);
+    await this.redis.copy(this.listKey, s.listKey), await this.redis.expire(s.listKey, t ?? this.ttl);
+    const a = await this.redis.xRange(this.streamKey, "-", "+");
+    if (a && a.length > 0) {
+      for (const r of a) {
+        const n = {};
+        for (const [l, i] of Object.entries(r.message))
+          n[l] = String(i);
+        await this.redis.xAdd(s.streamKey, "*", n);
+      }
+      await this.redis.expire(s.streamKey, t ?? this.ttl);
+    }
+    return s;
+  }
+}
+export {
+  o as RedisStreamQueue
+};

package/dist/remote-threads-CrG03ZS7-C9duTCnB.mjs

@@ -0,0 +1,157 @@
+var h = /* @__PURE__ */ ((a) => (a.NETWORK_ERROR = "NETWORK_ERROR", a.CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT", a.INTERNAL_ERROR = "INTERNAL_ERROR", a.THREAD_NOT_FOUND = "THREAD_NOT_FOUND", a.THREAD_BUSY = "THREAD_BUSY", a.RUN_NOT_FOUND = "RUN_NOT_FOUND", a.GRAPH_NOT_FOUND = "GRAPH_NOT_FOUND", a.INVALID_REQUEST = "INVALID_REQUEST", a))(h || {});
+class d extends Error {
+  constructor(s, t, e) {
+    super(t), this.code = s, this.statusCode = e, this.name = "RemoteApiError";
+  }
+}
+async function c(a, s, t) {
+  try {
+    let e = a;
+    if (t?.query) {
+      const f = new URLSearchParams();
+      Object.entries(t.query).forEach(([v, N]) => {
+        f.append(v, String(N));
+      }), e += `?${f.toString()}`;
+    }
+    const i = await fetch(e, {
+      method: s,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: t?.body ? JSON.stringify(t.body) : void 0
+    }), n = await i.json();
+    if (!i.ok || !n.success)
+      throw new d(
+        n.error?.code || h.INTERNAL_ERROR,
+        n.error?.message || "Unknown error",
+        i.status
+      );
+    return n;
+  } catch (e) {
+    throw e instanceof d ? e : new d(
+      h.NETWORK_ERROR,
+      `Network error: ${e instanceof Error ? e.message : "Unknown error"}`
+    );
+  }
+}
+async function o(a, s) {
+  return c(a, "GET", { query: s });
+}
+async function r(a, s, t) {
+  return c(a, "POST", { body: s, query: t });
+}
+async function l(a, s, t) {
+  return c(a, "PUT", { body: s, query: t });
+}
+async function O(a, s) {
+  return c(a, "DELETE", { query: s });
+}
+class p {
+  constructor(s, t) {
+    this.serverUrl = s, this.httpClient = t, this.serverUrl = s.replace(/\/$/, ""), this.httpClient = t || fetch;
+  }
+  /**
+   * 初始化数据库
+   */
+  async setup() {
+    await r(`${this.serverUrl}/setup`);
+  }
+  /**
+   * 创建线程
+   */
+  async create(s) {
+    return (await r(`${this.serverUrl}/threads`, s)).data;
+  }
+  /**
+   * 搜索线程
+   */
+  async search(s) {
+    const t = {};
+    return s?.ids !== void 0 && s.ids.length > 0 && (t.ids = JSON.stringify(s.ids)), s?.metadata !== void 0 && (t.metadata = JSON.stringify(s.metadata)), s?.limit !== void 0 && (t.limit = s.limit), s?.offset !== void 0 && (t.offset = s.offset), s?.status !== void 0 && (t.status = s.status), s?.sortBy !== void 0 && (t.sortBy = s.sortBy), s?.sortOrder !== void 0 && (t.sortOrder = s.sortOrder), s?.values !== void 0 && (t.values = JSON.stringify(s.values)), s?.select !== void 0 && (t.select = JSON.stringify(s.select)), s?.withoutDetails !== void 0 && (t.withoutDetails = s.withoutDetails), (await o(`${this.serverUrl}/threads`, t)).data;
+  }
+  /**
+   * 获取线程
+   */
+  async get(s) {
+    return (await o(`${this.serverUrl}/threads/${s}`)).data;
+  }
+  /**
+   * 更新线程
+   */
+  async set(s, t) {
+    await l(`${this.serverUrl}/threads/${s}`, t);
+  }
+  /**
+   * 删除线程
+   */
+  async delete(s) {
+    await O(`${this.serverUrl}/threads/${s}`);
+  }
+  /**
+   * 更新状态
+   */
+  async updateState(s, t) {
+    return (await r(
+      `${this.serverUrl}/threads/${s}/state`,
+      t
+    )).data;
+  }
+  /**
+   * 创建运行
+   */
+  async createRun(s, t, e) {
+    return (await r(`${this.serverUrl}/threads/${s}/runs`, e || {}, {
+      assistantId: t
+    })).data;
+  }
+  /**
+   * 列出运行
+   */
+  async listRuns(s, t) {
+    const e = {};
+    return t?.limit !== void 0 && (e.limit = t.limit), t?.offset !== void 0 && (e.offset = t.offset), t?.status !== void 0 && (e.status = t.status), (await o(`${this.serverUrl}/threads/${s}/runs`, e)).data;
+  }
+  /**
+   * 更新运行
+   */
+  async updateRun(s, t) {
+    await l(`${this.serverUrl}/runs/${s}`, t);
+  }
+  // New methods for Threads API
+  /**
+   * 计算线程数量
+   */
+  async count(s) {
+    const t = {};
+    return s?.ids !== void 0 && s.ids.length > 0 && (t.ids = JSON.stringify(s.ids)), s?.metadata !== void 0 && (t.metadata = JSON.stringify(s.metadata)), s?.status !== void 0 && (t.status = s.status), s?.values !== void 0 && (t.values = JSON.stringify(s.values)), (await o(`${this.serverUrl}/threads/count`, t)).data;
+  }
+  /**
+   * 更新线程元数据
+   */
+  async patch(s, t) {
+    return (await r(`${this.serverUrl}/threads/${s}`, t)).data;
+  }
+  /**
+   * 获取线程状态
+   */
+  async getState(s, t) {
+    const e = {};
+    return t?.subgraphs !== void 0 && (e.subgraphs = t.subgraphs), t?.checkpointId !== void 0 && (e.checkpointId = t.checkpointId), (await r(`${this.serverUrl}/threads/${s}/state`, e)).data;
+  }
+  /**
+   * 获取线程历史
+   */
+  async getStateHistory(s, t) {
+    const e = {};
+    return t?.limit !== void 0 && (e.limit = t.limit), t?.before !== void 0 && (e.before = t.before), (await r(`${this.serverUrl}/threads/${s}/history`, e)).data;
+  }
+  /**
+   * 复制线程
+   */
+  async copy(s) {
+    return (await r(`${this.serverUrl}/threads/${s}/copy`)).data;
+  }
+}
+export {
+  p as RemoteKyselyThreadsManager
+};

package/dist/shallow-CqCGqQDo.mjs

@@ -0,0 +1,331 @@
+import { B as $, u as g } from "./app-CcnStH9S.mjs";
+import "./graphBuilder-skVEY6RJ.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
+};