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

package/dist/client.d.mts

@@ -1,4 +1,4 @@
-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 { RunsCreatePayload, RunsStreamPayload, RunsWaitPayload } from "./types.mjs";
 interface ClientConfig {
@@ -21,19 +21,51 @@ 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;
         config?: Config;
         metadata?: Metadata;
     }): Promise<Assistant>;
+    /**
+     * Update an assistant.
+     * @param assistantId ID of the assistant.
+     * @param payload Payload for updating the assistant.
+     * @returns The updated assistant.
+     */
     upsert(assistantId: string, payload: {
         graphId: string;
         config?: Config;
         metadata?: Metadata;
     }): Promise<Assistant>;
+    /**
+     * List assistants.
+     * @param query Query options.
+     * @returns List of assistants.
+     */
     search(query?: {
         metadata?: Metadata;
         limit?: number;
@@ -54,7 +86,7 @@ declare class ThreadsClient extends BaseClient {
      * @param payload Payload for creating a thread.
      * @returns The created thread.
      */
-    create(payload: {
+    create(payload?: {
         /**
          * Metadata for the thread.
          */
@@ -106,7 +138,7 @@ declare class ThreadsClient extends BaseClient {
      * @param threadId ID of the thread.
      * @returns Thread state.
      */
-    getState(threadId: string): Promise<ThreadState>;
+    getState<ValuesType = DefaultValues>(threadId: string): Promise<ThreadState<ValuesType>>;
     /**
      * Add state to a thread.
      *
@@ -115,11 +147,12 @@ declare class ThreadsClient extends BaseClient {
      * @param options Additional options.
      * @returns
      */
-    updateState(threadIdOrConfig: string | Config, values: Record<string, unknown>, options?: {
+    updateState<ValuesType = DefaultValues>(threadIdOrConfig: string | Config, options: {
+        values: ValuesType;
         asNode?: string;
     }): Promise<void>;
     /**
-     * Patch the state of a thread.
+     * 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.
@@ -132,10 +165,10 @@ declare class ThreadsClient extends BaseClient {
      * @param options Additional options.
      * @returns List of thread states.
      */
-    getHistory(threadId: string, options?: {
+    getHistory<ValuesType = DefaultValues>(threadId: string, options?: {
         limit?: number;
         before?: Config;
-    }): Promise<ThreadState[]>;
+    }): Promise<ThreadState<ValuesType>[]>;
 }
 declare class RunsClient extends BaseClient {
     /**
@@ -146,8 +179,8 @@ declare class RunsClient extends BaseClient {
      * @param payload Payload for creating a run.
      */
     stream(threadId: string, assistantId: string, payload?: RunsStreamPayload): AsyncGenerator<{
-        event: string;
-        data: unknown;
+        event: "events" | "metadata" | "debug" | "updates" | "values" | "messages/partial" | "messages/metadata" | "messages/complete" | (string & {});
+        data: any;
     }>;
     /**
      * Create a run.
@@ -216,8 +249,17 @@ declare class RunsClient extends BaseClient {
     }): 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

@@ -22,8 +22,8 @@ class BaseClient {
             value: void 0
         });
         this.asyncCaller = new AsyncCaller({
-            maxRetries: 5,
-            maxConcurrency: 5,
+            maxRetries: 4,
+            maxConcurrency: 4,
             ...config?.callerOptions,
         });
         this.timeoutMs = config?.timeoutMs || 12_000;
@@ -59,15 +59,36 @@ 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",
@@ -78,6 +99,12 @@ class AssistantsClient extends BaseClient {
             },
         });
     }
+    /**
+     * Update an assistant.
+     * @param assistantId ID of the assistant.
+     * @param payload Payload for updating the assistant.
+     * @returns The updated assistant.
+     */
     async upsert(assistantId, payload) {
         return this.fetch(`/assistants/${assistantId}`, {
             method: "PUT",
@@ -88,6 +115,11 @@ class AssistantsClient extends BaseClient {
             },
         });
     }
+    /**
+     * List assistants.
+     * @param query Query options.
+     * @returns List of assistants.
+     */
     async search(query) {
         return this.fetch("/assistants/search", {
             method: "POST",
@@ -177,7 +209,7 @@ class ThreadsClient extends BaseClient {
      * @param options Additional options.
      * @returns
      */
-    async updateState(threadIdOrConfig, values, options) {
+    async updateState(threadIdOrConfig, options) {
         let config = undefined;
         let threadId;
         if (typeof threadIdOrConfig !== "string") {
@@ -193,11 +225,11 @@ class ThreadsClient extends BaseClient {
         }
         return this.fetch(`/threads/${threadId}/state`, {
             method: "POST",
-            json: { values, config, as_node: options?.asNode },
+            json: { values: options.values, config, as_node: options?.asNode },
         });
     }
     /**
-     * Patch the state of a thread.
+     * 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.
@@ -365,18 +397,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/schema.d.ts

@@ -19,8 +19,17 @@ export interface Config {
     };
 }
 export interface GraphSchema {
+    /**
+     * The ID of the graph.
+     */
     graph_id: string;
+    /**
+     * The schema for the graph state
+     */
     state_schema: Record<string, unknown>;
+    /**
+     * The schema for the graph config
+     */
     config_schema: Record<string, unknown>;
 }
 export type Metadata = Optional<Record<string, unknown>>;
@@ -39,8 +48,9 @@ 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;
     metadata: Metadata;

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/package.json

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