@ai-sdk/openai 3.0.44 → 3.0.46

package/src/responses/openai-responses-options.ts

@@ -37,11 +37,12 @@ export const openaiResponsesReasoningModelIds = [
   'gpt-5.2-chat-latest',
   'gpt-5.2-pro',
   'gpt-5.2-codex',
+  'gpt-5.3-chat-latest',
+  'gpt-5.3-codex',
   'gpt-5.4',
   'gpt-5.4-2026-03-05',
   'gpt-5.4-pro',
   'gpt-5.4-pro-2026-03-05',
-  'gpt-5.3-codex',
 ] as const;
 
 export const openaiResponsesModelIds = [
@@ -98,11 +99,12 @@ export type OpenAIResponsesModelId =
   | 'gpt-5.2-pro'
   | 'gpt-5.2-pro-2025-12-11'
   | 'gpt-5.2-codex'
+  | 'gpt-5.3-chat-latest'
+  | 'gpt-5.3-codex'
   | 'gpt-5.4'
   | 'gpt-5.4-2026-03-05'
   | 'gpt-5.4-pro'
   | 'gpt-5.4-pro-2026-03-05'
-  | 'gpt-5.3-codex'
   | 'gpt-5-2025-08-07'
   | 'gpt-5-chat-latest'
   | 'gpt-5-codex'

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

@@ -10,6 +10,7 @@ import { imageGenerationArgsSchema } from '../tool/image-generation';
 import { customArgsSchema } from '../tool/custom';
 import { mcpArgsSchema } from '../tool/mcp';
 import { shellArgsSchema } from '../tool/shell';
+import { toolSearchArgsSchema } from '../tool/tool-search';
 import { webSearchArgsSchema } from '../tool/web-search';
 import { webSearchPreviewArgsSchema } from '../tool/web-search-preview';
 import { OpenAIResponsesTool } from './openai-responses-api';
@@ -56,15 +57,22 @@ export async function prepareResponsesTools({
 
   for (const tool of tools) {
     switch (tool.type) {
-      case 'function':
+      case 'function': {
+        const openaiOptions = tool.providerOptions?.openai as
+          | { deferLoading?: boolean }
+          | undefined;
+        const deferLoading = openaiOptions?.deferLoading;
+
         openaiTools.push({
           type: 'function',
           name: tool.name,
           description: tool.description,
           parameters: tool.inputSchema,
           ...(tool.strict != null ? { strict: tool.strict } : {}),
+          ...(deferLoading != null ? { defer_loading: deferLoading } : {}),
         });
         break;
+      }
       case 'provider': {
         switch (tool.id) {
           case 'openai.file_search': {
@@ -248,6 +256,23 @@ export async function prepareResponsesTools({
             resolvedCustomProviderToolNames.add(args.name);
             break;
           }
+          case 'openai.tool_search': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: toolSearchArgsSchema,
+            });
+            openaiTools.push({
+              type: 'tool_search',
+              ...(args.execution != null ? { execution: args.execution } : {}),
+              ...(args.description != null
+                ? { description: args.description }
+                : {}),
+              ...(args.parameters != null
+                ? { parameters: args.parameters }
+                : {}),
+            });
+            break;
+          }
         }
         break;
       }

package/src/tool/tool-search.ts

@@ -0,0 +1,98 @@
+import { JSONObject } from '@ai-sdk/provider';
+import {
+  createProviderToolFactoryWithOutputSchema,
+  FlexibleSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const toolSearchArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      execution: z.enum(['server', 'client']).optional(),
+      description: z.string().optional(),
+      parameters: z.record(z.string(), z.unknown()).optional(),
+    }),
+  ),
+);
+
+export const toolSearchInputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      arguments: z.unknown().optional(),
+      call_id: z.string().nullish(),
+    }),
+  ),
+);
+
+export const toolSearchOutputSchema: FlexibleSchema<{
+  tools: Array<JSONObject>;
+}> = lazySchema(() =>
+  zodSchema(
+    z.object({
+      tools: z.array(z.record(z.string(), z.unknown())),
+    }),
+  ),
+) as FlexibleSchema<{ tools: Array<JSONObject> }>;
+
+const toolSearchToolFactory = createProviderToolFactoryWithOutputSchema<
+  {
+    /**
+     * The arguments from the tool_search_call.
+     * This is preserved for multi-turn conversation reconstruction.
+     */
+    arguments?: unknown;
+
+    /**
+     * The call ID from the tool_search_call.
+     * Present for client-executed tool search; null for hosted.
+     */
+    call_id?: string | null;
+  },
+  {
+    /**
+     * The tools that were loaded by the tool search.
+     * These are the deferred tools that the model requested to load.
+     * Each tool is represented as a JSON object with properties depending on its type.
+     *
+     * Common properties include:
+     * - `type`: The type of the tool (e.g., 'function', 'web_search', etc.)
+     * - `name`: The name of the tool (for function tools)
+     * - `description`: A description of the tool
+     * - `deferLoading`: Whether this tool was deferred (had defer_loading: true)
+     * - `parameters`: The JSON Schema for the function parameters (for function tools)
+     * - `strict`: Whether to enable strict schema adherence (for function tools)
+     */
+    tools: Array<JSONObject>;
+  },
+  {
+    /**
+     * Whether the tool search is executed by the server (hosted) or client.
+     * - `'server'` (default): OpenAI performs the search across deferred tools.
+     * - `'client'`: The model emits a `tool_search_call` and your `execute`
+     *   function performs the lookup, returning the tools to load.
+     */
+    execution?: 'server' | 'client';
+
+    /**
+     * A description of the tool search capability.
+     * Only used for client-executed tool search.
+     */
+    description?: string;
+
+    /**
+     * JSON Schema for the search arguments your application expects.
+     * Only used for client-executed tool search.
+     */
+    parameters?: Record<string, unknown>;
+  }
+>({
+  id: 'openai.tool_search',
+  inputSchema: toolSearchInputSchema,
+  outputSchema: toolSearchOutputSchema,
+});
+
+export const toolSearch = (
+  args: Parameters<typeof toolSearchToolFactory>[0] = {},
+) => toolSearchToolFactory(args);