@ai-sdk/openai 4.0.108 → 4.0.110

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

@@ -333,7 +333,23 @@ export async function prepareResponsesTools({
                   ? { type: 'auto', file_ids: undefined }
                   : typeof args.container === 'string'
                     ? args.container
-                    : { type: 'auto', file_ids: args.container.fileIds },
+                    : {
+                        type: 'auto',
+                        file_ids: args.container.fileIds,
+                        memory_limit: args.container.memoryLimit,
+                        network_policy:
+                          args.container.networkPolicy == null
+                            ? undefined
+                            : args.container.networkPolicy.type === 'disabled'
+                              ? { type: 'disabled' }
+                              : {
+                                  type: 'allowlist',
+                                  allowed_domains:
+                                    args.container.networkPolicy.allowedDomains,
+                                  domain_secrets:
+                                    args.container.networkPolicy.domainSecrets,
+                                },
+                      },
             });
             break;
           }
@@ -407,6 +423,7 @@ export async function prepareResponsesTools({
               require_approval: requireApprovalParam ?? 'never',
               server_description: args.serverDescription,
               server_url: args.serverUrl,
+              tunnel_id: args.tunnelId,
             });
 
             break;

package/src/tool/code-interpreter.ts

@@ -37,6 +37,25 @@ export const codeInterpreterArgsSchema = lazySchema(() =>
           z.string(),
           z.object({
             fileIds: z.array(z.string()).optional(),
+            memoryLimit: z.enum(['1g', '4g', '16g', '64g']).optional(),
+            networkPolicy: z
+              .discriminatedUnion('type', [
+                z.object({ type: z.literal('disabled') }),
+                z.object({
+                  type: z.literal('allowlist'),
+                  allowedDomains: z.array(z.string()),
+                  domainSecrets: z
+                    .array(
+                      z.object({
+                        domain: z.string(),
+                        name: z.string(),
+                        value: z.string(),
+                      }),
+                    )
+                    .optional(),
+                }),
+              ])
+              .optional(),
           }),
         ])
         .optional(),
@@ -48,9 +67,26 @@ 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.
+   * or an object that configures uploaded file IDs, the memory limit,
+   * and the network policy for a new container.
    */
-  container?: string | { fileIds?: string[] };
+  container?:
+    | string
+    | {
+        fileIds?: string[];
+        memoryLimit?: '1g' | '4g' | '16g' | '64g';
+        networkPolicy?:
+          | { type: 'disabled' }
+          | {
+              type: 'allowlist';
+              allowedDomains: string[];
+              domainSecrets?: Array<{
+                domain: string;
+                name: string;
+                value: string;
+              }>;
+            };
+      };
 };
 
 export const codeInterpreterToolFactory = createProviderExecutedToolFactory<

package/src/tool/mcp.ts

@@ -51,10 +51,16 @@ export const mcpArgsSchema = lazySchema(() =>
           .optional(),
         serverDescription: z.string().optional(),
         serverUrl: z.string().optional(),
+        tunnelId: z.string().optional(),
       })
       .refine(
-        v => v.serverUrl != null || v.connectorId != null,
-        'One of serverUrl or connectorId must be provided.',
+        v => v.serverUrl != null || v.connectorId != null || v.tunnelId != null,
+        'One of serverUrl, connectorId, or tunnelId must be provided.',
+      )
+      .refine(
+        v =>
+          v.tunnelId == null || (v.serverUrl == null && v.connectorId == null),
+        'tunnelId cannot be combined with serverUrl or connectorId.',
       ),
   ),
 );
@@ -74,7 +80,7 @@ export const mcpOutputSchema = lazySchema(() =>
   ),
 );
 
