@ai-sdk/xai 4.0.44 → 4.0.48

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

@@ -13,6 +13,7 @@ import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
+  createProviderStreamError,
   isCustomReasoning,
   mapReasoningToProviderEffort,
   parseProviderOptions,
@@ -21,16 +22,20 @@ import {
   WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE,
   type FetchFunction,
+  type InferSchema,
   type ParseResult,
 } from '@ai-sdk/provider-utils';
 import type { z } from 'zod/v4';
 import { getResponseMetadata } from '../get-response-metadata';
 import { supportsReasoningEffort } from '../supports-reasoning-effort';
+import type { webSearchOutputSchema } from '../tool/web-search';
 import { xaiFailedResponseHandler } from '../xai-error';
 import { convertToXaiResponsesInput } from './convert-to-xai-responses-input';
 import { convertXaiResponsesUsage } from './convert-xai-responses-usage';
 import { mapXaiResponsesFinishReason } from './map-xai-responses-finish-reason';
 import {
+  webSearchWireActionSchema,
+  webSearchWireSourceSchema,
   xaiResponsesChunkSchema,
   xaiResponsesResponseSchema,
   type XaiResponsesIncludeOptions,
@@ -41,7 +46,7 @@ import {
 } from './xai-responses-language-model-options';
 import { prepareResponsesTools } from './xai-responses-prepare-tools';
 
-type XaiResponsesConfig = {
+export type XaiResponsesConfig = {
   provider: string;
   baseURL: string | undefined;
   headers?: () => Record<string, string | undefined>;
@@ -49,6 +54,91 @@ type XaiResponsesConfig = {
   fetch?: FetchFunction;
 };
 
+function createXaiResponsesStreamError({
+  message,
+  code,
+  eventType,
+  data,
+}: {
+  message: string;
+  code?: string | null;
+  eventType: 'error' | 'response.failed';
+  data: unknown;
+}) {
+  const statusCode = getHttpStatusCode(code);
+
+  return createProviderStreamError({
+    message,
+    type: eventType,
+    code: code ?? undefined,
+    ...(statusCode != null
+      ? {
+          statusCode,
+          isRetryable: isRetryableStatusCode(statusCode),
+        }
+      : getXaiResponsesStreamErrorMetadata(code)),
+    data,
+  });
+}
+
+function getXaiResponsesStreamErrorMetadata(code?: string | null): {
+  statusCode?: number;
+  isRetryable?: boolean;
+} {
+  switch (code) {
+    case 'rate_limit_exceeded':
+    case 'rate_limit_error':
+      return { statusCode: 429, isRetryable: true };
+    case 'insufficient_quota':
+      return { statusCode: 429, isRetryable: false };
+    case 'api_error':
+    case 'internal_server_error':
+    case 'server_error':
+      return { statusCode: 500, isRetryable: true };
+    case 'overloaded_error':
+    case 'service_unavailable':
+      return { statusCode: 503, isRetryable: true };
+    case 'timeout':
+    case 'timeout_error':
+      return { statusCode: 504, isRetryable: true };
+    case 'authentication_error':
+    case 'invalid_api_key':
+      return { statusCode: 401, isRetryable: false };
+    case 'permission_error':
+      return { statusCode: 403, isRetryable: false };
+    case 'not_found_error':
+    case 'model_not_found':
+      return { statusCode: 404, isRetryable: false };
+    case 'bad_request':
+    case 'context_length_exceeded':
+    case 'invalid_request_error':
+      return { statusCode: 400, isRetryable: false };
+    default:
+      return {};
+  }
+}
+
+function getHttpStatusCode(value: unknown): number | undefined {
+  const statusCode =
+    typeof value === 'string' && /^\d{3}$/.test(value) ? Number(value) : value;
+
+  return typeof statusCode === 'number' &&
+    Number.isInteger(statusCode) &&
+    statusCode >= 400 &&
+    statusCode <= 599
+    ? statusCode
+    : undefined;
+}
+
+function isRetryableStatusCode(statusCode: number): boolean {
+  return (
+    statusCode === 408 ||
+    statusCode === 409 ||
+    statusCode === 429 ||
+    statusCode >= 500
+  );
+}
+
 export class XaiResponsesLanguageModel implements LanguageModelV4 {
   readonly specificationVersion = 'v4';
 
@@ -88,7 +178,7 @@ export class XaiResponsesLanguageModel implements LanguageModelV4 {
     'text/*': [/^https?:\/\/.*$/],
   };
 
-  private async getArgs({
+  protected async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -436,6 +526,15 @@ export class XaiResponsesLanguageModel implements LanguageModelV4 {
           providerExecuted: true,
         });
 
+        if (part.type === 'web_search_call') {
+          content.push({
+            type: 'tool-result',
+            toolCallId: part.id,
+            toolName,
+            result: mapWebSearchAction(part.action),
+          });
+        }
+
         continue;
       }
 
@@ -820,11 +919,31 @@ export class XaiResponsesLanguageModel implements LanguageModelV4 {
                 usage = convertXaiResponsesUsage(event.response.usage);
               }
 
+              if (event.response.error != null) {
+                controller.enqueue({
+                  type: 'error',
+                  error: createXaiResponsesStreamError({
+                    message: event.response.error.message,
+                    code: event.response.error.code,
+                    eventType: event.type,
+                    data: event,
+                  }),
+                });
+              }
+
               return;
             }
 
             if (event.type === 'error') {
-              controller.enqueue({ type: 'error', error: event });
+              controller.enqueue({
+                type: 'error',
+                error: createXaiResponsesStreamError({
+                  message: event.message,
+                  code: event.code,
+                  eventType: event.type,
+                  data: event,
+                }),
+              });
               return;
             }
 
@@ -1133,7 +1252,10 @@ export class XaiResponsesLanguageModel implements LanguageModelV4 {
                     type: 'tool-result',
                     toolCallId: part.id,
                     toolName,
-                    result: {},
+                    result:
+                      part.type === 'web_search_call'
+                        ? mapWebSearchAction(part.action)
+                        : {},
                   });
                 }
 
@@ -1251,3 +1373,36 @@ export class XaiResponsesLanguageModel implements LanguageModelV4 {
     };
   }
 }
