@tanstack/ai-solid 0.13.14 → 0.13.15

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { ChatRequestBody, DeepPartial, UIMessage, UseChatOptions, UseChatReturn } from "./types.js";
+import { useChat } from "./use-chat.js";
+import { UseGenerationOptions, UseGenerationReturn, useGeneration } from "./use-generation.js";
+import { UseGenerateImageOptions, UseGenerateImageReturn, useGenerateImage } from "./use-generate-image.js";
+import { UseGenerateAudioOptions, UseGenerateAudioReturn, useGenerateAudio } from "./use-generate-audio.js";
+import { UseGenerateSpeechOptions, UseGenerateSpeechReturn, useGenerateSpeech } from "./use-generate-speech.js";
+import { UseTranscriptionOptions, UseTranscriptionReturn, useTranscription } from "./use-transcription.js";
+import { UseSummarizeOptions, UseSummarizeReturn, useSummarize } from "./use-summarize.js";
+import { UseGenerateVideoOptions, UseGenerateVideoReturn, useGenerateVideo } from "./use-generate-video.js";
+import { AudioGenerateInput, ConnectConnectionAdapter, ConnectionAdapter, FetchConnectionOptions, GenerationClientState, ImageGenerateInput, InferChatMessages, RunAgentInputContext, SpeechGenerateInput, SubscribeConnectionAdapter, SummarizeGenerateInput, TranscriptionGenerateInput, VideoGenerateInput, VideoGenerateResult, VideoStatusInfo, XhrConnectionOptions, createChatClientOptions, fetchHttpStream, fetchServerSentEvents, rpcStream, stream, xhrHttpStream, xhrServerSentEvents } from "@tanstack/ai-client";
+export { type AudioGenerateInput, type ChatRequestBody, type ConnectConnectionAdapter, type ConnectionAdapter, type DeepPartial, type FetchConnectionOptions, type GenerationClientState, type ImageGenerateInput, type InferChatMessages, type RunAgentInputContext, type SpeechGenerateInput, type SubscribeConnectionAdapter, type SummarizeGenerateInput, type TranscriptionGenerateInput, type UIMessage, type UseChatOptions, type UseChatReturn, type UseGenerateAudioOptions, type UseGenerateAudioReturn, type UseGenerateImageOptions, type UseGenerateImageReturn, type UseGenerateSpeechOptions, type UseGenerateSpeechReturn, type UseGenerateVideoOptions, type UseGenerateVideoReturn, type UseGenerationOptions, type UseGenerationReturn, type UseSummarizeOptions, type UseSummarizeReturn, type UseTranscriptionOptions, type UseTranscriptionReturn, type VideoGenerateInput, type VideoGenerateResult, type VideoStatusInfo, type XhrConnectionOptions, createChatClientOptions, fetchHttpStream, fetchServerSentEvents, rpcStream, stream, useChat, useGenerateAudio, useGenerateImage, useGenerateSpeech, useGenerateVideo, useGeneration, useSummarize, useTranscription, xhrHttpStream, xhrServerSentEvents };

package/dist/index.js

@@ -0,0 +1,11 @@
+import { useChat } from "./use-chat.js";
+import { useGeneration } from "./use-generation.js";
+import { useGenerateImage } from "./use-generate-image.js";
+import { useGenerateAudio } from "./use-generate-audio.js";
+import { useGenerateSpeech } from "./use-generate-speech.js";
+import { useTranscription } from "./use-transcription.js";
+import { useSummarize } from "./use-summarize.js";
+import { useGenerateVideo } from "./use-generate-video.js";
+import { createChatClientOptions, fetchHttpStream, fetchServerSentEvents, rpcStream, stream, xhrHttpStream, xhrServerSentEvents } from "@tanstack/ai-client";
+
+export { createChatClientOptions, fetchHttpStream, fetchServerSentEvents, rpcStream, stream, useChat, useGenerateAudio, useGenerateImage, useGenerateSpeech, useGenerateVideo, useGeneration, useSummarize, useTranscription, xhrHttpStream, xhrServerSentEvents };

package/dist/types.d.ts

