@langchain/langgraph-api 0.0.60 → 0.0.62

package/dist/http/middleware.mjs

@@ -16,7 +16,7 @@ export const cors = (cors) => {
                 return origin;
             return undefined;
         }
-        : cors.allow_origins ?? [];
+        : cors.allow_origins;
     if (cors.expose_headers?.length) {
         const headersSet = new Set(cors.expose_headers.map((h) => h.toLowerCase()));
         if (!headersSet.has("content-location")) {
@@ -28,15 +28,19 @@ export const cors = (cors) => {
             cors.expose_headers.push("x-pagination-total");
         }
     }
-    // TODO: handle `cors.allow_credentials`
-    return honoCors({
-        origin,
-        maxAge: cors.max_age,
-        allowMethods: cors.allow_methods,
-        allowHeaders: cors.allow_headers,
-        credentials: cors.allow_credentials,
-        exposeHeaders: cors.expose_headers,
-    });
+    const config = { origin: origin ?? "*" };
+    if (cors.max_age != null)
+        config.maxAge = cors.max_age;
+    if (cors.allow_methods != null)
+        config.allowMethods = cors.allow_methods;
+    if (cors.allow_headers != null)
+        config.allowHeaders = cors.allow_headers;
+    if (cors.expose_headers != null)
+        config.exposeHeaders = cors.expose_headers;
+    if (cors.allow_credentials != null) {
+        config.credentials = cors.allow_credentials;
+    }
+    return honoCors(config);
 };
 // This is used to match the behavior of the original LangGraph API
 // where the content-type is not being validated. Might be nice

package/dist/loopback.d.mts

@@ -1,3 +1,4 @@
 import { Hono } from "hono";
+import type { StorageEnv } from "./storage/types.mjs";
 export declare function getLoopbackFetch(): (url: string, init?: RequestInit) => Promise<Response>;
-export declare const bindLoopbackFetch: (app: Hono) => void;
+export declare const bindLoopbackFetch: (app: Hono<StorageEnv>) => void;

package/dist/queue.d.mts

@@ -1 +1,2 @@
-export declare const queue: () => Promise<never>;
+import type { Ops } from "./storage/types.mjs";
+export declare const queue: (ops: Ops) => Promise<never>;

package/dist/queue.mjs

@@ -1,4 +1,3 @@
-import { Runs, Threads } from "./storage/ops.mjs";
 import { streamState, } from "./stream.mjs";
 import { logError, logger } from "./logging.mjs";
 import { serializeError } from "./utils/serde.mjs";
@@ -6,16 +5,16 @@ import { callWebhook } from "./webhook.mjs";
 import { getGraph } from "./graph/load.mjs";
 const MAX_RETRY_ATTEMPTS = 3;
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-export const queue = async () => {
+export const queue = async (ops) => {
     while (true) {
-        for await (const { run, attempt, signal } of Runs.next()) {
-            await worker(run, attempt, signal);
+        for await (const { run, attempt, signal } of ops.runs.next()) {
+            await worker(ops, run, attempt, signal);
         }
         // TODO: this is very suboptimal, we should implement subscription to the run
         await sleep(1000 * Math.random());
     }
 };
-const worker = async (run, attempt, signal) => {
+const worker = async (ops, run, attempt, signal) => {
     const startedAt = new Date();
     let endedAt = undefined;
     let checkpoint = undefined;
@@ -56,11 +55,11 @@ const worker = async (run, attempt, signal) => {
                 ...(!temporary ? { onCheckpoint, onTaskResult } : undefined),
             });
             for await (const { event, data } of stream) {
-                await Runs.Stream.publish({ runId, resumable, event, data });
+                await ops.runs.stream.publish({ runId, resumable, event, data });
             }
         }
         catch (error) {
-            await Runs.Stream.publish({
+            await ops.runs.stream.publish({
                 runId,
                 resumable,
                 event: "error",
@@ -78,7 +77,7 @@ const worker = async (run, attempt, signal) => {
             run_exec_ms: endedAt.valueOf() - startedAt.valueOf(),
         });
         status = "success";
-        await Runs.setStatus(run.run_id, status);
+        await ops.runs.setStatus(run.run_id, status);
     }
     catch (error) {
         endedAt = new Date();
@@ -96,14 +95,14 @@ const worker = async (run, attempt, signal) => {
             },
         });
         status = "error";
-        await Runs.setStatus(run.run_id, "error");
+        await ops.runs.setStatus(run.run_id, "error");
     }
     finally {
         if (temporary) {
-            await Threads.delete(run.thread_id, undefined);
+            await ops.threads.delete(run.thread_id, undefined);
         }
         else {
-            await Threads.setStatus(run.thread_id, { checkpoint, exception });
+            await ops.threads.setStatus(run.thread_id, { checkpoint, exception });
         }
         if (webhook) {
             await callWebhook({