@langchain/langgraph-sdk 0.0.8 → 0.0.9

package/dist/client.d.mts

@@ -85,6 +85,8 @@ export declare class AssistantsClient extends BaseClient {
         graphId: string;
         config?: Config;
         metadata?: Metadata;
+        assistantId?: string;
+        ifExists?: OnConflictBehavior;
     }): Promise<Assistant>;
     /**
      * Update an assistant.
@@ -93,7 +95,7 @@ export declare class AssistantsClient extends BaseClient {
      * @returns The updated assistant.
      */
     update(assistantId: string, payload: {
-        graphId: string;
+        graphId?: string;
         config?: Config;
         metadata?: Metadata;
     }): Promise<Assistant>;
@@ -222,7 +224,7 @@ export declare class ThreadsClient extends BaseClient {
     }): Promise<ThreadState<ValuesType>[]>;
 }
 export declare class RunsClient extends BaseClient {
-    stream(threadId: null, assistantId: string, payload?: Omit<RunsStreamPayload, "multitaskStrategy">): AsyncGenerator<{
+    stream(threadId: null, assistantId: string, payload?: Omit<RunsStreamPayload, "multitaskStrategy" | "onCompletion">): AsyncGenerator<{
         event: StreamEvent;
         data: any;
     }>;
@@ -239,7 +241,16 @@ export declare class RunsClient extends BaseClient {
      * @returns The created run.
      */
     create(threadId: string, assistantId: string, payload?: RunsCreatePayload): Promise<Run>;
-    wait(threadId: null, assistantId: string, payload?: Omit<RunsWaitPayload, "multitaskStrategy">): Promise<ThreadState["values"]>;
+    /**
+     * Create a batch of stateless background runs.
+     *
+     * @param payloads An array of payloads for creating runs.
+     * @returns An array of created runs.
+     */
+    createBatch(payloads: (RunsCreatePayload & {
+        assistantId: string;
+    })[]): Promise<Run[]>;
+    wait(threadId: null, assistantId: string, payload?: Omit<RunsWaitPayload, "multitaskStrategy" | "onCompletion">): Promise<ThreadState["values"]>;
     wait(threadId: string, assistantId: string, payload?: RunsWaitPayload): Promise<ThreadState["values"]>;
     /**
      * List all runs for a thread.
@@ -285,6 +296,20 @@ export declare class RunsClient extends BaseClient {
      * @returns
      */
     join(threadId: string, runId: string): Promise<void>;
+    /**
+     * Stream output from a run in real-time, until the run is done.
+     * Output is not buffered, so any output produced before this call will
+     * not be received here.
+     *
+     * @param threadId The ID of the thread.
+     * @param runId The ID of the run.
+     * @param signal An optional abort signal.
+     * @returns An async generator yielding stream parts.
+     */
+    joinStream(threadId: string, runId: string, signal?: AbortSignal): AsyncGenerator<{
+        event: StreamEvent;
+        data: any;
+    }>;
     /**
      * Delete a run.
      *

package/dist/client.mjs

@@ -92,6 +92,7 @@ export class CronsClient extends BaseClient {
             interrupt_before: payload?.interruptBefore,
             interrupt_after: payload?.interruptAfter,
             webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
         };
         return this.fetch(`/threads/${threadId}/runs/crons`, {
             method: "POST",
@@ -114,6 +115,7 @@ export class CronsClient extends BaseClient {
             interrupt_before: payload?.interruptBefore,
             interrupt_after: payload?.interruptAfter,
             webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
         };
         return this.fetch(`/runs/crons`, {
             method: "POST",
@@ -184,6 +186,8 @@ export class AssistantsClient extends BaseClient {
                 graph_id: payload.graphId,
                 config: payload.config,
                 metadata: payload.metadata,
+                assistant_id: payload.assistantId,
+                if_exists: payload.ifExists,
             },
         });
     }
@@ -391,10 +395,11 @@ export class RunsClient extends BaseClient {
             interrupt_before: payload?.interruptBefore,
             interrupt_after: payload?.interruptAfter,
             checkpoint_id: payload?.checkpointId,
+            webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
+            on_completion: payload?.onCompletion,
+            on_disconnect: payload?.onDisconnect,
         };
-        if (payload?.multitaskStrategy != null) {
-            json["multitask_strategy"] = payload?.multitaskStrategy;
-        }
         const endpoint = threadId == null ? `/runs/stream` : `/threads/${threadId}/runs/stream`;
         const response = await this.asyncCaller.fetch(...this.prepareFetchOptions(endpoint, {
             method: "POST",
@@ -452,16 +457,31 @@ export class RunsClient extends BaseClient {
             interrupt_after: payload?.interruptAfter,
             webhook: payload?.webhook,
             checkpoint_id: payload?.checkpointId,
+            multitask_strategy: payload?.multitaskStrategy,
         };
-        if (payload?.multitaskStrategy != null) {
-            json["multitask_strategy"] = payload?.multitaskStrategy;
-        }
         return this.fetch(`/threads/${threadId}/runs`, {
             method: "POST",
             json,
             signal: payload?.signal,
         });
     }
+    /**
+     * Create a batch of stateless background runs.
+     *
+     * @param payloads An array of payloads for creating runs.
+     * @returns An array of created runs.
+     */
+    async createBatch(payloads) {
+        const filteredPayloads = payloads
+            .map((payload) => ({ ...payload, assistant_id: payload.assistantId }))
+            .map((payload) => {
+            return Object.fromEntries(Object.entries(payload).filter(([_, v]) => v !== undefined));
+        });
+        return this.fetch("/runs/batch", {
+            method: "POST",
+            json: filteredPayloads,
+        });
+    }
     /**
      * Create a run and wait for it to complete.
      *
@@ -479,10 +499,11 @@ export class RunsClient extends BaseClient {
             interrupt_before: payload?.interruptBefore,
             interrupt_after: payload?.interruptAfter,
             checkpoint_id: payload?.checkpointId,
+            webhook: payload?.webhook,
+            multitask_strategy: payload?.multitaskStrategy,
+            on_completion: payload?.onCompletion,
+            on_disconnect: payload?.onDisconnect,
         };
-        if (payload?.multitaskStrategy != null) {
-            json["multitask_strategy"] = payload?.multitaskStrategy;
-        }
         const endpoint = threadId == null ? `/runs/wait` : `/threads/${threadId}/runs/wait`;
         return this.fetch(endpoint, {
             method: "POST",
@@ -541,6 +562,54 @@ export class RunsClient extends BaseClient {
     async join(threadId, runId) {
         return this.fetch(`/threads/${threadId}/runs/${runId}/join`);
     }
+    /**
+     * Stream output from a run in real-time, until the run is done.
+     * Output is not buffered, so any output produced before this call will
+     * not be received here.
+     *
+     * @param threadId The ID of the thread.
+     * @param runId The ID of the run.
+     * @param signal An optional abort signal.
+     * @returns An async generator yielding stream parts.
+     */
+    async *joinStream(threadId, runId, signal) {
+        const response = await this.asyncCaller.fetch(...this.prepareFetchOptions(`/threads/${threadId}/runs/${runId}/stream`, {
+            method: "GET",
+            signal,
+        }));
+        let parser;
+        let onEndEvent;
+        const textDecoder = new TextDecoder();
+        const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })).pipeThrough(new TransformStream({
+            async start(ctrl) {
+                parser = createParser((event) => {
+                    if ((signal && signal.aborted) ||
+                        (event.type === "event" && event.data === "[DONE]")) {
+                        ctrl.terminate();
+                        return;
+                    }
+                    if ("data" in event) {
+                        ctrl.enqueue({
+                            event: event.event ?? "message",
+                            data: JSON.parse(event.data),
+                        });
+                    }
+                });
+                onEndEvent = () => {
+                    ctrl.enqueue({ event: "end", data: undefined });
+                };
+            },
+            async transform(chunk) {
+                const payload = textDecoder.decode(chunk);
+                parser.feed(payload);
+                // eventsource-parser will ignore events
+                // that are not terminated by a newline
+                if (payload.trim() === "event: end")
+                    onEndEvent();
+            },
+        }));
+        yield* IterableReadableStream.fromReadableStream(stream);
+    }
     /**
      * Delete a run.
      *

package/dist/types.d.mts

@@ -2,6 +2,8 @@ import { Config, Metadata } from "./schema.js";
 export type StreamMode = "values" | "messages" | "updates" | "events" | "debug";
 export type MultitaskStrategy = "reject" | "interrupt" | "rollback" | "enqueue";
 export type OnConflictBehavior = "raise" | "do_nothing";
+export type OnCompletionBehavior = "complete" | "continue";
+export type DisconnectMode = "cancel" | "continue";
 export type StreamEvent = "events" | "metadata" | "debug" | "updates" | "values" | "messages/partial" | "messages/metadata" | "messages/complete" | (string & {});
 interface RunsInvokePayload {
     /**
@@ -43,6 +45,24 @@ interface RunsInvokePayload {
      * Abort controller signal to cancel the run.
      */
     signal?: AbortController["signal"];
