@langchain/vue 0.4.7 → 1.0.1

package/README.md

@@ -1,6 +1,40 @@
 # @langchain/vue
 
-Vue SDK for building AI-powered applications with [Deep Agents](https://docs.langchain.com/oss/javascript/deepagents/overview), [LangChain](https://docs.langchain.com/oss/javascript/langchain/overview) and [LangGraph](https://docs.langchain.com/oss/javascript/langgraph/overview). It provides a `useStream` composable that manages streaming, state, branching, and interrupts using Vue's reactivity system.
+Vue SDK for building AI-powered applications with [Deep Agents](https://docs.langchain.com/oss/javascript/deepagents/overview), [LangChain](https://docs.langchain.com/oss/javascript/langchain/overview) and [LangGraph](https://docs.langchain.com/oss/javascript/langgraph/overview).
+
+The package ships a Composition-API–first binding built on top of
+the v2 streaming protocol. `useStream` returns a small, always-on
+root handle (`values`, `messages`, `isLoading`, `error`, …) and
+pushes anything namespaced (subagents, subgraphs, media, submission
+queue, per-message metadata) behind **ref-counted `use*` selectors**
+so components only pay for the data they actually consume.
+
+> **Upgrading from `0.x`?** See [`docs/v1-migration.md`](./docs/v1-migration.md)
+> for the complete matrix of option, return-shape, and transport
+> changes.
+
+## Highlights
+
+- **v2-native streaming protocol.** Session-based transport with
+  automatic re-attach on remount — no `reconnectOnMount` /
+  `joinStream` dance.
+- **Composition-API first.** Everything is a `ShallowRef` /
+  `ComputedRef`, auto-disposed via `onScopeDispose` when the scope
+  unmounts.
+- **Selector-based subscriptions.** Namespaced data (subagents,
+  subgraphs, media) streams only when a component actually mounts
+  the matching selector composable, and releases on unmount.
+- **Discriminated transports.** Hosted Agent Server and custom
+  adapters are two arms of a single typed union — mixing them is a
+  compile-time error.
+- **Agent-brand type inference.** `useStream<typeof agent>()`
+  unwraps state, tool calls, and subagent state maps from an agent
+  brand.
+- **Multimodal media streams.** Built-in assembly for audio,
+  images, video, and files, with ready-to-use `<img>` / `<audio>` /
+  `<video>` players.
+- **`<Suspense>` friendly.** `hydrationPromise` lets you gate
+  `async setup()` on initial hydration.
 
 ## Installation
 
@@ -8,395 +42,81 @@ Vue SDK for building AI-powered applications with [Deep Agents](https://docs.lan
 npm install @langchain/vue @langchain/core
 ```
 
-**Peer dependencies:** `vue` (^3.0.0), `@langchain/core` (^1.0.1)
+**Peer dependencies:** `vue` (^3.4.0), `@langchain/core` (^1.0.1).
 
-## Quick Start
+## Quick start
 
 ```vue
 <script setup lang="ts">
 import { useStream } from "@langchain/vue";
 
-const { messages, submit, isLoading } = useStream({
+const stream = useStream({
   assistantId: "agent",
   apiUrl: "http://localhost:2024",
 });
-</script>
-
-<template>
-  <div>
-    <div v-for="(msg, i) in messages" :key="msg.id ?? i">
-      {{ msg.content }}
-    </div>
-
-    <button
-      :disabled="isLoading"
-      @click="submit({ messages: [{ type: 'human', content: 'Hello!' }] })"
-    >
-      Send
-    </button>
-  </div>
-</template>
-```
-
-## `useStream` Options
-
-| Option | Type | Description |
-|---|---|---|
-| `assistantId` | `string` | **Required.** The assistant/graph ID to stream from. |
-| `apiUrl` | `string` | Base URL of the LangGraph API. |
-| `client` | `Client` | Pre-configured `Client` instance (alternative to `apiUrl`). |
-| `messagesKey` | `string` | State key containing messages. Defaults to `"messages"`. |
-| `initialValues` | `StateType` | Initial state values before any stream data arrives. |
-| `fetchStateHistory` | `boolean \| { limit: number }` | Fetch thread history on stream completion. Enables branching. |
-| `throttle` | `boolean \| number` | Throttle state updates for performance. |
-| `onFinish` | `(state, error?) => void` | Called when the stream completes. |
-| `onError` | `(error, state?) => void` | Called on stream errors. |
-| `onThreadId` | `(threadId) => void` | Called when a new thread is created. |
-| `onUpdateEvent` | `(event) => void` | Receive update events from the stream. |
-| `onCustomEvent` | `(event) => void` | Receive custom events from the stream. |
-| `onStop` | `() => void` | Called when the stream is stopped by the user. |
-
-## Return Values
-
-All reactive properties are Vue `computed` or `ref` values that [auto-unwrap](https://vuejs.org/guide/essentials/reactivity-fundamentals.html#ref-unwrapping-in-templates) in `<template>` blocks — use them directly (e.g. `messages`, not `messages.value`). The `queue` object is `reactive`, so its nested properties also auto-unwrap in templates.
-
-| Property | Type | Description |
-|---|---|---|
-| `values` | `ComputedRef<StateType>` | Current graph state. |
-| `messages` | `ComputedRef<Message[]>` | Messages from the current state. |
-| `isLoading` | `Ref<boolean>` | Whether a stream is currently active. |
-| `error` | `ComputedRef<unknown>` | The most recent error, if any. |
-| `interrupt` | `ComputedRef<Interrupt \| undefined>` | Current interrupt requiring user input. |
-| `branch` | `Ref<string>` | Active branch identifier. |
-| `submit(values, options?)` | `function` | Submit new input to the graph. When called while a stream is active, the run is created on the server with `multitaskStrategy: "enqueue"` and queued automatically. |
-| `stop()` | `function` | Cancel the active stream. |
-| `setBranch(branch)` | `function` | Switch to a different conversation branch. |
-| `getMessagesMetadata(msg, index?)` | `function` | Get branching and checkpoint metadata for a message. |
-| `switchThread(id)` | `(id: string \| null) => void` | Switch to a different thread. Pass `null` to start a new thread on next submit. |
-| `queue.entries` | `ReadonlyArray<QueueEntry>` | Pending server-side runs. Each entry has `id` (server run ID), `values`, `options`, and `createdAt`. |
-| `queue.size` | `number` | Number of pending runs on the server. |
-| `queue.cancel(id)` | `(id: string) => Promise<boolean>` | Cancel a pending run on the server by its run ID. |
-| `queue.clear()` | `() => Promise<void>` | Cancel all pending runs on the server. |
-
-## Type Safety
-
-Provide your state type as a generic parameter:
-
-```vue
-<script setup lang="ts">
-import { useStream } from "@langchain/vue";
-import type { BaseMessage } from "langchain";
 
-interface MyState {
-  messages: BaseMessage[];
-  context?: string;
+function onSubmit() {
+  void stream.submit({ messages: [{ type: "human", content: "Hello!" }] });
 }
-
-const { messages, submit } = useStream<MyState>({
-  assistantId: "my-graph",
-  apiUrl: "http://localhost:2024",
-});
-</script>
-```
-
-### Typed Interrupts
-
-```vue
-<script setup lang="ts">
-import { useStream } from "@langchain/vue";
-import type { BaseMessage } from "langchain";
-
-const { interrupt, submit } = useStream<
-  { messages: BaseMessage[] },
-  { InterruptType: { question: string } }
->({
-  assistantId: "my-graph",
-  apiUrl: "http://localhost:2024",
-});
-</script>
-```
-
-## Handling Interrupts
-
-```vue
-<script setup lang="ts">
-import { useStream } from "@langchain/vue";
-import type { BaseMessage } from "langchain";
-
-const { messages, interrupt, submit } = useStream<
-  { messages: BaseMessage[] },
-  { InterruptType: { question: string } }
->({
-  assistantId: "agent",
-  apiUrl: "http://localhost:2024",
-});
 </script>
 
 <template>
   <div>
-    <div v-for="(msg, i) in messages" :key="msg.id ?? i">
-      {{ msg.content }}
-    </div>
-
-    <div v-if="interrupt">
-      <p>{{ interrupt.question }}</p>
-      <button @click="submit(null, { command: { resume: 'Approved' } })">
-        Approve
-      </button>
+    <div v-for="(msg, i) in stream.messages" :key="msg.id ?? i">
+      {{ typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content) }}
     </div>
 
-    <button
-      @click="submit({ messages: [{ type: 'human', content: 'Hello' }] })"
-    >
+    <button :disabled="stream.isLoading" @click="onSubmit">
       Send
     </button>
   </div>
 </template>
 ```
 
-## Branching
-
-Enable conversation branching with `fetchStateHistory: true`:
-
-```vue
-<script setup lang="ts">
-import { useStream } from "@langchain/vue";
-
-const { messages, submit, getMessagesMetadata, setBranch } = useStream({
-  assistantId: "agent",
-  apiUrl: "http://localhost:2024",
-  fetchStateHistory: true,
-});
-</script>
-
-<template>
-  <div>
-    <div v-for="(msg, i) in messages" :key="msg.id ?? i">
-      <p>{{ msg.content }}</p>
-
-      <template v-if="getMessagesMetadata(msg, i)?.branchOptions">
-        <button
-          @click="() => {
-            const meta = getMessagesMetadata(msg, i);
-            const prev = meta.branchOptions[meta.branchOptions.indexOf(meta.branch) - 1];
-            if (prev) setBranch(prev);
-          }"
-        >
-          Previous
-        </button>
-        <button
-          @click="() => {
-            const meta = getMessagesMetadata(msg, i);
-            const next = meta.branchOptions[meta.branchOptions.indexOf(meta.branch) + 1];
-            if (next) setBranch(next);
-          }"
-        >
-          Next
-        </button>
-      </template>
-    </div>
-
-    <button
-      @click="submit({ messages: [{ type: 'human', content: 'Hello' }] })"
-    >
-      Send
-    </button>
-  </div>
-</template>
-```
-
-## Server-Side Queuing
-
-When `submit()` is called while a stream is already active, the SDK automatically creates the run on the server with `multitaskStrategy: "enqueue"`. The pending runs are tracked in `queue` and processed in order as each finishes:
-
-```vue
-<script setup lang="ts">
-import { useStream } from "@langchain/vue";
-
-const { messages, submit, isLoading, queue, switchThread } = useStream({
-  assistantId: "agent",
-  apiUrl: "http://localhost:2024",
-});
-</script>
-
-<template>
-  <div>
-    <div v-for="(msg, i) in messages" :key="msg.id ?? i">
-      {{ msg.content }}
-    </div>
-
-    <div v-if="queue.size > 0">
-      <p>{{ queue.size }} message(s) queued</p>
-      <button @click="queue.clear()">Clear Queue</button>
-    </div>
-
-    <button
-      :disabled="isLoading"
-      @click="submit({ messages: [{ type: 'human', content: 'Hello!' }] })"
-    >
-      Send
-    </button>
-    <button @click="switchThread(null)">New Thread</button>
-  </div>
-</template>
-```
-
-Switching threads via `switchThread()` cancels all pending runs and clears the queue.
-
-## Custom Transport
-
-Instead of connecting to a LangGraph API, you can provide your own streaming transport. Pass a `transport` object instead of `assistantId` to use a custom backend:
-
-```vue
-<script setup lang="ts">
-import { useStream, FetchStreamTransport } from "@langchain/vue";
-import type { BaseMessage } from "langchain";
-
-const {
-  messages,
-  submit,
-  isLoading,
-  branch,
-  setBranch,
-  getMessagesMetadata,
-} = useStream<{ messages: BaseMessage[] }>({
-  transport: new FetchStreamTransport({
-    url: "https://my-api.example.com/stream",
-  }),
-  threadId: null,
-  onThreadId: (id) => console.log("Thread created:", id),
-});
-</script>
-
-<template>
-  <div>
-    <div v-for="(msg, i) in messages" :key="msg.id ?? i">
-      <p>{{ msg.content }}</p>
-      <span v-if="getMessagesMetadata(msg, i)?.streamMetadata">
-        Node: {{ getMessagesMetadata(msg, i)?.streamMetadata?.langgraph_node }}
-      </span>
-    </div>
-
-    <p>Current branch: {{ branch }}</p>
-
-    <button
-      :disabled="isLoading"
-      @click="submit({ messages: [{ type: 'human', content: 'Hello!' }] })"
-    >
-      Send
-    </button>
-  </div>
-</template>
-```
-
-The custom transport interface returns the same properties as the standard `useStream` composable, including `getMessagesMetadata`, `branch`, `setBranch`, `switchThread`, and all message/interrupt/subagent helpers. When using a custom transport, `getMessagesMetadata` returns stream metadata sent alongside messages during streaming; `branch` and `setBranch` provide local branch state management. `onFinish` is also supported and receives a synthetic `ThreadState` built from the final locally streamed values; the run metadata argument is `undefined`.
-
-## Sharing State with `provideStream`
-
-When multiple components need access to the same stream (a message list, a header, an input bar), use `provideStream` and `useStreamContext` to share a single stream instance via Vue's `provide`/`inject`:
-
-```vue
-<!-- ChatContainer.vue -->
-<script setup lang="ts">
-import { provideStream } from "@langchain/vue";
-
-provideStream({
-  assistantId: "agent",
-  apiUrl: "http://localhost:2024",
-});
-</script>
-
-<template>
-  <ChatHeader />
-  <MessageList />
-  <MessageInput />
-</template>
-```
-
-```vue
-<!-- MessageList.vue -->
-<script setup lang="ts">
-import { useStreamContext } from "@langchain/vue";
-
-const { messages } = useStreamContext();
-</script>
-
-<template>
-  <div v-for="(msg, i) in messages" :key="msg.id ?? i">
-    {{ msg.content }}
-  </div>
-</template>
-```
-
-```vue
-<!-- MessageInput.vue -->
-<script setup lang="ts">
-import { useStreamContext } from "@langchain/vue";
-import { ref } from "vue";
-
-const { submit, isLoading } = useStreamContext();
-const input = ref("");
-
-function send() {
-  submit({ messages: [{ type: "human", content: input.value }] });
-  input.value = "";
-}
-</script>
-
-<template>
-  <form @submit.prevent="send">
-    <textarea v-model="input" />
-    <button :disabled="isLoading" type="submit">Send</button>
-  </form>
-</template>
-```
-
-### App-Level Configuration with `LangChainPlugin`
-
-Use the Vue plugin to set default configuration for all `useStream` calls:
-
-```typescript
-import { createApp } from "vue";
-import { LangChainPlugin } from "@langchain/vue";
-import App from "./App.vue";
-
-const app = createApp(App);
-app.use(LangChainPlugin, {
-  apiUrl: "http://localhost:2024",
-});
-app.mount("#app");
-```
-
-Then in any component, `apiUrl` is inherited automatically:
-
-```vue
-<script setup lang="ts">
-import { useStream } from "@langchain/vue";
-
-const stream = useStream({ assistantId: "agent" });
-</script>
-```
-
-### Multiple Agents
-
-Nest `provideStream` calls for multi-agent scenarios — Vue's `provide`/`inject` scoping ensures each subtree gets its own stream:
-
-```vue
-<!-- ResearchPanel.vue -->
-<script setup lang="ts">
-import { provideStream } from "@langchain/vue";
-provideStream({ assistantId: "researcher", apiUrl: "http://localhost:2024" });
-</script>
-
-<template>
-  <MessageList />
-  <MessageInput />
-</template>
-```
+Reactive fields on the handle are Vue refs (`ShallowRef` /
+`ComputedRef`). In `<script setup>`, read them with `.value`:
+`stream.messages.value`, `stream.isLoading.value`. In `<template>`,
+Vue auto-unwraps refs, so prefer the shorter
+`stream.messages` / `stream.isLoading` form.
+
+## Documentation
+
+In-depth guides live in [`docs/`](./docs):
+
+- [API reference](./docs/api-reference.md) — `useStream` options and
+  return shape.
+- [Selectors](./docs/selectors.md) — ref-counted readers for
+  namespaced / scoped data.
+- [Transports](./docs/transports.md) — SSE, WebSocket, and custom
+  `AgentServerAdapter` implementations.
+- [Custom transports](./docs/custom-transport.md) — implementing
+  `AgentServerAdapter` against your own backend, with a worked
+  walkthrough of [`examples/ui-react-transport`](../../examples/ui-react-transport).
+- [Interrupts & headless tools](./docs/interrupts.md) — pausing a
+  run, responding to interrupts, registering browser-side tools.
+- [Forking from a message](./docs/forking.md) — edit / retry flows
+  with `useMessageMetadata` + `submit({ forkFrom })`.
+- [Submission queue](./docs/submission-queue.md) — inspecting and
+  cancelling enqueued submits.
+- [Subagents & subgraphs](./docs/subagents.md) — rendering
+  per-subagent messages, tool calls, and state via scoped selectors.
+- [Multimodal media](./docs/multimodal.md) — audio / image / video /
+  file streams with built-in players.
+- [Sharing a stream](./docs/sharing-streams.md) — `provideStream`,
+  `useStreamContext`, and the `LangChainPlugin` app-level defaults.
+- [Suspense-style hydration](./docs/suspense.md) — gating
+  `async setup()` on `hydrationPromise`.
+- [Type safety](./docs/type-safety.md) — brand inference, generics,
+  and the exported helper types.
+- [Testing](./docs/testing.md) — mounting components with mock
+  streams or real dev servers.
+- [Migrating from 0.x](./docs/v1-migration.md) — full diff of
+  options, return shape, and transport classes.
 
 ## Playground
 
-For complete end-to-end examples with full agentic UIs, visit the [LangChain UI Playground](https://docs.langchain.com/playground).
+For complete end-to-end examples with full agentic UIs, visit the
+[LangChain UI Playground](https://docs.langchain.com/playground).
 
 ## License
 

package/dist/context.cjs

@@ -1,4 +1,4 @@
-const require_index = require("./index.cjs");
+const require_use_stream = require("./use-stream.cjs");
 let vue = require("vue");
 //#region src/context.ts
 const STREAM_CONTEXT_KEY = Symbol("langchain-stream");
@@ -62,7 +62,7 @@ const LangChainPlugin = { install(app, options = {}) {
 * @returns The stream instance (same as calling `useStream` directly).
 */
 function provideStream(options) {
-	const stream = require_index.useStream(options);
+	const stream = require_use_stream.useStream(options);
 	(0, vue.provide)(STREAM_CONTEXT_KEY, stream);
 	return stream;
 }

package/dist/context.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"context.cjs","names":["useStream"],"sources":["../src/context.ts"],"sourcesContent":["import { provide, inject, type InjectionKey, type App, type Plugin } from \"vue\";\nimport type { BagTemplate } from \"@langchain/langgraph-sdk\";\nimport type {\n  ResolveStreamOptions,\n  InferBag,\n  InferStateType,\n  UseStreamCustomOptions,\n} from \"@langchain/langgraph-sdk/ui\";\nimport { Client } from \"@langchain/langgraph-sdk\";\nimport { useStream } from \"./index.js\";\n\n/**\n * Configuration options for the LangChain Vue plugin.\n * These provide default values that `useStream` will pick up automatically.\n */\nexport interface LangChainPluginOptions {\n  /** Base URL of the LangGraph API. */\n  apiUrl?: string;\n  /** API key for authenticating with the LangGraph API. */\n  apiKey?: string;\n  /** Pre-configured Client instance. */\n  client?: Client;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst STREAM_CONTEXT_KEY: InjectionKey<any> = Symbol(\"langchain-stream\");\n\nexport const LANGCHAIN_OPTIONS: InjectionKey<LangChainPluginOptions> =\n  Symbol(\"langchain-options\");\n\n/**\n * Vue plugin that provides default LangGraph configuration to all components.\n *\n * When installed, `useStream` composables throughout the application will\n * automatically use the configured `apiUrl` and `client` without requiring\n * explicit options.\n *\n * @example\n * ```typescript\n * import { createApp } from \"vue\";\n * import { LangChainPlugin } from \"@langchain/vue\";\n * import App from \"./App.vue\";\n *\n * const app = createApp(App);\n * app.use(LangChainPlugin, {\n *   apiUrl: \"http://localhost:2024\",\n * });\n * app.mount(\"#app\");\n * ```\n *\n * Then in any component:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * // apiUrl is inherited from the plugin — no need to repeat it\n * const stream = useStream({ assistantId: \"agent\" });\n * </script>\n * ```\n */\nexport const LangChainPlugin: Plugin<[LangChainPluginOptions?]> = {\n  install(app: App, options: LangChainPluginOptions = {}) {\n    app.provide(LANGCHAIN_OPTIONS, options);\n  },\n};\n\n/**\n * Creates a shared `useStream` instance and provides it to all descendant\n * components via Vue's `provide`/`inject`.\n *\n * Call this in a parent component's `<script setup>` to make the stream\n * available to children via `useStreamContext()`.\n *\n * @example\n * ```vue\n * <!-- ChatContainer.vue -->\n * <script setup lang=\"ts\">\n * import { provideStream } from \"@langchain/vue\";\n *\n * provideStream({ assistantId: \"agent\", apiUrl: \"http://localhost:2024\" });\n * </script>\n *\n * <template>\n *   <ChatHeader />\n *   <MessageList />\n *   <MessageInput />\n * </template>\n * ```\n *\n * @returns The stream instance (same as calling `useStream` directly).\n */\nexport function provideStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options:\n    | ResolveStreamOptions<T, InferBag<T, Bag>>\n    | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): ReturnType<typeof useStream<T, Bag>> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const stream = useStream<T, Bag>(options as any);\n  provide(STREAM_CONTEXT_KEY, stream);\n  return stream;\n}\n\n/**\n * Accesses the shared stream instance from the nearest ancestor that\n * called `provideStream()`.\n *\n * Throws if no ancestor has provided a stream.\n *\n * @example\n * ```vue\n * <!-- MessageList.vue -->\n * <script setup lang=\"ts\">\n * import { useStreamContext } from \"@langchain/vue\";\n *\n * const { messages } = useStreamContext();\n * </script>\n *\n * <template>\n *   <div v-for=\"(msg, i) in messages.value\" :key=\"msg.id ?? i\">\n *     {{ msg.content }}\n *   </div>\n * </template>\n * ```\n *\n * @example With type parameters for full type safety:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStreamContext } from \"@langchain/vue\";\n * import type { agent } from \"./agent\";\n *\n * const { toolCalls } = useStreamContext<typeof agent>();\n * </script>\n * ```\n */\nexport function useStreamContext<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): ReturnType<typeof useStream<T, Bag>> {\n  const context = inject(STREAM_CONTEXT_KEY);\n  if (context == null) {\n    throw new Error(\n      \"useStreamContext() requires a parent component to call provideStream(). \" +\n        \"Add provideStream({ assistantId: '...' }) in an ancestor component.\"\n    );\n  }\n  return context;\n}\n"],"mappings":";;;AAyBA,MAAM,qBAAwC,OAAO,mBAAmB;AAExE,MAAa,oBACX,OAAO,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgC7B,MAAa,kBAAqD,EAChE,QAAQ,KAAU,UAAkC,EAAE,EAAE;AACtD,KAAI,QAAQ,mBAAmB,QAAQ;GAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,SAAgB,cAId,SAGsC;CAEtC,MAAM,SAASA,cAAAA,UAAkB,QAAe;AAChD,EAAA,GAAA,IAAA,SAAQ,oBAAoB,OAAO;AACnC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCT,SAAgB,mBAG0B;CACxC,MAAM,WAAA,GAAA,IAAA,QAAiB,mBAAmB;AAC1C,KAAI,WAAW,KACb,OAAM,IAAI,MACR,8IAED;AAEH,QAAO"}
+{"version":3,"file":"context.cjs","names":["useStream"],"sources":["../src/context.ts"],"sourcesContent":["import { provide, inject, type InjectionKey, type App, type Plugin } from \"vue\";\nimport { Client } from \"@langchain/langgraph-sdk\";\nimport { useStream } from \"./use-stream.js\";\n\n/**\n * Configuration options for the LangChain Vue plugin.\n * These provide default values that `useStream` will pick up automatically.\n */\nexport interface LangChainPluginOptions {\n  /** Base URL of the LangGraph API. */\n  apiUrl?: string;\n  /** API key for authenticating with the LangGraph API. */\n  apiKey?: string;\n  /** Pre-configured Client instance. */\n  client?: Client;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst STREAM_CONTEXT_KEY: InjectionKey<any> = Symbol(\"langchain-stream\");\n\nexport const LANGCHAIN_OPTIONS: InjectionKey<LangChainPluginOptions> =\n  Symbol(\"langchain-options\");\n\n/**\n * Vue plugin that provides default LangGraph configuration to all components.\n *\n * When installed, `useStream` composables throughout the application will\n * automatically use the configured `apiUrl` and `client` without requiring\n * explicit options.\n *\n * @example\n * ```typescript\n * import { createApp } from \"vue\";\n * import { LangChainPlugin } from \"@langchain/vue\";\n * import App from \"./App.vue\";\n *\n * const app = createApp(App);\n * app.use(LangChainPlugin, {\n *   apiUrl: \"http://localhost:2024\",\n * });\n * app.mount(\"#app\");\n * ```\n *\n * Then in any component:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * // apiUrl is inherited from the plugin — no need to repeat it\n * const stream = useStream({ assistantId: \"agent\" });\n * </script>\n * ```\n */\nexport const LangChainPlugin: Plugin<[LangChainPluginOptions?]> = {\n  install(app: App, options: LangChainPluginOptions = {}) {\n    app.provide(LANGCHAIN_OPTIONS, options);\n  },\n};\n\n/**\n * Creates a shared `useStream` instance and provides it to all descendant\n * components via Vue's `provide`/`inject`.\n *\n * Call this in a parent component's `<script setup>` to make the stream\n * available to children via `useStreamContext()`.\n *\n * @example\n * ```vue\n * <!-- ChatContainer.vue -->\n * <script setup lang=\"ts\">\n * import { provideStream } from \"@langchain/vue\";\n *\n * provideStream({ assistantId: \"agent\", apiUrl: \"http://localhost:2024\" });\n * </script>\n *\n * <template>\n *   <ChatHeader />\n *   <MessageList />\n *   <MessageInput />\n * </template>\n * ```\n *\n * @returns The stream instance (same as calling `useStream` directly).\n */\nexport function provideStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: Parameters<typeof useStream>[0]\n): ReturnType<typeof useStream<T, InterruptType, ConfigurableType>> {\n  const stream = useStream<T, InterruptType, ConfigurableType>(\n    // The context helper is a thin pass-through; keep its generic surface\n    // aligned with useStream without re-deriving the overload input type.\n    options as Parameters<\n      typeof useStream<T, InterruptType, ConfigurableType>\n    >[0]\n  );\n  provide(STREAM_CONTEXT_KEY, stream);\n  return stream;\n}\n\n/**\n * Accesses the shared stream instance from the nearest ancestor that\n * called `provideStream()`.\n *\n * Throws if no ancestor has provided a stream.\n *\n * @example\n * ```vue\n * <!-- MessageList.vue -->\n * <script setup lang=\"ts\">\n * import { useStreamContext } from \"@langchain/vue\";\n *\n * const { messages } = useStreamContext();\n * </script>\n *\n * <template>\n *   <div v-for=\"(msg, i) in messages.value\" :key=\"msg.id ?? i\">\n *     {{ msg.content }}\n *   </div>\n * </template>\n * ```\n *\n * @example With type parameters for full type safety:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStreamContext } from \"@langchain/vue\";\n * import type { agent } from \"./agent\";\n *\n * const { toolCalls } = useStreamContext<typeof agent>();\n * </script>\n * ```\n */\nexport function useStreamContext<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(): ReturnType<typeof useStream<T, InterruptType, ConfigurableType>> {\n  const context = inject(STREAM_CONTEXT_KEY);\n  if (context == null) {\n    throw new Error(\n      \"useStreamContext() requires a parent component to call provideStream(). \" +\n        \"Add provideStream({ assistantId: '...' }) in an ancestor component.\"\n    );\n  }\n  return context;\n}\n"],"mappings":";;;AAkBA,MAAM,qBAAwC,OAAO,mBAAmB;AAExE,MAAa,oBACX,OAAO,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgC7B,MAAa,kBAAqD,EAChE,QAAQ,KAAU,UAAkC,EAAE,EAAE;AACtD,KAAI,QAAQ,mBAAmB,QAAQ;GAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,SAAgB,cAKd,SACkE;CAClE,MAAM,SAASA,mBAAAA,UAGb,QAGD;AACD,EAAA,GAAA,IAAA,SAAQ,oBAAoB,OAAO;AACnC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCT,SAAgB,mBAIsD;CACpE,MAAM,WAAA,GAAA,IAAA,QAAiB,mBAAmB;AAC1C,KAAI,WAAW,KACb,OAAM,IAAI,MACR,8IAED;AAEH,QAAO"}

package/dist/context.d.cts

@@ -1,7 +1,6 @@
-import { useStream } from "./index.cjs";
+import { useStream } from "./use-stream.cjs";
 import { InjectionKey, Plugin } from "vue";
-import { InferBag, InferStateType, ResolveStreamOptions, UseStreamCustomOptions } from "@langchain/langgraph-sdk/ui";
-import { BagTemplate, Client } from "@langchain/langgraph-sdk";
+import { Client } from "@langchain/langgraph-sdk";
 
 //#region src/context.d.ts
 /**
@@ -73,7 +72,7 @@ declare const LangChainPlugin: Plugin<[LangChainPluginOptions?]>;
  *
  * @returns The stream instance (same as calling `useStream` directly).
  */
-declare function provideStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>> | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): ReturnType<typeof useStream<T, Bag>>;
+declare function provideStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: Parameters<typeof useStream>[0]): ReturnType<typeof useStream<T, InterruptType, ConfigurableType>>;
 /**
  * Accesses the shared stream instance from the nearest ancestor that
  * called `provideStream()`.
@@ -106,7 +105,7 @@ declare function provideStream<T = Record<string, unknown>, Bag extends BagTempl
  * </script>
  * ```
  */
-declare function useStreamContext<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): ReturnType<typeof useStream<T, Bag>>;
+declare function useStreamContext<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(): ReturnType<typeof useStream<T, InterruptType, ConfigurableType>>;
 //#endregion
 export { LANGCHAIN_OPTIONS, LangChainPlugin, LangChainPluginOptions, provideStream, useStreamContext };
 //# sourceMappingURL=context.d.cts.map

package/dist/context.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.cts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;AAeA;;;UAAiB,sBAAA;EAEf;EAAA,MAAA;EAIA;EAFA,MAAA;EAEe;EAAf,MAAA,GAAS,MAAA;AAAA;AAAA,cAME,iBAAA,EAAmB,YAAA,CAAa,sBAAA;;;;AAiC7C;;;;;AA+BA;;;;;;;;;;;;;;;;;;;;;;cA/Ba,eAAA,EAAiB,MAAA,EAAQ,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;AA6EtC;;iBA9CgB,aAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EACI,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KACpC,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA,KACzD,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuClB,gBAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAAA,GACvB,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,GAAA"}
+{"version":3,"file":"context.d.cts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;AAQA;;UAAiB,sBAAA;EAMA;EAJf,MAAA;EAEA;EAAA,MAAA;EAES;EAAT,MAAA,GAAS,MAAA;AAAA;AAAA,cAME,iBAAA,EAAmB,YAAA,CAAa,sBAAA;;;;;AAiC7C;;;;;AA+BA;;;;;;;;;;;;;;;;;;;;;cA/Ba,eAAA,EAAiB,MAAA,EAAQ,sBAAA;;;;;;;;AAiFtC;;;;;;;;;;;;;;;;;;iBAlDgB,aAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,UAAA,QAAkB,SAAA,OAC1B,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CjC,gBAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAAA,GAC/B,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/context.d.ts

@@ -1,7 +1,6 @@
-import { useStream } from "./index.js";
+import { useStream } from "./use-stream.js";
 import { InjectionKey, Plugin } from "vue";
-import { InferBag, InferStateType, ResolveStreamOptions, UseStreamCustomOptions } from "@langchain/langgraph-sdk/ui";
-import { BagTemplate, Client } from "@langchain/langgraph-sdk";
+import { Client } from "@langchain/langgraph-sdk";
 
 //#region src/context.d.ts
 /**
@@ -73,7 +72,7 @@ declare const LangChainPlugin: Plugin<[LangChainPluginOptions?]>;
  *
  * @returns The stream instance (same as calling `useStream` directly).
  */
-declare function provideStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>> | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): ReturnType<typeof useStream<T, Bag>>;
+declare function provideStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: Parameters<typeof useStream>[0]): ReturnType<typeof useStream<T, InterruptType, ConfigurableType>>;
 /**
  * Accesses the shared stream instance from the nearest ancestor that
  * called `provideStream()`.
@@ -106,7 +105,7 @@ declare function provideStream<T = Record<string, unknown>, Bag extends BagTempl
  * </script>
  * ```
  */
