@langchain/langgraph-sdk 1.3.1 → 1.4.5

package/dist/ui/types.d.ts

@@ -0,0 +1,420 @@
+import { Checkpoint, Config, Metadata, ThreadState } from "../schema.js";
+import { AIMessage, DefaultToolCall } from "../types.messages.js";
+import { CheckpointsStreamEvent, CustomStreamEvent, DebugStreamEvent, EventsStreamEvent, MetadataStreamEvent, StreamMode, TasksStreamEvent, UpdatesStreamEvent } from "../types.stream.js";
+import { Command, DisconnectMode, Durability, MultitaskStrategy, OnCompletionBehavior } from "../types.js";
+import { Client, ClientConfig } from "../client.js";
+import { BagTemplate } from "../types.template.js";
+
+//#region src/ui/types.d.ts
+
+/**
+ * Minimal interface matching the structure of AgentTypeConfig from @langchain/langgraph.
+ * This allows type inference from ReactAgent without requiring the langchain dependency.
+ */
+interface AgentTypeConfigLike {
+  Response: unknown;
+  State: unknown;
+  Context: unknown;
+  Middleware: unknown;
+  Tools: unknown;
+}
+/**
+ * Check if a type is agent-like (has `~agentTypes` phantom property).
+ * This property is present on `ReactAgent` instances created with `createAgent`.
+ */
+type IsAgentLike<T> = T extends {
+  "~agentTypes": AgentTypeConfigLike;
+} ? true : false;
+/**
+ * Extract the AgentTypeConfig from an agent-like type.
+ *
+ * @example
+ * ```ts
+ * const agent = createAgent({ ... });
+ * type Config = ExtractAgentConfig<typeof agent>;
+ * // Config is the AgentTypeConfig with Response, State, Context, Middleware, Tools
+ * ```
+ */
+type ExtractAgentConfig<T> = T extends {
+  "~agentTypes": infer Config;
+} ? Config extends AgentTypeConfigLike ? Config : never : never;
+/**
+ * Helper type to infer schema input type, supporting both Zod v3 and v4.
+ * - Zod v4 uses `_zod.input` property
+ * - Zod v3 uses `_input` property
+ */
+type InferSchemaInput<S> = S extends {
+  _zod: {
+    input: infer Args;
+  };
+} ? Args : S extends {
+  _input: infer Args;
+} ? Args : never;
+/**
+ * Helper type to extract the input type from a DynamicStructuredTool's _call method.
+ * This is more reliable than trying to infer from the schema directly because
+ * DynamicStructuredTool has the input type baked into its _call signature.
+ */
+type InferToolInput<T> = T extends {
+  _call: (arg: infer Args, ...rest: any[]) => any;
+} ? Args : T extends {
+  schema: infer S;
+} ? InferSchemaInput<S> : never;
+/**
+ * Extract a tool call type from a single tool.
+ * Works with tools created via `tool()` from `@langchain/core/tools`.
+ *
+ * This extracts the literal name type from DynamicStructuredTool's NameT parameter
+ * and the args type from the _call method or schema's input property.
+ */
+type ToolCallFromAgentTool<T> = T extends {
+  name: infer N;
+} ? N extends string ? InferToolInput<T> extends infer Args ? Args extends never ? never : Args extends Record<string, any> ? {
+  name: N;
+  args: Args;
+  id?: string;
+  type?: "tool_call";
+} : never : never : never : never;
+/**
+ * Extract tool calls type from an agent's tools.
+ * Converts the tools array to a discriminated union of tool calls.
+ *
+ * This handles both tuple types (e.g., `readonly [Tool1, Tool2]`) and
+ * array-of-union types (e.g., `readonly (Tool1 | Tool2)[]`) which is how
+ * `createAgent` captures tool types.
+ *
+ * @example
+ * ```ts
+ * const agent = createAgent({ tools: [getWeather, search], ... });
+ * type ToolCalls = InferAgentToolCalls<typeof agent>;
+ * // ToolCalls is:
+ * // | { name: "get_weather"; args: { location: string }; id?: string }
+ * // | { name: "search"; args: { query: string }; id?: string }
+ * ```
+ */
+type InferAgentToolCalls<T> = ExtractAgentConfig<T>["Tools"] extends readonly (infer Tool)[] ? ToolCallFromAgentTool<Tool> extends never ? DefaultToolCall : ToolCallFromAgentTool<Tool> : DefaultToolCall;
+/**
+ * Extract the tool call type parameter from an AIMessage in a message union.
+ * Returns `never` if the message is not an AIMessage or uses DefaultToolCall.
+ *
+ * The key distinction: custom tool calls have literal `name` types (e.g., "get_weather"),
+ * while DefaultToolCall has `name: string`. We check if `string extends TC["name"]` -
+ * if true, it's DefaultToolCall; if false, it's a custom type with literal names.
+ */
+type ExtractToolCallFromMessageUnion<M> = M extends AIMessage<infer TC> ? TC extends {
+  name: infer N;
+} ? string extends N ? never : TC : never : never;
+/**
+ * Extract the tool call type from a StateType's messages property.
+ * This is the primary way to specify tool call types when using useStream.
+ *
+ * @example
+ * ```ts
+ * // Define state with typed messages
+ * type MyToolCalls =
+ *   | { name: "get_weather"; args: { location: string }; id?: string }
+ *   | { name: "search"; args: { query: string }; id?: string };
+ *
+ * interface MyState {
+ *   messages: Message<MyToolCalls>[];
+ * }
+ *
+ * // ExtractToolCallsFromState<MyState> = MyToolCalls
+ * ```
+ */
+type ExtractToolCallsFromState<StateType extends Record<string, unknown>> = StateType extends {
+  messages: infer Messages;
+} ? Messages extends readonly (infer M)[] ? ExtractToolCallFromMessageUnion<M> : Messages extends (infer M)[] ? ExtractToolCallFromMessageUnion<M> : never : never;
+type MessageMetadata<StateType extends Record<string, unknown>> = {
+  /**
+   * The ID of the message used.
+   */
+  messageId: string;
+  /**
+   * The first thread state the message was seen in.
+   */
+  firstSeenState: ThreadState<StateType> | undefined;
+  /**
+   * The branch of the message.
+   */
+  branch: string | undefined;
+  /**
+   * The list of branches this message is part of.
+   * This is useful for displaying branching controls.
+   */
+  branchOptions: string[] | undefined;
+  /**
+   * Metadata sent alongside the message during run streaming.
+   * @remarks This metadata only exists temporarily in browser memory during streaming and is not persisted after completion.
+   */
+  streamMetadata: Record<string, unknown> | undefined;
+};
+type GetUpdateType<Bag extends BagTemplate, StateType extends Record<string, unknown>> = Bag extends {
+  UpdateType: unknown;
+} ? Bag["UpdateType"] : Partial<StateType>;
+type GetConfigurableType<Bag extends BagTemplate> = Bag extends {
+  ConfigurableType: Record<string, unknown>;
+} ? Bag["ConfigurableType"] : Record<string, unknown>;
+type GetInterruptType<Bag extends BagTemplate> = Bag extends {
+  InterruptType: unknown;
+} ? Bag["InterruptType"] : unknown;
+type GetCustomEventType<Bag extends BagTemplate> = Bag extends {
+  CustomEventType: unknown;
+} ? Bag["CustomEventType"] : unknown;
+/**
+ * Extract the tool call type from a StateType's messages property.
+ * This is the canonical way to get typed tool calls in useStream.
+ *
+ * Tool call types are now extracted from the messages property of StateType,
+ * rather than being specified separately in the Bag.
+ *
+ * @example
+ * ```ts
+ * // Define state with typed messages
+ * type MyToolCalls =
+ *   | { name: "get_weather"; args: { location: string }; id?: string }
+ *   | { name: "search"; args: { query: string }; id?: string };
+ *
+ * interface MyState {
+ *   messages: Message<MyToolCalls>[];
+ * }
+ *
+ * // GetToolCallsType<MyState> = MyToolCalls
+ * ```
+ */
+type GetToolCallsType<StateType extends Record<string, unknown>> = ExtractToolCallsFromState<StateType> extends never ? DefaultToolCall : ExtractToolCallsFromState<StateType>;
+interface RunCallbackMeta {
+  run_id: string;
+  thread_id: string;
+}
+interface UseStreamThread<StateType extends Record<string, unknown>> {
+  data: ThreadState<StateType>[] | null | undefined;
+  error: unknown;
+  isLoading: boolean;
+  mutate: (mutateId?: string) => Promise<ThreadState<StateType>[] | null | undefined>;
+}
+interface UseStreamOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {
+  /**
+   * The ID of the assistant to use.
+   */
+  assistantId: string;
+  /**
+   * Client used to send requests.
+   */
+  client?: Client;
+  /**
+   * The URL of the API to use.
+   */
+  apiUrl?: ClientConfig["apiUrl"];
+  /**
+   * The API key to use.
+   */
+  apiKey?: ClientConfig["apiKey"];
+  /**
+   * Custom call options, such as custom fetch implementation.
+   */
+  callerOptions?: ClientConfig["callerOptions"];
+  /**
+   * Default headers to send with requests.
+   */
+  defaultHeaders?: ClientConfig["defaultHeaders"];
+  /**
+   * Specify the key within the state that contains messages.
+   * Defaults to "messages".
+   *
+   * @default "messages"
+   */
+  messagesKey?: string;
+  /**
+   * Callback that is called when an error occurs.
+   */
+  onError?: (error: unknown, run: RunCallbackMeta | undefined) => void;
+  /**
+   * Callback that is called when the stream is finished.
+   */
+  onFinish?: (state: ThreadState<StateType>, run: RunCallbackMeta | undefined) => void;
+  /**
+   * Callback that is called when a new stream is created.
+   */
+  onCreated?: (run: RunCallbackMeta) => void;
+  /**
+   * Callback that is called when an update event is received.
+   */
+  onUpdateEvent?: (data: UpdatesStreamEvent<GetUpdateType<Bag, StateType>>["data"], options: {
+    namespace: string[] | undefined;
+    mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;
+  }) => void;
+  /**
+   * Callback that is called when a custom event is received.
+   */
+  onCustomEvent?: (data: CustomStreamEvent<GetCustomEventType<Bag>>["data"], options: {
+    namespace: string[] | undefined;
+    mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;
+  }) => void;
+  /**
+   * Callback that is called when a metadata event is received.
+   */
+  onMetadataEvent?: (data: MetadataStreamEvent["data"]) => void;
+  /**
+   * Callback that is called when a LangChain event is received.
+   * @see https://langchain-ai.github.io/langgraph/cloud/how-tos/stream_events/#stream-graph-in-events-mode for more details.
+   */
+  onLangChainEvent?: (data: EventsStreamEvent["data"]) => void;
+  /**
+   * Callback that is called when a debug event is received.
+   * @internal This API is experimental and subject to change.
+   */
+  onDebugEvent?: (data: DebugStreamEvent["data"], options: {
+    namespace: string[] | undefined;
+  }) => void;
+  /**
+   * Callback that is called when a checkpoints event is received.
+   */
+  onCheckpointEvent?: (data: CheckpointsStreamEvent<StateType>["data"], options: {
+    namespace: string[] | undefined;
+  }) => void;
+  /**
+   * Callback that is called when a tasks event is received.
+   */
+  onTaskEvent?: (data: TasksStreamEvent<StateType, GetUpdateType<Bag, StateType>>["data"], options: {
+    namespace: string[] | undefined;
+  }) => void;
+  /**
+   * Callback that is called when the stream is stopped by the user.
+   * Provides a mutate function to update the stream state immediately
+   * without requiring a server roundtrip.
+   *
+   * @example
+   * ```typescript
+   * onStop: ({ mutate }) => {
+   *   mutate((prev) => ({
+   *     ...prev,
+   *     ui: prev.ui?.map(component =>
+   *       component.props.isLoading
+   *         ? { ...component, props: { ...component.props, stopped: true, isLoading: false }}
+   *         : component
+   *     )
+   *   }));
+   * }
+   * ```
+   */
+  onStop?: (options: {
+    mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;
+  }) => void;
+  /**
+   * The ID of the thread to fetch history and current values from.
+   */
+  threadId?: string | null;
+  /**
+   * Callback that is called when the thread ID is updated (ie when a new thread is created).
+   */
+  onThreadId?: (threadId: string) => void;
+  /** Will reconnect the stream on mount */
+  reconnectOnMount?: boolean | (() => RunMetadataStorage);
+  /**
+   * Initial values to display immediately when loading a thread.
+   * Useful for displaying cached thread data while official history loads.
+   * These values will be replaced when official thread data is fetched.
+   *
+   * Note: UI components from initialValues will render immediately if they're
+   * predefined in LoadExternalComponent's components prop, providing instant
+   * cached UI display without server fetches.
+   */
+  initialValues?: StateType | null;
+  /**
+   * Whether to fetch the history of the thread.
+   * If true, the history will be fetched from the server. Defaults to 10 entries.
+   * If false, only the last state will be fetched from the server.
+   * @default true
+   */
+  fetchStateHistory?: boolean | {
+    limit: number;
+  };
+  /**
+   * Manage the thread state externally.
+   */
+  thread?: UseStreamThread<StateType>;
+  /**
+   * Throttle the stream.
+   * If a number is provided, the stream will be throttled to the given number of milliseconds.
+   * If `true`, updates are batched in a single macrotask.
+   * If `false`, updates are not throttled or batched.
+   * @default true
+   */
+  throttle?: number | boolean;
+}
+interface RunMetadataStorage {
+  getItem(key: `lg:stream:${string}`): string | null;
+  setItem(key: `lg:stream:${string}`, value: string): void;
+  removeItem(key: `lg:stream:${string}`): void;
+}
+type ConfigWithConfigurable<ConfigurableType extends Record<string, unknown>> = Config & {
+  configurable?: ConfigurableType;
+};
+interface SubmitOptions<StateType extends Record<string, unknown> = Record<string, unknown>, ContextType extends Record<string, unknown> = Record<string, unknown>> {
+  config?: ConfigWithConfigurable<ContextType>;
+  context?: ContextType;
+  checkpoint?: Omit<Checkpoint, "thread_id"> | null;
+  command?: Command;
+  interruptBefore?: "*" | string[];
+  interruptAfter?: "*" | string[];
+  metadata?: Metadata;
+  multitaskStrategy?: MultitaskStrategy;
+  onCompletion?: OnCompletionBehavior;
+  onDisconnect?: DisconnectMode;
+  feedbackKeys?: string[];
+  streamMode?: Array<StreamMode>;
+  runId?: string;
+  optimisticValues?: Partial<StateType> | ((prev: StateType) => Partial<StateType>);
+  /**
+   * Whether or not to stream the nodes of any subgraphs called
+   * by the assistant.
+   * @default false
+   */
+  streamSubgraphs?: boolean;
+  /**
+   * Mark the stream as resumable. All events emitted during the run will be temporarily persisted
+   * in order to be re-emitted if the stream is re-joined.
+   * @default false
+   */
+  streamResumable?: boolean;
+  /**
+   * Whether to checkpoint during the run (or only at the end/interruption).
+   * - `"async"`: Save checkpoint asynchronously while the next step executes (default).
+   * - `"sync"`: Save checkpoint synchronously before the next step starts.
+   * - `"exit"`: Save checkpoint only when the graph exits.
+   * @default "async"
+   */
+  durability?: Durability;
+  /**
+   * The ID to use when creating a new thread. When provided, this ID will be used
+   * for thread creation when threadId is `null` or `undefined`.
+   * This enables optimistic UI updates where you know the thread ID
+   * before the thread is actually created.
+   */
+  threadId?: string;
+}
+/**
+ * Transport used to stream the thread.
+ * Only applicable for custom endpoints using `toLangGraphEventStream` or `toLangGraphEventStreamResponse`.
+ */
+interface UseStreamTransport<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {
+  stream: (payload: {
+    input: GetUpdateType<Bag, StateType> | null | undefined;
+    context: GetConfigurableType<Bag> | undefined;
+    command: Command | undefined;
+    config: ConfigWithConfigurable<GetConfigurableType<Bag>> | undefined;
+    signal: AbortSignal;
+  }) => Promise<AsyncGenerator<{
+    id?: string;
+    event: string;
+    data: unknown;
+  }>>;
+}
+type UseStreamCustomOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = Pick<UseStreamOptions<StateType, Bag>, "messagesKey" | "threadId" | "onThreadId" | "onError" | "onCreated" | "onUpdateEvent" | "onCustomEvent" | "onMetadataEvent" | "onLangChainEvent" | "onDebugEvent" | "onCheckpointEvent" | "onTaskEvent" | "onStop" | "initialValues" | "throttle"> & {
+  transport: UseStreamTransport<StateType, Bag>;
+};
+type CustomSubmitOptions<StateType extends Record<string, unknown> = Record<string, unknown>, ConfigurableType extends Record<string, unknown> = Record<string, unknown>> = Pick<SubmitOptions<StateType, ConfigurableType>, "optimisticValues" | "context" | "command" | "config">;
+//#endregion
+export { AgentTypeConfigLike, CustomSubmitOptions, ExtractAgentConfig, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, InferAgentToolCalls, IsAgentLike, MessageMetadata, RunCallbackMeta, SubmitOptions, UseStreamCustomOptions, UseStreamOptions, UseStreamThread, UseStreamTransport };
+//# sourceMappingURL=types.d.ts.map

