@langchain/vue 0.4.7 → 1.0.1

package/dist/use-stream.d.cts

@@ -0,0 +1,118 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+import { BaseMessage } from "@langchain/core/messages";
+import { Client, Interrupt } from "@langchain/langgraph-sdk";
+import { ThreadStream } from "@langchain/langgraph-sdk/client";
+import { AgentServerOptions, AssembledToolCall, ChannelRegistry, CustomAdapterOptions, InferStateType, InferSubagentStates, StateOf, StreamController, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, UseStreamOptions, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-stream.d.ts
+/** @deprecated Prefer {@link InferStateType}. */
+type StateOf$1<T> = StateOf<T>;
+type VueThreadId = MaybeRefOrGetter<string | null | undefined>;
+type VueApiString = MaybeRefOrGetter<string | undefined>;
+type AgentServerOptions$1<StateType extends object> = AgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;
+type CustomAdapterOptions$1<StateType extends object> = CustomAdapterOptions<StateType, VueThreadId, string>;
+type UseStreamOptions$1<StateType extends object = Record<string, unknown>> = UseStreamOptions<StateType, VueThreadId, VueApiString, VueApiString, string>;
+/**
+ * Private field on the handle that carries the {@link StreamController}
+ * reference. Selector composables read this to reach the shared
+ * {@link ChannelRegistry}. Use the selector composables (`useMessages`,
+ * `useToolCalls`, `useValues`, …) instead of reading this directly.
+ */
+declare const STREAM_CONTROLLER: unique symbol;
+/**
+ * Vue binding return type for {@link useStream}.
+ *
+ * Reactive primitives follow Vue conventions:
+ *
+ *  - Data projections are `Readonly<ShallowRef<T>>` / `ComputedRef<T>`
+ *    so templates auto-unwrap via `msg.value` in `<script setup>`
+ *    and directly in templates. They are snapshots — never mutate.
+ *  - Imperative methods (`submit` / `stop` / `respond`) are plain
+ *    functions — no refs involved.
+ *  - Identity values captured at setup time (`client` / `assistantId`)
+ *    are exposed as plain values; if you need to swap the bound agent
+ *    or client, remount the composable.
+ */
+interface UseStreamReturn<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>, StateType extends object = InferStateType<T>, SubagentStates = InferSubagentStates<T>> {
+  readonly values: Readonly<ShallowRef<StateType>>;
+  readonly messages: Readonly<ShallowRef<BaseMessage[]>>;
+  readonly toolCalls: Readonly<ShallowRef<AssembledToolCall[]>>;
+  readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;
+  readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;
+  readonly isLoading: ComputedRef<boolean>;
+  readonly isThreadLoading: ComputedRef<boolean>;
+  readonly error: ComputedRef<unknown>;
+  readonly threadId: ComputedRef<string | null>;
+  /**
+   * Promise that settles when the active thread's initial hydration
+   * completes. Exposed so `async setup()` sites can
+   * `await stream.hydrationPromise` to implement a Suspense-like
+   * boundary.
+   */
+  readonly hydrationPromise: ComputedRef<Promise<void>>;
+  readonly subagents: Readonly<ShallowRef<ReadonlyMap<keyof SubagentStates & string extends never ? string : keyof SubagentStates & string, SubagentDiscoverySnapshot>>>;
+  readonly subgraphs: Readonly<ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>>;
+  readonly subgraphsByNode: Readonly<ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>>;
+  submit(input: WidenUpdateMessages<Partial<StateType>> | null | undefined, options?: StreamSubmitOptions<StateType, ConfigurableType>): Promise<void>;
+  stop(): Promise<void>;
+  respond(response: unknown, target?: {
+    interruptId: string;
+    namespace?: string[];
+  }): Promise<void>;
+  readonly client: Client;
+  readonly assistantId: string;
+  /** v2 escape hatch — returns the bound {@link ThreadStream}. */
+  getThread(): ThreadStream | undefined;
+  /** @internal Used by selector composables. */
+  readonly [STREAM_CONTROLLER]: StreamController<StateType, InterruptType, ConfigurableType>;
+}
+/**
+ * Erased handle useful as a parameter type for helpers and wrapper
+ * components that pass a `stream` through to selector composables
+ * without reading `values` directly. Mirrors the React
+ * `AnyStream` alias.
+ */
+type AnyStream = UseStreamReturn<any, any, any>;
+/** Convenience alias for the fully-resolved stream handle type. */
+type UseStreamResult<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>> = UseStreamReturn<T, InterruptType, ConfigurableType>;
+/**
+ * Vue Composition API binding for the v2-native stream runtime.
+ *
+ * Returns a handle whose projections are Vue refs so templates
+ * auto-unwrap and scripts can feed them into `computed`/`watch`.
+ * Scoped views (subagents, subgraphs, any namespaced projection) are
+ * surfaced via the companion selector composables (`useMessages`,
+ * `useToolCalls`, `useValues`, `useMessageMetadata`,
+ * `useSubmissionQueue`, `useExtension`, `useChannel`, plus media
+ * composables).
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useStream } from "@langchain/vue";
+ *
+ * const stream = useStream({
+ *   assistantId: "agent",
+ *   apiUrl: "http://localhost:2024",
+ * });
+ * </script>
+ *
+ * <template>
+ *   <div v-for="msg in stream.messages.value" :key="msg.id">
+ *     {{ msg.content }}
+ *   </div>
+ *   <button @click="stream.submit({ messages: [{ type: 'human', content: 'Hi' }] })">
+ *     Send
+ *   </button>
+ * </template>
+ * ```
+ *
+ * `assistantId`, `client`, and `transport` are captured at setup time.
+ * To bind a new assistant/transport, remount the component. Reactive
+ * inputs (`threadId`, `apiUrl`, `apiKey`) trigger in-place behaviour
+ * changes on the active controller.
+ */
+declare function useStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: UseStreamOptions$1<InferStateType<T>>): UseStreamReturn<T, InterruptType, ConfigurableType>;
+//#endregion
+export { AgentServerOptions$1 as AgentServerOptions, AnyStream, CustomAdapterOptions$1 as CustomAdapterOptions, STREAM_CONTROLLER, StateOf$1 as StateOf, type ThreadStream, UseStreamOptions$1 as UseStreamOptions, UseStreamResult, UseStreamReturn, useStream };
+//# sourceMappingURL=use-stream.d.cts.map