-type McpArgs = {
+type McpCommonArgs = {
   /** A label for this MCP server, used to identify it in tool calls. */
   serverLabel: string;
   /** List of allowed tool names or a filter object. */
@@ -84,10 +90,8 @@ type McpArgs = {
         readOnly?: boolean;
         toolNames?: string[];
       };
-  /** OAuth access token usable with the remote MCP server or connector. */
+  /** OAuth access token usable with the remote MCP server or connector (including tunneled servers). */
   authorization?: string;
-  /** Identifier for a service connector. */
-  connectorId?: string;
   /** Optional HTTP headers to send to the MCP server. */
   headers?: Record<string, string>;
   /**
@@ -103,10 +107,25 @@ type McpArgs = {
       };
   /** Optional description of the MCP server. */
   serverDescription?: string;
-  /** URL for the MCP server. One of serverUrl or connectorId must be provided. */
-  serverUrl?: string;
 };
 
+type McpArgs = McpCommonArgs &
+  (
+    | {
+        /** URL for the MCP server. */
+        serverUrl?: string;
+        /** Identifier for a service connector. */
+        connectorId?: string;
+        tunnelId?: never;
+      }
+    | {
+        /** Identifier for an OpenAI Secure MCP tunnel. */
+        tunnelId: string;
+        serverUrl?: never;
+        connectorId?: never;
+      }
+  );
+
 export const mcpToolFactory = createProviderExecutedToolFactory<
   {},
   {

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

@@ -162,6 +162,7 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
     audio,
     mediaType,
     providerOptions,
+    timestampGranularities: requestedTimestampGranularities,
   }: OpenAITranscriptionCallOptions) {
     const warnings: SharedV4Warning[] = [];
 
@@ -194,12 +195,42 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
     const responseFormat =
       openAIOptions?.responseFormat ?? requestConfig.responseFormat;
 
-    // Timestamps are only returned with verbose_json, so only default to
-    // segments when that format is used.
+    // Only verbose_json accepts timestamp_granularities. Diarized JSON
+    // always returns segment timings without a timestamp control.
     const timestampGranularities =
       openAIOptions?.timestampGranularities ??
+      requestedTimestampGranularities ??
       (responseFormat === 'verbose_json' ? ['segment'] : undefined);
 
+    for (const granularity of requestedTimestampGranularities ?? []) {
+      if (
+        openAIOptions?.timestampGranularities != null &&
+        !openAIOptions.timestampGranularities.includes(granularity)
+      ) {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'timestampGranularities',
+          details: `The "${granularity}" timestamp granularity is excluded by providerOptions.openai.timestampGranularities.`,
+        });
+      }
+    }
+
+    for (const granularity of timestampGranularities ?? []) {
+      if (
+        responseFormat !== 'verbose_json' &&
+        !(responseFormat === 'diarized_json' && granularity === 'segment')
+      ) {
+        warnings.push({
+          type: 'unsupported',
+          feature:
+            openAIOptions?.timestampGranularities != null
+              ? 'providerOptions.openai.timestampGranularities'
+              : 'timestampGranularities',
+          details: `OpenAI transcription with the ${responseFormat ?? 'default JSON'} response format does not support ${granularity} timestamps.`,
+        });
+      }
+    }
+
     const chunkingStrategy =
       openAIOptions?.chunkingStrategy ?? requestConfig.chunkingStrategy;
 
@@ -211,7 +242,8 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
       keywords: openAIOptions?.keywords,
       prompt: openAIOptions?.prompt,
       temperature: openAIOptions?.temperature,
-      timestamp_granularities: timestampGranularities,
+      timestamp_granularities:
+        responseFormat === 'verbose_json' ? timestampGranularities : undefined,
     };
 
     for (const [key, value] of Object.entries(transcriptionModelOptions)) {
@@ -314,6 +346,12 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
         : [],
     );
 
+    const words = response.words?.map(word => ({
+      text: word.word,
+      startSecond: word.start,
+      endSecond: word.end,
+    }));
+
     return {
       text: response.text,
       segments:
@@ -322,12 +360,9 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
           startSecond: segment.start,
           endSecond: segment.end,
         })) ??
-        response.words?.map(word => ({
-          text: word.word,
-          startSecond: word.start,
-          endSecond: word.end,
-        })) ??
+        words ??
         [],
+      ...(words != null && words.length > 0 ? { words } : {}),
       language,
       // Duration-billed json responses report the duration only in `usage`:
       durationInSeconds: