@ai-sdk/xai 4.0.59 → 5.0.0

package/docs/01-xai.mdx

@@ -65,13 +65,6 @@ first argument is the model id, e.g. `grok-4.6`.
 const model = xai('grok-4.6');
 ```
 
-<Note>
-  Since AI SDK 7, `xai(modelId)` uses the xAI Responses API by default. To use
-  the [Chat Completions
-  API](https://docs.x.ai/docs/api-reference#chat-completions) (legacy), use
-  `xai.chat(modelId)`.
-</Note>
-
 ### Example
 
 You can use xAI language models to generate text with the `generateText` function:
@@ -94,8 +87,7 @@ and support structured data generation with [`Output`](/docs/reference/ai-sdk-co
 
 For models with configurable reasoning, you can control how much effort the
 model spends thinking before responding via
-`providerOptions.xai.reasoningEffort`. This works for both the Responses API
-(default) and the Chat Completions API (`xai.chat()`).
+`providerOptions.xai.reasoningEffort`.
 
 ```ts
 import { xai } from '@ai-sdk/xai';
@@ -141,9 +133,7 @@ The AI SDK option accepts these values, but each xAI model supports a subset:
 ### Priority Processing
 
 `providerOptions.xai.serviceTier` requests higher scheduling priority, which
-typically lowers time-to-first-token and speeds up inter-token latency. This
-works for both the Responses API (default) and the Chat Completions API
-(`xai.chat()`).
+typically lowers time-to-first-token and speeds up inter-token latency.
 
 ```ts
 import { xai } from '@ai-sdk/xai';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/xai",
-  "version": "4.0.59",
+  "version": "5.0.0",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/index.ts

@@ -1,8 +1,3 @@
-export type {
-  XaiLanguageModelChatOptions,
-  /** @deprecated Use `XaiLanguageModelChatOptions` instead. */
-  XaiLanguageModelChatOptions as XaiProviderOptions,
-} from './xai-chat-language-model-options';
 export type { XaiErrorData } from './xai-error';
 export type { XaiFilePartProviderOptions } from './xai-file-part-options';
 export type {

package/src/xai-batch.ts

@@ -40,13 +40,8 @@ import {
   type InferSchema,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
-import { convertXaiChatUsage } from './convert-xai-chat-usage';
 import { getResponseMetadata } from './get-response-metadata';
 import { mapXaiFinishReason } from './map-xai-finish-reason';
-import {
-  xaiChatResponseSchema,
-  type XaiChatResponse,
-} from './xai-chat-language-model';
 import { xaiFailedResponseHandler } from './xai-error';
 import { xaiFilesResponseSchema } from './files/xai-files-api';
 import {
@@ -171,6 +166,59 @@ const xaiBatchResultSchema = z.object({
 
 type XaiBatchResult = z.infer<typeof xaiBatchResultSchema>;
 
+// xAI returns text batch results in Chat Completions API shape even when the
+// request was submitted to the Responses API endpoint.
+const xaiBatchTextResponseSchema = z.object({
+  id: z.string().nullish(),
+  created: z.number().nullish(),
+  model: z.string().nullish(),
+  choices: z
+    .array(
+      z.object({
+        message: z.object({
+          role: z.enum(['assistant', 'tool']),
+          content: z.string().nullish(),
+          reasoning_content: z.string().nullish(),
+          tool_calls: z
+            .array(
+              z.object({
+                id: z.string(),
+                type: z.literal('function'),
+                function: z.object({
+                  name: z.string(),
+                  arguments: z.string(),
+                }),
+              }),
+            )
+            .nullish(),
+        }),
+        index: z.number(),
+        finish_reason: z.string().nullish(),
+      }),
+    )
+    .nullish(),
+  usage: z
+    .object({
+      prompt_tokens: z.number(),
+      completion_tokens: z.number(),
+      total_tokens: z.number(),
+      cost_in_usd_ticks: z.number().nullish(),
+      prompt_tokens_details: z
+        .object({ cached_tokens: z.number().nullish() })
+        .nullish(),
+      completion_tokens_details: z
+        .object({ reasoning_tokens: z.number().nullish() })
+        .nullish(),
+    })
+    .nullish(),
+  citations: z.array(z.string().url()).nullish(),
+  service_tier: z.string().nullish(),
+  code: z.string().nullish(),
+  error: z.string().nullish(),
+});
+
+type XaiBatchTextResponse = z.infer<typeof xaiBatchTextResponseSchema>;
+
 const xaiBatchResultsPageSchema = lazySchema(() =>
   zodSchema(
     z.object({
@@ -460,19 +508,17 @@ export class XaiBatch implements BatchV4<XaiBatchModelIds> {
       };
     }
 
-    // xAI returns text batch results in chat completion format, including for
-    // requests submitted to the Responses API endpoint.
     const response = result.batch_result?.response;
     if (response?.chat_get_completion != null) {
       const validation = await safeValidateTypes({
         value: response.chat_get_completion,
-        schema: xaiChatResponseSchema,
+        schema: zodSchema(xaiBatchTextResponseSchema),
       });
       if (!validation.success) {
         return invalidXaiBatchResult(result.batch_request_id);
       }
 
-      const conversion = convertXaiChatBatchResponse(validation.value);
+      const conversion = convertXaiBatchTextResponse(validation.value);
       return conversion.success
         ? {
             type: 'text',
@@ -738,8 +784,8 @@ function invalidXaiImageBatchResult(id: string): ImageBatchV4ItemResult {
   };
 }
 
-function convertXaiChatBatchResponse(
-  response: XaiChatResponse,
+function convertXaiBatchTextResponse(
+  response: XaiBatchTextResponse,
 ): XaiBatchResponseConversion {
   if (response.error != null) {
     return {
@@ -829,7 +875,7 @@ function convertXaiChatBatchResponse(
         raw: lastAssistantChoice?.finish_reason ?? undefined,
       },
       usage: response.usage
-        ? convertXaiChatUsage(response.usage)
+        ? convertXaiBatchTextUsage(response.usage)
         : createNullLanguageModelUsage(),
       response: getResponseMetadata(response),
       warnings: [],
@@ -849,3 +895,31 @@ function convertXaiChatBatchResponse(
     },
   };
 }
+
+function convertXaiBatchTextUsage(
+  usage: NonNullable<XaiBatchTextResponse['usage']>,
+) {
+  const cacheReadTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;
+  const reasoningTokens =
+    usage.completion_tokens_details?.reasoning_tokens ?? 0;
+  const promptTokensIncludesCached = cacheReadTokens <= usage.prompt_tokens;
+
+  return {
+    inputTokens: {
+      total: promptTokensIncludesCached
+        ? usage.prompt_tokens
+        : usage.prompt_tokens + cacheReadTokens,
+      noCache: promptTokensIncludesCached
+        ? usage.prompt_tokens - cacheReadTokens
+        : usage.prompt_tokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: undefined,
+    },
+    outputTokens: {
+      total: usage.completion_tokens + reasoningTokens,
+      text: usage.completion_tokens,
+      reasoning: reasoningTokens,
+    },
+    raw: usage,
+  };
+}

package/src/xai-error.ts

@@ -1,7 +1,7 @@
 import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-const chatCompletionsErrorSchema = z.object({
+const apiErrorSchema = z.object({
   error: z.object({
     message: z.string(),
     type: z.string().nullish(),
@@ -21,7 +21,7 @@ const speechErrorSchema = z.object({
 });
 
 export const xaiErrorDataSchema = z.union([
-  chatCompletionsErrorSchema,
+  apiErrorSchema,
   responsesErrorSchema,
   speechErrorSchema,
 ]);

package/src/xai-provider.ts

@@ -19,8 +19,6 @@ import {
   type FetchFunction,
   type WebSocketConstructor,
 } from '@ai-sdk/provider-utils';
-import { XaiChatLanguageModel } from './xai-chat-language-model';
-import type { XaiChatModelId } from './xai-chat-language-model-options';
 import { XaiImageModel } from './xai-image-model';
 import type { XaiImageModelId } from './xai-image-settings';
 import { XaiBatch } from './xai-batch';
@@ -43,11 +41,6 @@ export interface XaiProvider extends ProviderV4 {
    */
   languageModel(modelId: XaiResponsesModelId): LanguageModelV4;
 
-  /**
-   * Creates an Xai chat model for text generation.
-   */
-  chat: (modelId: XaiChatModelId) => LanguageModelV4;
-
   /**
    * Creates an Xai responses model for text generation.
    */
@@ -165,16 +158,6 @@ export function createXai(options: XaiProviderSettings = {}): XaiProvider {
       `ai-sdk/xai/${VERSION}`,
     );
 
-  const createChatLanguageModel = (modelId: XaiChatModelId) => {
-    return new XaiChatLanguageModel(modelId, {
-      provider: 'xai.chat',
-      baseURL,
-      headers: getHeaders,
-      generateId,
-      fetch: options.fetch,
-    });
-  };
-
   const createResponsesLanguageModel = (modelId: XaiResponsesModelId) => {
     return new XaiResponsesLanguageModel(modelId, {
       provider: 'xai.responses',
@@ -275,7 +258,6 @@ export function createXai(options: XaiProviderSettings = {}): XaiProvider {
 
   provider.specificationVersion = 'v4' as const;
   provider.languageModel = createResponsesLanguageModel;
-  provider.chat = createChatLanguageModel;
   provider.responses = createResponsesLanguageModel;
   provider.embeddingModel = (modelId: string) => {
     throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });

package/src/convert-to-xai-chat-messages.ts

@@ -1,181 +0,0 @@
-import {
-  UnsupportedFunctionalityError,
-  type SharedV4Warning,
-  type LanguageModelV4Prompt,
-} from '@ai-sdk/provider';
-import {
-  convertToBase64,
-  getTopLevelMediaType,
-  parseProviderOptions,
-  resolveFullMediaType,
-  resolveProviderReference,
-} from '@ai-sdk/provider-utils';
-import type { XaiChatPrompt, XaiUserMessageContent } from './xai-chat-prompt';
-import { xaiFilePartProviderOptions } from './xai-file-part-options';
-
-export async function convertToXaiChatMessages(
-  prompt: LanguageModelV4Prompt,
-): Promise<{
-  messages: XaiChatPrompt;
-  warnings: Array<SharedV4Warning>;
-}> {
-  const messages: XaiChatPrompt = [];
-  const warnings: Array<SharedV4Warning> = [];
-
-  for (const { role, content } of prompt) {
-    switch (role) {
-      case 'system': {
-        messages.push({ role: 'system', content });
-        break;
-      }
-
-      case 'user': {
-        if (content.length === 1 && content[0].type === 'text') {
-          messages.push({ role: 'user', content: content[0].text });
-          break;
-        }
-
-        const userContent: Array<XaiUserMessageContent> = [];
-
-        for (const part of content) {
-          switch (part.type) {
-            case 'text': {
-              userContent.push({ type: 'text', text: part.text });
-              break;
-            }
-            case 'file': {
-              switch (part.data.type) {
-                case 'reference': {
-                  userContent.push({
-                    type: 'file',
-                    file: {
-                      file_id: resolveProviderReference({
-                        reference: part.data.reference,
-                        provider: 'xai',
-                      }),
-                    },
-                  });
-                  break;
-                }
-                case 'text': {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: 'text file parts',
-                  });
-                }
-                case 'url':
-                case 'data': {
-                  if (getTopLevelMediaType(part.mediaType) === 'image') {
-                    const filePartOptions = await parseProviderOptions({
-                      provider: 'xai',
-                      providerOptions: part.providerOptions,
-                      schema: xaiFilePartProviderOptions,
-                    });
-
-                    userContent.push({
-                      type: 'image_url',
-                      image_url: {
-                        url:
-                          part.data.type === 'url'
-                            ? part.data.url.toString()
-                            : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`,
-                        ...(filePartOptions?.imageDetail != null && {
-                          detail: filePartOptions.imageDetail,
-                        }),
-                      },
-                    });
-                  } else {
-                    throw new UnsupportedFunctionalityError({
-                      functionality: `file part media type ${part.mediaType}`,
-                    });
-                  }
-                  break;
-                }
-              }
-              break;
-            }
-          }
-        }
-
-        messages.push({ role: 'user', content: userContent });
-
-        break;
-      }
-
-      case 'assistant': {
-        let text = '';
-        const toolCalls: Array<{
-          id: string;
-          type: 'function';
-          function: { name: string; arguments: string };
-        }> = [];
-
-        for (const part of content) {
-          switch (part.type) {
-            case 'text': {
-              text += part.text;
-              break;
-            }
-            case 'tool-call': {
-              toolCalls.push({
-                id: part.toolCallId,
-                type: 'function',
-                function: {
-                  name: part.toolName,
-                  arguments: JSON.stringify(part.input),
-                },
-              });
-              break;
-            }
-          }
-        }
-
-        messages.push({
-          role: 'assistant',
-          content: text,
-          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-        });
-
-        break;
-      }
-
-      case 'tool': {
-        for (const toolResponse of content) {
-          if (toolResponse.type === 'tool-approval-response') {
-            continue;
-          }
-          const output = toolResponse.output;
-
-          let contentValue: string;
-          switch (output.type) {
-            case 'text':
-            case 'error-text':
-              contentValue = output.value;
-              break;
-            case 'execution-denied':
-              contentValue = output.reason ?? 'Tool call execution denied.';
-              break;
-            case 'content':
-            case 'json':
-            case 'error-json':
-              contentValue = JSON.stringify(output.value);
-              break;
-          }
-
-          messages.push({
-            role: 'tool',
-            tool_call_id: toolResponse.toolCallId,
-            content: contentValue,
-          });
-        }
-        break;
-      }
-
-      default: {
-        const _exhaustiveCheck: never = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-
-  return { messages, warnings };
-}

