@langgraph-js/pure-graph 1.4.5 → 1.4.6

package/dist/adapter/hono/index.js

@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
 import { zValidator } from '@hono/zod-validator';
-import { c as createEndpoint, s as serialiseAsDict } from '../../createEndpoint-BcVhF-uq.js';
+import { c as createEndpoint, s as serialiseAsDict } from '../../createEndpoint-B0FQz0jr.js';
 import { A as AssistantsSearchSchema, a as AssistantGraphQuerySchema, T as ThreadIdParamSchema, R as RunStreamPayloadSchema, b as RunListQuerySchema, c as RunIdParamSchema, d as RunCancelQuerySchema, e as ThreadStateUpdate, f as ThreadCreatePayloadSchema, g as ThreadSearchPayloadSchema } from '../../zod-BaCzVUl8.js';
 import { streamSSE } from 'hono/streaming';
 import z from 'zod';

package/dist/adapter/nextjs/index.js

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server';
-import { c as createEndpoint, s as serialiseAsDict } from '../../createEndpoint-BcVhF-uq.js';
+import { c as createEndpoint, s as serialiseAsDict } from '../../createEndpoint-B0FQz0jr.js';
 import { a as AssistantGraphQuerySchema, b as RunListQuerySchema, A as AssistantsSearchSchema, f as ThreadCreatePayloadSchema, g as ThreadSearchPayloadSchema, e as ThreadStateUpdate, R as RunStreamPayloadSchema, d as RunCancelQuerySchema } from '../../zod-BaCzVUl8.js';
 
 const client = createEndpoint();

package/dist/{createEndpoint-BcVhF-uq.js → createEndpoint-B0FQz0jr.js}

@@ -942,6 +942,304 @@ class SQLiteThreadsManager {
   }
 }
 
+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") {
@@ -976,7 +1274,7 @@ const createMessageQueue = async () => {
   let q;
   if (process.env.REDIS_URL) {
     console.debug("LG | Using redis as stream queue");
-    const { RedisStreamQueue } = await import('./queue-pSZu1PVS.js');
+    const { RedisStreamQueue } = await import('./queue-Cao_-0hm.js');
     q = RedisStreamQueue;
   } else {
     q = MemoryStreamQueue;
@@ -985,7 +1283,6 @@ const createMessageQueue = async () => {
 };
 const createThreadManager = async (config) => {
   if (process.env.DATABASE_URL && config.checkpointer) {
-    const { PostgresThreadsManager } = await import('./threads-amMaxKul.js');
     const threadsManager = new PostgresThreadsManager(config.checkpointer);
     if (process.env.DATABASE_INIT === "true") {
       await threadsManager.setup();
@@ -1249,5 +1546,5 @@ const createEndpoint = () => {
   };
 };
 
-export { AssistantEndpoint as A, BaseStreamQueue as B, CancelEventMessage as C, LangGraphGlobal as L, createEndpoint as c, getGraph as g, registerGraph as r, serialiseAsDict as s };
-//# sourceMappingURL=createEndpoint-BcVhF-uq.js.map
+export { AssistantEndpoint as A, BaseStreamQueue as B, CancelEventMessage as C, LangGraphGlobal as L, createEndpoint as c, registerGraph as r, serialiseAsDict as s };
+//# sourceMappingURL=createEndpoint-B0FQz0jr.js.map