@depup/ai-sdk__openai 3.0.41-depup.0

package/src/tool/web-search-preview.ts

@@ -0,0 +1,141 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const webSearchPreviewArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      searchContextSize: z.enum(['low', 'medium', 'high']).optional(),
+      userLocation: z
+        .object({
+          type: z.literal('approximate'),
+          country: z.string().optional(),
+          city: z.string().optional(),
+          region: z.string().optional(),
+          timezone: z.string().optional(),
+        })
+        .optional(),
+    }),
+  ),
+);
+
+export const webSearchPreviewInputSchema = lazySchema(() =>
+  zodSchema(z.object({})),
+);
+
+const webSearchPreviewOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      action: z
+        .discriminatedUnion('type', [
+          z.object({
+            type: z.literal('search'),
+            query: 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(),
+    }),
+  ),
+);
+
+export const webSearchPreview = createProviderToolFactoryWithOutputSchema<
+  {
+    // Web search preview doesn't take input parameters - it's controlled by the prompt
+  },
+  {
+    /**
+     * An object describing the specific action taken in this web search call.
+     * Includes details on how the model used the web (search, open_page, find_in_page).
+     */
+    action?:
+      | {
+          /**
+           * Action type "search" - Performs a web search query.
+           */
+          type: 'search';
+
+          /**
+           * The search query.
+           */
+          query?: string;
+        }
+      | {
+          /**
+           * Action type "openPage" - Opens a specific URL from search results.
+           */
+          type: 'openPage';
+
+          /**
+           * The URL opened by the model.
+           */
+          url?: string | null;
+        }
+      | {
+          /**
+           * Action type "findInPage": Searches for a pattern within a loaded page.
+           */
+          type: 'findInPage';
+
+          /**
+           * The URL of the page searched for the pattern.
+           */
+          url?: string | null;
+
+          /**
+           * The pattern or text to search for within the page.
+           */
+          pattern?: string | null;
+        };
+  },
+  {
+    /**
+     * Search context size to use for the web search.
+     * - high: Most comprehensive context, highest cost, slower response
+     * - medium: Balanced context, cost, and latency (default)
+     * - low: Least context, lowest cost, fastest response
+     */
+    searchContextSize?: 'low' | 'medium' | 'high';
+
+    /**
+     * User location information to provide geographically relevant search results.
+     */
+    userLocation?: {
+      /**
+       * Type of location (always 'approximate')
+       */
+      type: 'approximate';
+      /**
+       * Two-letter ISO country code (e.g., 'US', 'GB')
+       */
+      country?: string;
+      /**
+       * City name (free text, e.g., 'Minneapolis')
+       */
+      city?: string;
+      /**
+       * Region name (free text, e.g., 'Minnesota')
+       */
+      region?: string;
+      /**
+       * IANA timezone (e.g., 'America/Chicago')
+       */
+      timezone?: string;
+    };
+  }
+>({
+  id: 'openai.web_search_preview',
+  inputSchema: webSearchPreviewInputSchema,
+  outputSchema: webSearchPreviewOutputSchema,
+});

package/src/tool/web-search.ts

