@langchain/langgraph-sdk 0.0.1-rc.0 → 0.0.1-rc.1

package/dist/client.d.mts

@@ -1,6 +1,6 @@
 import { Assistant, AssistantGraph, Config, GraphSchema, Metadata, Run, RunEvent, Thread, ThreadState } from "./schema.js";
 import { AsyncCaller, AsyncCallerParams } from "./utils/async_caller.mjs";
-import { IterableReadableStreamInterface } from "./utils/stream.mjs";
+import { RunsCreatePayload, RunsStreamPayload, RunsWaitPayload } from "./types.mjs";
 interface ClientConfig {
     apiUrl?: string;
     callerOptions?: AsyncCallerParams;
@@ -25,80 +25,193 @@ declare class AssistantsClient extends BaseClient {
     getGraph(assistantId: string): Promise<AssistantGraph>;
     getSchemas(assistantId: string): Promise<GraphSchema>;
     create(payload: {
-        graphId?: string;
+        graphId: string;
         config?: Config;
         metadata?: Metadata;
     }): Promise<Assistant>;
     upsert(assistantId: string, payload: {
-        graphId?: string;
+        graphId: string;
         config?: Config;
         metadata?: Metadata;
     }): Promise<Assistant>;
-    search(query: {
+    search(query?: {
         metadata?: Metadata;
         limit?: number;
         offset?: number;
     }): Promise<Assistant[]>;
 }
 declare class ThreadsClient extends BaseClient {
+    /**
+     * Get a thread by ID.
+     *
+     * @param threadId ID of the thread.
+     * @returns The thread.
+     */
     get(threadId: string): Promise<Thread>;
+    /**
+     * Create a new thread.
+     *
+     * @param payload Payload for creating a thread.
+     * @returns The created thread.
+     */
     create(payload: {
+        /**
+         * Metadata for the thread.
+         */
         metadata?: Metadata;
     }): Promise<Thread>;
-    upsert(threadId: string, payload: {
+    /**
+     * Update a thread.
+     *
+     * @param threadId ID of the thread.
+     * @param payload Payload for updating the thread.
+     * @returns The updated thread.
+     */
+    upsert(threadId: string, payload?: {
+        /**
+         * Metadata for the thread.
+         */
         metadata?: Metadata;
     }): Promise<Thread>;
+    /**
+     * Delete a thread.
+     *
+     * @param threadId ID of the thread.
+     */
     delete(threadId: string): Promise<void>;
-    search(query: {
+    /**
+     * List threads
+     *
+     * @param query Query options
+     * @returns List of threads
+     */
+    search(query?: {
+        /**
+         * Metadata to filter threads by.
+         */
         metadata?: Metadata;
+        /**
+         * Maximum number of threads to return.
+         * Defaults to 10
+         */
         limit?: number;
+        /**
+         * Offset to start from.
+         */
         offset?: number;
     }): Promise<Thread[]>;
+    /**
+     * Get state for a thread.
+     *
+     * @param threadId ID of the thread.
+     * @returns Thread state.
+     */
     getState(threadId: string): Promise<ThreadState>;
+    /**
+     * Add state to a thread.
+     *
+     * @param threadIdOrConfig Thread ID or config that identifies the state to start from.
+     * @param values The state update
+     * @param options Additional options.
+     * @returns
+     */
     updateState(threadIdOrConfig: string | Config, values: Record<string, unknown>, options?: {
         asNode?: string;
     }): Promise<void>;
-    patchState(threadIdOrConfig: string | Config, metadata: Record<string, unknown>): Promise<void>;
+    /**
+     * Patch the state of a thread.
+     *
+     * @param threadIdOrConfig Thread ID or config to patch the state of.
+     * @param metadata Metadata to patch the state with.
+     */
+    patchState(threadIdOrConfig: string | Config, metadata: Metadata): Promise<void>;
+    /**
+     * Get all past states for a thread.
+     *
+     * @param threadId ID of the thread.
+     * @param options Additional options.
+     * @returns List of thread states.
+     */
     getHistory(threadId: string, options?: {
         limit?: number;
         before?: Config;
     }): Promise<ThreadState[]>;
 }
 declare class RunsClient extends BaseClient {
-    stream(threadId: string, assistantId: string, options?: {
-        input?: Record<string, unknown>;
-        streamMode?: "values" | "messages" | "updates" | "events" | "debug";
-        metadata?: Metadata;
-        config?: Config;
-        interruptBefore?: string[];
-        interruptAfter?: string[];
-    }): Promise<IterableReadableStreamInterface<{
+    /**
+     * Create a run and stream the results.
+     *
+     * @param threadId The ID of the thread.
+     * @param assistantId Assistant ID to use for this run.
+     * @param payload Payload for creating a run.
+     */
+    stream(threadId: string, assistantId: string, payload?: RunsStreamPayload): AsyncGenerator<{
         event: string;
         data: unknown;
-    }>>;
-    create(threadId: string, assistantId: string, options?: {
-        input?: Record<string, unknown>;
-        metadata?: Metadata;
-        config?: Config;
-        interruptBefore?: string[];
-        interruptAfter?: string[];
-        webhook?: string;
-    }): Promise<Run>;
-    wait(threadId: string, assistantId: string, options?: {
-        input?: Record<string, unknown>;
-        streamMode?: "values" | "messages" | "updates" | "events" | "debug";
-        metadata?: Metadata;
-        config?: Config;
-        interruptBefore?: string[];
-        interruptAfter?: string[];
-    }): Promise<ThreadState["values"]>;
+    }>;
+    /**
+     * Create a run.
+     *
+     * @param threadId The ID of the thread.
+     * @param assistantId Assistant ID to use for this run.
+     * @param payload Payload for creating a run.
+     * @returns The created run.
+     */
+    create(threadId: string, assistantId: string, payload?: RunsCreatePayload): Promise<Run>;
+    /**
+     * Create a run and wait for it to complete.
+     *
+     * @param threadId The ID of the thread.
+     * @param assistantId Assistant ID to use for this run.
+     * @param payload Payload for creating a run.
+     * @returns The last values chunk of the thread.
+     */
+    wait(threadId: string, assistantId: string, payload?: RunsWaitPayload): Promise<ThreadState["values"]>;
+    /**
+     * List all runs for a thread.
+     *
+     * @param threadId The ID of the thread.
+     * @param options Filtering and pagination options.
+     * @returns List of runs.
+     */
     list(threadId: string, options?: {
+        /**
+         * Maximum number of runs to return.
+         * Defaults to 10
+         */
         limit?: number;
+        /**
+         * Offset to start from.
+         * Defaults to 0.
+         */
         offset?: number;
     }): Promise<Run[]>;
+    /**
+     * Get a run by ID.
+     *
+     * @param threadId The ID of the thread.
+     * @param runId The ID of the run.
+     * @returns The run.
+     */
     get(threadId: string, runId: string): Promise<Run>;
+    /**
+     * List all events for a run.
+     *
+     * @param threadId The ID of the thread.
+     * @param runId The ID of the run.
+     * @param options Filtering and pagination options.
+     * @returns List of events.
+     */
     listEvents(threadId: string, runId: string, options?: {
+        /**
+         * Maximum number of events to return.
+         * Defaults to 10
+         */
         limit?: number;
+        /**
+         * Offset to start from.
+         * Defaults to 0.
+         */
         offset?: number;
     }): Promise<RunEvent[]>;
 }

package/dist/client.mjs

@@ -1,6 +1,6 @@
 import { AsyncCaller } from "./utils/async_caller.mjs";
 import { createParser } from "eventsource-parser";
-import { IterableReadableStream, } from "./utils/stream.mjs";
+import { IterableReadableStream } from "./utils/stream.mjs";
 class BaseClient {
     constructor(config) {
         Object.defineProperty(this, "asyncCaller", {
@@ -71,12 +71,11 @@ class AssistantsClient extends BaseClient {
     async create(payload) {
         return this.fetch("/assistants", {
             method: "POST",
-            body: JSON.stringify({
+            json: {
                 graph_id: payload.graphId,
                 config: payload.config,
                 metadata: payload.metadata,
-            }),
-            headers: { "Content-Type": "application/json" },
+            },
         });
     }
     async upsert(assistantId, payload) {
@@ -93,53 +92,97 @@ class AssistantsClient extends BaseClient {
         return this.fetch("/assistants/search", {
             method: "POST",
             json: {
-                metadata: query.metadata ?? undefined,
-                limit: query.limit ?? 10,
-                offset: query.offset ?? 0,
+                metadata: query?.metadata ?? undefined,
+                limit: query?.limit ?? 10,
+                offset: query?.offset ?? 0,
             },
         });
     }
 }
 class ThreadsClient extends BaseClient {
+    /**
+     * Get a thread by ID.
+     *
+     * @param threadId ID of the thread.
+     * @returns The thread.
+     */
     async get(threadId) {
         return this.fetch(`/threads/${threadId}`);
     }
+    /**
+     * Create a new thread.
+     *
+     * @param payload Payload for creating a thread.
+     * @returns The created thread.
+     */
     async create(payload) {
         return this.fetch(`/threads`, {
             method: "POST",
             json: { metadata: payload },
         });
     }
+    /**
+     * Update a thread.
+     *
+     * @param threadId ID of the thread.
+     * @param payload Payload for updating the thread.
+     * @returns The updated thread.
+     */
     async upsert(threadId, payload) {
         return this.fetch(`/threads/${threadId}`, {
             method: "PUT",
             json: { metadata: payload },
         });
     }
+    /**
+     * Delete a thread.
+     *
+     * @param threadId ID of the thread.
+     */
     async delete(threadId) {
         return this.fetch(`/threads/${threadId}`, {
             method: "DELETE",
         });
     }
+    /**
+     * List threads
+     *
+     * @param query Query options
+     * @returns List of threads
+     */
     async search(query) {
         return this.fetch("/threads/search", {
             method: "POST",
             json: {
-                metadata: query.metadata ?? undefined,
-                limit: query.limit ?? 10,
-                offset: query.offset ?? 0,
+                metadata: query?.metadata ?? undefined,
+                limit: query?.limit ?? 10,
+                offset: query?.offset ?? 0,
             },
         });
     }
+    /**
+     * Get state for a thread.
+     *
+     * @param threadId ID of the thread.
+     * @returns Thread state.
+     */
     async getState(threadId) {
         return this.fetch(`/threads/${threadId}/state`);
     }
+    /**
+     * Add state to a thread.
+     *
+     * @param threadIdOrConfig Thread ID or config that identifies the state to start from.
+     * @param values The state update
+     * @param options Additional options.
+     * @returns
+     */
     async updateState(threadIdOrConfig, values, options) {
         let config = undefined;
         let threadId;
         if (typeof threadIdOrConfig !== "string") {
             config = threadIdOrConfig;
-            if (typeof config.configurable.thread_id !== "string") {
+            if (typeof config.configurable?.thread_id !== "string") {
                 throw new Error("Thread ID is required when updating state with a config.");
             }
             threadId = config.configurable.thread_id;
@@ -153,6 +196,12 @@ class ThreadsClient extends BaseClient {
             json: { values, config, as_node: options?.asNode },
         });
     }
+    /**
+     * Patch the state of a thread.
+     *
+     * @param threadIdOrConfig Thread ID or config to patch the state of.
+     * @param metadata Metadata to patch the state with.
+     */
     async patchState(threadIdOrConfig, metadata) {
         let threadId;
         if (typeof threadIdOrConfig !== "string") {
@@ -169,6 +218,13 @@ class ThreadsClient extends BaseClient {
             json: { metadata: metadata },
         });
     }
+    /**
+     * Get all past states for a thread.
+     *
+     * @param threadId ID of the thread.
+     * @param options Additional options.
+     * @returns List of thread states.
+     */
     async getHistory(threadId, options) {
         return this.fetch(`/threads/${threadId}/history`, {
             params: {
@@ -179,17 +235,24 @@ class ThreadsClient extends BaseClient {
     }
 }
 class RunsClient extends BaseClient {
-    async stream(threadId, assistantId, options) {
+    /**
+     * Create a run and stream the results.
+     *
+     * @param threadId The ID of the thread.
+     * @param assistantId Assistant ID to use for this run.
+     * @param payload Payload for creating a run.
+     */
+    async *stream(threadId, assistantId, payload) {
         const response = await this.asyncCaller.fetch(...this.prepareFetchOptions(`/threads/${threadId}/runs/stream`, {
             method: "POST",
             json: {
-                input: options?.input,
-                config: options?.config,
-                metadata: options?.metadata,
-                stream_mode: options?.streamMode,
+                input: payload?.input,
+                config: payload?.config,
+                metadata: payload?.metadata,
+                stream_mode: payload?.streamMode,
                 assistant_id: assistantId,
-                interrupt_before: options?.interruptBefore,
-                interrupt_after: options?.interruptAfter,
+                interrupt_before: payload?.interruptBefore,
+                interrupt_after: payload?.interruptAfter,
             },
         }));
         let parser;
@@ -203,7 +266,7 @@ class RunsClient extends BaseClient {
                     }
                     if ("data" in event) {
                         ctrl.enqueue({
-                            event: event.event ?? "event",
+                            event: event.event ?? "message",
                             data: JSON.parse(event.data),
                         });
                     }
@@ -213,35 +276,58 @@ class RunsClient extends BaseClient {
                 parser.feed(textDecoder.decode(chunk));
             },
         }));
-        return IterableReadableStream.fromReadableStream(stream);
+        yield* IterableReadableStream.fromReadableStream(stream);
     }
-    async create(threadId, assistantId, options) {
+    /**
+     * Create a run.
+     *
+     * @param threadId The ID of the thread.
+     * @param assistantId Assistant ID to use for this run.
+     * @param payload Payload for creating a run.
+     * @returns The created run.
+     */
+    async create(threadId, assistantId, payload) {
         return this.fetch(`/threads/${threadId}/runs`, {
             method: "POST",
             json: {
-                input: options?.input,
-                config: options?.config,
-                metadata: options?.metadata,
+                input: payload?.input,
+                config: payload?.config,
+                metadata: payload?.metadata,
                 assistant_id: assistantId,
-                interrupt_before: options?.interruptBefore,
-                interrupt_after: options?.interruptAfter,
-                webhook: options?.webhook,
+                interrupt_before: payload?.interruptBefore,
+                interrupt_after: payload?.interruptAfter,
+                webhook: payload?.webhook,
             },
         });
     }
-    async wait(threadId, assistantId, options) {
+    /**
+     * Create a run and wait for it to complete.
+     *
+     * @param threadId The ID of the thread.
+     * @param assistantId Assistant ID to use for this run.
+     * @param payload Payload for creating a run.
+     * @returns The last values chunk of the thread.
+     */
+    async wait(threadId, assistantId, payload) {
         return this.fetch(`/threads/${threadId}/runs/wait`, {
             method: "POST",
             json: {
-                input: options?.input,
-                config: options?.config,
-                metadata: options?.metadata,
+                input: payload?.input,
+                config: payload?.config,
+                metadata: payload?.metadata,
                 assistant_id: assistantId,
-                interrupt_before: options?.interruptBefore,
-                interrupt_after: options?.interruptAfter,
+                interrupt_before: payload?.interruptBefore,
+                interrupt_after: payload?.interruptAfter,
             },
         });
     }
+    /**
+     * List all runs for a thread.
+     *
+     * @param threadId The ID of the thread.
+     * @param options Filtering and pagination options.
+     * @returns List of runs.
+     */
     async list(threadId, options) {
         return this.fetch(`/threads/${threadId}/runs`, {
             params: {
@@ -250,9 +336,24 @@ class RunsClient extends BaseClient {
             },
         });
     }
+    /**
+     * Get a run by ID.
+     *
+     * @param threadId The ID of the thread.
+     * @param runId The ID of the run.
+     * @returns The run.
+     */
     async get(threadId, runId) {
         return this.fetch(`/threads/${threadId}/runs/${runId}`);
     }
+    /**
+     * List all events for a run.
+     *
+     * @param threadId The ID of the thread.
+     * @param runId The ID of the run.
+     * @param options Filtering and pagination options.
+     * @returns List of events.
+     */
     async listEvents(threadId, runId, options) {
         return this.fetch(`/threads/${threadId}/runs/${runId}/events`, {
             params: {

package/dist/schema.d.ts

@@ -4,16 +4,19 @@ export interface Config {
      * Tags for this call and any sub-calls (eg. a Chain calling an LLM).
      * You can use these to filter calls.
      */
-    tags: string[];
+    tags?: string[];
     /**
      * Maximum number of times a call can recurse.
      * If not provided, defaults to 25.
      */
-    recursion_limit: number;
+    recursion_limit?: number;
     /**
      * Runtime values for attributes previously made configurable on this Runnable.
      */
-    configurable: Record<string, unknown>;
+    configurable: {
+        thread_id?: string;
+        [key: string]: unknown;
+    };
 }
 export interface GraphSchema {
     graph_id: string;

package/dist/types.d.mts

@@ -0,0 +1,44 @@
+import { Config, Metadata } from "./schema.js";
+export type StreamMode = "values" | "messages" | "updates" | "events" | "debug";
+interface RunsInvokePayload {
+    /**
+     * Input to the run. Pass `null` to resume from the current state of the thread.
+     */
+    input?: Record<string, unknown> | null;
+    /**
+     * Metadata for the run.
+     */
+    metadata?: Metadata;
+    /**
+     * Additional configuration for the run.
+     */
+    config?: Config;
+    /**
+     * Interrupt execution before entering these nodes.
+     */
+    interruptBefore?: string[];
+    /**
+     * Interrupt execution after leaving these nodes.
+     */
+    interruptAfter?: string[];
+}
+export interface RunsStreamPayload extends RunsInvokePayload {
+    /**
+     * One of `"values"`, `"messages"`, `"updates"` or `"events"`.
+     * - `"values"`: Stream the thread state any time it changes.
+     * - `"messages"`: Stream chat messages from thread state and calls to chat models,
+     *                 token-by-token where possible.
+     * - `"updates"`: Stream the state updates returned by each node.
+     * - `"events"`: Stream all events produced by the run. You can also access these
+     *               afterwards using the `client.runs.listEvents()` method.
+     */
+    streamMode?: StreamMode | Array<StreamMode>;
+}
+export interface RunsCreatePayload extends RunsInvokePayload {
+    /**
+     * Webhook to call when the run is complete.
+     */
+    webhook?: string;
+}
+export type RunsWaitPayload = RunsStreamPayload;
+export {};

package/dist/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/utils/stream.d.mts

@@ -1,4 +1,4 @@
-export type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;
+type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;
 export declare class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {
     reader: ReadableStreamDefaultReader<T>;
     ensureReader(): void;
@@ -9,3 +9,4 @@ export declare class IterableReadableStream<T> extends ReadableStream<T> impleme
     static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;
     static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;
 }
+export {};

package/package.json

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