@ai-sdk/xai 4.0.50 → 4.0.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/xai",
-  "version": "4.0.50",
+  "version": "4.0.52",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -29,8 +29,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.9",
-    "@ai-sdk/provider-utils": "5.0.34"
+    "@ai-sdk/provider": "4.0.10",
+    "@ai-sdk/provider-utils": "5.0.35"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.1",

package/src/files/xai-files-api.ts

@@ -8,9 +8,20 @@ export const xaiFilesResponseSchema = lazySchema(() =>
       object: z.string().nullish(),
       bytes: z.number().nullish(),
       created_at: z.number().nullish(),
+      expires_at: z.number().nullish(),
       filename: z.string().nullish(),
       purpose: z.string().nullish(),
       status: z.string().nullish(),
     }),
   ),
 );
+
+export const xaiFileDeleteResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string(),
+      object: z.string().nullish(),
+      deleted: z.boolean(),
+    }),
+  ),
+);

package/src/files/xai-files-options.ts

@@ -10,6 +10,12 @@ export const xaiFilesOptionsSchema = lazySchema(() =>
     z.looseObject({
       teamId: z.string().optional(),
       filePath: z.string().optional(),
+      /**
+       * TTL in seconds measured from upload time; xAI accepts integers
+       * between 3600 (1 hour) and 2592000 (30 days) inclusive.
+       * Omit to keep the file until it is deleted.
+       */
+      expiresAfter: z.number().int().min(3600).max(2_592_000).optional(),
     }),
   ),
 );

package/src/files/xai-files.ts

