@langchain/svelte 0.4.7 → 1.0.0

package/README.md

@@ -1,6 +1,8 @@
 # @langchain/svelte
 
-Svelte 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` function that manages streaming, state, branching, and interrupts with a Svelte 5 runes-compatible reactive API.
+Svelte 5 SDK for [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).
+
+`useStream` binds a LangGraph agent into a Svelte 5 component. Reactive fields are exposed as getters on a stable handle (`stream.messages`, `stream.isLoading`, …) so templates and `$derived` expressions track updates automatically — no stores, no `$` prefix, no destructuring.
 
 ## Installation
 
@@ -8,157 +10,9 @@ Svelte SDK for building AI-powered applications with [Deep Agents](https://docs.
 npm install @langchain/svelte @langchain/core
 ```
 
-**Peer dependencies:** `svelte` (^5.0.0), `@langchain/core` (^1.0.1)
-
-## Quick Start
-
-```svelte
-<script lang="ts">
-  import { useStream } from "@langchain/svelte";
-
-  const stream = useStream({
-    assistantId: "agent",
-    apiUrl: "http://localhost:2024",
-  });
-</script>
-
-<div>
-  {#each stream.messages as msg, i (msg.id ?? i)}
-    <div>{msg.content}</div>
-  {/each}
-
-  <button
-    disabled={stream.isLoading}
-    onclick={() =>
-      void stream.submit({ messages: [{ type: "human", content: "Hello!" }] })}
-  >
-    Send
-  </button>
-</div>
-```
-
-All reactive properties (`messages`, `isLoading`, `values`, etc.) are accessed directly on the returned object — no `$` prefix needed. Avoid destructuring reactive properties; use `stream.messages` instead of `const { messages } = stream` to keep reactivity intact.
-
-## `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 exposed as getters on the returned object. They update automatically and can be read directly in Svelte 5 templates without the `$` prefix.
-
-| Property | Type | Description |
-|---|---|---|
-| `values` | `StateType` | Current graph state. |
-| `messages` | `BaseMessage[]` | Messages from the current state. |
-| `isLoading` | `boolean` | Whether a stream is currently active. |
-| `error` | `unknown` | The most recent error, if any. |
-| `interrupt` | `Interrupt \| undefined` | Current interrupt requiring user input. |
-| `branch` | `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:
-
-```svelte
-<script lang="ts">
-  import { useStream } from "@langchain/svelte";
-  import type { BaseMessage } from "langchain";
-
-  interface MyState {
-    messages: BaseMessage[];
-    context?: string;
-  }
-
-  const stream = useStream<MyState>({
-    assistantId: "my-graph",
-    apiUrl: "http://localhost:2024",
-  });
-</script>
-```
-
-### Typed Interrupts
-
-```svelte
-<script lang="ts">
-  import { useStream } from "@langchain/svelte";
-  import type { BaseMessage } from "langchain";
-
-  const stream = useStream<
-    { messages: BaseMessage[] },
-    { InterruptType: { question: string } }
-  >({
-    assistantId: "my-graph",
-    apiUrl: "http://localhost:2024",
-  });
-</script>
-```
-
-## Handling Interrupts
-
-```svelte
-<script lang="ts">
-  import { useStream } from "@langchain/svelte";
-  import type { BaseMessage } from "langchain";
-
-  const stream = useStream<
-    { messages: BaseMessage[] },
-    { InterruptType: { question: string } }
-  >({
-    assistantId: "agent",
-    apiUrl: "http://localhost:2024",
-  });
-</script>
-
-<div>
-  {#each stream.messages as msg, i (msg.id ?? i)}
-    <div>{msg.content}</div>
-  {/each}
-
-  {#if stream.interrupt}
-    <div>
-      <p>{stream.interrupt.value.question}</p>
-      <button onclick={() => void stream.submit(null, { command: { resume: "Approved" } })}>
-        Approve
-      </button>
-    </div>
-  {/if}
-
-  <button
-    onclick={() =>
-      void stream.submit({ messages: [{ type: "human", content: "Hello" }] })}
-  >
-    Send
-  </button>
-</div>
-```
-
-## Branching
+**Peer dependencies:** `svelte` ^5.0.0, `@langchain/core` ^1.0.1
 
-Enable conversation branching with `fetchStateHistory: true`:
+## Quick start
 
 ```svelte
 <script lang="ts">
@@ -167,316 +21,56 @@ Enable conversation branching with `fetchStateHistory: true`:
   const stream = useStream({
     assistantId: "agent",
     apiUrl: "http://localhost:2024",
-    fetchStateHistory: true,
   });
 </script>
 
-<div>
-  {#each stream.messages as msg, i (msg.id ?? i)}
-    {@const metadata = stream.getMessagesMetadata(msg, i)}
-    {@const branchOptions = metadata?.branchOptions}
-    {@const currentBranch = metadata?.branch}
-
-    <div>
-      <p>{msg.content}</p>
-
-      {#if branchOptions && currentBranch}
-        <button onclick={() => {
-          const prev = branchOptions[branchOptions.indexOf(currentBranch) - 1];
-          if (prev) stream.setBranch(prev);
-        }}>
-          Previous
-        </button>
-        <span>
-          {branchOptions.indexOf(currentBranch) + 1} / {branchOptions.length}
-        </span>
-        <button onclick={() => {
-          const next = branchOptions[branchOptions.indexOf(currentBranch) + 1];
-          if (next) stream.setBranch(next);
-        }}>
-          Next
-        </button>
-      {/if}
-    </div>
-  {/each}
-
-  <button
-    onclick={() =>
-      void stream.submit({ messages: [{ type: "human", content: "Hello" }] })}
-  >
-    Send
-  </button>
-</div>
-```
-
-## 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:
-
-```svelte
-<script lang="ts">
-  import { useStream } from "@langchain/svelte";
-
-  const stream = useStream({
-    assistantId: "agent",
-    apiUrl: "http://localhost:2024",
-  });
-</script>
-
-<div>
-  {#each stream.messages as msg, i (msg.id ?? i)}
-    <div>{msg.content}</div>
-  {/each}
-
-  {#if stream.queue.size > 0}
-    <div>
-      <p>{stream.queue.size} message(s) queued</p>
-      <button onclick={() => void stream.queue.clear()}>Clear Queue</button>
-    </div>
-  {/if}
-
-  <button
-    disabled={stream.isLoading}
-    onclick={() =>
-      void stream.submit({ messages: [{ type: "human", content: "Hello!" }] })}
-  >
-    Send
-  </button>
-  <button onclick={() => stream.switchThread(null)}>New Thread</button>
-</div>
-```
-
-Switching threads via `switchThread()` cancels all pending runs and clears the queue.
-
-## Stream Context
-
-Use `setStreamContext` and `getStreamContext` to share a single `useStream` instance across a component tree without prop drilling. This uses Svelte's built-in `setContext` / `getContext` under the hood.
-
-### Setting context in a parent
-
-Call `setStreamContext` during component initialisation to provide the stream to all descendants:
-
-```svelte
-<script lang="ts">
-  import { useStream, setStreamContext } from "@langchain/svelte";
-  import ChatMessages from "./ChatMessages.svelte";
-  import ChatInput from "./ChatInput.svelte";
-
-  const stream = useStream({
-    assistantId: "agent",
-    apiUrl: "http://localhost:2024",
-  });
-
-  setStreamContext(stream);
-</script>
-
-<ChatMessages />
-<ChatInput />
-```
-
-### Consuming context in a child
-
-Call `getStreamContext` in any descendant to retrieve the stream. The returned value has the same shape and types as the `useStream` return value:
-
-```svelte
-<script lang="ts">
-  import { getStreamContext } from "@langchain/svelte";
-
-  const stream = getStreamContext();
-</script>
-
-{#each stream.messages as msg, i (msg.id ?? i)}
-  <div>{msg.content}</div>
-{/each}
-
-{#if stream.isLoading}
-  <p>Thinking…</p>
-{/if}
-```
-
-```svelte
-<script lang="ts">
-  import { getStreamContext } from "@langchain/svelte";
-
-  const stream = getStreamContext();
-
-  let input = $state("");
-</script>
-
-<form onsubmit={(e) => { e.preventDefault(); void stream.submit({ messages: [{ type: "human", content: input }] }); input = ""; }}>
-  <input bind:value={input} />
-  <button type="submit">Send</button>
-</form>
-```
-
-### Type safety
-
-`getStreamContext` accepts the same generic parameters as `useStream` so child components can be fully typed:
-
-```svelte
-<script lang="ts">
-  import { getStreamContext } from "@langchain/svelte";
-  import type { BaseMessage } from "@langchain/core/messages";
-
-  interface MyState {
-    messages: BaseMessage[];
-    context?: string;
-  }
-
-  const stream = getStreamContext<MyState>();
-</script>
-```
-
-`setStreamContext` returns the stream it was given, so you can inline both calls:
-
-```svelte
-<script lang="ts">
-  import { useStream, setStreamContext } from "@langchain/svelte";
-
-  const stream = setStreamContext(
-    useStream({ assistantId: "agent", apiUrl: "http://localhost:2024" }),
-  );
-</script>
-```
-
-> **Note:** Both functions must be called during component initialisation (i.e. at the top level of a `<script>` block), just like Svelte's own `setContext` / `getContext`. Calling `getStreamContext` without a parent `setStreamContext` throws an error.
-
-## 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:
-
-```svelte
-<script lang="ts">
-  import { useStream, FetchStreamTransport } from "@langchain/svelte";
-  import type { BaseMessage } from "langchain";
-
-  const stream = useStream<{ messages: BaseMessage[] }>({
-    transport: new FetchStreamTransport({
-      url: "https://my-api.example.com/stream",
-    }),
-    threadId: null,
-    onThreadId: (id) => console.log("Thread created:", id),
-  });
-</script>
-
-<div>
-  {#each stream.messages as msg, i (msg.id ?? i)}
-    {@const metadata = stream.getMessagesMetadata(msg, i)}
-    <div>
-      <p>{msg.content}</p>
-      {#if metadata?.streamMetadata}
-        <span>Node: {metadata.streamMetadata.langgraph_node}</span>
-      {/if}
-    </div>
-  {/each}
-
-  <p>Current branch: {stream.branch}</p>
-
-  <button
-    disabled={stream.isLoading}
-    onclick={() =>
-      void stream.submit({ messages: [{ type: "human", content: "Hello!" }] })}
-  >
-    Send
-  </button>
-</div>
-```
-
-The custom transport interface returns the same properties as the standard `useStream` function, 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 `getStream` to share a single stream instance via Svelte's context API:
-
-```svelte
-<!-- ChatContainer.svelte -->
-<script lang="ts">
-  import { provideStream } from "@langchain/svelte";
-  import ChatHeader from "./ChatHeader.svelte";
-  import MessageList from "./MessageList.svelte";
-  import MessageInput from "./MessageInput.svelte";
-
-  provideStream({
-    assistantId: "agent",
-    apiUrl: "http://localhost:2024",
-  });
-</script>
-
-<ChatHeader />
-<MessageList />
-<MessageInput />
-```
-
-```svelte
-<!-- MessageList.svelte -->
-<script lang="ts">
-  import { getStream } from "@langchain/svelte";
-
-  const stream = getStream();
-</script>
-
 {#each stream.messages as msg (msg.id)}
   <div>{msg.content}</div>
 {/each}
-```
-
-```svelte
-<!-- MessageInput.svelte -->
-<script lang="ts">
-  import { getStream } from "@langchain/svelte";
-
-  const stream = getStream();
-  let input = $state("");
 
-  function send() {
-    stream.submit({ messages: [{ type: "human", content: input }] });
-    input = "";
-  }
-</script>
-
-<form onsubmit={send}>
-  <textarea bind:value={input}></textarea>
-  <button disabled={stream.isLoading} type="submit">Send</button>
-</form>
+<button
+  disabled={stream.isLoading}
+  onclick={() =>
+    stream.submit({ messages: [{ type: "human", content: "Hello!" }] })}
+>
+  Send
+</button>
 ```
 
-```svelte
-<!-- ChatHeader.svelte -->
-<script lang="ts">
-  import { getStream } from "@langchain/svelte";
+> **Note:** Access fields through the live `stream` handle. Destructuring (`const { messages } = stream`) freezes the values at that moment — use `stream.messages` in templates instead.
 
-  const stream = getStream();
-</script>
+## Highlights
 
-<header>
-  <h1>Chat</h1>
-  {#if stream.isLoading}
-    <span>Thinking...</span>
-  {/if}
-  {#if stream.error}
-    <span>Error occurred</span>
-  {/if}
-</header>
-```
+- **v2-native streaming protocol.** Session-based transport with automatic re-attach on remount; no more `reconnectOnMount` / `joinStream` dance.
+- **Always-on root projections.** `values`, `messages`, `toolCalls`, and `interrupts` are reactive at the root with zero extra subscription cost.
+- **Selector composables for scoped data.** Per-subagent / per-subgraph messages, tool calls, and media stream only when a component actually mounts the matching composable, and release on unmount.
+- **Discriminated option bag.** The hosted Agent Server path and the custom-adapter path are two arms of a single typed union — mixing them is a compile-time error.
+- **Reactive `threadId`.** Pass `threadId: () => active` to drive in-place thread swaps without remounting.
+- **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 — plus opinionated playback helpers.
+- **Headless tools.** Register local tool implementations that auto-resolve server-emitted tool-call interrupts without a round-trip through the UI.
 
-### Multiple Agents
+## Documentation
 
-Nest `provideStream` calls for multi-agent scenarios — Svelte's context scoping ensures each subtree gets its own stream:
+In-depth guides live in [`docs/`](./docs/):
 
-```svelte
-<!-- ResearchPanel.svelte -->
-<script lang="ts">
-  import { provideStream } from "@langchain/svelte";
-  provideStream({ assistantId: "researcher", apiUrl: "http://localhost:2024" });
-</script>
+- [`useStream` — options, return shape, reactive `threadId`](./docs/use-stream.md)
+- [Selector composables (`useMessages`, `useToolCalls`, `useValues`, …)](./docs/selector-composables.md)
+- [Interrupts, `respond()`, `stop()`, `hydrationPromise`](./docs/interrupts.md)
+- [Submission queue](./docs/submission-queue.md)
+- [Stream context (`provideStream` / `getStream`)](./docs/stream-context.md)
+- [Headless tools](./docs/headless-tools.md)
+- [Custom transport (`AgentServerAdapter`, `HttpAgentServerAdapter`)](./docs/custom-transport.md)
+- [Media (images, audio, video, files) & playback helpers](./docs/media.md)
+- [Type safety](./docs/type-safety.md)
 
-<MessageList />
-<MessageInput />
-```
+## Migrating from v0
+
+`@langchain/svelte` **v1** targets the v2 streaming protocol. The `useStream` import stays the same, but the option bag, return shape, and how you subscribe to scoped data all change. Most chat apps migrate in well under an hour — the full guide with line-by-line diffs lives in [`docs/v1-migration.md`](./docs/v1-migration.md).
 
 ## Playground
 
-For complete end-to-end examples with full agentic UIs, visit the [LangChain UI Playground](https://docs.langchain.com/playground).
+For full end-to-end examples, see the [LangChain UI Playground](https://docs.langchain.com/playground).
 
 ## License
 

package/dist/context.cjs

@@ -0,0 +1,72 @@
+const require_use_stream_svelte = require("./use-stream.svelte.cjs");
+let svelte = require("svelte");
+//#region src/context.ts
+/**
+* Context key used for the shared stream handle exposed via
+* {@link provideStream}. Exported so advanced callers can drive
+* Svelte's context API directly (e.g. a shared context in a
+* microfrontend shell).
+*/
+const STREAM_CONTEXT_KEY = Symbol.for("@langchain/svelte/stream-context");
+/**
+* Creates a shared {@link useStream} handle and publishes it via
+* Svelte's `setContext`. Descendant components read it via
+* {@link getStream}.
+*
+* Must be called during component initialisation (the top level of a
+* `<script>` block or `<script module>` that runs at mount), same
+* lifecycle constraint as `setContext`.
+*
+* @example
+* ```svelte
+* <!-- ChatContainer.svelte -->
+* <script lang="ts">
+*   import { provideStream } from "@langchain/svelte";
+*
+*   provideStream({
+*     assistantId: "agent",
+*     apiUrl: "http://localhost:2024",
+*   });
+* <\/script>
+*
+* <ChatHeader />
+* <MessageList />
+* <MessageInput />
+* ```
+*/
+function provideStream(options) {
+	const stream = require_use_stream_svelte.useStream(options);
+	(0, svelte.setContext)(STREAM_CONTEXT_KEY, stream);
+	return stream;
+}
+/**
+* Reads the shared stream handle exposed by the nearest ancestor
+* {@link provideStream} call. Throws when no ancestor has provided
+* one.
+*
+* @example
+* ```svelte
+* <!-- MessageList.svelte -->
+* <script lang="ts">
+*   import { getStream } from "@langchain/svelte";
+*   import type { agent } from "./agent";
+*
+*   const stream = getStream<typeof agent>();
+* <\/script>
+*
+* {#each stream.messages as msg (msg.id)}
+*   <div>{msg.content}</div>
+* {/each}
+* ```
+*/
+function getStream() {
+	const context = (0, svelte.getContext)(STREAM_CONTEXT_KEY);
+	if (context == null) throw new Error("getStream() requires a parent component to call provideStream(). Add provideStream({ assistantId: '...' }) in an ancestor component.");
+	return context;
+}
+//#endregion
+exports.STREAM_CONTEXT_KEY = STREAM_CONTEXT_KEY;
+exports.getStream = getStream;
+exports.provideStream = provideStream;
+
+//# sourceMappingURL=context.cjs.map

package/dist/context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.cjs","names":["useStream"],"sources":["../src/context.ts"],"sourcesContent":["import { getContext, setContext } from \"svelte\";\nimport type { InferStateType } from \"@langchain/langgraph-sdk/stream\";\nimport {\n  useStream,\n  type AgentServerOptions,\n  type CustomAdapterOptions,\n  type UseStreamOptions,\n  type UseStreamReturn,\n} from \"./use-stream.svelte.js\";\n\n/**\n * Context key used for the shared stream handle exposed via\n * {@link provideStream}. Exported so advanced callers can drive\n * Svelte's context API directly (e.g. a shared context in a\n * microfrontend shell).\n */\nexport const STREAM_CONTEXT_KEY: unique symbol = Symbol.for(\n  \"@langchain/svelte/stream-context\"\n);\n\n/**\n * Props for {@link provideStream} when talking to the default\n * LangGraph-Platform agent server.\n */\nexport type ProvideStreamProps<T = Record<string, unknown>> =\n  AgentServerOptions<InferStateType<T>>;\n\n/**\n * Props for {@link provideStream} when wiring a custom\n * {@link AgentServerAdapter}.\n */\nexport type ProvideStreamCustomProps<T = Record<string, unknown>> =\n  CustomAdapterOptions<InferStateType<T>>;\n\n/**\n * Creates a shared {@link useStream} handle and publishes it via\n * Svelte's `setContext`. Descendant components read it via\n * {@link getStream}.\n *\n * Must be called during component initialisation (the top level of a\n * `<script>` block or `<script module>` that runs at mount), same\n * lifecycle constraint as `setContext`.\n *\n * @example\n * ```svelte\n * <!-- ChatContainer.svelte -->\n * <script lang=\"ts\">\n *   import { provideStream } from \"@langchain/svelte\";\n *\n *   provideStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n * </script>\n *\n * <ChatHeader />\n * <MessageList />\n * <MessageInput />\n * ```\n */\nexport function provideStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: ProvideStreamProps<T> | ProvideStreamCustomProps<T>\n): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  const stream = useStream<T, InterruptType, ConfigurableType>(\n    options as UseStreamOptions<InferStateType<T>>\n  );\n  setContext(STREAM_CONTEXT_KEY, stream);\n  return stream;\n}\n\n/**\n * Reads the shared stream handle exposed by the nearest ancestor\n * {@link provideStream} call. Throws when no ancestor has provided\n * one.\n *\n * @example\n * ```svelte\n * <!-- MessageList.svelte -->\n * <script lang=\"ts\">\n *   import { getStream } from \"@langchain/svelte\";\n *   import type { agent } from \"./agent\";\n *\n *   const stream = getStream<typeof agent>();\n * </script>\n *\n * {#each stream.messages as msg (msg.id)}\n *   <div>{msg.content}</div>\n * {/each}\n * ```\n */\nexport function getStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  const context = getContext<\n    UseStreamReturn<T, InterruptType, ConfigurableType> | undefined\n  >(STREAM_CONTEXT_KEY);\n  if (context == null) {\n    throw new Error(\n      \"getStream() requires a parent component to call provideStream(). \" +\n        \"Add provideStream({ assistantId: '...' }) in an ancestor component.\"\n    );\n  }\n  return context;\n}\n"],"mappings":";;;;;;;;;AAgBA,MAAa,qBAAoC,OAAO,IACtD,mCACD;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CD,SAAgB,cAKd,SACqD;CACrD,MAAM,SAASA,0BAAAA,UACb,QACD;AACD,EAAA,GAAA,OAAA,YAAW,oBAAoB,OAAO;AACtC,QAAO;;;;;;;;;;;;;;;;;;;;;;AAuBT,SAAgB,YAIyC;CACvD,MAAM,WAAA,GAAA,OAAA,YAEJ,mBAAmB;AACrB,KAAI,WAAW,KACb,OAAM,IAAI,MACR,uIAED;AAEH,QAAO"}

package/dist/context.d.cts

@@ -0,0 +1,72 @@
+import { AgentServerOptions as AgentServerOptions$1, CustomAdapterOptions as CustomAdapterOptions$1, UseStreamReturn } from "./use-stream.svelte.cjs";
+import { InferStateType } from "@langchain/langgraph-sdk/stream";
+
+//#region src/context.d.ts
+/**
+ * Context key used for the shared stream handle exposed via
+ * {@link provideStream}. Exported so advanced callers can drive
+ * Svelte's context API directly (e.g. a shared context in a
+ * microfrontend shell).
+ */
+declare const STREAM_CONTEXT_KEY: unique symbol;
+/**
+ * Props for {@link provideStream} when talking to the default
+ * LangGraph-Platform agent server.
+ */
+type ProvideStreamProps<T = Record<string, unknown>> = AgentServerOptions$1<InferStateType<T>>;
+/**
+ * Props for {@link provideStream} when wiring a custom
+ * {@link AgentServerAdapter}.
+ */
+type ProvideStreamCustomProps<T = Record<string, unknown>> = CustomAdapterOptions$1<InferStateType<T>>;
+/**
+ * Creates a shared {@link useStream} handle and publishes it via
+ * Svelte's `setContext`. Descendant components read it via
+ * {@link getStream}.
+ *
+ * Must be called during component initialisation (the top level of a
+ * `<script>` block or `<script module>` that runs at mount), same
+ * lifecycle constraint as `setContext`.
+ *
+ * @example
+ * ```svelte
+ * <!-- ChatContainer.svelte -->
+ * <script lang="ts">
+ *   import { provideStream } from "@langchain/svelte";
+ *
+ *   provideStream({
+ *     assistantId: "agent",
+ *     apiUrl: "http://localhost:2024",
+ *   });
+ * </script>
+ *
+ * <ChatHeader />
+ * <MessageList />
+ * <MessageInput />
+ * ```
+ */
+declare function provideStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: ProvideStreamProps<T> | ProvideStreamCustomProps<T>): UseStreamReturn<T, InterruptType, ConfigurableType>;
+/**
+ * Reads the shared stream handle exposed by the nearest ancestor
+ * {@link provideStream} call. Throws when no ancestor has provided
+ * one.
+ *
+ * @example
+ * ```svelte
+ * <!-- MessageList.svelte -->
+ * <script lang="ts">
+ *   import { getStream } from "@langchain/svelte";
+ *   import type { agent } from "./agent";
+ *
+ *   const stream = getStream<typeof agent>();
+ * </script>
+ *
+ * {#each stream.messages as msg (msg.id)}
+ *   <div>{msg.content}</div>
+ * {/each}
+ * ```
+ */
+declare function getStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(): UseStreamReturn<T, InterruptType, ConfigurableType>;
+//#endregion
+export { ProvideStreamCustomProps, ProvideStreamProps, STREAM_CONTEXT_KEY, getStream, provideStream };
+//# sourceMappingURL=context.d.cts.map

package/dist/context.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.cts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;AAgBA;;;;cAAa,kBAAA;AAQb;;;;AAAA,KAAY,kBAAA,KAAuB,MAAA,qBACjC,oBAAA,CAAmB,cAAA,CAAe,CAAA;;;;;KAMxB,wBAAA,KAA6B,MAAA,qBACvC,sBAAA,CAAqB,cAAA,CAAe,CAAA;;;;;;;AADtC;;;;;;;;;;;;;;;;AA6BA;;;;iBAAgB,aAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,wBAAA,CAAyB,CAAA,IACzD,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;;;;;;;;;;;;;;;;;;iBA4BrB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAAA,GAC/B,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}