@ai-sdk/xai 4.0.47 → 4.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/xai",
-  "version": "4.0.47",
+  "version": "4.0.48",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

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

@@ -168,6 +168,31 @@ const toolCallSchema = z.object({
   action: z.any().optional(),
 });
 
+export const webSearchWireSourceSchema = z.object({
+  type: z.literal('url'),
+  url: z.string(),
+});
+
+export const webSearchWireActionSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('search'),
+    query: z.string().nullish(),
+    queries: z.array(z.string()).nullish(),
+    sources: z.array(z.unknown()).nullish(),
+  }),
+  z.object({
+    type: z.literal('open_page'),
+    url: z.string().nullish(),
+    sources: z.array(z.unknown()).nullish(),
+  }),
+  z.object({
+    type: z.literal('find_in_page'),
+    url: z.string().nullish(),
+    pattern: z.string().nullish(),
+    sources: z.array(z.unknown()).nullish(),
+  }),
+]);
+
 const mcpCallSchema = z.object({
   name: z.string().optional(),
   arguments: z.string().optional(),

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

@@ -22,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,
@@ -522,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;
       }
 
@@ -1239,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)
+                        : {},
                   });
                 }
 
@@ -1357,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[];