@langchain/vue 0.4.7 → 1.0.0

package/dist/use-media-url.cjs

@@ -0,0 +1,51 @@
+let vue = require("vue");
+//#region src/use-media-url.ts
+/**
+* Resolve the lazy {@link MediaBase.objectURL} promise into a
+* reactive string suitable for `<audio src>`, `<img src>`,
+* `<video src>`, or `<a download href>`. Returns `undefined` until
+* the URL is available.
+*
+* Lifecycle:
+*  - On setup (or whenever the supplied `media` value changes), the
+*    composable awaits `media.objectURL` and commits the resolved
+*    string to state.
+*  - On scope disposal (or when `media` changes), the composable
+*    calls `media.revoke()` to free the blob URL slot. The next
+*    consumer that accesses `media.objectURL` mints a fresh URL from
+*    the same `Blob`, so live re-renders just work.
+*  - If the underlying handle errored before settling, the URL stays
+*    `undefined`. Surface the failure via `media.error`.
+*
+* `media` accepts a raw handle, a `Ref<MediaBase | undefined>`, or a
+* getter, so the composable can rebind automatically to the latest
+* media without a manual watcher at the call site.
+*/
+function useMediaURL(media) {
+	const url = (0, vue.ref)();
+	let currentMedia;
+	let cancelled = false;
+	const detach = () => {
+		cancelled = true;
+		if (currentMedia != null) try {
+			currentMedia.revoke();
+		} catch {}
+		currentMedia = void 0;
+		url.value = void 0;
+	};
+	(0, vue.watch)(() => (0, vue.toValue)(media), (next) => {
+		detach();
+		if (next == null) return;
+		cancelled = false;
+		currentMedia = next;
+		next.objectURL.then((resolved) => {
+			if (!cancelled) url.value = resolved;
+		}, () => {});
+	}, { immediate: true });
+	(0, vue.onScopeDispose)(detach);
+	return url;
+}
+//#endregion
+exports.useMediaURL = useMediaURL;
+
+//# sourceMappingURL=use-media-url.cjs.map

package/dist/use-media-url.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-url.cjs","names":[],"sources":["../src/use-media-url.ts"],"sourcesContent":["import {\n  ref,\n  watch,\n  onScopeDispose,\n  toValue,\n  type MaybeRefOrGetter,\n  type Ref,\n} from \"vue\";\nimport type { MediaBase } from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Resolve the lazy {@link MediaBase.objectURL} promise into a\n * reactive string suitable for `<audio src>`, `<img src>`,\n * `<video src>`, or `<a download href>`. Returns `undefined` until\n * the URL is available.\n *\n * Lifecycle:\n *  - On setup (or whenever the supplied `media` value changes), the\n *    composable awaits `media.objectURL` and commits the resolved\n *    string to state.\n *  - On scope disposal (or when `media` changes), the composable\n *    calls `media.revoke()` to free the blob URL slot. The next\n *    consumer that accesses `media.objectURL` mints a fresh URL from\n *    the same `Blob`, so live re-renders just work.\n *  - If the underlying handle errored before settling, the URL stays\n *    `undefined`. Surface the failure via `media.error`.\n *\n * `media` accepts a raw handle, a `Ref<MediaBase | undefined>`, or a\n * getter, so the composable can rebind automatically to the latest\n * media without a manual watcher at the call site.\n */\nexport function useMediaURL(\n  media: MaybeRefOrGetter<MediaBase | undefined>\n): Readonly<Ref<string | undefined>> {\n  const url = ref<string | undefined>();\n\n  let currentMedia: MediaBase | undefined;\n  let cancelled = false;\n\n  const detach = () => {\n    cancelled = true;\n    if (currentMedia != null) {\n      try {\n        currentMedia.revoke();\n      } catch {\n        // best-effort\n      }\n    }\n    currentMedia = undefined;\n    url.value = undefined;\n  };\n\n  watch(\n    () => toValue(media),\n    (next) => {\n      detach();\n      if (next == null) return;\n      cancelled = false;\n      currentMedia = next;\n      next.objectURL.then(\n        (resolved) => {\n          if (!cancelled) url.value = resolved;\n        },\n        () => {\n          // Errors surfaced via `media.error`; keep `url` undefined\n          // so consumers fall through to a no-src render.\n        }\n      );\n    },\n    { immediate: true }\n  );\n\n  onScopeDispose(detach);\n\n  return url;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,YACd,OACmC;CACnC,MAAM,OAAA,GAAA,IAAA,MAA+B;CAErC,IAAI;CACJ,IAAI,YAAY;CAEhB,MAAM,eAAe;AACnB,cAAY;AACZ,MAAI,gBAAgB,KAClB,KAAI;AACF,gBAAa,QAAQ;UACf;AAIV,iBAAe,KAAA;AACf,MAAI,QAAQ,KAAA;;AAGd,EAAA,GAAA,IAAA,cAAA,GAAA,IAAA,SACgB,MAAM,GACnB,SAAS;AACR,UAAQ;AACR,MAAI,QAAQ,KAAM;AAClB,cAAY;AACZ,iBAAe;AACf,OAAK,UAAU,MACZ,aAAa;AACZ,OAAI,CAAC,UAAW,KAAI,QAAQ;WAExB,GAIP;IAEH,EAAE,WAAW,MAAM,CACpB;AAED,EAAA,GAAA,IAAA,gBAAe,OAAO;AAEtB,QAAO"}

