@ai-sdk/xai 4.0.0-beta.7 → 4.0.0-beta.75

package/src/tool/web-search.ts

@@ -1,5 +1,5 @@
 import {
-  createProviderToolFactoryWithOutputSchema,
+  createProviderExecutedToolFactory,
   lazySchema,
   zodSchema,
 } from '@ai-sdk/provider-utils';
@@ -10,6 +10,7 @@ export const webSearchArgsSchema = lazySchema(() =>
     z.object({
       allowedDomains: z.array(z.string()).max(5).optional(),
       excludedDomains: z.array(z.string()).max(5).optional(),
+      enableImageSearch: z.boolean().optional(),
       enableImageUnderstanding: z.boolean().optional(),
     }),
   ),
@@ -30,7 +31,7 @@ const webSearchOutputSchema = lazySchema(() =>
   ),
 );
 
-const webSearchToolFactory = createProviderToolFactoryWithOutputSchema<
+const webSearchToolFactory = createProviderExecutedToolFactory<
   {},
   {
     query: string;
@@ -43,6 +44,7 @@ const webSearchToolFactory = createProviderToolFactoryWithOutputSchema<
   {
     allowedDomains?: string[];
     excludedDomains?: string[];
+    enableImageSearch?: boolean;
     enableImageUnderstanding?: boolean;
   }
 >({

package/src/tool/x-search.ts

@@ -1,5 +1,5 @@
 import {
-  createProviderToolFactoryWithOutputSchema,
+  createProviderExecutedToolFactory,
   lazySchema,
   zodSchema,
 } from '@ai-sdk/provider-utils';
@@ -34,7 +34,7 @@ const xSearchOutputSchema = lazySchema(() =>
   ),
 );
 
-const xSearchToolFactory = createProviderToolFactoryWithOutputSchema<
+const xSearchToolFactory = createProviderExecutedToolFactory<
   {},
   {
     query: string;

package/src/{xai-chat-options.ts → xai-chat-language-model-options.ts}

@@ -2,18 +2,10 @@ import { z } from 'zod/v4';
 
 // https://docs.x.ai/docs/models
 export type XaiChatModelId =
-  | 'grok-4-1-fast-reasoning'
-  | 'grok-4-1-fast-non-reasoning'
-  | 'grok-4-fast-non-reasoning'
-  | 'grok-4-fast-reasoning'
-  | 'grok-code-fast-1'
-  | 'grok-4'
-  | 'grok-4-0709'
-  | 'grok-4-latest'
-  | 'grok-3'
-  | 'grok-3-latest'
-  | 'grok-3-mini'
-  | 'grok-3-mini-latest'
+  | 'grok-4.20-non-reasoning'
+  | 'grok-4.20-reasoning'
+  | 'grok-4.3'
+  | 'grok-latest'
   | (string & {});
 
 // search source schemas
@@ -58,7 +50,21 @@ const searchSourceSchema = z.discriminatedUnion('type', [
 
 // xai-specific provider options
 export const xaiLanguageModelChatOptions = z.object({
-  reasoningEffort: z.enum(['low', 'high']).optional(),
+  /**
+   * Constrains how hard a reasoning model thinks before responding.
+   *
+   * - `none`: Disables reasoning entirely (supported by `grok-4.3` and newer
+   *   reasoning models). When set, no thinking tokens are used.
+   * - `low` (default): Uses some reasoning tokens, but still fast.
+   * - `medium`: More thinking for less-latency-sensitive applications.
+   * - `high`: Uses more reasoning tokens for deeper thinking.
+   *
+   * Note: Not every Grok model accepts every value. Refer to xAI's docs for
+   * the values supported by your selected model.
+   *
+   * @see https://docs.x.ai/docs/guides/reasoning
+   */
+  reasoningEffort: z.enum(['none', 'low', 'medium', 'high']).optional(),
   logprobs: z.boolean().optional(),
   topLogprobs: z.number().int().min(0).max(8).optional(),
 
@@ -70,6 +76,15 @@ export const xaiLanguageModelChatOptions = z.object({
    */
   parallel_function_calling: z.boolean().optional(),
 
+  /**
+   * @deprecated xAI has deprecated Live Search (`search_parameters`) in favor
+   * of the Agent Tools API. Requests using this option now return a "Live
+   * search is deprecated" error. Use the `web_search` / `x_search` tools
+   * instead (e.g. `xai.tools.webSearch()`, `xai.tools.xSearch()`) with
+   * `xai.responses(modelId)`.
+   *
+   * @see https://docs.x.ai/docs/guides/tools/overview
+   */
   searchParameters: z
     .object({
       /**

package/src/xai-chat-language-model.ts

@@ -1,25 +1,30 @@
 import {
   APICallError,
-  LanguageModelV3,
-  LanguageModelV3CallOptions,
-  LanguageModelV3Content,
-  LanguageModelV3FinishReason,
-  LanguageModelV3GenerateResult,
-  LanguageModelV3StreamPart,
-  LanguageModelV3StreamResult,
-  LanguageModelV3Usage,
-  SharedV3Warning,
+  type LanguageModelV4,
+  type LanguageModelV4CallOptions,
+  type LanguageModelV4Content,
+  type LanguageModelV4FinishReason,
+  type LanguageModelV4GenerateResult,
+  type LanguageModelV4StreamPart,
+  type LanguageModelV4StreamResult,
+  type LanguageModelV4Usage,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   extractResponseHeaders,
-  FetchFunction,
+  isCustomReasoning,
+  mapReasoningToProviderEffort,
   parseProviderOptions,
-  ParseResult,
   postJsonToApi,
   safeParseJSON,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type FetchFunction,
+  type ParseResult,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { convertToXaiChatMessages } from './convert-to-xai-chat-messages';
@@ -27,27 +32,41 @@ import { convertXaiChatUsage } from './convert-xai-chat-usage';
 import { getResponseMetadata } from './get-response-metadata';
 import { mapXaiFinishReason } from './map-xai-finish-reason';
 import {
-  XaiChatModelId,
   xaiLanguageModelChatOptions,
-} from './xai-chat-options';
+  type XaiChatModelId,
+} from './xai-chat-language-model-options';
 import { xaiFailedResponseHandler } from './xai-error';
 import { prepareTools } from './xai-prepare-tools';
 
 type XaiChatConfig = {
   provider: string;
   baseURL: string | undefined;
-  headers: () => Record<string, string | undefined>;
+  headers?: () => Record<string, string | undefined>;
   generateId: () => string;
   fetch?: FetchFunction;
 };
 
-export class XaiChatLanguageModel implements LanguageModelV3 {
-  readonly specificationVersion = 'v3';
+export class XaiChatLanguageModel implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
 
   readonly modelId: XaiChatModelId;
 
   private readonly config: XaiChatConfig;
 
+  static [WORKFLOW_SERIALIZE](model: XaiChatLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: XaiChatModelId;
+    config: XaiChatConfig;
+  }) {
+    return new XaiChatLanguageModel(options.modelId, options.config);
+  }
+
   constructor(modelId: XaiChatModelId, config: XaiChatConfig) {
     this.modelId = modelId;
     this.config = config;
@@ -71,12 +90,13 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
     presencePenalty,
     stopSequences,
     seed,
+    reasoning,
     responseFormat,
     providerOptions,
     tools,
     toolChoice,
-  }: LanguageModelV3CallOptions) {
-    const warnings: SharedV3Warning[] = [];
+  }: LanguageModelV4CallOptions) {
+    const warnings: SharedV4Warning[] = [];
 
     // parse xai-specific provider options
     const options =
@@ -133,7 +153,23 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
       temperature,
       top_p: topP,
       seed,
-      reasoning_effort: options.reasoningEffort,
+      reasoning_effort:
+        options.reasoningEffort ??
+        (isCustomReasoning(reasoning)
+          ? reasoning === 'none'
+            ? undefined
+            : mapReasoningToProviderEffort({
+                reasoning,
+                effortMap: {
+                  minimal: 'low',
+                  low: 'low',
+                  medium: 'medium',
+                  high: 'high',
+                  xhigh: 'high',
+                },
+                warnings,
+              })
+          : undefined),
 
       // parallel function calling
       parallel_function_calling: options.parallel_function_calling,
@@ -202,8 +238,8 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
   }
 
   async doGenerate(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3GenerateResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4GenerateResult> {
     const { args: body, warnings } = await this.getArgs(options);
 
     const url = `${this.config.baseURL ?? 'https://api.x.ai/v1'}/chat/completions`;
@@ -214,7 +250,7 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
       rawValue: rawResponse,
     } = await postJsonToApi({
       url,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body,
       failedResponseHandler: xaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
@@ -237,7 +273,7 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
     }
 
     const choice = response.choices![0];
-    const content: Array<LanguageModelV3Content> = [];
+    const content: Array<LanguageModelV4Content> = [];
 
     // extract text content
     if (choice.message.content != null && choice.message.content.length > 0) {
@@ -312,8 +348,8 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
   }
 
   async doStream(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3StreamResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4StreamResult> {
     const { args, warnings } = await this.getArgs(options);
     const body = {
       ...args,
@@ -327,7 +363,7 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
 
     const { responseHeaders, value: response } = await postJsonToApi({
       url,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body,
       failedResponseHandler: xaiFailedResponseHandler,
       successfulResponseHandler: async ({ response }) => {
@@ -375,11 +411,11 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
-    let finishReason: LanguageModelV3FinishReason = {
+    let finishReason: LanguageModelV4FinishReason = {
       unified: 'other',
       raw: undefined,
     };
-    let usage: LanguageModelV3Usage | undefined = undefined;
+    let usage: LanguageModelV4Usage | undefined = undefined;
     let isFirstChunk = true;
     const contentBlocks: Record<
       string,
@@ -394,7 +430,7 @@ export class XaiChatLanguageModel implements LanguageModelV3 {
       stream: response.pipeThrough(
         new TransformStream<
           ParseResult<z.infer<typeof xaiChatChunkSchema>>,
-          LanguageModelV3StreamPart
+          LanguageModelV4StreamPart
         >({
           start(controller) {
             controller.enqueue({ type: 'stream-start', warnings });

package/src/xai-chat-prompt.ts

@@ -18,7 +18,8 @@ export interface XaiUserMessage {
 
 export type XaiUserMessageContent =
   | { type: 'text'; text: string }
-  | { type: 'image_url'; image_url: { url: string } };
+  | { type: 'image_url'; image_url: { url: string } }
+  | { type: 'file'; file: { file_id: string } };
 
 export interface XaiAssistantMessage {
   role: 'assistant';

package/src/xai-error.ts

@@ -1,8 +1,7 @@
 import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-// Add error schema and structure
-export const xaiErrorDataSchema = z.object({
+const chatCompletionsErrorSchema = z.object({
   error: z.object({
     message: z.string(),
     type: z.string().nullish(),
@@ -11,9 +10,20 @@ export const xaiErrorDataSchema = z.object({
   }),
 });
 
+const responsesErrorSchema = z.object({
+  code: z.string(),
+  error: z.string(),
+});
+
+export const xaiErrorDataSchema = z.union([
+  chatCompletionsErrorSchema,
+  responsesErrorSchema,
+]);
+
 export type XaiErrorData = z.infer<typeof xaiErrorDataSchema>;
 
 export const xaiFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: xaiErrorDataSchema,
-  errorToMessage: data => data.error.message,
+  errorToMessage: data =>
+    'code' in data ? `${data.code}: ${data.error}` : data.error.message,
 });

package/src/xai-image-model.ts

@@ -1,38 +1,55 @@
-import { ImageModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import type { ImageModelV4, SharedV4Warning } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertImageModelFileToDataUri,
   createBinaryResponseHandler,
   createJsonResponseHandler,
   createStatusCodeErrorResponseHandler,
-  FetchFunction,
   getFromApi,
   parseProviderOptions,
   postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { xaiFailedResponseHandler } from './xai-error';
-import { xaiImageModelOptions } from './xai-image-options';
-import { XaiImageModelId } from './xai-image-settings';
+import { xaiImageModelOptions } from './xai-image-model-options';
+import type { XaiImageModelId } from './xai-image-settings';
 
 interface XaiImageModelConfig {
   provider: string;
   baseURL: string | undefined;
-  headers: () => Record<string, string | undefined>;
+  headers?: () => Record<string, string | undefined>;
   fetch?: FetchFunction;
   _internal?: {
     currentDate?: () => Date;
   };
 }
 
-export class XaiImageModel implements ImageModelV3 {
-  readonly specificationVersion = 'v3';
+export class XaiImageModel implements ImageModelV4 {
+  readonly specificationVersion = 'v4';
   readonly maxImagesPerCall = 3;
 
   get provider(): string {
     return this.config.provider;
   }
 
+  static [WORKFLOW_SERIALIZE](model: XaiImageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: XaiImageModelId;
+    config: XaiImageModelConfig;
+  }) {
+    return new XaiImageModel(options.modelId, options.config);
+  }
+
   constructor(
     readonly modelId: XaiImageModelId,
     private config: XaiImageModelConfig,
@@ -49,10 +66,10 @@ export class XaiImageModel implements ImageModelV3 {
     abortSignal,
     files,
     mask,
-  }: Parameters<ImageModelV3['doGenerate']>[0]): Promise<
-    Awaited<ReturnType<ImageModelV3['doGenerate']>>
+  }: Parameters<ImageModelV4['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<ImageModelV4['doGenerate']>>
   > {
-    const warnings: Array<SharedV3Warning> = [];
+    const warnings: Array<SharedV4Warning> = [];
 
     if (size != null) {
       warnings.push({
@@ -135,7 +152,7 @@ export class XaiImageModel implements ImageModelV3 {
     const currentDate = this.config._internal?.currentDate?.() ?? new Date();
     const { value: response, responseHeaders } = await postJsonToApi({
       url: `${baseURL}${endpoint}`,
-      headers: combineHeaders(this.config.headers(), headers),
+      headers: combineHeaders(this.config.headers?.(), headers),
       body,
       failedResponseHandler: xaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(

package/src/xai-prepare-tools.ts

@@ -1,16 +1,17 @@
 import {
-  LanguageModelV3CallOptions,
-  SharedV3Warning,
   UnsupportedFunctionalityError,
+  type LanguageModelV4CallOptions,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
-import { XaiToolChoice } from './xai-chat-prompt';
+import { removeAdditionalPropertiesFalse } from './remove-additional-properties';
+import type { XaiToolChoice } from './xai-chat-prompt';
 
 export function prepareTools({
   tools,
   toolChoice,
 }: {
-  tools: LanguageModelV3CallOptions['tools'];
-  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+  tools: LanguageModelV4CallOptions['tools'];
+  toolChoice?: LanguageModelV4CallOptions['toolChoice'];
 }): {
   tools:
     | Array<{
@@ -24,12 +25,12 @@ export function prepareTools({
       }>
     | undefined;
   toolChoice: XaiToolChoice | undefined;
-  toolWarnings: SharedV3Warning[];
+  toolWarnings: SharedV4Warning[];
 } {
   // when the tools array is empty, change it to undefined to prevent errors
   tools = tools?.length ? tools : undefined;
 
-  const toolWarnings: SharedV3Warning[] = [];
+  const toolWarnings: SharedV4Warning[] = [];
 
   if (tools == null) {
     return { tools: undefined, toolChoice: undefined, toolWarnings };
@@ -58,7 +59,7 @@ export function prepareTools({
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: tool.inputSchema,
+          parameters: removeAdditionalPropertiesFalse(tool.inputSchema),
           ...(tool.strict != null ? { strict: tool.strict } : {}),
         },
       });

package/src/xai-provider.ts

@@ -1,65 +1,101 @@
 import {
-  type Experimental_VideoModelV3,
-  ImageModelV3,
-  LanguageModelV3,
+  type Experimental_RealtimeFactoryV4 as RealtimeFactoryV4,
+  type Experimental_RealtimeFactoryV4GetTokenOptions as RealtimeFactoryV4GetTokenOptions,
+  type Experimental_VideoModelV4,
+  type FilesV4,
+  type ImageModelV4,
+  type LanguageModelV4,
   NoSuchModelError,
-  ProviderV3,
+  type ProviderV4,
+  type SpeechModelV4,
+  type TranscriptionModelV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
   generateId,
   loadApiKey,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { XaiChatLanguageModel } from './xai-chat-language-model';
-import { XaiChatModelId } from './xai-chat-options';
+import type { XaiChatModelId } from './xai-chat-language-model-options';
 import { XaiImageModel } from './xai-image-model';
-import { XaiImageModelId } from './xai-image-settings';
+import type { XaiImageModelId } from './xai-image-settings';
 import { XaiResponsesLanguageModel } from './responses/xai-responses-language-model';
-import { XaiResponsesModelId } from './responses/xai-responses-options';
+import type { XaiResponsesModelId } from './responses/xai-responses-language-model-options';
+import { XaiRealtimeModel } from './realtime/xai-realtime-model';
 import { xaiTools } from './tool';
 import { VERSION } from './version';
+import { XaiFiles } from './files/xai-files';
 import { XaiVideoModel } from './xai-video-model';
-import { XaiVideoModelId } from './xai-video-settings';
+import type { XaiVideoModelId } from './xai-video-settings';
+import { XaiSpeechModel } from './xai-speech-model';
+import { XaiTranscriptionModel } from './xai-transcription-model';
 
-export interface XaiProvider extends ProviderV3 {
-  (modelId: XaiResponsesModelId): LanguageModelV3;
+export interface XaiProvider extends ProviderV4 {
+  (modelId: XaiResponsesModelId): LanguageModelV4;
 
   /**
    * Creates an Xai language model for text generation.
    */
-  languageModel(modelId: XaiResponsesModelId): LanguageModelV3;
+  languageModel(modelId: XaiResponsesModelId): LanguageModelV4;
 
   /**
    * Creates an Xai chat model for text generation.
    */
-  chat: (modelId: XaiChatModelId) => LanguageModelV3;
+  chat: (modelId: XaiChatModelId) => LanguageModelV4;
 
   /**
    * Creates an Xai responses model for text generation.
    */
-  responses: (modelId: XaiResponsesModelId) => LanguageModelV3;
+  responses: (modelId: XaiResponsesModelId) => LanguageModelV4;
 
   /**
    * Creates an Xai image model for image generation.
    */
-  image(modelId: XaiImageModelId): ImageModelV3;
+  image(modelId: XaiImageModelId): ImageModelV4;
 
   /**
    * Creates an Xai image model for image generation.
    */
-  imageModel(modelId: XaiImageModelId): ImageModelV3;
+  imageModel(modelId: XaiImageModelId): ImageModelV4;
 
   /**
    * Creates an Xai video model for video generation.
    */
-  video(modelId: XaiVideoModelId): Experimental_VideoModelV3;
+  video(modelId: XaiVideoModelId): Experimental_VideoModelV4;
 
   /**
    * Creates an Xai video model for video generation.
    */
-  videoModel(modelId: XaiVideoModelId): Experimental_VideoModelV3;
+  videoModel(modelId: XaiVideoModelId): Experimental_VideoModelV4;
+
+  experimental_realtime: RealtimeFactoryV4;
+
+  /**
+   * Creates an xAI model for speech generation (text-to-speech).
+   */
+  speech(): SpeechModelV4;
+
+  /**
+   * Creates an xAI model for speech generation (text-to-speech).
+   */
+  speechModel(): SpeechModelV4;
+
+  /**
+   * Creates an xAI model for speech-to-text transcription.
+   */
+  transcription(): TranscriptionModelV4;
+
+  /**
+   * Creates an xAI model for speech-to-text transcription.
+   */
+  transcriptionModel(): TranscriptionModelV4;
+
+  /**
+   * Returns the xAI files interface for uploading files.
+   */
+  files(): FilesV4;
 
   /**
    * Server-side agentic tools for use with the responses API.
@@ -150,10 +186,64 @@ export function createXai(options: XaiProviderSettings = {}): XaiProvider {
     });
   };
 
+  const createRealtimeModel = (modelId: string) => {
+    return new XaiRealtimeModel(modelId, {
+      provider: 'xai.realtime',
+      baseURL: baseURL ?? 'https://api.x.ai/v1',
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+  };
+
+  const createSpeechModel = () => {
+    return new XaiSpeechModel('', {
+      provider: 'xai.speech',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+  };
+
+  const createTranscriptionModel = () => {
+    return new XaiTranscriptionModel('', {
+      provider: 'xai.transcription',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+  };
+
+  const experimentalRealtimeFactory = Object.assign(
+    (modelId: string) => createRealtimeModel(modelId),
+    {
+      getToken: async (tokenOptions: RealtimeFactoryV4GetTokenOptions) => {
+        const model = createRealtimeModel(tokenOptions.model);
+        const secret = await model.doCreateClientSecret({
+          sessionConfig: tokenOptions.sessionConfig,
+          expiresAfterSeconds: tokenOptions.expiresAfterSeconds,
+        });
+
+        return {
+          token: secret.token,
+          url: secret.url,
+          expiresAt: secret.expiresAt,
+        };
+      },
+    },
+  ) as RealtimeFactoryV4;
+
+  const createFiles = () =>
+    new XaiFiles({
+      provider: 'xai.files',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
   const provider = (modelId: XaiResponsesModelId) =>
     createResponsesLanguageModel(modelId);
 
-  provider.specificationVersion = 'v3' as const;
+  provider.specificationVersion = 'v4' as const;
   provider.languageModel = createResponsesLanguageModel;
   provider.chat = createChatLanguageModel;
   provider.responses = createResponsesLanguageModel;
@@ -165,6 +255,12 @@ export function createXai(options: XaiProviderSettings = {}): XaiProvider {
   provider.image = createImageModel;
   provider.videoModel = createVideoModel;
   provider.video = createVideoModel;
+  provider.experimental_realtime = experimentalRealtimeFactory;
+  provider.speechModel = createSpeechModel;
+  provider.speech = createSpeechModel;
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.transcription = createTranscriptionModel;
+  provider.files = createFiles;
   provider.tools = xaiTools;
 
   return provider;