package/dist/use-stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stream.d.cts","names":[],"sources":["../src/use-stream.ts"],"mappings":";;;;;;;;KAgDY,SAAA,MAAa,OAAA,CAAc,CAAA;AAAA,KAElC,WAAA,GAAc,gBAAA;AAAA,KACd,YAAA,GAAe,gBAAA;AAAA,KAER,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,WAAA,EAAa,YAAA,EAAc,YAAA;AAAA,KAErD,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,WAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,WAAA,EACA,YAAA,EACA,YAAA;;;;;AAjBwC;;cA2B7B,iBAAA;;;AAzBsB;;;;;AAGnC;;;;;;;UAwCiB,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EAAA,SAE5B,MAAA,EAAQ,QAAA,CAAS,UAAA,CAAW,SAAA;EAAA,SAC5B,QAAA,EAAU,QAAA,CAAS,UAAA,CAAW,WAAA;EAAA,SAC9B,SAAA,EAAW,QAAA,CAAS,UAAA,CAAW,iBAAA;EAAA,SAC/B,UAAA,EAAY,QAAA,CAAS,UAAA,CAAW,SAAA,CAAU,aAAA;EAAA,SAC1C,SAAA,EAAW,WAAA,CAAY,SAAA,CAAU,aAAA;EAAA,SACjC,SAAA,EAAW,WAAA;EAAA,SACX,eAAA,EAAiB,WAAA;EAAA,SACjB,KAAA,EAAO,WAAA;EAAA,SACP,QAAA,EAAU,WAAA;EAtDwD;AAE7E;;;;;EAF6E,SA8DlE,gBAAA,EAAkB,WAAA,CAAY,OAAA;EAAA,SAE9B,SAAA,EAAW,QAAA,CAClB,UAAA,CACE,WAAA,OACQ,cAAA,yCAEI,cAAA,WACV,yBAAA;EAAA,SAIG,SAAA,EAAW,QAAA,CAClB,UAAA,CAAW,WAAA,SAAoB,yBAAA;EAAA,SAExB,eAAA,EAAiB,QAAA,CACxB,UAAA,CAAW,WAAA,kBAA6B,yBAAA;EAG1C,MAAA,CACE,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,SAAA,uBACnC,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EACH,IAAA,IAAQ,OAAA;EACR,OAAA,CACE,QAAA,WACA,MAAA;IAAW,WAAA;IAAqB,SAAA;EAAA,IAC/B,OAAA;EAAA,SAEM,MAAA,EAAQ,MAAA;EAAA,SACR,WAAA;EAtFkB;EAyF3B,SAAA,IAAa,YAAA;EAtFb;EAAA,UAyFU,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;;;;KAWQ,SAAA,GAAY,eAAA;;KAGZ,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;AAlGtC;;;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuHgB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/use-stream.d.ts