package/dist/use-media-url.d.cts

@@ -0,0 +1,29 @@
+import { MaybeRefOrGetter, Ref } from "vue";
+import { MediaBase } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-media-url.d.ts
+/**
+ * Resolve the lazy {@link MediaBase.objectURL} promise into a
+ * reactive string suitable for `<audio src>`, `<img src>`,
+ * `<video src>`, or `<a download href>`. Returns `undefined` until
+ * the URL is available.
+ *
+ * Lifecycle:
+ *  - On setup (or whenever the supplied `media` value changes), the
+ *    composable awaits `media.objectURL` and commits the resolved
+ *    string to state.
+ *  - On scope disposal (or when `media` changes), the composable
+ *    calls `media.revoke()` to free the blob URL slot. The next
+ *    consumer that accesses `media.objectURL` mints a fresh URL from
+ *    the same `Blob`, so live re-renders just work.
+ *  - If the underlying handle errored before settling, the URL stays
+ *    `undefined`. Surface the failure via `media.error`.
+ *
+ * `media` accepts a raw handle, a `Ref<MediaBase | undefined>`, or a
+ * getter, so the composable can rebind automatically to the latest
+ * media without a manual watcher at the call site.
+ */
+declare function useMediaURL(media: MaybeRefOrGetter<MediaBase | undefined>): Readonly<Ref<string | undefined>>;
+//#endregion
+export { useMediaURL };
+//# sourceMappingURL=use-media-url.d.cts.map

package/dist/use-media-url.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-url.d.cts","names":[],"sources":["../src/use-media-url.ts"],"mappings":";;;;;;AA+BA;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,KAAA,EAAO,gBAAA,CAAiB,SAAA,gBACvB,QAAA,CAAS,GAAA"}

package/dist/use-media-url.d.ts

@@ -0,0 +1,29 @@
+import { MaybeRefOrGetter, Ref } from "vue";
+import { MediaBase } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-media-url.d.ts
+/**
+ * Resolve the lazy {@link MediaBase.objectURL} promise into a
+ * reactive string suitable for `<audio src>`, `<img src>`,
+ * `<video src>`, or `<a download href>`. Returns `undefined` until
+ * the URL is available.
+ *
+ * Lifecycle:
+ *  - On setup (or whenever the supplied `media` value changes), the
+ *    composable awaits `media.objectURL` and commits the resolved
+ *    string to state.
+ *  - On scope disposal (or when `media` changes), the composable
+ *    calls `media.revoke()` to free the blob URL slot. The next
+ *    consumer that accesses `media.objectURL` mints a fresh URL from
+ *    the same `Blob`, so live re-renders just work.
+ *  - If the underlying handle errored before settling, the URL stays
+ *    `undefined`. Surface the failure via `media.error`.
+ *
+ * `media` accepts a raw handle, a `Ref<MediaBase | undefined>`, or a
+ * getter, so the composable can rebind automatically to the latest
+ * media without a manual watcher at the call site.
+ */
+declare function useMediaURL(media: MaybeRefOrGetter<MediaBase | undefined>): Readonly<Ref<string | undefined>>;
+//#endregion
+export { useMediaURL };
+//# sourceMappingURL=use-media-url.d.ts.map

package/dist/use-media-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-url.d.ts","names":[],"sources":["../src/use-media-url.ts"],"mappings":";;;;;;AA+BA;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,KAAA,EAAO,gBAAA,CAAiB,SAAA,gBACvB,QAAA,CAAS,GAAA"}

package/dist/use-media-url.js

@@ -0,0 +1,51 @@
+import { onScopeDispose, ref, toValue, watch } from "vue";
+//#region src/use-media-url.ts
+/**
+* Resolve the lazy {@link MediaBase.objectURL} promise into a
+* reactive string suitable for `<audio src>`, `<img src>`,
+* `<video src>`, or `<a download href>`. Returns `undefined` until
+* the URL is available.
+*
+* Lifecycle:
+*  - On setup (or whenever the supplied `media` value changes), the
+*    composable awaits `media.objectURL` and commits the resolved
+*    string to state.
+*  - On scope disposal (or when `media` changes), the composable
+*    calls `media.revoke()` to free the blob URL slot. The next
+*    consumer that accesses `media.objectURL` mints a fresh URL from
+*    the same `Blob`, so live re-renders just work.
+*  - If the underlying handle errored before settling, the URL stays
+*    `undefined`. Surface the failure via `media.error`.
+*
+* `media` accepts a raw handle, a `Ref<MediaBase | undefined>`, or a
+* getter, so the composable can rebind automatically to the latest
+* media without a manual watcher at the call site.
+*/
+function useMediaURL(media) {
+	const url = ref();
+	let currentMedia;
+	let cancelled = false;
+	const detach = () => {
+		cancelled = true;
+		if (currentMedia != null) try {
+			currentMedia.revoke();
+		} catch {}
+		currentMedia = void 0;
+		url.value = void 0;
+	};
+	watch(() => toValue(media), (next) => {
+		detach();
+		if (next == null) return;
+		cancelled = false;
+		currentMedia = next;
+		next.objectURL.then((resolved) => {
+			if (!cancelled) url.value = resolved;
+		}, () => {});
+	}, { immediate: true });
+	onScopeDispose(detach);
+	return url;
+}
+//#endregion
+export { useMediaURL };
+
+//# sourceMappingURL=use-media-url.js.map

