@depup/ai-sdk__openai 3.0.41-depup.0

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

@@ -0,0 +1,299 @@
+import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+/**
+ * `top_logprobs` request body argument can be set to an integer between
+ * 0 and 20 specifying the number of most likely tokens to return at each
+ * token position, each with an associated log probability.
+ *
+ * @see https://platform.openai.com/docs/api-reference/responses/create#responses_create-top_logprobs
+ */
+export const TOP_LOGPROBS_MAX = 20;
+
+export const openaiResponsesReasoningModelIds = [
+  'o1',
+  'o1-2024-12-17',
+  'o3',
+  'o3-2025-04-16',
+  'o3-mini',
+  'o3-mini-2025-01-31',
+  'o4-mini',
+  'o4-mini-2025-04-16',
+  'gpt-5',
+  'gpt-5-2025-08-07',
+  'gpt-5-codex',
+  'gpt-5-mini',
+  'gpt-5-mini-2025-08-07',
+  'gpt-5-nano',
+  'gpt-5-nano-2025-08-07',
+  'gpt-5-pro',
+  'gpt-5-pro-2025-10-06',
+  'gpt-5.1',
+  'gpt-5.1-chat-latest',
+  'gpt-5.1-codex-mini',
+  'gpt-5.1-codex',
+  'gpt-5.1-codex-max',
+  'gpt-5.2',
+  'gpt-5.2-chat-latest',
+  'gpt-5.2-pro',
+  'gpt-5.2-codex',
+  'gpt-5.3-codex',
+] as const;
+
+export const openaiResponsesModelIds = [
+  'gpt-4.1',
+  'gpt-4.1-2025-04-14',
+  'gpt-4.1-mini',
+  'gpt-4.1-mini-2025-04-14',
+  'gpt-4.1-nano',
+  'gpt-4.1-nano-2025-04-14',
+  'gpt-4o',
+  'gpt-4o-2024-05-13',
+  'gpt-4o-2024-08-06',
+  'gpt-4o-2024-11-20',
+  'gpt-4o-audio-preview',
+  'gpt-4o-audio-preview-2024-12-17',
+  'gpt-4o-search-preview',
+  'gpt-4o-search-preview-2025-03-11',
+  'gpt-4o-mini-search-preview',
+  'gpt-4o-mini-search-preview-2025-03-11',
+  'gpt-4o-mini',
+  'gpt-4o-mini-2024-07-18',
+  'gpt-3.5-turbo-0125',
+  'gpt-3.5-turbo',
+  'gpt-3.5-turbo-1106',
+  'gpt-5-chat-latest',
+  ...openaiResponsesReasoningModelIds,
+] as const;
+
+export type OpenAIResponsesModelId =
+  | 'gpt-3.5-turbo-0125'
+  | 'gpt-3.5-turbo-1106'
+  | 'gpt-3.5-turbo'
+  | 'gpt-4.1-2025-04-14'
+  | 'gpt-4.1-mini-2025-04-14'
+  | 'gpt-4.1-mini'
+  | 'gpt-4.1-nano-2025-04-14'
+  | 'gpt-4.1-nano'
+  | 'gpt-4.1'
+  | 'gpt-4o-2024-05-13'
+  | 'gpt-4o-2024-08-06'
+  | 'gpt-4o-2024-11-20'
+  | 'gpt-4o-mini-2024-07-18'
+  | 'gpt-4o-mini'
+  | 'gpt-4o'
+  | 'gpt-5.1'
+  | 'gpt-5.1-2025-11-13'
+  | 'gpt-5.1-chat-latest'
+  | 'gpt-5.1-codex-mini'
+  | 'gpt-5.1-codex'
+  | 'gpt-5.1-codex-max'
+  | 'gpt-5.2'
+  | 'gpt-5.2-2025-12-11'
+  | 'gpt-5.2-chat-latest'
+  | 'gpt-5.2-pro'
+  | 'gpt-5.2-pro-2025-12-11'
+  | 'gpt-5.2-codex'
+  | 'gpt-5.3-codex'
+  | 'gpt-5-2025-08-07'
+  | 'gpt-5-chat-latest'
+  | 'gpt-5-codex'
+  | 'gpt-5-mini-2025-08-07'
+  | 'gpt-5-mini'
+  | 'gpt-5-nano-2025-08-07'
+  | 'gpt-5-nano'
+  | 'gpt-5-pro-2025-10-06'
+  | 'gpt-5-pro'
+  | 'gpt-5'
+  | 'o1-2024-12-17'
+  | 'o1'
+  | 'o3-2025-04-16'
+  | 'o3-mini-2025-01-31'
+  | 'o3-mini'
+  | 'o3'
+  | 'o4-mini'
+  | 'o4-mini-2025-04-16'
+  | (string & {});
+
+// TODO AI SDK 6: use optional here instead of nullish
+export const openaiLanguageModelResponsesOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * The ID of the OpenAI Conversation to continue.
+       * You must create a conversation first via the OpenAI API.
+       * Cannot be used in conjunction with `previousResponseId`.
+       * Defaults to `undefined`.
+       * @see https://platform.openai.com/docs/api-reference/conversations/create
+       */
+      conversation: z.string().nullish(),
+
+      /**
+       * The set of extra fields to include in the response (advanced, usually not needed).
+       * Example values: 'reasoning.encrypted_content', 'file_search_call.results', 'message.output_text.logprobs'.
+       */
+      include: z
+        .array(
+          z.enum([
+            'reasoning.encrypted_content', // handled internally by default, only needed for unknown reasoning models
+            'file_search_call.results',
+            'message.output_text.logprobs',
+          ]),
+        )
+        .nullish(),
+
+      /**
+       * Instructions for the model.
+       * They can be used to change the system or developer message when continuing a conversation using the `previousResponseId` option.
+       * Defaults to `undefined`.
+       */
+      instructions: z.string().nullish(),
+
+      /**
+       * Return the log probabilities of the tokens. Including logprobs will increase
+       * the response size and can slow down response times. However, it can
+       * be useful to better understand how the model is behaving.
+       *
+       * Setting to true will return the log probabilities of the tokens that
+       * were generated.
+       *
+       * Setting to a number will return the log probabilities of the top n
+       * tokens that were generated.
+       *
+       * @see https://platform.openai.com/docs/api-reference/responses/create
+       * @see https://cookbook.openai.com/examples/using_logprobs
+       */
+      logprobs: z
+        .union([z.boolean(), z.number().min(1).max(TOP_LOGPROBS_MAX)])
+        .optional(),
+
+      /**
+       * The maximum number of total calls to built-in tools that can be processed in a response.
+       * This maximum number applies across all built-in tool calls, not per individual tool.
+       * Any further attempts to call a tool by the model will be ignored.
+       */
+      maxToolCalls: z.number().nullish(),
+
+      /**
+       * Additional metadata to store with the generation.
+       */
+      metadata: z.any().nullish(),
+
+      /**
+       * Whether to use parallel tool calls. Defaults to `true`.
+       */
+      parallelToolCalls: z.boolean().nullish(),
+
+      /**
+       * The ID of the previous response. You can use it to continue a conversation.
+       * Defaults to `undefined`.
+       */
+      previousResponseId: z.string().nullish(),
+
+      /**
+       * Sets a cache key to tie this prompt to cached prefixes for better caching performance.
+       */
+      promptCacheKey: z.string().nullish(),
+
+      /**
+       * The retention policy for the prompt cache.
+       * - 'in_memory': Default. Standard prompt caching behavior.
+       * - '24h': Extended prompt caching that keeps cached prefixes active for up to 24 hours.
+       *          Currently only available for 5.1 series models.
+       *
+       * @default 'in_memory'
+       */
+      promptCacheRetention: z.enum(['in_memory', '24h']).nullish(),
+
+      /**
+       * Reasoning effort for reasoning models. Defaults to `medium`. If you use
+       * `providerOptions` to set the `reasoningEffort` option, this model setting will be ignored.
+       * Valid values: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh'
+       *
+       * The 'none' type for `reasoningEffort` is only available for OpenAI's GPT-5.1
+       * models. Also, the 'xhigh' type for `reasoningEffort` is only available for
+       * OpenAI's GPT-5.1-Codex-Max model. Setting `reasoningEffort` to 'none' or 'xhigh' with unsupported models will result in
+       * an error.
+       */
+      reasoningEffort: z.string().nullish(),
+
+      /**
+       * Controls reasoning summary output from the model.
+       * Set to "auto" to automatically receive the richest level available,
+       * or "detailed" for comprehensive summaries.
+       */
+      reasoningSummary: z.string().nullish(),
+
+      /**
+       * The identifier for safety monitoring and tracking.
+       */
+      safetyIdentifier: z.string().nullish(),
+
+      /**
+       * Service tier for the request.
+       * Set to 'flex' for 50% cheaper processing at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
+       * Set to 'priority' for faster processing with Enterprise access (available for gpt-4, gpt-5, gpt-5-mini, o3, o4-mini; gpt-5-nano is not supported).
+       *
+       * Defaults to 'auto'.
+       */
+      serviceTier: z.enum(['auto', 'flex', 'priority', 'default']).nullish(),
+
+      /**
+       * Whether to store the generation. Defaults to `true`.
+       */
+      store: z.boolean().nullish(),
+
+      /**
+       * Whether to use strict JSON schema validation.
+       * Defaults to `true`.
+       */
+      strictJsonSchema: z.boolean().nullish(),
+
+      /**
+       * Controls the verbosity of the model's responses. Lower values ('low') will result
+       * in more concise responses, while higher values ('high') will result in more verbose responses.
+       * Valid values: 'low', 'medium', 'high'.
+       */
+      textVerbosity: z.enum(['low', 'medium', 'high']).nullish(),
+
+      /**
+       * Controls output truncation. 'auto' (default) performs truncation automatically;
+       * 'disabled' turns truncation off.
+       */
+      truncation: z.enum(['auto', 'disabled']).nullish(),
+
+      /**
+       * A unique identifier representing your end-user, which can help OpenAI to
+       * monitor and detect abuse.
+       * Defaults to `undefined`.
+       * @see https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids
+       */
+      user: z.string().nullish(),
+
+      /**
+       * Override the system message mode for this model.
+       * - 'system': Use the 'system' role for system messages (default for most models)
+       * - 'developer': Use the 'developer' role for system messages (used by reasoning models)
+       * - 'remove': Remove system messages entirely
+       *
+       * If not specified, the mode is automatically determined based on the model.
+       */
+      systemMessageMode: z.enum(['system', 'developer', 'remove']).optional(),
+
+      /**
+       * Force treating this model as a reasoning model.
+       *
+       * This is useful for "stealth" reasoning models (e.g. via a custom baseURL)
+       * where the model ID is not recognized by the SDK's allowlist.
+       *
+       * When enabled, the SDK applies reasoning-model parameter compatibility rules
+       * and defaults `systemMessageMode` to `developer` unless overridden.
+       */
+      forceReasoning: z.boolean().optional(),
+    }),
+  ),
+);
+
+export type OpenAILanguageModelResponsesOptions = InferSchema<
+  typeof openaiLanguageModelResponsesOptionsSchema
+>;

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

