@tanstack/ai 0.0.3 → 0.2.0

package/src/types.ts

@@ -1,6 +1,88 @@
-import type { CommonOptions } from './core/chat-common-options'
-import type { z } from 'zod'
-import type { ToolCallState, ToolResultState } from './stream/types'
+import type { StandardJSONSchemaV1 } from '@standard-schema/spec'
+
+/**
+ * Tool call states - track the lifecycle of a tool call
+ */
+export type ToolCallState =
+  | 'awaiting-input' // Received start but no arguments yet
+  | 'input-streaming' // Partial arguments received
+  | 'input-complete' // All arguments received
+  | 'approval-requested' // Waiting for user approval
+  | 'approval-responded' // User has approved/denied
+
+/**
+ * Tool result states - track the lifecycle of a tool result
+ */
+export type ToolResultState =
+  | 'streaming' // Placeholder for future streamed output
+  | 'complete' // Result is complete
+  | 'error' // Error occurred
+
+/**
+ * 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 // Allow additional properties for extensibility
+}
+
+/**
+ * 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
@@ -100,11 +182,11 @@ export interface DocumentPart<TMetadata = unknown> {
  * @template TDocumentMeta - Provider-specific document metadata type
  */
 export type ContentPart<
+  TTextMeta = unknown,
   TImageMeta = unknown,
   TAudioMeta = unknown,
   TVideoMeta = unknown,
   TDocumentMeta = unknown,
-  TTextMeta = unknown,
 > =
   | TextPart<TTextMeta>
   | ImagePart<TImageMeta>
@@ -116,16 +198,17 @@ export type ContentPart<
  * 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,
+export type ContentPartForInputModalitiesTypes<
+  TInputModalitiesTypes extends InputModalitiesTypes,
 > = Extract<
-  ContentPart<TImageMeta, TAudioMeta, TVideoMeta, TDocumentMeta, TTextMeta>,
-  { type: TModalities }
+  ContentPart<
+    TInputModalitiesTypes['messageMetadataByModality']['text'],
+    TInputModalitiesTypes['messageMetadataByModality']['image'],
+    TInputModalitiesTypes['messageMetadataByModality']['audio'],
+    TInputModalitiesTypes['messageMetadataByModality']['video'],
+    TInputModalitiesTypes['messageMetadataByModality']['document']
+  >,
+  { type: TInputModalitiesTypes['inputModalities'][number] }
 >
 
 /**
@@ -140,25 +223,11 @@ export type ModalitiesArrayToUnion<T extends ReadonlyArray<Modality>> =
  * 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,
+  TInputModalitiesTypes extends InputModalitiesTypes,
 > =
   | string
   | null
-  | Array<
-      ContentPartForModalities<
-        ModalitiesArrayToUnion<TModalities>,
-        TImageMeta,
-        TAudioMeta,
-        TVideoMeta,
-        TDocumentMeta,
-        TTextMeta
-      >
-    >
+  | Array<ContentPartForInputModalitiesTypes<TInputModalitiesTypes>>
 
 export interface ModelMessage<
   TContent extends string | null | Array<ContentPart> =
@@ -227,26 +296,20 @@ 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,
+  TInputModalitiesTypes extends InputModalitiesTypes,
 > = Omit<ModelMessage, 'content'> & {
-  content: ConstrainedContent<
-    TModalities,
-    TImageMeta,
-    TAudioMeta,
-    TVideoMeta,
-    TDocumentMeta,
-    TTextMeta
-  >
+  content: ConstrainedContent<TInputModalitiesTypes>
 }
 
 /**
@@ -255,14 +318,16 @@ export type ConstrainedModelMessage<
  * 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,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 > {
   /**
@@ -286,34 +351,58 @@ export interface Tool<
   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(),
@@ -473,21 +562,72 @@ 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,
+export interface TextOptions<
   TProviderOptionsSuperset extends Record<string, any> = Record<string, any>,
-  TOutput extends ResponseFormat<any> | undefined = undefined,
   TProviderOptionsForModel = TProviderOptionsSuperset,
 > {
-  model: TModel
+  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.
@@ -607,9 +747,9 @@ export type StreamChunk =
   | ToolInputAvailableStreamChunk
   | ThinkingStreamChunk
 
-// Simple streaming format for basic chat completions
-// Converted to StreamChunk format by convertChatCompletionStream()
-export interface ChatCompletionChunk {
+// Simple streaming format for basic text completions
+// Converted to StreamChunk format by convertTextCompletionStream()
+export interface TextCompletionChunk {
   id: string
   model: string
   content: string
@@ -641,245 +781,250 @@ export interface SummarizationResult {
   }
 }
 
-export interface EmbeddingOptions {
+// ============================================================================
+// Image Generation Types
+// ============================================================================
+
+/**
+ * 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
   }
 }
 
+// ============================================================================
+// Video Generation Types (Experimental)
+// ============================================================================
+
 /**
- * Default metadata type for adapters that don't define custom metadata.
- * Uses unknown for all modalities.
+ * Options for video generation.
+ * These are the common options supported across providers.
+ *
+ * @experimental Video generation is an experimental feature and may change.
  */
-export interface DefaultMessageMetadataByModality {
-  text: unknown
-  image: unknown
-  audio: unknown
-  video: unknown
-  document: unknown
+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
 }
 
 /**
- * AI adapter interface with support for endpoint-specific models and provider options.
+ * Result of creating a video generation job.
  *
- * 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
+ * @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
+}
 
-  /** Models that support embeddings */
-  embeddingModels?: TEmbeddingModels
+/**
+ * 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
+}
 
-  // Type-only properties for provider options inference
-  _providerOptions?: TChatProviderOptions // Alias for _chatProviderOptions
-  _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
+/**
+ * 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
+}
 
-  // Structured streaming with JSON chunks (supports tool calls and rich content)
-  chatStream: (
-    options: ChatOptions<string, TChatProviderOptions>,
-  ) => AsyncIterable<StreamChunk>
+// ============================================================================
+// Text-to-Speech (TTS) Types
+// ============================================================================
 
-  // Summarization
-  summarize: (options: SummarizationOptions) => Promise<SummarizationResult>
+/**
+ * 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
+}
 
-  // Embeddings
-  createEmbeddings: (options: EmbeddingOptions) => Promise<EmbeddingResult>
+/**
+ * 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
+}
+
+// ============================================================================
+// Transcription (Speech-to-Text) Types
+// ============================================================================
+
+/**
+ * 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
 }
 
-export interface AIAdapterConfig {
-  apiKey?: string
-  baseUrl?: string
-  timeout?: number
-  maxRetries?: number
-  headers?: Record<string, string>
+/**
+ * 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
 }
 
-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
-
-// Extract types from adapter (updated to 6 generics)
-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>
+/**
+ * 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.
+ */
+export interface DefaultMessageMetadataByModality {
+  text: unknown
+  image: unknown
+  audio: unknown
+  video: unknown
+  document: unknown
+}