package/dist/use-media-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-url.js","names":[],"sources":["../src/use-media-url.ts"],"sourcesContent":["import {\n  ref,\n  watch,\n  onScopeDispose,\n  toValue,\n  type MaybeRefOrGetter,\n  type Ref,\n} from \"vue\";\nimport type { MediaBase } from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Resolve the lazy {@link MediaBase.objectURL} promise into a\n * reactive string suitable for `<audio src>`, `<img src>`,\n * `<video src>`, or `<a download href>`. Returns `undefined` until\n * the URL is available.\n *\n * Lifecycle:\n *  - On setup (or whenever the supplied `media` value changes), the\n *    composable awaits `media.objectURL` and commits the resolved\n *    string to state.\n *  - On scope disposal (or when `media` changes), the composable\n *    calls `media.revoke()` to free the blob URL slot. The next\n *    consumer that accesses `media.objectURL` mints a fresh URL from\n *    the same `Blob`, so live re-renders just work.\n *  - If the underlying handle errored before settling, the URL stays\n *    `undefined`. Surface the failure via `media.error`.\n *\n * `media` accepts a raw handle, a `Ref<MediaBase | undefined>`, or a\n * getter, so the composable can rebind automatically to the latest\n * media without a manual watcher at the call site.\n */\nexport function useMediaURL(\n  media: MaybeRefOrGetter<MediaBase | undefined>\n): Readonly<Ref<string | undefined>> {\n  const url = ref<string | undefined>();\n\n  let currentMedia: MediaBase | undefined;\n  let cancelled = false;\n\n  const detach = () => {\n    cancelled = true;\n    if (currentMedia != null) {\n      try {\n        currentMedia.revoke();\n      } catch {\n        // best-effort\n      }\n    }\n    currentMedia = undefined;\n    url.value = undefined;\n  };\n\n  watch(\n    () => toValue(media),\n    (next) => {\n      detach();\n      if (next == null) return;\n      cancelled = false;\n      currentMedia = next;\n      next.objectURL.then(\n        (resolved) => {\n          if (!cancelled) url.value = resolved;\n        },\n        () => {\n          // Errors surfaced via `media.error`; keep `url` undefined\n          // so consumers fall through to a no-src render.\n        }\n      );\n    },\n    { immediate: true }\n  );\n\n  onScopeDispose(detach);\n\n  return url;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,YACd,OACmC;CACnC,MAAM,MAAM,KAAyB;CAErC,IAAI;CACJ,IAAI,YAAY;CAEhB,MAAM,eAAe;AACnB,cAAY;AACZ,MAAI,gBAAgB,KAClB,KAAI;AACF,gBAAa,QAAQ;UACf;AAIV,iBAAe,KAAA;AACf,MAAI,QAAQ,KAAA;;AAGd,aACQ,QAAQ,MAAM,GACnB,SAAS;AACR,UAAQ;AACR,MAAI,QAAQ,KAAM;AAClB,cAAY;AACZ,iBAAe;AACf,OAAK,UAAU,MACZ,aAAa;AACZ,OAAI,CAAC,UAAW,KAAI,QAAQ;WAExB,GAIP;IAEH,EAAE,WAAW,MAAM,CACpB;AAED,gBAAe,OAAO;AAEtB,QAAO"}

package/dist/use-projection.cjs

