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

package/dist/client.d.mts

@@ -1,15 +1,17 @@
-import { Assistant, AssistantGraph, Config, GraphSchema, Metadata, Run, RunEvent, Thread, ThreadState } from "./schema.js";
+import { Assistant, AssistantGraph, Config, DefaultValues, 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;
     timeoutMs?: number;
+    defaultHeaders?: Record<string, string | null | undefined>;
 }
 declare class BaseClient {
     protected asyncCaller: AsyncCaller;
     protected timeoutMs: number;
     protected apiUrl: string;
+    protected defaultHeaders: Record<string, string | null | undefined>;
     constructor(config?: ClientConfig);
     protected prepareFetchOptions(path: string, options?: RequestInit & {
         json?: unknown;
@@ -21,90 +23,245 @@ declare class BaseClient {
     }): Promise<T>;
 }
 declare class AssistantsClient extends BaseClient {
+    /**
+     * Get an assistant by ID.
+     *
+     * @param assistantId The ID of the assistant.
+     * @returns Assistant
+     */
     get(assistantId: string): Promise<Assistant>;
+    /**
+     * Get the JSON representation of the graph assigned to a runnable
+     * @param assistantId The ID of the assistant.
+     * @returns Serialized graph
+     */
     getGraph(assistantId: string): Promise<AssistantGraph>;
+    /**
+     * Get the state and config schema of the graph assigned to a runnable
+     * @param assistantId The ID of the assistant.
+     * @returns Graph schema
+     */
     getSchemas(assistantId: string): Promise<GraphSchema>;
+    /**
+     * Create a new assistant.
+     * @param payload Payload for creating an assistant.
+     * @returns The created assistant.
+     */
     create(payload: {
-        graphId?: string;
+        graphId: string;
         config?: Config;
         metadata?: Metadata;
     }): Promise<Assistant>;
-    upsert(assistantId: string, payload: {
-        graphId?: string;
+    /**
+     * Update an assistant.
+     * @param assistantId ID of the assistant.
+     * @param payload Payload for updating the assistant.
+     * @returns The updated assistant.
+     */
+    update(assistantId: string, payload: {
+        graphId: string;
         config?: Config;
         metadata?: Metadata;
     }): Promise<Assistant>;
-    search(query: {
+    /**
+     * List assistants.
+     * @param query Query options.
+     * @returns List of assistants.
+     */
+    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(payload: {
+    /**
+     * 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.
+     */
+    update(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[]>;
-    getState(threadId: string): Promise<ThreadState>;
-    updateState(threadIdOrConfig: string | Config, values: Record<string, unknown>, options?: {
+    /**
+     * Get state for a thread.
+     *
+     * @param threadId ID of the thread.
+     * @returns Thread state.
+     */
+    getState<ValuesType = DefaultValues>(threadId: string, checkpointId?: string): Promise<ThreadState<ValuesType>>;
+    /**
+     * Add state to a thread.
+     *
+     * @param threadId The ID of the thread.
+     * @returns
+     */
+    updateState<ValuesType = DefaultValues>(threadId: string, options: {
+        values: ValuesType;
+        checkpointId?: string;
         asNode?: string;
     }): Promise<void>;
-    patchState(threadIdOrConfig: string | Config, metadata: Record<string, unknown>): Promise<void>;
-    getHistory(threadId: string, options?: {
+    /**
+     * Patch the metadata 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<ValuesType = DefaultValues>(threadId: string, options?: {
         limit?: number;
         before?: Config;
-    }): Promise<ThreadState[]>;
+        metadata?: Metadata;
+    }): Promise<ThreadState<ValuesType>[]>;
 }
 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<{
-        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 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: "events" | "metadata" | "debug" | "updates" | "values" | "messages/partial" | "messages/metadata" | "messages/complete" | (string & {});
+        data: any;
+    }>;
+    /**
+     * 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[]>;
 }
 export declare class Client {
+    /**
+     * The client for interacting with assistants.
+     */
     assistants: AssistantsClient;
+    /**
+     * The client for interacting with threads.
+     */
     threads: ThreadsClient;
+    /**
+     * The client for interacting with runs.
+     */
     runs: RunsClient;
     constructor(config?: ClientConfig);
 }

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", {
@@ -21,16 +21,26 @@ class BaseClient {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "defaultHeaders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.asyncCaller = new AsyncCaller({
-            maxRetries: 5,
-            maxConcurrency: 5,
+            maxRetries: 4,
+            maxConcurrency: 4,
             ...config?.callerOptions,
         });
         this.timeoutMs = config?.timeoutMs || 12_000;
         this.apiUrl = config?.apiUrl || "http://localhost:8123";
+        this.defaultHeaders = config?.defaultHeaders || {};
     }
     prepareFetchOptions(path, options) {
-        const mutatedOptions = { ...options };
+        const mutatedOptions = {
+            ...options,
+            headers: { ...this.defaultHeaders, ...options?.headers },
+        };
         if (mutatedOptions.json) {
             mutatedOptions.body = JSON.stringify(mutatedOptions.json);
             mutatedOptions.headers = {
@@ -59,29 +69,55 @@ class BaseClient {
     }
 }
 class AssistantsClient extends BaseClient {
+    /**
+     * Get an assistant by ID.
+     *
+     * @param assistantId The ID of the assistant.
+     * @returns Assistant
+     */
     async get(assistantId) {
         return this.fetch(`/assistants/${assistantId}`);
     }
+    /**
+     * Get the JSON representation of the graph assigned to a runnable
+     * @param assistantId The ID of the assistant.
+     * @returns Serialized graph
+     */
     async getGraph(assistantId) {
         return this.fetch(`/assistants/${assistantId}/graph`);
     }
+    /**
+     * Get the state and config schema of the graph assigned to a runnable
+     * @param assistantId The ID of the assistant.
+     * @returns Graph schema
+     */
     async getSchemas(assistantId) {
         return this.fetch(`/assistants/${assistantId}/schemas`);
     }
+    /**
+     * Create a new assistant.
+     * @param payload Payload for creating an assistant.
+     * @returns The created assistant.
+     */
     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) {
+    /**
+     * Update an assistant.
+     * @param assistantId ID of the assistant.
+     * @param payload Payload for updating the assistant.
+     * @returns The updated assistant.
+     */
+    async update(assistantId, payload) {
         return this.fetch(`/assistants/${assistantId}`, {
-            method: "PUT",
+            method: "PATCH",
             json: {
                 graph_id: payload.graphId,
                 config: payload.config,
@@ -89,70 +125,116 @@ class AssistantsClient extends BaseClient {
             },
         });
     }
+    /**
+     * List assistants.
+     * @param query Query options.
+     * @returns List of assistants.
+     */
     async search(query) {
         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 },
+            json: { metadata: payload?.metadata },
         });
     }
-    async upsert(threadId, payload) {
+    /**
+     * Update a thread.
+     *
+     * @param threadId ID of the thread.
+     * @param payload Payload for updating the thread.
+     * @returns The updated thread.
+     */
+    async update(threadId, payload) {
         return this.fetch(`/threads/${threadId}`, {
-            method: "PUT",
-            json: { metadata: payload },
+            method: "PATCH",
+            json: { metadata: payload?.metadata },
         });
     }
+    /**
+     * 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,
             },
         });
     }
-    async getState(threadId) {
-        return this.fetch(`/threads/${threadId}/state`);
+    /**
+     * Get state for a thread.
+     *
+     * @param threadId ID of the thread.
+     * @returns Thread state.
+     */
+    async getState(threadId, checkpointId) {
+        return this.fetch(checkpointId != null
+            ? `/threads/${threadId}/state/${checkpointId}`
+            : `/threads/${threadId}/state`);
     }
-    async updateState(threadIdOrConfig, values, options) {
-        let config = undefined;
-        let threadId;
-        if (typeof threadIdOrConfig !== "string") {
-            config = threadIdOrConfig;
-            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;
-        }
-        else {
-            config = undefined;
-            threadId = threadIdOrConfig;
-        }
+    /**
+     * Add state to a thread.
+     *
+     * @param threadId The ID of the thread.
+     * @returns
+     */
+    async updateState(threadId, options) {
         return this.fetch(`/threads/${threadId}/state`, {
             method: "POST",
-            json: { values, config, as_node: options?.asNode },
+            json: {
+                values: options.values,
+                checkpoint_id: options.checkpointId,
+                as_node: options?.asNode,
+            },
         });
     }
+    /**
+     * Patch the metadata 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,41 +251,60 @@ 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: {
+            method: "POST",
+            json: {
                 limit: options?.limit ?? 10,
                 before: options?.before,
+                metadata: options?.metadata,
             },
         });
     }
 }
 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,
+                feedback_keys: payload?.feedbackKeys,
                 assistant_id: assistantId,
-                interrupt_before: options?.interruptBefore,
-                interrupt_after: options?.interruptAfter,
+                interrupt_before: payload?.interruptBefore,
+                interrupt_after: payload?.interruptAfter,
             },
+            signal: payload?.signal,
         }));
         let parser;
         const textDecoder = new TextDecoder();
         const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })).pipeThrough(new TransformStream({
             async start(ctrl) {
                 parser = createParser((event) => {
-                    if (event.type === "event" && event.data === "[DONE]") {
+                    if ((payload?.signal && payload.signal.aborted) ||
+                        (event.type === "event" && event.data === "[DONE]")) {
                         ctrl.terminate();
                         return;
                     }
                     if ("data" in event) {
                         ctrl.enqueue({
-                            event: event.event ?? "event",
+                            event: event.event ?? "message",
                             data: JSON.parse(event.data),
                         });
                     }
@@ -213,35 +314,60 @@ 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,
             },
+            signal: payload?.signal,
         });
     }
-    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,
             },
+            signal: payload?.signal,
         });
     }
+    /**
+     * 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 +376,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: {
@@ -264,18 +405,27 @@ class RunsClient extends BaseClient {
 }
 export class Client {
     constructor(config) {
+        /**
+         * The client for interacting with assistants.
+         */
         Object.defineProperty(this, "assistants", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * The client for interacting with threads.
+         */
         Object.defineProperty(this, "threads", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * The client for interacting with runs.
+         */
         Object.defineProperty(this, "runs", {
             enumerable: true,
             configurable: true,

package/dist/index.d.mts

@@ -1 +1,2 @@
 export { Client } from "./client.mjs";
+export type { Assistant, AssistantGraph, Config, DefaultValues, GraphSchema, Metadata, Run, RunEvent, Thread, ThreadState, } from "./schema.js";

package/dist/schema.d.ts

@@ -1,24 +1,44 @@
+import type { JSONSchema7 } from "json-schema";
 type Optional<T> = T | null | undefined;
 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: {
+        /**
+         * ID of the thread
+         */
+        thread_id?: string;
+        /**
+         * Timestamp of the state checkpoint
+         */
+        thread_ts?: string;
+        [key: string]: unknown;
+    };
 }
 export interface GraphSchema {
+    /**
+     * The ID of the graph.
+     */
     graph_id: string;
-    state_schema: Record<string, unknown>;
-    config_schema: Record<string, unknown>;
+    /**
+     * The schema for the graph state
+     */
+    state_schema: JSONSchema7;
+    /**
+     * The schema for the graph config
+     */
+    config_schema: JSONSchema7;
 }
 export type Metadata = Optional<Record<string, unknown>>;
 export interface Assistant {
@@ -36,13 +56,14 @@ export interface Thread {
     updated_at: string;
     metadata: Metadata;
 }
-export interface ThreadState {
-    values: Record<string, unknown>[] | Record<string, unknown>;
+export type DefaultValues = Record<string, unknown>[] | Record<string, unknown>;
+export interface ThreadState<ValuesType = DefaultValues> {
+    values: ValuesType;
     next: string[];
-    config: Config;
+    checkpoint_id: string;
     metadata: Metadata;
     created_at: Optional<string>;
-    parent_config: Optional<Config>;
+    parent_checkpoint_id: Optional<string>;
 }
 export interface Run {
     run_id: string;

package/dist/types.d.mts

@@ -0,0 +1,53 @@
+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[];
+    /**
+     * Abort controller signal to cancel the run.
+     */
+    signal?: AbortController["signal"];
+}
+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>;
+    /**
+     * Pass one or more feedbackKeys if you want to request short-lived signed URLs
+     * for submitting feedback to LangSmith with this key for this run.
+     */
+    feedbackKeys?: string[];
+}
+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/async_caller.d.mts

@@ -24,8 +24,8 @@ export interface AsyncCallerCallOptions {
  * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
  * to `Infinity`. This means that by default, all calls will be made in parallel.
  *
- * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
- * means that by default, each call will be retried up to 6 times, with an
+ * Retries are limited by the `maxRetries` parameter, which defaults to 5. This
+ * means that by default, each call will be retried up to 5 times, with an
  * exponential backoff between each attempt.
  */
 export declare class AsyncCaller {

package/dist/utils/async_caller.mjs

@@ -9,10 +9,57 @@ const STATUS_NO_RETRY = [
     406, // Not Acceptable
     407, // Proxy Authentication Required
     408, // Request Timeout
+    422, // Unprocessable Entity
 ];
 const STATUS_IGNORE = [
     409, // Conflict
 ];
+/**
+ * Do not rely on globalThis.Response, rather just
+ * do duck typing
+ */
+function isResponse(x) {
+    if (x == null || typeof x !== "object")
+        return false;
+    return "status" in x && "statusText" in x && "text" in x;
+}
+/**
+ * Utility error to properly handle failed requests
+ */
+class HTTPError extends Error {
+    constructor(status, message, response) {
+        super(`HTTP ${status}: ${message}`);
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "text", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.status = status;
+        this.text = message;
+        this.response = response;
+    }
+    static async fromResponse(response, options) {
+        try {
+            return new HTTPError(response.status, await response.text(), options?.includeResponse ? response : undefined);
+        }
+        catch {
+            return new HTTPError(response.status, response.statusText, options?.includeResponse ? response : undefined);
+        }
+    }
+}
 /**
  * A class that can be used to make async calls with concurrency and retry logic.
  *
@@ -22,8 +69,8 @@ const STATUS_IGNORE = [
  * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
  * to `Infinity`. This means that by default, all calls will be made in parallel.
  *
- * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
- * means that by default, each call will be retried up to 6 times, with an
+ * Retries are limited by the `maxRetries` parameter, which defaults to 5. This
+ * means that by default, each call will be retried up to 5 times, with an
  * exponential backoff between each attempt.
  */
 export class AsyncCaller {
@@ -53,7 +100,7 @@ export class AsyncCaller {
             value: void 0
         });
         this.maxConcurrency = params.maxConcurrency ?? Infinity;
-        this.maxRetries = params.maxRetries ?? 6;
+        this.maxRetries = params.maxRetries ?? 4;
         if ("default" in PQueueMod) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.queue = new PQueueMod.default({
@@ -69,15 +116,15 @@ export class AsyncCaller {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     call(callable, ...args) {
         const onFailedResponseHook = this.onFailedResponseHook;
-        return this.queue.add(() => pRetry(() => callable(...args).catch((error) => {
+        return this.queue.add(() => pRetry(() => callable(...args).catch(async (error) => {
             // eslint-disable-next-line no-instanceof/no-instanceof
-            console.error;
             if (error instanceof Error) {
                 throw error;
             }
-            else if (error instanceof Response) {
-                // TODO: try to parse the response body and throw a more informative error
-                throw new Error(`HTTP ${error.status}: ${error.statusText}`);
+            else if (isResponse(error)) {
+                throw await HTTPError.fromResponse(error, {
+                    includeResponse: !!onFailedResponseHook,
+                });
             }
             else {
                 throw new Error(error);
@@ -93,18 +140,15 @@ export class AsyncCaller {
                 if (error?.code === "ECONNABORTED") {
                     throw error;
                 }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const response = error?.response;
-                const status = response?.status;
-                if (status) {
-                    if (STATUS_NO_RETRY.includes(+status)) {
+                if (error instanceof HTTPError) {
+                    if (STATUS_NO_RETRY.includes(error.status)) {
                         throw error;
                     }
-                    else if (STATUS_IGNORE.includes(+status)) {
+                    else if (STATUS_IGNORE.includes(error.status)) {
                         return;
                     }
-                    if (onFailedResponseHook) {
-                        await onFailedResponseHook(response);
+                    if (onFailedResponseHook && error.response) {
+                        await onFailedResponseHook(error.response);
                     }
                 }
             },

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.10",
   "description": "Client library for interacting with the LangGraph API",
   "type": "module",
   "packageManager": "yarn@1.22.19",
@@ -9,11 +9,14 @@
     "build": "yarn clean && yarn build:esm && yarn build:cjs && node scripts/create-entrypoints.js",
     "build:esm": "rm -f src/package.json && tsc --outDir dist/ && rm -rf dist/tests dist/**/tests",
     "build:cjs": "echo '{}' > src/package.json && tsc --outDir dist-cjs/ -p tsconfig.cjs.json && node scripts/move-cjs-to-dist.js && rm -r dist-cjs src/package.json",
-    "prepublish": "yarn run build"
+    "prepublish": "yarn run build",
+    "format": "prettier --write src",
+    "lint": "prettier --check src && tsc --noEmit"
   },
   "main": "index.js",
   "license": "MIT",
   "dependencies": {
+    "@types/json-schema": "^7.0.15",
     "eventsource-parser": "^1.1.2",
     "p-queue": "^6.6.2",
     "p-retry": "4",
@@ -23,6 +26,7 @@
     "@tsconfig/recommended": "^1.0.2",
     "@types/node": "^20.12.12",
     "@types/uuid": "^9.0.1",
+    "prettier": "^3.2.5",
     "typescript": "^5.4.5"
   },
   "exports": {