@@ -0,0 +1,181 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const webSearchArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      externalWebAccess: z.boolean().optional(),
+      filters: z
+        .object({ allowedDomains: z.array(z.string()).optional() })
+        .optional(),
+      searchContextSize: z.enum(['low', 'medium', 'high']).optional(),
+      userLocation: z
+        .object({
+          type: z.literal('approximate'),
+          country: z.string().optional(),
+          city: z.string().optional(),
+          region: z.string().optional(),
+          timezone: z.string().optional(),
+        })
+        .optional(),
+    }),
+  ),
+);
+
+const webSearchInputSchema = lazySchema(() => zodSchema(z.object({})));
+
+export const webSearchOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      action: z
+        .discriminatedUnion('type', [
+          z.object({
+            type: z.literal('search'),
+            query: 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.discriminatedUnion('type', [
+            z.object({ type: z.literal('url'), url: z.string() }),
+            z.object({ type: z.literal('api'), name: z.string() }),
+          ]),
+        )
+        .optional(),
+    }),
+  ),
+);
+
+export const webSearchToolFactory = createProviderToolFactoryWithOutputSchema<
+  {
+    // Web search doesn't take input parameters - it's controlled by the prompt
+  },
+  {
+    /**
+     * An object describing the specific action taken in this web search call.
+     * Includes details on how the model used the web (search, open_page, find_in_page).
+     */
+    action?:
+      | {
+          /**
+           * Action type "search" - Performs a web search query.
+           */
+          type: 'search';
+
+          /**
+           * The search query.
+           */
+          query?: string;
+        }
+      | {
+          /**
+           * Action type "openPage" - Opens a specific URL from search results.
+           */
+          type: 'openPage';
+
+          /**
+           * The URL opened by the model.
+           */
+          url?: string | null;
+        }
+      | {
+          /**
+           * Action type "findInPage": Searches for a pattern within a loaded page.
+           */
+          type: 'findInPage';
+
+          /**
+           * The URL of the page searched for the pattern.
+           */
+          url?: string | null;
+
+          /**
+           * The pattern or text to search for within the page.
+           */
+          pattern?: string | null;
+        };
+
+    /**
+     * Optional sources cited by the model for the web search call.
+     */
+    sources?: Array<
+      { type: 'url'; url: string } | { type: 'api'; name: string }
+    >;
+  },
+  {
+    /**
+     * Whether to use external web access for fetching live content.
+     * - true: Fetch live web content (default)
+     * - false: Use cached/indexed results
+     */
+    externalWebAccess?: boolean;
+
+    /**
+     * Filters for the search.
+     */
+    filters?: {
+      /**
+       * Allowed domains for the search.
+       * If not provided, all domains are allowed.
+       * Subdomains of the provided domains are allowed as well.
+       */
+      allowedDomains?: string[];
+    };
+
+    /**
+     * Search context size to use for the web search.
+     * - high: Most comprehensive context, highest cost, slower response
+     * - medium: Balanced context, cost, and latency (default)
+     * - low: Least context, lowest cost, fastest response
+     */
+    searchContextSize?: 'low' | 'medium' | 'high';
+
+    /**
+     * User location information to provide geographically relevant search results.
+     */
+    userLocation?: {
+      /**
+       * Type of location (always 'approximate')
+       */
+      type: 'approximate';
+      /**
+       * Two-letter ISO country code (e.g., 'US', 'GB')
+       */
+      country?: string;
+      /**
+       * City name (free text, e.g., 'Minneapolis')
+       */
+      city?: string;
+      /**
+       * Region name (free text, e.g., 'Minnesota')
+       */
+      region?: string;
+      /**
+       * IANA timezone (e.g., 'America/Chicago')
+       */
+      timezone?: string;
+    };
+  }
+>({
+  id: 'openai.web_search',
+  inputSchema: webSearchInputSchema,
+  outputSchema: webSearchOutputSchema,
+});
+
+export const webSearch = (
+  args: Parameters<typeof webSearchToolFactory>[0] = {}, // default
+) => webSearchToolFactory(args);

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

@@ -0,0 +1,37 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const openaiTranscriptionResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      text: z.string(),
+      language: z.string().nullish(),
+      duration: z.number().nullish(),
+      words: z
+        .array(
+          z.object({
+            word: z.string(),
+            start: z.number(),
+            end: z.number(),
+          }),
+        )
+        .nullish(),
+      segments: z
+        .array(
+          z.object({
+            id: z.number(),
+            seek: z.number(),
+            start: z.number(),
+            end: z.number(),
+            text: z.string(),
+            tokens: z.array(z.number()),
+            temperature: z.number(),
+            avg_logprob: z.number(),
+            compression_ratio: z.number(),
+            no_speech_prob: z.number(),
+          }),
+        )
+        .nullish(),
+    }),
+  ),
+);

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