@@ -0,0 +1,139 @@
+import { Accessor } from "solid-js";
+import { AIDevtoolsDisplayOptions, ChatClientOptions, ChatClientState, ChatRequestBody, ClientContextOptionFromTools, ConnectionStatus, DistributedOmit, InferredClientContext, MultimodalContent, UIMessage } from "@tanstack/ai-client";
+import { AnyClientTool, InferSchemaType, ModelMessage, SchemaInput } from "@tanstack/ai";
+
+//#region src/types.d.ts
+
+/**
+ * Recursive partial — every property and every nested array element is optional.
+ * Used to type the in-flight `partial` accessor while a structured-output
+ * stream is still arriving.
+ */
+type DeepPartial<T> = T extends ReadonlyArray<infer U> ? Array<DeepPartial<U>> : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+/**
+ * Options for the useChat hook.
+ *
+ * This extends ChatClientOptions but omits the state change callbacks that are
+ * managed internally by Solid signals:
+ * - `onMessagesChange` - Managed by Solid signal (exposed as `messages`)
+ * - `onLoadingChange` - Managed by Solid signal (exposed as `isLoading`)
+ * - `onErrorChange` - Managed by Solid signal (exposed as `error`)
+ * - `onStatusChange` - Managed by Solid signal (exposed as `status`)
+ *
+ * All other callbacks (onResponse, onChunk, onFinish, onError) are
+ * passed through to the underlying ChatClient and can be used for side effects.
+ *
+ * When `outputSchema` is supplied, the hook returns typed `partial` and `final`
+ * accessors. The schema is used purely for type inference; server-side
+ * validation still runs against the schema passed to `chat({ outputSchema })`
+ * on the server route.
+ *
+ * Note: Connection and body changes will recreate the ChatClient instance.
+ * To update these options, remount the component or use a key prop.
+ */
+type UseChatOptions<TTools extends ReadonlyArray<AnyClientTool> = any, TSchema extends SchemaInput | undefined = undefined, TContext = InferredClientContext<TTools>> = DistributedOmit<ChatClientOptions<TTools, TContext>, 'onMessagesChange' | 'onLoadingChange' | 'onErrorChange' | 'onStatusChange' | 'onSubscriptionChange' | 'onConnectionStatusChange' | 'onSessionGeneratingChange' | 'context' | 'devtools'> & {
+  /** Display options for TanStack AI Devtools. */
+  devtools?: AIDevtoolsDisplayOptions;
+  live?: boolean;
+  /**
+   * Standard-schema-compatible schema (Zod, Valibot, ArkType, or plain JSON
+   * Schema). Used to infer the shape of `partial` and `final`.
+   */
+  outputSchema?: TSchema;
+} & ClientContextOptionFromTools<TTools, TContext>;
+/**
+ * Discriminated return shape: when `outputSchema` is supplied, the hook adds
+ * typed `partial` / `final` accessors; otherwise the return is unchanged.
+ */
+type UseChatReturn<TTools extends ReadonlyArray<AnyClientTool> = any, TSchema extends SchemaInput | undefined = undefined> = BaseUseChatReturn<TTools, TSchema extends SchemaInput ? InferSchemaType<TSchema> : unknown> & (TSchema extends SchemaInput ? {
+  /**
+   * Live progressively-parsed structured output. Derived from the
+   * latest assistant message's structured-output part.
+   */
+  partial: Accessor<DeepPartial<InferSchemaType<TSchema>>>;
+  /**
+   * Final, schema-validated structured output. `null` until the latest
+   * assistant turn's structured-output part transitions to `complete`.
+   */
+  final: Accessor<InferSchemaType<TSchema> | null>;
+} : Record<never, never>);
+interface BaseUseChatReturn<TTools extends ReadonlyArray<AnyClientTool> = any, TData = unknown> {
+  /**
+   * Current messages in the conversation. When `outputSchema` is supplied,
+   * `messages()[i].parts.find(p => p.type === 'structured-output')` is typed
+   * by the schema — `data: T`, `partial: DeepPartial<T>`.
+   */
+  messages: Accessor<Array<UIMessage<TTools, TData>>>;
+  /**
+   * Send a message and get a response.
+   * Can be a simple string or multimodal content with images, audio, etc.
+   */
+  sendMessage: (content: string | MultimodalContent) => Promise<void>;
+  /**
+   * Append a message to the conversation
+   */
+  append: (message: ModelMessage | UIMessage<TTools, TData>) => Promise<void>;
+  /**
+   * Add the result of a client-side tool execution
+   */
+  addToolResult: (result: {
+    toolCallId: string;
+    tool: string;
+    output: any;
+    state?: 'output-available' | 'output-error';
+    errorText?: string;
+  }) => Promise<void>;
+  /**
+   * Respond to a tool approval request
+   */
+  addToolApprovalResponse: (response: {
+    id: string;
+    approved: boolean;
+  }) => Promise<void>;
+  /**
+   * Reload the last assistant message
+   */
+  reload: () => Promise<void>;
+  /**
+   * Stop the current response generation
+   */
+  stop: () => void;
+  /**
+   * Whether a response is currently being generated
+   */
+  isLoading: Accessor<boolean>;
+  /**
+   * Current error, if any
+   */
+  error: Accessor<Error | undefined>;
+  /**
+   * Set messages manually
+   */
+  setMessages: (messages: Array<UIMessage<TTools, TData>>) => void;
+  /**
+   * Clear all messages
+   */
+  clear: () => void;
+  /**
+   * Current generation status
+   */
+  status: Accessor<ChatClientState>;
+  /**
+   * Whether the subscription loop is currently active
+   */
+  isSubscribed: Accessor<boolean>;
+  /**
+   * Current connection lifecycle status
+   */
+  connectionStatus: Accessor<ConnectionStatus>;
+  /**
+   * Whether the shared session is actively generating.
+   * Derived from stream run events (RUN_STARTED / RUN_FINISHED / RUN_ERROR).
+   * Unlike `isLoading` (request-local), this reflects shared generation
+   * activity visible to all subscribers (e.g. across tabs/devices).
+   */
+  sessionGenerating: Accessor<boolean>;
+}
+//#endregion
+export { type ChatRequestBody, DeepPartial, type UIMessage, UseChatOptions, UseChatReturn };
+//# sourceMappingURL=types.d.ts.map