+
+function mapWebSearchAction(
+  action: unknown,
+): InferSchema<typeof webSearchOutputSchema> {
+  const parsed = webSearchWireActionSchema.safeParse(action);
+  if (!parsed.success) return {};
+
+  const a = parsed.data;
+  const sources = a.sources?.flatMap(s => {
+    const source = webSearchWireSourceSchema.safeParse(s);
+    return source.success ? [source.data] : [];
+  });
+  const sourcesExtra = sources != null && sources.length > 0 ? { sources } : {};
+
+  switch (a.type) {
+    case 'search':
+      return {
+        action: {
+          type: 'search',
+          ...(a.query != null && { query: a.query }),
+          ...(a.queries != null && { queries: a.queries }),
+        },
+        ...sourcesExtra,
+      };
+    case 'open_page':
+      return { action: { type: 'openPage', url: a.url }, ...sourcesExtra };
+    case 'find_in_page':
+      return {
+        action: { type: 'findInPage', url: a.url, pattern: a.pattern },
+        ...sourcesExtra,
+      };
+  }
+}

package/src/tool/web-search.ts

@@ -16,17 +16,30 @@ export const webSearchArgsSchema = lazySchema(() =>
   ),
 );
 
-const webSearchOutputSchema = lazySchema(() =>
+export const webSearchOutputSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      query: z.string(),
-      sources: z.array(
-        z.object({
-          title: z.string(),
-          url: z.string(),
-          snippet: z.string(),
-        }),
-      ),
+      action: z
+        .discriminatedUnion('type', [
+          z.object({
+            type: z.literal('search'),
+            query: z.string().optional(),
+            queries: z.array(z.string()).optional(),
+          }),
+          z.object({
+            type: z.literal('openPage'),
+            url: z.string().nullish(),
+          }),
+          z.object({
+            type: z.literal('findInPage'),
+            url: z.string().nullish(),
+            pattern: z.string().nullish(),
+          }),
+        ])
+        .optional(),
+      sources: z
+        .array(z.object({ type: z.literal('url'), url: z.string() }))
+        .optional(),
     }),
   ),
 );
@@ -34,12 +47,22 @@ const webSearchOutputSchema = lazySchema(() =>
 const webSearchToolFactory = createProviderExecutedToolFactory<
   {},
   {
-    query: string;
-    sources: Array<{
-      title: string;
-      url: string;
-      snippet: string;
-    }>;
+    action?:
+      | {
+          type: 'search';
+          query?: string;
+          queries?: string[];
+        }
+      | {
+          type: 'openPage';
+          url?: string | null;
+        }
+      | {
+          type: 'findInPage';
+          url?: string | null;
+          pattern?: string | null;
+        };
+    sources?: Array<{ type: 'url'; url: string }>;
   },
   {
     allowedDomains?: string[];

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

@@ -672,31 +672,36 @@ export class XaiChatLanguageModel implements LanguageModelV4 {
 }
 
 // XAI API Response Schemas
-const xaiUsageSchema = z.object({
-  prompt_tokens: z.number(),
-  completion_tokens: z.number(),
-  total_tokens: z.number(),
-  prompt_tokens_details: z
-    .object({
-      text_tokens: z.number().nullish(),
-      audio_tokens: z.number().nullish(),
-      image_tokens: z.number().nullish(),
-      cached_tokens: z.number().nullish(),
-    })
-    .nullish(),
-  completion_tokens_details: z
-    .object({
-      reasoning_tokens: z.number().nullish(),
-      audio_tokens: z.number().nullish(),
-      accepted_prediction_tokens: z.number().nullish(),
-      rejected_prediction_tokens: z.number().nullish(),
-    })
-    .nullish(),
-});
+const xaiUsageSchema = 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({
+        text_tokens: z.number().nullish(),
+        audio_tokens: z.number().nullish(),
+        image_tokens: z.number().nullish(),
+        cached_tokens: z.number().nullish(),
+      })
+      .catchall(z.json())
+      .nullish(),
+    completion_tokens_details: z
+      .object({
+        reasoning_tokens: z.number().nullish(),
+        audio_tokens: z.number().nullish(),
+        accepted_prediction_tokens: z.number().nullish(),
+        rejected_prediction_tokens: z.number().nullish(),
+      })
+      .catchall(z.json())
+      .nullish(),
+  })
+  .catchall(z.json());
 
 export type XaiChatUsage = z.infer<typeof xaiUsageSchema>;
 