package/dist/ui/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["Client","ClientConfig","ThreadState","Config","Checkpoint","Metadata","Command","MultitaskStrategy","OnCompletionBehavior","DisconnectMode","Durability","UpdatesStreamEvent","CustomStreamEvent","MetadataStreamEvent","EventsStreamEvent","DebugStreamEvent","CheckpointsStreamEvent","TasksStreamEvent","StreamMode","DefaultToolCall","AIMessage","BagTemplate","AgentTypeConfigLike","IsAgentLike","T","ExtractAgentConfig","InferSchemaInput","S","Args","InferToolInput","ToolCallFromAgentTool","N","Record","InferAgentToolCalls","Tool","ExtractToolCallFromMessageUnion","M","TC","ExtractToolCallsFromState","StateType","Messages","MessageMetadata","GetUpdateType","Bag","Partial","GetConfigurableType","GetInterruptType","GetCustomEventType","GetToolCallsType","RunCallbackMeta","UseStreamThread","Promise","UseStreamOptions","RunMetadataStorage","ConfigWithConfigurable","ConfigurableType","SubmitOptions","ContextType","Omit","Array","UseStreamTransport","AbortSignal","AsyncGenerator","UseStreamCustomOptions","Pick","CustomSubmitOptions"],"sources":["../../src/ui/types.d.ts"],"sourcesContent":["import type { Client, ClientConfig } from \"../client.js\";\nimport type { ThreadState, Config, Checkpoint, Metadata } from \"../schema.js\";\nimport type { Command, MultitaskStrategy, OnCompletionBehavior, DisconnectMode, Durability } from \"../types.js\";\nimport type { UpdatesStreamEvent, CustomStreamEvent, MetadataStreamEvent, EventsStreamEvent, DebugStreamEvent, CheckpointsStreamEvent, TasksStreamEvent, StreamMode } from \"../types.stream.js\";\nimport type { DefaultToolCall, AIMessage } from \"../types.messages.js\";\nimport type { BagTemplate } from \"../types.template.js\";\n/**\n * Minimal interface matching the structure of AgentTypeConfig from @langchain/langgraph.\n * This allows type inference from ReactAgent without requiring the langchain dependency.\n */\nexport interface AgentTypeConfigLike {\n    Response: unknown;\n    State: unknown;\n    Context: unknown;\n    Middleware: unknown;\n    Tools: unknown;\n}\n/**\n * Check if a type is agent-like (has `~agentTypes` phantom property).\n * This property is present on `ReactAgent` instances created with `createAgent`.\n */\nexport type IsAgentLike<T> = T extends {\n    \"~agentTypes\": AgentTypeConfigLike;\n} ? true : false;\n/**\n * Extract the AgentTypeConfig from an agent-like type.\n *\n * @example\n * ```ts\n * const agent = createAgent({ ... });\n * type Config = ExtractAgentConfig<typeof agent>;\n * // Config is the AgentTypeConfig with Response, State, Context, Middleware, Tools\n * ```\n */\nexport type ExtractAgentConfig<T> = T extends {\n    \"~agentTypes\": infer Config;\n} ? Config extends AgentTypeConfigLike ? Config : never : never;\n/**\n * Helper type to infer schema input type, supporting both Zod v3 and v4.\n * - Zod v4 uses `_zod.input` property\n * - Zod v3 uses `_input` property\n */\ntype InferSchemaInput<S> = S extends {\n    _zod: {\n        input: infer Args;\n    };\n} ? Args : S extends {\n    _input: infer Args;\n} ? Args : never;\n/**\n * Helper type to extract the input type from a DynamicStructuredTool's _call method.\n * This is more reliable than trying to infer from the schema directly because\n * DynamicStructuredTool has the input type baked into its _call signature.\n */\ntype InferToolInput<T> = T extends {\n    _call: (arg: infer Args, ...rest: any[]) => any;\n} ? Args : T extends {\n    schema: infer S;\n} ? InferSchemaInput<S> : never;\n/**\n * Extract a tool call type from a single tool.\n * Works with tools created via `tool()` from `@langchain/core/tools`.\n *\n * This extracts the literal name type from DynamicStructuredTool's NameT parameter\n * and the args type from the _call method or schema's input property.\n */\ntype ToolCallFromAgentTool<T> = T extends {\n    name: infer N;\n} ? N extends string ? InferToolInput<T> extends infer Args ? Args extends never ? never : Args extends Record<string, any> ? {\n    name: N;\n    args: Args;\n    id?: string;\n    type?: \"tool_call\";\n} : never : never : never : never;\n/**\n * Extract tool calls type from an agent's tools.\n * Converts the tools array to a discriminated union of tool calls.\n *\n * This handles both tuple types (e.g., `readonly [Tool1, Tool2]`) and\n * array-of-union types (e.g., `readonly (Tool1 | Tool2)[]`) which is how\n * `createAgent` captures tool types.\n *\n * @example\n * ```ts\n * const agent = createAgent({ tools: [getWeather, search], ... });\n * type ToolCalls = InferAgentToolCalls<typeof agent>;\n * // ToolCalls is:\n * // | { name: \"get_weather\"; args: { location: string }; id?: string }\n * // | { name: \"search\"; args: { query: string }; id?: string }\n * ```\n */\nexport type InferAgentToolCalls<T> = ExtractAgentConfig<T>[\"Tools\"] extends readonly (infer Tool)[] ? ToolCallFromAgentTool<Tool> extends never ? DefaultToolCall : ToolCallFromAgentTool<Tool> : DefaultToolCall;\n/**\n * Extract the tool call type parameter from an AIMessage in a message union.\n * Returns `never` if the message is not an AIMessage or uses DefaultToolCall.\n *\n * The key distinction: custom tool calls have literal `name` types (e.g., \"get_weather\"),\n * while DefaultToolCall has `name: string`. We check if `string extends TC[\"name\"]` -\n * if true, it's DefaultToolCall; if false, it's a custom type with literal names.\n */\ntype ExtractToolCallFromMessageUnion<M> = M extends AIMessage<infer TC> ? TC extends {\n    name: infer N;\n} ? string extends N ? never : TC : never : never;\n/**\n * Extract the tool call type from a StateType's messages property.\n * This is the primary way to specify tool call types when using useStream.\n *\n * @example\n * ```ts\n * // Define state with typed messages\n * type MyToolCalls =\n *   | { name: \"get_weather\"; args: { location: string }; id?: string }\n *   | { name: \"search\"; args: { query: string }; id?: string };\n *\n * interface MyState {\n *   messages: Message<MyToolCalls>[];\n * }\n *\n * // ExtractToolCallsFromState<MyState> = MyToolCalls\n * ```\n */\nexport type ExtractToolCallsFromState<StateType extends Record<string, unknown>> = StateType extends {\n    messages: infer Messages;\n} ? Messages extends readonly (infer M)[] ? ExtractToolCallFromMessageUnion<M> : Messages extends (infer M)[] ? ExtractToolCallFromMessageUnion<M> : never : never;\nexport type MessageMetadata<StateType extends Record<string, unknown>> = {\n    /**\n     * The ID of the message used.\n     */\n    messageId: string;\n    /**\n     * The first thread state the message was seen in.\n     */\n    firstSeenState: ThreadState<StateType> | undefined;\n    /**\n     * The branch of the message.\n     */\n    branch: string | undefined;\n    /**\n     * The list of branches this message is part of.\n     * This is useful for displaying branching controls.\n     */\n    branchOptions: string[] | undefined;\n    /**\n     * Metadata sent alongside the message during run streaming.\n     * @remarks This metadata only exists temporarily in browser memory during streaming and is not persisted after completion.\n     */\n    streamMetadata: Record<string, unknown> | undefined;\n};\nexport type GetUpdateType<Bag extends BagTemplate, StateType extends Record<string, unknown>> = Bag extends {\n    UpdateType: unknown;\n} ? Bag[\"UpdateType\"] : Partial<StateType>;\nexport type GetConfigurableType<Bag extends BagTemplate> = Bag extends {\n    ConfigurableType: Record<string, unknown>;\n} ? Bag[\"ConfigurableType\"] : Record<string, unknown>;\nexport type GetInterruptType<Bag extends BagTemplate> = Bag extends {\n    InterruptType: unknown;\n} ? Bag[\"InterruptType\"] : unknown;\nexport type GetCustomEventType<Bag extends BagTemplate> = Bag extends {\n    CustomEventType: unknown;\n} ? Bag[\"CustomEventType\"] : unknown;\n/**\n * Extract the tool call type from a StateType's messages property.\n * This is the canonical way to get typed tool calls in useStream.\n *\n * Tool call types are now extracted from the messages property of StateType,\n * rather than being specified separately in the Bag.\n *\n * @example\n * ```ts\n * // Define state with typed messages\n * type MyToolCalls =\n *   | { name: \"get_weather\"; args: { location: string }; id?: string }\n *   | { name: \"search\"; args: { query: string }; id?: string };\n *\n * interface MyState {\n *   messages: Message<MyToolCalls>[];\n * }\n *\n * // GetToolCallsType<MyState> = MyToolCalls\n * ```\n */\nexport type GetToolCallsType<StateType extends Record<string, unknown>> = ExtractToolCallsFromState<StateType> extends never ? DefaultToolCall : ExtractToolCallsFromState<StateType>;\nexport interface RunCallbackMeta {\n    run_id: string;\n    thread_id: string;\n}\nexport interface UseStreamThread<StateType extends Record<string, unknown>> {\n    data: ThreadState<StateType>[] | null | undefined;\n    error: unknown;\n    isLoading: boolean;\n    mutate: (mutateId?: string) => Promise<ThreadState<StateType>[] | null | undefined>;\n}\nexport interface UseStreamOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {\n    /**\n     * The ID of the assistant to use.\n     */\n    assistantId: string;\n    /**\n     * Client used to send requests.\n     */\n    client?: Client;\n    /**\n     * The URL of the API to use.\n     */\n    apiUrl?: ClientConfig[\"apiUrl\"];\n    /**\n     * The API key to use.\n     */\n    apiKey?: ClientConfig[\"apiKey\"];\n    /**\n     * Custom call options, such as custom fetch implementation.\n     */\n    callerOptions?: ClientConfig[\"callerOptions\"];\n    /**\n     * Default headers to send with requests.\n     */\n    defaultHeaders?: ClientConfig[\"defaultHeaders\"];\n    /**\n     * Specify the key within the state that contains messages.\n     * Defaults to \"messages\".\n     *\n     * @default \"messages\"\n     */\n    messagesKey?: string;\n    /**\n     * Callback that is called when an error occurs.\n     */\n    onError?: (error: unknown, run: RunCallbackMeta | undefined) => void;\n    /**\n     * Callback that is called when the stream is finished.\n     */\n    onFinish?: (state: ThreadState<StateType>, run: RunCallbackMeta | undefined) => void;\n    /**\n     * Callback that is called when a new stream is created.\n     */\n    onCreated?: (run: RunCallbackMeta) => void;\n    /**\n     * Callback that is called when an update event is received.\n     */\n    onUpdateEvent?: (data: UpdatesStreamEvent<GetUpdateType<Bag, StateType>>[\"data\"], options: {\n        namespace: string[] | undefined;\n        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;\n    }) => void;\n    /**\n     * Callback that is called when a custom event is received.\n     */\n    onCustomEvent?: (data: CustomStreamEvent<GetCustomEventType<Bag>>[\"data\"], options: {\n        namespace: string[] | undefined;\n        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;\n    }) => void;\n    /**\n     * Callback that is called when a metadata event is received.\n     */\n    onMetadataEvent?: (data: MetadataStreamEvent[\"data\"]) => void;\n    /**\n     * Callback that is called when a LangChain event is received.\n     * @see https://langchain-ai.github.io/langgraph/cloud/how-tos/stream_events/#stream-graph-in-events-mode for more details.\n     */\n    onLangChainEvent?: (data: EventsStreamEvent[\"data\"]) => void;\n    /**\n     * Callback that is called when a debug event is received.\n     * @internal This API is experimental and subject to change.\n     */\n    onDebugEvent?: (data: DebugStreamEvent[\"data\"], options: {\n        namespace: string[] | undefined;\n    }) => void;\n    /**\n     * Callback that is called when a checkpoints event is received.\n     */\n    onCheckpointEvent?: (data: CheckpointsStreamEvent<StateType>[\"data\"], options: {\n        namespace: string[] | undefined;\n    }) => void;\n    /**\n     * Callback that is called when a tasks event is received.\n     */\n    onTaskEvent?: (data: TasksStreamEvent<StateType, GetUpdateType<Bag, StateType>>[\"data\"], options: {\n        namespace: string[] | undefined;\n    }) => void;\n    /**\n     * Callback that is called when the stream is stopped by the user.\n     * Provides a mutate function to update the stream state immediately\n     * without requiring a server roundtrip.\n     *\n     * @example\n     * ```typescript\n     * onStop: ({ mutate }) => {\n     *   mutate((prev) => ({\n     *     ...prev,\n     *     ui: prev.ui?.map(component =>\n     *       component.props.isLoading\n     *         ? { ...component, props: { ...component.props, stopped: true, isLoading: false }}\n     *         : component\n     *     )\n     *   }));\n     * }\n     * ```\n     */\n    onStop?: (options: {\n        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;\n    }) => void;\n    /**\n     * The ID of the thread to fetch history and current values from.\n     */\n    threadId?: string | null;\n    /**\n     * Callback that is called when the thread ID is updated (ie when a new thread is created).\n     */\n    onThreadId?: (threadId: string) => void;\n    /** Will reconnect the stream on mount */\n    reconnectOnMount?: boolean | (() => RunMetadataStorage);\n    /**\n     * Initial values to display immediately when loading a thread.\n     * Useful for displaying cached thread data while official history loads.\n     * These values will be replaced when official thread data is fetched.\n     *\n     * Note: UI components from initialValues will render immediately if they're\n     * predefined in LoadExternalComponent's components prop, providing instant\n     * cached UI display without server fetches.\n     */\n    initialValues?: StateType | null;\n    /**\n     * Whether to fetch the history of the thread.\n     * If true, the history will be fetched from the server. Defaults to 10 entries.\n     * If false, only the last state will be fetched from the server.\n     * @default true\n     */\n    fetchStateHistory?: boolean | {\n        limit: number;\n    };\n    /**\n     * Manage the thread state externally.\n     */\n    thread?: UseStreamThread<StateType>;\n    /**\n     * Throttle the stream.\n     * If a number is provided, the stream will be throttled to the given number of milliseconds.\n     * If `true`, updates are batched in a single macrotask.\n     * If `false`, updates are not throttled or batched.\n     * @default true\n     */\n    throttle?: number | boolean;\n}\ninterface RunMetadataStorage {\n    getItem(key: `lg:stream:${string}`): string | null;\n    setItem(key: `lg:stream:${string}`, value: string): void;\n    removeItem(key: `lg:stream:${string}`): void;\n}\ntype ConfigWithConfigurable<ConfigurableType extends Record<string, unknown>> = Config & {\n    configurable?: ConfigurableType;\n};\nexport interface SubmitOptions<StateType extends Record<string, unknown> = Record<string, unknown>, ContextType extends Record<string, unknown> = Record<string, unknown>> {\n    config?: ConfigWithConfigurable<ContextType>;\n    context?: ContextType;\n    checkpoint?: Omit<Checkpoint, \"thread_id\"> | null;\n    command?: Command;\n    interruptBefore?: \"*\" | string[];\n    interruptAfter?: \"*\" | string[];\n    metadata?: Metadata;\n    multitaskStrategy?: MultitaskStrategy;\n    onCompletion?: OnCompletionBehavior;\n    onDisconnect?: DisconnectMode;\n    feedbackKeys?: string[];\n    streamMode?: Array<StreamMode>;\n    runId?: string;\n    optimisticValues?: Partial<StateType> | ((prev: StateType) => Partial<StateType>);\n    /**\n     * Whether or not to stream the nodes of any subgraphs called\n     * by the assistant.\n     * @default false\n     */\n    streamSubgraphs?: boolean;\n    /**\n     * Mark the stream as resumable. All events emitted during the run will be temporarily persisted\n     * in order to be re-emitted if the stream is re-joined.\n     * @default false\n     */\n    streamResumable?: boolean;\n    /**\n     * Whether to checkpoint during the run (or only at the end/interruption).\n     * - `\"async\"`: Save checkpoint asynchronously while the next step executes (default).\n     * - `\"sync\"`: Save checkpoint synchronously before the next step starts.\n     * - `\"exit\"`: Save checkpoint only when the graph exits.\n     * @default \"async\"\n     */\n    durability?: Durability;\n    /**\n     * The ID to use when creating a new thread. When provided, this ID will be used\n     * for thread creation when threadId is `null` or `undefined`.\n     * This enables optimistic UI updates where you know the thread ID\n     * before the thread is actually created.\n     */\n    threadId?: string;\n}\n/**\n * Transport used to stream the thread.\n * Only applicable for custom endpoints using `toLangGraphEventStream` or `toLangGraphEventStreamResponse`.\n */\nexport interface UseStreamTransport<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {\n    stream: (payload: {\n        input: GetUpdateType<Bag, StateType> | null | undefined;\n        context: GetConfigurableType<Bag> | undefined;\n        command: Command | undefined;\n        config: ConfigWithConfigurable<GetConfigurableType<Bag>> | undefined;\n        signal: AbortSignal;\n    }) => Promise<AsyncGenerator<{\n        id?: string;\n        event: string;\n        data: unknown;\n    }>>;\n}\nexport type UseStreamCustomOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = Pick<UseStreamOptions<StateType, Bag>, \"messagesKey\" | \"threadId\" | \"onThreadId\" | \"onError\" | \"onCreated\" | \"onUpdateEvent\" | \"onCustomEvent\" | \"onMetadataEvent\" | \"onLangChainEvent\" | \"onDebugEvent\" | \"onCheckpointEvent\" | \"onTaskEvent\" | \"onStop\" | \"initialValues\" | \"throttle\"> & {\n    transport: UseStreamTransport<StateType, Bag>;\n};\nexport type CustomSubmitOptions<StateType extends Record<string, unknown> = Record<string, unknown>, ConfigurableType extends Record<string, unknown> = Record<string, unknown>> = Pick<SubmitOptions<StateType, ConfigurableType>, \"optimisticValues\" | \"context\" | \"command\" | \"config\">;\nexport {};\n"],"mappings":"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"}

