@ai-sdk/xai 0.0.0-64aae7dd-20260114144918 → 0.0.0-98261322-20260122142521

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

@@ -0,0 +1,463 @@
+import { describe, expect, it } from 'vitest';
+import { convertToXaiResponsesInput } from './convert-to-xai-responses-input';
+
+describe('convertToXaiResponsesInput', () => {
+  describe('system messages', () => {
+    it('should convert system messages', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [{ role: 'system', content: 'you are a helpful assistant' }],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "content": "you are a helpful assistant",
+            "role": "system",
+          },
+        ]
+      `);
+      expect(result.inputWarnings).toEqual([]);
+    });
+  });
+
+  describe('user messages', () => {
+    it('should convert single text part', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'hello' }] }],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "content": [
+              {
+                "text": "hello",
+                "type": "input_text",
+              },
+            ],
+            "role": "user",
+          },
+        ]
+      `);
+    });
+
+    it('should concatenate multiple text parts', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'user',
+            content: [
+              { type: 'text', text: 'hello ' },
+              { type: 'text', text: 'world' },
+            ],
+          },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "content": [
+              {
+                "text": "hello ",
+                "type": "input_text",
+              },
+              {
+                "text": "world",
+                "type": "input_text",
+              },
+            ],
+            "role": "user",
+          },
+        ]
+      `);
+    });
+
+    it('should convert image file parts with URL', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'user',
+            content: [
+              { type: 'text', text: 'what is in this image' },
+              {
+                type: 'file',
+                mediaType: 'image/jpeg',
+                data: new URL('https://example.com/image.jpg'),
+              },
+            ],
+          },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "content": [
+              {
+                "text": "what is in this image",
+                "type": "input_text",
+              },
+              {
+                "image_url": "https://example.com/image.jpg",
+                "type": "input_image",
+              },
+            ],
+            "role": "user",
+          },
+        ]
+      `);
+      expect(result.inputWarnings).toEqual([]);
+    });
+
+    it('should convert image file parts with base64 data', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'user',
+            content: [
+              { type: 'text', text: 'describe this' },
+              {
+                type: 'file',
+                mediaType: 'image/png',
+                data: new Uint8Array([1, 2, 3]),
+              },
+            ],
+          },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "content": [
+              {
+                "text": "describe this",
+                "type": "input_text",
+              },
+              {
+                "image_url": "data:image/png;base64,AQID",
+                "type": "input_image",
+              },
+            ],
+            "role": "user",
+          },
+        ]
+      `);
+    });
+
+    it('should throw for unsupported file types', async () => {
+      await expect(
+        convertToXaiResponsesInput({
+          prompt: [
+            {
+              role: 'user',
+              content: [
+                { type: 'text', text: 'check this file' },
+                {
+                  type: 'file',
+                  mediaType: 'application/pdf',
+                  data: new Uint8Array([1, 2, 3]),
+                },
+              ],
+            },
+          ],
+        }),
+      ).rejects.toThrow('file part media type application/pdf');
+    });
+  });
+
+  describe('assistant messages', () => {
+    it('should convert text content', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          { role: 'assistant', content: [{ type: 'text', text: 'hi there' }] },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "content": "hi there",
+            "id": undefined,
+            "role": "assistant",
+          },
+        ]
+      `);
+    });
+
+    it('should handle client-side tool-call parts', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'call_123',
+                toolName: 'weather',
+                input: { location: 'sf' },
+              },
+            ],
+          },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "arguments": "{"location":"sf"}",
+            "call_id": "call_123",
+            "id": "call_123",
+            "name": "weather",
+            "status": "completed",
+            "type": "function_call",
+          },
+        ]
+      `);
+    });
+
+    it('should handle client-side tool-call parts named like server-side tools', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'call_ws',
+                toolName: 'web_search',
+                input: { query: 'latest news' },
+              },
+            ],
+          },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "arguments": "{\"query\":\"latest news\"}",
+            "call_id": "call_ws",
+            "id": "call_ws",
+            "name": "web_search",
+            "status": "completed",
+            "type": "function_call",
+          },
+        ]
+      `);
+    });
+
+    it('should skip server-side tool-call parts', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'ws_123',
+                toolName: 'web_search',
+                input: {},
+                providerExecuted: true,
+              },
+            ],
+          },
+        ],
+      });
+
+      expect(result.input).toEqual([]);
+    });
+  });
+
+  describe('tool messages', () => {
+    it('should convert tool-result to function_call_output with json', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-result',
+                toolCallId: 'call_123',
+                toolName: 'weather',
+                output: {
+                  type: 'json',
+                  value: { temp: 72 },
+                },
+              },
+            ],
+          },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "call_id": "call_123",
+            "output": "{"temp":72}",
+            "type": "function_call_output",
+          },
+        ]
+      `);
+    });
+
+    it('should handle text output', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-result',
+                toolCallId: 'call_123',
+                toolName: 'weather',
+                output: {
+                  type: 'text',
+                  value: 'sunny, 72 degrees',
+                },
+              },
+            ],
+          },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "call_id": "call_123",
+            "output": "sunny, 72 degrees",
+            "type": "function_call_output",
+          },
+        ]
+      `);
+    });
+  });
+
+  describe('multi-turn conversations', () => {
+    it('should handle full conversation with client-side tool calls', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'user',
+            content: [{ type: 'text', text: 'whats the weather' }],
+          },
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'call_123',
+                toolName: 'weather',
+                input: { location: 'sf' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            content: [
+              {
+                type: 'tool-result',
+                toolCallId: 'call_123',
+                toolName: 'weather',
+                output: {
+                  type: 'json',
+                  value: { temp: 72 },
+                },
+              },
+            ],
+          },
+          {
+            role: 'assistant',
+            content: [{ type: 'text', text: 'its 72 degrees' }],
+          },
+        ],
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "content": [
+              {
+                "text": "whats the weather",
+                "type": "input_text",
+              },
+            ],
+            "role": "user",
+          },
+          {
+            "arguments": "{"location":"sf"}",
+            "call_id": "call_123",
+            "id": "call_123",
+            "name": "weather",
+            "status": "completed",
+            "type": "function_call",
+          },
+          {
+            "call_id": "call_123",
+            "output": "{"temp":72}",
+            "type": "function_call_output",
+          },
+          {
+            "content": "its 72 degrees",
+            "id": undefined,
+            "role": "assistant",
+          },
+        ]
+      `);
+    });
+
+    it('should handle conversation with server-side tool calls and item references', async () => {
+      const result = await convertToXaiResponsesInput({
+        prompt: [
+          {
+            role: 'user',
+            content: [{ type: 'text', text: 'search for ai news' }],
+          },
+          {
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool-call',
+                toolCallId: 'ws_123',
+                toolName: 'web_search',
+                input: {},
+                providerExecuted: true,
+              },
+              {
+                type: 'tool-result',
+                toolCallId: 'ws_123',
+                toolName: 'web_search',
+                output: {
+                  type: 'json',
+                  value: {},
+                },
+              },
+              { type: 'text', text: 'here are the results' },
+            ],
+          },
+        ],
+        store: true,
+      });
+
+      expect(result.input).toMatchInlineSnapshot(`
+        [
+          {
+            "content": [
+              {
+                "text": "search for ai news",
+                "type": "input_text",
+              },
+            ],
+            "role": "user",
+          },
+          {
+            "content": "here are the results",
+            "id": undefined,
+            "role": "assistant",
+          },
+        ]
+      `);
+    });
+  });
+});

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';
+  }
+}