@ai-sdk/openai 2.0.0-canary.14 → 2.0.0-canary.16

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @ai-sdk/openai
 
+## 2.0.0-canary.16
+
+### Patch Changes
+
+- 928fadf: fix(providers/openai): logprobs for stream alongside completion model
+- 6f231db: fix(providers): always use optional instead of mix of nullish for providerOptions
+- Updated dependencies [a571d6e]
+- Updated dependencies [a8c8bd5]
+- Updated dependencies [7979f7f]
+- Updated dependencies [41fa418]
+  - @ai-sdk/provider-utils@3.0.0-canary.15
+  - @ai-sdk/provider@2.0.0-canary.14
+
+## 2.0.0-canary.15
+
+### Patch Changes
+
+- 136819b: chore(providers/openai): re-introduce logprobs as providerMetadata
+- 9bd5ab5: feat (provider): add providerMetadata to ImageModelV2 interface (#5977)
+
+  The `experimental_generateImage` method from the `ai` package now returnes revised prompts for OpenAI's image models.
+
+  ```js
+  const prompt = 'Santa Claus driving a Cadillac';
+
+  const { providerMetadata } = await experimental_generateImage({
+    model: openai.image('dall-e-3'),
+    prompt,
+  });
+
+  const revisedPrompt = providerMetadata.openai.images[0]?.revisedPrompt;
+
+  console.log({
+    prompt,
+    revisedPrompt,
+  });
+  ```
+
+- 284353f: fix(providers/openai): zod parse error with function
+- Updated dependencies [957b739]
+- Updated dependencies [9bd5ab5]
+  - @ai-sdk/provider-utils@3.0.0-canary.14
+  - @ai-sdk/provider@2.0.0-canary.13
+
 ## 2.0.0-canary.14
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # AI SDK - OpenAI Provider
 
-The **[OpenAI provider](https://sdk.vercel.ai/providers/ai-sdk-providers/openai)** for the [AI SDK](https://sdk.vercel.ai/docs)
+The **[OpenAI provider](https://ai-sdk.dev/providers/ai-sdk-providers/openai)** for the [AI SDK](https://ai-sdk.dev/docs)
 contains language model support for the OpenAI chat and completion APIs and embedding model support for the OpenAI embeddings API.
 
 ## Setup
@@ -33,4 +33,4 @@ const { text } = await generateText({
 
 ## Documentation
 
-Please check out the **[OpenAI provider documentation](https://sdk.vercel.ai/providers/ai-sdk-providers/openai)** for more information.
+Please check out the **[OpenAI provider documentation](https://ai-sdk.dev/providers/ai-sdk-providers/openai)** for more information.

package/dist/index.js

@@ -238,6 +238,16 @@ var openaiProviderOptions = import_zod.z.object({
    * the GPT tokenizer) to an associated bias value from -100 to 100.
    */
   logitBias: import_zod.z.record(import_zod.z.coerce.number(), import_zod.z.number()).optional(),
+  /**
+   * Return the log probabilities of the tokens.
+   *
+   * 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.
+   */
+  logprobs: import_zod.z.union([import_zod.z.boolean(), import_zod.z.number()]).optional(),
   /**
    * Whether to enable parallel function calling during tool use. Default to true.
    */
@@ -412,6 +422,8 @@ var OpenAIChatLanguageModel = class {
       model: this.modelId,
       // model specific settings:
       logit_bias: openaiOptions.logitBias,
+      logprobs: openaiOptions.logprobs === true || typeof openaiOptions.logprobs === "number" ? true : void 0,
+      top_logprobs: typeof openaiOptions.logprobs === "number" ? openaiOptions.logprobs : typeof openaiOptions.logprobs === "boolean" ? openaiOptions.logprobs ? 0 : void 0 : void 0,
       user: openaiOptions.user,
       parallel_tool_calls: openaiOptions.parallelToolCalls,
       // standardized settings:
@@ -484,6 +496,20 @@ var OpenAIChatLanguageModel = class {
           message: "logitBias is not supported for reasoning models"
         });
       }
+      if (baseArgs.logprobs != null) {
+        baseArgs.logprobs = void 0;
+        warnings.push({
+          type: "other",
+          message: "logprobs is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.top_logprobs != null) {
+        baseArgs.top_logprobs = void 0;
+        warnings.push({
+          type: "other",
+          message: "topLogprobs is not supported for reasoning models"
+        });
+      }
       if (baseArgs.max_tokens != null) {
         if (baseArgs.max_completion_tokens == null) {
           baseArgs.max_completion_tokens = baseArgs.max_tokens;
@@ -519,7 +545,7 @@ var OpenAIChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
     const { args: body, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
@@ -557,24 +583,24 @@ var OpenAIChatLanguageModel = class {
     const completionTokenDetails = (_c = response.usage) == null ? void 0 : _c.completion_tokens_details;
     const promptTokenDetails = (_d = response.usage) == null ? void 0 : _d.prompt_tokens_details;
     const providerMetadata = { openai: {} };
-    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens) != null) {
-      providerMetadata.openai.reasoningTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens;
-    }
     if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
       providerMetadata.openai.acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
     }
     if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
       providerMetadata.openai.rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
     }
-    if ((promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens) != null) {
-      providerMetadata.openai.cachedPromptTokens = promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens;
+    if (((_e = choice.logprobs) == null ? void 0 : _e.content) != null) {
+      providerMetadata.openai.logprobs = choice.logprobs.content;
     }
     return {
       content,
       finishReason: mapOpenAIFinishReason(choice.finish_reason),
       usage: {
-        inputTokens: (_f = (_e = response.usage) == null ? void 0 : _e.prompt_tokens) != null ? _f : void 0,
-        outputTokens: (_h = (_g = response.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : void 0
+        inputTokens: (_g = (_f = response.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : void 0,
+        outputTokens: (_i = (_h = response.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : void 0,
+        totalTokens: (_k = (_j = response.usage) == null ? void 0 : _j.total_tokens) != null ? _k : void 0,
+        reasoningTokens: (_l = completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens) != null ? _l : void 0,
+        cachedInputTokens: (_m = promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens) != null ? _m : void 0
       },
       request: { body },
       response: {
@@ -608,12 +634,12 @@ var OpenAIChatLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { messages: rawPrompt, ...rawSettings } = args;
     const toolCalls = [];
     let finishReason = "unknown";
     const usage = {
       inputTokens: void 0,
-      outputTokens: void 0
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let isFirstChunk = true;
     const providerMetadata = { openai: {} };
@@ -624,7 +650,7 @@ var OpenAIChatLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -644,31 +670,25 @@ var OpenAIChatLanguageModel = class {
               });
             }
             if (value.usage != null) {
-              const {
-                prompt_tokens,
-                completion_tokens,
-                prompt_tokens_details,
-                completion_tokens_details
-              } = value.usage;
-              usage.inputTokens = prompt_tokens != null ? prompt_tokens : void 0;
-              usage.outputTokens = completion_tokens != null ? completion_tokens : void 0;
-              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens) != null) {
-                providerMetadata.openai.reasoningTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens;
-              }
-              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.accepted_prediction_tokens) != null) {
-                providerMetadata.openai.acceptedPredictionTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.accepted_prediction_tokens;
+              usage.inputTokens = (_a = value.usage.prompt_tokens) != null ? _a : void 0;
+              usage.outputTokens = (_b = value.usage.completion_tokens) != null ? _b : void 0;
+              usage.totalTokens = (_c = value.usage.total_tokens) != null ? _c : void 0;
+              usage.reasoningTokens = (_e = (_d = value.usage.completion_tokens_details) == null ? void 0 : _d.reasoning_tokens) != null ? _e : void 0;
+              usage.cachedInputTokens = (_g = (_f = value.usage.prompt_tokens_details) == null ? void 0 : _f.cached_tokens) != null ? _g : void 0;
+              if (((_h = value.usage.completion_tokens_details) == null ? void 0 : _h.accepted_prediction_tokens) != null) {
+                providerMetadata.openai.acceptedPredictionTokens = (_i = value.usage.completion_tokens_details) == null ? void 0 : _i.accepted_prediction_tokens;
               }
-              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.rejected_prediction_tokens) != null) {
-                providerMetadata.openai.rejectedPredictionTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.rejected_prediction_tokens;
-              }
-              if ((prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens) != null) {
-                providerMetadata.openai.cachedPromptTokens = prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens;
+              if (((_j = value.usage.completion_tokens_details) == null ? void 0 : _j.rejected_prediction_tokens) != null) {
+                providerMetadata.openai.rejectedPredictionTokens = (_k = value.usage.completion_tokens_details) == null ? void 0 : _k.rejected_prediction_tokens;
               }
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
               finishReason = mapOpenAIFinishReason(choice.finish_reason);
             }
+            if (((_l = choice == null ? void 0 : choice.logprobs) == null ? void 0 : _l.content) != null) {
+              providerMetadata.openai.logprobs = choice.logprobs.content;
+            }
             if ((choice == null ? void 0 : choice.delta) == null) {
               return;
             }
@@ -695,7 +715,7 @@ var OpenAIChatLanguageModel = class {
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_a = toolCallDelta.function) == null ? void 0 : _a.name) == null) {
+                  if (((_m = toolCallDelta.function) == null ? void 0 : _m.name) == null) {
                     throw new import_provider3.InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
@@ -706,12 +726,12 @@ var OpenAIChatLanguageModel = class {
                     type: "function",
                     function: {
                       name: toolCallDelta.function.name,
-                      arguments: (_b = toolCallDelta.function.arguments) != null ? _b : ""
+                      arguments: (_n = toolCallDelta.function.arguments) != null ? _n : ""
                     },
                     hasFinished: false
                   };
                   const toolCall2 = toolCalls[index];
-                  if (((_c = toolCall2.function) == null ? void 0 : _c.name) != null && ((_d = toolCall2.function) == null ? void 0 : _d.arguments) != null) {
+                  if (((_o = toolCall2.function) == null ? void 0 : _o.name) != null && ((_p = toolCall2.function) == null ? void 0 : _p.arguments) != null) {
                     if (toolCall2.function.arguments.length > 0) {
                       controller.enqueue({
                         type: "tool-call-delta",
@@ -725,7 +745,7 @@ var OpenAIChatLanguageModel = class {
                       controller.enqueue({
                         type: "tool-call",
                         toolCallType: "function",
-                        toolCallId: (_e = toolCall2.id) != null ? _e : (0, import_provider_utils3.generateId)(),
+                        toolCallId: (_q = toolCall2.id) != null ? _q : (0, import_provider_utils3.generateId)(),
                         toolName: toolCall2.function.name,
                         args: toolCall2.function.arguments
                       });
@@ -738,21 +758,21 @@ var OpenAIChatLanguageModel = class {
                 if (toolCall.hasFinished) {
                   continue;
                 }
-                if (((_f = toolCallDelta.function) == null ? void 0 : _f.arguments) != null) {
-                  toolCall.function.arguments += (_h = (_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null ? _h : "";
+                if (((_r = toolCallDelta.function) == null ? void 0 : _r.arguments) != null) {
+                  toolCall.function.arguments += (_t = (_s = toolCallDelta.function) == null ? void 0 : _s.arguments) != null ? _t : "";
                 }
                 controller.enqueue({
                   type: "tool-call-delta",
                   toolCallType: "function",
                   toolCallId: toolCall.id,
                   toolName: toolCall.function.name,
-                  argsTextDelta: (_i = toolCallDelta.function.arguments) != null ? _i : ""
+                  argsTextDelta: (_u = toolCallDelta.function.arguments) != null ? _u : ""
                 });
-                if (((_j = toolCall.function) == null ? void 0 : _j.name) != null && ((_k = toolCall.function) == null ? void 0 : _k.arguments) != null && (0, import_provider_utils3.isParsableJson)(toolCall.function.arguments)) {
+                if (((_v = toolCall.function) == null ? void 0 : _v.name) != null && ((_w = toolCall.function) == null ? void 0 : _w.arguments) != null && (0, import_provider_utils3.isParsableJson)(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-call",
                     toolCallType: "function",
-                    toolCallId: (_l = toolCall.id) != null ? _l : (0, import_provider_utils3.generateId)(),
+                    toolCallId: (_x = toolCall.id) != null ? _x : (0, import_provider_utils3.generateId)(),
                     toolName: toolCall.function.name,
                     args: toolCall.function.arguments
                   });
@@ -779,6 +799,7 @@ var OpenAIChatLanguageModel = class {
 var openaiTokenUsageSchema = import_zod3.z.object({
   prompt_tokens: import_zod3.z.number().nullish(),
   completion_tokens: import_zod3.z.number().nullish(),
+  total_tokens: import_zod3.z.number().nullish(),
   prompt_tokens_details: import_zod3.z.object({
     cached_tokens: import_zod3.z.number().nullish()
   }).nullish(),
@@ -809,6 +830,20 @@ var openaiChatResponseSchema = import_zod3.z.object({
         ).nullish()
       }),
       index: import_zod3.z.number(),
+      logprobs: import_zod3.z.object({
+        content: import_zod3.z.array(
+          import_zod3.z.object({
+            token: import_zod3.z.string(),
+            logprob: import_zod3.z.number(),
+            top_logprobs: import_zod3.z.array(
+              import_zod3.z.object({
+                token: import_zod3.z.string(),
+                logprob: import_zod3.z.number()
+              })
+            )
+          })
+        ).nullish()
+      }).nullish(),
       finish_reason: import_zod3.z.string().nullish()
     })
   ),
@@ -828,7 +863,7 @@ var openaiChatChunkSchema = import_zod3.z.union([
             import_zod3.z.object({
               index: import_zod3.z.number(),
               id: import_zod3.z.string().nullish(),
-              type: import_zod3.z.literal("function").optional(),
+              type: import_zod3.z.literal("function").nullish(),
               function: import_zod3.z.object({
                 name: import_zod3.z.string().nullish(),
                 arguments: import_zod3.z.string().nullish()
@@ -836,7 +871,21 @@ var openaiChatChunkSchema = import_zod3.z.union([
             })
           ).nullish()
         }).nullish(),
-        finish_reason: import_zod3.z.string().nullable().optional(),
+        logprobs: import_zod3.z.object({
+          content: import_zod3.z.array(
+            import_zod3.z.object({
+              token: import_zod3.z.string(),
+              logprob: import_zod3.z.number(),
+              top_logprobs: import_zod3.z.array(
+                import_zod3.z.object({
+                  token: import_zod3.z.string(),
+                  logprob: import_zod3.z.number()
+                })
+              )
+            })
+          ).nullish()
+        }).nullish(),
+        finish_reason: import_zod3.z.string().nullish(),
         index: import_zod3.z.number()
       })
     ),
@@ -996,7 +1045,17 @@ var openaiCompletionProviderOptions = import_zod4.z.object({
   A unique identifier representing your end-user, which can help OpenAI to
   monitor and detect abuse. Learn more.
    */
-  user: import_zod4.z.string().optional()
+  user: import_zod4.z.string().optional(),
+  /**
+  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.
+     */
+  logprobs: import_zod4.z.union([import_zod4.z.boolean(), import_zod4.z.number()]).optional()
 });
 
 // src/openai-completion-language-model.ts
@@ -1068,6 +1127,7 @@ var OpenAICompletionLanguageModel = class {
         // model specific settings:
         echo: openaiOptions.echo,
         logit_bias: openaiOptions.logitBias,
+        logprobs: (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? 0 : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === false ? void 0 : openaiOptions == null ? void 0 : openaiOptions.logprobs,
         suffix: openaiOptions.suffix,
         user: openaiOptions.user,
         // standardized settings:
@@ -1086,6 +1146,7 @@ var OpenAICompletionLanguageModel = class {
     };
   }
   async doGenerate(options) {
+    var _a, _b, _c;
     const { args, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
@@ -1106,11 +1167,16 @@ var OpenAICompletionLanguageModel = class {
       fetch: this.config.fetch
     });
     const choice = response.choices[0];
+    const providerMetadata = { openai: {} };
+    if (choice.logprobs != null) {
+      providerMetadata.openai.logprobs = choice.logprobs;
+    }
     return {
       content: [{ type: "text", text: choice.text }],
       usage: {
-        inputTokens: response.usage.prompt_tokens,
-        outputTokens: response.usage.completion_tokens
+        inputTokens: (_a = response.usage) == null ? void 0 : _a.prompt_tokens,
+        outputTokens: (_b = response.usage) == null ? void 0 : _b.completion_tokens,
+        totalTokens: (_c = response.usage) == null ? void 0 : _c.total_tokens
       },
       finishReason: mapOpenAIFinishReason(choice.finish_reason),
       request: { body: args },
@@ -1119,6 +1185,7 @@ var OpenAICompletionLanguageModel = class {
         headers: responseHeaders,
         body: rawResponse
       },
+      providerMetadata,
       warnings
     };
   }
@@ -1145,9 +1212,11 @@ var OpenAICompletionLanguageModel = class {
       fetch: this.config.fetch
     });
     let finishReason = "unknown";
+    const providerMetadata = { openai: {} };
     const usage = {
       inputTokens: void 0,
-      outputTokens: void 0
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let isFirstChunk = true;
     return {
@@ -1178,11 +1247,15 @@ var OpenAICompletionLanguageModel = class {
             if (value.usage != null) {
               usage.inputTokens = value.usage.prompt_tokens;
               usage.outputTokens = value.usage.completion_tokens;
+              usage.totalTokens = value.usage.total_tokens;
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
               finishReason = mapOpenAIFinishReason(choice.finish_reason);
             }
+            if ((choice == null ? void 0 : choice.logprobs) != null) {
+              providerMetadata.openai.logprobs = choice.logprobs;
+            }
             if ((choice == null ? void 0 : choice.text) != null) {
               controller.enqueue({
                 type: "text",
@@ -1194,6 +1267,7 @@ var OpenAICompletionLanguageModel = class {
             controller.enqueue({
               type: "finish",
               finishReason,
+              providerMetadata,
               usage
             });
           }
@@ -1204,6 +1278,11 @@ var OpenAICompletionLanguageModel = class {
     };
   }
 };
+var usageSchema = import_zod5.z.object({
+  prompt_tokens: import_zod5.z.number(),
+  completion_tokens: import_zod5.z.number(),
+  total_tokens: import_zod5.z.number()
+});
 var openaiCompletionResponseSchema = import_zod5.z.object({
   id: import_zod5.z.string().nullish(),
   created: import_zod5.z.number().nullish(),
@@ -1211,13 +1290,15 @@ var openaiCompletionResponseSchema = import_zod5.z.object({
   choices: import_zod5.z.array(
     import_zod5.z.object({
       text: import_zod5.z.string(),
-      finish_reason: import_zod5.z.string()
+      finish_reason: import_zod5.z.string(),
+      logprobs: import_zod5.z.object({
+        tokens: import_zod5.z.array(import_zod5.z.string()),
+        token_logprobs: import_zod5.z.array(import_zod5.z.number()),
+        top_logprobs: import_zod5.z.array(import_zod5.z.record(import_zod5.z.string(), import_zod5.z.number())).nullish()
+      }).nullish()
     })
   ),
-  usage: import_zod5.z.object({
-    prompt_tokens: import_zod5.z.number(),
-    completion_tokens: import_zod5.z.number()
-  })
+  usage: usageSchema.nullish()
 });
 var openaiCompletionChunkSchema = import_zod5.z.union([
   import_zod5.z.object({
@@ -1228,13 +1309,15 @@ var openaiCompletionChunkSchema = import_zod5.z.union([
       import_zod5.z.object({
         text: import_zod5.z.string(),
         finish_reason: import_zod5.z.string().nullish(),
-        index: import_zod5.z.number()
+        index: import_zod5.z.number(),
+        logprobs: import_zod5.z.object({
+          tokens: import_zod5.z.array(import_zod5.z.string()),
+          token_logprobs: import_zod5.z.array(import_zod5.z.number()),
+          top_logprobs: import_zod5.z.array(import_zod5.z.record(import_zod5.z.string(), import_zod5.z.number())).nullish()
+        }).nullish()
       })
     ),
-    usage: import_zod5.z.object({
-      prompt_tokens: import_zod5.z.number(),
-      completion_tokens: import_zod5.z.number()
-    }).nullish()
+    usage: usageSchema.nullish()
   }),
   openaiErrorDataSchema
 ]);
@@ -1405,12 +1488,23 @@ var OpenAIImageModel = class {
         timestamp: currentDate,
         modelId: this.modelId,
         headers: responseHeaders
+      },
+      providerMetadata: {
+        openai: {
+          images: response.data.map(
+            (item) => item.revised_prompt ? {
+              revisedPrompt: item.revised_prompt
+            } : null
+          )
+        }
       }
     };
   }
 };
 var openaiImageResponseSchema = import_zod8.z.object({
-  data: import_zod8.z.array(import_zod8.z.object({ b64_json: import_zod8.z.string() }))
+  data: import_zod8.z.array(
+    import_zod8.z.object({ b64_json: import_zod8.z.string(), revised_prompt: import_zod8.z.string().optional() })
+  )
 });
 
 // src/openai-tools.ts
@@ -1444,25 +1538,25 @@ var openAITranscriptionProviderOptions = import_zod10.z.object({
   /**
    * Additional information to include in the transcription response.
    */
-  include: import_zod10.z.array(import_zod10.z.string()).nullish(),
+  include: import_zod10.z.array(import_zod10.z.string()).optional(),
   /**
    * The language of the input audio in ISO-639-1 format.
    */
-  language: import_zod10.z.string().nullish(),
+  language: import_zod10.z.string().optional(),
   /**
    * An optional text to guide the model's style or continue a previous audio segment.
    */
-  prompt: import_zod10.z.string().nullish(),
+  prompt: import_zod10.z.string().optional(),
   /**
    * The sampling temperature, between 0 and 1.
    * @default 0
    */
-  temperature: import_zod10.z.number().min(0).max(1).default(0).nullish(),
+  temperature: import_zod10.z.number().min(0).max(1).default(0).optional(),
   /**
    * The timestamp granularities to populate for this transcription.
    * @default ['segment']
    */
-  timestampGranularities: import_zod10.z.array(import_zod10.z.enum(["word", "segment"])).default(["segment"]).nullish()
+  timestampGranularities: import_zod10.z.array(import_zod10.z.enum(["word", "segment"])).default(["segment"]).optional()
 });
 
 // src/openai-transcription-model.ts
@@ -2033,7 +2127,7 @@ var OpenAIResponsesLanguageModel = class {
             ])
           ),
           incomplete_details: import_zod12.z.object({ reason: import_zod12.z.string() }).nullable(),
-          usage: usageSchema
+          usage: usageSchema2
         })
       ),
       abortSignal: options.abortSignal,
@@ -2087,7 +2181,10 @@ var OpenAIResponsesLanguageModel = class {
       }),
       usage: {
         inputTokens: response.usage.input_tokens,
-        outputTokens: response.usage.output_tokens
+        outputTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+        reasoningTokens: (_f = (_e = response.usage.output_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : void 0,
+        cachedInputTokens: (_h = (_g = response.usage.input_tokens_details) == null ? void 0 : _g.cached_tokens) != null ? _h : void 0
       },
       request: { body },
       response: {
@@ -2099,9 +2196,7 @@ var OpenAIResponsesLanguageModel = class {
       },
       providerMetadata: {
         openai: {
-          responseId: response.id,
-          cachedPromptTokens: (_f = (_e = response.usage.input_tokens_details) == null ? void 0 : _e.cached_tokens) != null ? _f : null,
-          reasoningTokens: (_h = (_g = response.usage.output_tokens_details) == null ? void 0 : _g.reasoning_tokens) != null ? _h : null
+          responseId: response.id
         }
       },
       warnings
@@ -2130,10 +2225,9 @@ var OpenAIResponsesLanguageModel = class {
     let finishReason = "unknown";
     const usage = {
       inputTokens: void 0,
-      outputTokens: void 0
+      outputTokens: void 0,
+      totalTokens: void 0
     };
-    let cachedPromptTokens = null;
-    let reasoningTokens = null;
     let responseId = null;
     const ongoingToolCalls = {};
     let hasToolCalls = false;
@@ -2211,8 +2305,9 @@ var OpenAIResponsesLanguageModel = class {
               });
               usage.inputTokens = value.response.usage.input_tokens;
               usage.outputTokens = value.response.usage.output_tokens;
-              cachedPromptTokens = (_c = (_b = value.response.usage.input_tokens_details) == null ? void 0 : _b.cached_tokens) != null ? _c : cachedPromptTokens;
-              reasoningTokens = (_e = (_d = value.response.usage.output_tokens_details) == null ? void 0 : _d.reasoning_tokens) != null ? _e : reasoningTokens;
+              usage.totalTokens = value.response.usage.input_tokens + value.response.usage.output_tokens;
+              usage.reasoningTokens = (_c = (_b = value.response.usage.output_tokens_details) == null ? void 0 : _b.reasoning_tokens) != null ? _c : void 0;
+              usage.cachedInputTokens = (_e = (_d = value.response.usage.input_tokens_details) == null ? void 0 : _d.cached_tokens) != null ? _e : void 0;
             } else if (isResponseAnnotationAddedChunk(value)) {
               controller.enqueue({
                 type: "source",
@@ -2228,13 +2323,9 @@ var OpenAIResponsesLanguageModel = class {
               type: "finish",
               finishReason,
               usage,
-              ...(cachedPromptTokens != null || reasoningTokens != null) && {
-                providerMetadata: {
-                  openai: {
-                    responseId,
-                    cachedPromptTokens,
-                    reasoningTokens
-                  }
+              providerMetadata: {
+                openai: {
+                  responseId
                 }
               }
             });
@@ -2246,7 +2337,7 @@ var OpenAIResponsesLanguageModel = class {
     };
   }
 };
-var usageSchema = import_zod12.z.object({
+var usageSchema2 = import_zod12.z.object({
   input_tokens: import_zod12.z.number(),
   input_tokens_details: import_zod12.z.object({ cached_tokens: import_zod12.z.number().nullish() }).nullish(),
   output_tokens: import_zod12.z.number(),
@@ -2260,7 +2351,7 @@ var responseFinishedChunkSchema = import_zod12.z.object({
   type: import_zod12.z.enum(["response.completed", "response.incomplete"]),
   response: import_zod12.z.object({
     incomplete_details: import_zod12.z.object({ reason: import_zod12.z.string() }).nullish(),
-    usage: usageSchema
+    usage: usageSchema2
   })
 });
 var responseCreatedChunkSchema = import_zod12.z.object({