package/dist/use-chat.d.ts

@@ -0,0 +1,9 @@
+import { UseChatOptions, UseChatReturn } from "./types.js";
+import { InferredClientContext } from "@tanstack/ai-client";
+import { AnyClientTool, SchemaInput } from "@tanstack/ai";
+
+//#region src/use-chat.d.ts
+declare function useChat<TTools extends ReadonlyArray<AnyClientTool> = any, TSchema extends SchemaInput | undefined = undefined, TContext = InferredClientContext<TTools>>(options?: UseChatOptions<TTools, TSchema, TContext>): UseChatReturn<TTools, TSchema>;
+//#endregion
+export { useChat };
+//# sourceMappingURL=use-chat.d.ts.map

package/dist/use-chat.js

@@ -0,0 +1,162 @@
+import { createEffect, createMemo, createSignal, createUniqueId, onCleanup, onMount } from "solid-js";
+import { ChatClient } from "@tanstack/ai-client";
+import { createChatDevtoolsBridge } from "@tanstack/ai-client/devtools";
+
+//#region src/use-chat.ts
+function useChat(options = {}) {
+	const hookId = createUniqueId();
+	const clientId = options.id || hookId;
+	const [messages, setMessages] = createSignal(options.initialMessages || []);
+	const [isLoading, setIsLoading] = createSignal(false);
+	const [error, setError] = createSignal(void 0);
+	const [status, setStatus] = createSignal("ready");
+	const [isSubscribed, setIsSubscribed] = createSignal(false);
+	const [connectionStatus, setConnectionStatus] = createSignal("disconnected");
+	const [sessionGenerating, setSessionGenerating] = createSignal(false);
+	const client = createMemo(() => {
+		return new ChatClient({
+			devtoolsBridgeFactory: createChatDevtoolsBridge,
+			...options.connection ? { connection: options.connection } : { fetcher: options.fetcher },
+			id: clientId,
+			...options.initialMessages !== void 0 && { initialMessages: options.initialMessages },
+			...options.persistence !== void 0 && { persistence: options.persistence },
+			body: options.body,
+			...options.threadId !== void 0 && { threadId: options.threadId },
+			...options.forwardedProps !== void 0 && { forwardedProps: options.forwardedProps },
+			...options.context !== void 0 && { context: options.context },
+			devtools: {
+				...options.devtools,
+				framework: "solid",
+				hookName: "useChat",
+				outputKind: options.outputSchema ? "structured" : "chat"
+			},
+			onResponse: (response) => options.onResponse?.(response),
+			onChunk: (chunk) => {
+				options.onChunk?.(chunk);
+			},
+			onFinish: (message) => {
+				options.onFinish?.(message);
+			},
+			onError: (err) => {
+				options.onError?.(err);
+			},
+			tools: options.tools,
+			onCustomEvent: (eventType, data, context) => options.onCustomEvent?.(eventType, data, context),
+			...options.streamProcessor !== void 0 && { streamProcessor: options.streamProcessor },
+			onMessagesChange: (newMessages) => {
+				setMessages(newMessages);
+			},
+			onLoadingChange: (newIsLoading) => {
+				setIsLoading(newIsLoading);
+			},
+			onStatusChange: (newStatus) => {
+				setStatus(newStatus);
+			},
+			onErrorChange: (newError) => {
+				setError(newError);
+			},
+			onSubscriptionChange: (nextIsSubscribed) => {
+				setIsSubscribed(nextIsSubscribed);
+			},
+			onConnectionStatusChange: (nextStatus) => {
+				setConnectionStatus(nextStatus);
+			},
+			onSessionGeneratingChange: (isGenerating) => {
+				setSessionGenerating(isGenerating);
+			}
+		});
+	}, [clientId]);
+	setMessages(client().getMessages());
+	createEffect(() => {
+		client().updateOptions({
+			...options.body !== void 0 && { body: options.body },
+			...options.forwardedProps !== void 0 && { forwardedProps: options.forwardedProps },
+			context: options.context
+		});
+	});
+	if (options.live) client().subscribe();
+	else client().unsubscribe();
+	createEffect(() => {
+		if (options.live) client().subscribe();
+		else client().unsubscribe();
+	});
+	onMount(() => {
+		client().mountDevtools();
+	});
+	onCleanup(() => {
+		if (options.live) client().unsubscribe();
+		else client().stop();
+		client().dispose();
+	});
+	const sendMessage = async (content) => {
+		await client().sendMessage(content);
+	};
+	const append = async (message) => {
+		await client().append(message);
+	};
+	const reload = async () => {
+		await client().reload();
+	};
+	const stop = () => {
+		client().stop();
+	};
+	const clear = () => {
+		client().clear();
+	};
+	const setMessagesManually = (newMessages) => {
+		client().setMessagesManually(newMessages);
+	};
+	const addToolResult = async (result) => {
+		await client().addToolResult(result);
+	};
+	const addToolApprovalResponse = async (response) => {
+		await client().addToolApprovalResponse(response);
+	};
+	const activeStructuredPart = createMemo(() => {
+		const list = messages();
+		let lastUserIndex = -1;
+		for (let i = list.length - 1; i >= 0; i--) if (list[i]?.role === "user") {
+			lastUserIndex = i;
+			break;
+		}
+		if (lastUserIndex === -1) return null;
+		for (let i = list.length - 1; i > lastUserIndex; i--) {
+			const m = list[i];
+			if (m?.role !== "assistant") continue;
+			const part = m.parts.find((p) => p.type === "structured-output");
+			if (part) return part;
+		}
+		return null;
+	});
+	return {
+		messages,
+		sendMessage,
+		append,
+		reload,
+		stop,
+		isLoading,
+		error,
+		status,
+		isSubscribed,
+		connectionStatus,
+		sessionGenerating,
+		setMessages: setMessagesManually,
+		clear,
+		addToolResult,
+		addToolApprovalResponse,
+		partial: createMemo(() => {
+			const part = activeStructuredPart();
+			if (!part) return {};
+			return part.partial ?? part.data ?? {};
+		}),
+		final: createMemo(() => {
+			const part = activeStructuredPart();
+			if (!part || part.status !== "complete") return null;
+			return part.data;
+		})
+	};
+}
+
+//#endregion
+export { useChat };
+//# sourceMappingURL=use-chat.js.map