+    /**
+     * Behavior to handle run completion. Only relevant if
+     * there is a pending/inflight run on the same thread. One of:
+     * - "complete": Complete the run.
+     * - "continue": Continue the run.
+     */
+    onCompletion?: OnCompletionBehavior;
+    /**
+     * Webhook to call when the run is complete.
+     */
+    webhook?: string;
+    /**
+     * Behavior to handle disconnection. Only relevant if
+     * there is a pending/inflight run on the same thread. One of:
+     * - "cancel": Cancel the run.
+     * - "continue": Continue the run.
+     */
+    onDisconnect?: DisconnectMode;
 }
 export interface RunsStreamPayload extends RunsInvokePayload {
     /**
@@ -62,10 +82,6 @@ export interface RunsStreamPayload extends RunsInvokePayload {
     feedbackKeys?: string[];
 }
 export interface RunsCreatePayload extends RunsInvokePayload {
-    /**
-     * Webhook to call when the run is complete.
-     */
-    webhook?: string;
 }
 export interface CronsCreatePayload extends RunsCreatePayload {
     /**

package/dist/utils/async_caller.d.mts

@@ -16,7 +16,7 @@ export interface AsyncCallerParams {
      *
      * By default we expect the `fetch` is available in the global scope.
      */
-    fetch?: typeof fetch;
+    fetch?: typeof fetch | ((...args: any[]) => any);
 }
 export interface AsyncCallerCallOptions {
     signal?: AbortSignal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-sdk",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Client library for interacting with the LangGraph API",
   "type": "module",
   "packageManager": "yarn@1.22.19",