@@ -0,0 +1,118 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+import { Client, Interrupt } from "@langchain/langgraph-sdk";
+import { ThreadStream } from "@langchain/langgraph-sdk/client";
+import { AgentServerOptions, AssembledToolCall, ChannelRegistry, CustomAdapterOptions, InferStateType, InferSubagentStates, StateOf, StreamController, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, UseStreamOptions, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/use-stream.d.ts
+/** @deprecated Prefer {@link InferStateType}. */
+type StateOf$1<T> = StateOf<T>;
+type VueThreadId = MaybeRefOrGetter<string | null | undefined>;
+type VueApiString = MaybeRefOrGetter<string | undefined>;
+type AgentServerOptions$1<StateType extends object> = AgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;
+type CustomAdapterOptions$1<StateType extends object> = CustomAdapterOptions<StateType, VueThreadId, string>;
+type UseStreamOptions$1<StateType extends object = Record<string, unknown>> = UseStreamOptions<StateType, VueThreadId, VueApiString, VueApiString, string>;
+/**
+ * Private field on the handle that carries the {@link StreamController}
+ * reference. Selector composables read this to reach the shared
+ * {@link ChannelRegistry}. Use the selector composables (`useMessages`,
+ * `useToolCalls`, `useValues`, …) instead of reading this directly.
+ */
+declare const STREAM_CONTROLLER: unique symbol;
+/**
+ * Vue binding return type for {@link useStream}.
+ *
+ * Reactive primitives follow Vue conventions:
+ *
+ *  - Data projections are `Readonly<ShallowRef<T>>` / `ComputedRef<T>`
+ *    so templates auto-unwrap via `msg.value` in `<script setup>`
+ *    and directly in templates. They are snapshots — never mutate.
+ *  - Imperative methods (`submit` / `stop` / `respond`) are plain
+ *    functions — no refs involved.
+ *  - Identity values captured at setup time (`client` / `assistantId`)
+ *    are exposed as plain values; if you need to swap the bound agent
+ *    or client, remount the composable.
+ */
+interface UseStreamReturn<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>, StateType extends object = InferStateType<T>, SubagentStates = InferSubagentStates<T>> {
+  readonly values: Readonly<ShallowRef<StateType>>;
+  readonly messages: Readonly<ShallowRef<BaseMessage[]>>;
+  readonly toolCalls: Readonly<ShallowRef<AssembledToolCall[]>>;
+  readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;
+  readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;
+  readonly isLoading: ComputedRef<boolean>;
+  readonly isThreadLoading: ComputedRef<boolean>;
+  readonly error: ComputedRef<unknown>;
+  readonly threadId: ComputedRef<string | null>;
+  /**
+   * Promise that settles when the active thread's initial hydration
+   * completes. Exposed so `async setup()` sites can
+   * `await stream.hydrationPromise` to implement a Suspense-like
+   * boundary.
+   */
+  readonly hydrationPromise: ComputedRef<Promise<void>>;
+  readonly subagents: Readonly<ShallowRef<ReadonlyMap<keyof SubagentStates & string extends never ? string : keyof SubagentStates & string, SubagentDiscoverySnapshot>>>;
+  readonly subgraphs: Readonly<ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>>;
+  readonly subgraphsByNode: Readonly<ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>>;
+  submit(input: WidenUpdateMessages<Partial<StateType>> | null | undefined, options?: StreamSubmitOptions<StateType, ConfigurableType>): Promise<void>;
+  stop(): Promise<void>;
+  respond(response: unknown, target?: {
+    interruptId: string;
+    namespace?: string[];
+  }): Promise<void>;
+  readonly client: Client;
+  readonly assistantId: string;
+  /** v2 escape hatch — returns the bound {@link ThreadStream}. */
+  getThread(): ThreadStream | undefined;
+  /** @internal Used by selector composables. */
+  readonly [STREAM_CONTROLLER]: StreamController<StateType, InterruptType, ConfigurableType>;
+}
+/**
+ * Erased handle useful as a parameter type for helpers and wrapper
+ * components that pass a `stream` through to selector composables
+ * without reading `values` directly. Mirrors the React
+ * `AnyStream` alias.
+ */
+type AnyStream = UseStreamReturn<any, any, any>;
+/** Convenience alias for the fully-resolved stream handle type. */
+type UseStreamResult<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>> = UseStreamReturn<T, InterruptType, ConfigurableType>;
+/**
+ * Vue Composition API binding for the v2-native stream runtime.
+ *
+ * Returns a handle whose projections are Vue refs so templates
+ * auto-unwrap and scripts can feed them into `computed`/`watch`.
+ * Scoped views (subagents, subgraphs, any namespaced projection) are
+ * surfaced via the companion selector composables (`useMessages`,
+ * `useToolCalls`, `useValues`, `useMessageMetadata`,
+ * `useSubmissionQueue`, `useExtension`, `useChannel`, plus media
+ * composables).
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useStream } from "@langchain/vue";
+ *
+ * const stream = useStream({
+ *   assistantId: "agent",
+ *   apiUrl: "http://localhost:2024",
+ * });
+ * </script>
+ *
+ * <template>
+ *   <div v-for="msg in stream.messages.value" :key="msg.id">
+ *     {{ msg.content }}
+ *   </div>
+ *   <button @click="stream.submit({ messages: [{ type: 'human', content: 'Hi' }] })">
+ *     Send
+ *   </button>
+ * </template>
+ * ```
+ *
+ * `assistantId`, `client`, and `transport` are captured at setup time.
+ * To bind a new assistant/transport, remount the component. Reactive
+ * inputs (`threadId`, `apiUrl`, `apiKey`) trigger in-place behaviour
+ * changes on the active controller.
+ */
+declare function useStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: UseStreamOptions$1<InferStateType<T>>): UseStreamReturn<T, InterruptType, ConfigurableType>;
+//#endregion
+export { AgentServerOptions$1 as AgentServerOptions, AnyStream, CustomAdapterOptions$1 as CustomAdapterOptions, STREAM_CONTROLLER, StateOf$1 as StateOf, type ThreadStream, UseStreamOptions$1 as UseStreamOptions, UseStreamResult, UseStreamReturn, useStream };
+//# sourceMappingURL=use-stream.d.ts.map

