@tanstack/ai 0.0.3 → 0.2.0

package/dist/esm/types.d.ts

@@ -1,6 +1,73 @@
-import { CommonOptions } from './core/chat-common-options.js';
-import { z } from 'zod';
-import { ToolCallState, ToolResultState } from './stream/types.js';
+import { StandardJSONSchemaV1 } from '@standard-schema/spec';
+/**
+ * Tool call states - track the lifecycle of a tool call
+ */
+export type ToolCallState = 'awaiting-input' | 'input-streaming' | 'input-complete' | 'approval-requested' | 'approval-responded';
+/**
+ * Tool result states - track the lifecycle of a tool result
+ */
+export type ToolResultState = 'streaming' | 'complete' | 'error';
+/**
+ * JSON Schema type for defining tool input/output schemas as raw JSON Schema objects.
+ * This allows tools to be defined without schema libraries when you have JSON Schema definitions available.
+ */
+export interface JSONSchema {
+    type?: string | Array<string>;
+    properties?: Record<string, JSONSchema>;
+    items?: JSONSchema | Array<JSONSchema>;
+    required?: Array<string>;
+    enum?: Array<unknown>;
+    const?: unknown;
+    description?: string;
+    default?: unknown;
+    $ref?: string;
+    $defs?: Record<string, JSONSchema>;
+    definitions?: Record<string, JSONSchema>;
+    allOf?: Array<JSONSchema>;
+    anyOf?: Array<JSONSchema>;
+    oneOf?: Array<JSONSchema>;
+    not?: JSONSchema;
+    if?: JSONSchema;
+    then?: JSONSchema;
+    else?: JSONSchema;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    additionalProperties?: boolean | JSONSchema;
+    additionalItems?: boolean | JSONSchema;
+    patternProperties?: Record<string, JSONSchema>;
+    propertyNames?: JSONSchema;
+    minProperties?: number;
+    maxProperties?: number;
+    title?: string;
+    examples?: Array<unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Union type for schema input - can be any Standard JSON Schema compliant schema or a plain JSONSchema object.
+ *
+ * Standard JSON Schema compliant libraries include:
+ * - Zod v4.2+ (natively supports StandardJSONSchemaV1)
+ * - ArkType v2.1.28+ (natively supports StandardJSONSchemaV1)
+ * - Valibot v1.2+ (via `toStandardJsonSchema()` from `@valibot/to-json-schema`)
+ *
+ * @see https://standardschema.dev/json-schema
+ */
+export type SchemaInput = StandardJSONSchemaV1<any, any> | JSONSchema;
+/**
+ * Infer the TypeScript type from a schema.
+ * For Standard JSON Schema compliant schemas, extracts the input type.
+ * For plain JSONSchema, returns `any` since we can't infer types from JSON Schema at compile time.
+ */
+export type InferSchemaType<T> = T extends StandardJSONSchemaV1<infer TInput, unknown> ? TInput : unknown;
 export interface ToolCall {
     id: string;
     type: 'function';
@@ -87,13 +154,13 @@ export interface DocumentPart<TMetadata = unknown> {
  * @template TVideoMeta - Provider-specific video metadata type
  * @template TDocumentMeta - Provider-specific document metadata type
  */
-export type ContentPart<TImageMeta = unknown, TAudioMeta = unknown, TVideoMeta = unknown, TDocumentMeta = unknown, TTextMeta = unknown> = TextPart<TTextMeta> | ImagePart<TImageMeta> | AudioPart<TAudioMeta> | VideoPart<TVideoMeta> | DocumentPart<TDocumentMeta>;
+export type ContentPart<TTextMeta = unknown, TImageMeta = unknown, TAudioMeta = unknown, TVideoMeta = unknown, TDocumentMeta = unknown> = TextPart<TTextMeta> | ImagePart<TImageMeta> | AudioPart<TAudioMeta> | VideoPart<TVideoMeta> | DocumentPart<TDocumentMeta>;
 /**
  * Helper type to filter ContentPart union to only include specific modalities.
  * Used to constrain message content based on model capabilities.
  */
-export type ContentPartForModalities<TModalities extends Modality, TImageMeta = unknown, TAudioMeta = unknown, TVideoMeta = unknown, TDocumentMeta = unknown, TTextMeta = unknown> = Extract<ContentPart<TImageMeta, TAudioMeta, TVideoMeta, TDocumentMeta, TTextMeta>, {
-    type: TModalities;
+export type ContentPartForInputModalitiesTypes<TInputModalitiesTypes extends InputModalitiesTypes> = Extract<ContentPart<TInputModalitiesTypes['messageMetadataByModality']['text'], TInputModalitiesTypes['messageMetadataByModality']['image'], TInputModalitiesTypes['messageMetadataByModality']['audio'], TInputModalitiesTypes['messageMetadataByModality']['video'], TInputModalitiesTypes['messageMetadataByModality']['document']>, {
+    type: TInputModalitiesTypes['inputModalities'][number];
 }>;
 /**
  * Helper type to convert a readonly array of modalities to a union type.
@@ -104,7 +171,7 @@ export type ModalitiesArrayToUnion<T extends ReadonlyArray<Modality>> = T[number
  * Type for message content constrained by supported modalities.
  * When modalities is ['text', 'image'], only TextPart and ImagePart are allowed in the array.
  */
-export type ConstrainedContent<TModalities extends ReadonlyArray<Modality>, TImageMeta = unknown, TAudioMeta = unknown, TVideoMeta = unknown, TDocumentMeta = unknown, TTextMeta = unknown> = string | null | Array<ContentPartForModalities<ModalitiesArrayToUnion<TModalities>, TImageMeta, TAudioMeta, TVideoMeta, TDocumentMeta, TTextMeta>>;
+export type ConstrainedContent<TInputModalitiesTypes extends InputModalitiesTypes> = string | null | Array<ContentPartForInputModalitiesTypes<TInputModalitiesTypes>>;
 export interface ModelMessage<TContent extends string | null | Array<ContentPart> = string | null | Array<ContentPart>> {
     role: 'user' | 'assistant' | 'tool';
     content: TContent;
@@ -157,12 +224,16 @@ export interface UIMessage {
     parts: Array<MessagePart>;
     createdAt?: Date;
 }
+export type InputModalitiesTypes = {
+    inputModalities: ReadonlyArray<Modality>;
+    messageMetadataByModality: DefaultMessageMetadataByModality;
+};
 /**
  * A ModelMessage with content constrained to only allow content parts
  * matching the specified input modalities.
  */
-export type ConstrainedModelMessage<TModalities extends ReadonlyArray<Modality>, TImageMeta = unknown, TAudioMeta = unknown, TVideoMeta = unknown, TDocumentMeta = unknown, TTextMeta = unknown> = Omit<ModelMessage, 'content'> & {
-    content: ConstrainedContent<TModalities, TImageMeta, TAudioMeta, TVideoMeta, TDocumentMeta, TTextMeta>;
+export type ConstrainedModelMessage<TInputModalitiesTypes extends InputModalitiesTypes> = Omit<ModelMessage, 'content'> & {
+    content: ConstrainedContent<TInputModalitiesTypes>;
 };
 /**
  * Tool/Function definition for function calling.
@@ -170,12 +241,14 @@ export type ConstrainedModelMessage<TModalities extends ReadonlyArray<Modality>,
  * Tools allow the model to interact with external systems, APIs, or perform computations.
  * The model will decide when to call tools based on the user's request and the tool descriptions.
  *
- * Tools use Zod schemas for runtime validation and type safety.
+ * Tools can use any Standard JSON Schema compliant library (Zod, ArkType, Valibot, etc.)
+ * or plain JSON Schema objects for runtime validation and type safety.
  *
  * @see https://platform.openai.com/docs/guides/function-calling
  * @see https://docs.anthropic.com/claude/docs/tool-use
+ * @see https://standardschema.dev/json-schema
  */
-export interface Tool<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType, TName extends string = string> {
+export interface Tool<TInput extends SchemaInput = SchemaInput, TOutput extends SchemaInput = SchemaInput, TName extends string = string> {
     /**
      * Unique name of the tool (used by the model to call it).
      *
@@ -195,33 +268,57 @@ export interface Tool<TInput extends z.ZodType = z.ZodType, TOutput extends z.Zo
      */
     description: string;
     /**
-     * Zod schema describing the tool's input parameters.
+     * Schema describing the tool's input parameters.
      *
+     * Can be any Standard JSON Schema compliant schema (Zod, ArkType, Valibot, etc.) or a plain JSON Schema object.
      * Defines the structure and types of arguments the tool accepts.
      * The model will generate arguments matching this schema.
-     * The schema is converted to JSON Schema for LLM providers.
+     * Standard JSON Schema compliant schemas are converted to JSON Schema for LLM providers.
      *
-     * @see https://zod.dev/
+     * @see https://standardschema.dev/json-schema
+     * @see https://json-schema.org/
      *
      * @example
+     * // Using Zod v4+ schema (natively supports Standard JSON Schema)
      * import { z } from 'zod';
-     *
      * z.object({
      *   location: z.string().describe("City name or coordinates"),
      *   unit: z.enum(["celsius", "fahrenheit"]).optional()
      * })
+     *
+     * @example
+     * // Using ArkType (natively supports Standard JSON Schema)
+     * import { type } from 'arktype';
+     * type({
+     *   location: 'string',
+     *   unit: "'celsius' | 'fahrenheit'"
+     * })
+     *
+     * @example
+     * // Using plain JSON Schema
+     * {
+     *   type: 'object',
+     *   properties: {
+     *     location: { type: 'string', description: 'City name or coordinates' },
+     *     unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
+     *   },
+     *   required: ['location']
+     * }
      */
     inputSchema?: TInput;
     /**
-     * Optional Zod schema for validating tool output.
+     * Optional schema for validating tool output.
      *
-     * If provided, tool results will be validated against this schema before
-     * being sent back to the model. This catches bugs in tool implementations
-     * and ensures consistent output formatting.
+     * Can be any Standard JSON Schema compliant schema or a plain JSON Schema object.
+     * If provided with a Standard Schema compliant schema, tool results will be validated
+     * against this schema before being sent back to the model. This catches bugs in tool
+     * implementations and ensures consistent output formatting.
      *
      * Note: This is client-side validation only - not sent to LLM providers.
+     * Note: Plain JSON Schema output validation is not performed at runtime.
      *
      * @example
+     * // Using Zod
      * z.object({
      *   temperature: z.number(),
      *   conditions: z.string(),
@@ -368,16 +465,68 @@ export type AgentLoopStrategy = (state: AgentLoopState) => boolean;
 /**
  * Options passed into the SDK and further piped to the AI provider.
  */
-export interface ChatOptions<TModel extends string = string, TProviderOptionsSuperset extends Record<string, any> = Record<string, any>, TOutput extends ResponseFormat<any> | undefined = undefined, TProviderOptionsForModel = TProviderOptionsSuperset> {
-    model: TModel;
+export interface TextOptions<TProviderOptionsSuperset extends Record<string, any> = Record<string, any>, TProviderOptionsForModel = TProviderOptionsSuperset> {
+    model: string;
     messages: Array<ModelMessage>;
-    tools?: Array<Tool>;
+    tools?: Array<Tool<any, any, any>>;
     systemPrompts?: Array<string>;
     agentLoopStrategy?: AgentLoopStrategy;
-    options?: CommonOptions;
-    providerOptions?: TProviderOptionsForModel;
+    /**
+     * Controls the randomness of the output.
+     * Higher values (e.g., 0.8) make output more random, lower values (e.g., 0.2) make it more focused and deterministic.
+     * Range: [0.0, 2.0]
+     *
+     * Note: Generally recommended to use either temperature or topP, but not both.
+     *
+     * Provider usage:
+     * - OpenAI: `temperature` (number) - in text.top_p field
+     * - Anthropic: `temperature` (number) - ranges from 0.0 to 1.0, default 1.0
+     * - Gemini: `generationConfig.temperature` (number) - ranges from 0.0 to 2.0
+     */
+    temperature?: number;
+    /**
+     * Nucleus sampling parameter. An alternative to temperature sampling.
+     * The model considers the results of tokens with topP probability mass.
+     * For example, 0.1 means only tokens comprising the top 10% probability mass are considered.
+     *
+     * Note: Generally recommended to use either temperature or topP, but not both.
+     *
+     * Provider usage:
+     * - OpenAI: `text.top_p` (number)
+     * - Anthropic: `top_p` (number | null)
+     * - Gemini: `generationConfig.topP` (number)
+     */
+    topP?: number;
+    /**
+     * The maximum number of tokens to generate in the response.
+     *
+     * Provider usage:
+     * - OpenAI: `max_output_tokens` (number) - includes visible output and reasoning tokens
+     * - Anthropic: `max_tokens` (number, required) - range x >= 1
+     * - Gemini: `generationConfig.maxOutputTokens` (number)
+     */
+    maxTokens?: number;
+    /**
+     * Additional metadata to attach to the request.
+     * Can be used for tracking, debugging, or passing custom information.
+     * Structure and constraints vary by provider.
+     *
+     * Provider usage:
+     * - OpenAI: `metadata` (Record<string, string>) - max 16 key-value pairs, keys max 64 chars, values max 512 chars
+     * - Anthropic: `metadata` (Record<string, any>) - includes optional user_id (max 256 chars)
+     * - Gemini: Not directly available in TextProviderOptions
+     */
+    metadata?: Record<string, any>;
+    modelOptions?: TProviderOptionsForModel;
     request?: Request | RequestInit;
-    output?: TOutput;
+    /**
+     * Schema for structured output.
+     * When provided, the adapter should use the provider's native structured output API
+     * to ensure the response conforms to this schema.
+     * The schema will be converted to JSON Schema format before being sent to the provider.
+     * Supports any Standard JSON Schema compliant library (Zod, ArkType, Valibot, etc.).
+     */
+    outputSchema?: SchemaInput;
     /**
      * Conversation ID for correlating client and server-side devtools events.
      * When provided, server-side events will be linked to the client conversation in devtools.
@@ -469,7 +618,7 @@ export interface ThinkingStreamChunk extends BaseStreamChunk {
  * Chunk returned by the sdk during streaming chat completions.
  */
 export type StreamChunk = ContentStreamChunk | ToolCallStreamChunk | ToolResultStreamChunk | DoneStreamChunk | ErrorStreamChunk | ApprovalRequestedStreamChunk | ToolInputAvailableStreamChunk | ThinkingStreamChunk;
-export interface ChatCompletionChunk {
+export interface TextCompletionChunk {
     id: string;
     model: string;
     content: string;
@@ -498,20 +647,207 @@ export interface SummarizationResult {
         totalTokens: number;
     };
 }
-export interface EmbeddingOptions {
+/**
+ * Options for image generation.
+ * These are the common options supported across providers.
+ */
+export interface ImageGenerationOptions<TProviderOptions extends object = object> {
+    /** The model to use for image generation */
     model: string;
-    input: string | Array<string>;
-    dimensions?: number;
+    /** Text description of the desired image(s) */
+    prompt: string;
+    /** Number of images to generate (default: 1) */
+    numberOfImages?: number;
+    /** Image size in WIDTHxHEIGHT format (e.g., "1024x1024") */
+    size?: string;
+    /** Model-specific options for image generation */
+    modelOptions?: TProviderOptions;
 }
-export interface EmbeddingResult {
+/**
+ * A single generated image
+ */
+export interface GeneratedImage {
+    /** Base64-encoded image data */
+    b64Json?: string;
+    /** URL to the generated image (may be temporary) */
+    url?: string;
+    /** Revised prompt used by the model (if applicable) */
+    revisedPrompt?: string;
+}
+/**
+ * Result of image generation
+ */
+export interface ImageGenerationResult {
+    /** Unique identifier for the generation */
     id: string;
+    /** Model used for generation */
     model: string;
-    embeddings: Array<Array<number>>;
-    usage: {
-        promptTokens: number;
-        totalTokens: number;
+    /** Array of generated images */
+    images: Array<GeneratedImage>;
+    /** Token usage information (if available) */
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
     };
 }
+/**
+ * Options for video generation.
+ * These are the common options supported across providers.
+ *
+ * @experimental Video generation is an experimental feature and may change.
+ */
+export interface VideoGenerationOptions<TProviderOptions extends object = object> {
+    /** The model to use for video generation */
+    model: string;
+    /** Text description of the desired video */
+    prompt: string;
+    /** Video size in WIDTHxHEIGHT format (e.g., "1280x720") */
+    size?: string;
+    /** Video duration in seconds */
+    duration?: number;
+    /** Model-specific options for video generation */
+    modelOptions?: TProviderOptions;
+}
+/**
+ * Result of creating a video generation job.
+ *
+ * @experimental Video generation is an experimental feature and may change.
+ */
+export interface VideoJobResult {
+    /** Unique job identifier for polling status */
+    jobId: string;
+    /** Model used for generation */
+    model: string;
+}
+/**
+ * Status of a video generation job.
+ *
+ * @experimental Video generation is an experimental feature and may change.
+ */
+export interface VideoStatusResult {
+    /** Job identifier */
+    jobId: string;
+    /** Current status of the job */
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    /** Progress percentage (0-100), if available */
+    progress?: number;
+    /** Error message if status is 'failed' */
+    error?: string;
+}
+/**
+ * Result containing the URL to a generated video.
+ *
+ * @experimental Video generation is an experimental feature and may change.
+ */
+export interface VideoUrlResult {
+    /** Job identifier */
+    jobId: string;
+    /** URL to the generated video */
+    url: string;
+    /** When the URL expires, if applicable */
+    expiresAt?: Date;
+}
+/**
+ * Options for text-to-speech generation.
+ * These are the common options supported across providers.
+ */
+export interface TTSOptions<TProviderOptions extends object = object> {
+    /** The model to use for TTS generation */
+    model: string;
+    /** The text to convert to speech */
+    text: string;
+    /** The voice to use for generation */
+    voice?: string;
+    /** The output audio format */
+    format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+    /** The speed of the generated audio (0.25 to 4.0) */
+    speed?: number;
+    /** Model-specific options for TTS generation */
+    modelOptions?: TProviderOptions;
+}
+/**
+ * Result of text-to-speech generation.
+ */
+export interface TTSResult {
+    /** Unique identifier for the generation */
+    id: string;
+    /** Model used for generation */
+    model: string;
+    /** Base64-encoded audio data */
+    audio: string;
+    /** Audio format of the generated audio */
+    format: string;
+    /** Duration of the audio in seconds, if available */
+    duration?: number;
+    /** Content type of the audio (e.g., 'audio/mp3') */
+    contentType?: string;
+}
+/**
+ * Options for audio transcription.
+ * These are the common options supported across providers.
+ */
+export interface TranscriptionOptions<TProviderOptions extends object = object> {
+    /** The model to use for transcription */
+    model: string;
+    /** The audio data to transcribe - can be base64 string, File, Blob, or Buffer */
+    audio: string | File | Blob | ArrayBuffer;
+    /** The language of the audio in ISO-639-1 format (e.g., 'en') */
+    language?: string;
+    /** An optional prompt to guide the transcription */
+    prompt?: string;
+    /** The format of the transcription output */
+    responseFormat?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt';
+    /** Model-specific options for transcription */
+    modelOptions?: TProviderOptions;
+}
+/**
+ * A single segment of transcribed audio with timing information.
+ */
+export interface TranscriptionSegment {
+    /** Unique identifier for the segment */
+    id: number;
+    /** Start time of the segment in seconds */
+    start: number;
+    /** End time of the segment in seconds */
+    end: number;
+    /** Transcribed text for this segment */
+    text: string;
+    /** Confidence score (0-1), if available */
+    confidence?: number;
+    /** Speaker identifier, if diarization is enabled */
+    speaker?: string;
+}
+/**
+ * A single word with timing information.
+ */
+export interface TranscriptionWord {
+    /** The transcribed word */
+    word: string;
+    /** Start time in seconds */
+    start: number;
+    /** End time in seconds */
+    end: number;
+}
+/**
+ * Result of audio transcription.
+ */
+export interface TranscriptionResult {
+    /** Unique identifier for the transcription */
+    id: string;
+    /** Model used for transcription */
+    model: string;
+    /** The full transcribed text */
+    text: string;
+    /** Language detected or specified */
+    language?: string;
+    /** Duration of the audio in seconds */
+    duration?: number;
+    /** Detailed segments with timing, if available */
+    segments?: Array<TranscriptionSegment>;
+    /** Word-level timestamps, if available */
+    words?: Array<TranscriptionWord>;
+}
 /**
  * Default metadata type for adapters that don't define custom metadata.
  * Uses unknown for all modalities.
@@ -523,102 +859,3 @@ export interface DefaultMessageMetadataByModality {
     video: unknown;
     document: unknown;
 }
-/**
- * AI adapter interface with support for endpoint-specific models and provider options.
- *
- * Generic parameters:
- * - TChatModels: Models that support chat/text completion
- * - TEmbeddingModels: Models that support embeddings
- * - TChatProviderOptions: Provider-specific options for chat endpoint
- * - TEmbeddingProviderOptions: Provider-specific options for embedding endpoint
- * - TModelProviderOptionsByName: Map from model name to its specific provider options
- * - TModelInputModalitiesByName: Map from model name to its supported input modalities
- * - TMessageMetadataByModality: Map from modality type to adapter-specific metadata types
- */
-export interface AIAdapter<TChatModels extends ReadonlyArray<string> = ReadonlyArray<string>, TEmbeddingModels extends ReadonlyArray<string> = ReadonlyArray<string>, TChatProviderOptions extends Record<string, any> = Record<string, any>, TEmbeddingProviderOptions extends Record<string, any> = Record<string, any>, TModelProviderOptionsByName extends Record<string, any> = Record<string, any>, TModelInputModalitiesByName extends Record<string, ReadonlyArray<Modality>> = Record<string, ReadonlyArray<Modality>>, TMessageMetadataByModality extends {
-    text: unknown;
-    image: unknown;
-    audio: unknown;
-    video: unknown;
-    document: unknown;
-} = DefaultMessageMetadataByModality> {
-    name: string;
-    /** Models that support chat/text completion */
-    models: TChatModels;
-    /** Models that support embeddings */
-    embeddingModels?: TEmbeddingModels;
-    _providerOptions?: TChatProviderOptions;
-    _chatProviderOptions?: TChatProviderOptions;
-    _embeddingProviderOptions?: TEmbeddingProviderOptions;
-    /**
-     * Type-only map from model name to its specific provider options.
-     * Used by the core AI types to narrow providerOptions based on the selected model.
-     * Must be provided by all adapters.
-     */
-    _modelProviderOptionsByName: TModelProviderOptionsByName;
-    /**
-     * Type-only map from model name to its supported input modalities.
-     * Used by the core AI types to narrow ContentPart types based on the selected model.
-     * Must be provided by all adapters.
-     */
-    _modelInputModalitiesByName?: TModelInputModalitiesByName;
-    /**
-     * Type-only map from modality type to adapter-specific metadata types.
-     * Used to provide type-safe autocomplete for metadata on content parts.
-     */
-    _messageMetadataByModality?: TMessageMetadataByModality;
-    chatStream: (options: ChatOptions<string, TChatProviderOptions>) => AsyncIterable<StreamChunk>;
-    summarize: (options: SummarizationOptions) => Promise<SummarizationResult>;
-    createEmbeddings: (options: EmbeddingOptions) => Promise<EmbeddingResult>;
-}
-export interface AIAdapterConfig {
-    apiKey?: string;
-    baseUrl?: string;
-    timeout?: number;
-    maxRetries?: number;
-    headers?: Record<string, string>;
-}
-export type ChatStreamOptionsUnion<TAdapter extends AIAdapter<any, any, any, any, any, any, any>> = TAdapter extends AIAdapter<infer Models, any, any, any, infer ModelProviderOptions, infer ModelInputModalities, infer MessageMetadata> ? Models[number] extends infer TModel ? TModel extends string ? Omit<ChatOptions, 'model' | 'providerOptions' | 'responseFormat' | 'messages'> & {
-    adapter: TAdapter;
-    model: TModel;
-    providerOptions?: TModel extends keyof ModelProviderOptions ? ModelProviderOptions[TModel] : never;
-    /**
-     * Messages array with content constrained to the model's supported input modalities.
-     * For example, if a model only supports ['text', 'image'], you cannot pass audio or video content.
-     * Metadata types are also constrained based on the adapter's metadata type definitions.
-     */
-    messages: TModel extends keyof ModelInputModalities ? ModelInputModalities[TModel] extends ReadonlyArray<Modality> ? MessageMetadata extends {
-        text: infer TTextMeta;
-        image: infer TImageMeta;
-        audio: infer TAudioMeta;
-        video: infer TVideoMeta;
-        document: infer TDocumentMeta;
-    } ? Array<ConstrainedModelMessage<ModelInputModalities[TModel], TImageMeta, TAudioMeta, TVideoMeta, TDocumentMeta, TTextMeta>> : Array<ConstrainedModelMessage<ModelInputModalities[TModel]>> : Array<ModelMessage> : Array<ModelMessage>;
-} : never : never : never;
-/**
- * Chat options constrained by a specific model's capabilities.
- * Unlike ChatStreamOptionsUnion which creates a union over all models,
- * this type takes a specific model and constrains messages accordingly.
- */
-export type ChatStreamOptionsForModel<TAdapter extends AIAdapter<any, any, any, any, any, any, any>, TModel extends string> = TAdapter extends AIAdapter<any, any, any, any, infer ModelProviderOptions, infer ModelInputModalities, infer MessageMetadata> ? Omit<ChatOptions, 'model' | 'providerOptions' | 'responseFormat' | 'messages'> & {
-    adapter: TAdapter;
-    model: TModel;
-    providerOptions?: TModel extends keyof ModelProviderOptions ? ModelProviderOptions[TModel] : never;
-    /**
-     * Messages array with content constrained to the model's supported input modalities.
-     * For example, if a model only supports ['text', 'image'], you cannot pass audio or video content.
-     * Metadata types are also constrained based on the adapter's metadata type definitions.
-     */
-    messages: TModel extends keyof ModelInputModalities ? ModelInputModalities[TModel] extends ReadonlyArray<Modality> ? MessageMetadata extends {
-        text: infer TTextMeta;
-        image: infer TImageMeta;
-        audio: infer TAudioMeta;
-        video: infer TVideoMeta;
-        document: infer TDocumentMeta;
-    } ? Array<ConstrainedModelMessage<ModelInputModalities[TModel], TImageMeta, TAudioMeta, TVideoMeta, TDocumentMeta, TTextMeta>> : Array<ConstrainedModelMessage<ModelInputModalities[TModel]>> : Array<ModelMessage> : Array<ModelMessage>;
-} : never;
-export type ExtractModelsFromAdapter<T> = T extends AIAdapter<infer M, any, any, any, any, any> ? M[number] : never;
-/**
- * Extract the supported input modalities for a specific model from an adapter.
- */
-export type ExtractModalitiesForModel<TAdapter extends AIAdapter<any, any, any, any, any, any>, TModel extends string> = TAdapter extends AIAdapter<any, any, any, any, any, infer ModelInputModalities> ? TModel extends keyof ModelInputModalities ? ModelInputModalities[TModel] : ReadonlyArray<Modality> : ReadonlyArray<Modality>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai",
-  "version": "0.0.3",
+  "version": "0.2.0",
   "description": "Core TanStack AI library - Open source AI SDK",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -17,6 +17,10 @@
       "types": "./dist/esm/index.d.ts",
       "import": "./dist/esm/index.js"
     },
+    "./adapters": {
+      "types": "./dist/esm/activities/index.d.ts",
+      "import": "./dist/esm/activities/index.js"
+    },
     "./event-client": {
       "types": "./dist/esm/event-client.d.ts",
       "import": "./dist/esm/event-client.js"
@@ -42,13 +46,10 @@
     "@tanstack/devtools-event-client": "^0.4.0",
     "partial-json": "^0.1.7"
   },
-  "peerDependencies": {
-    "@alcyone-labs/zod-to-json-schema": "^4.0.0",
-    "zod": "^3.0.0 || ^4.0.0"
-  },
   "devDependencies": {
+    "@standard-schema/spec": "^1.1.0",
     "@vitest/coverage-v8": "4.0.14",
-    "zod": "^4.1.13"
+    "zod": "^4.2.0"
   },
   "scripts": {
     "build": "vite build",