@ai-sdk/xai 0.0.0-70e0935a-20260114150030 → 0.0.0-98261322-20260122142521

package/src/responses/xai-responses-prepare-tools.ts

@@ -0,0 +1,226 @@
+import {
+  LanguageModelV3CallOptions,
+  SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { validateTypes } from '@ai-sdk/provider-utils';
+import { webSearchArgsSchema } from '../tool/web-search';
+import { xSearchArgsSchema } from '../tool/x-search';
+import { XaiResponsesTool } from './xai-responses-api';
+
+type XaiResponsesToolChoice =
+  | 'auto'
+  | 'none'
+  | 'required'
+  | { type: 'web_search' }
+  | { type: 'x_search' }
+  | { type: 'code_interpreter' }
+  | { type: 'view_image' }
+  | { type: 'view_x_video' }
+  | { type: 'file_search' }
+  | { type: 'mcp' }
+  | { type: 'function'; name: string };
+
+export async function prepareResponsesTools({
+  tools,
+  toolChoice,
+}: {
+  tools: LanguageModelV3CallOptions['tools'];
+  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+}): Promise<{
+  tools: Array<XaiResponsesTool> | undefined;
+  toolChoice: XaiResponsesToolChoice | undefined;
+  toolWarnings: SharedV3Warning[];
+}> {
+  const normalizedTools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV3Warning[] = [];
+
+  if (normalizedTools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+
+  const xaiTools: Array<XaiResponsesTool> = [];
+  const toolByName = new Map<string, (typeof normalizedTools)[number]>();
+
+  for (const tool of normalizedTools) {
+    toolByName.set(tool.name, tool);
+
+    if (tool.type === 'provider') {
+      switch (tool.id) {
+        case 'xai.web_search': {
+          const args = await validateTypes({
+            value: tool.args,
+            schema: webSearchArgsSchema,
+          });
+
+          xaiTools.push({
+            type: 'web_search',
+            allowed_domains: args.allowedDomains,
+            excluded_domains: args.excludedDomains,
+            enable_image_understanding: args.enableImageUnderstanding,
+          });
+          break;
+        }
+
+        case 'xai.x_search': {
+          const args = await validateTypes({
+            value: tool.args,
+            schema: xSearchArgsSchema,
+          });
+
+          xaiTools.push({
+            type: 'x_search',
+            allowed_x_handles: args.allowedXHandles,
+            excluded_x_handles: args.excludedXHandles,
+            from_date: args.fromDate,
+            to_date: args.toDate,
+            enable_image_understanding: args.enableImageUnderstanding,
+            enable_video_understanding: args.enableVideoUnderstanding,
+          });
+          break;
+        }
+
+        case 'xai.code_execution': {
+          xaiTools.push({
+            type: 'code_interpreter',
+          });
+          break;
+        }
+
+        case 'xai.view_image': {
+          xaiTools.push({
+            type: 'view_image',
+          });
+          break;
+        }
+
+        case 'xai.view_x_video': {
+          xaiTools.push({
+            type: 'view_x_video',
+          });
+          break;
+        }
+
+        case 'xai.file_search': {
+          xaiTools.push({
+            type: 'file_search',
+          });
+          break;
+        }
+
+        case 'xai.mcp': {
+          xaiTools.push({
+            type: 'mcp',
+          });
+          break;
+        }
+
+        default: {
+          toolWarnings.push({
+            type: 'unsupported',
+            feature: `provider-defined tool ${tool.name}`,
+          });
+          break;
+        }
+      }
+    } else {
+      xaiTools.push({
+        type: 'function',
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema,
+      });
+    }
+  }
+
+  if (toolChoice == null) {
+    return { tools: xaiTools, toolChoice: undefined, toolWarnings };
+  }
+
+  const type = toolChoice.type;
+
+  switch (type) {
+    case 'auto':
+    case 'none':
+      return { tools: xaiTools, toolChoice: type, toolWarnings };
+    case 'required':
+      return { tools: xaiTools, toolChoice: 'required', toolWarnings };
+    case 'tool': {
+      const selectedTool = toolByName.get(toolChoice.toolName);
+
+      if (selectedTool == null) {
+        return {
+          tools: xaiTools,
+          toolChoice: undefined,
+          toolWarnings,
+        };
+      }
+
+      if (selectedTool.type === 'provider') {
+        switch (selectedTool.id) {
+          case 'xai.web_search':
+            return {
+              tools: xaiTools,
+              toolChoice: { type: 'web_search' },
+              toolWarnings,
+            };
+          case 'xai.x_search':
+            return {
+              tools: xaiTools,
+              toolChoice: { type: 'x_search' },
+              toolWarnings,
+            };
+          case 'xai.code_execution':
+            return {
+              tools: xaiTools,
+              toolChoice: { type: 'code_interpreter' },
+              toolWarnings,
+            };
+          case 'xai.view_image':
+            return {
+              tools: xaiTools,
+              toolChoice: { type: 'view_image' },
+              toolWarnings,
+            };
+          case 'xai.view_x_video':
+            return {
+              tools: xaiTools,
+              toolChoice: { type: 'view_x_video' },
+              toolWarnings,
+            };
+          case 'xai.file_search':
+            return {
+              tools: xaiTools,
+              toolChoice: { type: 'file_search' },
+              toolWarnings,
+            };
+          case 'xai.mcp':
+            return {
+              tools: xaiTools,
+              toolChoice: { type: 'mcp' },
+              toolWarnings,
+            };
+          default:
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${selectedTool.name}`,
+            });
+            return { tools: xaiTools, toolChoice: undefined, toolWarnings };
+        }
+      }
+
+      return {
+        tools: xaiTools,
+        toolChoice: { type: 'function', name: selectedTool.name },
+        toolWarnings,
+      };
+    }
+    default: {
+      const _exhaustiveCheck: never = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      });
+    }
+  }
+}

package/src/tool/code-execution.ts

@@ -0,0 +1,17 @@
+import { createProviderToolFactoryWithOutputSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+const codeExecutionOutputSchema = z.object({
+  output: z.string().describe('the output of the code execution'),
+  error: z.string().optional().describe('any error that occurred'),
+});
+
+const codeExecutionToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: 'xai.code_execution',
+  inputSchema: z.object({}).describe('no input parameters'),
+  outputSchema: codeExecutionOutputSchema,
+});
+
+export const codeExecution = (
+  args: Parameters<typeof codeExecutionToolFactory>[0] = {},
+) => codeExecutionToolFactory(args);

package/src/tool/index.ts

@@ -0,0 +1,15 @@
+import { codeExecution } from './code-execution';
+import { viewImage } from './view-image';
+import { viewXVideo } from './view-x-video';
+import { webSearch } from './web-search';
+import { xSearch } from './x-search';
+
+export { codeExecution, viewImage, viewXVideo, webSearch, xSearch };
+
+export const xaiTools = {
+  codeExecution,
+  viewImage,
+  viewXVideo,
+  webSearch,
+  xSearch,
+};

package/src/tool/view-image.ts

@@ -0,0 +1,20 @@
+import { createProviderToolFactoryWithOutputSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+const viewImageOutputSchema = z.object({
+  description: z.string().describe('description of the image'),
+  objects: z
+    .array(z.string())
+    .optional()
+    .describe('objects detected in the image'),
+});
+
+const viewImageToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: 'xai.view_image',
+  inputSchema: z.object({}).describe('no input parameters'),
+  outputSchema: viewImageOutputSchema,
+});
+
+export const viewImage = (
+  args: Parameters<typeof viewImageToolFactory>[0] = {},
+) => viewImageToolFactory(args);

package/src/tool/view-x-video.ts

@@ -0,0 +1,18 @@
+import { createProviderToolFactoryWithOutputSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+const viewXVideoOutputSchema = z.object({
+  transcript: z.string().optional().describe('transcript of the video'),
+  description: z.string().describe('description of the video content'),
+  duration: z.number().optional().describe('duration in seconds'),
+});
+
+const viewXVideoToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: 'xai.view_x_video',
+  inputSchema: z.object({}).describe('no input parameters'),
+  outputSchema: viewXVideoOutputSchema,
+});
+
+export const viewXVideo = (
+  args: Parameters<typeof viewXVideoToolFactory>[0] = {},
+) => viewXVideoToolFactory(args);

package/src/tool/web-search.ts

@@ -0,0 +1,56 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const webSearchArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      allowedDomains: z.array(z.string()).max(5).optional(),
+      excludedDomains: z.array(z.string()).max(5).optional(),
+      enableImageUnderstanding: z.boolean().optional(),
+    }),
+  ),
+);
+
+const webSearchOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      query: z.string(),
+      sources: z.array(
+        z.object({
+          title: z.string(),
+          url: z.string(),
+          snippet: z.string(),
+        }),
+      ),
+    }),
+  ),
+);
+
+const webSearchToolFactory = createProviderToolFactoryWithOutputSchema<
+  Record<string, never>,
+  {
+    query: string;
+    sources: Array<{
+      title: string;
+      url: string;
+      snippet: string;
+    }>;
+  },
+  {
+    allowedDomains?: string[];
+    excludedDomains?: string[];
+    enableImageUnderstanding?: boolean;
+  }
+>({
+  id: 'xai.web_search',
+  inputSchema: lazySchema(() => zodSchema(z.object({}))),
+  outputSchema: webSearchOutputSchema,
+});
+
+export const webSearch = (
+  args: Parameters<typeof webSearchToolFactory>[0] = {},
+) => webSearchToolFactory(args);

package/src/tool/x-search.ts

@@ -0,0 +1,63 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const xSearchArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      allowedXHandles: z.array(z.string()).max(10).optional(),
+      excludedXHandles: z.array(z.string()).max(10).optional(),
+      fromDate: z.string().optional(),
+      toDate: z.string().optional(),
+      enableImageUnderstanding: z.boolean().optional(),
+      enableVideoUnderstanding: z.boolean().optional(),
+    }),
+  ),
+);
+
+const xSearchOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      query: z.string(),
+      posts: z.array(
+        z.object({
+          author: z.string(),
+          text: z.string(),
+          url: z.string(),
+          likes: z.number(),
+        }),
+      ),
+    }),
+  ),
+);
+
+const xSearchToolFactory = createProviderToolFactoryWithOutputSchema<
+  Record<string, never>,
+  {
+    query: string;
+    posts: Array<{
+      author: string;
+      text: string;
+      url: string;
+      likes: number;
+    }>;
+  },
+  {
+    allowedXHandles?: string[];
+    excludedXHandles?: string[];
+    fromDate?: string;
+    toDate?: string;
+    enableImageUnderstanding?: boolean;
+    enableVideoUnderstanding?: boolean;
+  }
+>({
+  id: 'xai.x_search',
+  inputSchema: lazySchema(() => zodSchema(z.object({}))),
+  outputSchema: xSearchOutputSchema,
+});
+
+export const xSearch = (args: Parameters<typeof xSearchToolFactory>[0] = {}) =>
+  xSearchToolFactory(args);

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';