@ai-sdk/openai 2.0.142 → 2.0.143

package/dist/index.mjs

@@ -2461,14 +2461,27 @@ import {
   safeValidateTypes,
   validateTypes
 } from "@ai-sdk/provider-utils";
-import { z as z17 } from "zod/v4";
+import { z as z18 } from "zod/v4";
+
+// src/responses/openai-responses-text-format.ts
+import { z as z16 } from "zod/v4";
+var openaiResponsesTextFormatSchema = () => z16.discriminatedUnion("type", [
+  z16.object({ type: z16.literal("text") }),
+  z16.object({
+    type: z16.literal("json_schema"),
+    name: z16.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/),
+    schema: z16.record(z16.string(), z16.json()),
+    description: z16.string().optional(),
+    strict: z16.boolean().optional()
+  })
+]);
 
 // src/responses/openai-responses-options.ts
 import {
   lazyValidator as lazyValidator9,
   zodSchema as zodSchema16
 } from "@ai-sdk/provider-utils";
-import { z as z16 } from "zod/v4";
+import { z as z17 } from "zod/v4";
 var TOP_LOGPROBS_MAX = 20;
 var openaiResponsesReasoningModelIds = [
   "o1",
@@ -2560,17 +2573,17 @@ var openaiResponsesModelIds = [
 ];
 var openaiResponsesProviderOptionsSchema = lazyValidator9(
   () => zodSchema16(
-    z16.object({
-      conversation: z16.string().nullish(),
-      include: z16.array(
-        z16.enum([
+    z17.object({
+      conversation: z17.string().nullish(),
+      include: z17.array(
+        z17.enum([
           "reasoning.encrypted_content",
           // handled internally by default, only needed for unknown reasoning models
           "file_search_call.results",
           "message.output_text.logprobs"
         ])
       ).nullish(),
-      instructions: z16.string().nullish(),
+      instructions: z17.string().nullish(),
       /**
        * Return the log probabilities of the tokens.
        *
@@ -2583,25 +2596,26 @@ var openaiResponsesProviderOptionsSchema = lazyValidator9(
        * @see https://platform.openai.com/docs/api-reference/responses/create
        * @see https://cookbook.openai.com/examples/using_logprobs
        */
-      logprobs: z16.union([z16.boolean(), z16.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+      logprobs: z17.union([z17.boolean(), z17.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: z16.number().nullish(),
-      metadata: z16.any().nullish(),
-      parallelToolCalls: z16.boolean().nullish(),
-      previousResponseId: z16.string().nullish(),
-      promptCacheKey: z16.string().nullish(),
+      maxToolCalls: z17.number().nullish(),
+      metadata: z17.any().nullish(),
+      parallelToolCalls: z17.boolean().nullish(),
+      previousResponseId: z17.string().nullish(),
+      promptCacheKey: z17.string().nullish(),
       /**
        * Prompt cache behavior for GPT-5.6 and later models.
        * `mode` controls whether OpenAI also places an implicit breakpoint.
        * `ttl` sets the minimum cache lifetime and currently only supports 30 minutes.
        */
-      promptCacheOptions: z16.object({
-        mode: z16.enum(["implicit", "explicit"]).optional(),
-        ttl: z16.literal("30m").optional()
+      promptCacheOptions: z17.object({
+        comparisonResponseId: z17.string().optional(),
+        mode: z17.enum(["implicit", "explicit"]).optional(),
+        ttl: z17.literal("30m").optional()
       }).optional(),
       /**
        * The retention policy for the prompt cache.
@@ -2613,14 +2627,14 @@ var openaiResponsesProviderOptionsSchema = lazyValidator9(
        *
        * @default 'in_memory'
        */
-      promptCacheRetention: z16.enum(["in_memory", "24h"]).nullish(),
+      promptCacheRetention: z17.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.
        * GPT-5.6 supports 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'.
        * Supported values vary by model.
        */
-      reasoningEffort: z16.string().nullish(),
+      reasoningEffort: z17.string().nullish(),
       /**
        * Updates the reasoning effort for GPT-6 and later models starting with this response
        * without changing the request-level reasoning effort. This preserves the
@@ -2629,32 +2643,36 @@ var openaiResponsesProviderOptionsSchema = lazyValidator9(
        * Only supported by GPT-6 and later models in standard, single-agent mode. Cannot be
        * combined with automatic truncation.
        */
-      reasoningEffortUpdate: z16.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
+      reasoningEffortUpdate: z17.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
       /**
        * Controls how much model work GPT-5.6 performs before returning a final answer.
        * `standard` is the default. `pro` increases quality, latency, and token usage.
        */
-      reasoningMode: z16.enum(["standard", "pro"]).optional(),
+      reasoningMode: z17.enum(["standard", "pro"]).optional(),
       /**
        * Controls which available reasoning items GPT-5.6 can use.
        * `auto` uses the model default, `current_turn` excludes reasoning from earlier
        * turns, and `all_turns` makes compatible earlier reasoning available.
        */
-      reasoningContext: z16.enum(["auto", "current_turn", "all_turns"]).optional(),
-      reasoningSummary: z16.string().nullish(),
-      safetyIdentifier: z16.string().nullish(),
-      serviceTier: z16.enum(["auto", "flex", "priority", "default"]).nullish(),
-      store: z16.boolean().nullish(),
-      strictJsonSchema: z16.boolean().nullish(),
-      textVerbosity: z16.enum(["low", "medium", "high"]).nullish(),
-      truncation: z16.enum(["auto", "disabled"]).nullish(),
-      user: z16.string().nullish()
+      reasoningContext: z17.enum(["auto", "current_turn", "all_turns"]).optional(),
+      reasoningSummary: z17.string().nullish(),
+      safetyIdentifier: z17.string().nullish(),
+      serviceTier: z17.enum(["auto", "flex", "priority", "default"]).nullish(),
+      store: z17.boolean().nullish(),
+      strictJsonSchema: z17.boolean().nullish(),
+      textVerbosity: z17.enum(["low", "medium", "high"]).nullish(),
+      /** Keep the initial wire format stable while Output validates the current schema. */
+      textFormat: openaiResponsesTextFormatSchema().optional(),
+      truncation: z17.enum(["auto", "disabled"]).nullish(),
+      user: z17.string().nullish()
     })
   )
 );
 var openaiResponsesSystemMessageOptionsSchema = lazyValidator9(
   () => zodSchema16(
-    z16.object({
+    z17.object({
+      /** Replace the format at this position; requires empty system content. */
+      textFormatUpdate: openaiResponsesTextFormatSchema().optional(),
       /**
        * Emit a configuration update at this position in Responses history.
        * Requires empty system message content and the same supported
@@ -2663,7 +2681,7 @@ var openaiResponsesSystemMessageOptionsSchema = lazyValidator9(
        *
        * @see https://developers.openai.com/api/docs/guides/reasoning#change-reasoning-mid-conversation
        */
-      reasoningEffortUpdate: z16.enum(["low", "medium", "high", "xhigh", "max"]).optional()
+      reasoningEffortUpdate: z17.enum(["low", "medium", "high", "xhigh", "max"]).optional()
     })
   )
 );
@@ -2758,17 +2776,24 @@ async function convertToOpenAIResponsesInput({
           });
         }
         const effort = options == null ? void 0 : options.reasoningEffortUpdate;
-        if (effort != null) {
-          const unsupportedReason = content !== "" ? "Message-level reasoningEffortUpdate requires empty system message content." : configurationUpdateUnsupportedReason;
+        const textFormat = options == null ? void 0 : options.textFormatUpdate;
+        if (effort != null || textFormat != null) {
+          const feature = effort != null ? "reasoningEffortUpdate" : "textFormatUpdate";
+          const unsupportedReason = content !== "" ? `Message-level ${feature} requires empty system message content.` : configurationUpdateUnsupportedReason;
           if (unsupportedReason != null) {
             throw new UnsupportedFunctionalityError4({
-              functionality: "Message-level reasoningEffortUpdate",
+              functionality: `Message-level ${feature}`,
               message: unsupportedReason
             });
           }
           input.push({
             type: "configuration_update",
-            reasoning: { effort }
+            ...effort != null && { reasoning: { effort } },
+            ...textFormat != null && {
+              text: {
+                format: textFormat
+              }
+            }
           });
           break;
         }
@@ -3138,9 +3163,9 @@ async function convertToOpenAIResponsesInput({
 }
 var openaiResponsesReasoningProviderOptionsSchema = lazySchema8(
   () => zodSchema17(
-    z17.object({
-      itemId: z17.string().nullish(),
-      reasoningEncryptedContent: z17.string().nullish()
+    z18.object({
+      itemId: z18.string().nullish(),
+      reasoningEncryptedContent: z18.string().nullish()
     })
   )
 );
@@ -3181,301 +3206,308 @@ import {
   lazyValidator as lazyValidator10,
   zodSchema as zodSchema18
 } from "@ai-sdk/provider-utils";
-import { z as z18 } from "zod/v4";
+import { z as z19 } from "zod/v4";
+var openaiResponsesPromptCacheDiagnosticsSchema = () => z19.object({
+  type: z19.string(),
+  reason: z19.string().nullish(),
+  cache_missed_tokens: z19.number().nullish(),
+  comparison_reusable_tokens: z19.number().nullish()
+});
 var openaiResponsesChunkSchema = lazyValidator10(
   () => zodSchema18(
-    z18.union([
-      z18.object({
-        type: z18.literal("response.output_text.delta"),
-        item_id: z18.string(),
-        delta: z18.string(),
-        logprobs: z18.array(
-          z18.object({
-            token: z18.string(),
-            logprob: z18.number(),
-            top_logprobs: z18.array(
-              z18.object({
-                token: z18.string(),
-                logprob: z18.number()
+    z19.union([
+      z19.object({
+        type: z19.literal("response.output_text.delta"),
+        item_id: z19.string(),
+        delta: z19.string(),
+        logprobs: z19.array(
+          z19.object({
+            token: z19.string(),
+            logprob: z19.number(),
+            top_logprobs: z19.array(
+              z19.object({
+                token: z19.string(),
+                logprob: z19.number()
               })
             )
           })
         ).nullish()
       }),
-      z18.object({
-        type: z18.literal("response.refusal.delta"),
-        item_id: z18.string(),
-        output_index: z18.number().nullish(),
-        content_index: z18.number().nullish(),
-        delta: z18.string()
+      z19.object({
+        type: z19.literal("response.refusal.delta"),
+        item_id: z19.string(),
+        output_index: z19.number().nullish(),
+        content_index: z19.number().nullish(),
+        delta: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.refusal.done"),
-        item_id: z18.string(),
-        output_index: z18.number().nullish(),
-        content_index: z18.number().nullish(),
-        refusal: z18.string()
+      z19.object({
+        type: z19.literal("response.refusal.done"),
+        item_id: z19.string(),
+        output_index: z19.number().nullish(),
+        content_index: z19.number().nullish(),
+        refusal: z19.string()
       }),
-      z18.object({
-        type: z18.enum(["response.completed", "response.incomplete"]),
-        response: z18.object({
-          incomplete_details: z18.object({ reason: z18.string() }).nullish(),
-          usage: z18.object({
-            input_tokens: z18.number(),
-            input_tokens_details: z18.object({
-              cached_tokens: z18.number().nullish(),
-              cache_write_tokens: z18.number().nullish(),
-              orchestration_input_tokens: z18.number().nullish(),
-              orchestration_input_cached_tokens: z18.number().nullish()
+      z19.object({
+        type: z19.enum(["response.completed", "response.incomplete"]),
+        response: z19.object({
+          prompt_cache_diagnostics: openaiResponsesPromptCacheDiagnosticsSchema().nullish(),
+          incomplete_details: z19.object({ reason: z19.string() }).nullish(),
+          usage: z19.object({
+            input_tokens: z19.number(),
+            input_tokens_details: z19.object({
+              cached_tokens: z19.number().nullish(),
+              cache_write_tokens: z19.number().nullish(),
+              orchestration_input_tokens: z19.number().nullish(),
+              orchestration_input_cached_tokens: z19.number().nullish()
             }).nullish(),
-            output_tokens: z18.number(),
-            output_tokens_details: z18.object({
-              reasoning_tokens: z18.number().nullish(),
-              orchestration_output_tokens: z18.number().nullish()
+            output_tokens: z19.number(),
+            output_tokens_details: z19.object({
+              reasoning_tokens: z19.number().nullish(),
+              orchestration_output_tokens: z19.number().nullish()
             }).nullish()
           }),
-          reasoning: z18.object({
-            context: z18.string().nullish()
+          reasoning: z19.object({
+            context: z19.string().nullish()
           }).nullish(),
-          service_tier: z18.string().nullish()
+          service_tier: z19.string().nullish()
         })
       }),
-      z18.object({
-        type: z18.literal("response.created"),
-        response: z18.object({
-          id: z18.string(),
-          created_at: z18.number(),
-          model: z18.string(),
-          service_tier: z18.string().nullish()
+      z19.object({
+        type: z19.literal("response.created"),
+        response: z19.object({
+          id: z19.string(),
+          created_at: z19.number(),
+          model: z19.string(),
+          service_tier: z19.string().nullish()
         })
       }),
-      z18.object({
-        type: z18.literal("response.output_item.added"),
-        output_index: z18.number(),
-        item: z18.discriminatedUnion("type", [
-          z18.object({
-            type: z18.literal("message"),
-            id: z18.string(),
-            phase: z18.enum(["commentary", "final_answer"]).nullish()
+      z19.object({
+        type: z19.literal("response.output_item.added"),
+        output_index: z19.number(),
+        item: z19.discriminatedUnion("type", [
+          z19.object({
+            type: z19.literal("message"),
+            id: z19.string(),
+            phase: z19.enum(["commentary", "final_answer"]).nullish()
           }),
-          z18.object({
-            type: z18.literal("reasoning"),
-            id: z18.string(),
-            encrypted_content: z18.string().nullish()
+          z19.object({
+            type: z19.literal("reasoning"),
+            id: z19.string(),
+            encrypted_content: z19.string().nullish()
           }),
-          z18.object({
-            type: z18.literal("function_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            name: z18.string(),
-            arguments: z18.string(),
-            async: z18.boolean().nullish()
+          z19.object({
+            type: z19.literal("function_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            name: z19.string(),
+            arguments: z19.string(),
+            async: z19.boolean().nullish()
           }),
-          z18.object({
-            type: z18.literal("web_search_call"),
-            id: z18.string(),
-            status: z18.string()
+          z19.object({
+            type: z19.literal("web_search_call"),
+            id: z19.string(),
+            status: z19.string()
           }),
-          z18.object({
-            type: z18.literal("computer_call"),
-            id: z18.string(),
-            status: z18.string()
+          z19.object({
+            type: z19.literal("computer_call"),
+            id: z19.string(),
+            status: z19.string()
           }),
-          z18.object({
-            type: z18.literal("file_search_call"),
-            id: z18.string()
+          z19.object({
+            type: z19.literal("file_search_call"),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("image_generation_call"),
-            id: z18.string()
+          z19.object({
+            type: z19.literal("image_generation_call"),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("code_interpreter_call"),
-            id: z18.string(),
-            container_id: z18.string(),
-            code: z18.string().nullable(),
-            outputs: z18.array(
-              z18.discriminatedUnion("type", [
-                z18.object({ type: z18.literal("logs"), logs: z18.string() }),
-                z18.object({ type: z18.literal("image"), url: z18.string() })
+          z19.object({
+            type: z19.literal("code_interpreter_call"),
+            id: z19.string(),
+            container_id: z19.string(),
+            code: z19.string().nullable(),
+            outputs: z19.array(
+              z19.discriminatedUnion("type", [
+                z19.object({ type: z19.literal("logs"), logs: z19.string() }),
+                z19.object({ type: z19.literal("image"), url: z19.string() })
               ])
             ).nullable(),
-            status: z18.string()
+            status: z19.string()
           })
         ])
       }),
-      z18.object({
-        type: z18.literal("response.output_item.done"),
-        output_index: z18.number(),
-        item: z18.discriminatedUnion("type", [
-          z18.object({
-            type: z18.literal("message"),
-            id: z18.string(),
-            phase: z18.enum(["commentary", "final_answer"]).nullish()
+      z19.object({
+        type: z19.literal("response.output_item.done"),
+        output_index: z19.number(),
+        item: z19.discriminatedUnion("type", [
+          z19.object({
+            type: z19.literal("message"),
+            id: z19.string(),
+            phase: z19.enum(["commentary", "final_answer"]).nullish()
           }),
-          z18.object({
-            type: z18.literal("reasoning"),
-            id: z18.string(),
-            encrypted_content: z18.string().nullish()
+          z19.object({
+            type: z19.literal("reasoning"),
+            id: z19.string(),
+            encrypted_content: z19.string().nullish()
           }),
-          z18.object({
-            type: z18.literal("function_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            name: z18.string(),
-            arguments: z18.string(),
-            async: z18.boolean().nullish(),
-            status: z18.enum(["in_progress", "completed", "incomplete"])
+          z19.object({
+            type: z19.literal("function_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            name: z19.string(),
+            arguments: z19.string(),
+            async: z19.boolean().nullish(),
+            status: z19.enum(["in_progress", "completed", "incomplete"])
           }),
-          z18.object({
-            type: z18.literal("code_interpreter_call"),
-            id: z18.string(),
-            code: z18.string().nullable(),
-            container_id: z18.string(),
-            outputs: z18.array(
-              z18.discriminatedUnion("type", [
-                z18.object({ type: z18.literal("logs"), logs: z18.string() }),
-                z18.object({ type: z18.literal("image"), url: z18.string() })
+          z19.object({
+            type: z19.literal("code_interpreter_call"),
+            id: z19.string(),
+            code: z19.string().nullable(),
+            container_id: z19.string(),
+            outputs: z19.array(
+              z19.discriminatedUnion("type", [
+                z19.object({ type: z19.literal("logs"), logs: z19.string() }),
+                z19.object({ type: z19.literal("image"), url: z19.string() })
               ])
             ).nullable()
           }),
-          z18.object({
-            type: z18.literal("image_generation_call"),
-            id: z18.string(),
-            result: z18.string()
+          z19.object({
+            type: z19.literal("image_generation_call"),
+            id: z19.string(),
+            result: z19.string()
           }),
-          z18.object({
-            type: z18.literal("web_search_call"),
-            id: z18.string(),
-            status: z18.string(),
-            action: z18.discriminatedUnion("type", [
-              z18.object({
-                type: z18.literal("search"),
-                query: z18.string().nullish(),
-                sources: z18.array(
-                  z18.discriminatedUnion("type", [
-                    z18.object({ type: z18.literal("url"), url: z18.string() }),
-                    z18.object({ type: z18.literal("api"), name: z18.string() })
+          z19.object({
+            type: z19.literal("web_search_call"),
+            id: z19.string(),
+            status: z19.string(),
+            action: z19.discriminatedUnion("type", [
+              z19.object({
+                type: z19.literal("search"),
+                query: z19.string().nullish(),
+                sources: z19.array(
+                  z19.discriminatedUnion("type", [
+                    z19.object({ type: z19.literal("url"), url: z19.string() }),
+                    z19.object({ type: z19.literal("api"), name: z19.string() })
                   ])
                 ).nullish()
               }),
-              z18.object({
-                type: z18.literal("open_page"),
-                url: z18.string().nullish()
+              z19.object({
+                type: z19.literal("open_page"),
+                url: z19.string().nullish()
               }),
-              z18.object({
-                type: z18.literal("find_in_page"),
-                url: z18.string().nullish(),
-                pattern: z18.string().nullish()
+              z19.object({
+                type: z19.literal("find_in_page"),
+                url: z19.string().nullish(),
+                pattern: z19.string().nullish()
               })
             ]).nullish()
           }),
-          z18.object({
-            type: z18.literal("file_search_call"),
-            id: z18.string(),
-            queries: z18.array(z18.string()),
-            results: z18.array(
-              z18.object({
-                attributes: z18.record(z18.string(), z18.unknown()),
-                file_id: z18.string(),
-                filename: z18.string(),
-                score: z18.number(),
-                text: z18.string()
+          z19.object({
+            type: z19.literal("file_search_call"),
+            id: z19.string(),
+            queries: z19.array(z19.string()),
+            results: z19.array(
+              z19.object({
+                attributes: z19.record(z19.string(), z19.unknown()),
+                file_id: z19.string(),
+                filename: z19.string(),
+                score: z19.number(),
+                text: z19.string()
               })
             ).nullish()
           }),
-          z18.object({
-            type: z18.literal("local_shell_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            action: z18.object({
-              type: z18.literal("exec"),
-              command: z18.array(z18.string()),
-              timeout_ms: z18.number().optional(),
-              user: z18.string().optional(),
-              working_directory: z18.string().optional(),
-              env: z18.record(z18.string(), z18.string()).optional()
+          z19.object({
+            type: z19.literal("local_shell_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            action: z19.object({
+              type: z19.literal("exec"),
+              command: z19.array(z19.string()),
+              timeout_ms: z19.number().optional(),
+              user: z19.string().optional(),
+              working_directory: z19.string().optional(),
+              env: z19.record(z19.string(), z19.string()).optional()
             })
           }),
-          z18.object({
-            type: z18.literal("computer_call"),
-            id: z18.string(),
-            status: z18.literal("completed")
+          z19.object({
+            type: z19.literal("computer_call"),
+            id: z19.string(),
+            status: z19.literal("completed")
           })
         ])
       }),
-      z18.object({
-        type: z18.literal("response.function_call_arguments.delta"),
-        item_id: z18.string(),
-        output_index: z18.number(),
-        delta: z18.string()
+      z19.object({
+        type: z19.literal("response.function_call_arguments.delta"),
+        item_id: z19.string(),
+        output_index: z19.number(),
+        delta: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.image_generation_call.partial_image"),
-        item_id: z18.string(),
-        output_index: z18.number(),
-        partial_image_b64: z18.string()
+      z19.object({
+        type: z19.literal("response.image_generation_call.partial_image"),
+        item_id: z19.string(),
+        output_index: z19.number(),
+        partial_image_b64: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.code_interpreter_call_code.delta"),
-        item_id: z18.string(),
-        output_index: z18.number(),
-        delta: z18.string()
+      z19.object({
+        type: z19.literal("response.code_interpreter_call_code.delta"),
+        item_id: z19.string(),
+        output_index: z19.number(),
+        delta: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.code_interpreter_call_code.done"),
-        item_id: z18.string(),
-        output_index: z18.number(),
-        code: z18.string()
+      z19.object({
+        type: z19.literal("response.code_interpreter_call_code.done"),
+        item_id: z19.string(),
+        output_index: z19.number(),
+        code: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.output_text.annotation.added"),
-        annotation: z18.discriminatedUnion("type", [
-          z18.object({
-            type: z18.literal("url_citation"),
-            start_index: z18.number(),
-            end_index: z18.number(),
-            url: z18.string(),
-            title: z18.string()
+      z19.object({
+        type: z19.literal("response.output_text.annotation.added"),
+        annotation: z19.discriminatedUnion("type", [
+          z19.object({
+            type: z19.literal("url_citation"),
+            start_index: z19.number(),
+            end_index: z19.number(),
+            url: z19.string(),
+            title: z19.string()
           }),
-          z18.object({
-            type: z18.literal("file_citation"),
-            file_id: z18.string(),
-            filename: z18.string().nullish(),
-            index: z18.number().nullish(),
-            start_index: z18.number().nullish(),
-            end_index: z18.number().nullish(),
-            quote: z18.string().nullish()
+          z19.object({
+            type: z19.literal("file_citation"),
+            file_id: z19.string(),
+            filename: z19.string().nullish(),
+            index: z19.number().nullish(),
+            start_index: z19.number().nullish(),
+            end_index: z19.number().nullish(),
+            quote: z19.string().nullish()
           })
         ])
       }),
-      z18.object({
-        type: z18.literal("response.reasoning_summary_part.added"),
-        item_id: z18.string(),
-        summary_index: z18.number()
+      z19.object({
+        type: z19.literal("response.reasoning_summary_part.added"),
+        item_id: z19.string(),
+        summary_index: z19.number()
       }),
-      z18.object({
-        type: z18.literal("response.reasoning_summary_text.delta"),
-        item_id: z18.string(),
-        summary_index: z18.number(),
-        delta: z18.string()
+      z19.object({
+        type: z19.literal("response.reasoning_summary_text.delta"),
+        item_id: z19.string(),
+        summary_index: z19.number(),
+        delta: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.reasoning_summary_part.done"),
-        item_id: z18.string(),
-        summary_index: z18.number()
+      z19.object({
+        type: z19.literal("response.reasoning_summary_part.done"),
+        item_id: z19.string(),
+        summary_index: z19.number()
       }),
-      z18.object({
-        type: z18.literal("error"),
-        sequence_number: z18.number(),
-        error: z18.object({
-          type: z18.string(),
-          code: z18.string(),
-          message: z18.string(),
-          param: z18.string().nullish()
+      z19.object({
+        type: z19.literal("error"),
+        sequence_number: z19.number(),
+        error: z19.object({
+          type: z19.string(),
+          code: z19.string(),
+          message: z19.string(),
+          param: z19.string().nullish()
         })
       }),
-      z18.object({ type: z18.string() }).loose().transform((value) => ({
+      z19.object({ type: z19.string() }).loose().transform((value) => ({
         type: "unknown_chunk",
         message: value.type
       }))
@@ -3485,202 +3517,203 @@ var openaiResponsesChunkSchema = lazyValidator10(
 );
 var openaiResponsesResponseSchema = lazyValidator10(
   () => zodSchema18(
-    z18.object({
-      id: z18.string().optional(),
-      created_at: z18.number().optional(),
-      error: z18.object({
-        message: z18.string(),
-        type: z18.string(),
-        param: z18.string().nullish(),
-        code: z18.string()
+    z19.object({
+      id: z19.string().optional(),
+      created_at: z19.number().optional(),
+      error: z19.object({
+        message: z19.string(),
+        type: z19.string(),
+        param: z19.string().nullish(),
+        code: z19.string()
       }).nullish(),
-      model: z18.string().optional(),
-      output: z18.array(
-        z18.discriminatedUnion("type", [
-          z18.object({
-            type: z18.literal("message"),
-            role: z18.literal("assistant"),
-            id: z18.string(),
-            phase: z18.enum(["commentary", "final_answer"]).nullish(),
+      model: z19.string().optional(),
+      output: z19.array(
+        z19.discriminatedUnion("type", [
+          z19.object({
+            type: z19.literal("message"),
+            role: z19.literal("assistant"),
+            id: z19.string(),
+            phase: z19.enum(["commentary", "final_answer"]).nullish(),
             // the API returns either text or a refusal as content parts:
-            content: z18.array(
-              z18.discriminatedUnion("type", [
-                z18.object({
-                  type: z18.literal("output_text"),
-                  text: z18.string(),
-                  logprobs: z18.array(
-                    z18.object({
-                      token: z18.string(),
-                      logprob: z18.number(),
-                      top_logprobs: z18.array(
-                        z18.object({
-                          token: z18.string(),
-                          logprob: z18.number()
+            content: z19.array(
+              z19.discriminatedUnion("type", [
+                z19.object({
+                  type: z19.literal("output_text"),
+                  text: z19.string(),
+                  logprobs: z19.array(
+                    z19.object({
+                      token: z19.string(),
+                      logprob: z19.number(),
+                      top_logprobs: z19.array(
+                        z19.object({
+                          token: z19.string(),
+                          logprob: z19.number()
                         })
                       )
                     })
                   ).nullish(),
-                  annotations: z18.array(
-                    z18.discriminatedUnion("type", [
-                      z18.object({
-                        type: z18.literal("url_citation"),
-                        start_index: z18.number(),
-                        end_index: z18.number(),
-                        url: z18.string(),
-                        title: z18.string()
+                  annotations: z19.array(
+                    z19.discriminatedUnion("type", [
+                      z19.object({
+                        type: z19.literal("url_citation"),
+                        start_index: z19.number(),
+                        end_index: z19.number(),
+                        url: z19.string(),
+                        title: z19.string()
                       }),
-                      z18.object({
-                        type: z18.literal("file_citation"),
-                        file_id: z18.string(),
-                        filename: z18.string().nullish(),
-                        index: z18.number().nullish(),
-                        start_index: z18.number().nullish(),
-                        end_index: z18.number().nullish(),
-                        quote: z18.string().nullish()
+                      z19.object({
+                        type: z19.literal("file_citation"),
+                        file_id: z19.string(),
+                        filename: z19.string().nullish(),
+                        index: z19.number().nullish(),
+                        start_index: z19.number().nullish(),
+                        end_index: z19.number().nullish(),
+                        quote: z19.string().nullish()
                       }),
-                      z18.object({
-                        type: z18.literal("container_file_citation"),
-                        container_id: z18.string(),
-                        file_id: z18.string(),
-                        filename: z18.string().nullish(),
-                        start_index: z18.number().nullish(),
-                        end_index: z18.number().nullish(),
-                        index: z18.number().nullish()
+                      z19.object({
+                        type: z19.literal("container_file_citation"),
+                        container_id: z19.string(),
+                        file_id: z19.string(),
+                        filename: z19.string().nullish(),
+                        start_index: z19.number().nullish(),
+                        end_index: z19.number().nullish(),
+                        index: z19.number().nullish()
                       }),
-                      z18.object({
-                        type: z18.literal("file_path"),
-                        file_id: z18.string(),
-                        index: z18.number().nullish()
+                      z19.object({
+                        type: z19.literal("file_path"),
+                        file_id: z19.string(),
+                        index: z19.number().nullish()
                       })
                     ])
                   )
                 }),
-                z18.object({
-                  type: z18.literal("refusal"),
-                  refusal: z18.string()
+                z19.object({
+                  type: z19.literal("refusal"),
+                  refusal: z19.string()
                 })
               ])
             )
           }),
-          z18.object({
-            type: z18.literal("web_search_call"),
-            id: z18.string(),
-            status: z18.string(),
-            action: z18.discriminatedUnion("type", [
-              z18.object({
-                type: z18.literal("search"),
-                query: z18.string().nullish(),
-                sources: z18.array(
-                  z18.discriminatedUnion("type", [
-                    z18.object({ type: z18.literal("url"), url: z18.string() }),
-                    z18.object({
-                      type: z18.literal("api"),
-                      name: z18.string()
+          z19.object({
+            type: z19.literal("web_search_call"),
+            id: z19.string(),
+            status: z19.string(),
+            action: z19.discriminatedUnion("type", [
+              z19.object({
+                type: z19.literal("search"),
+                query: z19.string().nullish(),
+                sources: z19.array(
+                  z19.discriminatedUnion("type", [
+                    z19.object({ type: z19.literal("url"), url: z19.string() }),
+                    z19.object({
+                      type: z19.literal("api"),
+                      name: z19.string()
                     })
                   ])
                 ).nullish()
               }),
-              z18.object({
-                type: z18.literal("open_page"),
-                url: z18.string().nullish()
+              z19.object({
+                type: z19.literal("open_page"),
+                url: z19.string().nullish()
               }),
-              z18.object({
-                type: z18.literal("find_in_page"),
-                url: z18.string().nullish(),
-                pattern: z18.string().nullish()
+              z19.object({
+                type: z19.literal("find_in_page"),
+                url: z19.string().nullish(),
+                pattern: z19.string().nullish()
               })
             ]).nullish()
           }),
-          z18.object({
-            type: z18.literal("file_search_call"),
-            id: z18.string(),
-            queries: z18.array(z18.string()),
-            results: z18.array(
-              z18.object({
-                attributes: z18.record(
-                  z18.string(),
-                  z18.union([z18.string(), z18.number(), z18.boolean()])
+          z19.object({
+            type: z19.literal("file_search_call"),
+            id: z19.string(),
+            queries: z19.array(z19.string()),
+            results: z19.array(
+              z19.object({
+                attributes: z19.record(
+                  z19.string(),
+                  z19.union([z19.string(), z19.number(), z19.boolean()])
                 ),
-                file_id: z18.string(),
-                filename: z18.string(),
-                score: z18.number(),
-                text: z18.string()
+                file_id: z19.string(),
+                filename: z19.string(),
+                score: z19.number(),
+                text: z19.string()
               })
             ).nullish()
           }),
-          z18.object({
-            type: z18.literal("code_interpreter_call"),
-            id: z18.string(),
-            code: z18.string().nullable(),
-            container_id: z18.string(),
-            outputs: z18.array(
-              z18.discriminatedUnion("type", [
-                z18.object({ type: z18.literal("logs"), logs: z18.string() }),
-                z18.object({ type: z18.literal("image"), url: z18.string() })
+          z19.object({
+            type: z19.literal("code_interpreter_call"),
+            id: z19.string(),
+            code: z19.string().nullable(),
+            container_id: z19.string(),
+            outputs: z19.array(
+              z19.discriminatedUnion("type", [
+                z19.object({ type: z19.literal("logs"), logs: z19.string() }),
+                z19.object({ type: z19.literal("image"), url: z19.string() })
               ])
             ).nullable()
           }),
-          z18.object({
-            type: z18.literal("image_generation_call"),
-            id: z18.string(),
-            result: z18.string()
+          z19.object({
+            type: z19.literal("image_generation_call"),
+            id: z19.string(),
+            result: z19.string()
           }),
-          z18.object({
-            type: z18.literal("local_shell_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            action: z18.object({
-              type: z18.literal("exec"),
-              command: z18.array(z18.string()),
-              timeout_ms: z18.number().optional(),
-              user: z18.string().optional(),
-              working_directory: z18.string().optional(),
-              env: z18.record(z18.string(), z18.string()).optional()
+          z19.object({
+            type: z19.literal("local_shell_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            action: z19.object({
+              type: z19.literal("exec"),
+              command: z19.array(z19.string()),
+              timeout_ms: z19.number().optional(),
+              user: z19.string().optional(),
+              working_directory: z19.string().optional(),
+              env: z19.record(z19.string(), z19.string()).optional()
             })
           }),
-          z18.object({
-            type: z18.literal("function_call"),
-            call_id: z18.string(),
-            name: z18.string(),
-            arguments: z18.string(),
-            id: z18.string(),
-            async: z18.boolean().nullish()
+          z19.object({
+            type: z19.literal("function_call"),
+            call_id: z19.string(),
+            name: z19.string(),
+            arguments: z19.string(),
+            id: z19.string(),
+            async: z19.boolean().nullish()
           }),
-          z18.object({
-            type: z18.literal("computer_call"),
-            id: z18.string(),
-            status: z18.string().optional()
+          z19.object({
+            type: z19.literal("computer_call"),
+            id: z19.string(),
+            status: z19.string().optional()
           }),
-          z18.object({
-            type: z18.literal("reasoning"),
-            id: z18.string(),
-            encrypted_content: z18.string().nullish(),
-            summary: z18.array(
-              z18.object({
-                type: z18.literal("summary_text"),
-                text: z18.string()
+          z19.object({
+            type: z19.literal("reasoning"),
+            id: z19.string(),
+            encrypted_content: z19.string().nullish(),
+            summary: z19.array(
+              z19.object({
+                type: z19.literal("summary_text"),
+                text: z19.string()
               })
             )
           })
         ])
       ).optional(),
-      service_tier: z18.string().nullish(),
-      reasoning: z18.object({
-        context: z18.string().nullish()
+      service_tier: z19.string().nullish(),
+      prompt_cache_diagnostics: openaiResponsesPromptCacheDiagnosticsSchema().nullish(),
+      reasoning: z19.object({
+        context: z19.string().nullish()
       }).nullish(),
-      incomplete_details: z18.object({ reason: z18.string() }).nullish(),
-      usage: z18.object({
-        input_tokens: z18.number(),
-        input_tokens_details: z18.object({
-          cached_tokens: z18.number().nullish(),
-          cache_write_tokens: z18.number().nullish(),
-          orchestration_input_tokens: z18.number().nullish(),
-          orchestration_input_cached_tokens: z18.number().nullish()
+      incomplete_details: z19.object({ reason: z19.string() }).nullish(),
+      usage: z19.object({
+        input_tokens: z19.number(),
+        input_tokens_details: z19.object({
+          cached_tokens: z19.number().nullish(),
+          cache_write_tokens: z19.number().nullish(),
+          orchestration_input_tokens: z19.number().nullish(),
+          orchestration_input_cached_tokens: z19.number().nullish()
         }).nullish(),
-        output_tokens: z18.number(),
-        output_tokens_details: z18.object({
-          reasoning_tokens: z18.number().nullish(),
-          orchestration_output_tokens: z18.number().nullish()
+        output_tokens: z19.number(),
+        output_tokens_details: z19.object({
+          reasoning_tokens: z19.number().nullish(),
+          orchestration_output_tokens: z19.number().nullish()
         }).nullish()
       }).optional()
     })
@@ -3866,10 +3899,10 @@ function getConfigurationUpdateUnsupportedReason({
   options
 }) {
   if (!modelCapabilities.supportsConfigurationUpdate) {
-    return "reasoningEffortUpdate is only supported by GPT-6 and later models";
+    return "Configuration updates are only supported by GPT-6 and later models";
   }
   if ((options == null ? void 0 : options.reasoningMode) === "pro" || (options == null ? void 0 : options.truncation) === "auto") {
-    return "reasoningEffortUpdate requires standard reasoning mode without automatic truncation";
+    return "Configuration updates require standard reasoning mode without automatic truncation";
   }
   return void 0;
 }
@@ -3901,7 +3934,7 @@ var OpenAIResponsesLanguageModel = class {
     toolChoice,
     responseFormat
   }) {
-    var _a2, _b, _c, _d, _e, _f;
+    var _a2, _b, _c, _d, _e, _f, _g;
     const warnings = [];
     const modelCapabilities = getOpenAILanguageModelCapabilities(this.modelId);
     if (topK != null) {
@@ -3977,7 +4010,7 @@ var OpenAIResponsesLanguageModel = class {
       });
     } else if (reasoningEffortUpdate != null) {
       const firstItem = input[0];
-      if ((firstItem == null ? void 0 : firstItem.type) !== "configuration_update" || firstItem.reasoning.effort !== reasoningEffortUpdate) {
+      if ((firstItem == null ? void 0 : firstItem.type) !== "configuration_update" || ((_c = firstItem.reasoning) == null ? void 0 : _c.effort) !== reasoningEffortUpdate) {
         input.unshift({
           type: "configuration_update",
           reasoning: { effort: reasoningEffortUpdate }
@@ -3987,11 +4020,13 @@ var OpenAIResponsesLanguageModel = class {
     for (let i = 1; i < input.length; i++) {
       if (input[i - 1].type === "configuration_update" && input[i].type === "configuration_update") {
         throw new UnsupportedFunctionalityError6({
-          functionality: "Adjacent reasoning effort configuration updates"
+          functionality: "Adjacent configuration updates",
+          message: "Configuration updates cannot be consecutive. Set reasoningEffortUpdate and textFormatUpdate in the same empty system message, and omit request-level reasoningEffortUpdate when using message-level updates."
         });
       }
     }
-    const strictJsonSchema = (_c = openaiOptions == null ? void 0 : openaiOptions.strictJsonSchema) != null ? _c : false;
+    const strictJsonSchema = (_d = openaiOptions == null ? void 0 : openaiOptions.strictJsonSchema) != null ? _d : false;
+    const requestTextFormat = openaiOptions == null ? void 0 : openaiOptions.textFormat;
     let include = openaiOptions == null ? void 0 : openaiOptions.include;
     function addInclude(key) {
       if (include == null) {
@@ -4025,13 +4060,13 @@ var OpenAIResponsesLanguageModel = class {
       temperature,
       top_p: topP,
       max_output_tokens: maxOutputTokens,
-      ...((responseFormat == null ? void 0 : responseFormat.type) === "json" || (openaiOptions == null ? void 0 : openaiOptions.textVerbosity)) && {
+      ...((responseFormat == null ? void 0 : responseFormat.type) === "json" || requestTextFormat != null || (openaiOptions == null ? void 0 : openaiOptions.textVerbosity)) && {
         text: {
-          ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && {
+          ...requestTextFormat != null ? { format: requestTextFormat } : (responseFormat == null ? void 0 : responseFormat.type) === "json" && {
             format: responseFormat.schema != null ? {
               type: "json_schema",
               strict: strictJsonSchema,
-              name: (_d = responseFormat.name) != null ? _d : "response",
+              name: (_e = responseFormat.name) != null ? _e : "response",
               description: responseFormat.description,
               schema: responseFormat.schema
             } : { type: "json_object" }
@@ -4053,7 +4088,11 @@ var OpenAIResponsesLanguageModel = class {
       service_tier: openaiOptions == null ? void 0 : openaiOptions.serviceTier,
       include,
       prompt_cache_key: openaiOptions == null ? void 0 : openaiOptions.promptCacheKey,
-      prompt_cache_options: openaiOptions == null ? void 0 : openaiOptions.promptCacheOptions,
+      prompt_cache_options: (openaiOptions == null ? void 0 : openaiOptions.promptCacheOptions) && {
+        mode: openaiOptions.promptCacheOptions.mode,
+        ttl: openaiOptions.promptCacheOptions.ttl,
+        comparison_response_id: openaiOptions.promptCacheOptions.comparisonResponseId
+      },
       prompt_cache_retention: openaiOptions == null ? void 0 : openaiOptions.promptCacheRetention,
       safety_identifier: openaiOptions == null ? void 0 : openaiOptions.safetyIdentifier,
       top_logprobs: topLogprobs,
@@ -4102,9 +4141,9 @@ var OpenAIResponsesLanguageModel = class {
             details: "topP is not supported for reasoning models"
           });
         }
-        if (modelCapabilities.supportedReasoningEfforts != null && (baseArgs.top_logprobs != null || ((_e = baseArgs.include) == null ? void 0 : _e.includes("message.output_text.logprobs")))) {
+        if (modelCapabilities.supportedReasoningEfforts != null && (baseArgs.top_logprobs != null || ((_f = baseArgs.include) == null ? void 0 : _f.includes("message.output_text.logprobs")))) {
           baseArgs.top_logprobs = void 0;
-          const filteredInclude = (_f = baseArgs.include) == null ? void 0 : _f.filter(
+          const filteredInclude = (_g = baseArgs.include) == null ? void 0 : _g.filter(
             (value) => value !== "message.output_text.logprobs"
           );
           baseArgs.include = filteredInclude != null && filteredInclude.length > 0 ? filteredInclude : void 0;
@@ -4480,6 +4519,9 @@ var OpenAIResponsesLanguageModel = class {
     if (logprobs.length > 0) {
       providerMetadata[providerKey].logprobs = logprobs;
     }
+    if (response.prompt_cache_diagnostics != null) {
+      providerMetadata[providerKey].promptCacheDiagnostics = response.prompt_cache_diagnostics;
+    }
     if (typeof response.service_tier === "string") {
       providerMetadata[providerKey].serviceTier = response.service_tier;
     }
@@ -4559,6 +4601,7 @@ var OpenAIResponsesLanguageModel = class {
     const activeReasoning = {};
     let serviceTier;
     let reasoningContext;
+    let promptCacheDiagnostics;
     let responsesUsage;
     return {
       stream: response.pipeThrough(
@@ -4567,7 +4610,7 @@ var OpenAIResponsesLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+            var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -4960,20 +5003,21 @@ var OpenAIResponsesLanguageModel = class {
                 activeReasoning[value.item_id].summaryParts[value.summary_index] = "can-conclude";
               }
             } else if (isResponseFinishedChunk(value)) {
+              promptCacheDiagnostics = (_k = value.response.prompt_cache_diagnostics) != null ? _k : void 0;
               finishReason = mapOpenAIResponseFinishReason({
-                finishReason: (_k = value.response.incomplete_details) == null ? void 0 : _k.reason,
+                finishReason: (_l = value.response.incomplete_details) == null ? void 0 : _l.reason,
                 hasFunctionCall,
                 hasRefusal
               });
               usage.inputTokens = value.response.usage.input_tokens;
               usage.outputTokens = value.response.usage.output_tokens;
               usage.totalTokens = value.response.usage.input_tokens + value.response.usage.output_tokens;
-              usage.reasoningTokens = (_m = (_l = value.response.usage.output_tokens_details) == null ? void 0 : _l.reasoning_tokens) != null ? _m : void 0;
-              usage.cachedInputTokens = (_o = (_n = value.response.usage.input_tokens_details) == null ? void 0 : _n.cached_tokens) != null ? _o : void 0;
+              usage.reasoningTokens = (_n = (_m = value.response.usage.output_tokens_details) == null ? void 0 : _m.reasoning_tokens) != null ? _n : void 0;
+              usage.cachedInputTokens = (_p = (_o = value.response.usage.input_tokens_details) == null ? void 0 : _o.cached_tokens) != null ? _p : void 0;
               if (typeof value.response.service_tier === "string") {
                 serviceTier = value.response.service_tier;
               }
-              if (((_p = value.response.reasoning) == null ? void 0 : _p.context) != null) {
+              if (((_q = value.response.reasoning) == null ? void 0 : _q.context) != null) {
                 reasoningContext = value.response.reasoning.context;
               }
               responsesUsage = getResponsesUsageMetadata(value.response.usage);
@@ -4983,7 +5027,7 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "url",
-                  id: (_s = (_r = (_q = self.config).generateId) == null ? void 0 : _r.call(_q)) != null ? _s : generateId2(),
+                  id: (_t = (_s = (_r = self.config).generateId) == null ? void 0 : _s.call(_r)) != null ? _t : generateId2(),
                   url: value.annotation.url,
                   title: value.annotation.title
                 });
@@ -4991,10 +5035,10 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "document",
-                  id: (_v = (_u = (_t = self.config).generateId) == null ? void 0 : _u.call(_t)) != null ? _v : generateId2(),
+                  id: (_w = (_v = (_u = self.config).generateId) == null ? void 0 : _v.call(_u)) != null ? _w : generateId2(),
                   mediaType: "text/plain",
-                  title: (_x = (_w = value.annotation.quote) != null ? _w : value.annotation.filename) != null ? _x : "Document",
-                  filename: (_y = value.annotation.filename) != null ? _y : value.annotation.file_id,
+                  title: (_y = (_x = value.annotation.quote) != null ? _x : value.annotation.filename) != null ? _y : "Document",
+                  filename: (_z = value.annotation.filename) != null ? _z : value.annotation.file_id,
                   ...value.annotation.file_id ? {
                     providerMetadata: {
                       [providerKey]: {
@@ -5023,6 +5067,9 @@ var OpenAIResponsesLanguageModel = class {
             if (reasoningContext !== void 0) {
               providerMetadata[providerKey].reasoningContext = reasoningContext;
             }
+            if (promptCacheDiagnostics !== void 0) {
+              providerMetadata[providerKey].promptCacheDiagnostics = promptCacheDiagnostics;
+            }
             if (responsesUsage != null) {
               providerMetadata[providerKey].usage = responsesUsage;
             }
@@ -5138,12 +5185,12 @@ import {
   lazyValidator as lazyValidator11,
   zodSchema as zodSchema19
 } from "@ai-sdk/provider-utils";
-import { z as z19 } from "zod/v4";
+import { z as z20 } from "zod/v4";
 var openaiSpeechProviderOptionsSchema = lazyValidator11(
   () => zodSchema19(
-    z19.object({
-      instructions: z19.string().nullish(),
-      speed: z19.number().min(0.25).max(4).default(1).nullish()
+    z20.object({
+      instructions: z20.string().nullish(),
+      speed: z20.number().min(0.25).max(4).default(1).nullish()
     })
   )
 );
@@ -5261,38 +5308,38 @@ import {
 
 // src/transcription/openai-transcription-api.ts
 import { lazyValidator as lazyValidator12, zodSchema as zodSchema20 } from "@ai-sdk/provider-utils";
-import { z as z20 } from "zod/v4";
+import { z as z21 } from "zod/v4";
 var openaiTranscriptionResponseSchema = lazyValidator12(
   () => zodSchema20(
-    z20.object({
-      text: z20.string(),
-      language: z20.string().nullish(),
-      duration: z20.number().nullish(),
-      words: z20.array(
-        z20.object({
-          word: z20.string(),
-          start: z20.number(),
-          end: z20.number()
+    z21.object({
+      text: z21.string(),
+      language: z21.string().nullish(),
+      duration: z21.number().nullish(),
+      words: z21.array(
+        z21.object({
+          word: z21.string(),
+          start: z21.number(),
+          end: z21.number()
         })
       ).nullish(),
-      segments: z20.array(
-        z20.object({
-          id: z20.number(),
-          seek: z20.number(),
-          start: z20.number(),
-          end: z20.number(),
-          text: z20.string(),
-          tokens: z20.array(z20.number()),
-          temperature: z20.number(),
-          avg_logprob: z20.number(),
-          compression_ratio: z20.number(),
-          no_speech_prob: z20.number()
+      segments: z21.array(
+        z21.object({
+          id: z21.number(),
+          seek: z21.number(),
+          start: z21.number(),
+          end: z21.number(),
+          text: z21.string(),
+          tokens: z21.array(z21.number()),
+          temperature: z21.number(),
+          avg_logprob: z21.number(),
+          compression_ratio: z21.number(),
+          no_speech_prob: z21.number()
         })
       ).nullish(),
       // Lenient: an unexpected usage shape must not fail the transcription.
-      usage: z20.object({
-        type: z20.string().nullish(),
-        seconds: z20.number().nullish()
+      usage: z21.object({
+        type: z21.string().nullish(),
+        seconds: z21.number().nullish()
       }).nullish().catch(void 0)
     })
   )
@@ -5303,42 +5350,42 @@ import {
   lazyValidator as lazyValidator13,
   zodSchema as zodSchema21
 } from "@ai-sdk/provider-utils";
-import { z as z21 } from "zod/v4";
+import { z as z22 } from "zod/v4";
 var openAITranscriptionProviderOptions = lazyValidator13(
   () => zodSchema21(
-    z21.object({
+    z22.object({
       /**
        * Additional information to include in the transcription response.
        */
-      include: z21.array(z21.string()).optional(),
+      include: z22.array(z22.string()).optional(),
       /**
        * The language of the input audio in ISO-639-1 format.
        */
-      language: z21.string().optional(),
+      language: z22.string().optional(),
       /**
        * Expected languages for REST transcription, e.g. with gpt-transcribe.
        * Use this instead of language. The API validates model support.
        */
-      languages: z21.array(z21.string()).optional(),
+      languages: z22.array(z22.string()).optional(),
       /**
        * Vocabulary hints for REST transcription, e.g. names or technical terms.
        * The API validates model support.
        */
-      keywords: z21.array(z21.string()).optional(),
+      keywords: z22.array(z22.string()).optional(),
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */
-      prompt: z21.string().optional(),
+      prompt: z22.string().optional(),
       /**
        * The sampling temperature, between 0 and 1.
        * @default 0
        */
-      temperature: z21.number().min(0).max(1).default(0).optional(),
+      temperature: z22.number().min(0).max(1).default(0).optional(),
       /**
        * The timestamp granularities to populate for this transcription.
        * @default ['segment']
        */
-      timestampGranularities: z21.array(z21.enum(["word", "segment"])).default(["segment"]).optional()
+      timestampGranularities: z22.array(z22.enum(["word", "segment"])).default(["segment"]).optional()
     })
   )
 );
@@ -5514,7 +5561,7 @@ var OpenAITranscriptionModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "2.0.142" : "0.0.0-test";
+var VERSION = true ? "2.0.143" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {