@ai-sdk/xai 0.0.0-1c33ba03-20260114162300 → 0.0.0-4115c213-20260122152721

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/xai",
-  "version": "0.0.0-1c33ba03-20260114162300",
+  "version": "0.0.0-4115c213-20260122152721",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,9 +8,18 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "docs/**/*",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test-d.ts",
+    "!src/**/__snapshots__",
+    "!src/**/__fixtures__",
     "CHANGELOG.md",
     "README.md"
   ],
+  "directories": {
+    "doc": "./docs"
+  },
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -20,16 +29,16 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/openai-compatible": "0.0.0-1c33ba03-20260114162300",
-    "@ai-sdk/provider": "3.0.3",
-    "@ai-sdk/provider-utils": "0.0.0-1c33ba03-20260114162300"
+    "@ai-sdk/openai-compatible": "0.0.0-4115c213-20260122152721",
+    "@ai-sdk/provider": "0.0.0-4115c213-20260122152721",
+    "@ai-sdk/provider-utils": "0.0.0-4115c213-20260122152721"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
     "tsup": "^8",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "1.0.1",
+    "@ai-sdk/test-server": "0.0.0-4115c213-20260122152721",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
@@ -55,7 +64,7 @@
   "scripts": {
     "build": "pnpm clean && tsup --tsconfig tsconfig.build.json",
     "build:watch": "pnpm clean && tsup --watch",
-    "clean": "del-cli dist *.tsbuildinfo",
+    "clean": "del-cli dist docs *.tsbuildinfo",
     "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --build",
     "prettier-check": "prettier --check \"./**/*.ts*\"",

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

@@ -0,0 +1,142 @@
+import {
+  SharedV3Warning,
+  LanguageModelV3Prompt,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+import { XaiChatPrompt } from './xai-chat-prompt';
+
+export function convertToXaiChatMessages(prompt: LanguageModelV3Prompt): {
+  messages: XaiChatPrompt;
+  warnings: Array<SharedV3Warning>;
+} {
+  const messages: XaiChatPrompt = [];
+  const warnings: Array<SharedV3Warning> = [];
+
+  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;
+        }
+
+        messages.push({
+          role: 'user',
+          content: content.map(part => {
+            switch (part.type) {
+              case 'text': {
+                return { type: 'text', text: part.text };
+              }
+              case 'file': {
+                if (part.mediaType.startsWith('image/')) {
+                  const mediaType =
+                    part.mediaType === 'image/*'
+                      ? 'image/jpeg'
+                      : part.mediaType;
+
+                  return {
+                    type: 'image_url',
+                    image_url: {
+                      url:
+                        part.data instanceof URL
+                          ? part.data.toString()
+                          : `data:${mediaType};base64,${convertToBase64(part.data)}`,
+                    },
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`,
+                  });
+                }
+              }
+            }
+          }),
+        });
+
+        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 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

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

package/src/get-response-metadata.ts

@@ -0,0 +1,19 @@
+export function getResponseMetadata({
+  id,
+  model,
+  created,
+  created_at,
+}: {
+  id?: string | undefined | null;
+  created?: number | undefined | null;
+  created_at?: number | undefined | null;
+  model?: string | undefined | null;
+}) {
+  const unixTime = created ?? created_at;
+
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: unixTime != null ? new Date(unixTime * 1000) : undefined,
+  };
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+export type { XaiProviderOptions } from './xai-chat-options';
+export type { XaiErrorData } from './xai-error';
+export type { XaiResponsesProviderOptions } from './responses/xai-responses-options';
+export { createXai, xai } from './xai-provider';
+export type { XaiProvider, XaiProviderSettings } from './xai-provider';
+export {
+  codeExecution,
+  viewImage,
+  viewXVideo,
+  webSearch,
+  xSearch,
+  xaiTools,
+} from './tool';
+export { VERSION } from './version';

package/src/map-xai-finish-reason.ts

@@ -0,0 +1,19 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+
+export function mapXaiFinishReason(
+  finishReason: string | null | undefined,
+): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case 'stop':
+      return 'stop';
+    case 'length':
+      return 'length';
+    case 'tool_calls':
+    case 'function_call':
+      return 'tool-calls';
+    case 'content_filter':
+      return 'content-filter';
+    default:
+      return 'other';
+  }
+}

package/src/responses/convert-to-xai-responses-input.ts

@@ -0,0 +1,206 @@
+import {
+  SharedV3Warning,
+  LanguageModelV3Message,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+import {
+  XaiResponsesInput,
+  XaiResponsesUserMessageContentPart,
+} from './xai-responses-api';
+
+export async function convertToXaiResponsesInput({
+  prompt,
+}: {
+  prompt: LanguageModelV3Message[];
+  store?: boolean;
+}): Promise<{
+  input: XaiResponsesInput;
+  inputWarnings: SharedV3Warning[];
+}> {
+  const input: XaiResponsesInput = [];
+  const inputWarnings: SharedV3Warning[] = [];
+
+  for (const message of prompt) {
+    switch (message.role) {
+      case 'system': {
+        input.push({
+          role: 'system',
+          content: message.content,
+        });
+        break;
+      }
+
+      case 'user': {
+        const contentParts: XaiResponsesUserMessageContentPart[] = [];
+
+        for (const block of message.content) {
+          switch (block.type) {
+            case 'text': {
+              contentParts.push({ type: 'input_text', text: block.text });
+              break;
+            }
+
+            case 'file': {
+              if (block.mediaType.startsWith('image/')) {
+                const mediaType =
+                  block.mediaType === 'image/*'
+                    ? 'image/jpeg'
+                    : block.mediaType;
+
+                const imageUrl =
+                  block.data instanceof URL
+                    ? block.data.toString()
+                    : `data:${mediaType};base64,${convertToBase64(block.data)}`;
+
+                contentParts.push({ type: 'input_image', image_url: imageUrl });
+              } else {
+                throw new UnsupportedFunctionalityError({
+                  functionality: `file part media type ${block.mediaType}`,
+                });
+              }
+              break;
+            }
+
+            default: {
+              const _exhaustiveCheck: never = block;
+              inputWarnings.push({
+                type: 'other',
+                message:
+                  'xAI Responses API does not support this content type in user messages',
+              });
+            }
+          }
+        }
+
+        input.push({
+          role: 'user',
+          content: contentParts,
+        });
+        break;
+      }
+
+      case 'assistant': {
+        for (const part of message.content) {
+          switch (part.type) {
+            case 'text': {
+              const id =
+                typeof part.providerOptions?.xai?.itemId === 'string'
+                  ? part.providerOptions.xai.itemId
+                  : undefined;
+
+              input.push({
+                role: 'assistant',
+                content: part.text,
+                id,
+              });
+
+              break;
+            }
+
+            case 'tool-call': {
+              if (part.providerExecuted) {
+                break;
+              }
+
+              const id =
+                typeof part.providerOptions?.xai?.itemId === 'string'
+                  ? part.providerOptions.xai.itemId
+                  : undefined;
+
+              input.push({
+                type: 'function_call',
+                id: id ?? part.toolCallId,
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify(part.input),
+                status: 'completed',
+              });
+              break;
+            }
+
+            case 'tool-result': {
+              break;
+            }
+
+            case 'reasoning':
+            case 'file': {
+              inputWarnings.push({
+                type: 'other',
+                message: `xAI Responses API does not support ${part.type} in assistant messages`,
+              });
+              break;
+            }
+
+            default: {
+              const _exhaustiveCheck: never = part;
+              inputWarnings.push({
+                type: 'other',
+                message:
+                  'xAI Responses API does not support this content type in assistant messages',
+              });
+            }
+          }
+        }
+
+        break;
+      }
+
+      case 'tool': {
+        for (const part of message.content) {
+          if (part.type === 'tool-approval-response') {
+            continue;
+          }
+          const output = part.output;
+
+          let outputValue: string;
+          switch (output.type) {
+            case 'text':
+            case 'error-text':
+              outputValue = output.value;
+              break;
+            case 'execution-denied':
+              outputValue = output.reason ?? 'tool execution denied';
+              break;
+            case 'json':
+            case 'error-json':
+              outputValue = JSON.stringify(output.value);
+              break;
+            case 'content':
+              outputValue = output.value
+                .map(item => {
+                  if (item.type === 'text') {
+                    return item.text;
+                  }
+                  return '';
+                })
+                .join('');
+              break;
+            default: {
+              const _exhaustiveCheck: never = output;
+              outputValue = '';
+            }
+          }
+
+          input.push({
+            type: 'function_call_output',
+            call_id: part.toolCallId,
+            output: outputValue,
+          });
+        }
+
+        break;
+      }
+
+      default: {
+        const _exhaustiveCheck: never = message;
+        inputWarnings.push({
+          type: 'other',
+          message: 'unsupported message role',
+        });
+      }
+    }
+  }
+
+  return { input, inputWarnings };
+}

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

@@ -0,0 +1,24 @@
+import { LanguageModelV3Usage } from '@ai-sdk/provider';
+import { XaiResponsesUsage } from './xai-responses-api';
+
+export function convertXaiResponsesUsage(
+  usage: XaiResponsesUsage,
+): LanguageModelV3Usage {
+  const cacheReadTokens = usage.input_tokens_details?.cached_tokens ?? 0;
+  const reasoningTokens = usage.output_tokens_details?.reasoning_tokens ?? 0;
+
+  return {
+    inputTokens: {
+      total: usage.input_tokens,
+      noCache: usage.input_tokens - cacheReadTokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: undefined,
+    },
+    outputTokens: {
+      total: usage.output_tokens,
+      text: usage.output_tokens - reasoningTokens,
+      reasoning: reasoningTokens,
+    },
+    raw: usage,
+  };
+}

package/src/responses/map-xai-responses-finish-reason.ts

@@ -0,0 +1,20 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+
+export function mapXaiResponsesFinishReason(
+  finishReason: string | null | undefined,
+): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case 'stop':
+    case 'completed':
+      return 'stop';
+    case 'length':
+      return 'length';
+    case 'tool_calls':
+    case 'function_call':
+      return 'tool-calls';
+    case 'content_filter':
+      return 'content-filter';
+    default:
+      return 'other';
+  }
+}