@tanstack/ai-solid 0.15.1 → 0.16.1

package/dist/use-summarize.d.ts

@@ -1,5 +1,6 @@
+import { UseGenerationOptions, UseGenerationReturn } from "./use-generation.js";
 import { Accessor } from "solid-js";
-import { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, InferGenerationOutputFromReturn, SummarizeGenerateInput } from "@tanstack/ai-client";
+import { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, GenerationPersistenceOptions, InferGenerationOutputFromReturn, SummarizeGenerateInput } from "@tanstack/ai-client";
 import { StreamChunk, SummarizationResult } from "@tanstack/ai";
 
 //#region src/use-summarize.d.ts
@@ -9,12 +10,14 @@ import { StreamChunk, SummarizationResult } from "@tanstack/ai";
  *
  * @template TOutput - The transformed output type (defaults to SummarizationResult)
  */
-interface UseSummarizeOptions<TOutput = SummarizationResult> {
+interface UseSummarizeOptions<TOutput = SummarizationResult> extends Pick<UseGenerationOptions<SummarizeGenerateInput, SummarizationResult, TOutput>, 'persistence' | 'threadId' | 'hydrateGeneration' | 'joinRun'> {
   /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */
   connection?: ConnectConnectionAdapter;
   /** Direct async function for summarization */
   fetcher?: GenerationFetcher<SummarizeGenerateInput, SummarizationResult>;
-  /** 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>;
@@ -40,7 +43,7 @@ interface UseSummarizeOptions<TOutput = SummarizationResult> {
  *
  * @template TOutput - The transformed output type (defaults to SummarizationResult)
  */
-interface UseSummarizeReturn<TOutput = SummarizationResult> {
+interface UseSummarizeReturn<TOutput = SummarizationResult> extends Omit<UseGenerationReturn<TOutput>, 'generate'> {
   /** Trigger summarization */
   generate: (input: SummarizeGenerateInput) => Promise<void>;
   /** The summarization result, or null */
@@ -51,10 +54,6 @@ interface UseSummarizeReturn<TOutput = SummarizationResult> {
   error: Accessor<Error | undefined>;
   /** Current state of the generation */
   status: Accessor<GenerationClientState>;
-  /** Abort the current summarization */
-  stop: () => void;
-  /** Clear result, error, and return to idle */
-  reset: () => void;
 }
 /**
  * Solid hook for summarizing text using AI models.
@@ -85,9 +84,9 @@ interface UseSummarizeReturn<TOutput = SummarizationResult> {
  * }
  * ```
  */
-declare function useSummarize<TTransformed = void>(options: Omit<UseSummarizeOptions, 'onResult'> & {
+declare function useSummarize<TTransformed = void>(options: Omit<UseSummarizeOptions, 'onResult' | 'persistence' | 'threadId' | 'id'> & {
   onResult?: (result: SummarizationResult) => TTransformed;
-}): UseSummarizeReturn<InferGenerationOutputFromReturn<SummarizationResult, TTransformed>>;
+} & GenerationPersistenceOptions): UseSummarizeReturn<InferGenerationOutputFromReturn<SummarizationResult, TTransformed>>;
 //#endregion
 export { UseSummarizeOptions, UseSummarizeReturn, useSummarize };
 //# sourceMappingURL=use-summarize.d.ts.map

package/dist/use-summarize.js

@@ -1,4 +1,5 @@
 import { useGeneration } from "./use-generation.js";
+import { reconstructSummarizeResult } from "@tanstack/ai-client";
 
 //#region src/use-summarize.ts
 /**
@@ -37,19 +38,11 @@ function useSummarize(options) {
 		hookName: "useSummarize",
 		outputKind: "text"
 	};
-	const { generate, result, isLoading, error, status, stop, reset } = useGeneration({
+	return useGeneration({
 		...options,
-		devtools
+		devtools,
+		reconstructResult: reconstructSummarizeResult
 	});
-	return {
-		generate,
-		result,
-		isLoading,
-		error,
-		status,
-		stop,
-		reset
-	};
 }
 
 //#endregion

package/dist/use-summarize.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-summarize.js","names":[],"sources":["../src/use-summarize.ts"],"sourcesContent":["import { useGeneration } from './use-generation'\nimport type { StreamChunk, SummarizationResult } from '@tanstack/ai'\nimport type {\n  AIDevtoolsDisplayOptions,\n  ConnectConnectionAdapter,\n  GenerationClientState,\n  GenerationFetcher,\n  InferGenerationOutputFromReturn,\n  SummarizeGenerateInput,\n} from '@tanstack/ai-client'\nimport type { Accessor } from 'solid-js'\n\n/**\n * Options for the useSummarize hook.\n *\n * @template TOutput - The transformed output type (defaults to SummarizationResult)\n */\nexport interface UseSummarizeOptions<TOutput = SummarizationResult> {\n  /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */\n  connection?: ConnectConnectionAdapter\n  /** Direct async function for summarization */\n  fetcher?: GenerationFetcher<SummarizeGenerateInput, SummarizationResult>\n  /** Unique identifier for this generation instance */\n  id?: string\n  /** Additional body parameters to send with connect-based adapter requests */\n  body?: Record<string, any>\n  /** Display options for TanStack AI Devtools. */\n  devtools?: AIDevtoolsDisplayOptions\n  /**\n   * Callback when summarization is complete. Can optionally return a transformed value.\n   *\n   * - Return a non-null value to transform and store it as the result\n   * - Return `null` to keep the previous result unchanged\n   * - Return nothing (`void`) to store the raw result as-is\n   */\n  onResult?: (result: SummarizationResult) => TOutput | null | void\n  /** Callback when an error occurs */\n  onError?: (error: Error) => void\n  /** Callback when progress is reported (0-100) */\n  onProgress?: (progress: number, message?: string) => void\n  /** Callback for each stream chunk (connect-based adapter mode only) */\n  onChunk?: (chunk: StreamChunk) => void\n}\n\n/**\n * Return type for the useSummarize hook.\n *\n * @template TOutput - The transformed output type (defaults to SummarizationResult)\n */\nexport interface UseSummarizeReturn<TOutput = SummarizationResult> {\n  /** Trigger summarization */\n  generate: (input: SummarizeGenerateInput) => Promise<void>\n  /** The summarization result, or null */\n  result: Accessor<TOutput | null>\n  /** Whether summarization is in progress */\n  isLoading: Accessor<boolean>\n  /** Current error, if any */\n  error: Accessor<Error | undefined>\n  /** Current state of the generation */\n  status: Accessor<GenerationClientState>\n  /** Abort the current summarization */\n  stop: () => void\n  /** Clear result, error, and return to idle */\n  reset: () => void\n}\n\n/**\n * Solid hook for summarizing text using AI models.\n *\n * @example\n * ```tsx\n * import { useSummarize } from '@tanstack/ai-solid'\n * import { fetchServerSentEvents } from '@tanstack/ai-client'\n *\n * function Summarizer() {\n *   const { generate, result, isLoading } = useSummarize({\n *     connection: fetchServerSentEvents('/api/summarize'),\n *   })\n *\n *   return (\n *     <div>\n *       <button onClick={() => generate({\n *         text: 'Long article text...',\n *         style: 'bullet-points',\n *         maxLength: 200,\n *       })}>\n *         Summarize\n *       </button>\n *       {isLoading() && <p>Summarizing...</p>}\n *       {result() && <p>{result()!.summary}</p>}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useSummarize<TTransformed = void>(\n  options: Omit<UseSummarizeOptions, 'onResult'> & {\n    onResult?: (result: SummarizationResult) => TTransformed\n  },\n): UseSummarizeReturn<\n  InferGenerationOutputFromReturn<SummarizationResult, TTransformed>\n> {\n  const devtools = {\n    ...options.devtools,\n    framework: 'solid',\n    hookName: 'useSummarize',\n    outputKind: 'text' as const,\n  }\n  const { generate, result, isLoading, error, status, stop, reset } =\n    useGeneration<SummarizeGenerateInput, SummarizationResult, TTransformed>({\n      ...options,\n      devtools,\n    })\n\n  return {\n    generate: generate as (input: SummarizeGenerateInput) => Promise<void>,\n    result,\n    isLoading,\n    error,\n    status,\n    stop,\n    reset,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,aACd,SAKA;CACA,MAAM,WAAW;EACf,GAAG,QAAQ;EACX,WAAW;EACX,UAAU;EACV,YAAY;EACb;CACD,MAAM,EAAE,UAAU,QAAQ,WAAW,OAAO,QAAQ,MAAM,UACxD,cAAyE;EACvE,GAAG;EACH;EACD,CAAC;AAEJ,QAAO;EACK;EACV;EACA;EACA;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"use-summarize.js","names":[],"sources":["../src/use-summarize.ts"],"sourcesContent":["import { useGeneration } from './use-generation'\nimport { reconstructSummarizeResult } from '@tanstack/ai-client'\nimport type {\n  UseGenerationOptions,\n  UseGenerationReturn,\n} from './use-generation'\nimport type { StreamChunk, SummarizationResult } from '@tanstack/ai'\nimport type {\n  AIDevtoolsDisplayOptions,\n  ConnectConnectionAdapter,\n  GenerationClientState,\n  GenerationFetcher,\n  GenerationPersistenceOptions,\n  InferGenerationOutputFromReturn,\n  SummarizeGenerateInput,\n} from '@tanstack/ai-client'\nimport type { Accessor } from 'solid-js'\n\n/**\n * Options for the useSummarize hook.\n *\n * @template TOutput - The transformed output type (defaults to SummarizationResult)\n */\nexport interface UseSummarizeOptions<\n  TOutput = SummarizationResult,\n> extends Pick<\n  UseGenerationOptions<SummarizeGenerateInput, SummarizationResult, TOutput>,\n  'persistence' | 'threadId' | 'hydrateGeneration' | 'joinRun'\n> {\n  /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */\n  connection?: ConnectConnectionAdapter\n  /** Direct async function for summarization */\n  fetcher?: GenerationFetcher<SummarizeGenerateInput, SummarizationResult>\n  /**\n   * @deprecated Prefer `threadId`. Only allowed when `threadId` is omitted (see `GenerationPersistenceOptions`).\n   */\n  id?: string\n  /** Additional body parameters to send with connect-based adapter requests */\n  body?: Record<string, any>\n  /** Display options for TanStack AI Devtools. */\n  devtools?: AIDevtoolsDisplayOptions\n  /**\n   * Callback when summarization is complete. Can optionally return a transformed value.\n   *\n   * - Return a non-null value to transform and store it as the result\n   * - Return `null` to keep the previous result unchanged\n   * - Return nothing (`void`) to store the raw result as-is\n   */\n  onResult?: (result: SummarizationResult) => TOutput | null | void\n  /** Callback when an error occurs */\n  onError?: (error: Error) => void\n  /** Callback when progress is reported (0-100) */\n  onProgress?: (progress: number, message?: string) => void\n  /** Callback for each stream chunk (connect-based adapter mode only) */\n  onChunk?: (chunk: StreamChunk) => void\n}\n\n/**\n * Return type for the useSummarize hook.\n *\n * @template TOutput - The transformed output type (defaults to SummarizationResult)\n */\nexport interface UseSummarizeReturn<TOutput = SummarizationResult> extends Omit<\n  UseGenerationReturn<TOutput>,\n  'generate'\n> {\n  /** Trigger summarization */\n  generate: (input: SummarizeGenerateInput) => Promise<void>\n  /** The summarization result, or null */\n  result: Accessor<TOutput | null>\n  /** Whether summarization is in progress */\n  isLoading: Accessor<boolean>\n  /** Current error, if any */\n  error: Accessor<Error | undefined>\n  /** Current state of the generation */\n  status: Accessor<GenerationClientState>\n}\n\n/**\n * Solid hook for summarizing text using AI models.\n *\n * @example\n * ```tsx\n * import { useSummarize } from '@tanstack/ai-solid'\n * import { fetchServerSentEvents } from '@tanstack/ai-client'\n *\n * function Summarizer() {\n *   const { generate, result, isLoading } = useSummarize({\n *     connection: fetchServerSentEvents('/api/summarize'),\n *   })\n *\n *   return (\n *     <div>\n *       <button onClick={() => generate({\n *         text: 'Long article text...',\n *         style: 'bullet-points',\n *         maxLength: 200,\n *       })}>\n *         Summarize\n *       </button>\n *       {isLoading() && <p>Summarizing...</p>}\n *       {result() && <p>{result()!.summary}</p>}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useSummarize<TTransformed = void>(\n  options: Omit<\n    UseSummarizeOptions,\n    'onResult' | 'persistence' | 'threadId' | 'id'\n  > & {\n    onResult?: (result: SummarizationResult) => TTransformed\n  } & GenerationPersistenceOptions,\n): UseSummarizeReturn<\n  InferGenerationOutputFromReturn<SummarizationResult, TTransformed>\n> {\n  const devtools = {\n    ...options.devtools,\n    framework: 'solid',\n    hookName: 'useSummarize',\n    outputKind: 'text' as const,\n  }\n  const generation = useGeneration<\n    SummarizeGenerateInput,\n    SummarizationResult,\n    TTransformed\n  >({\n    ...options,\n    devtools,\n    reconstructResult: reconstructSummarizeResult,\n  })\n\n  return generation\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2GA,SAAgB,aACd,SAQA;CACA,MAAM,WAAW;EACf,GAAG,QAAQ;EACX,WAAW;EACX,UAAU;EACV,YAAY;EACb;AAWD,QAVmB,cAIjB;EACA,GAAG;EACH;EACA,mBAAmB;EACpB,CAAC"}

package/dist/use-transcription.d.ts

@@ -1,5 +1,6 @@
+import { UseGenerationOptions, UseGenerationReturn } from "./use-generation.js";
 import { Accessor } from "solid-js";
-import { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, InferGenerationOutputFromReturn, TranscriptionGenerateInput } from "@tanstack/ai-client";
+import { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, GenerationPersistenceOptions, InferGenerationOutputFromReturn, TranscriptionGenerateInput } from "@tanstack/ai-client";
 import { StreamChunk, TranscriptionResult } from "@tanstack/ai";
 
 //#region src/use-transcription.d.ts
@@ -9,12 +10,14 @@ import { StreamChunk, TranscriptionResult } from "@tanstack/ai";
  *
  * @template TOutput - The transformed output type (defaults to TranscriptionResult)
  */
-interface UseTranscriptionOptions<TOutput = TranscriptionResult> {
+interface UseTranscriptionOptions<TOutput = TranscriptionResult> extends Pick<UseGenerationOptions<TranscriptionGenerateInput, TranscriptionResult, TOutput>, 'persistence' | 'threadId' | 'hydrateGeneration' | 'joinRun'> {
   /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */
   connection?: ConnectConnectionAdapter;
   /** Direct async function for transcription */
   fetcher?: GenerationFetcher<TranscriptionGenerateInput, TranscriptionResult>;
-  /** 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>;
@@ -40,7 +43,7 @@ interface UseTranscriptionOptions<TOutput = TranscriptionResult> {
  *
  * @template TOutput - The transformed output type (defaults to TranscriptionResult)
  */
-interface UseTranscriptionReturn<TOutput = TranscriptionResult> {
+interface UseTranscriptionReturn<TOutput = TranscriptionResult> extends Omit<UseGenerationReturn<TOutput>, 'generate'> {
   /** Trigger transcription */
   generate: (input: TranscriptionGenerateInput) => Promise<void>;
   /** The transcription result, or null */
@@ -51,10 +54,6 @@ interface UseTranscriptionReturn<TOutput = TranscriptionResult> {
   error: Accessor<Error | undefined>;
   /** Current state of the generation */
   status: Accessor<GenerationClientState>;
-  /** Abort the current transcription */
-  stop: () => void;
-  /** Clear result, error, and return to idle */
-  reset: () => void;
 }
 /**
  * Solid hook for transcribing audio to text using AI models.
@@ -91,9 +90,9 @@ interface UseTranscriptionReturn<TOutput = TranscriptionResult> {
  * }
  * ```
  */
-declare function useTranscription<TTransformed = void>(options: Omit<UseTranscriptionOptions, 'onResult'> & {
+declare function useTranscription<TTransformed = void>(options: Omit<UseTranscriptionOptions, 'onResult' | 'persistence' | 'threadId' | 'id'> & {
   onResult?: (result: TranscriptionResult) => TTransformed;
-}): UseTranscriptionReturn<InferGenerationOutputFromReturn<TranscriptionResult, TTransformed>>;
+} & GenerationPersistenceOptions): UseTranscriptionReturn<InferGenerationOutputFromReturn<TranscriptionResult, TTransformed>>;
 //#endregion
 export { UseTranscriptionOptions, UseTranscriptionReturn, useTranscription };
 //# sourceMappingURL=use-transcription.d.ts.map

package/dist/use-transcription.js

@@ -1,4 +1,5 @@
 import { useGeneration } from "./use-generation.js";
+import { reconstructTranscriptionResult } from "@tanstack/ai-client";
 
 //#region src/use-transcription.ts
 /**
@@ -43,19 +44,11 @@ function useTranscription(options) {
 		hookName: "useTranscription",
 		outputKind: "text"
 	};
-	const { generate, result, isLoading, error, status, stop, reset } = useGeneration({
+	return useGeneration({
 		...options,
-		devtools
+		devtools,
+		reconstructResult: reconstructTranscriptionResult
 	});
-	return {
-		generate,
-		result,
-		isLoading,
-		error,
-		status,
-		stop,
-		reset
-	};
 }
 
 //#endregion

package/dist/use-transcription.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-transcription.js","names":[],"sources":["../src/use-transcription.ts"],"sourcesContent":["import { useGeneration } from './use-generation'\nimport type { StreamChunk, TranscriptionResult } from '@tanstack/ai'\nimport type {\n  AIDevtoolsDisplayOptions,\n  ConnectConnectionAdapter,\n  GenerationClientState,\n  GenerationFetcher,\n  InferGenerationOutputFromReturn,\n  TranscriptionGenerateInput,\n} from '@tanstack/ai-client'\nimport type { Accessor } from 'solid-js'\n\n/**\n * Options for the useTranscription hook.\n *\n * @template TOutput - The transformed output type (defaults to TranscriptionResult)\n */\nexport interface UseTranscriptionOptions<TOutput = TranscriptionResult> {\n  /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */\n  connection?: ConnectConnectionAdapter\n  /** Direct async function for transcription */\n  fetcher?: GenerationFetcher<TranscriptionGenerateInput, TranscriptionResult>\n  /** Unique identifier for this generation instance */\n  id?: string\n  /** Additional body parameters to send with connect-based adapter requests */\n  body?: Record<string, any>\n  /** Display options for TanStack AI Devtools. */\n  devtools?: AIDevtoolsDisplayOptions\n  /**\n   * Callback when transcription is complete. Can optionally return a transformed value.\n   *\n   * - Return a non-null value to transform and store it as the result\n   * - Return `null` to keep the previous result unchanged\n   * - Return nothing (`void`) to store the raw result as-is\n   */\n  onResult?: (result: TranscriptionResult) => TOutput | null | void\n  /** Callback when an error occurs */\n  onError?: (error: Error) => void\n  /** Callback when progress is reported (0-100) */\n  onProgress?: (progress: number, message?: string) => void\n  /** Callback for each stream chunk (connect-based adapter mode only) */\n  onChunk?: (chunk: StreamChunk) => void\n}\n\n/**\n * Return type for the useTranscription hook.\n *\n * @template TOutput - The transformed output type (defaults to TranscriptionResult)\n */\nexport interface UseTranscriptionReturn<TOutput = TranscriptionResult> {\n  /** Trigger transcription */\n  generate: (input: TranscriptionGenerateInput) => Promise<void>\n  /** The transcription result, or null */\n  result: Accessor<TOutput | null>\n  /** Whether transcription is in progress */\n  isLoading: Accessor<boolean>\n  /** Current error, if any */\n  error: Accessor<Error | undefined>\n  /** Current state of the generation */\n  status: Accessor<GenerationClientState>\n  /** Abort the current transcription */\n  stop: () => void\n  /** Clear result, error, and return to idle */\n  reset: () => void\n}\n\n/**\n * Solid hook for transcribing audio to text using AI models.\n *\n * @example\n * ```tsx\n * import { useTranscription } from '@tanstack/ai-solid'\n * import { fetchServerSentEvents } from '@tanstack/ai-client'\n *\n * function Transcriber() {\n *   const { generate, result, isLoading } = useTranscription({\n *     connection: fetchServerSentEvents('/api/transcribe'),\n *   })\n *\n *   const handleFile = (e: Event) => {\n *     const input = e.target as HTMLInputElement\n *     const file = input.files?.[0]\n *     if (file) {\n *       const reader = new FileReader()\n *       reader.onload = () => {\n *         generate({ audio: reader.result as string, language: 'en' })\n *       }\n *       reader.readAsDataURL(file)\n *     }\n *   }\n *\n *   return (\n *     <div>\n *       <input type=\"file\" accept=\"audio/*\" onChange={handleFile} />\n *       {isLoading() && <p>Transcribing...</p>}\n *       {result() && <p>{result()!.text}</p>}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useTranscription<TTransformed = void>(\n  options: Omit<UseTranscriptionOptions, 'onResult'> & {\n    onResult?: (result: TranscriptionResult) => TTransformed\n  },\n): UseTranscriptionReturn<\n  InferGenerationOutputFromReturn<TranscriptionResult, TTransformed>\n> {\n  const devtools = {\n    ...options.devtools,\n    framework: 'solid',\n    hookName: 'useTranscription',\n    outputKind: 'text' as const,\n  }\n  const { generate, result, isLoading, error, status, stop, reset } =\n    useGeneration<\n      TranscriptionGenerateInput,\n      TranscriptionResult,\n      TTransformed\n    >({ ...options, devtools })\n\n  return {\n    generate: generate as (input: TranscriptionGenerateInput) => Promise<void>,\n    result,\n    isLoading,\n    error,\n    status,\n    stop,\n    reset,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGA,SAAgB,iBACd,SAKA;CACA,MAAM,WAAW;EACf,GAAG,QAAQ;EACX,WAAW;EACX,UAAU;EACV,YAAY;EACb;CACD,MAAM,EAAE,UAAU,QAAQ,WAAW,OAAO,QAAQ,MAAM,UACxD,cAIE;EAAE,GAAG;EAAS;EAAU,CAAC;AAE7B,QAAO;EACK;EACV;EACA;EACA;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"use-transcription.js","names":[],"sources":["../src/use-transcription.ts"],"sourcesContent":["import { useGeneration } from './use-generation'\nimport { reconstructTranscriptionResult } from '@tanstack/ai-client'\nimport type {\n  UseGenerationOptions,\n  UseGenerationReturn,\n} from './use-generation'\nimport type { StreamChunk, TranscriptionResult } from '@tanstack/ai'\nimport type {\n  AIDevtoolsDisplayOptions,\n  ConnectConnectionAdapter,\n  GenerationClientState,\n  GenerationFetcher,\n  GenerationPersistenceOptions,\n  InferGenerationOutputFromReturn,\n  TranscriptionGenerateInput,\n} from '@tanstack/ai-client'\nimport type { Accessor } from 'solid-js'\n\n/**\n * Options for the useTranscription hook.\n *\n * @template TOutput - The transformed output type (defaults to TranscriptionResult)\n */\nexport interface UseTranscriptionOptions<\n  TOutput = TranscriptionResult,\n> extends Pick<\n  UseGenerationOptions<\n    TranscriptionGenerateInput,\n    TranscriptionResult,\n    TOutput\n  >,\n  'persistence' | 'threadId' | 'hydrateGeneration' | 'joinRun'\n> {\n  /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */\n  connection?: ConnectConnectionAdapter\n  /** Direct async function for transcription */\n  fetcher?: GenerationFetcher<TranscriptionGenerateInput, TranscriptionResult>\n  /**\n   * @deprecated Prefer `threadId`. Only allowed when `threadId` is omitted (see `GenerationPersistenceOptions`).\n   */\n  id?: string\n  /** Additional body parameters to send with connect-based adapter requests */\n  body?: Record<string, any>\n  /** Display options for TanStack AI Devtools. */\n  devtools?: AIDevtoolsDisplayOptions\n  /**\n   * Callback when transcription is complete. Can optionally return a transformed value.\n   *\n   * - Return a non-null value to transform and store it as the result\n   * - Return `null` to keep the previous result unchanged\n   * - Return nothing (`void`) to store the raw result as-is\n   */\n  onResult?: (result: TranscriptionResult) => TOutput | null | void\n  /** Callback when an error occurs */\n  onError?: (error: Error) => void\n  /** Callback when progress is reported (0-100) */\n  onProgress?: (progress: number, message?: string) => void\n  /** Callback for each stream chunk (connect-based adapter mode only) */\n  onChunk?: (chunk: StreamChunk) => void\n}\n\n/**\n * Return type for the useTranscription hook.\n *\n * @template TOutput - The transformed output type (defaults to TranscriptionResult)\n */\nexport interface UseTranscriptionReturn<\n  TOutput = TranscriptionResult,\n> extends Omit<UseGenerationReturn<TOutput>, 'generate'> {\n  /** Trigger transcription */\n  generate: (input: TranscriptionGenerateInput) => Promise<void>\n  /** The transcription result, or null */\n  result: Accessor<TOutput | null>\n  /** Whether transcription is in progress */\n  isLoading: Accessor<boolean>\n  /** Current error, if any */\n  error: Accessor<Error | undefined>\n  /** Current state of the generation */\n  status: Accessor<GenerationClientState>\n}\n\n/**\n * Solid hook for transcribing audio to text using AI models.\n *\n * @example\n * ```tsx\n * import { useTranscription } from '@tanstack/ai-solid'\n * import { fetchServerSentEvents } from '@tanstack/ai-client'\n *\n * function Transcriber() {\n *   const { generate, result, isLoading } = useTranscription({\n *     connection: fetchServerSentEvents('/api/transcribe'),\n *   })\n *\n *   const handleFile = (e: Event) => {\n *     const input = e.target as HTMLInputElement\n *     const file = input.files?.[0]\n *     if (file) {\n *       const reader = new FileReader()\n *       reader.onload = () => {\n *         generate({ audio: reader.result as string, language: 'en' })\n *       }\n *       reader.readAsDataURL(file)\n *     }\n *   }\n *\n *   return (\n *     <div>\n *       <input type=\"file\" accept=\"audio/*\" onChange={handleFile} />\n *       {isLoading() && <p>Transcribing...</p>}\n *       {result() && <p>{result()!.text}</p>}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useTranscription<TTransformed = void>(\n  options: Omit<\n    UseTranscriptionOptions,\n    'onResult' | 'persistence' | 'threadId' | 'id'\n  > & {\n    onResult?: (result: TranscriptionResult) => TTransformed\n  } & GenerationPersistenceOptions,\n): UseTranscriptionReturn<\n  InferGenerationOutputFromReturn<TranscriptionResult, TTransformed>\n> {\n  const devtools = {\n    ...options.devtools,\n    framework: 'solid',\n    hookName: 'useTranscription',\n    outputKind: 'text' as const,\n  }\n  const generation = useGeneration<\n    TranscriptionGenerateInput,\n    TranscriptionResult,\n    TTransformed\n  >({ ...options, devtools, reconstructResult: reconstructTranscriptionResult })\n\n  return generation\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoHA,SAAgB,iBACd,SAQA;CACA,MAAM,WAAW;EACf,GAAG,QAAQ;EACX,WAAW;EACX,UAAU;EACV,YAAY;EACb;AAOD,QANmB,cAIjB;EAAE,GAAG;EAAS;EAAU,mBAAmB;EAAgC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-solid",
-  "version": "0.15.1",
+  "version": "0.16.1",
   "description": "Solid hooks for TanStack AI streaming chat, structured outputs, and media generation.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -45,11 +45,11 @@
     "media-generation"
   ],
   "dependencies": {
-    "@tanstack/ai-client": "0.22.1"
+    "@tanstack/ai-client": "0.23.1"
   },
   "peerDependencies": {
     "solid-js": ">=1.9.10",
-    "@tanstack/ai": "^0.42.0"
+    "@tanstack/ai": "^0.43.1"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",
@@ -60,12 +60,12 @@
     "solid-js": "^1.9.10",
     "tsdown": "^0.17.0-beta.6",
     "typescript": "5.9.3",
-    "vitest": "^4.0.14",
-    "@tanstack/ai": "0.42.0"
+    "vitest": "^4.1.10",
+    "@tanstack/ai": "0.43.1"
   },
   "scripts": {
     "clean": "premove ./build ./dist",
-    "test:eslint": "eslint ./src",
+    "test:oxlint": "oxlint src --type-aware",
     "test:lib": "vitest run",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc",

package/src/index.ts

@@ -62,6 +62,16 @@ export type {
 // Re-export from ai-client for convenience
 export {
   fetchServerSentEvents,
+  localStoragePersistence,
+  sessionStoragePersistence,
+  indexedDBPersistence,
+  StorageUnavailableError,
+  type ChatClientPersistence,
+  type ChatPersistedState,
+  type ChatPersistenceOption,
+  type ChatStorageAdapter,
+  type WebStoragePersistenceOptions,
+  type IndexedDBPersistenceOptions,
   fetchHttpStream,
   xhrServerSentEvents,
   xhrHttpStream,

package/src/types.ts

@@ -2,13 +2,18 @@ import type {
   AnyClientTool,
   InferSchemaType,
   ModelMessage,
+  RunAgentResumeItem,
   SchemaInput,
 } from '@tanstack/ai'
 import type {
   AIDevtoolsDisplayOptions,
+  BoundInterrupts,
   ChatClientOptions,
   ChatClientState,
+  ChatInterrupt,
+  ChatInterruptState,
   ChatRequestBody,
+  ChatResumeState,
   ClientContextOptionFromTools,
   ConnectionStatus,
   DistributedOmit,
@@ -84,8 +89,14 @@ export type UseChatOptions<
   | 'onConnectionStatusChange'
   | 'onSessionGeneratingChange'
   | 'onQueueChange'
+  | 'onResumeStateChange'
+  | 'onRunIdChange'
   | 'context'
   | 'devtools'
+  // `id` is not a hook option: the hook's identity is its `threadId`, which is
+  // also the persistence key. Persist across reloads by passing a stable
+  // `threadId`; there is no separate id to set.
+  | 'id'
 > & {
   /** Display options for TanStack AI Devtools. */
   devtools?: AIDevtoolsDisplayOptions
@@ -181,6 +192,39 @@ interface BaseUseChatReturn<
     approved: boolean
   }) => Promise<void>
 
+  /**
+   * The id of the run this client has in flight — one it started or rejoined —
+   * or `null` when there is none (including while a run sits paused on an
+   * interrupt, waiting on approval).
+   *
+   * A run is one turn of the conversation, so this changes from turn to turn. A
+   * whole tool loop stays inside one run, while resuming after an interrupt
+   * continues the turn under a new id — so one user message can produce several
+   * run ids. Use it to talk to your own server about that run (cancel it, poll
+   * it, correlate a log line).
+   */
+  runId: Accessor<string | null>
+  interrupts: Accessor<BoundInterrupts<TTools>>
+  /** @deprecated Use `interrupts`. */
+  pendingInterrupts: Accessor<BoundInterrupts<TTools>>
+  interruptErrors: Accessor<ChatInterruptState<TTools>['interruptErrors']>
+  resuming: Accessor<boolean>
+  resolveInterrupts: {
+    (approved: boolean): void
+    (resolver: (interrupt: ChatInterrupt<TTools>) => undefined): void
+  }
+  cancelInterrupts: () => void
+  retryInterrupts: () => void
+  resumeInterruptsUnsafe: (
+    resume: Array<RunAgentResumeItem>,
+    state?: ChatResumeState,
+  ) => Promise<boolean>
+  /** @deprecated Use bound interrupt methods or `resumeInterruptsUnsafe`. */
+  resumeInterrupts: (
+    resume: Array<RunAgentResumeItem>,
+    state?: ChatResumeState,
+  ) => Promise<boolean>
+
   /**
    * Reload the last assistant message
    */

package/src/use-chat.ts

@@ -11,6 +11,9 @@ import { ChatClient } from '@tanstack/ai-client'
 import { createChatDevtoolsBridge } from '@tanstack/ai-client/devtools'
 import type {
   ChatClientState,
+  ChatInterrupt,
+  ChatInterruptState,
+  ChatResumeState,
   ConnectionStatus,
   InferredClientContext,
   QueuedMessage,
@@ -21,6 +24,7 @@ import type {
   AnyClientTool,
   InferSchemaType,
   ModelMessage,
+  RunAgentResumeItem,
   SchemaInput,
   StreamChunk,
 } from '@tanstack/ai'
@@ -32,6 +36,9 @@ import type {
   UseChatReturn,
 } from './types'
 
+const EMPTY_INTERRUPTS = Object.freeze([])
+const EMPTY_INTERRUPT_ERRORS = Object.freeze([])
+
 export function useChat<
   const TTools extends ReadonlyArray<AnyClientTool> = any,
   TSchema extends SchemaInput | undefined = undefined,
@@ -43,8 +50,12 @@ export function useChat<
     TContext
   >,
 ): UseChatReturn<TTools, TSchema> {
+  // The hook's identity is its `threadId` — also the persistence key, so a
+  // reload with the same `threadId` restores the same conversation. `hookId` is
+  // only a stable fallback for client-recreation keying when no `threadId` is
+  // given (an ephemeral chat), never a persistence key.
   const hookId = createUniqueId()
-  const clientId = options.id || hookId
+  const clientId = options.threadId ?? hookId
 
   const [messages, setMessages] = createSignal<Array<UIMessage<TTools>>>(
     options.initialMessages || [],
@@ -57,6 +68,20 @@ export function useChat<
     createSignal<ConnectionStatus>('disconnected')
   const [sessionGenerating, setSessionGenerating] = createSignal(false)
   const [queue, setQueue] = createSignal<Array<QueuedMessage>>([])
+  const [runId, setRunId] = createSignal<string | null>(null)
+  const [interruptState, setInterruptState] = createSignal<
+    ChatInterruptState<TTools>
+  >({
+    interrupts: EMPTY_INTERRUPTS,
+    pendingInterrupts: EMPTY_INTERRUPTS,
+    interruptErrors: EMPTY_INTERRUPT_ERRORS,
+    resuming: false,
+  })
+
+  const syncResumeState = () => {
+    setRunId(client().getCurrentRunId())
+    setInterruptState(client().getInterruptState())
+  }
 
   // Structured-output `partial` / `final` are derived from `messages` —
   // specifically from the structured-output part on the latest assistant
@@ -82,13 +107,15 @@ export function useChat<
     return new ChatClient<TTools, TContext>({
       devtoolsBridgeFactory: createChatDevtoolsBridge,
       ...transport,
-      id: clientId,
       ...(options.initialMessages !== undefined && {
         initialMessages: options.initialMessages,
       }),
       ...(options.persistence !== undefined && {
         persistence: options.persistence,
       }),
+      ...(options.initialResumeSnapshot !== undefined && {
+        initialResumeSnapshot: options.initialResumeSnapshot,
+      }),
       body: options.body,
       ...(options.threadId !== undefined && { threadId: options.threadId }),
       ...(options.forwardedProps !== undefined && {
@@ -122,6 +149,7 @@ export function useChat<
       },
       onLoadingChange: (newIsLoading: boolean) => {
         setIsLoading(newIsLoading)
+        syncResumeState()
       },
       onStatusChange: (newStatus: ChatClientState) => {
         setStatus(newStatus)
@@ -142,12 +170,27 @@ export function useChat<
       onQueueChange: (nextQueue: Array<QueuedMessage>) => {
         setQueue(nextQueue)
       },
+      onRunIdChange: (nextRunId) => {
+        setRunId(nextRunId)
+      },
+      onResumeStateChange: (_nextResumeState, nextPendingInterrupts) => {
+        setInterruptState((current) => ({
+          ...current,
+          interrupts: nextPendingInterrupts,
+          pendingInterrupts: nextPendingInterrupts,
+        }))
+      },
+      onInterruptStateChange: (nextInterruptState) => {
+        setInterruptState(nextInterruptState)
+        options.onInterruptStateChange?.(nextInterruptState)
+      },
     })
     // Only recreate when clientId changes
     // Connection and other options are captured at creation time
   }, [clientId])
 
   setMessages(client().getMessages())
+  syncResumeState()
 
   // Sync body / forwardedProps changes to the client.
   // Both populate the same wire payload; `forwardedProps` is preferred
@@ -181,11 +224,24 @@ export function useChat<
   })
 
   onMount(() => {
+    // START TAILING HERE, not in the constructor. A client is idle until a view
+    // attaches it, so a client that gets built and thrown away never opens a
+    // connection — an unreachable stream would hold one of the browser's ~6
+    // connections per origin until the page reloaded.
+    client().attach()
     client().mountDevtools()
+    // 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 from the client here.
+    syncResumeState()
   })
 
   // Cleanup on unmount: stop any in-flight requests.
   onCleanup(() => {
+    // Release the connection first: `detach` is the counterpart of the `attach`
+    // above, and it keeps the transcript and resume pointer so a later mount can
+    // pick the run back up from the durable log.
+    client().detach()
     if (options.live) {
       client().unsubscribe()
     } else {
@@ -201,15 +257,27 @@ export function useChat<
     content: string | MultimodalContent,
     sendOptions?: SendMessageOptions,
   ) => {
-    await client().sendMessage(content, undefined, sendOptions)
+    try {
+      await client().sendMessage(content, undefined, sendOptions)
+    } finally {
+      syncResumeState()
+    }
   }
 
   const append = async (message: ModelMessage | UIMessage<TTools>) => {
-    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 = () => {
@@ -218,6 +286,7 @@ export function useChat<
 
   const clear = () => {
     client().clear()
+    syncResumeState()
   }
 
   const setMessagesManually = (newMessages: Array<UIMessage<TTools>>) => {
@@ -239,10 +308,48 @@ export function useChat<
     approved: boolean
   }) => {
     await client().addToolApprovalResponse(response)
+    syncResumeState()
   }
 
   const cancelQueued = (id: string) => client().cancelQueued(id)
 
+  const resumeInterrupts = async (
+    resumeItems: Array<RunAgentResumeItem>,
+    state?: ChatResumeState,
+  ) => {
+    const result = await client().resumeInterrupts(resumeItems, state)
+    syncResumeState()
+    return result
+  }
+
+  const resolveInterrupts = (
+    resolution: boolean | ((interrupt: ChatInterrupt<TTools>) => undefined),
+  ) => {
+    if (typeof resolution === 'boolean') {
+      client().resolveInterrupts(resolution)
+    } else {
+      client().resolveInterrupts(resolution)
+    }
+  }
+
+  const cancelInterrupts = () => {
+    client().cancelInterrupts()
+  }
+
+  const retryInterrupts = () => {
+    client().retryInterrupts()
+  }
+
+  const resumeInterruptsUnsafe = (
+    resumeItems: Array<RunAgentResumeItem>,
+    state?: ChatResumeState,
+  ) => client().resumeInterruptsUnsafe(resumeItems, state)
+
+  const interrupts = () => interruptState().interrupts
+  const pendingInterrupts = () => interruptState().pendingInterrupts
+  const interruptErrors = () => interruptState().interruptErrors
+  const resuming = () => interruptState().resuming
+
   // The "active" structured-output part is on the assistant message after
   // the latest user message. When no user message exists yet, return null
   // rather than scanning history — otherwise a stale `final` from
@@ -283,7 +390,7 @@ export function useChat<
 
   // partial / final are runtime-tracked unconditionally; the conditional
   // return type hides them when no `outputSchema` is supplied.
-  // eslint-disable-next-line no-restricted-syntax -- primitive return shape diverges from generic UseChatReturn<TTools, TSchema>; TS can't structurally narrow the conditional partial/final fields
+  // oxlint-disable-next-line eslint-js/no-restricted-syntax -- primitive return shape diverges from generic UseChatReturn<TTools, TSchema>; TS can't structurally narrow the conditional partial/final fields
   return {
     messages,
     queue,
@@ -302,6 +409,16 @@ export function useChat<
     addToolResult,
     addToolApprovalResponse,
     cancelQueued,
+    runId,
+    interrupts,
+    pendingInterrupts,
+    interruptErrors,
+    resuming,
+    resolveInterrupts,
+    cancelInterrupts,
+    retryInterrupts,
+    resumeInterruptsUnsafe,
+    resumeInterrupts,
     partial,
     final,
   } as unknown as UseChatReturn<TTools, TSchema>