@tanstack/ai-client 0.18.4 → 0.18.5

package/dist/esm/tool-types.d.ts

@@ -1,20 +0,0 @@
-import { AnyClientTool, InferToolInput, InferToolOutput } from '@tanstack/ai/client';
-/**
- * Extract all tool names from a tools array as a union type
- */
-export type ExtractToolNames<TTools extends ReadonlyArray<AnyClientTool>> = TTools[number]['name'];
-/**
- * Find a tool by name in the tools array
- */
-type FindTool<TTools extends ReadonlyArray<AnyClientTool>, TName extends string> = Extract<TTools[number], {
-    name: TName;
-}>;
-/**
- * Extract the input type for a specific tool by name
- */
-export type ExtractToolInput<TTools extends ReadonlyArray<AnyClientTool>, TName extends string> = TName extends ExtractToolNames<TTools> ? InferToolInput<FindTool<TTools, TName>> : any;
-/**
- * Extract the output type for a specific tool by name
- */
-export type ExtractToolOutput<TTools extends ReadonlyArray<AnyClientTool>, TName extends string> = TName extends ExtractToolNames<TTools> ? InferToolOutput<FindTool<TTools, TName>> : any;
-export {};

package/dist/esm/types.d.ts

@@ -1,419 +0,0 @@
-import { AnyClientTool, AudioPart, ChunkStrategy, ContentPart, DocumentPart, ImagePart, InferToolInput, InferToolOutput, ModelMessage, StreamChunk, StructuredOutputPart, VideoPart } from '@tanstack/ai/client';
-import { ConnectionAdapter } from './connection-adapters.js';
-import { AIDevtoolsClientMetadata } from './devtools.js';
-import { ChatDevtoolsBridgeFactory } from './devtools-noop.js';
-export type { StructuredOutputPart } from '@tanstack/ai/client';
-/**
- * `messages` is the full UIMessage history (not a delta). `data` is the
- * merged body — `ChatClientOptions.body` plus any per-call data passed to
- * `sendMessage(...)`. `threadId` / `runId` are the AG-UI correlation ids
- * the chat client uses to track this turn — forward them to your server
- * if it needs to correlate requests.
- */
-export interface ChatFetcherInput {
-    messages: Array<UIMessage>;
-    data?: Record<string, unknown>;
-    threadId: string;
-    runId: string;
-}
-export interface ChatFetcherOptions {
-    /** Fires when `stop()` is called or the request is superseded. */
-    signal: AbortSignal;
-}
-/**
- * Direct function that performs a chat request. Mirrors
- * `GenerationFetcher`. Returns either a `Response` (SSE body parsed by the
- * chat client) or an `AsyncIterable<StreamChunk>` (yielded directly). May
- * return the value synchronously, as a `Promise`, or as an async generator
- * (`async function*`) — the chat client awaits whichever shape is returned.
- *
- * @example
- * ```ts
- * useChat({
- *   fetcher: ({ messages }, { signal }) =>
- *     chatFn({ data: { messages }, signal }),
- * })
- * ```
- */
-export type ChatFetcher = (input: ChatFetcherInput, options: ChatFetcherOptions) => Response | AsyncIterable<StreamChunk> | Promise<Response | AsyncIterable<StreamChunk>>;
-/**
- * Distributive `Omit` — applies `Omit<O, K>` per branch of a union so
- * discriminated unions survive omission. Plain `Omit` collapses unions
- * into a single object shape, which would erase the `ChatTransport` XOR
- * when framework hooks omit React-managed callbacks from
- * `ChatClientOptions`.
- */
-export type DistributedOmit<TObject, TKeys extends keyof any> = TObject extends unknown ? Omit<TObject, TKeys> : never;
-/**
- * Discriminated union enforcing that exactly one of `connection` or
- * `fetcher` is provided. Mirrors `GenerationTransport`.
- */
-export type ChatTransport = {
-    connection: ConnectionAdapter;
-    fetcher?: never;
-} | {
-    fetcher: ChatFetcher;
-    connection?: never;
-};
-/**
- * Tool call states - track the lifecycle of a tool call
- */
-export type ToolCallState = 'awaiting-input' | 'input-streaming' | 'input-complete' | 'approval-requested' | 'approval-responded' | 'complete' | 'error';
-/**
- * Tool result states - track the lifecycle of a tool result
- */
-export type ToolResultState = 'streaming' | 'complete' | 'error';
-/**
- * ChatClient state - track the lifecycle of a chat
- */
-export type ChatClientState = 'ready' | 'submitted' | 'streaming' | 'error';
-/**
- * Connection lifecycle state for the subscription loop.
- */
-export type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
-/**
- * Multimodal content input for sending messages with rich media.
- * Allows sending text, images, audio, video, and documents to the LLM.
- *
- * @example
- * ```ts
- * // Send an image with a question
- * client.sendMessage({
- *   content: [
- *     { type: 'text', content: 'What is in this image?' },
- *     { type: 'image', source: { type: 'url', value: 'https://example.com/photo.jpg' } }
- *   ],
- *   id: 'custom-message-id' // optional
- * })
- * ```
- */
-export interface MultimodalContent {
-    /**
-     * The content of the message.
-     * Can be a simple string or an array of content parts for multimodal messages.
-     */
-    content: string | Array<ContentPart>;
-    /**
-     * Optional custom ID for the message.
-     * If not provided, a unique ID will be generated.
-     */
-    id?: string;
-}
-/**
- * Message parts - building blocks of UIMessage
- */
-export interface TextPart {
-    type: 'text';
-    content: string;
-}
-/**
- * Helper type that creates a tool-call part for a specific tool.
- * This is a conditional type to enable proper distribution over union types,
- * creating a discriminated union where `name` is the discriminant.
- */
-type ToolCallPartForTool<T> = T extends AnyClientTool ? {
-    type: 'tool-call';
-    id: string;
-    name: T['name'];
-    arguments: string;
-    /** Parsed tool input (typed from inputSchema) */
-    input?: InferToolInput<T>;
-    state: ToolCallState;
-    /** Approval metadata if tool requires user approval */
-    approval?: {
-        id: string;
-        needsApproval: boolean;
-        approved?: boolean;
-    };
-    /** Tool execution output (for client tools or after approval) */
-    output?: InferToolOutput<T>;
-} : never;
-/**
- * Fallback tool-call part type when tools are not typed
- */
-type UntypedToolCallPart = {
-    type: 'tool-call';
-    id: string;
-    name: string;
-    arguments: string;
-    input?: any;
-    state: ToolCallState;
-    approval?: {
-        id: string;
-        needsApproval: boolean;
-        approved?: boolean;
-    };
-    output?: any;
-};
-/**
- * Tool call part that creates a proper discriminated union.
- * When TTools is typed, checking `part.name === 'toolName'` will narrow
- * `part.output` to the correct type for that tool.
- *
- * The discriminant is `name`, so code like:
- * ```ts
- * if (part.name === 'recommendGuitar') {
- *   // part.output is now typed to the recommendGuitar tool's output
- * }
- * ```
- */
-export type ToolCallPart<TTools extends ReadonlyArray<AnyClientTool> = any> = [
-    TTools
-] extends [never] ? UntypedToolCallPart : unknown extends TTools ? UntypedToolCallPart : TTools extends ReadonlyArray<infer Tool> ? Tool extends AnyClientTool ? ToolCallPartForTool<Tool> : UntypedToolCallPart : UntypedToolCallPart;
-export interface ToolResultPart {
-    type: 'tool-result';
-    toolCallId: string;
-    content: string | Array<ContentPart>;
-    state: ToolResultState;
-    error?: string;
-}
-export interface ThinkingPart {
-    type: 'thinking';
-    content: string;
-}
-export type MessagePart<TTools extends ReadonlyArray<AnyClientTool> = any, TData = unknown> = TextPart | ImagePart | AudioPart | VideoPart | DocumentPart | ToolCallPart<TTools> | ToolResultPart | ThinkingPart | StructuredOutputPart<TData>;
-/**
- * UIMessage - Domain-specific message format optimized for building chat UIs
- * Contains parts that can be text, tool calls, or tool results.
- *
- * `TTools` narrows the tool-call/result part types based on the registered
- * tools. `TData` is the schema-inferred type for any `structured-output` part
- * on the message — defaulted to `unknown` so untyped consumers (the core
- * stream processor, the wire converter) don't need to thread a schema generic
- * everywhere; the hook layer (`useChat({ outputSchema })`) substitutes it on
- * the public return so `m.parts.find(p => p.type === 'structured-output').data`
- * is typed without manual casts.
- */
-export interface UIMessage<TTools extends ReadonlyArray<AnyClientTool> = any, TData = unknown> {
-    id: string;
-    role: 'system' | 'user' | 'assistant';
-    parts: Array<MessagePart<TTools, TData>>;
-    createdAt?: Date;
-}
-export interface ChatClientPersistence<TTools extends ReadonlyArray<AnyClientTool> = any> {
-    getItem: (id: string) => Array<UIMessage<TTools>> | null | undefined | Promise<Array<UIMessage<TTools>> | null | undefined>;
-    setItem: (id: string, messages: Array<UIMessage<TTools>>) => void | Promise<void>;
-    removeItem: (id: string) => void | Promise<void>;
-}
-type IsUnknown<T> = unknown extends T ? [T] extends [unknown] ? true : false : false;
-type KnownContext<T> = IsUnknown<T> extends true ? never : T;
-type MergeContext<TLeft, TRight> = [TLeft] extends [never] ? TRight : [TRight] extends [never] ? TLeft : TLeft & TRight;
-type UnionToIntersection<T> = [T] extends [never] ? never : (T extends unknown ? (value: T) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
-type DefinedContext<T> = Exclude<T, undefined>;
-type ContextFromExecute<T> = T extends (...args: any) => any ? NonNullable<Parameters<T>[1]> extends {
-    context: infer TContext;
-} ? KnownContext<TContext> : never : never;
-type ContextFromClientTool<T> = T extends AnyClientTool ? T extends {
-    execute?: infer TExecute;
-} ? ContextFromExecute<TExecute> : never : never;
-type RequiredContextFromClientToolUnion<T> = T extends unknown ? undefined extends ContextFromClientTool<T> ? never : ContextFromClientTool<T> : never;
-type ContextFromClientToolUnion<T> = [
-    UnionToIntersection<DefinedContext<ContextFromClientTool<T>>>
-] extends [never] ? never : [RequiredContextFromClientToolUnion<T>] extends [never] ? UnionToIntersection<DefinedContext<ContextFromClientTool<T>>> | undefined : UnionToIntersection<DefinedContext<ContextFromClientTool<T>>>;
-type ContextFromClientTools<TTools> = IsUnknown<TTools> extends true ? never : TTools extends readonly [infer THead, ...infer TTail] ? MergeContext<ContextFromClientTool<THead>, ContextFromClientTools<TTail>> : TTools extends ReadonlyArray<infer TItem> ? ContextFromClientToolUnion<TItem> : never;
-export type InferredClientContext<TTools> = [
-    ContextFromClientTools<TTools>
-] extends [never] ? unknown : ContextFromClientTools<TTools>;
-export type ClientContextOptionFromTools<TTools, TContext> = [
-    ContextFromClientTools<TTools>
-] extends [never] ? {
-    context?: TContext;
-} : undefined extends ContextFromClientTools<TTools> ? {
-    context?: TContext & ContextFromClientTools<TTools>;
-} : {
-    context: TContext & ContextFromClientTools<TTools>;
-};
-/**
- * Base options for `ChatClient`, excluding the transport (`connection` or
- * `fetcher`) which is supplied separately via `ChatTransport` so the XOR
- * is preserved when composing the final `ChatClientOptions` type.
- */
-export interface ChatClientBaseOptions<TTools extends ReadonlyArray<AnyClientTool> = any, TContext = unknown> {
-    /**
-     * Initial messages to populate the chat
-     */
-    initialMessages?: Array<UIMessage<TTools>>;
-    /**
-     * Optional persistence adapter for chat messages.
-     */
-    persistence?: ChatClientPersistence<TTools>;
-    /**
-     * Unique identifier for this chat instance
-     * Used for managing multiple chats
-     */
-    id?: string;
-    /**
-     * Thread ID to use for this chat session. Persists across sends within
-     * the session. If omitted, a unique thread ID is generated.
-     */
-    threadId?: string;
-    /**
-     * Arbitrary client-controlled JSON forwarded to the server in the
-     * AG-UI `RunAgentInput.forwardedProps` field. Use this for per-session
-     * options like provider/model selection or feature flags that the
-     * server endpoint should read.
-     *
-     * Replaces the legacy `body` option. If both are provided,
-     * `forwardedProps` wins on key collision.
-     */
-    forwardedProps?: Record<string, any>;
-    /**
-     * @deprecated Use `forwardedProps` instead. `body` continues to work
-     * unchanged — its values are merged into the AG-UI
-     * `RunAgentInput.forwardedProps` field on the wire and are also
-     * mirrored under the legacy `data` field for servers that have not
-     * migrated yet. Will be removed in a future major release.
-     */
-    body?: Record<string, any>;
-    /**
-     * Client-local runtime context passed to client tool implementations.
-     *
-     * This value is not serialized to the server. Use `forwardedProps` for
-     * explicit client-to-server handoff of serializable values.
-     */
-    context?: TContext;
-    /**
-     * Callback when a response is received
-     */
-    onResponse?: (response?: Response) => void | Promise<void>;
-    /**
-     * Callback when a stream chunk is received
-     */
-    onChunk?: (chunk: StreamChunk) => void;
-    /**
-     * Callback when the response is finished
-     */
-    onFinish?: (message: UIMessage<TTools>) => void;
-    /**
-     * Callback when an error occurs
-     */
-    onError?: (error: Error) => void;
-    /**
-     * Callback when messages change
-     */
-    onMessagesChange?: (messages: Array<UIMessage<TTools>>) => void;
-    /**
-     * Callback when loading state changes
-     */
-    onLoadingChange?: (isLoading: boolean) => void;
-    /**
-     * Callback when error state changes
-     */
-    onErrorChange?: (error: Error | undefined) => void;
-    /**
-     * Callback when chat status changes
-     */
-    onStatusChange?: (status: ChatClientState) => void;
-    /**
-     * Callback when subscription lifecycle changes.
-     * This is independent from request lifecycle (`isLoading`, `status`).
-     */
-    onSubscriptionChange?: (isSubscribed: boolean) => void;
-    /**
-     * Callback when connection lifecycle changes.
-     */
-    onConnectionStatusChange?: (status: ConnectionStatus) => void;
-    /**
-     * Callback when session generation activity changes.
-     * Derived from stream run events (RUN_STARTED / RUN_FINISHED / RUN_ERROR).
-     * Unlike `onLoadingChange` (request-local), this reflects shared generation
-     * activity visible to all subscribers (e.g. across tabs/devices).
-     */
-    onSessionGeneratingChange?: (isGenerating: boolean) => void;
-    /**
-     * Callback when a custom event is received from a server-side tool.
-     * Custom events are emitted by tools using `context.emitCustomEvent()` during execution.
-     *
-     * @param eventType - The name of the custom event
-     * @param data - The event payload data
-     * @param context - Additional context including the toolCallId that emitted the event
-     */
-    onCustomEvent?: (eventType: string, data: unknown, context: {
-        toolCallId?: string;
-    }) => void;
-    /**
-     * Client-side tools with execution logic
-     * When provided, tools with execute functions will be called automatically
-     */
-    tools?: TTools;
-    /**
-     * Devtools hook metadata for this client instance.
-     */
-    devtools?: Partial<AIDevtoolsClientMetadata>;
-    /**
-     * Factory that constructs the devtools bridge. Default is a no-op
-     * factory, which keeps `@tanstack/ai-client/devtools` (the heavy
-     * bridge implementation) out of the main entry's bundle. Frameworks
-     * that need live devtools should pass the real factory from
-     * `@tanstack/ai-client/devtools`.
-     */
-    devtoolsBridgeFactory?: ChatDevtoolsBridgeFactory;
-    /**
-     * Stream processing options (optional)
-     * Configure chunking strategy
-     */
-    streamProcessor?: {
-        /**
-         * Strategy for when to emit text updates
-         * Defaults to ImmediateStrategy (every chunk)
-         */
-        chunkStrategy?: ChunkStrategy;
-    };
-}
-/**
- * Options for `ChatClient`. Exactly one of `connection` or `fetcher` must be
- * provided — the type-level XOR is enforced via `ChatTransport`.
- */
-export type ChatClientOptions<TTools extends ReadonlyArray<AnyClientTool> = any, TContext = InferredClientContext<TTools>> = DistributedOmit<ChatClientBaseOptions<TTools, TContext>, 'context'> & ClientContextOptionFromTools<TTools, TContext> & ChatTransport;
-export interface ChatRequestBody {
-    messages: Array<ModelMessage>;
-    data?: Record<string, any>;
-}
-/**
- * Create a typed array of client tools with proper type inference.
- * This eliminates the need for `as const` when defining tool arrays.
- *
- * @example
- * ```ts
- * const tools = clientTools(
- *   myTool1.client(() => result1),
- *   myTool2.client(() => result2),
- * )
- *
- * // tools is now properly typed as a tuple with literal tool names
- * // This enables type narrowing when checking part.name === 'toolName'
- * ```
- */
-export declare function clientTools<const T extends Array<AnyClientTool>>(...tools: T): T;
-/**
- * Helper to create typed chat client options
- * Use this to get proper type inference for messages
- *
- * @example
- * ```ts
- * const tools = clientTools(myTool1, myTool2)
- *
- * const chatOptions = createChatClientOptions({
- *   connection: fetchServerSentEvents('/api/chat'),
- *   tools,
- * })
- *
- * type MyMessages = InferChatMessages<typeof chatOptions>
- * ```
- */
-export declare function createChatClientOptions<const TTools extends ReadonlyArray<AnyClientTool>, TContext = InferredClientContext<TTools>>(options: ChatClientOptions<TTools, TContext>): ChatClientOptions<TTools, TContext>;
-/**
- * Extract the message type from chat options
- *
- * @example
- * ```ts
- * const chatOptions = createChatClientOptions({
- *   connection: fetchServerSentEvents('/api/chat'),
- *   tools: [myTool1, myTool2],
- * })
- *
- * type MyMessages = InferChatMessages<typeof chatOptions>
- * // MyMessages is now Array<UIMessage<[typeof myTool1, typeof myTool2]>>
- * ```
- */
-export type InferChatMessages<T> = T extends ChatClientOptions<infer TTools, any> ? Array<UIMessage<TTools>> : never;

package/dist/esm/types.js

@@ -1,11 +0,0 @@
-function clientTools(...tools) {
-  return tools;
-}
-function createChatClientOptions(options) {
-  return options;
-}
-export {
-  clientTools,
-  createChatClientOptions
-};
-//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sources":["../../src/types.ts"],"sourcesContent":["import type {\n  AnyClientTool,\n  AudioPart,\n  ChunkStrategy,\n  ContentPart,\n  DocumentPart,\n  ImagePart,\n  InferToolInput,\n  InferToolOutput,\n  ModelMessage,\n  StreamChunk,\n  StructuredOutputPart,\n  VideoPart,\n} from '@tanstack/ai/client'\nimport type { ConnectionAdapter } from './connection-adapters'\nimport type { AIDevtoolsClientMetadata } from './devtools'\nimport type { ChatDevtoolsBridgeFactory } from './devtools-noop'\n\nexport type { StructuredOutputPart } from '@tanstack/ai/client'\n\n/**\n * `messages` is the full UIMessage history (not a delta). `data` is the\n * merged body — `ChatClientOptions.body` plus any per-call data passed to\n * `sendMessage(...)`. `threadId` / `runId` are the AG-UI correlation ids\n * the chat client uses to track this turn — forward them to your server\n * if it needs to correlate requests.\n */\nexport interface ChatFetcherInput {\n  messages: Array<UIMessage>\n  data?: Record<string, unknown>\n  threadId: string\n  runId: string\n}\n\nexport interface ChatFetcherOptions {\n  /** Fires when `stop()` is called or the request is superseded. */\n  signal: AbortSignal\n}\n\n/**\n * Direct function that performs a chat request. Mirrors\n * `GenerationFetcher`. Returns either a `Response` (SSE body parsed by the\n * chat client) or an `AsyncIterable<StreamChunk>` (yielded directly). May\n * return the value synchronously, as a `Promise`, or as an async generator\n * (`async function*`) — the chat client awaits whichever shape is returned.\n *\n * @example\n * ```ts\n * useChat({\n *   fetcher: ({ messages }, { signal }) =>\n *     chatFn({ data: { messages }, signal }),\n * })\n * ```\n */\nexport type ChatFetcher = (\n  input: ChatFetcherInput,\n  options: ChatFetcherOptions,\n) =>\n  | Response\n  | AsyncIterable<StreamChunk>\n  | Promise<Response | AsyncIterable<StreamChunk>>\n\n/**\n * Distributive `Omit` — applies `Omit<O, K>` per branch of a union so\n * discriminated unions survive omission. Plain `Omit` collapses unions\n * into a single object shape, which would erase the `ChatTransport` XOR\n * when framework hooks omit React-managed callbacks from\n * `ChatClientOptions`.\n */\nexport type DistributedOmit<\n  TObject,\n  TKeys extends keyof any,\n> = TObject extends unknown ? Omit<TObject, TKeys> : never\n\n/**\n * Discriminated union enforcing that exactly one of `connection` or\n * `fetcher` is provided. Mirrors `GenerationTransport`.\n */\nexport type ChatTransport =\n  | { connection: ConnectionAdapter; fetcher?: never }\n  | { fetcher: ChatFetcher; connection?: never }\n\n/**\n * Tool call states - track the lifecycle of a tool call\n */\nexport type ToolCallState =\n  | 'awaiting-input' // Received start but no arguments yet\n  | 'input-streaming' // Partial arguments received\n  | 'input-complete' // All arguments received\n  | 'approval-requested' // Waiting for user approval\n  | 'approval-responded' // User has approved/denied\n  | 'complete' // Result is complete\n  | 'error' // Tool execution failed (terminal)\n\n/**\n * Tool result states - track the lifecycle of a tool result\n */\nexport type ToolResultState =\n  | 'streaming' // Placeholder for future streamed output\n  | 'complete' // Result is complete\n  | 'error' // Error occurred\n\n/**\n * ChatClient state - track the lifecycle of a chat\n */\nexport type ChatClientState = 'ready' | 'submitted' | 'streaming' | 'error'\n\n/**\n * Connection lifecycle state for the subscription loop.\n */\nexport type ConnectionStatus =\n  | 'disconnected'\n  | 'connecting'\n  | 'connected'\n  | 'error'\n\n/**\n * Multimodal content input for sending messages with rich media.\n * Allows sending text, images, audio, video, and documents to the LLM.\n *\n * @example\n * ```ts\n * // Send an image with a question\n * client.sendMessage({\n *   content: [\n *     { type: 'text', content: 'What is in this image?' },\n *     { type: 'image', source: { type: 'url', value: 'https://example.com/photo.jpg' } }\n *   ],\n *   id: 'custom-message-id' // optional\n * })\n * ```\n */\nexport interface MultimodalContent {\n  /**\n   * The content of the message.\n   * Can be a simple string or an array of content parts for multimodal messages.\n   */\n  content: string | Array<ContentPart>\n  /**\n   * Optional custom ID for the message.\n   * If not provided, a unique ID will be generated.\n   */\n  id?: string\n}\n\n/**\n * Message parts - building blocks of UIMessage\n */\nexport interface TextPart {\n  type: 'text'\n  content: string\n}\n\n/**\n * Helper type that creates a tool-call part for a specific tool.\n * This is a conditional type to enable proper distribution over union types,\n * creating a discriminated union where `name` is the discriminant.\n */\ntype ToolCallPartForTool<T> = T extends AnyClientTool\n  ? {\n      type: 'tool-call'\n      id: string\n      name: T['name']\n      arguments: string // JSON string (may be incomplete)\n      /** Parsed tool input (typed from inputSchema) */\n      input?: InferToolInput<T>\n      state: ToolCallState\n      /** Approval metadata if tool requires user approval */\n      approval?: {\n        id: string // Unique approval ID\n        needsApproval: boolean // Always true if present\n        approved?: boolean // User's decision (undefined until responded)\n      }\n      /** Tool execution output (for client tools or after approval) */\n      output?: InferToolOutput<T>\n    }\n  : never\n\n/**\n * Fallback tool-call part type when tools are not typed\n */\ntype UntypedToolCallPart = {\n  type: 'tool-call'\n  id: string\n  name: string\n  arguments: string\n  input?: any\n  state: ToolCallState\n  approval?: {\n    id: string\n    needsApproval: boolean\n    approved?: boolean\n  }\n  output?: any\n}\n\n/**\n * Tool call part that creates a proper discriminated union.\n * When TTools is typed, checking `part.name === 'toolName'` will narrow\n * `part.output` to the correct type for that tool.\n *\n * The discriminant is `name`, so code like:\n * ```ts\n * if (part.name === 'recommendGuitar') {\n *   // part.output is now typed to the recommendGuitar tool's output\n * }\n * ```\n */\nexport type ToolCallPart<TTools extends ReadonlyArray<AnyClientTool> = any> =\n  // Check if we have a concrete tools array (not 'any' or 'never')\n  [TTools] extends [never]\n    ? UntypedToolCallPart\n    : unknown extends TTools\n      ? UntypedToolCallPart\n      : TTools extends ReadonlyArray<infer Tool>\n        ? Tool extends AnyClientTool\n          ? ToolCallPartForTool<Tool>\n          : UntypedToolCallPart\n        : UntypedToolCallPart\n\nexport interface ToolResultPart {\n  type: 'tool-result'\n  toolCallId: string\n  content: string | Array<ContentPart>\n  state: ToolResultState\n  error?: string // Error message if state is \"error\"\n}\n\nexport interface ThinkingPart {\n  type: 'thinking'\n  content: string\n}\n\nexport type MessagePart<\n  TTools extends ReadonlyArray<AnyClientTool> = any,\n  TData = unknown,\n> =\n  | TextPart\n  | ImagePart\n  | AudioPart\n  | VideoPart\n  | DocumentPart\n  | ToolCallPart<TTools>\n  | ToolResultPart\n  | ThinkingPart\n  | StructuredOutputPart<TData>\n\n/**\n * UIMessage - Domain-specific message format optimized for building chat UIs\n * Contains parts that can be text, tool calls, or tool results.\n *\n * `TTools` narrows the tool-call/result part types based on the registered\n * tools. `TData` is the schema-inferred type for any `structured-output` part\n * on the message — defaulted to `unknown` so untyped consumers (the core\n * stream processor, the wire converter) don't need to thread a schema generic\n * everywhere; the hook layer (`useChat({ outputSchema })`) substitutes it on\n * the public return so `m.parts.find(p => p.type === 'structured-output').data`\n * is typed without manual casts.\n */\nexport interface UIMessage<\n  TTools extends ReadonlyArray<AnyClientTool> = any,\n  TData = unknown,\n> {\n  id: string\n  role: 'system' | 'user' | 'assistant'\n  parts: Array<MessagePart<TTools, TData>>\n  createdAt?: Date\n}\n\nexport interface ChatClientPersistence<\n  TTools extends ReadonlyArray<AnyClientTool> = any,\n> {\n  getItem: (\n    id: string,\n  ) =>\n    | Array<UIMessage<TTools>>\n    | null\n    | undefined\n    | Promise<Array<UIMessage<TTools>> | null | undefined>\n  setItem: (\n    id: string,\n    messages: Array<UIMessage<TTools>>,\n  ) => void | Promise<void>\n  removeItem: (id: string) => void | Promise<void>\n}\n\ntype IsUnknown<T> = unknown extends T\n  ? [T] extends [unknown]\n    ? true\n    : false\n  : false\n\ntype KnownContext<T> = IsUnknown<T> extends true ? never : T\n\ntype MergeContext<TLeft, TRight> = [TLeft] extends [never]\n  ? TRight\n  : [TRight] extends [never]\n    ? TLeft\n    : TLeft & TRight\n\ntype UnionToIntersection<T> = [T] extends [never]\n  ? never\n  : (T extends unknown ? (value: T) => void : never) extends (\n        value: infer TIntersection,\n      ) => void\n    ? TIntersection\n    : never\n\ntype DefinedContext<T> = Exclude<T, undefined>\n\ntype ContextFromExecute<T> = T extends (...args: any) => any\n  ? NonNullable<Parameters<T>[1]> extends { context: infer TContext }\n    ? KnownContext<TContext>\n    : never\n  : never\n\ntype ContextFromClientTool<T> = T extends AnyClientTool\n  ? T extends { execute?: infer TExecute }\n    ? ContextFromExecute<TExecute>\n    : never\n  : never\n\ntype RequiredContextFromClientToolUnion<T> = T extends unknown\n  ? undefined extends ContextFromClientTool<T>\n    ? never\n    : ContextFromClientTool<T>\n  : never\n\ntype ContextFromClientToolUnion<T> = [\n  UnionToIntersection<DefinedContext<ContextFromClientTool<T>>>,\n] extends [never]\n  ? never\n  : [RequiredContextFromClientToolUnion<T>] extends [never]\n    ? UnionToIntersection<DefinedContext<ContextFromClientTool<T>>> | undefined\n    : UnionToIntersection<DefinedContext<ContextFromClientTool<T>>>\n\ntype ContextFromClientTools<TTools> =\n  IsUnknown<TTools> extends true\n    ? never\n    : TTools extends readonly [infer THead, ...infer TTail]\n      ? MergeContext<\n          ContextFromClientTool<THead>,\n          ContextFromClientTools<TTail>\n        >\n      : TTools extends ReadonlyArray<infer TItem>\n        ? ContextFromClientToolUnion<TItem>\n        : never\n\nexport type InferredClientContext<TTools> = [\n  ContextFromClientTools<TTools>,\n] extends [never]\n  ? unknown\n  : ContextFromClientTools<TTools>\n\nexport type ClientContextOptionFromTools<TTools, TContext> = [\n  ContextFromClientTools<TTools>,\n] extends [never]\n  ? { context?: TContext }\n  : undefined extends ContextFromClientTools<TTools>\n    ? { context?: TContext & ContextFromClientTools<TTools> }\n    : { context: TContext & ContextFromClientTools<TTools> }\n\n/**\n * Base options for `ChatClient`, excluding the transport (`connection` or\n * `fetcher`) which is supplied separately via `ChatTransport` so the XOR\n * is preserved when composing the final `ChatClientOptions` type.\n */\nexport interface ChatClientBaseOptions<\n  TTools extends ReadonlyArray<AnyClientTool> = any,\n  TContext = unknown,\n> {\n  /**\n   * Initial messages to populate the chat\n   */\n  initialMessages?: Array<UIMessage<TTools>>\n\n  /**\n   * Optional persistence adapter for chat messages.\n   */\n  persistence?: ChatClientPersistence<TTools>\n\n  /**\n   * Unique identifier for this chat instance\n   * Used for managing multiple chats\n   */\n  id?: string\n\n  /**\n   * Thread ID to use for this chat session. Persists across sends within\n   * the session. If omitted, a unique thread ID is generated.\n   */\n  threadId?: string\n\n  /**\n   * Arbitrary client-controlled JSON forwarded to the server in the\n   * AG-UI `RunAgentInput.forwardedProps` field. Use this for per-session\n   * options like provider/model selection or feature flags that the\n   * server endpoint should read.\n   *\n   * Replaces the legacy `body` option. If both are provided,\n   * `forwardedProps` wins on key collision.\n   */\n  forwardedProps?: Record<string, any>\n\n  /**\n   * @deprecated Use `forwardedProps` instead. `body` continues to work\n   * unchanged — its values are merged into the AG-UI\n   * `RunAgentInput.forwardedProps` field on the wire and are also\n   * mirrored under the legacy `data` field for servers that have not\n   * migrated yet. Will be removed in a future major release.\n   */\n  body?: Record<string, any>\n\n  /**\n   * Client-local runtime context passed to client tool implementations.\n   *\n   * This value is not serialized to the server. Use `forwardedProps` for\n   * explicit client-to-server handoff of serializable values.\n   */\n  context?: TContext\n\n  /**\n   * Callback when a response is received\n   */\n  onResponse?: (response?: Response) => void | Promise<void>\n\n  /**\n   * Callback when a stream chunk is received\n   */\n  onChunk?: (chunk: StreamChunk) => void\n\n  /**\n   * Callback when the response is finished\n   */\n  onFinish?: (message: UIMessage<TTools>) => void\n\n  /**\n   * Callback when an error occurs\n   */\n  onError?: (error: Error) => void\n\n  /**\n   * Callback when messages change\n   */\n  onMessagesChange?: (messages: Array<UIMessage<TTools>>) => void\n\n  /**\n   * Callback when loading state changes\n   */\n  onLoadingChange?: (isLoading: boolean) => void\n\n  /**\n   * Callback when error state changes\n   */\n  onErrorChange?: (error: Error | undefined) => void\n\n  /**\n   * Callback when chat status changes\n   */\n  onStatusChange?: (status: ChatClientState) => void\n\n  /**\n   * Callback when subscription lifecycle changes.\n   * This is independent from request lifecycle (`isLoading`, `status`).\n   */\n  onSubscriptionChange?: (isSubscribed: boolean) => void\n\n  /**\n   * Callback when connection lifecycle changes.\n   */\n  onConnectionStatusChange?: (status: ConnectionStatus) => void\n\n  /**\n   * Callback when session generation activity changes.\n   * Derived from stream run events (RUN_STARTED / RUN_FINISHED / RUN_ERROR).\n   * Unlike `onLoadingChange` (request-local), this reflects shared generation\n   * activity visible to all subscribers (e.g. across tabs/devices).\n   */\n  onSessionGeneratingChange?: (isGenerating: boolean) => void\n\n  /**\n   * Callback when a custom event is received from a server-side tool.\n   * Custom events are emitted by tools using `context.emitCustomEvent()` during execution.\n   *\n   * @param eventType - The name of the custom event\n   * @param data - The event payload data\n   * @param context - Additional context including the toolCallId that emitted the event\n   */\n  onCustomEvent?: (\n    eventType: string,\n    data: unknown,\n    context: { toolCallId?: string },\n  ) => void\n\n  /**\n   * Client-side tools with execution logic\n   * When provided, tools with execute functions will be called automatically\n   */\n  tools?: TTools\n\n  /**\n   * Devtools hook metadata for this client instance.\n   */\n  devtools?: Partial<AIDevtoolsClientMetadata>\n\n  /**\n   * Factory that constructs the devtools bridge. Default is a no-op\n   * factory, which keeps `@tanstack/ai-client/devtools` (the heavy\n   * bridge implementation) out of the main entry's bundle. Frameworks\n   * that need live devtools should pass the real factory from\n   * `@tanstack/ai-client/devtools`.\n   */\n  devtoolsBridgeFactory?: ChatDevtoolsBridgeFactory\n\n  /**\n   * Stream processing options (optional)\n   * Configure chunking strategy\n   */\n  streamProcessor?: {\n    /**\n     * Strategy for when to emit text updates\n     * Defaults to ImmediateStrategy (every chunk)\n     */\n    chunkStrategy?: ChunkStrategy\n  }\n}\n\n/**\n * Options for `ChatClient`. Exactly one of `connection` or `fetcher` must be\n * provided — the type-level XOR is enforced via `ChatTransport`.\n */\nexport type ChatClientOptions<\n  TTools extends ReadonlyArray<AnyClientTool> = any,\n  TContext = InferredClientContext<TTools>,\n> = DistributedOmit<ChatClientBaseOptions<TTools, TContext>, 'context'> &\n  ClientContextOptionFromTools<TTools, TContext> &\n  ChatTransport\n\nexport interface ChatRequestBody {\n  messages: Array<ModelMessage>\n  data?: Record<string, any>\n}\n\n/**\n * Create a typed array of client tools with proper type inference.\n * This eliminates the need for `as const` when defining tool arrays.\n *\n * @example\n * ```ts\n * const tools = clientTools(\n *   myTool1.client(() => result1),\n *   myTool2.client(() => result2),\n * )\n *\n * // tools is now properly typed as a tuple with literal tool names\n * // This enables type narrowing when checking part.name === 'toolName'\n * ```\n */\nexport function clientTools<const T extends Array<AnyClientTool>>(\n  ...tools: T\n): T {\n  return tools\n}\n\n/**\n * Helper to create typed chat client options\n * Use this to get proper type inference for messages\n *\n * @example\n * ```ts\n * const tools = clientTools(myTool1, myTool2)\n *\n * const chatOptions = createChatClientOptions({\n *   connection: fetchServerSentEvents('/api/chat'),\n *   tools,\n * })\n *\n * type MyMessages = InferChatMessages<typeof chatOptions>\n * ```\n */\nexport function createChatClientOptions<\n  const TTools extends ReadonlyArray<AnyClientTool>,\n  TContext = InferredClientContext<TTools>,\n>(\n  options: ChatClientOptions<TTools, TContext>,\n): ChatClientOptions<TTools, TContext> {\n  return options\n}\n\n/**\n * Extract the message type from chat options\n *\n * @example\n * ```ts\n * const chatOptions = createChatClientOptions({\n *   connection: fetchServerSentEvents('/api/chat'),\n *   tools: [myTool1, myTool2],\n * })\n *\n * type MyMessages = InferChatMessages<typeof chatOptions>\n * // MyMessages is now Array<UIMessage<[typeof myTool1, typeof myTool2]>>\n * ```\n */\nexport type InferChatMessages<T> =\n  T extends ChatClientOptions<infer TTools, any>\n    ? Array<UIMessage<TTools>>\n    : never\n"],"names":[],"mappings":"AA8iBO,SAAS,eACX,OACA;AACH,SAAO;AACT;AAkBO,SAAS,wBAId,SACqC;AACrC,SAAO;AACT;"}

package/dist/esm/video-generation-client.d.ts

@@ -1,110 +0,0 @@
-import { ConnectConnectionAdapter } from './connection-adapters.js';
-import { GenerationClientState, GenerationFetcher, VideoGenerateInput, VideoGenerateResult, VideoGenerationClientOptions, VideoStatusInfo } from './generation-types.js';
-/**
- * A specialized client for job-based video generation.
- *
- * Video generation is asynchronous: a job is created, then polled for status
- * until completion. This client handles the full lifecycle.
- *
- * Supports two transport modes:
- * - **ConnectConnectionAdapter** — Server handles the polling loop internally and
- *   streams status updates via CUSTOM events.
- * - **Fetcher** — Direct async function that returns a completed
- *   `VideoGenerateResult`.
- *
- * @example
- * ```typescript
- * // With streaming connection adapter (server-driven polling)
- * const client = new VideoGenerationClient({
- *   connection: fetchServerSentEvents('/api/generate/video'),
- *   onResultChange: setResult,
- *   onVideoStatusChange: setVideoStatus,
- * })
- *
- * // With fetcher (direct result)
- * const client = new VideoGenerationClient({
- *   fetcher: async (input) => {
- *     const res = await fetch('/api/video/generate', {
- *       method: 'POST',
- *       body: JSON.stringify(input),
- *     })
- *     return res.json() // { jobId, status: 'completed', url, expiresAt }
- *   },
- * })
- *
- * await client.generate({ prompt: 'A flying car over a city' })
- * ```
- */
-export declare class VideoGenerationClient<TOutput = VideoGenerateResult> {
-    private readonly connection;
-    private readonly fetcher;
-    private readonly uniqueId;
-    private readonly devtoolsMetadata;
-    private readonly devtoolsBridge;
-    private readonly threadId;
-    private body;
-    private result;
-    private input;
-    private progress;
-    private jobId;
-    private videoStatus;
-    private isLoading;
-    private error;
-    private status;
-    private abortController;
-    private readonly callbacksRef;
-    private devtoolsMounted;
-    constructor(options: VideoGenerationClientOptions<TOutput> & ({
-        connection: ConnectConnectionAdapter;
-        fetcher?: never;
-    } | {
-        fetcher: GenerationFetcher<VideoGenerateInput, VideoGenerateResult>;
-        connection?: never;
-    }));
-    private buildDevtoolsBridgeOptions;
-    mountDevtools(): void;
-    /**
-     * Trigger video generation.
-     * Only one generation can be in-flight at a time.
-     */
-    generate(input: VideoGenerateInput): Promise<void>;
-    /**
-     * Direct fetcher mode: call fetcher and set result.
-     */
-    private generateWithFetcher;
-    /**
-     * Process a stream of AG-UI events from the streaming connection adapter.
-     * The server handles the polling loop and streams status updates.
-     */
-    private processStream;
-    /**
-     * Abort any in-flight generation or polling.
-     */
-    stop(): void;
-    /**
-     * Clear all state and return to idle.
-     */
-    reset(): void;
-    /**
-     * Update options without recreating the client.
-     */
-    updateOptions(options: Partial<Pick<VideoGenerationClientOptions<TOutput>, 'body' | 'onResult' | 'onError' | 'onProgress' | 'onChunk' | 'onJobCreated' | 'onStatusUpdate'>>): void;
-    dispose(): void;
-    getResult(): TOutput | null;
-    getJobId(): string | null;
-    getVideoStatus(): VideoStatusInfo | null;
-    getIsLoading(): boolean;
-    getError(): Error | undefined;
-    getStatus(): GenerationClientState;
-    private setResult;
-    private setJobId;
-    private setVideoStatus;
-    private setIsLoading;
-    private setError;
-    private setStatus;
-    private setProgress;
-    private createCompletedVideoStatus;
-    private createDevtoolsMetadata;
-    private generateUniqueId;
-    private createRunContext;
-}