package/src/convert-xai-chat-usage.ts

@@ -1,29 +0,0 @@
-import type { LanguageModelV4Usage } from '@ai-sdk/provider';
-import type { XaiChatUsage } from './xai-chat-language-model';
-
-export function convertXaiChatUsage(usage: XaiChatUsage): LanguageModelV4Usage {
-  const cacheReadTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;
-  const reasoningTokens =
-    usage.completion_tokens_details?.reasoning_tokens ?? 0;
-
-  const promptTokensIncludesCached = cacheReadTokens <= usage.prompt_tokens;
-
-  return {
-    inputTokens: {
-      total: promptTokensIncludesCached
-        ? usage.prompt_tokens
-        : usage.prompt_tokens + cacheReadTokens,
-      noCache: promptTokensIncludesCached
-        ? usage.prompt_tokens - cacheReadTokens
-        : usage.prompt_tokens,
-      cacheRead: cacheReadTokens,
-      cacheWrite: undefined,
-    },
-    outputTokens: {
-      total: usage.completion_tokens + reasoningTokens,
-      text: usage.completion_tokens,
-      reasoning: reasoningTokens,
-    },
-    raw: usage,
-  };
-}

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

@@ -1,141 +0,0 @@
-import { z } from 'zod/v4';
-
-// https://docs.x.ai/docs/models
-export type XaiChatModelId =
-  | 'grok-4.20-non-reasoning'
-  | 'grok-4.20-reasoning'
-  | 'grok-4.3'
-  | 'grok-4.5'
-  | 'grok-4.6'
-  | 'grok-latest'
-  | (string & {});
-
-// search source schemas
-const webSourceSchema = z.object({
-  type: z.literal('web'),
-  country: z.string().length(2).optional(),
-  excludedWebsites: z.array(z.string()).max(5).optional(),
-  allowedWebsites: z.array(z.string()).max(5).optional(),
-  safeSearch: z.boolean().optional(),
-});
-
-const xSourceSchema = z.object({
-  type: z.literal('x'),
-  excludedXHandles: z.array(z.string()).optional(),
-  includedXHandles: z.array(z.string()).optional(),
-  postFavoriteCount: z.number().int().optional(),
-  postViewCount: z.number().int().optional(),
-  /**
-   * @deprecated use `includedXHandles` instead
-   */
-  xHandles: z.array(z.string()).optional(),
-});
-
-const newsSourceSchema = z.object({
-  type: z.literal('news'),
-  country: z.string().length(2).optional(),
-  excludedWebsites: z.array(z.string()).max(5).optional(),
-  safeSearch: z.boolean().optional(),
-});
-
-const rssSourceSchema = z.object({
-  type: z.literal('rss'),
-  links: z.array(z.string().url()).max(1), // currently only supports one RSS link
-});
-
-const searchSourceSchema = z.discriminatedUnion('type', [
-  webSourceSchema,
-  xSourceSchema,
-  newsSourceSchema,
-  rssSourceSchema,
-]);
-
-// xai-specific provider options
-export const xaiLanguageModelChatOptions = z.object({
-  /**
-   * 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.
-   * - `xhigh`: Uses the most reasoning tokens (supported by `grok-4.6`).
-   *
-   * 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', 'xhigh'])
-    .optional(),
-  logprobs: z.boolean().optional(),
-  topLogprobs: z.number().int().min(0).max(8).optional(),
-
-  serviceTier: z.enum(['default', 'priority']).optional(),
-
-  /**
-   * Whether to enable parallel function calling during tool use.
-   * When true, the model can call multiple functions in parallel.
-   * When false, the model will call functions sequentially.
-   * Defaults to true.
-   */
-  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({
-      /**
-       * search mode preference
-       * - "off": disables search completely
-       * - "auto": model decides whether to search (default)
-       * - "on": always enables search
-       */
-      mode: z.enum(['off', 'auto', 'on']),
-
-      /**
-       * whether to return citations in the response
-       * defaults to true
-       */
-      returnCitations: z.boolean().optional(),
-
-      /**
-       * start date for search data (ISO8601 format: YYYY-MM-DD)
-       */
-      fromDate: z.string().optional(),
-
-      /**
-       * end date for search data (ISO8601 format: YYYY-MM-DD)
-       */
-      toDate: z.string().optional(),
-
-      /**
-       * maximum number of search results to consider
-       * defaults to 20
-       */
-      maxSearchResults: z.number().min(1).max(50).optional(),
-
-      /**
-       * data sources to search from.
-       * defaults to [{ type: 'web' }, { type: 'x' }] if not specified.
-       *
-       * @example
-       * sources: [{ type: 'web', country: 'US' }, { type: 'x' }]
-       */
-      sources: z.array(searchSourceSchema).optional(),
-    })
-    .optional(),
-});
-
-export type XaiLanguageModelChatOptions = z.infer<
-  typeof xaiLanguageModelChatOptions
->;