package/dist/use-chat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat.js","names":[],"sources":["../src/use-chat.ts"],"sourcesContent":["import {\n  createEffect,\n  createMemo,\n  createSignal,\n  createUniqueId,\n  onCleanup,\n  onMount,\n} from 'solid-js'\n\nimport { ChatClient } from '@tanstack/ai-client'\nimport { createChatDevtoolsBridge } from '@tanstack/ai-client/devtools'\nimport type {\n  ChatClientState,\n  ConnectionStatus,\n  InferredClientContext,\n  StructuredOutputPart,\n} from '@tanstack/ai-client'\nimport type {\n  AnyClientTool,\n  InferSchemaType,\n  ModelMessage,\n  SchemaInput,\n  StreamChunk,\n} from '@tanstack/ai'\nimport type {\n  DeepPartial,\n  MultimodalContent,\n  UIMessage,\n  UseChatOptions,\n  UseChatReturn,\n} from './types'\n\nexport function useChat<\n  TTools extends ReadonlyArray<AnyClientTool> = any,\n  TSchema extends SchemaInput | undefined = undefined,\n  TContext = InferredClientContext<TTools>,\n>(\n  options: UseChatOptions<TTools, TSchema, TContext> = {} as UseChatOptions<\n    TTools,\n    TSchema,\n    TContext\n  >,\n): UseChatReturn<TTools, TSchema> {\n  const hookId = createUniqueId()\n  const clientId = options.id || hookId\n\n  const [messages, setMessages] = createSignal<Array<UIMessage<TTools>>>(\n    options.initialMessages || [],\n  )\n  const [isLoading, setIsLoading] = createSignal(false)\n  const [error, setError] = createSignal<Error | undefined>(undefined)\n  const [status, setStatus] = createSignal<ChatClientState>('ready')\n  const [isSubscribed, setIsSubscribed] = createSignal(false)\n  const [connectionStatus, setConnectionStatus] =\n    createSignal<ConnectionStatus>('disconnected')\n  const [sessionGenerating, setSessionGenerating] = createSignal(false)\n\n  // Structured-output `partial` / `final` are derived from `messages` —\n  // specifically from the structured-output part on the latest assistant\n  // message (the one after the most recent user message). Per-turn parts\n  // keep history coherent without a separate reset signal.\n  type Partial = DeepPartial<InferSchemaType<NonNullable<TSchema>>>\n  type Final = InferSchemaType<NonNullable<TSchema>>\n\n  // Create ChatClient instance with callbacks to sync state.\n  // Every user-provided callback is wrapped so the LATEST `options.xxx` value\n  // is read at call time. Direct assignment would freeze the callback to the\n  // reference we saw at creation; the wrapper lets reactive `options` or\n  // in-place mutations propagate. When the user clears a callback (sets it to\n  // undefined), `?.` no-ops.\n  const client = createMemo(() => {\n    // Build options with conditional spreads for fields whose source\n    // type is `T | undefined` but the ChatClient target uses a strict\n    // optional (`field?: T`) — `exactOptionalPropertyTypes` rejects\n    // assigning `undefined` to those, so we omit the key when absent.\n    const transport = options.connection\n      ? { connection: options.connection }\n      : { fetcher: options.fetcher }\n    return new ChatClient<TTools, TContext>({\n      devtoolsBridgeFactory: createChatDevtoolsBridge,\n      ...transport,\n      id: clientId,\n      ...(options.initialMessages !== undefined && {\n        initialMessages: options.initialMessages,\n      }),\n      ...(options.persistence !== undefined && {\n        persistence: options.persistence,\n      }),\n      body: options.body,\n      ...(options.threadId !== undefined && { threadId: options.threadId }),\n      ...(options.forwardedProps !== undefined && {\n        forwardedProps: options.forwardedProps,\n      }),\n      ...(options.context !== undefined && { context: options.context }),\n      devtools: {\n        ...options.devtools,\n        framework: 'solid',\n        hookName: 'useChat',\n        outputKind: options.outputSchema ? 'structured' : 'chat',\n      },\n      onResponse: (response) => options.onResponse?.(response),\n      onChunk: (chunk: StreamChunk) => {\n        options.onChunk?.(chunk)\n      },\n      onFinish: (message) => {\n        options.onFinish?.(message)\n      },\n      onError: (err) => {\n        options.onError?.(err)\n      },\n      tools: options.tools,\n      onCustomEvent: (eventType, data, context) =>\n        options.onCustomEvent?.(eventType, data, context),\n      ...(options.streamProcessor !== undefined && {\n        streamProcessor: options.streamProcessor,\n      }),\n      onMessagesChange: (newMessages: Array<UIMessage<TTools>>) => {\n        setMessages(newMessages)\n      },\n      onLoadingChange: (newIsLoading: boolean) => {\n        setIsLoading(newIsLoading)\n      },\n      onStatusChange: (newStatus: ChatClientState) => {\n        setStatus(newStatus)\n      },\n      onErrorChange: (newError: Error | undefined) => {\n        setError(newError)\n      },\n      onSubscriptionChange: (nextIsSubscribed: boolean) => {\n        setIsSubscribed(nextIsSubscribed)\n      },\n      onConnectionStatusChange: (nextStatus: ConnectionStatus) => {\n        setConnectionStatus(nextStatus)\n      },\n      onSessionGeneratingChange: (isGenerating: boolean) => {\n        setSessionGenerating(isGenerating)\n      },\n    })\n    // Only recreate when clientId changes\n    // Connection and other options are captured at creation time\n  }, [clientId])\n\n  setMessages(client().getMessages())\n\n  // Sync body / forwardedProps changes to the client.\n  // Both populate the same wire payload; `forwardedProps` is preferred\n  // and `body` is deprecated but still supported.\n  createEffect(() => {\n    // Conditional spread: `updateOptions` declares strict-optional\n    // fields and rejects explicit `undefined` under EOPT.\n    client().updateOptions({\n      ...(options.body !== undefined && { body: options.body }),\n      ...(options.forwardedProps !== undefined && {\n        forwardedProps: options.forwardedProps,\n      }),\n      context: options.context,\n    })\n  })\n\n  // Apply initial live mode immediately on hook creation.\n  if (options.live) {\n    client().subscribe()\n  } else {\n    client().unsubscribe()\n  }\n\n  createEffect(() => {\n    if (options.live) {\n      client().subscribe()\n    } else {\n      client().unsubscribe()\n    }\n  })\n\n  onMount(() => {\n    client().mountDevtools()\n  })\n\n  // Cleanup on unmount: stop any in-flight requests.\n  onCleanup(() => {\n    if (options.live) {\n      client().unsubscribe()\n    } else {\n      client().stop()\n    }\n    client().dispose()\n  })\n\n  // Callback options are read through `options.xxx` at call time, so reactive\n  // or mutated options propagate without recreating the client.\n\n  const sendMessage = async (content: string | MultimodalContent) => {\n    await client().sendMessage(content)\n  }\n\n  const append = async (message: ModelMessage | UIMessage<TTools>) => {\n    await client().append(message)\n  }\n\n  const reload = async () => {\n    await client().reload()\n  }\n\n  const stop = () => {\n    client().stop()\n  }\n\n  const clear = () => {\n    client().clear()\n  }\n\n  const setMessagesManually = (newMessages: Array<UIMessage<TTools>>) => {\n    client().setMessagesManually(newMessages)\n  }\n\n  const addToolResult = async (result: {\n    toolCallId: string\n    tool: string\n    output: any\n    state?: 'output-available' | 'output-error'\n    errorText?: string\n  }) => {\n    await client().addToolResult(result)\n  }\n\n  const addToolApprovalResponse = async (response: {\n    id: string\n    approved: boolean\n  }) => {\n    await client().addToolApprovalResponse(response)\n  }\n\n  // The \"active\" structured-output part is on the assistant message after\n  // the latest user message. When no user message exists yet, return null\n  // rather than scanning history — otherwise a stale `final` from\n  // `initialMessages` would leak into the value on first render.\n  const activeStructuredPart = createMemo<StructuredOutputPart | null>(() => {\n    const list = messages()\n    let lastUserIndex = -1\n    for (let i = list.length - 1; i >= 0; i--) {\n      if (list[i]?.role === 'user') {\n        lastUserIndex = i\n        break\n      }\n    }\n    if (lastUserIndex === -1) return null\n    for (let i = list.length - 1; i > lastUserIndex; i--) {\n      const m = list[i]\n      if (m?.role !== 'assistant') continue\n      const part = m.parts.find(\n        (p): p is StructuredOutputPart => p.type === 'structured-output',\n      )\n      if (part) return part\n    }\n    return null\n  })\n\n  const partial = createMemo<Partial>(() => {\n    const part = activeStructuredPart()\n    if (!part) return {} as Partial\n    const v = part.partial ?? part.data\n    return (v ?? {}) as Partial\n  })\n\n  const final = createMemo<Final | null>(() => {\n    const part = activeStructuredPart()\n    if (!part || part.status !== 'complete') return null\n    return part.data as Final\n  })\n\n  // partial / final are runtime-tracked unconditionally; the conditional\n  // return type hides them when no `outputSchema` is supplied.\n  // 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\n  return {\n    messages,\n    sendMessage,\n    append,\n    reload,\n    stop,\n    isLoading,\n    error,\n    status,\n    isSubscribed,\n    connectionStatus,\n    sessionGenerating,\n    setMessages: setMessagesManually,\n    clear,\n    addToolResult,\n    addToolApprovalResponse,\n    partial,\n    final,\n  } as unknown as UseChatReturn<TTools, TSchema>\n}\n"],"mappings":"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"}

package/dist/use-generate-audio.d.ts

@@ -0,0 +1,88 @@
+import { Accessor } from "solid-js";
+import { AIDevtoolsDisplayOptions, AudioGenerateInput, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, InferGenerationOutput } from "@tanstack/ai-client";
+import { AudioGenerationResult, StreamChunk } from "@tanstack/ai";
+
+//#region src/use-generate-audio.d.ts
+
+/**
+ * Options for the useGenerateAudio hook.
+ *
+ * @template TOutput - The transformed output type (defaults to AudioGenerationResult)
+ */
+interface UseGenerateAudioOptions<TOutput = AudioGenerationResult> {
+  /** 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 */
+  id?: string;
+  /** Additional body parameters to send with connect-based adapter requests */
+  body?: Record<string, any>;
+  /** Display options for TanStack AI Devtools. */
+  devtools?: AIDevtoolsDisplayOptions;
+  /**
+   * Callback when audio is generated. Can optionally return a transformed value.
+   *
+   * - Return a non-null value to transform and store it as the result
+   * - Return `null` to keep the previous result unchanged
+   * - Return nothing (`void`) to store the raw result as-is
+   */
+  onResult?: (result: AudioGenerationResult) => TOutput | null | void;
+  /** Callback when an error occurs */
+  onError?: (error: Error) => void;
+  /** Callback when progress is reported (0-100) */
+  onProgress?: (progress: number, message?: string) => void;
+  /** Callback for each stream chunk (connect-based adapter mode only) */
+  onChunk?: (chunk: StreamChunk) => void;
+}
+/**
+ * Return type for the useGenerateAudio hook.
+ *
+ * @template TOutput - The transformed output type (defaults to AudioGenerationResult)
+ */
+interface UseGenerateAudioReturn<TOutput = AudioGenerationResult> {
+  /** Trigger audio generation */
+  generate: (input: AudioGenerateInput) => Promise<void>;
+  /** The generation result containing audio, or null */
+  result: Accessor<TOutput | null>;
+  /** Whether generation is in progress */
+  isLoading: Accessor<boolean>;
+  /** Current error, if any */
+  error: Accessor<Error | undefined>;
+  /** Current state of the generation */
+  status: Accessor<GenerationClientState>;
+  /** Abort the current generation */
+  stop: () => void;
+  /** Clear result, error, and return to idle */
+  reset: () => void;
+}
+/**
+ * Solid hook for generating audio (music, sound effects) using AI models.
+ *
+ * @example
+ * ```tsx
+ * import { useGenerateAudio } from '@tanstack/ai-solid'
+ * import { fetchServerSentEvents } from '@tanstack/ai-client'
+ *
+ * function AudioGenerator() {
+ *   const { generate, result, isLoading } = useGenerateAudio({
+ *     connection: fetchServerSentEvents('/api/generate/audio'),
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => generate({ prompt: 'An upbeat electronic track', duration: 10 })}>
+ *         Generate
+ *       </button>
+ *       {result()?.audio.url && <audio src={result()!.audio.url} controls />}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useGenerateAudio<TOnResult extends ((result: AudioGenerationResult) => any) | undefined = undefined>(options: Omit<UseGenerateAudioOptions, 'onResult'> & {
+  onResult?: TOnResult;
+}): UseGenerateAudioReturn<InferGenerationOutput<AudioGenerationResult, TOnResult>>;
+//#endregion
+export { UseGenerateAudioOptions, UseGenerateAudioReturn, useGenerateAudio };
+//# sourceMappingURL=use-generate-audio.d.ts.map

package/dist/use-generate-audio.js

@@ -0,0 +1,52 @@
+import { useGeneration } from "./use-generation.js";
+
+//#region src/use-generate-audio.ts
+/**
+* Solid hook for generating audio (music, sound effects) using AI models.
+*
+* @example
+* ```tsx
+* import { useGenerateAudio } from '@tanstack/ai-solid'
+* import { fetchServerSentEvents } from '@tanstack/ai-client'
+*
+* function AudioGenerator() {
+*   const { generate, result, isLoading } = useGenerateAudio({
+*     connection: fetchServerSentEvents('/api/generate/audio'),
+*   })
+*
+*   return (
+*     <div>
+*       <button onClick={() => generate({ prompt: 'An upbeat electronic track', duration: 10 })}>
+*         Generate
+*       </button>
+*       {result()?.audio.url && <audio src={result()!.audio.url} controls />}
+*     </div>
+*   )
+* }
+* ```
+*/
+function useGenerateAudio(options) {
+	const devtools = {
+		...options.devtools,
+		framework: "solid",
+		hookName: "useGenerateAudio",
+		outputKind: "audio"
+	};
+	const { generate, result, isLoading, error, status, stop, reset } = useGeneration({
+		...options,
+		devtools
+	});
+	return {
+		generate,
+		result,
+		isLoading,
+		error,
+		status,
+		stop,
+		reset
+	};
+}
+
+//#endregion
+export { useGenerateAudio };
+//# sourceMappingURL=use-generate-audio.js.map

package/dist/use-generate-audio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-generate-audio.js","names":[],"sources":["../src/use-generate-audio.ts"],"sourcesContent":["import { useGeneration } from './use-generation'\nimport type { AudioGenerationResult, StreamChunk } from '@tanstack/ai'\nimport type {\n  AIDevtoolsDisplayOptions,\n  AudioGenerateInput,\n  ConnectConnectionAdapter,\n  GenerationClientState,\n  GenerationFetcher,\n  InferGenerationOutput,\n} from '@tanstack/ai-client'\nimport type { Accessor } from 'solid-js'\n\n/**\n * Options for the useGenerateAudio hook.\n *\n * @template TOutput - The transformed output type (defaults to AudioGenerationResult)\n */\nexport interface UseGenerateAudioOptions<TOutput = AudioGenerationResult> {\n  /** Connect-based adapter for streaming transport (SSE, HTTP stream, custom) */\n  connection?: ConnectConnectionAdapter\n  /** Direct async function for audio generation */\n  fetcher?: GenerationFetcher<AudioGenerateInput, AudioGenerationResult>\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 audio is generated. 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: AudioGenerationResult) => 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 useGenerateAudio hook.\n *\n * @template TOutput - The transformed output type (defaults to AudioGenerationResult)\n */\nexport interface UseGenerateAudioReturn<TOutput = AudioGenerationResult> {\n  /** Trigger audio generation */\n  generate: (input: AudioGenerateInput) => Promise<void>\n  /** The generation result containing audio, or null */\n  result: Accessor<TOutput | null>\n  /** Whether generation 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 generation */\n  stop: () => void\n  /** Clear result, error, and return to idle */\n  reset: () => void\n}\n\n/**\n * Solid hook for generating audio (music, sound effects) using AI models.\n *\n * @example\n * ```tsx\n * import { useGenerateAudio } from '@tanstack/ai-solid'\n * import { fetchServerSentEvents } from '@tanstack/ai-client'\n *\n * function AudioGenerator() {\n *   const { generate, result, isLoading } = useGenerateAudio({\n *     connection: fetchServerSentEvents('/api/generate/audio'),\n *   })\n *\n *   return (\n *     <div>\n *       <button onClick={() => generate({ prompt: 'An upbeat electronic track', duration: 10 })}>\n *         Generate\n *       </button>\n *       {result()?.audio.url && <audio src={result()!.audio.url} controls />}\n *     </div>\n *   )\n * }\n * ```\n */\nexport function useGenerateAudio<\n  TOnResult extends ((result: AudioGenerationResult) => any) | undefined =\n    undefined,\n>(\n  options: Omit<UseGenerateAudioOptions, 'onResult'> & {\n    onResult?: TOnResult\n  },\n): UseGenerateAudioReturn<\n  InferGenerationOutput<AudioGenerationResult, TOnResult>\n> {\n  const devtools = {\n    ...options.devtools,\n    framework: 'solid',\n    hookName: 'useGenerateAudio',\n    outputKind: 'audio' as const,\n  }\n  const { generate, result, isLoading, error, status, stop, reset } =\n    useGeneration<AudioGenerateInput, AudioGenerationResult, TOnResult>({\n      ...options,\n      devtools,\n    })\n\n  return {\n    generate: generate as (input: AudioGenerateInput) => Promise<void>,\n    result,\n    isLoading,\n    error,\n    status,\n    stop,\n    reset,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,iBAId,SAKA;CACA,MAAM,WAAW;EACf,GAAG,QAAQ;EACX,WAAW;EACX,UAAU;EACV,YAAY;EACb;CACD,MAAM,EAAE,UAAU,QAAQ,WAAW,OAAO,QAAQ,MAAM,UACxD,cAAoE;EAClE,GAAG;EACH;EACD,CAAC;AAEJ,QAAO;EACK;EACV;EACA;EACA;EACA;EACA;EACA;EACD"}

package/dist/use-generate-image.d.ts

@@ -0,0 +1,96 @@
+import { Accessor } from "solid-js";
+import { AIDevtoolsDisplayOptions, ConnectConnectionAdapter, GenerationClientState, GenerationFetcher, ImageGenerateInput, InferGenerationOutput } from "@tanstack/ai-client";
+import { ImageGenerationResult, StreamChunk } from "@tanstack/ai";
+
+//#region src/use-generate-image.d.ts
+
+/**
+ * Options for the useGenerateImage hook.
+ *
+ * @template TOutput - The transformed output type (defaults to ImageGenerationResult)
+ */
+interface UseGenerateImageOptions<TOutput = ImageGenerationResult> {
+  /** 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 */
+  id?: string;
+  /** Additional body parameters to send with connect-based adapter requests */
+  body?: Record<string, any>;
+  /** Display options for TanStack AI Devtools. */
+  devtools?: AIDevtoolsDisplayOptions;
+  /**
+   * Callback when images are generated. Can optionally return a transformed value.
+   *
+   * - Return a non-null value to transform and store it as the result
+   * - Return `null` to keep the previous result unchanged
+   * - Return nothing (`void`) to store the raw result as-is
+   */
+  onResult?: (result: ImageGenerationResult) => TOutput | null | void;
+  /** Callback when an error occurs */
+  onError?: (error: Error) => void;
+  /** Callback when progress is reported (0-100) */
+  onProgress?: (progress: number, message?: string) => void;
+  /** Callback for each stream chunk (connect-based adapter mode only) */
+  onChunk?: (chunk: StreamChunk) => void;
+}
+/**
+ * Return type for the useGenerateImage hook.
+ *
+ * @template TOutput - The transformed output type (defaults to ImageGenerationResult)
+ */
+interface UseGenerateImageReturn<TOutput = ImageGenerationResult> {
+  /** Trigger image generation */
+  generate: (input: ImageGenerateInput) => Promise<void>;
+  /** The generation result containing images, or null */
+  result: Accessor<TOutput | null>;
+  /** Whether generation is in progress */
+  isLoading: Accessor<boolean>;
+  /** Current error, if any */
+  error: Accessor<Error | undefined>;
+  /** Current state of the generation */
+  status: Accessor<GenerationClientState>;
+  /** Abort the current generation */
+  stop: () => void;
+  /** Clear result, error, and return to idle */
+  reset: () => void;
+}
+/**
+ * Solid hook for generating images using AI models.
+ *
+ * Supports two transport modes:
+ * - **ConnectConnectionAdapter** -- Streaming transport (SSE, HTTP stream, custom)
+ * - **Fetcher** -- Direct async function call
+ *
+ * @example
+ * ```tsx
+ * import { useGenerateImage } from '@tanstack/ai-solid'
+ * import { fetchServerSentEvents } from '@tanstack/ai-client'
+ *
+ * function ImageGenerator() {
+ *   const { generate, result, isLoading, error, reset } = useGenerateImage({
+ *     connection: fetchServerSentEvents('/api/generate/image'),
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => generate({ prompt: 'A sunset over mountains' })}>
+ *         Generate
+ *       </button>
+ *       {isLoading() && <p>Generating...</p>}
+ *       {error() && <p>Error: {error()!.message}</p>}
+ *       {result()?.images.map((img, i) => (
+ *         <img src={img.url || `data:image/png;base64,${img.b64Json}`} />
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useGenerateImage<TOnResult extends ((result: ImageGenerationResult) => any) | undefined = undefined>(options: Omit<UseGenerateImageOptions, 'onResult'> & {
+  onResult?: TOnResult;
+}): UseGenerateImageReturn<InferGenerationOutput<ImageGenerationResult, TOnResult>>;
+//#endregion
+export { UseGenerateImageOptions, UseGenerateImageReturn, useGenerateImage };
+//# sourceMappingURL=use-generate-image.d.ts.map