@langgraph-js/pure-graph 2.1.6 → 2.2.8

package/dist/{stream-BwdFJfJb.js → stream-SJdqjfOM.js}

@@ -397,6 +397,227 @@ class StreamQueueManager {
   }
 }
 
+const GRAPHS = {};
+async function registerGraph(graphId, graph) {
+  GRAPHS[graphId] = graph;
+}
+async function getGraph(graphId, config, options) {
+  if (!GRAPHS[graphId]) throw new Error(`Graph "${graphId}" not found`);
+  const compiled = typeof GRAPHS[graphId] === "function" ? await GRAPHS[graphId](config ?? { configurable: {} }) : GRAPHS[graphId];
+  if (typeof options?.checkpointer !== "undefined") {
+    compiled.checkpointer = options?.checkpointer ?? LangGraphGlobal.globalCheckPointer;
+  } else {
+    compiled.checkpointer = LangGraphGlobal.globalCheckPointer;
+  }
+  compiled.store = options?.store ?? void 0;
+  return compiled;
+}
+
+class KyselyThreadsManager {
+  db;
+  adapter;
+  constructor(adapter) {
+    this.db = adapter.db;
+    this.adapter = adapter;
+  }
+  async setup() {
+    await this.adapter.createTables(this.db);
+    await this.adapter.createIndexes(this.db);
+  }
+  async create(payload) {
+    const threadId = payload?.threadId || crypto.randomUUID();
+    if (payload?.ifExists === "raise") {
+      const existing = await this.db.selectFrom("threads").select("thread_id").where("thread_id", "=", threadId).executeTakeFirst();
+      if (existing) {
+        throw new Error(`Thread with ID ${threadId} already exists.`);
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    const metadata = payload?.metadata || {};
+    const interrupts = {};
+    await this.db.insertInto("threads").values({
+      thread_id: threadId,
+      created_at: this.adapter.dateToDb(now),
+      updated_at: this.adapter.dateToDb(now),
+      metadata: this.adapter.jsonToDb(metadata),
+      status: "idle",
+      values: null,
+      interrupts: this.adapter.jsonToDb(interrupts)
+    }).execute();
+    return {
+      thread_id: threadId,
+      created_at: now.toISOString(),
+      updated_at: now.toISOString(),
+      metadata,
+      status: "idle",
+      values: null,
+      interrupts
+    };
+  }
+  async search(query) {
+    let queryBuilder = this.db.selectFrom("threads").selectAll();
+    if (query?.status) {
+      queryBuilder = queryBuilder.where("status", "=", query.status);
+    }
+    if (query?.metadata) {
+      for (const [key, value] of Object.entries(query.metadata)) {
+        queryBuilder = queryBuilder.where(this.adapter.buildJsonQuery(this.db, "metadata", key, value));
+      }
+    }
+    if (query?.sortBy) {
+      const order = query.sortOrder === "desc" ? "desc" : "asc";
+      queryBuilder = queryBuilder.orderBy(query.sortBy, order);
+    }
+    if (query?.limit !== void 0) {
+      queryBuilder = queryBuilder.limit(query.limit);
+      if (query?.offset !== void 0) {
+        queryBuilder = queryBuilder.offset(query.offset);
+      }
+    }
+    const rows = await queryBuilder.execute();
+    return rows.map((row) => ({
+      thread_id: row.thread_id,
+      created_at: this.adapter.dbToDate(row.created_at).toISOString(),
+      updated_at: this.adapter.dbToDate(row.updated_at).toISOString(),
+      metadata: this.adapter.dbToJson(row.metadata),
+      status: row.status,
+      values: row.values ? this.adapter.dbToJson(row.values) : null,
+      interrupts: this.adapter.dbToJson(row.interrupts)
+    }));
+  }
+  async get(threadId) {
+    const row = await this.db.selectFrom("threads").selectAll().where("thread_id", "=", threadId).executeTakeFirst();
+    if (!row) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    return {
+      thread_id: row.thread_id,
+      created_at: this.adapter.dbToDate(row.created_at).toISOString(),
+      updated_at: this.adapter.dbToDate(row.updated_at).toISOString(),
+      metadata: this.adapter.dbToJson(row.metadata),
+      status: row.status,
+      values: row.values ? this.adapter.dbToJson(row.values) : null,
+      interrupts: this.adapter.dbToJson(row.interrupts)
+    };
+  }
+  async set(threadId, thread) {
+    const existing = await this.db.selectFrom("threads").select("thread_id").where("thread_id", "=", threadId).executeTakeFirst();
+    if (!existing) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    const updates = {
+      updated_at: this.adapter.dateToDb(/* @__PURE__ */ new Date())
+    };
+    if (thread.metadata !== void 0) {
+      updates.metadata = this.adapter.jsonToDb(thread.metadata);
+    }
+    if (thread.status !== void 0) {
+      updates.status = thread.status;
+    }
+    if (thread.values !== void 0) {
+      updates.values = thread.values ? this.adapter.jsonToDb(thread.values) : null;
+    }
+    if (thread.interrupts !== void 0) {
+      updates.interrupts = this.adapter.jsonToDb(thread.interrupts);
+    }
+    await this.db.updateTable("threads").set(updates).where("thread_id", "=", threadId).execute();
+  }
+  async updateState(threadId, thread) {
+    const targetThread = await this.get(threadId);
+    if (targetThread.status === "busy") {
+      throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
+    }
+    if (!targetThread.metadata?.graph_id) {
+      throw new Error(`Thread with ID ${threadId} has no graph_id.`);
+    }
+    const graphId = targetThread.metadata?.graph_id;
+    const config = {
+      configurable: {
+        thread_id: threadId,
+        graph_id: graphId
+      }
+    };
+    const graph = await getGraph(graphId, config);
+    const nextConfig = await graph.updateState(config, thread.values);
+    const graphState = await graph.getState(config);
+    await this.set(threadId, { values: JSON.parse(serialiseAsDict(graphState.values)) });
+    return nextConfig;
+  }
+  async delete(threadId) {
+    const result = await this.db.deleteFrom("threads").where("thread_id", "=", threadId).executeTakeFirst();
+    if (result.numDeletedRows === 0n) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+  }
+  async createRun(threadId, assistantId, payload) {
+    const runId = crypto.randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const metadata = payload?.metadata ?? {};
+    await this.db.insertInto("runs").values({
+      run_id: runId,
+      thread_id: threadId,
+      assistant_id: assistantId,
+      created_at: this.adapter.dateToDb(now),
+      updated_at: this.adapter.dateToDb(now),
+      status: "pending",
+      metadata: this.adapter.jsonToDb(metadata),
+      multitask_strategy: "reject"
+    }).execute();
+    return {
+      run_id: runId,
+      thread_id: threadId,
+      assistant_id: assistantId,
+      created_at: now.toISOString(),
+      updated_at: now.toISOString(),
+      status: "pending",
+      metadata,
+      multitask_strategy: "reject"
+    };
+  }
+  async listRuns(threadId, options) {
+    let queryBuilder = this.db.selectFrom("runs").selectAll().where("thread_id", "=", threadId).orderBy("created_at", "desc");
+    if (options?.status) {
+      queryBuilder = queryBuilder.where("status", "=", options.status);
+    }
+    if (options?.limit !== void 0) {
+      queryBuilder = queryBuilder.limit(options.limit);
+      if (options?.offset !== void 0) {
+        queryBuilder = queryBuilder.offset(options.offset);
+      }
+    }
+    const rows = await queryBuilder.execute();
+    return rows.map((row) => ({
+      run_id: row.run_id,
+      thread_id: row.thread_id,
+      assistant_id: row.assistant_id,
+      created_at: this.adapter.dbToDate(row.created_at).toISOString(),
+      updated_at: this.adapter.dbToDate(row.updated_at).toISOString(),
+      status: row.status,
+      metadata: this.adapter.dbToJson(row.metadata),
+      multitask_strategy: row.multitask_strategy
+    }));
+  }
+  async updateRun(runId, run) {
+    const existing = await this.db.selectFrom("runs").select("run_id").where("run_id", "=", runId).executeTakeFirst();
+    if (!existing) {
+      throw new Error(`Run with ID ${runId} not found.`);
+    }
+    const updates = {
+      updated_at: this.adapter.dateToDb(/* @__PURE__ */ new Date())
+    };
+    if (run.status !== void 0) {
+      updates.status = run.status;
+    }
+    if (run.metadata !== void 0) {
+      updates.metadata = this.adapter.jsonToDb(run.metadata);
+    }
+    if (run.multitask_strategy !== void 0) {
+      updates.multitask_strategy = run.multitask_strategy;
+    }
+    await this.db.updateTable("runs").set(updates).where("run_id", "=", runId).execute();
+  }
+}
+
 class EventMessage {
   event;
   data;
@@ -498,22 +719,6 @@ class MemoryStreamQueue extends BaseStreamQueue {
   }
 }
 
-const GRAPHS = {};
-async function registerGraph(graphId, graph) {
-  GRAPHS[graphId] = graph;
-}
-async function getGraph(graphId, config, options) {
-  if (!GRAPHS[graphId]) throw new Error(`Graph "${graphId}" not found`);
-  const compiled = typeof GRAPHS[graphId] === "function" ? await GRAPHS[graphId](config ?? { configurable: {} }) : GRAPHS[graphId];
-  if (typeof options?.checkpointer !== "undefined") {
-    compiled.checkpointer = options?.checkpointer ?? LangGraphGlobal.globalCheckPointer;
-  } else {
-    compiled.checkpointer = LangGraphGlobal.globalCheckPointer;
-  }
-  compiled.store = options?.store ?? void 0;
-  return compiled;
-}
-
 class MemoryThreadsManager {
   threads = [];
   async setup() {
@@ -659,587 +864,6 @@ class MemoryThreadsManager {
   }
 }
 
-class SQLiteThreadsManager {
-  db;
-  isSetup = false;
-  constructor(checkpointer) {
-    this.db = checkpointer.db;
-  }
-  async setup() {
-    if (this.isSetup) {
-      return;
-    }
-    this.db.exec(`
-            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 '{}'
-            )
-        `);
-    this.db.exec(`
-            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
-            )
-        `);
-    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_status ON threads(status)`);
-    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at)`);
-    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`);
-    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`);
-    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`);
-    this.isSetup = true;
-  }
-  async create(payload) {
-    const threadId = payload?.threadId || crypto.randomUUID();
-    if (payload?.ifExists === "raise") {
-      const existingThread = this.db.prepare("SELECT thread_id FROM threads WHERE thread_id = ?").get(threadId);
-      if (existingThread) {
-        throw new Error(`Thread with ID ${threadId} already exists.`);
-      }
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const metadata = JSON.stringify(payload?.metadata || {});
-    const interrupts = JSON.stringify({});
-    const thread = {
-      thread_id: threadId,
-      created_at: now,
-      updated_at: now,
-      metadata: payload?.metadata || {},
-      status: "idle",
-      values: null,
-      interrupts: {}
-    };
-    this.db.prepare(
-      `
-            INSERT INTO threads (thread_id, created_at, updated_at, metadata, status, [values], interrupts)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        `
-    ).run(threadId, now, now, metadata, "idle", null, interrupts);
-    return thread;
-  }
-  async search(query) {
-    let sql = "SELECT * FROM threads";
-    const whereConditions = [];
-    const params = [];
-    if (query?.status) {
-      whereConditions.push("status = ?");
-      params.push(query.status);
-    }
-    if (query?.metadata) {
-      for (const [key, value] of Object.entries(query.metadata)) {
-        whereConditions.push(`json_extract(metadata, '$.${key}') = ?`);
-        params.push(JSON.stringify(value));
-      }
-    }
-    if (whereConditions.length > 0) {
-      sql += " WHERE " + whereConditions.join(" AND ");
-    }
-    if (query?.sortBy) {
-      sql += ` ORDER BY ${query.sortBy}`;
-      if (query.sortOrder === "desc") {
-        sql += " DESC";
-      } else {
-        sql += " ASC";
-      }
-    }
-    if (query?.limit) {
-      sql += ` LIMIT ${query.limit}`;
-      if (query?.offset) {
-        sql += ` OFFSET ${query.offset}`;
-      }
-    }
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => ({
-      thread_id: row.thread_id,
-      created_at: row.created_at,
-      updated_at: row.updated_at,
-      metadata: JSON.parse(row.metadata),
-      status: row.status,
-      values: row.values ? JSON.parse(row.values) : null,
-      interrupts: JSON.parse(row.interrupts)
-    }));
-  }
-  async get(threadId) {
-    const row = this.db.prepare("SELECT * FROM threads WHERE thread_id = ?").get(threadId);
-    if (!row) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-    return {
-      thread_id: row.thread_id,
-      created_at: row.created_at,
-      updated_at: row.updated_at,
-      metadata: JSON.parse(row.metadata),
-      status: row.status,
-      values: row.values ? JSON.parse(row.values) : null,
-      interrupts: JSON.parse(row.interrupts)
-    };
-  }
-  async set(threadId, thread) {
-    const existingThread = this.db.prepare("SELECT thread_id FROM threads WHERE thread_id = ?").get(threadId);
-    if (!existingThread) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-    const updateFields = [];
-    const values = [];
-    if (thread.metadata !== void 0) {
-      updateFields.push("metadata = ?");
-      values.push(JSON.stringify(thread.metadata));
-    }
-    if (thread.status !== void 0) {
-      updateFields.push("status = ?");
-      values.push(thread.status);
-    }
-    if (thread.values !== void 0) {
-      updateFields.push("[values] = ?");
-      values.push(thread.values ? JSON.stringify(thread.values) : null);
-    }
-    if (thread.interrupts !== void 0) {
-      updateFields.push("interrupts = ?");
-      values.push(JSON.stringify(thread.interrupts));
-    }
-    updateFields.push("updated_at = ?");
-    values.push((/* @__PURE__ */ new Date()).toISOString());
-    if (updateFields.length > 0) {
-      values.push(threadId);
-      this.db.prepare(
-        `
-                UPDATE threads 
-                SET ${updateFields.join(", ")} 
-                WHERE thread_id = ?
-            `
-      ).run(...values);
-    }
-  }
-  async updateState(threadId, thread) {
-    const row = this.db.prepare("SELECT * FROM threads WHERE thread_id = ?").get(threadId);
-    if (!row) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-    const targetThread = {
-      thread_id: row.thread_id,
-      created_at: row.created_at,
-      updated_at: row.updated_at,
-      metadata: JSON.parse(row.metadata),
-      status: row.status,
-      values: row.values ? JSON.parse(row.values) : null,
-      interrupts: JSON.parse(row.interrupts)
-    };
-    if (targetThread.status === "busy") {
-      throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
-    }
-    if (!targetThread.metadata?.graph_id) {
-      throw new Error(`Thread with ID ${threadId} has no graph_id.`);
-    }
-    const graphId = targetThread.metadata?.graph_id;
-    const config = {
-      configurable: {
-        thread_id: threadId,
-        graph_id: graphId
-      }
-    };
-    const graph = await getGraph(graphId, config);
-    const nextConfig = await graph.updateState(config, thread.values);
-    const graphState = await graph.getState(config);
-    await this.set(threadId, { values: JSON.parse(serialiseAsDict(graphState.values)) });
-    return nextConfig;
-  }
-  async delete(threadId) {
-    const result = this.db.prepare("DELETE FROM threads WHERE thread_id = ?").run(threadId);
-    if (result.changes === 0) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-  }
-  async createRun(threadId, assistantId, payload) {
-    const runId = crypto.randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const metadata = JSON.stringify(payload?.metadata ?? {});
-    const run = {
-      run_id: runId,
-      thread_id: threadId,
-      assistant_id: assistantId,
-      created_at: now,
-      updated_at: now,
-      status: "pending",
-      metadata: payload?.metadata ?? {},
-      multitask_strategy: "reject"
-    };
-    this.db.prepare(
-      `
-            INSERT INTO runs (run_id, thread_id, assistant_id, created_at, updated_at, status, metadata, multitask_strategy)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        `
-    ).run(runId, threadId, assistantId, now, now, "pending", metadata, "reject");
-    return run;
-  }
-  async listRuns(threadId, options) {
-    let sql = "SELECT * FROM runs WHERE thread_id = ?";
-    const params = [threadId];
-    if (options?.status) {
-      sql += " AND status = ?";
-      params.push(options.status);
-    }
-    sql += " ORDER BY created_at DESC";
-    if (options?.limit) {
-      sql += ` LIMIT ${options.limit}`;
-      if (options?.offset) {
-        sql += ` OFFSET ${options.offset}`;
-      }
-    }
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => ({
-      run_id: row.run_id,
-      thread_id: row.thread_id,
-      assistant_id: row.assistant_id,
-      created_at: row.created_at,
-      updated_at: row.updated_at,
-      status: row.status,
-      metadata: JSON.parse(row.metadata),
-      multitask_strategy: row.multitask_strategy
-    }));
-  }
-  async updateRun(runId, run) {
-    const existingRun = this.db.prepare("SELECT run_id FROM runs WHERE run_id = ?").get(runId);
-    if (!existingRun) {
-      throw new Error(`Run with ID ${runId} not found.`);
-    }
-    const updateFields = [];
-    const values = [];
-    if (run.status !== void 0) {
-      updateFields.push("status = ?");
-      values.push(run.status);
-    }
-    if (run.metadata !== void 0) {
-      updateFields.push("metadata = ?");
-      values.push(JSON.stringify(run.metadata));
-    }
-    if (run.multitask_strategy !== void 0) {
-      updateFields.push("multitask_strategy = ?");
-      values.push(run.multitask_strategy);
-    }
-    updateFields.push("updated_at = ?");
-    values.push((/* @__PURE__ */ new Date()).toISOString());
-    if (updateFields.length > 0) {
-      values.push(runId);
-      this.db.prepare(
-        `
-                UPDATE runs 
-                SET ${updateFields.join(", ")} 
-                WHERE run_id = ?
-            `
-      ).run(...values);
-    }
-  }
-}
-
-class PostgresThreadsManager {
-  pool;
-  isSetup = false;
-  constructor(checkpointer) {
-    this.pool = checkpointer.pool;
-  }
-  async setup() {
-    if (this.isSetup) {
-      return;
-    }
-    await this.pool.query(`
-            CREATE TABLE IF NOT EXISTS threads (
-                thread_id TEXT PRIMARY KEY,
-                created_at TIMESTAMP NOT NULL,
-                updated_at TIMESTAMP NOT NULL,
-                metadata JSONB NOT NULL DEFAULT '{}',
-                status TEXT NOT NULL DEFAULT 'idle',
-                "values" JSONB,
-                interrupts JSONB NOT NULL DEFAULT '{}'
-            )
-        `);
-    await this.pool.query(`
-            CREATE TABLE IF NOT EXISTS runs (
-                run_id TEXT PRIMARY KEY,
-                thread_id TEXT NOT NULL,
-                assistant_id TEXT NOT NULL,
-                created_at TIMESTAMP NOT NULL,
-                updated_at TIMESTAMP NOT NULL,
-                status TEXT NOT NULL DEFAULT 'pending',
-                metadata JSONB NOT NULL DEFAULT '{}',
-                multitask_strategy TEXT NOT NULL DEFAULT 'reject',
-                FOREIGN KEY (thread_id) REFERENCES threads(thread_id) ON DELETE CASCADE
-            )
-        `);
-    await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_threads_status ON threads(status)`);
-    await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at)`);
-    await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`);
-    await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`);
-    await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`);
-    this.isSetup = true;
-  }
-  async create(payload) {
-    const threadId = payload?.threadId || crypto.randomUUID();
-    if (payload?.ifExists === "raise") {
-      const result = await this.pool.query("SELECT thread_id FROM threads WHERE thread_id = $1", [threadId]);
-      if (result.rows.length > 0) {
-        throw new Error(`Thread with ID ${threadId} already exists.`);
-      }
-    }
-    const now = /* @__PURE__ */ new Date();
-    const metadata = payload?.metadata || {};
-    const interrupts = {};
-    const thread = {
-      thread_id: threadId,
-      created_at: now.toISOString(),
-      updated_at: now.toISOString(),
-      metadata,
-      status: "idle",
-      values: null,
-      interrupts
-    };
-    await this.pool.query(
-      `
-            INSERT INTO threads (thread_id, created_at, updated_at, metadata, status, "values", interrupts)
-            VALUES ($1, $2, $3, $4, $5, $6, $7)
-        `,
-      [threadId, now, now, JSON.stringify(metadata), "idle", null, JSON.stringify(interrupts)]
-    );
-    return thread;
-  }
-  async search(query) {
-    let sql = "SELECT * FROM threads";
-    const whereConditions = [];
-    const params = [];
-    let paramIndex = 1;
-    if (query?.status) {
-      whereConditions.push(`status = $${paramIndex++}`);
-      params.push(query.status);
-    }
-    if (query?.metadata) {
-      for (const [key, value] of Object.entries(query.metadata)) {
-        whereConditions.push(`metadata->$${paramIndex} = $${paramIndex + 1}`);
-        params.push(key, JSON.stringify(value));
-        paramIndex += 2;
-      }
-    }
-    if (whereConditions.length > 0) {
-      sql += " WHERE " + whereConditions.join(" AND ");
-    }
-    if (query?.sortBy) {
-      sql += ` ORDER BY ${query.sortBy}`;
-      if (query.sortOrder === "desc") {
-        sql += " DESC";
-      } else {
-        sql += " ASC";
-      }
-    }
-    if (query?.limit) {
-      sql += ` LIMIT $${paramIndex++}`;
-      params.push(query.limit);
-      if (query?.offset) {
-        sql += ` OFFSET $${paramIndex++}`;
-        params.push(query.offset);
-      }
-    }
-    const result = await this.pool.query(sql, params);
-    return result.rows.map((row) => ({
-      thread_id: row.thread_id,
-      created_at: new Date(row.created_at).toISOString(),
-      updated_at: new Date(row.updated_at).toISOString(),
-      metadata: row.metadata,
-      status: row.status,
-      values: row.values || null,
-      interrupts: row.interrupts
-    }));
-  }
-  async get(threadId) {
-    const result = await this.pool.query("SELECT * FROM threads WHERE thread_id = $1", [threadId]);
-    if (result.rows.length === 0) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-    const row = result.rows[0];
-    return {
-      thread_id: row.thread_id,
-      created_at: new Date(row.created_at).toISOString(),
-      updated_at: new Date(row.updated_at).toISOString(),
-      metadata: row.metadata,
-      status: row.status,
-      values: row.values || null,
-      interrupts: row.interrupts
-    };
-  }
-  async set(threadId, thread) {
-    const existingThread = await this.pool.query("SELECT thread_id FROM threads WHERE thread_id = $1", [threadId]);
-    if (existingThread.rows.length === 0) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-    const updateFields = [];
-    const values = [];
-    let paramIndex = 1;
-    if (thread.metadata !== void 0) {
-      updateFields.push(`metadata = $${paramIndex++}`);
-      values.push(JSON.stringify(thread.metadata));
-    }
-    if (thread.status !== void 0) {
-      updateFields.push(`status = $${paramIndex++}`);
-      values.push(thread.status);
-    }
-    if (thread.values !== void 0) {
-      updateFields.push(`"values" = $${paramIndex++}`);
-      values.push(thread.values ? JSON.stringify(thread.values) : null);
-    }
-    if (thread.interrupts !== void 0) {
-      updateFields.push(`interrupts = $${paramIndex++}`);
-      values.push(JSON.stringify(thread.interrupts));
-    }
-    updateFields.push(`updated_at = $${paramIndex++}`);
-    values.push(/* @__PURE__ */ new Date());
-    if (updateFields.length > 0) {
-      values.push(threadId);
-      await this.pool.query(
-        `
-                UPDATE threads 
-                SET ${updateFields.join(", ")} 
-                WHERE thread_id = $${paramIndex}
-            `,
-        values
-      );
-    }
-  }
-  async updateState(threadId, thread) {
-    const result = await this.pool.query("SELECT * FROM threads WHERE thread_id = $1", [threadId]);
-    if (result.rows.length === 0) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-    const row = result.rows[0];
-    const targetThread = {
-      thread_id: row.thread_id,
-      created_at: new Date(row.created_at).toISOString(),
-      updated_at: new Date(row.updated_at).toISOString(),
-      metadata: row.metadata,
-      status: row.status,
-      values: row.values || null,
-      interrupts: row.interrupts
-    };
-    if (targetThread.status === "busy") {
-      throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
-    }
-    if (!targetThread.metadata?.graph_id) {
-      throw new Error(`Thread with ID ${threadId} has no graph_id.`);
-    }
-    const graphId = targetThread.metadata?.graph_id;
-    const config = {
-      configurable: {
-        thread_id: threadId,
-        graph_id: graphId
-      }
-    };
-    const graph = await getGraph(graphId, config);
-    const nextConfig = await graph.updateState(config, thread.values);
-    const graphState = await graph.getState(config);
-    await this.set(threadId, { values: JSON.parse(serialiseAsDict(graphState.values)) });
-    return nextConfig;
-  }
-  async delete(threadId) {
-    const result = await this.pool.query("DELETE FROM threads WHERE thread_id = $1", [threadId]);
-    if (result.rowCount === 0) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-  }
-  async createRun(threadId, assistantId, payload) {
-    const runId = crypto.randomUUID();
-    const now = /* @__PURE__ */ new Date();
-    const metadata = payload?.metadata ?? {};
-    const run = {
-      run_id: runId,
-      thread_id: threadId,
-      assistant_id: assistantId,
-      created_at: now.toISOString(),
-      updated_at: now.toISOString(),
-      status: "pending",
-      metadata,
-      multitask_strategy: "reject"
-    };
-    await this.pool.query(
-      `
-            INSERT INTO runs (run_id, thread_id, assistant_id, created_at, updated_at, status, metadata, multitask_strategy)
-            VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-        `,
-      [runId, threadId, assistantId, now, now, "pending", JSON.stringify(metadata), "reject"]
-    );
-    return run;
-  }
-  async listRuns(threadId, options) {
-    let sql = "SELECT * FROM runs WHERE thread_id = $1";
-    const params = [threadId];
-    let paramIndex = 2;
-    if (options?.status) {
-      sql += ` AND status = $${paramIndex++}`;
-      params.push(options.status);
-    }
-    sql += " ORDER BY created_at DESC";
-    if (options?.limit) {
-      sql += ` LIMIT $${paramIndex++}`;
-      params.push(options.limit);
-      if (options?.offset) {
-        sql += ` OFFSET $${paramIndex++}`;
-        params.push(options.offset);
-      }
-    }
-    const result = await this.pool.query(sql, params);
-    return result.rows.map((row) => ({
-      run_id: row.run_id,
-      thread_id: row.thread_id,
-      assistant_id: row.assistant_id,
-      created_at: new Date(row.created_at).toISOString(),
-      updated_at: new Date(row.updated_at).toISOString(),
-      status: row.status,
-      metadata: row.metadata,
-      multitask_strategy: row.multitask_strategy
-    }));
-  }
-  async updateRun(runId, run) {
-    const existingRun = await this.pool.query("SELECT run_id FROM runs WHERE run_id = $1", [runId]);
-    if (existingRun.rows.length === 0) {
-      throw new Error(`Run with ID ${runId} not found.`);
-    }
-    const updateFields = [];
-    const values = [];
-    let paramIndex = 1;
-    if (run.status !== void 0) {
-      updateFields.push(`status = $${paramIndex++}`);
-      values.push(run.status);
-    }
-    if (run.metadata !== void 0) {
-      updateFields.push(`metadata = $${paramIndex++}`);
-      values.push(JSON.stringify(run.metadata));
-    }
-    if (run.multitask_strategy !== void 0) {
-      updateFields.push(`multitask_strategy = $${paramIndex++}`);
-      values.push(run.multitask_strategy);
-    }
-    updateFields.push(`updated_at = $${paramIndex++}`);
-    values.push(/* @__PURE__ */ new Date());
-    if (updateFields.length > 0) {
-      values.push(runId);
-      await this.pool.query(
-        `
-                UPDATE runs 
-                SET ${updateFields.join(", ")} 
-                WHERE run_id = $${paramIndex}
-            `,
-        values
-      );
-    }
-  }
-}
-
 const createCheckPointer = async () => {
   if (process.env.REDIS_URL && process.env.CHECKPOINT_TYPE === "redis" || process.env.CHECKPOINT_TYPE === "shallow/redis") {
     if (process.env.CHECKPOINT_TYPE === "redis") {
@@ -1264,7 +888,7 @@ const createCheckPointer = async () => {
   }
   if (process.env.SQLITE_DATABASE_URI) {
     console.debug("LG | Using sqlite as checkpoint");
-    const { SqliteSaver } = await import('./checkpoint-DYSXoBLt.js');
+    const { SqliteSaver } = await import('./checkpoint-DnfHhpJw.js');
     const db = SqliteSaver.fromConnString(process.env.SQLITE_DATABASE_URI);
     return db;
   }
@@ -1274,7 +898,7 @@ const createMessageQueue = async () => {
   let q;
   if (process.env.REDIS_URL) {
     console.debug("LG | Using redis as stream queue");
-    const { RedisStreamQueue } = await import('./queue-CVAmN8_S.js');
+    const { RedisStreamQueue } = await import('./queue-CwCW8m0q.js');
     q = RedisStreamQueue;
   } else {
     q = MemoryStreamQueue;
@@ -1283,14 +907,20 @@ const createMessageQueue = async () => {
 };
 const createThreadManager = async (config) => {
   if (process.env.DATABASE_URL && config.checkpointer) {
-    const threadsManager = new PostgresThreadsManager(config.checkpointer);
+    console.debug("LG | Using PostgreSQL ThreadsManager");
+    const { PostgresAdapter } = await import('./pg-adapter-BFtir1GE.js');
+    const pool = config.checkpointer.pool;
+    const threadsManager = new KyselyThreadsManager(new PostgresAdapter(pool));
     if (process.env.DATABASE_INIT === "true") {
       await threadsManager.setup();
     }
     return threadsManager;
   }
   if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
-    const threadsManager = new SQLiteThreadsManager(config.checkpointer);
+    console.debug("LG | Using SQLite ThreadsManager");
+    const { SQLiteAdapter } = await import('./sqlite-adapter-BNYk10Gl.js');
+    const database = config.checkpointer.db;
+    const threadsManager = new KyselyThreadsManager(new SQLiteAdapter(database));
     await threadsManager.setup();
     return threadsManager;
   }
@@ -1481,4 +1111,4 @@ async function* streamState(threads, run, payload, options) {
 }
 
 export { BaseStreamQueue as B, CancelEventMessage as C, GRAPHS as G, LangGraphGlobal as L, streamState as a, getGraph as g, registerGraph as r, serialiseAsDict as s };
-//# sourceMappingURL=stream-BwdFJfJb.js.map
+//# sourceMappingURL=stream-SJdqjfOM.js.map