@@ -0,0 +1,66 @@
+let vue = require("vue");
+//#region src/use-projection.ts
+/**
+* Vue primitive that composes {@link ChannelRegistry.acquire} with
+* Vue's reactivity system.
+*
+* Contract (mirrors the React `useProjection` hook but adapted to
+* Vue's `setup` + `onScopeDispose` lifecycle):
+*
+*  - On `setup()` (or whenever `registry` / `key` change) the
+*    composable acquires a ref-counted projection from the registry
+*    and subscribes to its store. Vue re-renders automatically
+*    whenever the store's snapshot changes.
+*  - On `onScopeDispose` (or when `registry` / `key` change) the
+*    previous acquisition is released. If this was the last consumer
+*    of that spec, the registry closes the underlying server
+*    subscription.
+*  - When `registry` is `null`/`undefined` the composable stays at
+*    `initialValue`. This is the happy path for root-served
+*    projections (`useMessages`, `useToolCalls`, `useValues`) which
+*    delegate to the always-on root store instead of acquiring a new
+*    registry projection.
+*
+* `registry` and `key` accept `MaybeRefOrGetter` so selector
+* composables can pass a reactive target (e.g. a computed subagent
+* snapshot) and have the projection rebind automatically.
+*
+* Returns a `Readonly<ShallowRef<T>>` so templates auto-unwrap and
+* scripts can `computed(() => proj.value)`. The underlying ref is
+* `shallowRef` — consumers that mutate the snapshot get undefined
+* behaviour; stream projections should always be treated as
+* immutable snapshots.
+*/
+function useProjection(registry, specFactory, key, initialValue) {
+	const state = (0, vue.shallowRef)(initialValue);
+	let currentRelease = null;
+	let currentUnsubscribe = null;
+	const detach = () => {
+		currentUnsubscribe?.();
+		currentUnsubscribe = null;
+		currentRelease?.();
+		currentRelease = null;
+	};
+	(0, vue.watch)(() => [(0, vue.toValue)(registry), (0, vue.toValue)(key)], ([nextRegistry]) => {
+		detach();
+		if (nextRegistry == null) {
+			state.value = initialValue;
+			return;
+		}
+		const acquired = nextRegistry.acquire(specFactory());
+		state.value = acquired.store.getSnapshot();
+		currentUnsubscribe = acquired.store.subscribe(() => {
+			state.value = acquired.store.getSnapshot();
+		});
+		currentRelease = acquired.release;
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	(0, vue.onScopeDispose)(detach);
+	return (0, vue.readonly)(state);
+}
+//#endregion
+exports.useProjection = useProjection;
+
+//# sourceMappingURL=use-projection.cjs.map

package/dist/use-projection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-projection.cjs","names":[],"sources":["../src/use-projection.ts"],"sourcesContent":["import {\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  watch,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type {\n  ChannelRegistry,\n  ProjectionSpec,\n} from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Vue primitive that composes {@link ChannelRegistry.acquire} with\n * Vue's reactivity system.\n *\n * Contract (mirrors the React `useProjection` hook but adapted to\n * Vue's `setup` + `onScopeDispose` lifecycle):\n *\n *  - On `setup()` (or whenever `registry` / `key` change) the\n *    composable acquires a ref-counted projection from the registry\n *    and subscribes to its store. Vue re-renders automatically\n *    whenever the store's snapshot changes.\n *  - On `onScopeDispose` (or when `registry` / `key` change) the\n *    previous acquisition is released. If this was the last consumer\n *    of that spec, the registry closes the underlying server\n *    subscription.\n *  - When `registry` is `null`/`undefined` the composable stays at\n *    `initialValue`. This is the happy path for root-served\n *    projections (`useMessages`, `useToolCalls`, `useValues`) which\n *    delegate to the always-on root store instead of acquiring a new\n *    registry projection.\n *\n * `registry` and `key` accept `MaybeRefOrGetter` so selector\n * composables can pass a reactive target (e.g. a computed subagent\n * snapshot) and have the projection rebind automatically.\n *\n * Returns a `Readonly<ShallowRef<T>>` so templates auto-unwrap and\n * scripts can `computed(() => proj.value)`. The underlying ref is\n * `shallowRef` — consumers that mutate the snapshot get undefined\n * behaviour; stream projections should always be treated as\n * immutable snapshots.\n */\nexport function useProjection<T>(\n  registry: MaybeRefOrGetter<ChannelRegistry | null | undefined>,\n  specFactory: () => ProjectionSpec<T>,\n  key: MaybeRefOrGetter<string>,\n  initialValue: T\n): Readonly<ShallowRef<T>> {\n  const state = shallowRef<T>(initialValue);\n  let currentRelease: (() => void) | null = null;\n  let currentUnsubscribe: (() => void) | null = null;\n\n  const detach = () => {\n    currentUnsubscribe?.();\n    currentUnsubscribe = null;\n    currentRelease?.();\n    currentRelease = null;\n  };\n\n  watch(\n    () => [toValue(registry), toValue(key)] as const,\n    ([nextRegistry]) => {\n      detach();\n      if (nextRegistry == null) {\n        state.value = initialValue;\n        return;\n      }\n      const acquired = nextRegistry.acquire(specFactory());\n      state.value = acquired.store.getSnapshot();\n      currentUnsubscribe = acquired.store.subscribe(() => {\n        state.value = acquired.store.getSnapshot();\n      });\n      currentRelease = acquired.release;\n    },\n    { immediate: true, flush: \"sync\" }\n  );\n\n  onScopeDispose(detach);\n\n  return readonly(state) as Readonly<ShallowRef<T>>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,cACd,UACA,aACA,KACA,cACyB;CACzB,MAAM,SAAA,GAAA,IAAA,YAAsB,aAAa;CACzC,IAAI,iBAAsC;CAC1C,IAAI,qBAA0C;CAE9C,MAAM,eAAe;AACnB,wBAAsB;AACtB,uBAAqB;AACrB,oBAAkB;AAClB,mBAAiB;;AAGnB,EAAA,GAAA,IAAA,aACQ,EAAA,GAAA,IAAA,SAAS,SAAS,GAAA,GAAA,IAAA,SAAU,IAAI,CAAC,GACtC,CAAC,kBAAkB;AAClB,UAAQ;AACR,MAAI,gBAAgB,MAAM;AACxB,SAAM,QAAQ;AACd;;EAEF,MAAM,WAAW,aAAa,QAAQ,aAAa,CAAC;AACpD,QAAM,QAAQ,SAAS,MAAM,aAAa;AAC1C,uBAAqB,SAAS,MAAM,gBAAgB;AAClD,SAAM,QAAQ,SAAS,MAAM,aAAa;IAC1C;AACF,mBAAiB,SAAS;IAE5B;EAAE,WAAW;EAAM,OAAO;EAAQ,CACnC;AAED,EAAA,GAAA,IAAA,gBAAe,OAAO;AAEtB,SAAA,GAAA,IAAA,UAAgB,MAAM"}

package/dist/use-projection.d.cts

@@ -0,0 +1,39 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+import { ChannelRegistry, ProjectionSpec } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-projection.d.ts
+/**
+ * Vue primitive that composes {@link ChannelRegistry.acquire} with
+ * Vue's reactivity system.
+ *
+ * Contract (mirrors the React `useProjection` hook but adapted to
+ * Vue's `setup` + `onScopeDispose` lifecycle):
+ *
+ *  - On `setup()` (or whenever `registry` / `key` change) the
+ *    composable acquires a ref-counted projection from the registry
+ *    and subscribes to its store. Vue re-renders automatically
+ *    whenever the store's snapshot changes.
+ *  - On `onScopeDispose` (or when `registry` / `key` change) the
+ *    previous acquisition is released. If this was the last consumer
+ *    of that spec, the registry closes the underlying server
+ *    subscription.
+ *  - When `registry` is `null`/`undefined` the composable stays at
+ *    `initialValue`. This is the happy path for root-served
+ *    projections (`useMessages`, `useToolCalls`, `useValues`) which
+ *    delegate to the always-on root store instead of acquiring a new
+ *    registry projection.
+ *
+ * `registry` and `key` accept `MaybeRefOrGetter` so selector
+ * composables can pass a reactive target (e.g. a computed subagent
+ * snapshot) and have the projection rebind automatically.
+ *
+ * Returns a `Readonly<ShallowRef<T>>` so templates auto-unwrap and
+ * scripts can `computed(() => proj.value)`. The underlying ref is
+ * `shallowRef` — consumers that mutate the snapshot get undefined
+ * behaviour; stream projections should always be treated as
+ * immutable snapshots.
+ */
+declare function useProjection<T>(registry: MaybeRefOrGetter<ChannelRegistry | null | undefined>, specFactory: () => ProjectionSpec<T>, key: MaybeRefOrGetter<string>, initialValue: T): Readonly<ShallowRef<T>>;
+//#endregion
+export { useProjection };
+//# sourceMappingURL=use-projection.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-projection.d.cts","names":[],"sources":["../src/use-projection.ts"],"mappings":";;;;;;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,aAAA,GAAA,CACd,QAAA,EAAU,gBAAA,CAAiB,eAAA,sBAC3B,WAAA,QAAmB,cAAA,CAAe,CAAA,GAClC,GAAA,EAAK,gBAAA,UACL,YAAA,EAAc,CAAA,GACb,QAAA,CAAS,UAAA,CAAW,CAAA"}

package/dist/use-projection.d.ts

@@ -0,0 +1,39 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+import { ChannelRegistry, ProjectionSpec } from "@langchain/langgraph-sdk/stream";
+
+//#region src/use-projection.d.ts
+/**
+ * Vue primitive that composes {@link ChannelRegistry.acquire} with
+ * Vue's reactivity system.
+ *
+ * Contract (mirrors the React `useProjection` hook but adapted to
+ * Vue's `setup` + `onScopeDispose` lifecycle):
+ *
+ *  - On `setup()` (or whenever `registry` / `key` change) the
+ *    composable acquires a ref-counted projection from the registry
+ *    and subscribes to its store. Vue re-renders automatically
+ *    whenever the store's snapshot changes.
+ *  - On `onScopeDispose` (or when `registry` / `key` change) the
+ *    previous acquisition is released. If this was the last consumer
+ *    of that spec, the registry closes the underlying server
+ *    subscription.
+ *  - When `registry` is `null`/`undefined` the composable stays at
+ *    `initialValue`. This is the happy path for root-served
+ *    projections (`useMessages`, `useToolCalls`, `useValues`) which
+ *    delegate to the always-on root store instead of acquiring a new
+ *    registry projection.
+ *
+ * `registry` and `key` accept `MaybeRefOrGetter` so selector
+ * composables can pass a reactive target (e.g. a computed subagent
+ * snapshot) and have the projection rebind automatically.
+ *
+ * Returns a `Readonly<ShallowRef<T>>` so templates auto-unwrap and
+ * scripts can `computed(() => proj.value)`. The underlying ref is
+ * `shallowRef` — consumers that mutate the snapshot get undefined
+ * behaviour; stream projections should always be treated as
+ * immutable snapshots.
+ */
+declare function useProjection<T>(registry: MaybeRefOrGetter<ChannelRegistry | null | undefined>, specFactory: () => ProjectionSpec<T>, key: MaybeRefOrGetter<string>, initialValue: T): Readonly<ShallowRef<T>>;
+//#endregion
+export { useProjection };
+//# sourceMappingURL=use-projection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-projection.d.ts","names":[],"sources":["../src/use-projection.ts"],"mappings":";;;;;;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,aAAA,GAAA,CACd,QAAA,EAAU,gBAAA,CAAiB,eAAA,sBAC3B,WAAA,QAAmB,cAAA,CAAe,CAAA,GAClC,GAAA,EAAK,gBAAA,UACL,YAAA,EAAc,CAAA,GACb,QAAA,CAAS,UAAA,CAAW,CAAA"}

package/dist/use-projection.js

@@ -0,0 +1,66 @@
+import { onScopeDispose, readonly, shallowRef, toValue, watch } from "vue";
+//#region src/use-projection.ts
+/**
+* Vue primitive that composes {@link ChannelRegistry.acquire} with
+* Vue's reactivity system.
+*
+* Contract (mirrors the React `useProjection` hook but adapted to
+* Vue's `setup` + `onScopeDispose` lifecycle):
+*
+*  - On `setup()` (or whenever `registry` / `key` change) the
+*    composable acquires a ref-counted projection from the registry
+*    and subscribes to its store. Vue re-renders automatically
+*    whenever the store's snapshot changes.
+*  - On `onScopeDispose` (or when `registry` / `key` change) the
+*    previous acquisition is released. If this was the last consumer
+*    of that spec, the registry closes the underlying server
+*    subscription.
+*  - When `registry` is `null`/`undefined` the composable stays at
+*    `initialValue`. This is the happy path for root-served
+*    projections (`useMessages`, `useToolCalls`, `useValues`) which
+*    delegate to the always-on root store instead of acquiring a new
+*    registry projection.
+*
+* `registry` and `key` accept `MaybeRefOrGetter` so selector
+* composables can pass a reactive target (e.g. a computed subagent
+* snapshot) and have the projection rebind automatically.
+*
+* Returns a `Readonly<ShallowRef<T>>` so templates auto-unwrap and
+* scripts can `computed(() => proj.value)`. The underlying ref is
+* `shallowRef` — consumers that mutate the snapshot get undefined
+* behaviour; stream projections should always be treated as
+* immutable snapshots.
+*/
+function useProjection(registry, specFactory, key, initialValue) {
+	const state = shallowRef(initialValue);
+	let currentRelease = null;
+	let currentUnsubscribe = null;
+	const detach = () => {
+		currentUnsubscribe?.();
+		currentUnsubscribe = null;
+		currentRelease?.();
+		currentRelease = null;
+	};
+	watch(() => [toValue(registry), toValue(key)], ([nextRegistry]) => {
+		detach();
+		if (nextRegistry == null) {
+			state.value = initialValue;
+			return;
+		}
+		const acquired = nextRegistry.acquire(specFactory());
+		state.value = acquired.store.getSnapshot();
+		currentUnsubscribe = acquired.store.subscribe(() => {
+			state.value = acquired.store.getSnapshot();
+		});
+		currentRelease = acquired.release;
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	onScopeDispose(detach);
+	return readonly(state);
+}
+//#endregion
+export { useProjection };
+
+//# sourceMappingURL=use-projection.js.map

package/dist/use-projection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-projection.js","names":[],"sources":["../src/use-projection.ts"],"sourcesContent":["import {\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  watch,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type {\n  ChannelRegistry,\n  ProjectionSpec,\n} from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Vue primitive that composes {@link ChannelRegistry.acquire} with\n * Vue's reactivity system.\n *\n * Contract (mirrors the React `useProjection` hook but adapted to\n * Vue's `setup` + `onScopeDispose` lifecycle):\n *\n *  - On `setup()` (or whenever `registry` / `key` change) the\n *    composable acquires a ref-counted projection from the registry\n *    and subscribes to its store. Vue re-renders automatically\n *    whenever the store's snapshot changes.\n *  - On `onScopeDispose` (or when `registry` / `key` change) the\n *    previous acquisition is released. If this was the last consumer\n *    of that spec, the registry closes the underlying server\n *    subscription.\n *  - When `registry` is `null`/`undefined` the composable stays at\n *    `initialValue`. This is the happy path for root-served\n *    projections (`useMessages`, `useToolCalls`, `useValues`) which\n *    delegate to the always-on root store instead of acquiring a new\n *    registry projection.\n *\n * `registry` and `key` accept `MaybeRefOrGetter` so selector\n * composables can pass a reactive target (e.g. a computed subagent\n * snapshot) and have the projection rebind automatically.\n *\n * Returns a `Readonly<ShallowRef<T>>` so templates auto-unwrap and\n * scripts can `computed(() => proj.value)`. The underlying ref is\n * `shallowRef` — consumers that mutate the snapshot get undefined\n * behaviour; stream projections should always be treated as\n * immutable snapshots.\n */\nexport function useProjection<T>(\n  registry: MaybeRefOrGetter<ChannelRegistry | null | undefined>,\n  specFactory: () => ProjectionSpec<T>,\n  key: MaybeRefOrGetter<string>,\n  initialValue: T\n): Readonly<ShallowRef<T>> {\n  const state = shallowRef<T>(initialValue);\n  let currentRelease: (() => void) | null = null;\n  let currentUnsubscribe: (() => void) | null = null;\n\n  const detach = () => {\n    currentUnsubscribe?.();\n    currentUnsubscribe = null;\n    currentRelease?.();\n    currentRelease = null;\n  };\n\n  watch(\n    () => [toValue(registry), toValue(key)] as const,\n    ([nextRegistry]) => {\n      detach();\n      if (nextRegistry == null) {\n        state.value = initialValue;\n        return;\n      }\n      const acquired = nextRegistry.acquire(specFactory());\n      state.value = acquired.store.getSnapshot();\n      currentUnsubscribe = acquired.store.subscribe(() => {\n        state.value = acquired.store.getSnapshot();\n      });\n      currentRelease = acquired.release;\n    },\n    { immediate: true, flush: \"sync\" }\n  );\n\n  onScopeDispose(detach);\n\n  return readonly(state) as Readonly<ShallowRef<T>>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,cACd,UACA,aACA,KACA,cACyB;CACzB,MAAM,QAAQ,WAAc,aAAa;CACzC,IAAI,iBAAsC;CAC1C,IAAI,qBAA0C;CAE9C,MAAM,eAAe;AACnB,wBAAsB;AACtB,uBAAqB;AACrB,oBAAkB;AAClB,mBAAiB;;AAGnB,aACQ,CAAC,QAAQ,SAAS,EAAE,QAAQ,IAAI,CAAC,GACtC,CAAC,kBAAkB;AAClB,UAAQ;AACR,MAAI,gBAAgB,MAAM;AACxB,SAAM,QAAQ;AACd;;EAEF,MAAM,WAAW,aAAa,QAAQ,aAAa,CAAC;AACpD,QAAM,QAAQ,SAAS,MAAM,aAAa;AAC1C,uBAAqB,SAAS,MAAM,gBAAgB;AAClD,SAAM,QAAQ,SAAS,MAAM,aAAa;IAC1C;AACF,mBAAiB,SAAS;IAE5B;EAAE,WAAW;EAAM,OAAO;EAAQ,CACnC;AAED,gBAAe,OAAO;AAEtB,QAAO,SAAS,MAAM"}

package/dist/use-stream.cjs

@@ -0,0 +1,169 @@
+const require_context = require("./context.cjs");
+let vue = require("vue");
+let _langchain_langgraph_sdk = require("@langchain/langgraph-sdk");
+let _langchain_langgraph_sdk_client = require("@langchain/langgraph-sdk/client");
+let _langchain_langgraph_sdk_stream = require("@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 = (0, vue.inject)(require_context.LANGCHAIN_OPTIONS, void 0) ?? {};
+	const hasCustomAdapter = asBag.transport != null && typeof asBag.transport !== "string";
+	const transport = asBag.transport;
+	const resolveApiUrl = () => (0, vue.toValue)(asBag.apiUrl) ?? pluginOptions.apiUrl;
+	const resolveApiKey = () => (0, vue.toValue)(asBag.apiKey) ?? pluginOptions.apiKey;
+	const client = (0, vue.shallowRef)(asBag.client ?? pluginOptions.client ?? new _langchain_langgraph_sdk_client.Client({
+		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 _langchain_langgraph_sdk_stream.StreamController({
+		assistantId,
+		client,
+		threadId: (0, vue.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
+	});
+	(0, vue.onScopeDispose)(controller.activate());
+	function bindStore(subscribe, getSnapshot) {
+		const ref = (0, vue.shallowRef)(getSnapshot());
+		(0, vue.onScopeDispose)(subscribe(() => {
+			ref.value = getSnapshot();
+		}));
+		return (0, vue.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 = (0, vue.computed)(() => rootRef.value.values);
+	const messages = (0, vue.computed)(() => rootRef.value.messages);
+	const toolCalls = (0, vue.computed)(() => rootRef.value.toolCalls);
+	const interrupts = (0, vue.computed)(() => (0, _langchain_langgraph_sdk.filterOutHeadlessToolInterrupts)(rootRef.value.interrupts));
+	const interrupt = (0, vue.computed)(() => interrupts.value[0]);
+	const isLoading = (0, vue.computed)(() => rootRef.value.isLoading);
+	const isThreadLoading = (0, vue.computed)(() => rootRef.value.isThreadLoading);
+	const error = (0, vue.computed)(() => rootRef.value.error);
+	const threadId = (0, vue.computed)(() => rootRef.value.threadId);
+	const hydrationPromise = (0, vue.computed)(() => controller.hydrationPromise);
+	const asShallow = (c) => c;
+	let skipFirstThreadIdWatch = true;
+	(0, vue.watch)(() => (0, vue.toValue)(asBag.threadId) ?? null, (next) => {
+		if (skipFirstThreadIdWatch) {
+			skipFirstThreadIdWatch = false;
+			return;
+		}
+		controller.hydrate(next);
+	});
+	const handledTools = /* @__PURE__ */ new Set();
+	(0, vue.watch)(() => (0, vue.toValue)(asBag.threadId) ?? null, () => handledTools.clear());
+	const tools = options.tools;
+	const onTool = options.onTool;
+	if (tools?.length) (0, vue.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;
+		(0, _langchain_langgraph_sdk.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
+exports.STREAM_CONTROLLER = STREAM_CONTROLLER;
+exports.getRegistry = getRegistry;
+exports.useStream = useStream;
+
+//# sourceMappingURL=use-stream.cjs.map

package/dist/use-stream.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stream.cjs","names":["LANGCHAIN_OPTIONS","ClientCtor","StreamController"],"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":";;;;;;;;;;;;AA2EA,MAAa,oBAAmC,OAAO,IACrD,4BACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuID,SAAgB,UAKd,SACqD;CAqBrD,MAAM,QAAQ;CAMd,MAAM,iBAAA,GAAA,IAAA,QACGA,gBAAAA,mBAAmB,KAAA,EAAU,IAAK,EAAE;CAE7C,MAAM,mBACJ,MAAM,aAAa,QAAQ,OAAO,MAAM,cAAc;CACxD,MAAM,YAAY,MAAM;CAOxB,MAAM,uBAAA,GAAA,IAAA,SACI,MAAM,OAAO,IAAK,cAAsC;CAClE,MAAM,uBAAA,GAAA,IAAA,SACI,MAAM,OAAO,IAAK,cAAsC;CAmBlE,MAAM,UAAA,GAAA,IAAA,YAjBJ,MAAM,UAAW,cAAsC,UAIpD,IAAIC,gCAAAA,OAAW;EACd,QAAQ,eAAe;EACvB,QAAQ,eAAe;EACvB,eAAe,MAAM;EACrB,gBAAgB,MAAM;EACvB,CAAC,CACL,CAOwB;CAIzB,MAAM,WAAW;CACjB,MAAM,cACJ,iBAAiB,UAAW,QAAQ,eAAe,WAAY;CAKjE,MAAM,aAAa,IAAIC,gCAAAA,iBAIrB;EACA;EACQ;EACR,WAAA,GAAA,IAAA,SAV8B,MAAM,SAAS,IAAI;EAWjD;EACA,OAAO,mBAAmB,KAAA,IAAY,MAAM;EAC5C,kBAAkB,mBAAmB,KAAA,IAAY,MAAM;EACvD,YAAY,QAAQ;EACpB,WAAW,QAAQ;EACnB,eAAe,QAAQ;EACvB,aAAa,QAAQ;EACtB,CAAC;AAOF,EAAA,GAAA,IAAA,gBADmB,WAAW,UAAU,CACd;CAG1B,SAAS,UACP,WACA,aACyB;EACzB,MAAM,OAAA,GAAA,IAAA,YAAoB,aAAa,CAAC;AAIxC,GAAA,GAAA,IAAA,gBAHoB,gBAAgB;AAClC,OAAI,QAAQ,aAAa;IACzB,CACyB;AAC3B,UAAA,GAAA,IAAA,UAAgB,IAAI;;CAGtB,MAAM,UAAU,UACd,WAAW,UAAU,WACrB,WAAW,UAAU,YACtB;CACD,MAAM,cAAc,UAClB,WAAW,cAAc,WACzB,WAAW,cAAc,YAC1B;CACD,MAAM,cAAc,UAClB,WAAW,cAAc,WACzB,WAAW,cAAc,YAC1B;CACD,MAAM,oBAAoB,UACxB,WAAW,oBAAoB,WAC/B,WAAW,oBAAoB,YAChC;CAMD,MAAM,UAAA,GAAA,IAAA,gBAAwB,QAAQ,MAAM,OAAO;CACnD,MAAM,YAAA,GAAA,IAAA,gBAA0B,QAAQ,MAAM,SAAS;CACvD,MAAM,aAAA,GAAA,IAAA,gBAA2B,QAAQ,MAAM,UAAU;CACzD,MAAM,cAAA,GAAA,IAAA,iBAAA,GAAA,yBAAA,iCAC4B,QAAQ,MAAM,WAAW,CAC1D;CACD,MAAM,aAAA,GAAA,IAAA,gBAA2B,WAAW,MAAM,GAAG;CACrD,MAAM,aAAA,GAAA,IAAA,gBAA2B,QAAQ,MAAM,UAAU;CACzD,MAAM,mBAAA,GAAA,IAAA,gBAAiC,QAAQ,MAAM,gBAAgB;CACrE,MAAM,SAAA,GAAA,IAAA,gBAAuB,QAAQ,MAAM,MAAM;CACjD,MAAM,YAAA,GAAA,IAAA,gBAA0B,QAAQ,MAAM,SAAS;CACvD,MAAM,oBAAA,GAAA,IAAA,gBAAkC,WAAW,iBAAiB;CAQpE,MAAM,aAAgB,MACpB;CAQF,IAAI,yBAAyB;AAC7B,EAAA,GAAA,IAAA,cAAA,GAAA,IAAA,SACgB,MAAM,SAAS,IAAI,OAChC,SAAS;AACR,MAAI,wBAAwB;AAC1B,4BAAyB;AACzB;;AAEG,aAAW,QAAQ,KAAK;GAEhC;CAQD,MAAM,+BAAe,IAAI,KAAa;AACtC,EAAA,GAAA,IAAA,cAAA,GAAA,IAAA,SACgB,MAAM,SAAS,IAAI,YAC3B,aAAa,OAAO,CAC3B;CACD,MAAM,QAAQ,QAAQ;CACtB,MAAM,SAAS,QAAQ;AACvB,KAAI,OAAO,OACT,EAAA,GAAA,IAAA,aACQ,CAAC,QAAQ,MAAM,QAAQ,QAAQ,MAAM,WAAW,GACrD,CAAC,YAAY,oBAAoB;EAChC,MAAM,MAAM;EAIZ,MAAM,WAAwB,CAC5B,GAJe,MAAM,QAAQ,KAAK,cAAc,GAC7C,IAAI,gBACL,EAAE,EAGJ,GAAI,eACL;AACD,MAAI,SAAS,WAAW,EAAG;AAC3B,GAAA,GAAA,yBAAA,oCACE;GAAE,GAAG;GAAK,eAAe;GAAU,EACnC,OACA,cACA;GACE;GACA,QAAQ,QAAQ;AACT,YAAQ,SAAS,CAAC,KAAK,IAAI;;GAElC,eAAe,YACb,WAAW,OAAO,MAAM,EACtB,SACD,CAAqD;GACzD,CACF;IAEH;EAAE,WAAW;EAAM,OAAO;EAAQ,CACnC;AAkCH,QA/BoE;EAClE,QAAQ,UAAU,OAAO;EAKzB,UAAU,UAAU,SAAS;EAC7B,WAAW,UAAU,UAAU;EAC/B,YAAY,UAAU,WAAW;EACjC;EACA;EACA;EACA;EACA;EACA;EACA,WAAW;EAKX,WAAW;EACX,iBAAiB;EACjB,SAAS,OAAO,kBAAkB,WAAW,OAAO,OAAO,cAAc;EACzE,YAAY,WAAW,MAAM;EAC7B,UAAU,UAAU,WAAW,WAAW,QAAQ,UAAU,OAAO;EACnE,iBAAiB,WAAW,WAAW;EACvC;EACA;GACC,oBAAoB;EACtB;;;;;;;;;AAYH,SAAgB,YAEd,QACiB;AACjB,QAAO,OAAO,mBAAmB"}