@ai-sdk/openai 3.0.14 → 3.0.15

package/src/tool/apply-patch.ts

@@ -0,0 +1,141 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+/**
+ * Schema for the apply_patch input - what the model sends.
+ *
+ * Refer the official spec here: https://platform.openai.com/docs/api-reference/responses/create#responses_create-input-input_item_list-item-apply_patch_tool_call
+ *
+ */
+export const applyPatchInputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      callId: z.string(),
+      operation: z.discriminatedUnion('type', [
+        z.object({
+          type: z.literal('create_file'),
+          path: z.string(),
+          diff: z.string(),
+        }),
+        z.object({
+          type: z.literal('delete_file'),
+          path: z.string(),
+        }),
+        z.object({
+          type: z.literal('update_file'),
+          path: z.string(),
+          diff: z.string(),
+        }),
+      ]),
+    }),
+  ),
+);
+
+/**
+ * Schema for the apply_patch output - what we send back.
+ */
+export const applyPatchOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      status: z.enum(['completed', 'failed']),
+      output: z.string().optional(),
+    }),
+  ),
+);
+
+/**
+ * Schema for tool arguments (configuration options).
+ * The apply_patch tool doesn't require any configuration options.
+ */
+export const applyPatchArgsSchema = lazySchema(() => zodSchema(z.object({})));
+
+/**
+ * Type definitions for the apply_patch operations.
+ */
+export type ApplyPatchOperation =
+  | {
+      type: 'create_file';
+      /**
+       * Path of the file to create relative to the workspace root.
+       */
+      path: string;
+      /**
+       * Unified diff content to apply when creating the file.
+       */
+      diff: string;
+    }
+  | {
+      type: 'delete_file';
+      /**
+       * Path of the file to delete relative to the workspace root.
+       */
+      path: string;
+    }
+  | {
+      type: 'update_file';
+      /**
+       * Path of the file to update relative to the workspace root.
+       */
+      path: string;
+      /**
+       * Unified diff content to apply to the existing file.
+       */
+      diff: string;
+    };
+
+/**
+ * The apply_patch tool lets GPT-5.1 create, update, and delete files in your
+ * codebase using structured diffs. Instead of just suggesting edits, the model
+ * emits patch operations that your application applies and then reports back on,
+ * enabling iterative, multi-step code editing workflows.
+ *
+ * The tool factory creates a provider-defined tool that:
+ * - Receives patch operations from the model (create_file, update_file, delete_file)
+ * - Returns the status of applying those patches (completed or failed)
+ *
+ */
+export const applyPatchToolFactory = createProviderToolFactoryWithOutputSchema<
+  {
+    /**
+     * The unique ID of the apply patch tool call generated by the model.
+     */
+    callId: string;
+
+    /**
+     * The specific create, delete, or update instruction for the apply_patch tool call.
+     */
+    operation: ApplyPatchOperation;
+  },
+  {
+    /**
+     * The status of the apply patch tool call output.
+     * - 'completed': The patch was applied successfully.
+     * - 'failed': The patch failed to apply.
+     */
+    status: 'completed' | 'failed';
+
+    /**
+     * Optional human-readable log text from the apply patch tool
+     * (e.g., patch results or errors).
+     */
+    output?: string;
+  },
+  // No configuration options for apply_patch
+  {}
+>({
+  id: 'openai.apply_patch',
+  inputSchema: applyPatchInputSchema,
+  outputSchema: applyPatchOutputSchema,
+});
+
+/**
+ * The apply_patch tool lets GPT-5.1 create, update, and delete files in your
+ * codebase using structured diffs. Instead of just suggesting edits, the model
+ * emits patch operations that your application applies and then reports back on,
+ * enabling iterative, multi-step code editing workflows.
+ */
+export const applyPatch = applyPatchToolFactory;

package/src/tool/code-interpreter.ts

@@ -0,0 +1,104 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const codeInterpreterInputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      code: z.string().nullish(),
+      containerId: z.string(),
+    }),
+  ),
+);
+
+export const codeInterpreterOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      outputs: z
+        .array(
+          z.discriminatedUnion('type', [
+            z.object({ type: z.literal('logs'), logs: z.string() }),
+            z.object({ type: z.literal('image'), url: z.string() }),
+          ]),
+        )
+        .nullish(),
+    }),
+  ),
+);
+
+export const codeInterpreterArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      container: z
+        .union([
+          z.string(),
+          z.object({
+            fileIds: z.array(z.string()).optional(),
+          }),
+        ])
+        .optional(),
+    }),
+  ),
+);
+
+type CodeInterpreterArgs = {
+  /**
+   * The code interpreter container.
+   * Can be a container ID
+   * or an object that specifies uploaded file IDs to make available to your code.
+   */
+  container?: string | { fileIds?: string[] };
+};
+
+export const codeInterpreterToolFactory =
+  createProviderToolFactoryWithOutputSchema<
+    {
+      /**
+       * The code to run, or null if not available.
+       */
+      code?: string | null;
+
+      /**
+       * The ID of the container used to run the code.
+       */
+      containerId: string;
+    },
+    {
+      /**
+       * The outputs generated by the code interpreter, such as logs or images.
+       * Can be null if no outputs are available.
+       */
+      outputs?: Array<
+        | {
+            type: 'logs';
+
+            /**
+             * The logs output from the code interpreter.
+             */
+            logs: string;
+          }
+        | {
+            type: 'image';
+
+            /**
+             * The URL of the image output from the code interpreter.
+             */
+            url: string;
+          }
+      > | null;
+    },
+    CodeInterpreterArgs
+  >({
+    id: 'openai.code_interpreter',
+    inputSchema: codeInterpreterInputSchema,
+    outputSchema: codeInterpreterOutputSchema,
+  });
+
+export const codeInterpreter = (
+  args: CodeInterpreterArgs = {}, // default
+) => {
+  return codeInterpreterToolFactory(args);
+};

package/src/tool/file-search.ts

@@ -0,0 +1,145 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import {
+  OpenAIResponsesFileSearchToolComparisonFilter,
+  OpenAIResponsesFileSearchToolCompoundFilter,
+} from '../responses/openai-responses-api';
+
+const comparisonFilterSchema = z.object({
+  key: z.string(),
+  type: z.enum(['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin']),
+  value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]),
+});
+
+const compoundFilterSchema: z.ZodType<any> = z.object({
+  type: z.enum(['and', 'or']),
+  filters: z.array(
+    z.union([comparisonFilterSchema, z.lazy(() => compoundFilterSchema)]),
+  ),
+});
+
+export const fileSearchArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      vectorStoreIds: z.array(z.string()),
+      maxNumResults: z.number().optional(),
+      ranking: z
+        .object({
+          ranker: z.string().optional(),
+          scoreThreshold: z.number().optional(),
+        })
+        .optional(),
+      filters: z
+        .union([comparisonFilterSchema, compoundFilterSchema])
+        .optional(),
+    }),
+  ),
+);
+
+export const fileSearchOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      queries: z.array(z.string()),
+      results: z
+        .array(
+          z.object({
+            attributes: z.record(z.string(), z.unknown()),
+            fileId: z.string(),
+            filename: z.string(),
+            score: z.number(),
+            text: z.string(),
+          }),
+        )
+        .nullable(),
+    }),
+  ),
+);
+
+export const fileSearch = createProviderToolFactoryWithOutputSchema<
+  {},
+  {
+    /**
+     * The search query to execute.
+     */
+    queries: string[];
+
+    /**
+     * The results of the file search tool call.
+     */
+    results:
+      | null
+      | {
+          /**
+           * Set of 16 key-value pairs that can be attached to an object.
+           * This can be useful for storing additional information about the object
+           * in a structured format, and querying for objects via API or the dashboard.
+           * Keys are strings with a maximum length of 64 characters.
+           * Values are strings with a maximum length of 512 characters, booleans, or numbers.
+           */
+          attributes: Record<string, unknown>;
+
+          /**
+           * The unique ID of the file.
+           */
+          fileId: string;
+
+          /**
+           * The name of the file.
+           */
+          filename: string;
+
+          /**
+           * The relevance score of the file - a value between 0 and 1.
+           */
+          score: number;
+
+          /**
+           * The text that was retrieved from the file.
+           */
+          text: string;
+        }[];
+  },
+  {
+    /**
+     * List of vector store IDs to search through.
+     */
+    vectorStoreIds: string[];
+
+    /**
+     * Maximum number of search results to return. Defaults to 10.
+     */
+    maxNumResults?: number;
+
+    /**
+     * Ranking options for the search.
+     */
+    ranking?: {
+      /**
+       * The ranker to use for the file search.
+       */
+      ranker?: string;
+
+      /**
+       * The score threshold for the file search, a number between 0 and 1.
+       * Numbers closer to 1 will attempt to return only the most relevant results,
+       * but may return fewer results.
+       */
+      scoreThreshold?: number;
+    };
+
+    /**
+     * A filter to apply.
+     */
+    filters?:
+      | OpenAIResponsesFileSearchToolComparisonFilter
+      | OpenAIResponsesFileSearchToolCompoundFilter;
+  }
+>({
+  id: 'openai.file_search',
+  inputSchema: z.object({}),
+  outputSchema: fileSearchOutputSchema,
+});

package/src/tool/image-generation.ts

