@ai-sdk/openai 3.0.36 → 3.0.38

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

@@ -3,10 +3,11 @@ import {
   SharedV3Warning,
   UnsupportedFunctionalityError,
 } from '@ai-sdk/provider';
-import { validateTypes } from '@ai-sdk/provider-utils';
+import { ToolNameMapping, validateTypes } from '@ai-sdk/provider-utils';
 import { codeInterpreterArgsSchema } from '../tool/code-interpreter';
 import { fileSearchArgsSchema } from '../tool/file-search';
 import { imageGenerationArgsSchema } from '../tool/image-generation';
+import { customArgsSchema } from '../tool/custom';
 import { mcpArgsSchema } from '../tool/mcp';
 import { shellArgsSchema } from '../tool/shell';
 import { webSearchArgsSchema } from '../tool/web-search';
@@ -16,9 +17,13 @@ import { OpenAIResponsesTool } from './openai-responses-api';
 export async function prepareResponsesTools({
   tools,
   toolChoice,
+  toolNameMapping,
+  customProviderToolNames,
 }: {
   tools: LanguageModelV3CallOptions['tools'];
   toolChoice: LanguageModelV3CallOptions['toolChoice'] | undefined;
+  toolNameMapping?: ToolNameMapping;
+  customProviderToolNames?: Set<string>;
 }): Promise<{
   tools?: Array<OpenAIResponsesTool>;
   toolChoice?:
@@ -29,6 +34,7 @@ export async function prepareResponsesTools({
     | { type: 'web_search_preview' }
     | { type: 'web_search' }
     | { type: 'function'; name: string }
+    | { type: 'custom'; name: string }
     | { type: 'code_interpreter' }
     | { type: 'mcp' }
     | { type: 'image_generation' }
@@ -45,6 +51,8 @@ export async function prepareResponsesTools({
   }
 
   const openaiTools: Array<OpenAIResponsesTool> = [];
+  const resolvedCustomProviderToolNames =
+    customProviderToolNames ?? new Set<string>();
 
   for (const tool of tools) {
     switch (tool.type) {
@@ -225,6 +233,21 @@ export async function prepareResponsesTools({
 
             break;
           }
+          case 'openai.custom': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: customArgsSchema,
+            });
+
+            openaiTools.push({
+              type: 'custom',
+              name: args.name,
+              description: args.description,
+              format: args.format,
+            });
+            resolvedCustomProviderToolNames.add(args.name);
+            break;
+          }
         }
         break;
       }
@@ -248,21 +271,28 @@ export async function prepareResponsesTools({
     case 'none':
     case 'required':
       return { tools: openaiTools, toolChoice: type, toolWarnings };
-    case 'tool':
+    case 'tool': {
+      const resolvedToolName =
+        toolNameMapping?.toProviderToolName(toolChoice.toolName) ??
+        toolChoice.toolName;
+
       return {
         tools: openaiTools,
         toolChoice:
-          toolChoice.toolName === 'code_interpreter' ||
-          toolChoice.toolName === 'file_search' ||
-          toolChoice.toolName === 'image_generation' ||
-          toolChoice.toolName === 'web_search_preview' ||
-          toolChoice.toolName === 'web_search' ||
-          toolChoice.toolName === 'mcp' ||
-          toolChoice.toolName === 'apply_patch'
-            ? { type: toolChoice.toolName }
-            : { type: 'function', name: toolChoice.toolName },
+          resolvedToolName === 'code_interpreter' ||
+          resolvedToolName === 'file_search' ||
+          resolvedToolName === 'image_generation' ||
+          resolvedToolName === 'web_search_preview' ||
+          resolvedToolName === 'web_search' ||
+          resolvedToolName === 'mcp' ||
+          resolvedToolName === 'apply_patch'
+            ? { type: resolvedToolName }
+            : resolvedCustomProviderToolNames.has(resolvedToolName)
+              ? { type: 'custom', name: resolvedToolName }
+              : { type: 'function', name: resolvedToolName },
         toolWarnings,
       };
+    }
     default: {
       const _exhaustiveCheck: never = type;
       throw new UnsupportedFunctionalityError({

package/src/tool/custom.ts

@@ -0,0 +1,64 @@
+import {
+  createProviderToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const customArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      name: z.string(),
+      description: z.string().optional(),
+      format: z
+        .union([
+          z.object({
+            type: z.literal('grammar'),
+            syntax: z.enum(['regex', 'lark']),
+            definition: z.string(),
+          }),
+          z.object({
+            type: z.literal('text'),
+          }),
+        ])
+        .optional(),
+    }),
+  ),
+);
+
+const customInputSchema = lazySchema(() => zodSchema(z.string()));
+
+export const customToolFactory = createProviderToolFactory<
+  string,
+  {
+    /**
+     * The name of the custom tool, used to identify it in the API.
+     */
+    name: string;
+
+    /**
+     * An optional description of what the tool does.
+     */
+    description?: string;
+
+    /**
+     * The output format specification for the tool.
+     * Omit for unconstrained text output.
+     */
+    format?:
+      | {
+          type: 'grammar';
+          syntax: 'regex' | 'lark';
+          definition: string;
+        }
+      | {
+          type: 'text';
+        };
+  }
+>({
+  id: 'openai.custom',
+  inputSchema: customInputSchema,
+});
+
+export const customTool = (args: Parameters<typeof customToolFactory>[0]) =>
+  customToolFactory(args);