@@ -1,22 +1,40 @@
-import type {
-  FilesV4,
-  FilesV4UploadFileCallOptions,
-  FilesV4UploadFileResult,
+import {
+  InvalidArgumentError,
+  type FilesV4,
+  type FilesV4DeleteFileCallOptions,
+  type FilesV4DeleteFileResult,
+  type FilesV4DownloadFileCallOptions,
+  type FilesV4DownloadFileResult,
+  type FilesV4GetFileMetadataCallOptions,
+  type FilesV4GetFileMetadataResult,
+  type FilesV4UploadFileCallOptions,
+  type FilesV4UploadFileResult,
+  type SharedV4ProviderReference,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertInlineFileDataToUint8Array,
+  createBinaryStreamResponseHandler,
   createJsonResponseHandler,
+  deleteFromApi,
+  getFromApi,
   parseProviderOptions,
   postFormDataToApi,
+  postMultipartStreamToApi,
   type FetchFunction,
+  type InferSchema,
+  type MultipartStreamPart,
 } from '@ai-sdk/provider-utils';
 import { xaiFailedResponseHandler } from '../xai-error';
-import { xaiFilesResponseSchema } from './xai-files-api';
+import {
+  xaiFileDeleteResponseSchema,
+  xaiFilesResponseSchema,
+} from './xai-files-api';
 import {
   xaiFilesOptionsSchema,
   type XaiFilesOptions,
 } from './xai-files-options';
+
 interface XaiFilesConfig {
   provider: string;
   baseURL: string | undefined;
@@ -24,6 +42,19 @@ interface XaiFilesConfig {
   fetch?: FetchFunction;
 }
 
+type XaiFilesResponse = InferSchema<typeof xaiFilesResponseSchema>;
+
+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;
+}
+
 export class XaiFiles implements FilesV4 {
   readonly specificationVersion = 'v4';
 
@@ -33,62 +64,250 @@ export class XaiFiles implements FilesV4 {
 
   constructor(private readonly config: XaiFilesConfig) {}
 
+  private getFileId(file: SharedV4ProviderReference): string {
+    const fileId = file.xai;
+    if (fileId == null || fileId.trim() === '') {
+      throw new InvalidArgumentError({
+        argument: 'file',
+        message: "file reference is missing an 'xai' file id.",
+      });
+    }
+    return fileId;
+  }
+
+  private getHeaders(
+    headers: Record<string, string | undefined> | undefined,
+  ): Record<string, string | undefined> {
+    return combineHeaders(this.config.headers(), headers);
+  }
+
   async uploadFile({
     data,
     mediaType,
     filename,
+    abortSignal,
+    headers,
     providerOptions,
   }: FilesV4UploadFileCallOptions): Promise<FilesV4UploadFileResult> {
-    const xaiOptions = (await parseProviderOptions({
-      provider: 'xai',
-      providerOptions,
-      schema: xaiFilesOptionsSchema,
-    })) as XaiFilesOptions | undefined;
+    let xaiOptions: XaiFilesOptions | undefined;
+    try {
+      xaiOptions = (await parseProviderOptions({
+        provider: 'xai',
+        providerOptions,
+        schema: xaiFilesOptionsSchema,
+      })) as XaiFilesOptions | undefined;
+    } catch (error) {
+      // rejected before any request: release the caller's stream
+      if (data.type === 'stream') {
+        await data.stream.cancel(error).catch(() => {});
+      }
+      throw error;
+    }
 
-    const fileBytes = convertInlineFileDataToUint8Array(data);
+    const requestHeaders = this.getHeaders(headers);
+    const url = `${this.config.baseURL}/files`;
 
-    const blob = new Blob([fileBytes], {
-      type: mediaType,
-    });
+    let response: XaiFilesResponse;
+
+    if (data.type === 'stream') {
+      // xAI rejects uploads where expires_after arrives after the file part,
+      // so all fields precede the file.
+      const parts: Array<MultipartStreamPart> = [];
 
-    const formData = new FormData();
-    if (filename != null) {
-      formData.append('file', blob, filename);
+      if (xaiOptions?.expiresAfter != null) {
+        parts.push({
+          type: 'field',
+          name: 'expires_after',
+          value: String(xaiOptions.expiresAfter),
+        });
+      }
+
+      if (xaiOptions?.teamId != null) {
+        parts.push({
+          type: 'field',
+          name: 'team_id',
+          value: xaiOptions.teamId,
+        });
+      }
+
+      parts.push({
+        type: 'file',
+        name: 'file',
+        filename,
+        mediaType,
+        content: data.stream,
+      });
+
+      ({ value: response } = await postMultipartStreamToApi({
+        url,
+        headers: requestHeaders,
+        parts,
+        failedResponseHandler: xaiFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          xaiFilesResponseSchema,
+        ),
+        abortSignal,
+        fetch: this.config.fetch,
+      }));
     } else {
-      formData.append('file', blob);
-    }
+      const fileBytes = convertInlineFileDataToUint8Array(data);
 
-    if (xaiOptions?.teamId != null) {
-      formData.append('team_id', xaiOptions.teamId);
+      const blob = new Blob([fileBytes], {
+        type: mediaType,
+      });
+
+      // FormData serializes in append order; expires_after must precede file.
+      const formData = new FormData();
+
+      if (xaiOptions?.expiresAfter != null) {
+        formData.append('expires_after', String(xaiOptions.expiresAfter));
+      }
+
+      if (xaiOptions?.teamId != null) {
+        formData.append('team_id', xaiOptions.teamId);
+      }
+
+      if (filename != null) {
+        formData.append('file', blob, filename);
+      } else {
+        formData.append('file', blob);
+      }
+
+      ({ value: response } = await postFormDataToApi({
+        url,
+        headers: requestHeaders,
+        formData,
+        failedResponseHandler: xaiFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          xaiFilesResponseSchema,
+        ),
+        abortSignal,
+        fetch: this.config.fetch,
+      }));
     }
 
-    const { value: response } = await postFormDataToApi({
-      url: `${this.config.baseURL}/files`,
-      headers: combineHeaders(this.config.headers()),
-      formData,
+    return {
+      warnings: [],
+      providerReference: { xai: response.id },
+      ...((response.filename ?? filename)
+        ? { filename: response.filename ?? filename }
+        : {}),
+      ...(mediaType != null ? { mediaType } : {}),
+      ...(response.bytes != null ? { byteSize: response.bytes } : {}),
+      ...(response.created_at != null
+        ? { createdAt: new Date(response.created_at * 1000) }
+        : {}),
+      ...(response.expires_at != null
+        ? { expiresAt: new Date(response.expires_at * 1000) }
+        : {}),
+      providerMetadata: {
+        xai: this.toFileMetadata(response),
+      },
+    };
+  }
+
+  async getFileMetadata({
+    file,
+    abortSignal,
+    headers,
+  }: FilesV4GetFileMetadataCallOptions): Promise<FilesV4GetFileMetadataResult> {
+    const fileId = this.getFileId(file);
+
+    const { value: response } = await getFromApi({
+      url: `${this.config.baseURL}/files/${encodePathSegment(fileId)}`,
+      headers: this.getHeaders(headers),
       failedResponseHandler: xaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         xaiFilesResponseSchema,
       ),
+      abortSignal,
       fetch: this.config.fetch,
+      validateUrl: false,
     });
 
     return {
       warnings: [],
       providerReference: { xai: response.id },
-      ...((response.filename ?? filename)
-        ? { filename: response.filename ?? filename }
+      ...(response.filename != null ? { filename: response.filename } : {}),
+      ...(response.bytes != null ? { byteSize: response.bytes } : {}),
+      ...(response.created_at != null
+        ? { createdAt: new Date(response.created_at * 1000) }
+        : {}),
+      ...(response.expires_at != null
+        ? { expiresAt: new Date(response.expires_at * 1000) }
         : {}),
-      ...(mediaType != null ? { mediaType } : {}),
       providerMetadata: {
-        xai: {
-          ...(response.filename != null ? { filename: response.filename } : {}),
-          ...(response.bytes != null ? { bytes: response.bytes } : {}),
-          ...(response.created_at != null
-            ? { createdAt: response.created_at }
-            : {}),
-        },
+        xai: this.toFileMetadata(response),
       },
     };
   }
+
+  async downloadFile({
+    file,
+    abortSignal,
+    headers,
+  }: FilesV4DownloadFileCallOptions): Promise<FilesV4DownloadFileResult> {
+    const fileId = this.getFileId(file);
+
+    const { value: content, responseHeaders } = await getFromApi({
+      url: `${this.config.baseURL}/files/${encodePathSegment(fileId)}/content`,
+      headers: this.getHeaders(headers),
+      failedResponseHandler: xaiFailedResponseHandler,
+      successfulResponseHandler: createBinaryStreamResponseHandler(),
+      abortSignal,
+      fetch: this.config.fetch,
+      validateUrl: false,
+    });
+
+    // media type from the content endpoint's Content-Type, without parameters
+    const mediaType = responseHeaders?.['content-type']?.split(';')[0].trim();
+
+    return {
+      warnings: [],
+      content,
+      ...(mediaType ? { mediaType } : {}),
+    };
+  }
+
+  async deleteFile({
+    file,
+    abortSignal,
+    headers,
+  }: FilesV4DeleteFileCallOptions): Promise<FilesV4DeleteFileResult> {
+    const fileId = this.getFileId(file);
+
+    const { value: response } = await deleteFromApi({
+      url: `${this.config.baseURL}/files/${encodePathSegment(fileId)}`,
+      headers: this.getHeaders(headers),
+      failedResponseHandler: xaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        xaiFileDeleteResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      warnings: [],
+      providerReference: { xai: response.id },
+      deleted: response.deleted,
+    };
+  }
+
+  private toFileMetadata(
+    response: XaiFilesResponse,
+  ): Record<string, string | number> {
+    return {
+      ...(response.filename != null ? { filename: response.filename } : {}),
+      ...(response.purpose != null ? { purpose: response.purpose } : {}),
+      ...(response.bytes != null ? { bytes: response.bytes } : {}),
+      ...(response.created_at != null
+        ? { createdAt: response.created_at }
+        : {}),
+      ...(response.status != null ? { status: response.status } : {}),
+      ...(response.expires_at != null
+        ? { expiresAt: response.expires_at }
+        : {}),
+    };
+  }
 }

package/src/responses/xai-responses-batch.ts

@@ -481,8 +481,8 @@ function convertXaiChatBatchResponse(
     };
   }
 
-  const choice = response.choices?.[0];
-  if (choice == null) {
+  const choices = response.choices;
+  if (choices == null || choices.length === 0) {
     return {
       success: false,
       error: {
@@ -492,19 +492,54 @@ function convertXaiChatBatchResponse(
     };
   }
 
-  if (choice.message.tool_calls?.length) {
-    return unsupportedXaiBatchContent('tool_calls');
-  }
-
   const content: LanguageModelV4Content[] = [];
-  if (choice.message.content) {
-    content.push({ type: 'text', text: choice.message.content });
-  }
-  if (choice.message.reasoning_content) {
-    content.push({
-      type: 'reasoning',
-      text: choice.message.reasoning_content,
-    });
+  const providerExecutedToolCallIds = new Set(
+    choices
+      .filter(choice => choice.message.role === 'tool')
+      .flatMap(choice =>
+        (choice.message.tool_calls ?? []).map(toolCall => toolCall.id),
+      ),
+  );
+  let lastAssistantChoice: (typeof choices)[number] | undefined;
+
+  for (const choice of choices) {
+    if (choice.message.role === 'tool') {
+      if (choice.message.content != null) {
+        for (const toolCall of choice.message.tool_calls ?? []) {
+          content.push({
+            type: 'tool-result',
+            toolCallId: toolCall.id,
+            toolName: toolCall.function.name,
+            result: choice.message.content,
+            dynamic: true,
+          });
+        }
+      }
+      continue;
+    }
+
+    lastAssistantChoice = choice;
+
+    if (choice.message.content) {
+      content.push({ type: 'text', text: choice.message.content });
+    }
+    if (choice.message.reasoning_content) {
+      content.push({
+        type: 'reasoning',
+        text: choice.message.reasoning_content,
+      });
+    }
+    for (const toolCall of choice.message.tool_calls ?? []) {
+      content.push({
+        type: 'tool-call',
+        toolCallId: toolCall.id,
+        toolName: toolCall.function.name,
+        input: toolCall.function.arguments,
+        ...(providerExecutedToolCallIds.has(toolCall.id)
+          ? { providerExecuted: true, dynamic: true }
+          : {}),
+      });
+    }
   }
   for (const url of response.citations ?? []) {
     content.push({
@@ -520,8 +555,8 @@ function convertXaiChatBatchResponse(
     result: {
       content,
       finishReason: {
-        unified: mapXaiFinishReason(choice.finish_reason),
-        raw: choice.finish_reason ?? undefined,
+        unified: mapXaiFinishReason(lastAssistantChoice?.finish_reason),
+        raw: lastAssistantChoice?.finish_reason ?? undefined,
       },
       usage: response.usage
         ? convertXaiChatUsage(response.usage)
@@ -544,15 +579,3 @@ function convertXaiChatBatchResponse(
     },
   };
 }
-
-function unsupportedXaiBatchContent(type: string): XaiBatchResponseConversion {
-  return {
-    success: false,
-    error: {
-      message:
-        `xAI returned "${type}" content, but tool content is not supported ` +
-        'in AI SDK text batches.',
-      code: 'unsupported_content',
-    },
-  };
-}

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

@@ -709,7 +709,7 @@ export const xaiChatResponseSchema = z.object({
     .array(
       z.object({
         message: z.object({
-          role: z.literal('assistant'),
+          role: z.enum(['assistant', 'tool']),
           content: z.string().nullish(),
           reasoning_content: z.string().nullish(),
           tool_calls: z