package/dist/ui/utils.cjs

@@ -5,7 +5,6 @@ function unique(array) {
 }
 function findLast(array, predicate) {
 	for (let i = array.length - 1; i >= 0; i -= 1) if (predicate(array[i])) return array[i];
-	return void 0;
 }
 
 //#endregion

package/dist/ui/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/ui/utils.ts"],"sourcesContent":["export function unique<T>(array: T[]) {\n  return [...new Set(array)] as T[];\n}\n\nexport function findLast<T>(array: T[], predicate: (item: T) => boolean) {\n  for (let i = array.length - 1; i >= 0; i -= 1) {\n    if (predicate(array[i])) return array[i];\n  }\n  return undefined;\n}\n"],"mappings":";;AAAA,SAAgB,OAAU,OAAY;AACpC,QAAO,CAAC,GAAG,IAAI,IAAI;;AAGrB,SAAgB,SAAY,OAAY,WAAiC;AACvE,MAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,EAC1C,KAAI,UAAU,MAAM,IAAK,QAAO,MAAM;AAExC,QAAO"}
+{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/ui/utils.ts"],"sourcesContent":["export function unique<T>(array: T[]) {\n  return [...new Set(array)] as T[];\n}\n\nexport function findLast<T>(array: T[], predicate: (item: T) => boolean) {\n  for (let i = array.length - 1; i >= 0; i -= 1) {\n    if (predicate(array[i])) return array[i];\n  }\n  return undefined;\n}\n"],"mappings":";;AAAA,SAAgB,OAAU,OAAY;AACpC,QAAO,CAAC,GAAG,IAAI,IAAI,MAAM,CAAC;;AAG5B,SAAgB,SAAY,OAAY,WAAiC;AACvE,MAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,EAC1C,KAAI,UAAU,MAAM,GAAG,CAAE,QAAO,MAAM"}

package/dist/ui/utils.js

@@ -4,7 +4,6 @@ function unique(array) {
 }
 function findLast(array, predicate) {
 	for (let i = array.length - 1; i >= 0; i -= 1) if (predicate(array[i])) return array[i];
-	return void 0;
 }
 
 //#endregion

package/dist/ui/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../src/ui/utils.ts"],"sourcesContent":["export function unique<T>(array: T[]) {\n  return [...new Set(array)] as T[];\n}\n\nexport function findLast<T>(array: T[], predicate: (item: T) => boolean) {\n  for (let i = array.length - 1; i >= 0; i -= 1) {\n    if (predicate(array[i])) return array[i];\n  }\n  return undefined;\n}\n"],"mappings":";AAAA,SAAgB,OAAU,OAAY;AACpC,QAAO,CAAC,GAAG,IAAI,IAAI;;AAGrB,SAAgB,SAAY,OAAY,WAAiC;AACvE,MAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,EAC1C,KAAI,UAAU,MAAM,IAAK,QAAO,MAAM;AAExC,QAAO"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/ui/utils.ts"],"sourcesContent":["export function unique<T>(array: T[]) {\n  return [...new Set(array)] as T[];\n}\n\nexport function findLast<T>(array: T[], predicate: (item: T) => boolean) {\n  for (let i = array.length - 1; i >= 0; i -= 1) {\n    if (predicate(array[i])) return array[i];\n  }\n  return undefined;\n}\n"],"mappings":";AAAA,SAAgB,OAAU,OAAY;AACpC,QAAO,CAAC,GAAG,IAAI,IAAI,MAAM,CAAC;;AAG5B,SAAgB,SAAY,OAAY,WAAiC;AACvE,MAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,EAC1C,KAAI,UAAU,MAAM,GAAG,CAAE,QAAO,MAAM"}