package/dist/use-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stream.d.ts","names":[],"sources":["../src/use-stream.ts"],"mappings":";;;;;;;;KAgDY,SAAA,MAAa,OAAA,CAAc,CAAA;AAAA,KAElC,WAAA,GAAc,gBAAA;AAAA,KACd,YAAA,GAAe,gBAAA;AAAA,KAER,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,WAAA,EAAa,YAAA,EAAc,YAAA;AAAA,KAErD,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,WAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,WAAA,EACA,YAAA,EACA,YAAA;;;;;AAjBwC;;cA2B7B,iBAAA;;;AAzBsB;;;;;AAGnC;;;;;;;UAwCiB,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EAAA,SAE5B,MAAA,EAAQ,QAAA,CAAS,UAAA,CAAW,SAAA;EAAA,SAC5B,QAAA,EAAU,QAAA,CAAS,UAAA,CAAW,WAAA;EAAA,SAC9B,SAAA,EAAW,QAAA,CAAS,UAAA,CAAW,iBAAA;EAAA,SAC/B,UAAA,EAAY,QAAA,CAAS,UAAA,CAAW,SAAA,CAAU,aAAA;EAAA,SAC1C,SAAA,EAAW,WAAA,CAAY,SAAA,CAAU,aAAA;EAAA,SACjC,SAAA,EAAW,WAAA;EAAA,SACX,eAAA,EAAiB,WAAA;EAAA,SACjB,KAAA,EAAO,WAAA;EAAA,SACP,QAAA,EAAU,WAAA;EAtDwD;AAE7E;;;;;EAF6E,SA8DlE,gBAAA,EAAkB,WAAA,CAAY,OAAA;EAAA,SAE9B,SAAA,EAAW,QAAA,CAClB,UAAA,CACE,WAAA,OACQ,cAAA,yCAEI,cAAA,WACV,yBAAA;EAAA,SAIG,SAAA,EAAW,QAAA,CAClB,UAAA,CAAW,WAAA,SAAoB,yBAAA;EAAA,SAExB,eAAA,EAAiB,QAAA,CACxB,UAAA,CAAW,WAAA,kBAA6B,yBAAA;EAG1C,MAAA,CACE,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,SAAA,uBACnC,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EACH,IAAA,IAAQ,OAAA;EACR,OAAA,CACE,QAAA,WACA,MAAA;IAAW,WAAA;IAAqB,SAAA;EAAA,IAC/B,OAAA;EAAA,SAEM,MAAA,EAAQ,MAAA;EAAA,SACR,WAAA;EAtFkB;EAyF3B,SAAA,IAAa,YAAA;EAtFb;EAAA,UAyFU,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;;;;KAWQ,SAAA,GAAY,eAAA;;KAGZ,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;AAlGtC;;;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuHgB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/use-stream.js

