@langchain/langgraph-sdk 1.7.1 → 1.7.2

package/dist/react/stream.custom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.custom.js","names":[],"sources":["../../src/react/stream.custom.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { useEffect, useRef, useState, useSyncExternalStore } from \"react\";\nimport { EventStreamEvent, StreamManager } from \"../ui/manager.js\";\nimport type {\n  GetUpdateType,\n  GetCustomEventType,\n  GetInterruptType,\n  GetToolCallsType,\n  GetConfigurableType,\n  UseStreamTransport,\n  AnyStreamCustomOptions,\n  CustomSubmitOptions,\n} from \"../ui/types.js\";\nimport type { UseStreamCustom } from \"./types.js\";\nimport { type Message } from \"../types.messages.js\";\nimport { getToolCallsWithResults } from \"../utils/tools.js\";\nimport { MessageTupleManager } from \"../ui/messages.js\";\nimport { Interrupt } from \"../schema.js\";\nimport { BytesLineDecoder, SSEDecoder } from \"../utils/sse.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { useControllableThreadId } from \"./thread.js\";\nimport { Command } from \"../types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\n\ninterface FetchStreamTransportOptions {\n  /**\n   * The URL of the API to use.\n   */\n  apiUrl: string;\n\n  /**\n   * Default headers to send with requests.\n   */\n  defaultHeaders?: HeadersInit;\n\n  /**\n   * Specify a custom fetch implementation.\n   */\n  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n\n  /**\n   * Callback that is called before the request is made.\n   */\n  onRequest?: (\n    url: string,\n    init: RequestInit\n  ) => Promise<RequestInit> | RequestInit;\n}\n\nexport class FetchStreamTransport<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n> implements UseStreamTransport<StateType, Bag>\n{\n  constructor(private readonly options: FetchStreamTransportOptions) {}\n\n  async stream(payload: {\n    input: GetUpdateType<Bag, StateType> | null | undefined;\n    context: GetConfigurableType<Bag> | undefined;\n    command: Command | undefined;\n    signal: AbortSignal;\n  }): Promise<AsyncGenerator<{ id?: string; event: string; data: unknown }>> {\n    const { signal, ...body } = payload;\n\n    let requestInit: RequestInit = {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        ...this.options.defaultHeaders,\n      },\n      body: JSON.stringify(body),\n      signal,\n    };\n\n    if (this.options.onRequest) {\n      requestInit = await this.options.onRequest(\n        this.options.apiUrl,\n        requestInit\n      );\n    }\n    const fetchFn = this.options.fetch ?? fetch;\n\n    const response = await fetchFn(this.options.apiUrl, requestInit);\n    if (!response.ok) {\n      throw new Error(`Failed to stream: ${response.statusText}`);\n    }\n\n    const stream = (\n      response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })\n    )\n      .pipeThrough(BytesLineDecoder())\n      .pipeThrough(SSEDecoder());\n\n    return IterableReadableStream.fromReadableStream(stream);\n  }\n}\n\nexport function useStreamCustom<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options: AnyStreamCustomOptions<StateType, Bag>\n): UseStreamCustom<StateType, Bag> {\n  type UpdateType = GetUpdateType<Bag, StateType>;\n  type CustomType = GetCustomEventType<Bag>;\n  type InterruptType = GetInterruptType<Bag>;\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type ToolCallType = GetToolCallsType<StateType>;\n\n  const [messageManager] = useState(() => new MessageTupleManager());\n  const [stream] = useState(\n    () =>\n      new StreamManager<StateType, Bag>(messageManager, {\n        throttle: options.throttle ?? false,\n        subagentToolNames: options.subagentToolNames,\n        filterSubagentMessages: options.filterSubagentMessages,\n      })\n  );\n\n  useSyncExternalStore(\n    stream.subscribe,\n    stream.getSnapshot,\n    stream.getSnapshot\n  );\n\n  const [threadId, onThreadId] = useControllableThreadId(options);\n  const threadIdRef = useRef<string | null>(threadId);\n\n  // Cancel the stream if thread ID has changed\n  useEffect(() => {\n    if (threadIdRef.current !== threadId) {\n      threadIdRef.current = threadId;\n      stream.clear();\n    }\n  }, [threadId, stream]);\n\n  const getMessages = (value: StateType): Message[] => {\n    const messagesKey = options.messagesKey ?? \"messages\";\n    return Array.isArray(value[messagesKey])\n      ? (value[messagesKey] as Message[])\n      : [];\n  };\n\n  const setMessages = (current: StateType, messages: Message[]): StateType => {\n    const messagesKey = options.messagesKey ?? \"messages\";\n    return { ...current, [messagesKey]: messages };\n  };\n\n  const historyValues = options.initialValues ?? ({} as StateType);\n\n  // Reconstruct subagents from initialValues when:\n  // 1. Subagent filtering is enabled\n  // 2. Not currently streaming\n  // 3. initialValues has messages\n  // This ensures subagent visualization works with cached/persisted state\n  const historyMessages = getMessages(historyValues);\n  const shouldReconstructSubagents =\n    options.filterSubagentMessages &&\n    !stream.isLoading &&\n    historyMessages.length > 0;\n\n  useEffect(() => {\n    if (shouldReconstructSubagents) {\n      // skipIfPopulated: true ensures we don't overwrite subagents from active streaming\n      stream.reconstructSubagents(historyMessages, { skipIfPopulated: true });\n    }\n    // We intentionally only run this when shouldReconstructSubagents changes\n    // to avoid unnecessary reconstructions during streaming\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [shouldReconstructSubagents, historyMessages.length]);\n\n  const stop = () => stream.stop(historyValues, { onStop: options.onStop });\n\n  const submit = async (\n    values: UpdateType | null | undefined,\n    submitOptions?: CustomSubmitOptions<StateType, ConfigurableType>\n  ) => {\n    let usableThreadId = threadId;\n\n    stream.setStreamValues(() => {\n      if (submitOptions?.optimisticValues != null) {\n        return {\n          ...historyValues,\n          ...(typeof submitOptions.optimisticValues === \"function\"\n            ? submitOptions.optimisticValues(historyValues)\n            : submitOptions.optimisticValues),\n        };\n      }\n\n      return { ...historyValues };\n    });\n\n    await stream.start(\n      async (signal: AbortSignal) => {\n        if (!usableThreadId) {\n          // generate random thread id\n          usableThreadId = crypto.randomUUID();\n          threadIdRef.current = usableThreadId;\n          onThreadId(usableThreadId);\n        }\n\n        if (!usableThreadId) {\n          throw new Error(\"Failed to obtain valid thread ID.\");\n        }\n\n        return options.transport.stream({\n          input: values,\n          context: submitOptions?.context,\n          command: submitOptions?.command,\n          signal,\n          config: {\n            ...submitOptions?.config,\n            configurable: {\n              thread_id: usableThreadId,\n              ...submitOptions?.config?.configurable,\n            } as unknown as GetConfigurableType<Bag>,\n          },\n        }) as Promise<\n          AsyncGenerator<EventStreamEvent<StateType, UpdateType, CustomType>>\n        >;\n      },\n      {\n        getMessages,\n        setMessages,\n\n        initialValues: {} as StateType,\n        callbacks: options,\n\n        onSuccess: () => undefined,\n        onError(error) {\n          options.onError?.(error, undefined);\n        },\n      }\n    );\n  };\n\n  return {\n    get values() {\n      return stream.values ?? ({} as StateType);\n    },\n\n    error: stream.error,\n    isLoading: stream.isLoading,\n\n    stop,\n    submit,\n\n    get interrupts(): Interrupt<InterruptType>[] {\n      if (\n        stream.values != null &&\n        \"__interrupt__\" in stream.values &&\n        Array.isArray(stream.values.__interrupt__)\n      ) {\n        const valueInterrupts = stream.values.__interrupt__;\n        if (valueInterrupts.length === 0) return [{ when: \"breakpoint\" }];\n        return valueInterrupts;\n      }\n\n      return [];\n    },\n\n    get interrupt(): Interrupt<InterruptType> | undefined {\n      const all = this.interrupts;\n      if (all.length === 0) return undefined;\n      if (all.length === 1) return all[0];\n\n      // Multiple interrupts: return the array for backward compat\n      return all as Interrupt<InterruptType>;\n    },\n\n    get messages(): Message<ToolCallType>[] {\n      if (!stream.values) return [];\n      return getMessages(stream.values);\n    },\n\n    get toolCalls() {\n      if (!stream.values) return [];\n      const msgs = getMessages(stream.values);\n      return getToolCallsWithResults<ToolCallType>(msgs);\n    },\n\n    getToolCalls(message) {\n      if (!stream.values) return [];\n      const msgs = getMessages(stream.values);\n      const allToolCalls = getToolCallsWithResults<ToolCallType>(msgs);\n      return allToolCalls.filter((tc) => tc.aiMessage.id === message.id);\n    },\n\n    get subagents() {\n      return stream.getSubagents();\n    },\n\n    get activeSubagents() {\n      return stream.getActiveSubagents();\n    },\n\n    getSubagent(toolCallId: string) {\n      return stream.getSubagent(toolCallId);\n    },\n\n    getSubagentsByType(type: string) {\n      return stream.getSubagentsByType(type);\n    },\n\n    getSubagentsByMessage(messageId: string) {\n      return stream.getSubagentsByMessage(messageId);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/react/stream.d.cts