-const xaiChatResponseSchema = z.object({
+export const xaiChatResponseSchema = z.object({
   id: z.string().nullish(),
   created: z.number().nullish(),
   model: z.string().nullish(),
@@ -733,6 +738,8 @@ const xaiChatResponseSchema = z.object({
   error: z.string().nullish(),
 });
 
+export type XaiChatResponse = z.infer<typeof xaiChatResponseSchema>;
+
 const xaiChatChunkSchema = z.object({
   id: z.string().nullish(),
   created: z.number().nullish(),

package/src/xai-provider.ts

@@ -2,6 +2,7 @@ import {
   type Experimental_RealtimeFactoryV4 as RealtimeFactoryV4,
   type Experimental_RealtimeFactoryV4GetTokenOptions as RealtimeFactoryV4GetTokenOptions,
   type Experimental_VideoModelV4,
+  type Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
   type FilesV4,
   type ImageModelV4,
   type LanguageModelV4,
@@ -22,7 +23,7 @@ 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 { XaiResponsesLanguageModel } from './responses/xai-responses-language-model';
+import { XaiResponsesBatchLanguageModel } from './responses/xai-responses-batch';
 import type { XaiResponsesModelId } from './responses/xai-responses-language-model-options';
 import { XaiRealtimeModel } from './realtime/xai-realtime-model';
 import { xaiTools } from './tool';
@@ -34,12 +35,12 @@ import { XaiSpeechModel } from './xai-speech-model';
 import { XaiTranscriptionModel } from './xai-transcription-model';
 
 export interface XaiProvider extends ProviderV4 {
-  (modelId: XaiResponsesModelId): LanguageModelV4;
+  (modelId: XaiResponsesModelId): BatchLanguageModelV4;
 
   /**
    * Creates an Xai language model for text generation.
    */
-  languageModel(modelId: XaiResponsesModelId): LanguageModelV4;
+  languageModel(modelId: XaiResponsesModelId): BatchLanguageModelV4;
 
   /**
    * Creates an Xai chat model for text generation.
@@ -49,7 +50,7 @@ export interface XaiProvider extends ProviderV4 {
   /**
    * Creates an Xai responses model for text generation.
    */
-  responses: (modelId: XaiResponsesModelId) => LanguageModelV4;
+  responses: (modelId: XaiResponsesModelId) => BatchLanguageModelV4;
 
   /**
    * Creates an Xai image model for image generation.
@@ -166,7 +167,7 @@ export function createXai(options: XaiProviderSettings = {}): XaiProvider {
   };
 
   const createResponsesLanguageModel = (modelId: XaiResponsesModelId) => {
-    return new XaiResponsesLanguageModel(modelId, {
+    return new XaiResponsesBatchLanguageModel(modelId, {
       provider: 'xai.responses',
       baseURL,
       headers: getHeaders,

package/src/xai-video-model.ts

@@ -39,6 +39,17 @@ interface XaiVideoModelConfig {
   };
 }
 
+function encodePathSegment(value: string): string {
+  const encodedValue = encodeURIComponent(value);
+
+  // URL parsing normalizes both literal and percent-encoded dot segments.
+  return encodedValue === '.'
+    ? '%252E'
+    : encodedValue === '..'
+      ? '%252E%252E'
+      : encodedValue;
+}
+
 const RESOLUTION_MAP: Record<string, string> = {
   '1920x1080': '1080p',
   '1280x720': '720p',
@@ -538,7 +549,7 @@ export class XaiVideoModel implements VideoModelV4 {
     const baseURL = this.config.baseURL ?? 'https://api.x.ai/v1';
 
     const { value: statusResponse, responseHeaders } = await getFromApi({
-      url: `${baseURL}/videos/${requestId}`,
+      url: `${baseURL}/videos/${encodePathSegment(requestId)}`,
       validateUrl: false,
       headers: combineHeaders(this.config.headers(), options.headers),
       successfulResponseHandler: xaiVideoStatusResponseHandler,