@langchain/vue 0.1.3 → 0.3.0

package/dist/index.js

@@ -1,470 +1,174 @@
 import { useStreamCustom } from "./stream.custom.js";
-import { computed, onScopeDispose, ref, shallowRef, watch } from "vue";
-import { FetchStreamTransport, MessageTupleManager, PendingRunsTracker, StreamError, StreamManager, SubagentManager, calculateDepthFromNamespace, ensureHistoryMessageInstances, ensureMessageInstances, extractInterrupts, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterStream, getBranchContext, getMessagesMetadataMap, isSubagentNamespace, toMessageClass, unique } from "@langchain/langgraph-sdk/ui";
-import { getToolCallsWithResults } from "@langchain/langgraph-sdk/utils";
+import { LANGCHAIN_OPTIONS, LangChainPlugin, provideStream, useStreamContext } from "./context.js";
+import { computed, inject, onScopeDispose, reactive, ref, shallowRef, toValue, watch } from "vue";
+import { FetchStreamTransport, StreamOrchestrator, SubagentManager, calculateDepthFromNamespace, ensureMessageInstances, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
 import { Client } from "@langchain/langgraph-sdk";
 //#region src/index.ts
-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 useStreamLGP(options) {
-	const runMetadataStorage = (() => {
-		if (typeof window === "undefined") return null;
-		const storage = options.reconnectOnMount;
-		if (storage === true) return window.sessionStorage;
-		if (typeof storage === "function") return storage();
-		return null;
-	})();
-	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 historyLimit = typeof options.fetchStateHistory === "object" && options.fetchStateHistory != null ? options.fetchStateHistory.limit ?? false : options.fetchStateHistory ?? false;
-	const threadId = ref(void 0);
-	let threadIdPromise = null;
-	const client = options.client ?? new Client({ apiUrl: options.apiUrl });
-	const history = shallowRef({
-		data: void 0,
-		error: void 0,
-		isLoading: false,
-		mutate: async () => void 0
-	});
-	async function mutate(mutateId) {
-		const tid = mutateId ?? threadId.value;
-		if (!tid) return void 0;
-		try {
-			const data = await fetchHistory(client, tid, { limit: historyLimit });
-			history.value = {
-				data,
-				error: void 0,
-				isLoading: false,
-				mutate
-			};
-			return data;
-		} catch (err) {
-			history.value = {
-				...history.value,
-				error: err,
-				isLoading: false
-			};
-			options.onError?.(err, void 0);
-			return;
-		}
-	}
-	history.value = {
-		...history.value,
-		mutate
-	};
-	const branch = ref("");
-	const branchContext = computed(() => getBranchContext(branch.value, history.value.data ?? void 0));
-	const messageManager = new MessageTupleManager();
-	const stream = new StreamManager(messageManager, {
-		throttle: options.throttle ?? false,
-		subagentToolNames: options.subagentToolNames,
-		filterSubagentMessages: options.filterSubagentMessages,
-		toMessage: toMessageClass
-	});
-	const pendingRuns = new PendingRunsTracker();
-	const queueEntries = shallowRef(pendingRuns.entries);
-	const queueSize = ref(pendingRuns.size);
-	const trackedStreamModes = [];
-	function trackStreamMode(...modes) {
-		for (const mode of modes) if (!trackedStreamModes.includes(mode)) trackedStreamModes.push(mode);
-	}
-	const callbackStreamModes = [];
-	if (options.onUpdateEvent) callbackStreamModes.push("updates");
-	if (options.onCustomEvent) callbackStreamModes.push("custom");
-	if (options.onCheckpointEvent) callbackStreamModes.push("checkpoints");
-	if (options.onTaskEvent) callbackStreamModes.push("tasks");
-	if ("onDebugEvent" in options && options.onDebugEvent) callbackStreamModes.push("debug");
-	if ("onLangChainEvent" in options && options.onLangChainEvent) callbackStreamModes.push("events");
-	const historyValues = computed(() => branchContext.value.threadHead?.values ?? options.initialValues ?? {});
-	const historyError = computed(() => {
-		const error = branchContext.value.threadHead?.tasks?.at(-1)?.error;
-		if (error == null) return void 0;
-		try {
-			const parsed = JSON.parse(error);
-			if (StreamError.isStructuredError(parsed)) return new StreamError(parsed);
-			return parsed;
-		} catch {}
-		return error;
+	const pluginOptions = inject(LANGCHAIN_OPTIONS, {});
+	const client = computed(() => {
+		const c = toValue(options.client) ?? pluginOptions.client;
+		if (c) return c;
+		return new Client({
+			apiUrl: toValue(options.apiUrl) ?? pluginOptions.apiUrl,
+			apiKey: toValue(options.apiKey) ?? pluginOptions.apiKey,
+			callerOptions: toValue(options.callerOptions),
+			defaultHeaders: toValue(options.defaultHeaders)
+		});
 	});
-	const streamValues = shallowRef(stream.values);
-	const streamError = shallowRef(stream.error);
-	const isLoading = shallowRef(stream.isLoading);
-	const values = computed(() => streamValues.value ?? historyValues.value);
-	const error = computed(() => streamError.value ?? historyError.value ?? history.value.error);
-	const messageMetadata = computed(() => getMessagesMetadataMap({
-		initialValues: options.initialValues,
-		history: history.value.data,
-		getMessages,
-		branchContext: branchContext.value
-	}));
-	const subagentVersion = shallowRef(0);
-	const unsubscribe = stream.subscribe(() => {
-		streamValues.value = stream.values;
-		streamError.value = stream.error;
-		isLoading.value = stream.isLoading;
-		subagentVersion.value += 1;
+	const orchestrator = new StreamOrchestrator(options, {
+		getClient: () => client.value,
+		getAssistantId: () => toValue(options.assistantId),
+		getMessagesKey: () => toValue(options.messagesKey) ?? "messages"
 	});
-	const unsubQueue = pendingRuns.subscribe(() => {
-		queueEntries.value = pendingRuns.entries;
-		queueSize.value = pendingRuns.size;
+	const initialThreadId = toValue(options.threadId) ?? void 0;
+	orchestrator.initThreadId(initialThreadId);
+	watch(() => toValue(options.threadId), (newId) => {
+		const resolved = newId ?? void 0;
+		orchestrator.setThreadId(resolved);
+	}, { flush: "sync" });
+	const version = shallowRef(0);
+	const subagentsRef = shallowRef(orchestrator.subagents);
+	const activeSubagentsRef = shallowRef(orchestrator.activeSubagents);
+	const unsubscribe = orchestrator.subscribe(() => {
+		version.value += 1;
+		subagentsRef.value = orchestrator.subagents;
+		activeSubagentsRef.value = orchestrator.activeSubagents;
 	});
 	onScopeDispose(() => {
 		unsubscribe();
-		unsubQueue();
-		stop();
+		orchestrator.dispose();
 	});
 	watch(() => {
-		const hvMessages = getMessages(historyValues.value);
+		version.value;
+		const hvMessages = orchestrator.messages;
 		return {
-			should: options.filterSubagentMessages && !isLoading.value && !history.value.isLoading && hvMessages.length > 0,
+			should: options.filterSubagentMessages && !orchestrator.isLoading && !orchestrator.historyData.isLoading && hvMessages.length > 0,
 			len: hvMessages.length
 		};
-	}, ({ should }) => {
+	}, ({ should }, _prev, onCleanup) => {
 		if (should) {
-			const hvMessages = getMessages(historyValues.value);
-			stream.reconstructSubagents(hvMessages, { skipIfPopulated: true });
+			const controller = orchestrator.reconstructSubagentsIfNeeded();
+			if (controller) onCleanup(() => controller.abort());
 		}
 	}, { immediate: true });
-	function stop() {
-		return stream.stop(historyValues.value, { onStop: (args) => {
-			if (runMetadataStorage && threadId.value) {
-				const runId = runMetadataStorage.getItem(`lg:stream:${threadId.value}`);
-				if (runId) client.runs.cancel(threadId.value, runId);
-				runMetadataStorage.removeItem(`lg:stream:${threadId.value}`);
-			}
-			options.onStop?.(args);
-		} });
-	}
-	function setBranch(value) {
-		branch.value = value;
-	}
-	async function joinStream(runId, lastEventId, joinOptions) {
-		lastEventId ??= "-1";
-		if (!threadId.value) return;
-		const callbackMeta = {
-			thread_id: threadId.value,
-			run_id: runId
-		};
-		await stream.start(async (signal) => {
-			const rawStream = client.runs.joinStream(threadId.value, runId, {
-				signal,
-				lastEventId,
-				streamMode: joinOptions?.streamMode
-			});
-			return joinOptions?.filter != null ? filterStream(rawStream, joinOptions.filter) : rawStream;
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: historyValues.value,
-			callbacks: options,
-			async onSuccess() {
-				runMetadataStorage?.removeItem(`lg:stream:${threadId.value}`);
-				const lastHead = (await mutate(threadId.value))?.at(0);
-				if (lastHead) options.onFinish?.(lastHead, callbackMeta);
-			},
-			onError(error) {
-				options.onError?.(error, callbackMeta);
-			}
-		});
-	}
-	function submitDirect(values, submitOptions) {
-		const currentBranchContext = branchContext.value;
-		const checkpointId = submitOptions?.checkpoint?.checkpoint_id;
-		branch.value = checkpointId != null ? currentBranchContext.branchByCheckpoint[checkpointId]?.branch ?? "" : "";
-		const includeImplicitBranch = historyLimit === true || typeof historyLimit === "number";
-		const shouldRefetch = options.onFinish != null || includeImplicitBranch;
-		let checkpoint = submitOptions?.checkpoint ?? (includeImplicitBranch ? currentBranchContext.threadHead?.checkpoint : void 0) ?? void 0;
-		if (submitOptions?.checkpoint === null) checkpoint = void 0;
-		if (checkpoint != null) delete checkpoint.thread_id;
-		let callbackMeta;
-		let rejoinKey;
-		let usableThreadId;
-		return stream.start(async (signal) => {
-			usableThreadId = threadId.value;
-			if (!usableThreadId) {
-				const threadPromise = client.threads.create({
-					threadId: submitOptions?.threadId,
-					metadata: submitOptions?.metadata
-				});
-				threadIdPromise = threadPromise.then((t) => t.thread_id);
-				usableThreadId = (await threadPromise).thread_id;
-				threadId.value = usableThreadId;
-				options.onThreadId?.(usableThreadId);
-			}
-			const streamMode = unique([
-				"values",
-				"updates",
-				...submitOptions?.streamMode ?? [],
-				...trackedStreamModes,
-				...callbackStreamModes
-			]);
-			stream.setStreamValues(() => {
-				const prev = {
-					...historyValues.value,
-					...stream.values
-				};
-				if (submitOptions?.optimisticValues != null) return {
-					...prev,
-					...typeof submitOptions.optimisticValues === "function" ? submitOptions.optimisticValues(prev) : submitOptions.optimisticValues
-				};
-				return { ...prev };
-			});
-			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.value,
-			callbacks: options,
-			async onSuccess() {
-				if (rejoinKey) runMetadataStorage?.removeItem(rejoinKey);
-				if (shouldRefetch && usableThreadId) {
-					const lastHead = (await mutate(usableThreadId))?.at(0);
-					if (lastHead) {
-						options.onFinish?.(lastHead, callbackMeta);
-						return null;
-					}
-				}
-			},
-			onError: (error) => {
-				options.onError?.(error, callbackMeta);
-				submitOptions?.onError?.(error, callbackMeta);
-			},
-			onFinish: () => {}
-		});
-	}
-	const submitting = ref(false);
-	function drainQueue() {
-		if (!isLoading.value && !submitting.value && pendingRuns.size > 0) {
-			const next = pendingRuns.shift();
-			if (next) {
-				submitting.value = true;
-				joinStream(next.id).finally(() => {
-					submitting.value = false;
-					drainQueue();
-				});
-			}
-		}
-	}
 	watch(() => ({
-		loading: isLoading.value,
-		submitting: submitting.value,
-		size: pendingRuns.size
+		loading: orchestrator.isLoading,
+		size: orchestrator.queueSize,
+		v: version.value
 	}), () => {
-		drainQueue();
+		orchestrator.drainQueue();
 	});
-	async function submit(values, submitOptions) {
-		if (stream.isLoading || submitting.value) {
-			if (submitOptions?.multitaskStrategy === "interrupt" || submitOptions?.multitaskStrategy === "rollback") {
-				submitting.value = true;
-				try {
-					await submitDirect(values, submitOptions);
-				} finally {
-					submitting.value = false;
-				}
-				return;
-			}
-			let usableThreadId = threadId.value;
-			if (!usableThreadId && threadIdPromise) usableThreadId = await threadIdPromise;
-			if (usableThreadId) {
-				try {
-					const run = await client.runs.create(usableThreadId, options.assistantId, {
-						input: values,
-						config: submitOptions?.config,
-						context: submitOptions?.context,
-						command: submitOptions?.command,
-						interruptBefore: submitOptions?.interruptBefore,
-						interruptAfter: submitOptions?.interruptAfter,
-						metadata: submitOptions?.metadata,
-						multitaskStrategy: "enqueue",
-						streamResumable: true,
-						streamSubgraphs: submitOptions?.streamSubgraphs,
-						durability: submitOptions?.durability
-					});
-					pendingRuns.add({
-						id: run.run_id,
-						values,
-						options: submitOptions,
-						createdAt: new Date(run.created_at)
-					});
-				} catch (error) {
-					options.onError?.(error, void 0);
-					submitOptions?.onError?.(error, void 0);
-				}
-				return;
-			}
-		}
-		submitting.value = true;
-		const result = submitDirect(values, submitOptions);
-		Promise.resolve(result).finally(() => {
-			submitting.value = false;
-			drainQueue();
-		});
-		return result;
-	}
-	let shouldReconnect = !!runMetadataStorage;
-	function tryReconnect() {
-		if (shouldReconnect && runMetadataStorage && threadId.value) {
-			const runId = runMetadataStorage.getItem(`lg:stream:${threadId.value}`);
-			if (runId) {
-				shouldReconnect = false;
-				joinStream(runId);
-			}
-		}
-	}
-	tryReconnect();
-	watch(() => threadId.value, () => {
-		shouldReconnect = !!runMetadataStorage;
-		tryReconnect();
-	});
-	const toolCalls = computed(() => {
-		trackStreamMode("messages-tuple");
-		return getToolCallsWithResults(getMessages(values.value));
+	let { shouldReconnect } = orchestrator;
+	if (shouldReconnect) orchestrator.tryReconnect();
+	watch(() => {
+		version.value;
+		return orchestrator.threadId;
+	}, () => {
+		({shouldReconnect} = orchestrator);
+		if (shouldReconnect) orchestrator.tryReconnect();
 	});
-	function getToolCalls(message) {
-		trackStreamMode("messages-tuple");
-		return getToolCallsWithResults(getMessages(values.value)).filter((tc) => tc.aiMessage.id === message.id);
-	}
-	const interrupts = computed(() => {
-		const v = values.value;
-		if (v != null && "__interrupt__" in v && Array.isArray(v.__interrupt__)) {
-			const valueInterrupts = v.__interrupt__;
-			if (valueInterrupts.length === 0) return [{ when: "breakpoint" }];
-			return valueInterrupts;
-		}
-		if (isLoading.value) return [];
-		const allInterrupts = (branchContext.value.threadHead?.tasks ?? []).flatMap((t) => t.interrupts ?? []);
-		if (allInterrupts.length > 0) return allInterrupts;
-		if (!(branchContext.value.threadHead?.next ?? []).length || error.value != null) return [];
-		return [{ when: "breakpoint" }];
+	const values = computed(() => {
+		version.value;
+		return orchestrator.values;
 	});
-	const flatHistory = computed(() => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
-		return ensureHistoryMessageInstances(branchContext.value.flatHistory, options.messagesKey ?? "messages");
+	const error = computed(() => {
+		version.value;
+		return orchestrator.error;
 	});
-	const isThreadLoading = computed(() => history.value.isLoading && history.value.data == null);
-	const experimentalBranchTree = computed(() => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `experimental_branchTree`");
-		return branchContext.value.branchTree;
+	const isLoading = computed(() => {
+		version.value;
+		return orchestrator.isLoading;
 	});
+	const branch = ref("");
+	watch(() => {
+		version.value;
+		return orchestrator.branch;
+	}, (newBranch) => {
+		if (branch.value !== newBranch) branch.value = newBranch;
+	}, { immediate: true });
 	return {
-		assistantId: options.assistantId,
-		client,
+		get assistantId() {
+			return toValue(options.assistantId);
+		},
+		get client() {
+			return client.value;
+		},
 		values,
 		error,
 		isLoading,
 		branch,
-		setBranch,
+		setBranch(value) {
+			orchestrator.setBranch(value);
+		},
 		messages: computed(() => {
-			trackStreamMode("messages-tuple");
-			return ensureMessageInstances(getMessages(streamValues.value ?? historyValues.value));
+			version.value;
+			orchestrator.trackStreamMode("messages-tuple");
+			return ensureMessageInstances(orchestrator.messages);
 		}),
-		toolCalls,
-		getToolCalls,
-		interrupt: computed(() => extractInterrupts(streamValues.value, {
-			isLoading: isLoading.value,
-			threadState: branchContext.value.threadHead,
-			error: streamError.value
-		})),
-		interrupts,
-		history: flatHistory,
-		isThreadLoading,
-		experimental_branchTree: experimentalBranchTree,
-		getMessagesMetadata: (message, index) => {
-			const streamMetadata = messageManager.get(message.id)?.metadata;
-			const historyMetadata = messageMetadata.value?.find((m) => m.messageId === (message.id ?? index));
-			if (streamMetadata != null || historyMetadata != null) return {
-				...historyMetadata,
-				streamMetadata
-			};
+		toolCalls: computed(() => {
+			version.value;
+			return orchestrator.toolCalls;
+		}),
+		getToolCalls(message) {
+			orchestrator.trackStreamMode("messages-tuple");
+			return orchestrator.getToolCalls(message);
 		},
-		submit,
-		stop,
-		joinStream,
-		queue: {
-			entries: queueEntries,
-			size: queueSize,
-			async cancel(id) {
-				const tid = threadId.value;
-				const removed = pendingRuns.remove(id);
-				if (removed && tid) await client.runs.cancel(tid, id);
-				return removed;
-			},
-			async clear() {
-				const tid = threadId.value;
-				const removed = pendingRuns.removeAll();
-				if (tid && removed.length > 0) await Promise.all(removed.map((e) => client.runs.cancel(tid, e.id)));
-			}
+		interrupt: computed(() => {
+			version.value;
+			return orchestrator.interrupt;
+		}),
+		interrupts: computed(() => {
+			version.value;
+			return orchestrator.interrupts;
+		}),
+		history: computed(() => {
+			version.value;
+			return orchestrator.flatHistory;
+		}),
+		isThreadLoading: computed(() => {
+			version.value;
+			return orchestrator.isThreadLoading;
+		}),
+		experimental_branchTree: computed(() => {
+			version.value;
+			return orchestrator.experimental_branchTree;
+		}),
+		getMessagesMetadata: (message, index) => {
+			return orchestrator.getMessagesMetadata(message, index);
 		},
+		submit: (...args) => orchestrator.submit(...args),
+		stop: () => orchestrator.stop(),
+		joinStream: (...args) => orchestrator.joinStream(...args),
+		queue: reactive({
+			entries: computed(() => {
+				version.value;
+				return orchestrator.queueEntries;
+			}),
+			size: computed(() => {
+				version.value;
+				return orchestrator.queueSize;
+			}),
+			cancel: (id) => orchestrator.cancelQueueItem(id),
+			clear: () => orchestrator.clearQueue()
+		}),
 		switchThread(newThreadId) {
-			if (newThreadId !== (threadId.value ?? null)) {
-				const prevThreadId = threadId.value;
-				threadId.value = newThreadId ?? void 0;
-				stream.clear();
-				const removed = pendingRuns.removeAll();
-				if (prevThreadId && removed.length > 0) Promise.all(removed.map((e) => client.runs.cancel(prevThreadId, e.id)));
-				if (newThreadId != null) options.onThreadId?.(newThreadId);
-			}
+			orchestrator.switchThread(newThreadId);
 		},
 		get subagents() {
-			subagentVersion.value;
-			return stream.getSubagents();
+			return subagentsRef.value;
 		},
 		get activeSubagents() {
-			subagentVersion.value;
-			return stream.getActiveSubagents();
+			return activeSubagentsRef.value;
 		},
 		getSubagent(toolCallId) {
-			return stream.getSubagent(toolCallId);
+			return orchestrator.getSubagent(toolCallId);
 		},
 		getSubagentsByType(type) {
-			return stream.getSubagentsByType(type);
+			return orchestrator.getSubagentsByType(type);
 		},
 		getSubagentsByMessage(messageId) {
-			return stream.getSubagentsByMessage(messageId);
+			return orchestrator.getSubagentsByMessage(messageId);
 		}
 	};
 }
@@ -473,6 +177,6 @@ function useStream(options) {
 	return useStreamLGP(options);
 }
 //#endregion
-export { FetchStreamTransport, SubagentManager, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace, useStream };
+export { FetchStreamTransport, LANGCHAIN_OPTIONS, LangChainPlugin, SubagentManager, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace, provideStream, useStream, useStreamContext };
 
 //# sourceMappingURL=index.js.map