@tanstack/ai-svelte 0.15.0 → 0.16.0

package/README.md

@@ -1,3 +1,20 @@
+<div align="center">
+  <picture>
+    <source
+      media="(prefers-color-scheme: dark)"
+      srcset="https://tanstack.com/api/readme/ai.png?framework=svelte&theme=dark"
+    />
+    <source
+      media="(prefers-color-scheme: light)"
+      srcset="https://tanstack.com/api/readme/ai.png?framework=svelte"
+    />
+    <img
+      src="https://tanstack.com/api/readme/ai.png?framework=svelte"
+      alt="TanStack Svelte AI"
+      width="900"
+    />
+  </picture>
+</div>
 # @tanstack/ai-svelte
 
 Svelte bindings for TanStack AI.

package/dist/create-chat.svelte.js

@@ -1,5 +1,8 @@
 import { ChatClient } from '@tanstack/ai-client';
 import { createChatDevtoolsBridge } from '@tanstack/ai-client/devtools';
+import { onMount } from 'svelte';
+const EMPTY_INTERRUPTS = Object.freeze([]);
+const EMPTY_INTERRUPT_ERRORS = Object.freeze([]);
 /**
  * Creates a reactive chat instance for Svelte 5.
  *
@@ -31,9 +34,6 @@ import { createChatDevtoolsBridge } from '@tanstack/ai-client/devtools';
  * ```
  */
 export function createChat(options) {
-    // Generate a unique ID for this chat instance
-    const clientId = options.id ||
-        `chat-${Date.now()}-${Math.random().toString(36).substring(7)}`;
     // Create reactive state using Svelte 5 runes
     let messages = $state(options.initialMessages || []);
     let isLoading = $state(false);
@@ -43,6 +43,13 @@ export function createChat(options) {
     let connectionStatus = $state('disconnected');
     let sessionGenerating = $state(false);
     let queue = $state([]);
+    let runId = $state(null);
+    let interruptState = $state.raw({
+        interrupts: EMPTY_INTERRUPTS,
+        pendingInterrupts: EMPTY_INTERRUPTS,
+        interruptErrors: EMPTY_INTERRUPT_ERRORS,
+        resuming: false,
+    });
     // Create ChatClient instance.
     // Note: Svelte's createChat runs once per instance and `options` is captured
     // by reference. Callbacks are therefore frozen to whatever the caller passed
@@ -56,16 +63,21 @@ export function createChat(options) {
     const transport = options.connection
         ? { connection: options.connection }
         : { fetcher: options.fetcher };
+    // The hook's identity is its `threadId`, which ChatClient also uses as the
+    // persistence key — no separate `id`. When no `threadId` is given the client
+    // generates one, so an ephemeral chat still works but is not restored on reload.
     const client = new ChatClient({
         devtoolsBridgeFactory: createChatDevtoolsBridge,
         ...transport,
-        id: clientId,
         ...(options.initialMessages !== undefined && {
             initialMessages: options.initialMessages,
         }),
         ...(options.persistence !== undefined && {
             persistence: options.persistence,
         }),
+        ...(options.initialResumeSnapshot !== undefined && {
+            initialResumeSnapshot: options.initialResumeSnapshot,
+        }),
         ...(options.body !== undefined && { body: options.body }),
         ...(options.threadId !== undefined && { threadId: options.threadId }),
         ...(options.forwardedProps !== undefined && {
@@ -100,6 +112,7 @@ export function createChat(options) {
         },
         onLoadingChange: (newIsLoading) => {
             isLoading = newIsLoading;
+            syncResumeState();
         },
         onStatusChange: (newStatus) => {
             status = newStatus;
@@ -120,26 +133,78 @@ export function createChat(options) {
         onQueueChange: (nextQueue) => {
             queue = nextQueue;
         },
+        onRunIdChange: (nextRunId) => {
+            runId = nextRunId;
+        },
+        onInterruptStateChange: (nextInterruptState) => {
+            interruptState = nextInterruptState;
+            options.onInterruptStateChange?.(nextInterruptState);
+        },
     });
+    function syncResumeState() {
+        runId = client.getCurrentRunId();
+        interruptState = client.getInterruptState();
+    }
     messages = client.getMessages();
+    interruptState = client.getInterruptState();
     if (options.live) {
         client.subscribe();
     }
     client.mountDevtools();
-    // Note: Cleanup is handled by calling stop() directly when needed.
-    // Unlike React/Vue/Solid, Svelte 5 runes like $effect can only be used
-    // during component initialization, so we don't add automatic cleanup here.
-    // Users should call chat.stop() in their component's cleanup if needed.
+    if (typeof window !== 'undefined') {
+        try {
+            onMount(() => {
+                // Delivery-durability resume is transparent: the resumable SSE
+                // connection adapter reattaches via the browser's native
+                // Last-Event-ID on reconnect. We only seed interrupt (state) resume.
+                syncResumeState();
+                client.attach();
+                // ONLY THE VIEW ON SCREEN HOLDS A STREAM. `onMount`'s returned function
+                // runs when the component is destroyed, which is the one automatic
+                // teardown Svelte gives us here — and it is enough, because a connection
+                // is all that must go. A page can own many chats and a browser allows
+                // only ~6 connections per origin, so one long-lived stream per chat
+                // starves every other request once a few views have been open.
+                //
+                // `detach` keeps the transcript and the resume pointer, so re-entering
+                // the view picks the run back up from the durable log.
+                return () => {
+                    client.detach();
+                };
+            });
+        }
+        catch {
+            // Svelte lifecycle hooks are only valid during component initialization.
+        }
+    }
+    // Note: `dispose()` remains manual — it releases devtools and marks the client
+    // dead, which only the owner can decide. The CONNECTION is released
+    // automatically by the `onMount` teardown above.
     // Define methods
     const sendMessage = async (content, sendOptions) => {
-        await client.sendMessage(content, undefined, sendOptions);
+        try {
+            await client.sendMessage(content, undefined, sendOptions);
+        }
+        finally {
+            syncResumeState();
+        }
     };
     const cancelQueued = (id) => client.cancelQueued(id);
     const append = async (message) => {
-        await client.append(message);
+        try {
+            await client.append(message);
+        }
+        finally {
+            syncResumeState();
+        }
     };
     const reload = async () => {
-        await client.reload();
+        try {
+            await client.reload();
+        }
+        finally {
+            syncResumeState();
+        }
     };
     const stop = () => {
         client.stop();
@@ -149,6 +214,7 @@ export function createChat(options) {
     };
     const clear = () => {
         client.clear();
+        syncResumeState();
     };
     const setMessages = (newMessages) => {
         client.setMessagesManually(newMessages);
@@ -158,7 +224,28 @@ export function createChat(options) {
     };
     const addToolApprovalResponse = async (response) => {
         await client.addToolApprovalResponse(response);
+        syncResumeState();
+    };
+    const resumeInterrupts = async (resumeItems, state) => {
+        const result = await client.resumeInterrupts(resumeItems, state);
+        syncResumeState();
+        return result;
+    };
+    const resolveInterrupts = (resolution) => {
+        if (typeof resolution === 'boolean') {
+            client.resolveInterrupts(resolution);
+        }
+        else {
+            client.resolveInterrupts(resolution);
+        }
+    };
+    const cancelInterrupts = () => {
+        client.cancelInterrupts();
     };
+    const retryInterrupts = () => {
+        client.retryInterrupts();
+    };
+    const resumeInterruptsUnsafe = (resumeItems, state) => client.resumeInterruptsUnsafe(resumeItems, state);
     /**
      * @deprecated Use `updateForwardedProps` instead.
      * Both populate the same wire payload.
@@ -209,7 +296,7 @@ export function createChat(options) {
         : null);
     // Return the chat interface with reactive getters
     // Using getters allows Svelte to track reactivity without needing $ prefix
-    // eslint-disable-next-line no-restricted-syntax -- rune return shape diverges from generic CreateChatReturn<TTools, TSchema, TContext> due to TSchema conditional partial/final fields; TS can't structurally narrow.
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- rune return shape diverges from generic CreateChatReturn<TTools, TSchema, TContext> due to TSchema conditional partial/final fields; TS can't structurally narrow.
     return {
         get messages() {
             return messages;
@@ -235,6 +322,21 @@ export function createChat(options) {
         get queue() {
             return queue;
         },
+        get runId() {
+            return runId;
+        },
+        get interrupts() {
+            return interruptState.interrupts;
+        },
+        get pendingInterrupts() {
+            return interruptState.interrupts;
+        },
+        get interruptErrors() {
+            return interruptState.interruptErrors;
+        },
+        get resuming() {
+            return interruptState.resuming;
+        },
         get partial() {
             return partial;
         },
@@ -251,6 +353,11 @@ export function createChat(options) {
         clear,
         addToolResult,
         addToolApprovalResponse,
+        resolveInterrupts,
+        cancelInterrupts,
+        retryInterrupts,
+        resumeInterruptsUnsafe,
+        resumeInterrupts,
         updateBody,
         updateForwardedProps,
         updateContext,

package/dist/create-generate-audio.svelte.d.ts

@@ -1,16 +1,19 @@
+import type { CreateGenerationOptions, CreateGenerationReturn } from './create-generation.svelte';
 import type { AudioGenerationResult, StreamChunk } from '@tanstack/ai';
-import type { AIDevtoolsDisplayOptions, AudioGenerateInput, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, InferGenerationOutputFromReturn } from '@tanstack/ai-client';
+import type { AIDevtoolsDisplayOptions, AudioGenerateInput, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, GenerationPersistenceOptions, InferGenerationOutputFromReturn } from '@tanstack/ai-client';
 /**
  * Options for the createGenerateAudio function.
  *
  * @template TOutput - The output type after optional transform (defaults to AudioGenerationResult)
  */
-export interface CreateGenerateAudioOptions<TOutput = AudioGenerationResult> {
+export interface CreateGenerateAudioOptions<TOutput = AudioGenerationResult> extends Pick<CreateGenerationOptions<AudioGenerateInput, AudioGenerationResult, TOutput>, 'persistence' | 'threadId' | 'hydrateGeneration' | 'joinRun'> {
     /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */
     connection?: ConnectConnectionAdapter;
     /** Direct async function for audio generation */
     fetcher?: GenerationFetcher<AudioGenerateInput, AudioGenerationResult>;
-    /** Unique identifier for this generation instance */
+    /**
+     * @deprecated Prefer `threadId`. Only allowed when `threadId` is omitted (see `GenerationPersistenceOptions`).
+     */
     id?: string;
     /** Additional body parameters to send with connect-based adapter requests */
     body?: Record<string, any>;
@@ -36,7 +39,7 @@ export interface CreateGenerateAudioOptions<TOutput = AudioGenerationResult> {
  *
  * @template TOutput - The output type (after optional transform)
  */
-export interface CreateGenerateAudioReturn<TOutput = AudioGenerationResult> {
+export interface CreateGenerateAudioReturn<TOutput = AudioGenerationResult> extends Omit<CreateGenerationReturn<TOutput>, 'generate'> {
     /** The generation result containing audio, or null */
     readonly result: TOutput | null;
     /** Whether generation is in progress */
@@ -47,12 +50,6 @@ export interface CreateGenerateAudioReturn<TOutput = AudioGenerationResult> {
     readonly status: GenerationClientState;
     /** Trigger audio generation */
     generate: (input: AudioGenerateInput) => Promise<void>;
-    /** Abort the current generation */
-    stop: () => void;
-    /** Clear result, error, and return to idle */
-    reset: () => void;
-    /** Update additional body parameters */
-    updateBody: (body: Record<string, any>) => void;
 }
 /**
  * Creates a reactive audio generation instance for Svelte 5.
@@ -80,6 +77,6 @@ export interface CreateGenerateAudioReturn<TOutput = AudioGenerationResult> {
  * </div>
  * ```
  */
-export declare function createGenerateAudio<TTransformed = void>(options: Omit<CreateGenerateAudioOptions, 'onResult'> & {
+export declare function createGenerateAudio<TTransformed = void>(options: Omit<CreateGenerateAudioOptions, 'onResult' | 'persistence' | 'threadId' | 'id'> & {
     onResult?: (result: AudioGenerationResult) => TTransformed;
-}): CreateGenerateAudioReturn<InferGenerationOutputFromReturn<AudioGenerationResult, TTransformed>>;
+} & GenerationPersistenceOptions): CreateGenerateAudioReturn<InferGenerationOutputFromReturn<AudioGenerationResult, TTransformed>>;

package/dist/create-generate-audio.svelte.js

@@ -1,4 +1,5 @@
 import { createGeneration } from './create-generation.svelte';
+import { reconstructAudioResult } from '@tanstack/ai-client';
 /**
  * Creates a reactive audio generation instance for Svelte 5.
  *
@@ -35,6 +36,7 @@ export function createGenerateAudio(options) {
     const gen = createGeneration({
         ...options,
         devtools,
+        reconstructResult: reconstructAudioResult,
     });
     return {
         get result() {
@@ -53,5 +55,9 @@ export function createGenerateAudio(options) {
         stop: gen.stop,
         reset: gen.reset,
         updateBody: gen.updateBody,
+        dispose: gen.dispose,
+        get runId() {
+            return gen.runId;
+        },
     };
 }

package/dist/create-generate-image.svelte.d.ts

@@ -1,16 +1,19 @@
+import type { CreateGenerationOptions, CreateGenerationReturn } from './create-generation.svelte';
 import type { ImageGenerationResult, StreamChunk } from '@tanstack/ai';
-import type { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, ImageGenerateInput, InferGenerationOutputFromReturn } from '@tanstack/ai-client';
+import type { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, GenerationPersistenceOptions, ImageGenerateInput, InferGenerationOutputFromReturn } from '@tanstack/ai-client';
 /**
  * Options for the createGenerateImage function.
  *
  * @template TOutput - The output type after optional transform (defaults to ImageGenerationResult)
  */
-export interface CreateGenerateImageOptions<TOutput = ImageGenerationResult> {
+export interface CreateGenerateImageOptions<TOutput = ImageGenerationResult> extends Pick<CreateGenerationOptions<ImageGenerateInput, ImageGenerationResult, TOutput>, 'persistence' | 'threadId' | 'hydrateGeneration' | 'joinRun'> {
     /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */
     connection?: ConnectConnectionAdapter;
     /** Direct async function for image generation */
     fetcher?: GenerationFetcher<ImageGenerateInput, ImageGenerationResult>;
-    /** Unique identifier for this generation instance */
+    /**
+     * @deprecated Prefer `threadId`. Only allowed when `threadId` is omitted (see `GenerationPersistenceOptions`).
+     */
     id?: string;
     /** Additional body parameters to send with connect-based adapter requests */
     body?: Record<string, any>;
@@ -36,7 +39,7 @@ export interface CreateGenerateImageOptions<TOutput = ImageGenerationResult> {
  *
  * @template TOutput - The output type (after optional transform)
  */
-export interface CreateGenerateImageReturn<TOutput = ImageGenerationResult> {
+export interface CreateGenerateImageReturn<TOutput = ImageGenerationResult> extends Omit<CreateGenerationReturn<TOutput>, 'generate'> {
     /** The generation result containing images, or null */
     readonly result: TOutput | null;
     /** Whether generation is in progress */
@@ -47,12 +50,6 @@ export interface CreateGenerateImageReturn<TOutput = ImageGenerationResult> {
     readonly status: GenerationClientState;
     /** Trigger image generation */
     generate: (input: ImageGenerateInput) => Promise<void>;
-    /** Abort the current generation */
-    stop: () => void;
-    /** Clear result, error, and return to idle */
-    reset: () => void;
-    /** Update additional body parameters */
-    updateBody: (body: Record<string, any>) => void;
 }
 /**
  * Creates a reactive image generation instance for Svelte 5.
@@ -89,6 +86,6 @@ export interface CreateGenerateImageReturn<TOutput = ImageGenerationResult> {
  * </div>
  * ```
  */
-export declare function createGenerateImage<TTransformed = void>(options: Omit<CreateGenerateImageOptions, 'onResult'> & {
+export declare function createGenerateImage<TTransformed = void>(options: Omit<CreateGenerateImageOptions, 'onResult' | 'persistence' | 'threadId' | 'id'> & {
     onResult?: (result: ImageGenerationResult) => TTransformed;
-}): CreateGenerateImageReturn<InferGenerationOutputFromReturn<ImageGenerationResult, TTransformed>>;
+} & GenerationPersistenceOptions): CreateGenerateImageReturn<InferGenerationOutputFromReturn<ImageGenerationResult, TTransformed>>;

package/dist/create-generate-image.svelte.js

@@ -1,4 +1,5 @@
 import { createGeneration } from './create-generation.svelte';
+import { reconstructImageResult } from '@tanstack/ai-client';
 /**
  * Creates a reactive image generation instance for Svelte 5.
  *
@@ -44,6 +45,7 @@ export function createGenerateImage(options) {
     const gen = createGeneration({
         ...options,
         devtools,
+        reconstructResult: reconstructImageResult,
     });
     return {
         get result() {
@@ -62,5 +64,9 @@ export function createGenerateImage(options) {
         stop: gen.stop,
         reset: gen.reset,
         updateBody: gen.updateBody,
+        dispose: gen.dispose,
+        get runId() {
+            return gen.runId;
+        },
     };
 }

package/dist/create-generate-speech.svelte.d.ts

@@ -1,16 +1,19 @@
+import type { CreateGenerationOptions, CreateGenerationReturn } from './create-generation.svelte';
 import type { StreamChunk, TTSResult } from '@tanstack/ai';
-import type { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, InferGenerationOutputFromReturn, SpeechGenerateInput } from '@tanstack/ai-client';
+import type { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, GenerationPersistenceOptions, InferGenerationOutputFromReturn, SpeechGenerateInput } from '@tanstack/ai-client';
 /**
  * Options for the createGenerateSpeech function.
  *
  * @template TOutput - The output type after optional transform (defaults to TTSResult)
  */
-export interface CreateGenerateSpeechOptions<TOutput = TTSResult> {
+export interface CreateGenerateSpeechOptions<TOutput = TTSResult> extends Pick<CreateGenerationOptions<SpeechGenerateInput, TTSResult, TOutput>, 'persistence' | 'threadId' | 'hydrateGeneration' | 'joinRun'> {
     /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */
     connection?: ConnectConnectionAdapter;
     /** Direct async function for speech generation */
     fetcher?: GenerationFetcher<SpeechGenerateInput, TTSResult>;
-    /** Unique identifier for this generation instance */
+    /**
+     * @deprecated Prefer `threadId`. Only allowed when `threadId` is omitted (see `GenerationPersistenceOptions`).
+     */
     id?: string;
     /** Additional body parameters to send with connect-based adapter requests */
     body?: Record<string, any>;
@@ -36,7 +39,7 @@ export interface CreateGenerateSpeechOptions<TOutput = TTSResult> {
  *
  * @template TOutput - The output type (after optional transform)
  */
-export interface CreateGenerateSpeechReturn<TOutput = TTSResult> {
+export interface CreateGenerateSpeechReturn<TOutput = TTSResult> extends Omit<CreateGenerationReturn<TOutput>, 'generate'> {
     /** The TTS result containing audio data, or null */
     readonly result: TOutput | null;
     /** Whether generation is in progress */
@@ -47,12 +50,6 @@ export interface CreateGenerateSpeechReturn<TOutput = TTSResult> {
     readonly status: GenerationClientState;
     /** Trigger speech generation */
     generate: (input: SpeechGenerateInput) => Promise<void>;
-    /** Abort the current generation */
-    stop: () => void;
-    /** Clear result, error, and return to idle */
-    reset: () => void;
-    /** Update additional body parameters */
-    updateBody: (body: Record<string, any>) => void;
 }
 /**
  * Creates a reactive speech generation (text-to-speech) instance for Svelte 5.
@@ -80,6 +77,6 @@ export interface CreateGenerateSpeechReturn<TOutput = TTSResult> {
  * </div>
  * ```
  */
-export declare function createGenerateSpeech<TTransformed = void>(options: Omit<CreateGenerateSpeechOptions, 'onResult'> & {
+export declare function createGenerateSpeech<TTransformed = void>(options: Omit<CreateGenerateSpeechOptions, 'onResult' | 'persistence' | 'threadId' | 'id'> & {
     onResult?: (result: TTSResult) => TTransformed;
-}): CreateGenerateSpeechReturn<InferGenerationOutputFromReturn<TTSResult, TTransformed>>;
+} & GenerationPersistenceOptions): CreateGenerateSpeechReturn<InferGenerationOutputFromReturn<TTSResult, TTransformed>>;

package/dist/create-generate-speech.svelte.js

@@ -1,4 +1,5 @@
 import { createGeneration } from './create-generation.svelte';
+import { reconstructSpeechResult } from '@tanstack/ai-client';
 /**
  * Creates a reactive speech generation (text-to-speech) instance for Svelte 5.
  *
@@ -35,6 +36,7 @@ export function createGenerateSpeech(options) {
     const gen = createGeneration({
         ...options,
         devtools,
+        reconstructResult: reconstructSpeechResult,
     });
     return {
         get result() {
@@ -53,5 +55,9 @@ export function createGenerateSpeech(options) {
         stop: gen.stop,
         reset: gen.reset,
         updateBody: gen.updateBody,
+        dispose: gen.dispose,
+        get runId() {
+            return gen.runId;
+        },
     };
 }

package/dist/create-generate-video.svelte.d.ts

@@ -1,5 +1,5 @@
 import type { StreamChunk } from '@tanstack/ai';
-import type { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, InferGenerationOutputFromReturn, VideoGenerateInput, VideoGenerateResult, VideoStatusInfo } from '@tanstack/ai-client';
+import type { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, GenerationPersistenceOptions, InferGenerationOutputFromReturn, VideoGenerateInput, VideoGenerateResult, VideoStatusInfo } from '@tanstack/ai-client';
 /**
  * Options for the createGenerateVideo function.
  *
@@ -10,12 +10,51 @@ export interface CreateGenerateVideoOptions<TOutput = VideoGenerateResult> {
     connection?: ConnectConnectionAdapter;
     /** Direct async function that returns a completed video result */
     fetcher?: GenerationFetcher<VideoGenerateInput, VideoGenerateResult>;
-    /** Unique identifier for this generation instance */
+    /**
+     * @deprecated Prefer `threadId`. Only allowed when `threadId` is omitted (see `GenerationPersistenceOptions`).
+     */
     id?: string;
     /** Additional body parameters to send with connect-based adapter requests */
     body?: Record<string, any>;
     /** Display options for TanStack AI Devtools. */
     devtools?: AIDevtoolsDisplayOptions;
+    /**
+     * How this generation persists across reloads.
+     * - Omit / `false`: ephemeral, in-memory only.
+     * - `true`: server-driven — on mount the client hydrates the last generation
+     *   for its `threadId` from the server (needs a connection with a
+     *   `hydrateGeneration` handler) and repaints it; it never auto-starts a run.
+     */
+    persistence?: boolean;
+    /**
+     * The **scope** this generation belongs to: a stable, app-chosen name for the
+     * slot successive runs fill — not a link to a chat conversation.
+     *
+     * The hook starts empty and produces many runs over its life; each gets its
+     * own `runId`, but all belong to one scope. Persistence keys on this, so
+     * derive it from your own domain and keep it identical across reloads (e.g.
+     * `` `video-${videoId}-start-frame` ``). It is also sent as the AG-UI thread
+     * id on the wire, which the protocol requires.
+     *
+     * **Required whenever `persistence` is set** — an app that cannot name the
+     * scope has nothing to restore to. Optional for ephemeral generations, where
+     * it falls back to `id` purely to satisfy the wire.
+     */
+    threadId?: string;
+    /**
+     * Server-driven hydration handler for `persistence: true` when the
+     * connection doesn't carry one (e.g. alongside `fetcher`, or a `stream()` /
+     * `rpcStream()` adapter built without handlers) — typically a one-line
+     * server-function call. The connection's own handler takes precedence.
+     */
+    hydrateGeneration?: ConnectConnectionAdapter['hydrateGeneration'];
+    /**
+     * Re-attach handler that replays a run still generating to completion on
+     * mount, when the connection doesn't carry one. Without it, a restored
+     * `running` snapshot surfaces as an (interrupted) error. The connection's
+     * own handler takes precedence.
+     */
+    joinRun?: ConnectConnectionAdapter['joinRun'];
     /**
      * Callback when video generation completes. Can optionally return a transformed value.
      *
@@ -63,6 +102,13 @@ export interface CreateGenerateVideoReturn<TOutput = VideoGenerateResult> {
     dispose: () => void;
     /** Update additional body parameters */
     updateBody: (body: Record<string, any>) => void;
+    /**
+     * The id of the generation job currently running, or `null` when nothing is in
+     * flight. Each call to `generate` is one job with its own id. Pass it to your
+     * own endpoint to cancel or poll the provider job — `stop()` only aborts the
+     * local stream, it does not stop work already running on the provider.
+     */
+    readonly runId: string | null;
 }
 /**
  * Creates a reactive video generation instance for Svelte 5.
@@ -94,6 +140,6 @@ export interface CreateGenerateVideoReturn<TOutput = VideoGenerateResult> {
  * </div>
  * ```
  */
-export declare function createGenerateVideo<TTransformed = void>(options: Omit<CreateGenerateVideoOptions, 'onResult'> & {
+export declare function createGenerateVideo<TTransformed = void>(options: Omit<CreateGenerateVideoOptions, 'onResult' | 'persistence' | 'threadId' | 'id'> & {
     onResult?: (result: VideoGenerateResult) => TTransformed;
-}): CreateGenerateVideoReturn<InferGenerationOutputFromReturn<VideoGenerateResult, TTransformed>>;
+} & GenerationPersistenceOptions): CreateGenerateVideoReturn<InferGenerationOutputFromReturn<VideoGenerateResult, TTransformed>>;