@@ -0,0 +1,126 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const imageGenerationArgsSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        background: z.enum(['auto', 'opaque', 'transparent']).optional(),
+        inputFidelity: z.enum(['low', 'high']).optional(),
+        inputImageMask: z
+          .object({
+            fileId: z.string().optional(),
+            imageUrl: z.string().optional(),
+          })
+          .optional(),
+        model: z.string().optional(),
+        moderation: z.enum(['auto']).optional(),
+        outputCompression: z.number().int().min(0).max(100).optional(),
+        outputFormat: z.enum(['png', 'jpeg', 'webp']).optional(),
+        partialImages: z.number().int().min(0).max(3).optional(),
+        quality: z.enum(['auto', 'low', 'medium', 'high']).optional(),
+        size: z
+          .enum(['1024x1024', '1024x1536', '1536x1024', 'auto'])
+          .optional(),
+      })
+      .strict(),
+  ),
+);
+
+const imageGenerationInputSchema = lazySchema(() => zodSchema(z.object({})));
+
+export const imageGenerationOutputSchema = lazySchema(() =>
+  zodSchema(z.object({ result: z.string() })),
+);
+
+type ImageGenerationArgs = {
+  /**
+   * Background type for the generated image. Default is 'auto'.
+   */
+  background?: 'auto' | 'opaque' | 'transparent';
+
+  /**
+   * Input fidelity for the generated image. Default is 'low'.
+   */
+  inputFidelity?: 'low' | 'high';
+
+  /**
+   * Optional mask for inpainting.
+   * Contains image_url (string, optional) and file_id (string, optional).
+   */
+  inputImageMask?: {
+    /**
+     * File ID for the mask image.
+     */
+    fileId?: string;
+
+    /**
+     * Base64-encoded mask image.
+     */
+    imageUrl?: string;
+  };
+
+  /**
+   * The image generation model to use. Default: gpt-image-1.
+   */
+  model?: string;
+
+  /**
+   * Moderation level for the generated image. Default: auto.
+   */
+  moderation?: 'auto';
+
+  /**
+   * Compression level for the output image. Default: 100.
+   */
+  outputCompression?: number;
+
+  /**
+   * The output format of the generated image. One of png, webp, or jpeg.
+   * Default: png
+   */
+  outputFormat?: 'png' | 'jpeg' | 'webp';
+
+  /**
+   * Number of partial images to generate in streaming mode, from 0 (default value) to 3.
+   */
+  partialImages?: number;
+
+  /**
+   * The quality of the generated image.
+   * One of low, medium, high, or auto. Default: auto.
+   */
+  quality?: 'auto' | 'low' | 'medium' | 'high';
+
+  /**
+   * The size of the generated image.
+   * One of 1024x1024, 1024x1536, 1536x1024, or auto.
+   * Default: auto.
+   */
+  size?: 'auto' | '1024x1024' | '1024x1536' | '1536x1024';
+};
+
+const imageGenerationToolFactory = createProviderToolFactoryWithOutputSchema<
+  {},
+  {
+    /**
+     * The generated image encoded in base64.
+     */
+    result: string;
+  },
+  ImageGenerationArgs
+>({
+  id: 'openai.image_generation',
+  inputSchema: imageGenerationInputSchema,
+  outputSchema: imageGenerationOutputSchema,
+});
+
+export const imageGeneration = (
+  args: ImageGenerationArgs = {}, // default
+) => {
+  return imageGenerationToolFactory(args);
+};

package/src/tool/local-shell.test-d.ts

@@ -0,0 +1,20 @@
+import { InferSchema, Tool } from '@ai-sdk/provider-utils';
+import { describe, expectTypeOf, it } from 'vitest';
+import {
+  localShell,
+  localShellInputSchema,
+  localShellOutputSchema,
+} from './local-shell';
+
+describe('local-shell tool type', () => {
+  it('should have Tool type', () => {
+    const localShellTool = localShell({});
+
+    expectTypeOf(localShellTool).toEqualTypeOf<
+      Tool<
+        InferSchema<typeof localShellInputSchema>,
+        InferSchema<typeof localShellOutputSchema>
+      >
+    >();
+  });
+});

package/src/tool/local-shell.ts

@@ -0,0 +1,72 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const localShellInputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      action: z.object({
+        type: z.literal('exec'),
+        command: z.array(z.string()),
+        timeoutMs: z.number().optional(),
+        user: z.string().optional(),
+        workingDirectory: z.string().optional(),
+        env: z.record(z.string(), z.string()).optional(),
+      }),
+    }),
+  ),
+);
+
+export const localShellOutputSchema = lazySchema(() =>
+  zodSchema(z.object({ output: z.string() })),
+);
+
+export const localShell = createProviderToolFactoryWithOutputSchema<
+  {
+    /**
+     * Execute a shell command on the server.
+     */
+    action: {
+      type: 'exec';
+
+      /**
+       * The command to run.
+       */
+      command: string[];
+
+      /**
+       * Optional timeout in milliseconds for the command.
+       */
+      timeoutMs?: number;
+
+      /**
+       * Optional user to run the command as.
+       */
+      user?: string;
+
+      /**
+       * Optional working directory to run the command in.
+       */
+      workingDirectory?: string;
+
+      /**
+       * Environment variables to set for the command.
+       */
+      env?: Record<string, string>;
+    };
+  },
+  {
+    /**
+     * The output of local shell tool call.
+     */
+    output: string;
+  },
+  {}
+>({
+  id: 'openai.local_shell',
+  inputSchema: localShellInputSchema,
+  outputSchema: localShellOutputSchema,
+});