-declare function useStreamContext<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): ReturnType<typeof useStream<T, Bag>>;
+declare function useStreamContext<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(): ReturnType<typeof useStream<T, InterruptType, ConfigurableType>>;
 //#endregion
 export { LANGCHAIN_OPTIONS, LangChainPlugin, LangChainPluginOptions, provideStream, useStreamContext };
 //# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;AAeA;;;UAAiB,sBAAA;EAEf;EAAA,MAAA;EAIA;EAFA,MAAA;EAEe;EAAf,MAAA,GAAS,MAAA;AAAA;AAAA,cAME,iBAAA,EAAmB,YAAA,CAAa,sBAAA;;;;AAiC7C;;;;;AA+BA;;;;;;;;;;;;;;;;;;;;;;cA/Ba,eAAA,EAAiB,MAAA,EAAQ,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;AA6EtC;;iBA9CgB,aAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EACI,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KACpC,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA,KACzD,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuClB,gBAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAAA,GACvB,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,GAAA"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;AAQA;;UAAiB,sBAAA;EAMA;EAJf,MAAA;EAEA;EAAA,MAAA;EAES;EAAT,MAAA,GAAS,MAAA;AAAA;AAAA,cAME,iBAAA,EAAmB,YAAA,CAAa,sBAAA;;;;;AAiC7C;;;;;AA+BA;;;;;;;;;;;;;;;;;;;;;cA/Ba,eAAA,EAAiB,MAAA,EAAQ,sBAAA;;;;;;;;AAiFtC;;;;;;;;;;;;;;;;;;iBAlDgB,aAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,UAAA,QAAkB,SAAA,OAC1B,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CjC,gBAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAAA,GAC/B,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/context.js

