@depup/ai-sdk__openai 3.0.41-depup.0

package/src/responses/openai-responses-provider-metadata.ts

@@ -0,0 +1,62 @@
+import {
+  openaiResponsesChunkSchema,
+  OpenAIResponsesLogprobs,
+} from './openai-responses-api';
+import { InferSchema } from '@ai-sdk/provider-utils';
+
+type OpenaiResponsesChunk = InferSchema<typeof openaiResponsesChunkSchema>;
+
+type ResponsesOutputTextAnnotationProviderMetadata = Extract<
+  OpenaiResponsesChunk,
+  { type: 'response.output_text.annotation.added' }
+>['annotation'];
+
+export type ResponsesProviderMetadata = {
+  responseId: string | null | undefined;
+  logprobs?: Array<OpenAIResponsesLogprobs>;
+  serviceTier?: string;
+};
+
+export type ResponsesReasoningProviderMetadata = {
+  itemId: string;
+  reasoningEncryptedContent?: string | null;
+};
+
+export type OpenaiResponsesReasoningProviderMetadata = {
+  openai: ResponsesReasoningProviderMetadata;
+};
+
+export type OpenaiResponsesProviderMetadata = {
+  openai: ResponsesProviderMetadata;
+};
+
+export type ResponsesTextProviderMetadata = {
+  itemId: string;
+  phase?: 'commentary' | 'final_answer' | null;
+  annotations?: Array<ResponsesOutputTextAnnotationProviderMetadata>;
+};
+
+export type OpenaiResponsesTextProviderMetadata = {
+  openai: ResponsesTextProviderMetadata;
+};
+
+export type ResponsesSourceDocumentProviderMetadata =
+  | {
+      type: 'file_citation';
+      fileId: string;
+      index: number;
+    }
+  | {
+      type: 'container_file_citation';
+      fileId: string;
+      containerId: string;
+    }
+  | {
+      type: 'file_path';
+      fileId: string;
+      index: number;
+    };
+
+export type OpenaiResponsesSourceDocumentProviderMetadata = {
+  openai: ResponsesSourceDocumentProviderMetadata;
+};

package/src/speech/openai-speech-api.ts

@@ -0,0 +1,38 @@
+export type OpenAISpeechAPITypes = {
+  /**
+   * The voice to use when generating the audio.
+   * Supported voices are alloy, ash, ballad, coral, echo, fable, onyx, nova, sage, shimmer, and verse.
+   * @default 'alloy'
+   */
+  voice?:
+    | 'alloy'
+    | 'ash'
+    | 'ballad'
+    | 'coral'
+    | 'echo'
+    | 'fable'
+    | 'onyx'
+    | 'nova'
+    | 'sage'
+    | 'shimmer'
+    | 'verse';
+
+  /**
+   * The speed of the generated audio.
+   * Select a value from 0.25 to 4.0.
+   * @default 1.0
+   */
+  speed?: number;
+
+  /**
+   * The format of the generated audio.
+   * @default 'mp3'
+   */
+  response_format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+
+  /**
+   * Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+   * Does not work with tts-1 or tts-1-hd.
+   */
+  instructions?: string;
+};

package/src/speech/openai-speech-model.ts

@@ -0,0 +1,137 @@
+import { SpeechModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createBinaryResponseHandler,
+  parseProviderOptions,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { OpenAIConfig } from '../openai-config';
+import { openaiFailedResponseHandler } from '../openai-error';
+import { OpenAISpeechAPITypes } from './openai-speech-api';
+import {
+  openaiSpeechModelOptionsSchema,
+  OpenAISpeechModelId,
+} from './openai-speech-options';
+
+interface OpenAISpeechModelConfig extends OpenAIConfig {
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class OpenAISpeechModel implements SpeechModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: OpenAISpeechModelId,
+    private readonly config: OpenAISpeechModelConfig,
+  ) {}
+
+  private async getArgs({
+    text,
+    voice = 'alloy',
+    outputFormat = 'mp3',
+    speed,
+    instructions,
+    language,
+    providerOptions,
+  }: Parameters<SpeechModelV3['doGenerate']>[0]) {
+    const warnings: SharedV3Warning[] = [];
+
+    // Parse provider options
+    const openAIOptions = await parseProviderOptions({
+      provider: 'openai',
+      providerOptions,
+      schema: openaiSpeechModelOptionsSchema,
+    });
+
+    // Create request body
+    const requestBody: Record<string, unknown> = {
+      model: this.modelId,
+      input: text,
+      voice,
+      response_format: 'mp3',
+      speed,
+      instructions,
+    };
+
+    if (outputFormat) {
+      if (['mp3', 'opus', 'aac', 'flac', 'wav', 'pcm'].includes(outputFormat)) {
+        requestBody.response_format = outputFormat;
+      } else {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'outputFormat',
+          details: `Unsupported output format: ${outputFormat}. Using mp3 instead.`,
+        });
+      }
+    }
+
+    // Add provider-specific options
+    if (openAIOptions) {
+      const speechModelOptions: OpenAISpeechAPITypes = {};
+
+      for (const key in speechModelOptions) {
+        const value = speechModelOptions[key as keyof OpenAISpeechAPITypes];
+        if (value !== undefined) {
+          requestBody[key] = value;
+        }
+      }
+    }
+
+    if (language) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'language',
+        details: `OpenAI speech models do not support language selection. Language parameter "${language}" was ignored.`,
+      });
+    }
+
+    return {
+      requestBody,
+      warnings,
+    };
+  }
+
+  async doGenerate(
+    options: Parameters<SpeechModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<SpeechModelV3['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const { requestBody, warnings } = await this.getArgs(options);
+
+    const {
+      value: audio,
+      responseHeaders,
+      rawValue: rawResponse,
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: '/audio/speech',
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: requestBody,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createBinaryResponseHandler(),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      audio,
+      warnings,
+      request: {
+        body: JSON.stringify(requestBody),
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+    };
+  }
+}

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

@@ -0,0 +1,26 @@
+import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type OpenAISpeechModelId =
+  | 'tts-1'
+  | 'tts-1-1106'
+  | 'tts-1-hd'
+  | 'tts-1-hd-1106'
+  | 'gpt-4o-mini-tts'
+  | 'gpt-4o-mini-tts-2025-03-20'
+  | 'gpt-4o-mini-tts-2025-12-15'
+  | (string & {});
+
+// https://platform.openai.com/docs/api-reference/audio/createSpeech
+export const openaiSpeechModelOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      instructions: z.string().nullish(),
+      speed: z.number().min(0.25).max(4.0).default(1.0).nullish(),
+    }),
+  ),
+);
+
+export type OpenAISpeechModelOptions = InferSchema<
+  typeof openaiSpeechModelOptionsSchema
+>;

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/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);