@@ -0,0 +1,232 @@
+import {
+  TranscriptionModelV3,
+  TranscriptionModelV3CallOptions,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  mediaTypeToExtension,
+  parseProviderOptions,
+  postFormDataToApi,
+} from '@ai-sdk/provider-utils';
+import { OpenAIConfig } from '../openai-config';
+import { openaiFailedResponseHandler } from '../openai-error';
+import { openaiTranscriptionResponseSchema } from './openai-transcription-api';
+import {
+  OpenAITranscriptionModelId,
+  openAITranscriptionModelOptions,
+  OpenAITranscriptionModelOptions,
+} from './openai-transcription-options';
+
+export type OpenAITranscriptionCallOptions = Omit<
+  TranscriptionModelV3CallOptions,
+  'providerOptions'
+> & {
+  providerOptions?: {
+    openai?: OpenAITranscriptionModelOptions;
+  };
+};
+
+interface OpenAITranscriptionModelConfig extends OpenAIConfig {
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+// https://platform.openai.com/docs/guides/speech-to-text#supported-languages
+const languageMap = {
+  afrikaans: 'af',
+  arabic: 'ar',
+  armenian: 'hy',
+  azerbaijani: 'az',
+  belarusian: 'be',
+  bosnian: 'bs',
+  bulgarian: 'bg',
+  catalan: 'ca',
+  chinese: 'zh',
+  croatian: 'hr',
+  czech: 'cs',
+  danish: 'da',
+  dutch: 'nl',
+  english: 'en',
+  estonian: 'et',
+  finnish: 'fi',
+  french: 'fr',
+  galician: 'gl',
+  german: 'de',
+  greek: 'el',
+  hebrew: 'he',
+  hindi: 'hi',
+  hungarian: 'hu',
+  icelandic: 'is',
+  indonesian: 'id',
+  italian: 'it',
+  japanese: 'ja',
+  kannada: 'kn',
+  kazakh: 'kk',
+  korean: 'ko',
+  latvian: 'lv',
+  lithuanian: 'lt',
+  macedonian: 'mk',
+  malay: 'ms',
+  marathi: 'mr',
+  maori: 'mi',
+  nepali: 'ne',
+  norwegian: 'no',
+  persian: 'fa',
+  polish: 'pl',
+  portuguese: 'pt',
+  romanian: 'ro',
+  russian: 'ru',
+  serbian: 'sr',
+  slovak: 'sk',
+  slovenian: 'sl',
+  spanish: 'es',
+  swahili: 'sw',
+  swedish: 'sv',
+  tagalog: 'tl',
+  tamil: 'ta',
+  thai: 'th',
+  turkish: 'tr',
+  ukrainian: 'uk',
+  urdu: 'ur',
+  vietnamese: 'vi',
+  welsh: 'cy',
+};
+
+export class OpenAITranscriptionModel implements TranscriptionModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: OpenAITranscriptionModelId,
+    private readonly config: OpenAITranscriptionModelConfig,
+  ) {}
+
+  private async getArgs({
+    audio,
+    mediaType,
+    providerOptions,
+  }: OpenAITranscriptionCallOptions) {
+    const warnings: SharedV3Warning[] = [];
+
+    // Parse provider options
+    const openAIOptions = await parseProviderOptions({
+      provider: 'openai',
+      providerOptions,
+      schema: openAITranscriptionModelOptions,
+    });
+
+    // Create form data with base fields
+    const formData = new FormData();
+    const blob =
+      audio instanceof Uint8Array
+        ? new Blob([audio])
+        : new Blob([convertBase64ToUint8Array(audio)]);
+
+    formData.append('model', this.modelId);
+    const fileExtension = mediaTypeToExtension(mediaType);
+    formData.append(
+      'file',
+      new File([blob], 'audio', { type: mediaType }),
+      `audio.${fileExtension}`,
+    );
+
+    // Add provider-specific options
+    if (openAIOptions) {
+      const transcriptionModelOptions = {
+        include: openAIOptions.include,
+        language: openAIOptions.language,
+        prompt: openAIOptions.prompt,
+        // https://platform.openai.com/docs/api-reference/audio/createTranscription#audio_createtranscription-response_format
+        // prefer verbose_json to get segments for models that support it
+        response_format: [
+          'gpt-4o-transcribe',
+          'gpt-4o-mini-transcribe',
+        ].includes(this.modelId)
+          ? 'json'
+          : 'verbose_json',
+        temperature: openAIOptions.temperature,
+        timestamp_granularities: openAIOptions.timestampGranularities,
+      };
+
+      for (const [key, value] of Object.entries(transcriptionModelOptions)) {
+        if (value != null) {
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              formData.append(`${key}[]`, String(item));
+            }
+          } else {
+            formData.append(key, String(value));
+          }
+        }
+      }
+    }
+
+    return {
+      formData,
+      warnings,
+    };
+  }
+
+  async doGenerate(
+    options: OpenAITranscriptionCallOptions,
+  ): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const { formData, warnings } = await this.getArgs(options);
+
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse,
+    } = await postFormDataToApi({
+      url: this.config.url({
+        path: '/audio/transcriptions',
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      formData,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiTranscriptionResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    const language =
+      response.language != null && response.language in languageMap
+        ? languageMap[response.language as keyof typeof languageMap]
+        : undefined;
+
+    return {
+      text: response.text,
+      segments:
+        response.segments?.map(segment => ({
+          text: segment.text,
+          startSecond: segment.start,
+          endSecond: segment.end,
+        })) ??
+        response.words?.map(word => ({
+          text: word.word,
+          startSecond: word.start,
+          endSecond: word.end,
+        })) ??
+        [],
+      language,
+      durationInSeconds: response.duration ?? undefined,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+    };
+  }
+}

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

@@ -0,0 +1,53 @@
+import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type OpenAITranscriptionModelId =
+  | 'whisper-1'
+  | 'gpt-4o-mini-transcribe'
+  | 'gpt-4o-mini-transcribe-2025-03-20'
+  | 'gpt-4o-mini-transcribe-2025-12-15'
+  | 'gpt-4o-transcribe'
+  | 'gpt-4o-transcribe-diarize'
+  | (string & {});
+
+// https://platform.openai.com/docs/api-reference/audio/createTranscription
+export const openAITranscriptionModelOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * Additional information to include in the transcription response.
+       */
+
+      include: z.array(z.string()).optional(),
+
+      /**
+       * The language of the input audio in ISO-639-1 format.
+       */
+      language: z.string().optional(),
+
+      /**
+       * An optional text to guide the model's style or continue a previous audio segment.
+       */
+      prompt: z.string().optional(),
+
+      /**
+       * The sampling temperature, between 0 and 1.
+       * @default 0
+       */
+      temperature: z.number().min(0).max(1).default(0).optional(),
+
+      /**
+       * The timestamp granularities to populate for this transcription.
+       * @default ['segment']
+       */
+      timestampGranularities: z
+        .array(z.enum(['word', 'segment']))
+        .default(['segment'])
+        .optional(),
+    }),
+  ),
+);
+
+export type OpenAITranscriptionModelOptions = InferSchema<
+  typeof openAITranscriptionModelOptions
+>;

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';