package/dist/utils/async_caller.cjs

@@ -1,7 +1,9 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_fetch = require('../singletons/fetch.cjs');
-const p_retry = require_rolldown_runtime.__toESM(require("p-retry"));
-const p_queue = require_rolldown_runtime.__toESM(require("p-queue"));
+let p_retry = require("p-retry");
+p_retry = require_rolldown_runtime.__toESM(p_retry);
+let p_queue = require("p-queue");
+p_queue = require_rolldown_runtime.__toESM(p_queue);
 
 //#region src/utils/async_caller.ts
 const STATUS_NO_RETRY = [
@@ -80,9 +82,15 @@ var AsyncCaller = class {
 			else if (isResponse(error)) throw await HTTPError.fromResponse(error, { includeResponse: !!onFailedResponseHook });
 			else throw new Error(error);
 		}), {
-			async onFailedAttempt(error) {
-				if (error.message.startsWith("Cancel") || error.message.startsWith("TimeoutError") || error.message.startsWith("AbortError")) throw error;
+			async onFailedAttempt({ error }) {
+				const errorMessage = error.message ?? "";
+				if (errorMessage.startsWith("Cancel") || errorMessage.startsWith("TimeoutError") || errorMessage.startsWith("AbortError")) throw error;
 				if (error?.code === "ECONNABORTED") throw error;
+				if (errorMessage.includes("ECONNREFUSED") || errorMessage.includes("fetch failed") || errorMessage.includes("Failed to fetch") || errorMessage.includes("NetworkError")) {
+					const connectionError = /* @__PURE__ */ new Error(`Unable to connect to LangGraph server. Please ensure the server is running and accessible. Original error: ${errorMessage}`);
+					connectionError.name = "ConnectionError";
+					throw connectionError;
+				}
 				if (error instanceof HTTPError) {
 					if (STATUS_NO_RETRY.includes(error.status)) throw error;
 					if (onFailedResponseHook && error.response) await onFailedResponseHook(error.response);

package/dist/utils/async_caller.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"async_caller.cjs","names":["PQueueMod","_getFetchImplementation"],"sources":["../../src/utils/async_caller.ts"],"sourcesContent":["import pRetry from \"p-retry\";\nimport PQueueMod from \"p-queue\";\nimport { _getFetchImplementation } from \"../singletons/fetch.js\";\n\nconst STATUS_NO_RETRY = [\n  400, // Bad Request\n  401, // Unauthorized\n  402, // Payment required\n  403, // Forbidden\n  404, // Not Found\n  405, // Method Not Allowed\n  406, // Not Acceptable\n  407, // Proxy Authentication Required\n  408, // Request Timeout\n  409, // Conflict\n  422, // Unprocessable Entity\n];\n\ntype ResponseCallback = (response?: Response) => Promise<boolean>;\n\nexport interface AsyncCallerParams {\n  /**\n   * The maximum number of concurrent calls that can be made.\n   * Defaults to `Infinity`, which means no limit.\n   */\n  maxConcurrency?: number;\n  /**\n   * The maximum number of retries that can be made for a single call,\n   * with an exponential backoff between each attempt. Defaults to 6.\n   */\n  maxRetries?: number;\n\n  onFailedResponseHook?: ResponseCallback;\n\n  /**\n   * Specify a custom fetch implementation.\n   *\n   * By default we expect the `fetch` is available in the global scope.\n   */\n  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n}\n\nexport interface AsyncCallerCallOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Do not rely on globalThis.Response, rather just\n * do duck typing\n */\nfunction isResponse(x: unknown): x is Response {\n  if (x == null || typeof x !== \"object\") return false;\n  return \"status\" in x && \"statusText\" in x && \"text\" in x;\n}\n\n/**\n * Utility error to properly handle failed requests\n */\nclass HTTPError extends Error {\n  status: number;\n\n  text: string;\n\n  response?: Response;\n\n  constructor(status: number, message: string, response?: Response) {\n    super(`HTTP ${status}: ${message}`);\n    this.status = status;\n    this.text = message;\n    this.response = response;\n  }\n\n  static async fromResponse(\n    response: Response,\n    options?: { includeResponse?: boolean }\n  ): Promise<HTTPError> {\n    try {\n      return new HTTPError(\n        response.status,\n        await response.text(),\n        options?.includeResponse ? response : undefined\n      );\n    } catch {\n      return new HTTPError(\n        response.status,\n        response.statusText,\n        options?.includeResponse ? response : undefined\n      );\n    }\n  }\n}\n\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 5. This\n * means that by default, each call will be retried up to 5 times, with an\n * exponential backoff between each attempt.\n */\nexport class AsyncCaller {\n  protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n\n  protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n\n  private queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n  private onFailedResponseHook?: ResponseCallback;\n\n  private customFetch?: typeof fetch;\n\n  constructor(params: AsyncCallerParams) {\n    this.maxConcurrency = params.maxConcurrency ?? Infinity;\n    this.maxRetries = params.maxRetries ?? 4;\n\n    if (\"default\" in PQueueMod) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.queue = new (PQueueMod.default as any)({\n        concurrency: this.maxConcurrency,\n      });\n    } else {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.queue = new (PQueueMod as any)({ concurrency: this.maxConcurrency });\n    }\n    this.onFailedResponseHook = params?.onFailedResponseHook;\n    this.customFetch = params.fetch;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  call<A extends any[], T extends (...args: A) => Promise<any>>(\n    callable: T,\n    ...args: Parameters<T>\n  ): Promise<Awaited<ReturnType<T>>> {\n    const { onFailedResponseHook } = this;\n    return this.queue.add(\n      () =>\n        pRetry(\n          () =>\n            callable(...(args as Parameters<T>)).catch(async (error) => {\n              // eslint-disable-next-line no-instanceof/no-instanceof\n              if (error instanceof Error) {\n                throw error;\n              } else if (isResponse(error)) {\n                throw await HTTPError.fromResponse(error, {\n                  includeResponse: !!onFailedResponseHook,\n                });\n              } else {\n                throw new Error(error);\n              }\n            }),\n          {\n            async onFailedAttempt(error) {\n              if (\n                error.message.startsWith(\"Cancel\") ||\n                error.message.startsWith(\"TimeoutError\") ||\n                error.message.startsWith(\"AbortError\")\n              ) {\n                throw error;\n              }\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              if ((error as any)?.code === \"ECONNABORTED\") {\n                throw error;\n              }\n\n              // eslint-disable-next-line no-instanceof/no-instanceof\n              if (error instanceof HTTPError) {\n                if (STATUS_NO_RETRY.includes(error.status)) {\n                  throw error;\n                }\n                if (onFailedResponseHook && error.response) {\n                  await onFailedResponseHook(error.response);\n                }\n              }\n            },\n            // If needed we can change some of the defaults here,\n            // but they're quite sensible.\n            retries: this.maxRetries,\n            randomize: true,\n          }\n        ),\n      { throwOnTimeout: true }\n    );\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(\n    options: AsyncCallerCallOptions,\n    callable: T,\n    ...args: Parameters<T>\n  ): Promise<Awaited<ReturnType<T>>> {\n    // Note this doesn't cancel the underlying request,\n    // when available prefer to use the signal option of the underlying call\n    if (options.signal) {\n      return Promise.race([\n        this.call<A, T>(callable, ...args),\n        new Promise<never>((_, reject) => {\n          options.signal?.addEventListener(\"abort\", () => {\n            reject(new Error(\"AbortError\"));\n          });\n        }),\n      ]);\n    }\n    return this.call<A, T>(callable, ...args);\n  }\n\n  fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch> {\n    const fetchFn =\n      this.customFetch ?? (_getFetchImplementation() as typeof fetch);\n    return this.call(() =>\n      fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res)))\n    );\n  }\n}\n"],"mappings":";;;;;;AAIA,MAAM,kBAAkB;CACtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;;;;;AAmCF,SAAS,WAAW,GAA2B;AAC7C,KAAI,KAAK,QAAQ,OAAO,MAAM,SAAU,QAAO;AAC/C,QAAO,YAAY,KAAK,gBAAgB,KAAK,UAAU;;;;;AAMzD,IAAM,YAAN,MAAM,kBAAkB,MAAM;CAC5B;CAEA;CAEA;CAEA,YAAY,QAAgB,SAAiB,UAAqB;AAChE,QAAM,QAAQ,OAAO,IAAI;AACzB,OAAK,SAAS;AACd,OAAK,OAAO;AACZ,OAAK,WAAW;;CAGlB,aAAa,aACX,UACA,SACoB;AACpB,MAAI;AACF,UAAO,IAAI,UACT,SAAS,QACT,MAAM,SAAS,QACf,SAAS,kBAAkB,WAAW;UAElC;AACN,UAAO,IAAI,UACT,SAAS,QACT,SAAS,YACT,SAAS,kBAAkB,WAAW;;;;;;;;;;;;;;;;;AAmB9C,IAAa,cAAb,MAAyB;CACvB,AAAU;CAEV,AAAU;CAEV,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,YAAY,QAA2B;AACrC,OAAK,iBAAiB,OAAO,kBAAkB;AAC/C,OAAK,aAAa,OAAO,cAAc;AAEvC,MAAI,aAAaA,gBAEf,MAAK,QAAQ,IAAKA,gBAAU,QAAgB,EAC1C,aAAa,KAAK;MAIpB,MAAK,QAAQ,IAAKA,gBAAkB,EAAE,aAAa,KAAK;AAE1D,OAAK,uBAAuB,QAAQ;AACpC,OAAK,cAAc,OAAO;;CAI5B,KACE,UACA,GAAG,MAC8B;EACjC,MAAM,EAAE,yBAAyB;AACjC,SAAO,KAAK,MAAM,qCAIV,SAAS,GAAI,MAAwB,MAAM,OAAO,UAAU;AAE1D,OAAI,iBAAiB,MACnB,OAAM;YACG,WAAW,OACpB,OAAM,MAAM,UAAU,aAAa,OAAO,EACxC,iBAAiB,CAAC,CAAC;OAGrB,OAAM,IAAI,MAAM;MAGtB;GACE,MAAM,gBAAgB,OAAO;AAC3B,QACE,MAAM,QAAQ,WAAW,aACzB,MAAM,QAAQ,WAAW,mBACzB,MAAM,QAAQ,WAAW,cAEzB,OAAM;AAGR,QAAK,OAAe,SAAS,eAC3B,OAAM;AAIR,QAAI,iBAAiB,WAAW;AAC9B,SAAI,gBAAgB,SAAS,MAAM,QACjC,OAAM;AAER,SAAI,wBAAwB,MAAM,SAChC,OAAM,qBAAqB,MAAM;;;GAMvC,SAAS,KAAK;GACd,WAAW;MAGjB,EAAE,gBAAgB;;CAKtB,gBACE,SACA,UACA,GAAG,MAC8B;AAGjC,MAAI,QAAQ,OACV,QAAO,QAAQ,KAAK,CAClB,KAAK,KAAW,UAAU,GAAG,OAC7B,IAAI,SAAgB,GAAG,WAAW;AAChC,WAAQ,QAAQ,iBAAiB,eAAe;AAC9C,2BAAO,IAAI,MAAM;;;AAKzB,SAAO,KAAK,KAAW,UAAU,GAAG;;CAGtC,MAAM,GAAG,MAA0D;EACjE,MAAM,UACJ,KAAK,eAAgBC;AACvB,SAAO,KAAK,WACV,QAAQ,GAAG,MAAM,MAAM,QAAS,IAAI,KAAK,MAAM,QAAQ,OAAO"}
+{"version":3,"file":"async_caller.cjs","names":["PQueueMod","_getFetchImplementation"],"sources":["../../src/utils/async_caller.ts"],"sourcesContent":["import pRetry from \"p-retry\";\nimport PQueueMod from \"p-queue\";\nimport { _getFetchImplementation } from \"../singletons/fetch.js\";\n\nconst STATUS_NO_RETRY = [\n  400, // Bad Request\n  401, // Unauthorized\n  402, // Payment required\n  403, // Forbidden\n  404, // Not Found\n  405, // Method Not Allowed\n  406, // Not Acceptable\n  407, // Proxy Authentication Required\n  408, // Request Timeout\n  409, // Conflict\n  422, // Unprocessable Entity\n];\n\ntype ResponseCallback = (response?: Response) => Promise<boolean>;\n\nexport interface AsyncCallerParams {\n  /**\n   * The maximum number of concurrent calls that can be made.\n   * Defaults to `Infinity`, which means no limit.\n   */\n  maxConcurrency?: number;\n  /**\n   * The maximum number of retries that can be made for a single call,\n   * with an exponential backoff between each attempt. Defaults to 6.\n   */\n  maxRetries?: number;\n\n  onFailedResponseHook?: ResponseCallback;\n\n  /**\n   * Specify a custom fetch implementation.\n   *\n   * By default we expect the `fetch` is available in the global scope.\n   */\n  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n}\n\nexport interface AsyncCallerCallOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Do not rely on globalThis.Response, rather just\n * do duck typing\n */\nfunction isResponse(x: unknown): x is Response {\n  if (x == null || typeof x !== \"object\") return false;\n  return \"status\" in x && \"statusText\" in x && \"text\" in x;\n}\n\n/**\n * Utility error to properly handle failed requests\n */\nclass HTTPError extends Error {\n  status: number;\n\n  text: string;\n\n  response?: Response;\n\n  constructor(status: number, message: string, response?: Response) {\n    super(`HTTP ${status}: ${message}`);\n    this.status = status;\n    this.text = message;\n    this.response = response;\n  }\n\n  static async fromResponse(\n    response: Response,\n    options?: { includeResponse?: boolean }\n  ): Promise<HTTPError> {\n    try {\n      return new HTTPError(\n        response.status,\n        await response.text(),\n        options?.includeResponse ? response : undefined\n      );\n    } catch {\n      return new HTTPError(\n        response.status,\n        response.statusText,\n        options?.includeResponse ? response : undefined\n      );\n    }\n  }\n}\n\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 5. This\n * means that by default, each call will be retried up to 5 times, with an\n * exponential backoff between each attempt.\n */\nexport class AsyncCaller {\n  protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n\n  protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n\n  private queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n  private onFailedResponseHook?: ResponseCallback;\n\n  private customFetch?: typeof fetch;\n\n  constructor(params: AsyncCallerParams) {\n    this.maxConcurrency = params.maxConcurrency ?? Infinity;\n    this.maxRetries = params.maxRetries ?? 4;\n\n    if (\"default\" in PQueueMod) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.queue = new (PQueueMod.default as any)({\n        concurrency: this.maxConcurrency,\n      });\n    } else {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.queue = new (PQueueMod as any)({ concurrency: this.maxConcurrency });\n    }\n    this.onFailedResponseHook = params?.onFailedResponseHook;\n    this.customFetch = params.fetch;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  call<A extends any[], T extends (...args: A) => Promise<any>>(\n    callable: T,\n    ...args: Parameters<T>\n  ): Promise<Awaited<ReturnType<T>>> {\n    const { onFailedResponseHook } = this;\n    return this.queue.add(\n      () =>\n        pRetry(\n          () =>\n            callable(...(args as Parameters<T>)).catch(async (error) => {\n              // eslint-disable-next-line no-instanceof/no-instanceof\n              if (error instanceof Error) {\n                throw error;\n              } else if (isResponse(error)) {\n                throw await HTTPError.fromResponse(error, {\n                  includeResponse: !!onFailedResponseHook,\n                });\n              } else {\n                throw new Error(error);\n              }\n            }),\n          {\n            async onFailedAttempt({ error }) {\n              const errorMessage = error.message ?? \"\";\n              if (\n                errorMessage.startsWith(\"Cancel\") ||\n                errorMessage.startsWith(\"TimeoutError\") ||\n                errorMessage.startsWith(\"AbortError\")\n              ) {\n                throw error;\n              }\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              if ((error as any)?.code === \"ECONNABORTED\") {\n                throw error;\n              }\n\n              // Check for connection refused errors (server not running)\n              if (\n                errorMessage.includes(\"ECONNREFUSED\") ||\n                errorMessage.includes(\"fetch failed\") ||\n                errorMessage.includes(\"Failed to fetch\") ||\n                errorMessage.includes(\"NetworkError\")\n              ) {\n                const connectionError = new Error(\n                  `Unable to connect to LangGraph server. Please ensure the server is running and accessible. Original error: ${errorMessage}`\n                );\n                connectionError.name = \"ConnectionError\";\n                throw connectionError;\n              }\n\n              // eslint-disable-next-line no-instanceof/no-instanceof\n              if (error instanceof HTTPError) {\n                if (STATUS_NO_RETRY.includes(error.status)) {\n                  throw error;\n                }\n                if (onFailedResponseHook && error.response) {\n                  await onFailedResponseHook(error.response);\n                }\n              }\n            },\n            // If needed we can change some of the defaults here,\n            // but they're quite sensible.\n            retries: this.maxRetries,\n            randomize: true,\n          }\n        ),\n      { throwOnTimeout: true }\n    );\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(\n    options: AsyncCallerCallOptions,\n    callable: T,\n    ...args: Parameters<T>\n  ): Promise<Awaited<ReturnType<T>>> {\n    // Note this doesn't cancel the underlying request,\n    // when available prefer to use the signal option of the underlying call\n    if (options.signal) {\n      return Promise.race([\n        this.call<A, T>(callable, ...args),\n        new Promise<never>((_, reject) => {\n          options.signal?.addEventListener(\"abort\", () => {\n            reject(new Error(\"AbortError\"));\n          });\n        }),\n      ]);\n    }\n    return this.call<A, T>(callable, ...args);\n  }\n\n  fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch> {\n    const fetchFn =\n      this.customFetch ?? (_getFetchImplementation() as typeof fetch);\n    return this.call(() =>\n      fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res)))\n    );\n  }\n}\n"],"mappings":";;;;;;;;AAIA,MAAM,kBAAkB;CACtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;;;;;AAkCD,SAAS,WAAW,GAA2B;AAC7C,KAAI,KAAK,QAAQ,OAAO,MAAM,SAAU,QAAO;AAC/C,QAAO,YAAY,KAAK,gBAAgB,KAAK,UAAU;;;;;AAMzD,IAAM,YAAN,MAAM,kBAAkB,MAAM;CAC5B;CAEA;CAEA;CAEA,YAAY,QAAgB,SAAiB,UAAqB;AAChE,QAAM,QAAQ,OAAO,IAAI,UAAU;AACnC,OAAK,SAAS;AACd,OAAK,OAAO;AACZ,OAAK,WAAW;;CAGlB,aAAa,aACX,UACA,SACoB;AACpB,MAAI;AACF,UAAO,IAAI,UACT,SAAS,QACT,MAAM,SAAS,MAAM,EACrB,SAAS,kBAAkB,WAAW,OACvC;UACK;AACN,UAAO,IAAI,UACT,SAAS,QACT,SAAS,YACT,SAAS,kBAAkB,WAAW,OACvC;;;;;;;;;;;;;;;;;AAkBP,IAAa,cAAb,MAAyB;CACvB,AAAU;CAEV,AAAU;CAEV,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,YAAY,QAA2B;AACrC,OAAK,iBAAiB,OAAO,kBAAkB;AAC/C,OAAK,aAAa,OAAO,cAAc;AAEvC,MAAI,aAAaA,gBAEf,MAAK,QAAQ,IAAKA,gBAAU,QAAgB,EAC1C,aAAa,KAAK,gBACnB,CAAC;MAGF,MAAK,QAAQ,IAAKA,gBAAkB,EAAE,aAAa,KAAK,gBAAgB,CAAC;AAE3E,OAAK,uBAAuB,QAAQ;AACpC,OAAK,cAAc,OAAO;;CAI5B,KACE,UACA,GAAG,MAC8B;EACjC,MAAM,EAAE,yBAAyB;AACjC,SAAO,KAAK,MAAM,qCAIV,SAAS,GAAI,KAAuB,CAAC,MAAM,OAAO,UAAU;AAE1D,OAAI,iBAAiB,MACnB,OAAM;YACG,WAAW,MAAM,CAC1B,OAAM,MAAM,UAAU,aAAa,OAAO,EACxC,iBAAiB,CAAC,CAAC,sBACpB,CAAC;OAEF,OAAM,IAAI,MAAM,MAAM;IAExB,EACJ;GACE,MAAM,gBAAgB,EAAE,SAAS;IAC/B,MAAM,eAAe,MAAM,WAAW;AACtC,QACE,aAAa,WAAW,SAAS,IACjC,aAAa,WAAW,eAAe,IACvC,aAAa,WAAW,aAAa,CAErC,OAAM;AAGR,QAAK,OAAe,SAAS,eAC3B,OAAM;AAIR,QACE,aAAa,SAAS,eAAe,IACrC,aAAa,SAAS,eAAe,IACrC,aAAa,SAAS,kBAAkB,IACxC,aAAa,SAAS,eAAe,EACrC;KACA,MAAM,kCAAkB,IAAI,MAC1B,8GAA8G,eAC/G;AACD,qBAAgB,OAAO;AACvB,WAAM;;AAIR,QAAI,iBAAiB,WAAW;AAC9B,SAAI,gBAAgB,SAAS,MAAM,OAAO,CACxC,OAAM;AAER,SAAI,wBAAwB,MAAM,SAChC,OAAM,qBAAqB,MAAM,SAAS;;;GAMhD,SAAS,KAAK;GACd,WAAW;GACZ,CACF,EACH,EAAE,gBAAgB,MAAM,CACzB;;CAIH,gBACE,SACA,UACA,GAAG,MAC8B;AAGjC,MAAI,QAAQ,OACV,QAAO,QAAQ,KAAK,CAClB,KAAK,KAAW,UAAU,GAAG,KAAK,EAClC,IAAI,SAAgB,GAAG,WAAW;AAChC,WAAQ,QAAQ,iBAAiB,eAAe;AAC9C,2BAAO,IAAI,MAAM,aAAa,CAAC;KAC/B;IACF,CACH,CAAC;AAEJ,SAAO,KAAK,KAAW,UAAU,GAAG,KAAK;;CAG3C,MAAM,GAAG,MAA0D;EACjE,MAAM,UACJ,KAAK,eAAgBC,uCAAyB;AAChD,SAAO,KAAK,WACV,QAAQ,GAAG,KAAK,CAAC,MAAM,QAAS,IAAI,KAAK,MAAM,QAAQ,OAAO,IAAI,CAAE,CACrE"}

package/dist/utils/async_caller.d.cts

@@ -17,7 +17,7 @@ interface AsyncCallerParams {
    *
    * By default we expect the `fetch` is available in the global scope.
    */
-  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any
+  fetch?: typeof fetch | ((...args: any[]) => any);
 }
 interface AsyncCallerCallOptions {
   signal?: AbortSignal;
@@ -42,9 +42,7 @@ declare class AsyncCaller {
   private onFailedResponseHook?;
   private customFetch?;
   constructor(params: AsyncCallerParams);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
   fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;
 }

package/dist/utils/async_caller.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"async_caller.d.cts","names":["ResponseCallback","Response","Promise","AsyncCallerParams","fetch","AsyncCallerCallOptions","AbortSignal","AsyncCaller","A","T","Parameters","ReturnType","Awaited"],"sources":["../../src/utils/async_caller.d.ts"],"sourcesContent":["type ResponseCallback = (response?: Response) => Promise<boolean>;\nexport interface AsyncCallerParams {\n    /**\n     * The maximum number of concurrent calls that can be made.\n     * Defaults to `Infinity`, which means no limit.\n     */\n    maxConcurrency?: number;\n    /**\n     * The maximum number of retries that can be made for a single call,\n     * with an exponential backoff between each attempt. Defaults to 6.\n     */\n    maxRetries?: number;\n    onFailedResponseHook?: ResponseCallback;\n    /**\n     * Specify a custom fetch implementation.\n     *\n     * By default we expect the `fetch` is available in the global scope.\n     */\n    fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n}\nexport interface AsyncCallerCallOptions {\n    signal?: AbortSignal;\n}\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 5. This\n * means that by default, each call will be retried up to 5 times, with an\n * exponential backoff between each attempt.\n */\nexport declare class AsyncCaller {\n    protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n    protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n    private queue;\n    private onFailedResponseHook?;\n    private customFetch?;\n    constructor(params: AsyncCallerParams);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;\n}\nexport {};\n"],"mappings":";KAAKA,gBAAAA,eAA+BC,aAAaC;AAA5CF,UACYG,iBAAAA,CADI;EAAA;;;;EACJA,cAAAA,CAAAA,EAAAA,MAAiB;EAAA;;;;EAmBjBE,UAAAA,CAAAA,EAAAA,MAAAA;EAgBIE,oBAAW,CAAA,EAxBLP,gBAwBK;EAAA;;;;;OAQoBE,CAAAA,EAAAA,OA1BjCE,KA0BiCF,GAAAA,CAAAA,CAAAA,GAAAA,IAAAA,EAAAA,GAAAA,EAAAA,EAAAA,GAAAA,GAAAA,CAAAA,CAAAA,CAAAA;;AAA+CO,UAxBlFJ,sBAAAA,CAwBkFI;QAAXC,CAAAA,EAvB3EJ,WAuB2EI;;;;;;;;;;;;;;;AAGnDN,cAXhBG,WAAAA,CAWgBH;YAAlBM,cAAAA,EAVWP,iBAUXO,CAAAA,gBAAAA,CAAAA;YAA6CN,UAAAA,EATtCD,iBASsCC,CAAAA,YAAAA,CAAAA;UAAlBO,KAAAA;;;sBALtBR;;4CAEsBK,MAAMN,wBAAwBO,YAAYC,WAAWD,KAAKP,QAAQU,QAAQD,WAAWF;;uDAE1ED,MAAMN,uBAAuBG,kCAAkCI,YAAYC,WAAWD,KAAKP,QAAQU,QAAQD,WAAWF;iBAC5JC,kBAAkBN,SAASO,kBAAkBP"}
+{"version":3,"file":"async_caller.d.cts","names":["ResponseCallback","Response","Promise","AsyncCallerParams","fetch","AsyncCallerCallOptions","AbortSignal","AsyncCaller","A","T","Parameters","ReturnType","Awaited"],"sources":["../../src/utils/async_caller.d.ts"],"sourcesContent":["type ResponseCallback = (response?: Response) => Promise<boolean>;\nexport interface AsyncCallerParams {\n    /**\n     * The maximum number of concurrent calls that can be made.\n     * Defaults to `Infinity`, which means no limit.\n     */\n    maxConcurrency?: number;\n    /**\n     * The maximum number of retries that can be made for a single call,\n     * with an exponential backoff between each attempt. Defaults to 6.\n     */\n    maxRetries?: number;\n    onFailedResponseHook?: ResponseCallback;\n    /**\n     * Specify a custom fetch implementation.\n     *\n     * By default we expect the `fetch` is available in the global scope.\n     */\n    fetch?: typeof fetch | ((...args: any[]) => any);\n}\nexport interface AsyncCallerCallOptions {\n    signal?: AbortSignal;\n}\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 5. This\n * means that by default, each call will be retried up to 5 times, with an\n * exponential backoff between each attempt.\n */\nexport declare class AsyncCaller {\n    protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n    protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n    private queue;\n    private onFailedResponseHook?;\n    private customFetch?;\n    constructor(params: AsyncCallerParams);\n    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;\n}\nexport {};\n"],"mappings":";KAAKA,gBAAAA,eAA+BC,aAAaC;AAA5CF,UACYG,iBAAAA,CADI;EAAA;;;;EACJA,cAAAA,CAAAA,EAAAA,MAAiB;EAAA;;;;EAmBjBE,UAAAA,CAAAA,EAAAA,MAAAA;EAgBIE,oBAAW,CAAA,EAxBLP,gBAwBK;EAAA;;;;;OAOoBE,CAAAA,EAAAA,OAzBjCE,KAyBiCF,GAAAA,CAAAA,CAAAA,GAAAA,IAAAA,EAAAA,GAAAA,EAAAA,EAAAA,GAAAA,GAAAA,CAAAA;;AAA+CO,UAvBlFJ,sBAAAA,CAuBkFI;QAAXC,CAAAA,EAtB3EJ,WAsB2EI;;;;;;;;;;;;;;;AAEnDN,cAThBG,WAAAA,CASgBH;YAAlBM,cAAAA,EARWP,iBAQXO,CAAAA,gBAAAA,CAAAA;YAA6CN,UAAAA,EAPtCD,iBAOsCC,CAAAA,YAAAA,CAAAA;UAAlBO,KAAAA;EAAU,QAAA,oBAAA;;sBAHhCR;4CACsBK,MAAMN,wBAAwBO,YAAYC,WAAWD,KAAKP,QAAQU,QAAQD,WAAWF;uDAC1ED,MAAMN,uBAAuBG,kCAAkCI,YAAYC,WAAWD,KAAKP,QAAQU,QAAQD,WAAWF;iBAC5JC,kBAAkBN,SAASO,kBAAkBP"}

package/dist/utils/async_caller.d.ts

@@ -17,7 +17,7 @@ interface AsyncCallerParams {
    *
    * By default we expect the `fetch` is available in the global scope.
    */
-  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any
+  fetch?: typeof fetch | ((...args: any[]) => any);
 }
 interface AsyncCallerCallOptions {
   signal?: AbortSignal;
@@ -42,9 +42,7 @@ declare class AsyncCaller {
   private onFailedResponseHook?;
   private customFetch?;
   constructor(params: AsyncCallerParams);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
   fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;
 }