@@ -0,0 +1,10 @@
+import { BagTemplate } from "../types.template.cjs";
+import { UseStreamCustomOptions } from "../ui/types.cjs";
+import { InferBag, InferStateType, ResolveStreamInterface, ResolveStreamOptions } from "../ui/stream/index.cjs";
+
+//#region src/react/stream.d.ts
+declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
+declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
+//#endregion
+export { useStream };
+//# sourceMappingURL=stream.d.cts.map

package/dist/react/stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.cts","names":[],"sources":["../../src/react/stream.tsx"],"mappings":";;;;;iBAwBgB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAC5C,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;AAAA,iBAEzB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA,KAC9D,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/react/stream.d.ts

@@ -0,0 +1,9 @@
+import { BagTemplate } from "../types.template.js";
+import { UseStreamCustomOptions } from "../ui/types.js";
+import { InferBag, InferStateType, ResolveStreamInterface, ResolveStreamOptions } from "../ui/stream/index.js";
+//#region src/react/stream.d.ts
+declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
+declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
+//#endregion
+export { useStream };
+//# sourceMappingURL=stream.d.ts.map

package/dist/react/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","names":[],"sources":["../../src/react/stream.tsx"],"mappings":";;;;iBAwBgB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAC5C,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;AAAA,iBAEzB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA,KAC9D,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/react/stream.js