@@ -0,0 +1,167 @@
+import { LANGCHAIN_OPTIONS } from "./context.js";
+import { computed, inject, onScopeDispose, readonly, shallowRef, toValue, watch } from "vue";
+import { filterOutHeadlessToolInterrupts, flushPendingHeadlessToolInterrupts } from "@langchain/langgraph-sdk";
+import { Client as Client$1 } from "@langchain/langgraph-sdk/client";
+import { StreamController } from "@langchain/langgraph-sdk/stream";
+//#region src/use-stream.ts
+/**
+* Private field on the handle that carries the {@link StreamController}
+* reference. Selector composables read this to reach the shared
+* {@link ChannelRegistry}. Use the selector composables (`useMessages`,
+* `useToolCalls`, `useValues`, …) instead of reading this directly.
+*/
+const STREAM_CONTROLLER = Symbol.for("@langchain/vue/controller");
+/**
+* Vue Composition API binding for the v2-native stream runtime.
+*
+* Returns a handle whose projections are Vue refs so templates
+* auto-unwrap and scripts can feed them into `computed`/`watch`.
+* Scoped views (subagents, subgraphs, any namespaced projection) are
+* surfaced via the companion selector composables (`useMessages`,
+* `useToolCalls`, `useValues`, `useMessageMetadata`,
+* `useSubmissionQueue`, `useExtension`, `useChannel`, plus media
+* composables).
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+* import { useStream } from "@langchain/vue";
+*
+* const stream = useStream({
+*   assistantId: "agent",
+*   apiUrl: "http://localhost:2024",
+* });
+* <\/script>
+*
+* <template>
+*   <div v-for="msg in stream.messages.value" :key="msg.id">
+*     {{ msg.content }}
+*   </div>
+*   <button @click="stream.submit({ messages: [{ type: 'human', content: 'Hi' }] })">
+*     Send
+*   </button>
+* </template>
+* ```
+*
+* `assistantId`, `client`, and `transport` are captured at setup time.
+* To bind a new assistant/transport, remount the component. Reactive
+* inputs (`threadId`, `apiUrl`, `apiKey`) trigger in-place behaviour
+* changes on the active controller.
+*/
+function useStream(options) {
+	const asBag = options;
+	const pluginOptions = inject(LANGCHAIN_OPTIONS, void 0) ?? {};
+	const hasCustomAdapter = asBag.transport != null && typeof asBag.transport !== "string";
+	const transport = asBag.transport;
+	const resolveApiUrl = () => toValue(asBag.apiUrl) ?? pluginOptions.apiUrl;
+	const resolveApiKey = () => toValue(asBag.apiKey) ?? pluginOptions.apiKey;
+	const client = shallowRef(asBag.client ?? pluginOptions.client ?? new Client$1({
+		apiUrl: resolveApiUrl(),
+		apiKey: resolveApiKey(),
+		callerOptions: asBag.callerOptions,
+		defaultHeaders: asBag.defaultHeaders
+	})).value;
+	const sentinel = "_";
+	const assistantId = "assistantId" in options ? options.assistantId ?? sentinel : sentinel;
+	const controller = new StreamController({
+		assistantId,
+		client,
+		threadId: toValue(asBag.threadId) ?? null,
+		transport,
+		fetch: hasCustomAdapter ? void 0 : asBag.fetch,
+		webSocketFactory: hasCustomAdapter ? void 0 : asBag.webSocketFactory,
+		onThreadId: options.onThreadId,
+		onCreated: options.onCreated,
+		initialValues: options.initialValues,
+		messagesKey: options.messagesKey
+	});
+	onScopeDispose(controller.activate());
+	function bindStore(subscribe, getSnapshot) {
+		const ref = shallowRef(getSnapshot());
+		onScopeDispose(subscribe(() => {
+			ref.value = getSnapshot();
+		}));
+		return readonly(ref);
+	}
+	const rootRef = bindStore(controller.rootStore.subscribe, controller.rootStore.getSnapshot);
+	const subagentRef = bindStore(controller.subagentStore.subscribe, controller.subagentStore.getSnapshot);
+	const subgraphRef = bindStore(controller.subgraphStore.subscribe, controller.subgraphStore.getSnapshot);
+	const subgraphByNodeRef = bindStore(controller.subgraphByNodeStore.subscribe, controller.subgraphByNodeStore.getSnapshot);
+	const values = computed(() => rootRef.value.values);
+	const messages = computed(() => rootRef.value.messages);
+	const toolCalls = computed(() => rootRef.value.toolCalls);
+	const interrupts = computed(() => filterOutHeadlessToolInterrupts(rootRef.value.interrupts));
+	const interrupt = computed(() => interrupts.value[0]);
+	const isLoading = computed(() => rootRef.value.isLoading);
+	const isThreadLoading = computed(() => rootRef.value.isThreadLoading);
+	const error = computed(() => rootRef.value.error);
+	const threadId = computed(() => rootRef.value.threadId);
+	const hydrationPromise = computed(() => controller.hydrationPromise);
+	const asShallow = (c) => c;
+	let skipFirstThreadIdWatch = true;
+	watch(() => toValue(asBag.threadId) ?? null, (next) => {
+		if (skipFirstThreadIdWatch) {
+			skipFirstThreadIdWatch = false;
+			return;
+		}
+		controller.hydrate(next);
+	});
+	const handledTools = /* @__PURE__ */ new Set();
+	watch(() => toValue(asBag.threadId) ?? null, () => handledTools.clear());
+	const tools = options.tools;
+	const onTool = options.onTool;
+	if (tools?.length) watch(() => [rootRef.value.values, rootRef.value.interrupts], ([rootValues, rootInterrupts]) => {
+		const bag = rootValues;
+		const combined = [...Array.isArray(bag?.__interrupt__) ? bag.__interrupt__ : [], ...rootInterrupts];
+		if (combined.length === 0) return;
+		flushPendingHeadlessToolInterrupts({
+			...bag,
+			__interrupt__: combined
+		}, tools, handledTools, {
+			onTool,
+			defer: (run) => {
+				Promise.resolve().then(run);
+			},
+			resumeSubmit: (command) => controller.submit(null, { command })
+		});
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	return {
+		values: asShallow(values),
+		messages: asShallow(messages),
+		toolCalls: asShallow(toolCalls),
+		interrupts: asShallow(interrupts),
+		interrupt,
+		isLoading,
+		isThreadLoading,
+		error,
+		threadId,
+		hydrationPromise,
+		subagents: subagentRef,
+		subgraphs: subgraphRef,
+		subgraphsByNode: subgraphByNodeRef,
+		submit: (input, submitOptions) => controller.submit(input, submitOptions),
+		stop: () => controller.stop(),
+		respond: (response, target) => controller.respond(response, target),
+		getThread: () => controller.getThread(),
+		client,
+		assistantId,
+		[STREAM_CONTROLLER]: controller
+	};
+}
+/**
+* Helper used by the selector composables to reach the underlying
+* {@link ChannelRegistry} from a stream handle. Kept internal —
+* application code should call `useMessages`, `useToolCalls`, etc.
+*
+* @internal
+*/
+function getRegistry(stream) {
+	return stream[STREAM_CONTROLLER].registry;
+}
+//#endregion
+export { STREAM_CONTROLLER, getRegistry, useStream };
+
+//# sourceMappingURL=use-stream.js.map

package/dist/use-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stream.js","names":["ClientCtor"],"sources":["../src/use-stream.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  watch,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\n  filterOutHeadlessToolInterrupts,\n  flushPendingHeadlessToolInterrupts,\n  type AnyHeadlessToolImplementation,\n  type OnToolCallback,\n} from \"@langchain/langgraph-sdk\";\nimport {\n  Client as ClientCtor,\n  type ClientConfig,\n  type ThreadStream,\n} from \"@langchain/langgraph-sdk/client\";\nimport {\n  StreamController,\n  type AgentServerAdapter,\n  type AgentServerOptions as StreamAgentServerOptions,\n  type AssembledToolCall,\n  type ChannelRegistry,\n  type CustomAdapterOptions as StreamCustomAdapterOptions,\n  type InferStateType,\n  type InferSubagentStates,\n  type RootSnapshot,\n  type StateOf as StreamStateOf,\n  type StreamSubmitOptions,\n  type SubagentDiscoverySnapshot,\n  type SubagentMap,\n  type SubgraphByNodeMap,\n  type SubgraphDiscoverySnapshot,\n  type SubgraphMap,\n  type UseStreamOptions as StreamUseStreamOptions,\n  type WidenUpdateMessages,\n} from \"@langchain/langgraph-sdk/stream\";\nimport { inject } from \"vue\";\nimport { LANGCHAIN_OPTIONS } from \"./context.js\";\n\n/** @deprecated Prefer {@link InferStateType}. */\nexport type StateOf<T> = StreamStateOf<T>;\n\ntype VueThreadId = MaybeRefOrGetter<string | null | undefined>;\ntype VueApiString = MaybeRefOrGetter<string | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, VueThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  VueThreadId,\n  VueApiString,\n  VueApiString,\n  string\n>;\n\n/**\n * Private field on the handle that carries the {@link StreamController}\n * reference. Selector composables read this to reach the shared\n * {@link ChannelRegistry}. Use the selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, …) instead of reading this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/vue/controller\"\n);\n\n/**\n * Vue binding return type for {@link useStream}.\n *\n * Reactive primitives follow Vue conventions:\n *\n *  - Data projections are `Readonly<ShallowRef<T>>` / `ComputedRef<T>`\n *    so templates auto-unwrap via `msg.value` in `<script setup>`\n *    and directly in templates. They are snapshots — never mutate.\n *  - Imperative methods (`submit` / `stop` / `respond`) are plain\n *    functions — no refs involved.\n *  - Identity values captured at setup time (`client` / `assistantId`)\n *    are exposed as plain values; if you need to swap the bound agent\n *    or client, remount the composable.\n */\nexport interface UseStreamReturn<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n  StateType extends object = InferStateType<T>,\n  SubagentStates = InferSubagentStates<T>,\n> {\n  readonly values: Readonly<ShallowRef<StateType>>;\n  readonly messages: Readonly<ShallowRef<BaseMessage[]>>;\n  readonly toolCalls: Readonly<ShallowRef<AssembledToolCall[]>>;\n  readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;\n  readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;\n  readonly isLoading: ComputedRef<boolean>;\n  readonly isThreadLoading: ComputedRef<boolean>;\n  readonly error: ComputedRef<unknown>;\n  readonly threadId: ComputedRef<string | null>;\n\n  /**\n   * Promise that settles when the active thread's initial hydration\n   * completes. Exposed so `async setup()` sites can\n   * `await stream.hydrationPromise` to implement a Suspense-like\n   * boundary.\n   */\n  readonly hydrationPromise: ComputedRef<Promise<void>>;\n\n  readonly subagents: Readonly<\n    ShallowRef<\n      ReadonlyMap<\n        keyof SubagentStates & string extends never\n          ? string\n          : keyof SubagentStates & string,\n        SubagentDiscoverySnapshot\n      >\n    >\n  >;\n  readonly subgraphs: Readonly<\n    ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>\n  >;\n  readonly subgraphsByNode: Readonly<\n    ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>\n  >;\n\n  submit(\n    input: WidenUpdateMessages<Partial<StateType>> | null | undefined,\n    options?: StreamSubmitOptions<StateType, ConfigurableType>\n  ): Promise<void>;\n  stop(): Promise<void>;\n  respond(\n    response: unknown,\n    target?: { interruptId: string; namespace?: string[] }\n  ): Promise<void>;\n\n  readonly client: Client;\n  readonly assistantId: string;\n\n  /** v2 escape hatch — returns the bound {@link ThreadStream}. */\n  getThread(): ThreadStream | undefined;\n\n  /** @internal Used by selector composables. */\n  readonly [STREAM_CONTROLLER]: StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >;\n}\n\n/**\n * Erased handle useful as a parameter type for helpers and wrapper\n * components that pass a `stream` through to selector composables\n * without reading `values` directly. Mirrors the React\n * `AnyStream` alias.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyStream = UseStreamReturn<any, any, any>;\n\n/** Convenience alias for the fully-resolved stream handle type. */\nexport type UseStreamResult<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n> = UseStreamReturn<T, InterruptType, ConfigurableType>;\n\n/**\n * Vue Composition API binding for the v2-native stream runtime.\n *\n * Returns a handle whose projections are Vue refs so templates\n * auto-unwrap and scripts can feed them into `computed`/`watch`.\n * Scoped views (subagents, subgraphs, any namespaced projection) are\n * surfaced via the companion selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, `useMessageMetadata`,\n * `useSubmissionQueue`, `useExtension`, `useChannel`, plus media\n * composables).\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   apiUrl: \"http://localhost:2024\",\n * });\n * </script>\n *\n * <template>\n *   <div v-for=\"msg in stream.messages.value\" :key=\"msg.id\">\n *     {{ msg.content }}\n *   </div>\n *   <button @click=\"stream.submit({ messages: [{ type: 'human', content: 'Hi' }] })\">\n *     Send\n *   </button>\n * </template>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at setup time.\n * To bind a new assistant/transport, remount the component. Reactive\n * inputs (`threadId`, `apiUrl`, `apiKey`) trigger in-place behaviour\n * changes on the active controller.\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: UseStreamOptions<InferStateType<T>>\n): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  type StateType = InferStateType<T>;\n\n  interface OptionsBag {\n    assistantId?: string;\n    threadId?: MaybeRefOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: MaybeRefOrGetter<string | undefined>;\n    apiKey?: MaybeRefOrGetter<string | undefined>;\n    callerOptions?: ClientConfig[\"callerOptions\"];\n    defaultHeaders?: ClientConfig[\"defaultHeaders\"];\n    transport?: \"sse\" | \"websocket\" | AgentServerAdapter;\n    fetch?: typeof fetch;\n    webSocketFactory?: (url: string) => WebSocket;\n    onThreadId?: (threadId: string) => void;\n    onCreated?: (meta: { run_id: string; thread_id: string }) => void;\n    initialValues?: StateType;\n    messagesKey?: string;\n    tools?: AnyHeadlessToolImplementation[];\n    onTool?: OnToolCallback;\n  }\n  const asBag = options as OptionsBag;\n\n  // Inherit missing apiUrl / apiKey / client from any LangChainPlugin\n  // installed on the app. Vue's `inject` returns `undefined` if the\n  // key was never provided; that's fine — we only merge when the\n  // caller didn't set a value.\n  const pluginOptions =\n    inject(LANGCHAIN_OPTIONS, undefined) ?? ({} as Record<string, unknown>);\n\n  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // ─── Client construction ────────────────────────────────────────────\n  //\n  // Identity-stable per setup. Watches apiUrl/apiKey refs so callers\n  // that flip a backend at runtime get a fresh client without a full\n  // remount — the controller is swapped in lock-step below.\n  const resolveApiUrl = () =>\n    toValue(asBag.apiUrl) ?? (pluginOptions as { apiUrl?: string }).apiUrl;\n  const resolveApiKey = () =>\n    toValue(asBag.apiKey) ?? (pluginOptions as { apiKey?: string }).apiKey;\n  const explicitClient =\n    asBag.client ?? (pluginOptions as { client?: Client }).client;\n\n  const clientRef = shallowRef<Client>(\n    explicitClient ??\n      (new ClientCtor({\n        apiUrl: resolveApiUrl(),\n        apiKey: resolveApiKey(),\n        callerOptions: asBag.callerOptions,\n        defaultHeaders: asBag.defaultHeaders,\n      }) as unknown as Client)\n  );\n\n  // Note: we intentionally bind the controller to the *initial* client\n  // instance. A dynamic client swap would require tearing the\n  // controller down (in-flight subscriptions, queue, hydration), so we\n  // keep the rule simple: client is captured at setup. Mirrors React\n  // v1 which bakes `useMemo` on `[client, assistantId, transport]`.\n  const client = clientRef.value;\n\n  // Custom adapters may omit `assistantId`; the controller still\n  // requires one so it has something to forward to `threads.stream`.\n  const sentinel = \"_\";\n  const assistantId =\n    \"assistantId\" in options ? (options.assistantId ?? sentinel) : sentinel;\n\n  const initialThreadId = toValue(asBag.threadId) ?? null;\n\n  // ─── Controller construction ────────────────────────────────────────\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    client: client as unknown as Client<StateType>,\n    threadId: initialThreadId,\n    transport,\n    fetch: hasCustomAdapter ? undefined : asBag.fetch,\n    webSocketFactory: hasCustomAdapter ? undefined : asBag.webSocketFactory,\n    onThreadId: options.onThreadId,\n    onCreated: options.onCreated,\n    initialValues: options.initialValues,\n    messagesKey: options.messagesKey,\n  });\n\n  // Deferred dispose: on the next microtask after the owning scope\n  // disappears. Mirrors React's StrictMode-safe activate/deactivate\n  // pattern — HMR and other scope-reuse scenarios stay clean because\n  // `activate()` cancels the pending dispose if the scope survives.\n  const deactivate = controller.activate();\n  onScopeDispose(deactivate);\n\n  // ─── Reactivity adapters — StreamStore → shallowRef ─────────────────\n  function bindStore<S>(\n    subscribe: (listener: () => void) => () => void,\n    getSnapshot: () => S\n  ): Readonly<ShallowRef<S>> {\n    const ref = shallowRef<S>(getSnapshot());\n    const unsubscribe = subscribe(() => {\n      ref.value = getSnapshot();\n    });\n    onScopeDispose(unsubscribe);\n    return readonly(ref) as Readonly<ShallowRef<S>>;\n  }\n\n  const rootRef = bindStore<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.subscribe,\n    controller.rootStore.getSnapshot\n  );\n  const subagentRef = bindStore<SubagentMap>(\n    controller.subagentStore.subscribe,\n    controller.subagentStore.getSnapshot\n  );\n  const subgraphRef = bindStore<SubgraphMap>(\n    controller.subgraphStore.subscribe,\n    controller.subgraphStore.getSnapshot\n  );\n  const subgraphByNodeRef = bindStore<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.subscribe,\n    controller.subgraphByNodeStore.getSnapshot\n  );\n\n  // Derived refs for individual root-snapshot fields. Using computed\n  // means templates that read `values.value` only retrigger when the\n  // root snapshot's identity actually changes — we can't split further\n  // because `StreamStore` fans the whole snapshot out on every update.\n  const values = computed(() => rootRef.value.values);\n  const messages = computed(() => rootRef.value.messages);\n  const toolCalls = computed(() => rootRef.value.toolCalls);\n  const interrupts = computed(() =>\n    filterOutHeadlessToolInterrupts(rootRef.value.interrupts)\n  );\n  const interrupt = computed(() => interrupts.value[0]);\n  const isLoading = computed(() => rootRef.value.isLoading);\n  const isThreadLoading = computed(() => rootRef.value.isThreadLoading);\n  const error = computed(() => rootRef.value.error);\n  const threadId = computed(() => rootRef.value.threadId);\n  const hydrationPromise = computed(() => controller.hydrationPromise);\n\n  // Expose the derived refs through a `readonly(shallowRef)` shape to\n  // match the rest of the public surface. `computed` already gives us\n  // read-only semantics but templates type-check more cleanly when the\n  // fully-typed return claims `Readonly<ShallowRef<T>>` everywhere.\n  // The cast is safe — a ComputedRef<T> is structurally a\n  // Readonly<Ref<T>>.\n  const asShallow = <V>(c: ComputedRef<V>): Readonly<ShallowRef<V>> =>\n    c as unknown as Readonly<ShallowRef<V>>;\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Re-hydrate whenever the caller's threadId input changes post-setup.\n  // The initial hydrate already fired synchronously in the controller\n  // constructor, so we skip that first tick; otherwise we'd double-fetch\n  // `thread.state.get()`.\n  let skipFirstThreadIdWatch = true;\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    (next) => {\n      if (skipFirstThreadIdWatch) {\n        skipFirstThreadIdWatch = false;\n        return;\n      }\n      void controller.hydrate(next);\n    }\n  );\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch root values + protocol interrupts for items targeting a\n  // registered tool, invoke the handler, and resume the run with the\n  // handler's return value. Dedup via an id set so StrictMode /\n  // rerenders don't replay a tool call twice.\n  const handledTools = new Set<string>();\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    () => handledTools.clear()\n  );\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    watch(\n      () => [rootRef.value.values, rootRef.value.interrupts] as const,\n      ([rootValues, rootInterrupts]) => {\n        const bag = rootValues as unknown as Record<string, unknown>;\n        const existing = Array.isArray(bag?.__interrupt__)\n          ? (bag.__interrupt__ as Interrupt[])\n          : [];\n        const combined: Interrupt[] = [\n          ...existing,\n          ...(rootInterrupts as unknown as Interrupt[]),\n        ];\n        if (combined.length === 0) return;\n        flushPendingHeadlessToolInterrupts(\n          { ...bag, __interrupt__: combined },\n          tools,\n          handledTools,\n          {\n            onTool,\n            defer: (run) => {\n              void Promise.resolve().then(run);\n            },\n            resumeSubmit: (command) =>\n              controller.submit(null, {\n                command,\n              } as StreamSubmitOptions<StateType, ConfigurableType>),\n          }\n        );\n      },\n      { immediate: true, flush: \"sync\" }\n    );\n  }\n\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    values: asShallow(values) as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"values\"],\n    messages: asShallow(messages),\n    toolCalls: asShallow(toolCalls),\n    interrupts: asShallow(interrupts),\n    interrupt,\n    isLoading,\n    isThreadLoading,\n    error,\n    threadId,\n    hydrationPromise,\n    subagents: subagentRef as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"subagents\"],\n    subgraphs: subgraphRef,\n    subgraphsByNode: subgraphByNodeRef,\n    submit: (input, submitOptions) => controller.submit(input, submitOptions),\n    stop: () => controller.stop(),\n    respond: (response, target) => controller.respond(response, target),\n    getThread: () => controller.getThread(),\n    client,\n    assistantId,\n    [STREAM_CONTROLLER]: controller,\n  };\n\n  return handle;\n}\n\n/**\n * Helper used by the selector composables to reach the underlying\n * {@link ChannelRegistry} from a stream handle. Kept internal —\n * application code should call `useMessages`, `useToolCalls`, etc.\n *\n * @internal\n */\nexport function getRegistry(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  stream: UseStreamReturn<any, any, any>\n): ChannelRegistry {\n  return stream[STREAM_CONTROLLER].registry;\n}\n\nexport type { ThreadStream };\n"],"mappings":"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"}