@@ -0,0 +1,408 @@
+import {
+  LanguageModelV3CallOptions,
+  SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+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';
+import { webSearchPreviewArgsSchema } from '../tool/web-search-preview';
+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?:
+    | 'auto'
+    | 'none'
+    | 'required'
+    | { type: 'file_search' }
+    | { type: 'web_search_preview' }
+    | { type: 'web_search' }
+    | { type: 'function'; name: string }
+    | { type: 'custom'; name: string }
+    | { type: 'code_interpreter' }
+    | { type: 'mcp' }
+    | { type: 'image_generation' }
+    | { type: 'apply_patch' };
+  toolWarnings: SharedV3Warning[];
+}> {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV3Warning[] = [];
+
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+
+  const openaiTools: Array<OpenAIResponsesTool> = [];
+  const resolvedCustomProviderToolNames =
+    customProviderToolNames ?? new Set<string>();
+
+  for (const tool of tools) {
+    switch (tool.type) {
+      case 'function':
+        openaiTools.push({
+          type: 'function',
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          ...(tool.strict != null ? { strict: tool.strict } : {}),
+        });
+        break;
+      case 'provider': {
+        switch (tool.id) {
+          case 'openai.file_search': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: fileSearchArgsSchema,
+            });
+
+            openaiTools.push({
+              type: 'file_search',
+              vector_store_ids: args.vectorStoreIds,
+              max_num_results: args.maxNumResults,
+              ranking_options: args.ranking
+                ? {
+                    ranker: args.ranking.ranker,
+                    score_threshold: args.ranking.scoreThreshold,
+                  }
+                : undefined,
+              filters: args.filters,
+            });
+
+            break;
+          }
+          case 'openai.local_shell': {
+            openaiTools.push({
+              type: 'local_shell',
+            });
+            break;
+          }
+          case 'openai.shell': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: shellArgsSchema,
+            });
+
+            openaiTools.push({
+              type: 'shell',
+              ...(args.environment && {
+                environment: mapShellEnvironment(args.environment),
+              }),
+            });
+            break;
+          }
+          case 'openai.apply_patch': {
+            openaiTools.push({
+              type: 'apply_patch',
+            });
+            break;
+          }
+          case 'openai.web_search_preview': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearchPreviewArgsSchema,
+            });
+            openaiTools.push({
+              type: 'web_search_preview',
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation,
+            });
+            break;
+          }
+          case 'openai.web_search': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearchArgsSchema,
+            });
+            openaiTools.push({
+              type: 'web_search',
+              filters:
+                args.filters != null
+                  ? { allowed_domains: args.filters.allowedDomains }
+                  : undefined,
+              external_web_access: args.externalWebAccess,
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation,
+            });
+            break;
+          }
+          case 'openai.code_interpreter': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: codeInterpreterArgsSchema,
+            });
+
+            openaiTools.push({
+              type: 'code_interpreter',
+              container:
+                args.container == null
+                  ? { type: 'auto', file_ids: undefined }
+                  : typeof args.container === 'string'
+                    ? args.container
+                    : { type: 'auto', file_ids: args.container.fileIds },
+            });
+            break;
+          }
+          case 'openai.image_generation': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: imageGenerationArgsSchema,
+            });
+
+            openaiTools.push({
+              type: 'image_generation',
+              background: args.background,
+              input_fidelity: args.inputFidelity,
+              input_image_mask: args.inputImageMask
+                ? {
+                    file_id: args.inputImageMask.fileId,
+                    image_url: args.inputImageMask.imageUrl,
+                  }
+                : undefined,
+              model: args.model,
+              moderation: args.moderation,
+              partial_images: args.partialImages,
+              quality: args.quality,
+              output_compression: args.outputCompression,
+              output_format: args.outputFormat,
+              size: args.size,
+            });
+            break;
+          }
+          case 'openai.mcp': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: mcpArgsSchema,
+            });
+
+            const mapApprovalFilter = (filter: { toolNames?: string[] }) => ({
+              tool_names: filter.toolNames,
+            });
+
+            const requireApproval = args.requireApproval;
+            const requireApprovalParam:
+              | 'always'
+              | 'never'
+              | {
+                  never?: { tool_names?: string[] };
+                }
+              | undefined =
+              requireApproval == null
+                ? undefined
+                : typeof requireApproval === 'string'
+                  ? requireApproval
+                  : requireApproval.never != null
+                    ? { never: mapApprovalFilter(requireApproval.never) }
+                    : undefined;
+
+            openaiTools.push({
+              type: 'mcp',
+              server_label: args.serverLabel,
+              allowed_tools: Array.isArray(args.allowedTools)
+                ? args.allowedTools
+                : args.allowedTools
+                  ? {
+                      read_only: args.allowedTools.readOnly,
+                      tool_names: args.allowedTools.toolNames,
+                    }
+                  : undefined,
+              authorization: args.authorization,
+              connector_id: args.connectorId,
+              headers: args.headers,
+              require_approval: requireApprovalParam ?? 'never',
+              server_description: args.serverDescription,
+              server_url: args.serverUrl,
+            });
+
+            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;
+      }
+      default:
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: `function tool ${tool}`,
+        });
+        break;
+    }
+  }
+
+  if (toolChoice == null) {
+    return { tools: openaiTools, toolChoice: undefined, toolWarnings };
+  }
+
+  const type = toolChoice.type;
+
+  switch (type) {
+    case 'auto':
+    case 'none':
+    case 'required':
+      return { tools: openaiTools, toolChoice: type, toolWarnings };
+    case 'tool': {
+      const resolvedToolName =
+        toolNameMapping?.toProviderToolName(toolChoice.toolName) ??
+        toolChoice.toolName;
+
+      return {
+        tools: openaiTools,
+        toolChoice:
+          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({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      });
+    }
+  }
+}
+
+function mapShellEnvironment(environment: {
+  type?: string;
+  [key: string]: unknown;
+}): NonNullable<
+  Extract<OpenAIResponsesTool, { type: 'shell' }>['environment']
+> {
+  if (environment.type === 'containerReference') {
+    const env = environment as {
+      type: 'containerReference';
+      containerId: string;
+    };
+    return {
+      type: 'container_reference',
+      container_id: env.containerId,
+    };
+  }
+
+  if (environment.type === 'containerAuto') {
+    const env = environment as {
+      type: 'containerAuto';
+      fileIds?: string[];
+      memoryLimit?: '1g' | '4g' | '16g' | '64g';
+      networkPolicy?: {
+        type: string;
+        allowedDomains?: string[];
+        domainSecrets?: Array<{
+          domain: string;
+          name: string;
+          value: string;
+        }>;
+      };
+      skills?: Array<{
+        type: string;
+        skillId?: string;
+        version?: string;
+        name?: string;
+        description?: string;
+        source?: { type: string; mediaType: string; data: string };
+      }>;
+    };
+
+    return {
+      type: 'container_auto',
+      file_ids: env.fileIds,
+      memory_limit: env.memoryLimit,
+      network_policy:
+        env.networkPolicy == null
+          ? undefined
+          : env.networkPolicy.type === 'disabled'
+            ? { type: 'disabled' as const }
+            : {
+                type: 'allowlist' as const,
+                allowed_domains: env.networkPolicy.allowedDomains!,
+                domain_secrets: env.networkPolicy.domainSecrets,
+              },
+      skills: mapShellSkills(env.skills),
+    };
+  }
+
+  const env = environment as {
+    type?: 'local';
+    skills?: Array<{
+      name: string;
+      description: string;
+      path: string;
+    }>;
+  };
+  return {
+    type: 'local',
+    skills: env.skills,
+  };
+}
+
+function mapShellSkills(
+  skills:
+    | Array<{
+        type: string;
+        skillId?: string;
+        version?: string;
+        name?: string;
+        description?: string;
+        source?: { type: string; mediaType: string; data: string };
+      }>
+    | undefined,
+) {
+  return skills?.map(skill =>
+    skill.type === 'skillReference'
+      ? {
+          type: 'skill_reference' as const,
+          skill_id: skill.skillId!,
+          version: skill.version,
+        }
+      : {
+          type: 'inline' as const,
+          name: skill.name!,
+          description: skill.description!,
+          source: {
+            type: 'base64' as const,
+            media_type: skill.source!.mediaType as 'application/zip',
+            data: skill.source!.data,
+          },
+        },
+  );
+}