@@ -0,0 +1,16 @@
+import { useStreamLGP } from "./stream.lgp.js";
+import { useStreamCustom } from "./stream.custom.js";
+import { useState } from "react";
+//#region src/react/stream.tsx
+function isCustomOptions(options) {
+	return "transport" in options;
+}
+function useStream(options) {
+	const [isCustom] = useState(isCustomOptions(options));
+	if (isCustom) return useStreamCustom(options);
+	return useStreamLGP(options);
+}
+//#endregion
+export { useStream };
+
+//# sourceMappingURL=stream.js.map

package/dist/react/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","names":[],"sources":["../../src/react/stream.tsx"],"sourcesContent":["import { useState } from \"react\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { useStreamCustom } from \"./stream.custom.js\";\nimport type { UseStreamOptions } from \"../ui/types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\nimport type { UseStreamCustomOptions } from \"./types.js\";\nimport type {\n  ResolveStreamInterface,\n  ResolveStreamOptions,\n  InferBag,\n  InferStateType,\n} from \"../ui/stream/index.js\";\n\nfunction isCustomOptions<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options:\n    | UseStreamOptions<StateType, Bag>\n    | UseStreamCustomOptions<StateType, Bag>\n): options is UseStreamCustomOptions<StateType, Bag> {\n  return \"transport\" in options;\n}\n\nexport function useStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>\n): ResolveStreamInterface<T, InferBag<T, Bag>>;\n\nexport function useStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): ResolveStreamInterface<T, InferBag<T, Bag>>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useStream(options: any): any {\n  // Store this in useState to make sure we're not changing the implementation in re-renders\n  const [isCustom] = useState(isCustomOptions(options));\n\n  if (isCustom) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useStreamCustom(options);\n  }\n\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return useStreamLGP(options);\n}\n"],"mappings":";;;;AAaA,SAAS,gBAIP,SAGmD;AACnD,QAAO,eAAe;;AAkBxB,SAAgB,UAAU,SAAmB;CAE3C,MAAM,CAAC,YAAY,SAAS,gBAAgB,QAAQ,CAAC;AAErD,KAAI,SAEF,QAAO,gBAAgB,QAAQ;AAIjC,QAAO,aAAa,QAAQ"}

package/dist/react/stream.lgp.cjs

@@ -0,0 +1,550 @@
+"use client";
+require("../_virtual/_rolldown/runtime.cjs");
+const require_client = require("../client.cjs");
+const require_errors = require("../ui/errors.cjs");
+const require_messages = require("../ui/messages.cjs");
+const require_tools = require("../utils/tools.cjs");
+const require_manager = require("../ui/manager.cjs");
+const require_utils = require("../ui/utils.cjs");
+const require_branching = require("../ui/branching.cjs");
+const require_thread = require("./thread.cjs");
+let react = require("react");
+//#region src/react/stream.lgp.tsx
+function getFetchHistoryKey(client, threadId, limit) {
+	return [
+		require_client.getClientConfigHash(client),
+		threadId,
+		limit
+	].join(":");
+}
+function fetchHistory(client, threadId, options) {
+	if (options?.limit === false) return client.threads.getState(threadId).then((state) => {
+		if (state.checkpoint == null) return [];
+		return [state];
+	});
+	const limit = typeof options?.limit === "number" ? options.limit : 10;
+	return client.threads.getHistory(threadId, { limit });
+}
+function useThreadHistory(client, threadId, limit, options) {
+	const key = getFetchHistoryKey(client, threadId, limit);
+	const [state, setState] = (0, react.useState)(() => ({
+		key: void 0,
+		data: void 0,
+		error: void 0,
+		isLoading: threadId != null
+	}));
+	const clientRef = (0, react.useRef)(client);
+	clientRef.current = client;
+	const onErrorRef = (0, react.useRef)(options?.onError);
+	onErrorRef.current = options?.onError;
+	const fetcher = (0, react.useCallback)((threadId, limit) => {
+		if (options.passthrough) return Promise.resolve([]);
+		const client = clientRef.current;
+		const key = getFetchHistoryKey(client, threadId, limit);
+		if (threadId != null) {
+			setState((state) => {
+				if (state.key === key) return {
+					...state,
+					isLoading: true
+				};
+				return {
+					key,
+					data: void 0,
+					error: void 0,
+					isLoading: true
+				};
+			});
+			return fetchHistory(client, threadId, { limit }).then((data) => {
+				setState((state) => {
+					if (state.key !== key) return state;
+					return {
+						key,
+						data,
+						error: void 0,
+						isLoading: false
+					};
+				});
+				return data;
+			}, (error) => {
+				setState((state) => {
+					if (state.key !== key) return state;
+					return {
+						key,
+						data: state.data,
+						error,
+						isLoading: false
+					};
+				});
+				onErrorRef.current?.(error);
+				return Promise.reject(error);
+			});
+		}
+		setState({
+			key,
+			data: void 0,
+			error: void 0,
+			isLoading: false
+		});
+		return Promise.resolve([]);
+	}, [options.passthrough]);
+	(0, react.useEffect)(() => {
+		if (options.submittingRef.current != null && options.submittingRef.current === threadId) return;
+		fetcher(threadId, limit);
+	}, [fetcher, key]);
+	return {
+		data: state.data,
+		error: state.error,
+		isLoading: state.isLoading,
+		mutate: (mutateId) => fetcher(mutateId ?? threadId, limit)
+	};
+}
+function useStreamLGP(options) {
+	const reconnectOnMountRef = (0, react.useRef)(options.reconnectOnMount);
+	const runMetadataStorage = (0, react.useMemo)(() => {
+		if (typeof window === "undefined") return null;
+		const storage = reconnectOnMountRef.current;
+		if (storage === true) return window.sessionStorage;
+		if (typeof storage === "function") return storage();
+		return null;
+	}, []);
+	const client = (0, react.useMemo)(() => options.client ?? new require_client.Client({
+		apiUrl: options.apiUrl,
+		apiKey: options.apiKey,
+		callerOptions: options.callerOptions,
+		defaultHeaders: options.defaultHeaders
+	}), [
+		options.client,
+		options.apiKey,
+		options.apiUrl,
+		options.callerOptions,
+		options.defaultHeaders
+	]);
+	const [messageManager] = (0, react.useState)(() => new require_messages.MessageTupleManager());
+	const [stream] = (0, react.useState)(() => new require_manager.StreamManager(messageManager, {
+		throttle: options.throttle ?? false,
+		subagentToolNames: options.subagentToolNames,
+		filterSubagentMessages: options.filterSubagentMessages
+	}));
+	(0, react.useSyncExternalStore)(stream.subscribe, stream.getSnapshot, stream.getSnapshot);
+	const [threadId, onThreadId] = require_thread.useControllableThreadId(options);
+	const trackStreamModeRef = (0, react.useRef)([]);
+	const trackStreamMode = (0, react.useCallback)((...mode) => {
+		const ref = trackStreamModeRef.current;
+		for (const m of mode) if (!ref.includes(m)) ref.push(m);
+	}, []);
+	const hasUpdateListener = options.onUpdateEvent != null;
+	const hasCustomListener = options.onCustomEvent != null;
+	const hasLangChainListener = options.onLangChainEvent != null;
+	const hasDebugListener = options.onDebugEvent != null;
+	const hasCheckpointListener = options.onCheckpointEvent != null;
+	const hasTaskListener = options.onTaskEvent != null;
+	const hasToolListener = options.onToolEvent != null;
+	const callbackStreamMode = (0, react.useMemo)(() => {
+		const modes = [];
+		if (hasUpdateListener) modes.push("updates");
+		if (hasCustomListener) modes.push("custom");
+		if (hasLangChainListener) modes.push("events");
+		if (hasDebugListener) modes.push("debug");
+		if (hasCheckpointListener) modes.push("checkpoints");
+		if (hasTaskListener) modes.push("tasks");
+		if (hasToolListener) modes.push("tools");
+		return modes;
+	}, [
+		hasUpdateListener,
+		hasCustomListener,
+		hasLangChainListener,
+		hasDebugListener,
+		hasCheckpointListener,
+		hasTaskListener,
+		hasToolListener
+	]);
+	const threadIdRef = (0, react.useRef)(threadId);
+	const threadIdStreamingRef = (0, react.useRef)(null);
+	(0, react.useEffect)(() => {
+		if (threadIdRef.current !== threadId) {
+			threadIdRef.current = threadId;
+			stream.clear();
+		}
+	}, [threadId, stream]);
+	const switchThread = (0, react.useCallback)((newThreadId) => {
+		if (newThreadId !== threadIdRef.current) {
+			threadIdRef.current = newThreadId;
+			stream.clear();
+			onThreadId(newThreadId);
+		}
+	}, [stream, onThreadId]);
+	const historyLimit = typeof options.fetchStateHistory === "object" && options.fetchStateHistory != null ? options.fetchStateHistory.limit ?? false : options.fetchStateHistory ?? false;
+	const builtInHistory = useThreadHistory(client, threadId, historyLimit, {
+		passthrough: options.thread != null,
+		submittingRef: threadIdStreamingRef,
+		onError: options.onError
+	});
+	const history = options.thread ?? builtInHistory;
+	const getMessages = (value) => {
+		const messagesKey = options.messagesKey ?? "messages";
+		return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
+	};
+	const setMessages = (current, messages) => {
+		const messagesKey = options.messagesKey ?? "messages";
+		return {
+			...current,
+			[messagesKey]: messages
+		};
+	};
+	const [branch, setBranch] = (0, react.useState)("");
+	const branchContext = require_branching.getBranchContext(branch, history.data ?? void 0);
+	const [toolProgressMap, setToolProgressMap] = (0, react.useState)(/* @__PURE__ */ new Map());
+	const handleToolEvent = (0, react.useCallback)((data) => {
+		setToolProgressMap((prev) => {
+			const next = new Map(prev);
+			const key = data.toolCallId ?? data.name;
+			const existing = next.get(key);
+			switch (data.event) {
+				case "on_tool_start":
+					next.set(key, {
+						toolCallId: data.toolCallId,
+						name: data.name,
+						state: "starting",
+						input: data.input
+					});
+					break;
+				case "on_tool_event":
+					if (existing) next.set(key, {
+						...existing,
+						state: "running",
+						data: data.data
+					});
+					break;
+				case "on_tool_end":
+					if (existing) next.set(key, {
+						...existing,
+						state: "completed",
+						result: data.output
+					});
+					break;
+				case "on_tool_error":
+					if (existing) next.set(key, {
+						...existing,
+						state: "error",
+						error: data.error
+					});
+					break;
+				default: throw new Error(`Unexpected tool event: ${data.event}`);
+			}
+			return next;
+		});
+	}, []);
+	const historyValues = branchContext.threadHead?.values ?? options.initialValues ?? {};
+	const historyMessages = getMessages(historyValues);
+	const shouldReconstructSubagents = options.filterSubagentMessages && !stream.isLoading && !history.isLoading && historyMessages.length > 0;
+	(0, react.useEffect)(() => {
+		if (shouldReconstructSubagents) stream.reconstructSubagents(historyMessages, { skipIfPopulated: true });
+	}, [shouldReconstructSubagents, historyMessages.length]);
+	const historyError = (() => {
+		const error = branchContext.threadHead?.tasks?.at(-1)?.error;
+		if (error == null) return void 0;
+		try {
+			const parsed = JSON.parse(error);
+			if (require_errors.StreamError.isStructuredError(parsed)) return new require_errors.StreamError(parsed);
+			return parsed;
+		} catch {}
+		return error;
+	})();
+	const messageMetadata = (() => {
+		const alreadyShown = /* @__PURE__ */ new Set();
+		return getMessages(historyValues).map((message, idx) => {
+			const messageId = message.id ?? idx;
+			const firstSeenState = require_utils.findLast(history.data ?? [], (state) => getMessages(state.values).map((m, idx) => m.id ?? idx).includes(messageId));
+			const checkpointId = firstSeenState?.checkpoint?.checkpoint_id;
+			let branch = checkpointId != null ? branchContext.branchByCheckpoint[checkpointId] : void 0;
+			if (!branch?.branch?.length) branch = void 0;
+			const optionsShown = branch?.branchOptions?.flat(2).join(",");
+			if (optionsShown) {
+				if (alreadyShown.has(optionsShown)) branch = void 0;
+				alreadyShown.add(optionsShown);
+			}
+			return {
+				messageId: messageId.toString(),
+				firstSeenState,
+				branch: branch?.branch,
+				branchOptions: branch?.branchOptions
+			};
+		});
+	})();
+	const stop = () => stream.stop(historyValues, { onStop: (args) => {
+		if (runMetadataStorage && threadId) {
+			const runId = runMetadataStorage.getItem(`lg:stream:${threadId}`);
+			if (runId) client.runs.cancel(threadId, runId);
+			runMetadataStorage.removeItem(`lg:stream:${threadId}`);
+		}
+		options.onStop?.(args);
+	} });
+	const submit = async (values, submitOptions) => {
+		setToolProgressMap(/* @__PURE__ */ new Map());
+		const checkpointId = submitOptions?.checkpoint?.checkpoint_id;
+		setBranch(checkpointId != null ? branchContext.branchByCheckpoint[checkpointId]?.branch ?? "" : "");
+		const includeImplicitBranch = historyLimit === true || typeof historyLimit === "number";
+		const shouldRefetch = options.onFinish != null || includeImplicitBranch;
+		let callbackMeta;
+		let rejoinKey;
+		let usableThreadId = threadId;
+		const shouldAbortPrevious = (submitOptions?.multitaskStrategy === "interrupt" || submitOptions?.multitaskStrategy === "rollback") && stream.isLoading;
+		await stream.start(async (signal) => {
+			stream.setStreamValues((values) => {
+				const prev = {
+					...historyValues,
+					...values
+				};
+				if (submitOptions?.optimisticValues != null) return {
+					...prev,
+					...typeof submitOptions.optimisticValues === "function" ? submitOptions.optimisticValues(prev) : submitOptions.optimisticValues
+				};
+				return { ...prev };
+			});
+			if (!usableThreadId) {
+				usableThreadId = (await client.threads.create({
+					threadId: submitOptions?.threadId,
+					metadata: submitOptions?.metadata,
+					signal
+				})).thread_id;
+				threadIdRef.current = usableThreadId;
+				threadIdStreamingRef.current = usableThreadId;
+				onThreadId(usableThreadId);
+			}
+			if (!usableThreadId) throw new Error("Failed to obtain valid thread ID.");
+			threadIdStreamingRef.current = usableThreadId;
+			const streamMode = require_utils.unique([
+				...submitOptions?.streamMode ?? [],
+				...trackStreamModeRef.current,
+				...callbackStreamMode
+			]);
+			let checkpoint = submitOptions?.checkpoint ?? (includeImplicitBranch ? branchContext.threadHead?.checkpoint : void 0) ?? void 0;
+			if (submitOptions?.checkpoint === null) checkpoint = void 0;
+			if (checkpoint != null) delete checkpoint.thread_id;
+			const streamResumable = submitOptions?.streamResumable ?? !!runMetadataStorage;
+			return client.runs.stream(usableThreadId, options.assistantId, {
+				input: values,
+				config: submitOptions?.config,
+				context: submitOptions?.context,
+				command: submitOptions?.command,
+				interruptBefore: submitOptions?.interruptBefore,
+				interruptAfter: submitOptions?.interruptAfter,
+				metadata: submitOptions?.metadata,
+				multitaskStrategy: submitOptions?.multitaskStrategy,
+				onCompletion: submitOptions?.onCompletion,
+				onDisconnect: submitOptions?.onDisconnect ?? (streamResumable ? "continue" : "cancel"),
+				signal,
+				checkpoint,
+				streamMode,
+				streamSubgraphs: submitOptions?.streamSubgraphs,
+				streamResumable,
+				durability: submitOptions?.durability,
+				onRunCreated(params) {
+					callbackMeta = {
+						run_id: params.run_id,
+						thread_id: params.thread_id ?? usableThreadId
+					};
+					if (runMetadataStorage) {
+						rejoinKey = `lg:stream:${usableThreadId}`;
+						runMetadataStorage.setItem(rejoinKey, callbackMeta.run_id);
+					}
+					options.onCreated?.(callbackMeta);
+				}
+			});
+		}, {
+			getMessages,
+			setMessages,
+			initialValues: historyValues,
+			callbacks: {
+				...options,
+				onToolEvent: (data, opts) => {
+					handleToolEvent(data);
+					options.onToolEvent?.(data, opts);
+				}
+			},
+			async onSuccess() {
+				if (rejoinKey) runMetadataStorage?.removeItem(rejoinKey);
+				if (shouldRefetch) {
+					const lastHead = (await history.mutate(usableThreadId))?.at(0);
+					if (lastHead) {
+						options.onFinish?.(lastHead, callbackMeta);
+						return null;
+					}
+				}
+			},
+			onError(error) {
+				options.onError?.(error, callbackMeta);
+			},
+			onFinish() {
+				threadIdStreamingRef.current = null;
+			}
+		}, { abortPrevious: shouldAbortPrevious });
+	};
+	const joinStream = async (runId, lastEventId, joinOptions) => {
+		setToolProgressMap(/* @__PURE__ */ new Map());
+		lastEventId ??= "-1";
+		if (!threadId) return;
+		const callbackMeta = {
+			thread_id: threadId,
+			run_id: runId
+		};
+		await stream.start(async (signal) => {
+			threadIdStreamingRef.current = threadId;
+			const stream = client.runs.joinStream(threadId, runId, {
+				signal,
+				lastEventId,
+				streamMode: joinOptions?.streamMode
+			});
+			return joinOptions?.filter != null ? require_utils.filterStream(stream, joinOptions.filter) : stream;
+		}, {
+			getMessages,
+			setMessages,
+			initialValues: historyValues,
+			callbacks: {
+				...options,
+				onToolEvent: (data, opts) => {
+					handleToolEvent(data);
+					options.onToolEvent?.(data, opts);
+				}
+			},
+			async onSuccess() {
+				runMetadataStorage?.removeItem(`lg:stream:${threadId}`);
+				const lastHead = (await history.mutate(threadId))?.at(0);
+				if (lastHead) options.onFinish?.(lastHead, callbackMeta);
+			},
+			onError(error) {
+				options.onError?.(error, callbackMeta);
+			},
+			onFinish() {
+				threadIdStreamingRef.current = null;
+			}
+		});
+	};
+	const reconnectKey = (0, react.useMemo)(() => {
+		if (!runMetadataStorage || stream.isLoading) return void 0;
+		if (typeof window === "undefined") return void 0;
+		const runId = runMetadataStorage?.getItem(`lg:stream:${threadId}`);
+		if (!runId) return void 0;
+		return {
+			runId,
+			threadId
+		};
+	}, [
+		runMetadataStorage,
+		stream.isLoading,
+		threadId
+	]);
+	const shouldReconnect = !!runMetadataStorage;
+	const reconnectRef = (0, react.useRef)({
+		threadId,
+		shouldReconnect
+	});
+	const joinStreamRef = (0, react.useRef)(joinStream);
+	joinStreamRef.current = joinStream;
+	(0, react.useEffect)(() => {
+		if (reconnectRef.current.threadId !== threadId) reconnectRef.current = {
+			threadId,
+			shouldReconnect
+		};
+	}, [threadId, shouldReconnect]);
+	(0, react.useEffect)(() => {
+		if (reconnectKey && reconnectRef.current.shouldReconnect) {
+			reconnectRef.current.shouldReconnect = false;
+			joinStreamRef.current?.(reconnectKey.runId);
+		}
+	}, [reconnectKey]);
+	const error = stream.error ?? historyError ?? history.error;
+	const values = stream.values ?? historyValues;
+	return {
+		get values() {
+			trackStreamMode("values");
+			return values;
+		},
+		client,
+		assistantId: options.assistantId,
+		error,
+		isLoading: stream.isLoading,
+		stop,
+		submit,
+		switchThread,
+		joinStream,
+		branch,
+		setBranch,
+		get history() {
+			if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
+			return branchContext.flatHistory;
+		},
+		isThreadLoading: history.isLoading && history.data == null,
+		get experimental_branchTree() {
+			if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `experimental_branchTree`");
+			return branchContext.branchTree;
+		},
+		get interrupts() {
+			if (values != null && "__interrupt__" in values && Array.isArray(values.__interrupt__)) {
+				const valueInterrupts = values.__interrupt__;
+				if (valueInterrupts.length === 0) return [{ when: "breakpoint" }];
+				return valueInterrupts;
+			}
+			if (stream.isLoading) return [];
+			const allInterrupts = (branchContext.threadHead?.tasks ?? []).flatMap((t) => t.interrupts ?? []);
+			if (allInterrupts.length > 0) return allInterrupts;
+			if (!(branchContext.threadHead?.next ?? []).length || error != null) return [];
+			return [{ when: "breakpoint" }];
+		},
+		get interrupt() {
+			const all = this.interrupts;
+			if (all.length === 0) return void 0;
+			if (all.length === 1) return all[0];
+			return all;
+		},
+		get messages() {
+			trackStreamMode("messages-tuple", "values");
+			return getMessages(values);
+		},
+		get toolCalls() {
+			trackStreamMode("messages-tuple", "values");
+			return require_tools.getToolCallsWithResults(getMessages(values));
+		},
+		get toolProgress() {
+			trackStreamMode("tools");
+			return Array.from(toolProgressMap.values());
+		},
+		getToolCalls(message) {
+			trackStreamMode("messages-tuple", "values");
+			return require_tools.getToolCallsWithResults(getMessages(values)).filter((tc) => tc.aiMessage.id === message.id);
+		},
+		getMessagesMetadata(message, index) {
+			trackStreamMode("values");
+			const streamMetadata = messageManager.get(message.id)?.metadata;
+			const historyMetadata = messageMetadata?.find((m) => m.messageId === (message.id ?? index));
+			if (streamMetadata != null || historyMetadata != null) return {
+				...historyMetadata,
+				streamMetadata
+			};
+		},
+		get subagents() {
+			trackStreamMode("updates", "messages-tuple");
+			return stream.getSubagents();
+		},
+		get activeSubagents() {
+			trackStreamMode("updates", "messages-tuple");
+			return stream.getActiveSubagents();
+		},
+		getSubagent(toolCallId) {
+			trackStreamMode("updates", "messages-tuple");
+			return stream.getSubagent(toolCallId);
+		},
+		getSubagentsByType(type) {
+			trackStreamMode("updates", "messages-tuple");
+			return stream.getSubagentsByType(type);
+		},
+		getSubagentsByMessage(messageId) {
+			trackStreamMode("updates", "messages-tuple");
+			return stream.getSubagentsByMessage(messageId);
+		}
+	};
+}
+//#endregion
+exports.useStreamLGP = useStreamLGP;
+
+//# sourceMappingURL=stream.lgp.cjs.map