@@ -1,4 +1,4 @@
-import { useStream } from "./index.js";
+import { useStream } from "./use-stream.js";
 import { inject, provide } from "vue";
 //#region src/context.ts
 const STREAM_CONTEXT_KEY = Symbol("langchain-stream");

package/dist/context.js.map

@@ -1 +1 @@
-{"version":3,"file":"context.js","names":[],"sources":["../src/context.ts"],"sourcesContent":["import { provide, inject, type InjectionKey, type App, type Plugin } from \"vue\";\nimport type { BagTemplate } from \"@langchain/langgraph-sdk\";\nimport type {\n  ResolveStreamOptions,\n  InferBag,\n  InferStateType,\n  UseStreamCustomOptions,\n} from \"@langchain/langgraph-sdk/ui\";\nimport { Client } from \"@langchain/langgraph-sdk\";\nimport { useStream } from \"./index.js\";\n\n/**\n * Configuration options for the LangChain Vue plugin.\n * These provide default values that `useStream` will pick up automatically.\n */\nexport interface LangChainPluginOptions {\n  /** Base URL of the LangGraph API. */\n  apiUrl?: string;\n  /** API key for authenticating with the LangGraph API. */\n  apiKey?: string;\n  /** Pre-configured Client instance. */\n  client?: Client;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst STREAM_CONTEXT_KEY: InjectionKey<any> = Symbol(\"langchain-stream\");\n\nexport const LANGCHAIN_OPTIONS: InjectionKey<LangChainPluginOptions> =\n  Symbol(\"langchain-options\");\n\n/**\n * Vue plugin that provides default LangGraph configuration to all components.\n *\n * When installed, `useStream` composables throughout the application will\n * automatically use the configured `apiUrl` and `client` without requiring\n * explicit options.\n *\n * @example\n * ```typescript\n * import { createApp } from \"vue\";\n * import { LangChainPlugin } from \"@langchain/vue\";\n * import App from \"./App.vue\";\n *\n * const app = createApp(App);\n * app.use(LangChainPlugin, {\n *   apiUrl: \"http://localhost:2024\",\n * });\n * app.mount(\"#app\");\n * ```\n *\n * Then in any component:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * // apiUrl is inherited from the plugin — no need to repeat it\n * const stream = useStream({ assistantId: \"agent\" });\n * </script>\n * ```\n */\nexport const LangChainPlugin: Plugin<[LangChainPluginOptions?]> = {\n  install(app: App, options: LangChainPluginOptions = {}) {\n    app.provide(LANGCHAIN_OPTIONS, options);\n  },\n};\n\n/**\n * Creates a shared `useStream` instance and provides it to all descendant\n * components via Vue's `provide`/`inject`.\n *\n * Call this in a parent component's `<script setup>` to make the stream\n * available to children via `useStreamContext()`.\n *\n * @example\n * ```vue\n * <!-- ChatContainer.vue -->\n * <script setup lang=\"ts\">\n * import { provideStream } from \"@langchain/vue\";\n *\n * provideStream({ assistantId: \"agent\", apiUrl: \"http://localhost:2024\" });\n * </script>\n *\n * <template>\n *   <ChatHeader />\n *   <MessageList />\n *   <MessageInput />\n * </template>\n * ```\n *\n * @returns The stream instance (same as calling `useStream` directly).\n */\nexport function provideStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options:\n    | ResolveStreamOptions<T, InferBag<T, Bag>>\n    | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): ReturnType<typeof useStream<T, Bag>> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const stream = useStream<T, Bag>(options as any);\n  provide(STREAM_CONTEXT_KEY, stream);\n  return stream;\n}\n\n/**\n * Accesses the shared stream instance from the nearest ancestor that\n * called `provideStream()`.\n *\n * Throws if no ancestor has provided a stream.\n *\n * @example\n * ```vue\n * <!-- MessageList.vue -->\n * <script setup lang=\"ts\">\n * import { useStreamContext } from \"@langchain/vue\";\n *\n * const { messages } = useStreamContext();\n * </script>\n *\n * <template>\n *   <div v-for=\"(msg, i) in messages.value\" :key=\"msg.id ?? i\">\n *     {{ msg.content }}\n *   </div>\n * </template>\n * ```\n *\n * @example With type parameters for full type safety:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStreamContext } from \"@langchain/vue\";\n * import type { agent } from \"./agent\";\n *\n * const { toolCalls } = useStreamContext<typeof agent>();\n * </script>\n * ```\n */\nexport function useStreamContext<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): ReturnType<typeof useStream<T, Bag>> {\n  const context = inject(STREAM_CONTEXT_KEY);\n  if (context == null) {\n    throw new Error(\n      \"useStreamContext() requires a parent component to call provideStream(). \" +\n        \"Add provideStream({ assistantId: '...' }) in an ancestor component.\"\n    );\n  }\n  return context;\n}\n"],"mappings":";;;AAyBA,MAAM,qBAAwC,OAAO,mBAAmB;AAExE,MAAa,oBACX,OAAO,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgC7B,MAAa,kBAAqD,EAChE,QAAQ,KAAU,UAAkC,EAAE,EAAE;AACtD,KAAI,QAAQ,mBAAmB,QAAQ;GAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,SAAgB,cAId,SAGsC;CAEtC,MAAM,SAAS,UAAkB,QAAe;AAChD,SAAQ,oBAAoB,OAAO;AACnC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCT,SAAgB,mBAG0B;CACxC,MAAM,UAAU,OAAO,mBAAmB;AAC1C,KAAI,WAAW,KACb,OAAM,IAAI,MACR,8IAED;AAEH,QAAO"}
+{"version":3,"file":"context.js","names":[],"sources":["../src/context.ts"],"sourcesContent":["import { provide, inject, type InjectionKey, type App, type Plugin } from \"vue\";\nimport { Client } from \"@langchain/langgraph-sdk\";\nimport { useStream } from \"./use-stream.js\";\n\n/**\n * Configuration options for the LangChain Vue plugin.\n * These provide default values that `useStream` will pick up automatically.\n */\nexport interface LangChainPluginOptions {\n  /** Base URL of the LangGraph API. */\n  apiUrl?: string;\n  /** API key for authenticating with the LangGraph API. */\n  apiKey?: string;\n  /** Pre-configured Client instance. */\n  client?: Client;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst STREAM_CONTEXT_KEY: InjectionKey<any> = Symbol(\"langchain-stream\");\n\nexport const LANGCHAIN_OPTIONS: InjectionKey<LangChainPluginOptions> =\n  Symbol(\"langchain-options\");\n\n/**\n * Vue plugin that provides default LangGraph configuration to all components.\n *\n * When installed, `useStream` composables throughout the application will\n * automatically use the configured `apiUrl` and `client` without requiring\n * explicit options.\n *\n * @example\n * ```typescript\n * import { createApp } from \"vue\";\n * import { LangChainPlugin } from \"@langchain/vue\";\n * import App from \"./App.vue\";\n *\n * const app = createApp(App);\n * app.use(LangChainPlugin, {\n *   apiUrl: \"http://localhost:2024\",\n * });\n * app.mount(\"#app\");\n * ```\n *\n * Then in any component:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * // apiUrl is inherited from the plugin — no need to repeat it\n * const stream = useStream({ assistantId: \"agent\" });\n * </script>\n * ```\n */\nexport const LangChainPlugin: Plugin<[LangChainPluginOptions?]> = {\n  install(app: App, options: LangChainPluginOptions = {}) {\n    app.provide(LANGCHAIN_OPTIONS, options);\n  },\n};\n\n/**\n * Creates a shared `useStream` instance and provides it to all descendant\n * components via Vue's `provide`/`inject`.\n *\n * Call this in a parent component's `<script setup>` to make the stream\n * available to children via `useStreamContext()`.\n *\n * @example\n * ```vue\n * <!-- ChatContainer.vue -->\n * <script setup lang=\"ts\">\n * import { provideStream } from \"@langchain/vue\";\n *\n * provideStream({ assistantId: \"agent\", apiUrl: \"http://localhost:2024\" });\n * </script>\n *\n * <template>\n *   <ChatHeader />\n *   <MessageList />\n *   <MessageInput />\n * </template>\n * ```\n *\n * @returns The stream instance (same as calling `useStream` directly).\n */\nexport function provideStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: Parameters<typeof useStream>[0]\n): ReturnType<typeof useStream<T, InterruptType, ConfigurableType>> {\n  const stream = useStream<T, InterruptType, ConfigurableType>(\n    // The context helper is a thin pass-through; keep its generic surface\n    // aligned with useStream without re-deriving the overload input type.\n    options as Parameters<\n      typeof useStream<T, InterruptType, ConfigurableType>\n    >[0]\n  );\n  provide(STREAM_CONTEXT_KEY, stream);\n  return stream;\n}\n\n/**\n * Accesses the shared stream instance from the nearest ancestor that\n * called `provideStream()`.\n *\n * Throws if no ancestor has provided a stream.\n *\n * @example\n * ```vue\n * <!-- MessageList.vue -->\n * <script setup lang=\"ts\">\n * import { useStreamContext } from \"@langchain/vue\";\n *\n * const { messages } = useStreamContext();\n * </script>\n *\n * <template>\n *   <div v-for=\"(msg, i) in messages.value\" :key=\"msg.id ?? i\">\n *     {{ msg.content }}\n *   </div>\n * </template>\n * ```\n *\n * @example With type parameters for full type safety:\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStreamContext } from \"@langchain/vue\";\n * import type { agent } from \"./agent\";\n *\n * const { toolCalls } = useStreamContext<typeof agent>();\n * </script>\n * ```\n */\nexport function useStreamContext<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(): ReturnType<typeof useStream<T, InterruptType, ConfigurableType>> {\n  const context = inject(STREAM_CONTEXT_KEY);\n  if (context == null) {\n    throw new Error(\n      \"useStreamContext() requires a parent component to call provideStream(). \" +\n        \"Add provideStream({ assistantId: '...' }) in an ancestor component.\"\n    );\n  }\n  return context;\n}\n"],"mappings":";;;AAkBA,MAAM,qBAAwC,OAAO,mBAAmB;AAExE,MAAa,oBACX,OAAO,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgC7B,MAAa,kBAAqD,EAChE,QAAQ,KAAU,UAAkC,EAAE,EAAE;AACtD,KAAI,QAAQ,mBAAmB,QAAQ;GAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,SAAgB,cAKd,SACkE;CAClE,MAAM,SAAS,UAGb,QAGD;AACD,SAAQ,oBAAoB,OAAO;AACnC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCT,SAAgB,mBAIsD;CACpE,MAAM,UAAU,OAAO,mBAAmB;AAC1C,KAAI,WAAW,KACb,OAAM,IAAI,MACR,8IAED;AAEH,QAAO"}