@ai-sdk/openai-compatible 1.0.0-canary.5 → 1.0.0-canary.7

package/dist/index.js

@@ -31,7 +31,7 @@ module.exports = __toCommonJS(src_exports);
 // src/openai-compatible-chat-language-model.ts
 var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/convert-to-openai-compatible-chat-messages.ts
 var import_provider = require("@ai-sdk/provider");
@@ -170,17 +170,27 @@ function mapOpenAICompatibleFinishReason(finishReason) {
   }
 }
 
-// src/openai-compatible-error.ts
+// src/openai-compatible-chat-options.ts
 var import_zod = require("zod");
-var openaiCompatibleErrorDataSchema = import_zod.z.object({
-  error: import_zod.z.object({
-    message: import_zod.z.string(),
+var openaiCompatibleProviderOptions = import_zod.z.object({
+  /**
+   * A unique identifier representing your end-user, which can help the provider to
+   * monitor and detect abuse.
+   */
+  user: import_zod.z.string().optional()
+});
+
+// src/openai-compatible-error.ts
+var import_zod2 = require("zod");
+var openaiCompatibleErrorDataSchema = import_zod2.z.object({
+  error: import_zod2.z.object({
+    message: import_zod2.z.string(),
     // The additional information below is handled loosely to support
     // OpenAI-compatible providers that have slightly different error
     // responses:
-    type: import_zod.z.string().nullish(),
-    param: import_zod.z.any().nullish(),
-    code: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).nullish()
+    type: import_zod2.z.string().nullish(),
+    param: import_zod2.z.any().nullish(),
+    code: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).nullish()
   })
 });
 var defaultOpenAICompatibleErrorStructure = {
@@ -244,11 +254,10 @@ function prepareTools({
 // src/openai-compatible-chat-language-model.ts
 var OpenAICompatibleChatLanguageModel = class {
   // type inferred via constructor
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.specificationVersion = "v2";
     var _a, _b;
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
     const errorStructure = (_a = config.errorStructure) != null ? _a : defaultOpenAICompatibleErrorStructure;
     this.chunkSchema = createOpenAICompatibleChatChunkSchema(
@@ -268,7 +277,7 @@ var OpenAICompatibleChatLanguageModel = class {
   }
   getArgs({
     prompt,
-    maxTokens,
+    maxOutputTokens,
     temperature,
     topP,
     topK,
@@ -281,8 +290,20 @@ var OpenAICompatibleChatLanguageModel = class {
     toolChoice,
     tools
   }) {
-    var _a;
+    var _a, _b, _c;
     const warnings = [];
+    const compatibleOptions = Object.assign(
+      (_a = (0, import_provider_utils.parseProviderOptions)({
+        provider: "openai-compatible",
+        providerOptions,
+        schema: openaiCompatibleProviderOptions
+      })) != null ? _a : {},
+      (_b = (0, import_provider_utils.parseProviderOptions)({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleProviderOptions
+      })) != null ? _b : {}
+    );
     if (topK != null) {
       warnings.push({ type: "unsupported-setting", setting: "topK" });
     }
@@ -306,9 +327,9 @@ var OpenAICompatibleChatLanguageModel = class {
         // model id:
         model: this.modelId,
         // model specific settings:
-        user: this.settings.user,
+        user: compatibleOptions.user,
         // standardized settings:
-        max_tokens: maxTokens,
+        max_tokens: maxOutputTokens,
         temperature,
         top_p: topP,
         frequency_penalty: frequencyPenalty,
@@ -317,7 +338,7 @@ var OpenAICompatibleChatLanguageModel = class {
           type: "json_schema",
           json_schema: {
             schema: responseFormat.schema,
-            name: (_a = responseFormat.name) != null ? _a : "response",
+            name: (_c = responseFormat.name) != null ? _c : "response",
             description: responseFormat.description
           }
         } : { type: "json_object" } : void 0,
@@ -334,7 +355,7 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const { args, warnings } = this.getArgs({ ...options });
     const body = JSON.stringify(args);
     const {
@@ -378,11 +399,18 @@ var OpenAICompatibleChatLanguageModel = class {
       providerMetadata[this.providerOptionsName].cachedPromptTokens = promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens;
     }
     return {
-      text: (_e = choice.message.content) != null ? _e : void 0,
-      reasoning: (_f = choice.message.reasoning_content) != null ? _f : void 0,
-      toolCalls: (_g = choice.message.tool_calls) == null ? void 0 : _g.map((toolCall) => {
+      text: choice.message.content != null ? { type: "text", text: choice.message.content } : void 0,
+      reasoning: choice.message.reasoning_content ? [
+        {
+          type: "reasoning",
+          reasoningType: "text",
+          text: choice.message.reasoning_content
+        }
+      ] : void 0,
+      toolCalls: (_e = choice.message.tool_calls) == null ? void 0 : _e.map((toolCall) => {
         var _a2;
         return {
+          type: "tool-call",
           toolCallType: "function",
           toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils.generateId)(),
           toolName: toolCall.function.name,
@@ -391,8 +419,8 @@ var OpenAICompatibleChatLanguageModel = class {
       }),
       finishReason: mapOpenAICompatibleFinishReason(choice.finish_reason),
       usage: {
-        promptTokens: (_i = (_h = responseBody.usage) == null ? void 0 : _h.prompt_tokens) != null ? _i : NaN,
-        completionTokens: (_k = (_j = responseBody.usage) == null ? void 0 : _j.completion_tokens) != null ? _k : NaN
+        inputTokens: (_g = (_f = responseBody.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : void 0,
+        outputTokens: (_i = (_h = responseBody.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : void 0
       },
       providerMetadata,
       request: { body },
@@ -406,59 +434,6 @@ var OpenAICompatibleChatLanguageModel = class {
   }
   async doStream(options) {
     var _a;
-    if (this.settings.simulateStreaming) {
-      const result = await this.doGenerate(options);
-      const simulatedStream = new ReadableStream({
-        start(controller) {
-          controller.enqueue({ type: "response-metadata", ...result.response });
-          if (result.reasoning) {
-            if (Array.isArray(result.reasoning)) {
-              for (const part of result.reasoning) {
-                if (part.type === "text") {
-                  controller.enqueue({
-                    type: "reasoning",
-                    textDelta: part.text
-                  });
-                }
-              }
-            } else {
-              controller.enqueue({
-                type: "reasoning",
-                textDelta: result.reasoning
-              });
-            }
-          }
-          if (result.text) {
-            controller.enqueue({
-              type: "text-delta",
-              textDelta: result.text
-            });
-          }
-          if (result.toolCalls) {
-            for (const toolCall of result.toolCalls) {
-              controller.enqueue({
-                type: "tool-call",
-                ...toolCall
-              });
-            }
-          }
-          controller.enqueue({
-            type: "finish",
-            finishReason: result.finishReason,
-            usage: result.usage,
-            logprobs: result.logprobs,
-            providerMetadata: result.providerMetadata
-          });
-          controller.close();
-        }
-      });
-      return {
-        stream: simulatedStream,
-        request: result.request,
-        response: result.response,
-        warnings: result.warnings
-      };
-    }
     const { args, warnings } = this.getArgs({ ...options });
     const body = JSON.stringify({ ...args, stream: true });
     const metadataExtractor = (_a = this.config.metadataExtractor) == null ? void 0 : _a.createStreamExtractor();
@@ -479,7 +454,6 @@ var OpenAICompatibleChatLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { messages: rawPrompt, ...rawSettings } = args;
     const toolCalls = [];
     let finishReason = "unknown";
     let usage = {
@@ -556,13 +530,14 @@ var OpenAICompatibleChatLanguageModel = class {
             if (delta.reasoning_content != null) {
               controller.enqueue({
                 type: "reasoning",
-                textDelta: delta.reasoning_content
+                reasoningType: "text",
+                text: delta.reasoning_content
               });
             }
             if (delta.content != null) {
               controller.enqueue({
-                type: "text-delta",
-                textDelta: delta.content
+                type: "text",
+                text: delta.content
               });
             }
             if (delta.tool_calls != null) {
@@ -669,8 +644,8 @@ var OpenAICompatibleChatLanguageModel = class {
               type: "finish",
               finishReason,
               usage: {
-                promptTokens: (_a2 = usage.promptTokens) != null ? _a2 : NaN,
-                completionTokens: (_b = usage.completionTokens) != null ? _b : NaN
+                inputTokens: (_a2 = usage.promptTokens) != null ? _a2 : void 0,
+                outputTokens: (_b = usage.completionTokens) != null ? _b : void 0
               },
               providerMetadata
             });
@@ -683,68 +658,68 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
 };
-var openaiCompatibleTokenUsageSchema = import_zod2.z.object({
-  prompt_tokens: import_zod2.z.number().nullish(),
-  completion_tokens: import_zod2.z.number().nullish(),
-  prompt_tokens_details: import_zod2.z.object({
-    cached_tokens: import_zod2.z.number().nullish()
+var openaiCompatibleTokenUsageSchema = import_zod3.z.object({
+  prompt_tokens: import_zod3.z.number().nullish(),
+  completion_tokens: import_zod3.z.number().nullish(),
+  prompt_tokens_details: import_zod3.z.object({
+    cached_tokens: import_zod3.z.number().nullish()
   }).nullish(),
-  completion_tokens_details: import_zod2.z.object({
-    reasoning_tokens: import_zod2.z.number().nullish(),
-    accepted_prediction_tokens: import_zod2.z.number().nullish(),
-    rejected_prediction_tokens: import_zod2.z.number().nullish()
+  completion_tokens_details: import_zod3.z.object({
+    reasoning_tokens: import_zod3.z.number().nullish(),
+    accepted_prediction_tokens: import_zod3.z.number().nullish(),
+    rejected_prediction_tokens: import_zod3.z.number().nullish()
   }).nullish()
 }).nullish();
-var OpenAICompatibleChatResponseSchema = import_zod2.z.object({
-  id: import_zod2.z.string().nullish(),
-  created: import_zod2.z.number().nullish(),
-  model: import_zod2.z.string().nullish(),
-  choices: import_zod2.z.array(
-    import_zod2.z.object({
-      message: import_zod2.z.object({
-        role: import_zod2.z.literal("assistant").nullish(),
-        content: import_zod2.z.string().nullish(),
-        reasoning_content: import_zod2.z.string().nullish(),
-        tool_calls: import_zod2.z.array(
-          import_zod2.z.object({
-            id: import_zod2.z.string().nullish(),
-            type: import_zod2.z.literal("function"),
-            function: import_zod2.z.object({
-              name: import_zod2.z.string(),
-              arguments: import_zod2.z.string()
+var OpenAICompatibleChatResponseSchema = import_zod3.z.object({
+  id: import_zod3.z.string().nullish(),
+  created: import_zod3.z.number().nullish(),
+  model: import_zod3.z.string().nullish(),
+  choices: import_zod3.z.array(
+    import_zod3.z.object({
+      message: import_zod3.z.object({
+        role: import_zod3.z.literal("assistant").nullish(),
+        content: import_zod3.z.string().nullish(),
+        reasoning_content: import_zod3.z.string().nullish(),
+        tool_calls: import_zod3.z.array(
+          import_zod3.z.object({
+            id: import_zod3.z.string().nullish(),
+            type: import_zod3.z.literal("function"),
+            function: import_zod3.z.object({
+              name: import_zod3.z.string(),
+              arguments: import_zod3.z.string()
             })
           })
         ).nullish()
       }),
-      finish_reason: import_zod2.z.string().nullish()
+      finish_reason: import_zod3.z.string().nullish()
     })
   ),
   usage: openaiCompatibleTokenUsageSchema
 });
-var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_zod2.z.union([
-  import_zod2.z.object({
-    id: import_zod2.z.string().nullish(),
-    created: import_zod2.z.number().nullish(),
-    model: import_zod2.z.string().nullish(),
-    choices: import_zod2.z.array(
-      import_zod2.z.object({
-        delta: import_zod2.z.object({
-          role: import_zod2.z.enum(["assistant"]).nullish(),
-          content: import_zod2.z.string().nullish(),
-          reasoning_content: import_zod2.z.string().nullish(),
-          tool_calls: import_zod2.z.array(
-            import_zod2.z.object({
-              index: import_zod2.z.number(),
-              id: import_zod2.z.string().nullish(),
-              type: import_zod2.z.literal("function").optional(),
-              function: import_zod2.z.object({
-                name: import_zod2.z.string().nullish(),
-                arguments: import_zod2.z.string().nullish()
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_zod3.z.union([
+  import_zod3.z.object({
+    id: import_zod3.z.string().nullish(),
+    created: import_zod3.z.number().nullish(),
+    model: import_zod3.z.string().nullish(),
+    choices: import_zod3.z.array(
+      import_zod3.z.object({
+        delta: import_zod3.z.object({
+          role: import_zod3.z.enum(["assistant"]).nullish(),
+          content: import_zod3.z.string().nullish(),
+          reasoning_content: import_zod3.z.string().nullish(),
+          tool_calls: import_zod3.z.array(
+            import_zod3.z.object({
+              index: import_zod3.z.number(),
+              id: import_zod3.z.string().nullish(),
+              type: import_zod3.z.literal("function").optional(),
+              function: import_zod3.z.object({
+                name: import_zod3.z.string().nullish(),
+                arguments: import_zod3.z.string().nullish()
               })
             })
           ).nullish()
         }).nullish(),
-        finish_reason: import_zod2.z.string().nullish()
+        finish_reason: import_zod3.z.string().nullish()
       })
     ),
     usage: openaiCompatibleTokenUsageSchema
@@ -754,7 +729,7 @@ var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_zod2.z.union
 
 // src/openai-compatible-completion-language-model.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_zod5 = require("zod");
 
 // src/convert-to-openai-compatible-completion-prompt.ts
 var import_provider4 = require("@ai-sdk/provider");
@@ -835,15 +810,39 @@ ${user}:`]
   };
 }
 
+// src/openai-compatible-completion-options.ts
+var import_zod4 = require("zod");
+var openaiCompatibleCompletionProviderOptions = import_zod4.z.object({
+  /**
+   * Echo back the prompt in addition to the completion.
+   */
+  echo: import_zod4.z.boolean().optional(),
+  /**
+   * Modify the likelihood of specified tokens appearing in the completion.
+   *
+   * Accepts a JSON object that maps tokens (specified by their token ID in
+   * the GPT tokenizer) to an associated bias value from -100 to 100.
+   */
+  logitBias: import_zod4.z.record(import_zod4.z.number(), import_zod4.z.number()).optional(),
+  /**
+   * The suffix that comes after a completion of inserted text.
+   */
+  suffix: import_zod4.z.string().optional(),
+  /**
+   * A unique identifier representing your end-user, which can help providers to
+   * monitor and detect abuse.
+   */
+  user: import_zod4.z.string().optional()
+});
+
 // src/openai-compatible-completion-language-model.ts
 var OpenAICompatibleCompletionLanguageModel = class {
   // type inferred via constructor
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.specificationVersion = "v2";
     this.defaultObjectGenerationMode = void 0;
     var _a;
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
     const errorStructure = (_a = config.errorStructure) != null ? _a : defaultOpenAICompatibleErrorStructure;
     this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(
@@ -860,7 +859,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
   getArgs({
     inputFormat,
     prompt,
-    maxTokens,
+    maxOutputTokens,
     temperature,
     topP,
     topK,
@@ -873,7 +872,13 @@ var OpenAICompatibleCompletionLanguageModel = class {
     tools,
     toolChoice
   }) {
+    var _a;
     const warnings = [];
+    const completionOptions = (_a = (0, import_provider_utils2.parseProviderOptions)({
+      provider: this.providerOptionsName,
+      providerOptions,
+      schema: openaiCompatibleCompletionProviderOptions
+    })) != null ? _a : {};
     if (topK != null) {
       warnings.push({ type: "unsupported-setting", setting: "topK" });
     }
@@ -897,12 +902,12 @@ var OpenAICompatibleCompletionLanguageModel = class {
         // model id:
         model: this.modelId,
         // model specific settings:
-        echo: this.settings.echo,
-        logit_bias: this.settings.logitBias,
-        suffix: this.settings.suffix,
-        user: this.settings.user,
+        echo: completionOptions.echo,
+        logit_bias: completionOptions.logitBias,
+        suffix: completionOptions.suffix,
+        user: completionOptions.user,
         // standardized settings:
-        max_tokens: maxTokens,
+        max_tokens: maxOutputTokens,
         temperature,
         top_p: topP,
         frequency_penalty: frequencyPenalty,
@@ -940,10 +945,10 @@ var OpenAICompatibleCompletionLanguageModel = class {
     });
     const choice = response.choices[0];
     return {
-      text: choice.text,
+      text: { type: "text", text: choice.text },
       usage: {
-        promptTokens: (_b = (_a = response.usage) == null ? void 0 : _a.prompt_tokens) != null ? _b : NaN,
-        completionTokens: (_d = (_c = response.usage) == null ? void 0 : _c.completion_tokens) != null ? _d : NaN
+        inputTokens: (_b = (_a = response.usage) == null ? void 0 : _a.prompt_tokens) != null ? _b : void 0,
+        outputTokens: (_d = (_c = response.usage) == null ? void 0 : _c.completion_tokens) != null ? _d : void 0
       },
       finishReason: mapOpenAICompatibleFinishReason(choice.finish_reason),
       request: { body: args },
@@ -976,15 +981,16 @@ var OpenAICompatibleCompletionLanguageModel = class {
       fetch: this.config.fetch
     });
     let finishReason = "unknown";
-    let usage = {
-      promptTokens: Number.NaN,
-      completionTokens: Number.NaN
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0
     };
     let isFirstChunk = true;
     return {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
+            var _a, _b;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -1004,10 +1010,8 @@ var OpenAICompatibleCompletionLanguageModel = class {
               });
             }
             if (value.usage != null) {
-              usage = {
-                promptTokens: value.usage.prompt_tokens,
-                completionTokens: value.usage.completion_tokens
-              };
+              usage.inputTokens = (_a = value.usage.prompt_tokens) != null ? _a : void 0;
+              usage.outputTokens = (_b = value.usage.completion_tokens) != null ? _b : void 0;
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
@@ -1017,8 +1021,8 @@ var OpenAICompatibleCompletionLanguageModel = class {
             }
             if ((choice == null ? void 0 : choice.text) != null) {
               controller.enqueue({
-                type: "text-delta",
-                textDelta: choice.text
+                type: "text",
+                text: choice.text
               });
             }
           },
@@ -1037,36 +1041,36 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
 };
-var openaiCompatibleCompletionResponseSchema = import_zod3.z.object({
-  id: import_zod3.z.string().nullish(),
-  created: import_zod3.z.number().nullish(),
-  model: import_zod3.z.string().nullish(),
-  choices: import_zod3.z.array(
-    import_zod3.z.object({
-      text: import_zod3.z.string(),
-      finish_reason: import_zod3.z.string()
+var openaiCompatibleCompletionResponseSchema = import_zod5.z.object({
+  id: import_zod5.z.string().nullish(),
+  created: import_zod5.z.number().nullish(),
+  model: import_zod5.z.string().nullish(),
+  choices: import_zod5.z.array(
+    import_zod5.z.object({
+      text: import_zod5.z.string(),
+      finish_reason: import_zod5.z.string()
     })
   ),
-  usage: import_zod3.z.object({
-    prompt_tokens: import_zod3.z.number(),
-    completion_tokens: import_zod3.z.number()
+  usage: import_zod5.z.object({
+    prompt_tokens: import_zod5.z.number(),
+    completion_tokens: import_zod5.z.number()
   }).nullish()
 });
-var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_zod3.z.union([
-  import_zod3.z.object({
-    id: import_zod3.z.string().nullish(),
-    created: import_zod3.z.number().nullish(),
-    model: import_zod3.z.string().nullish(),
-    choices: import_zod3.z.array(
-      import_zod3.z.object({
-        text: import_zod3.z.string(),
-        finish_reason: import_zod3.z.string().nullish(),
-        index: import_zod3.z.number()
+var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_zod5.z.union([
+  import_zod5.z.object({
+    id: import_zod5.z.string().nullish(),
+    created: import_zod5.z.number().nullish(),
+    model: import_zod5.z.string().nullish(),
+    choices: import_zod5.z.array(
+      import_zod5.z.object({
+        text: import_zod5.z.string(),
+        finish_reason: import_zod5.z.string().nullish(),
+        index: import_zod5.z.number()
       })
     ),
-    usage: import_zod3.z.object({
-      prompt_tokens: import_zod3.z.number(),
-      completion_tokens: import_zod3.z.number()
+    usage: import_zod5.z.object({
+      prompt_tokens: import_zod5.z.number(),
+      completion_tokens: import_zod5.z.number()
     }).nullish()
   }),
   errorSchema
@@ -1075,12 +1079,28 @@ var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_zod3.z
 // src/openai-compatible-embedding-model.ts
 var import_provider5 = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod4 = require("zod");
+var import_zod7 = require("zod");
+
+// src/openai-compatible-embedding-options.ts
+var import_zod6 = require("zod");
+var openaiCompatibleEmbeddingProviderOptions = import_zod6.z.object({
+  /**
+   * The number of dimensions the resulting output embeddings should have.
+   * Only supported in text-embedding-3 and later models.
+   */
+  dimensions: import_zod6.z.number().optional(),
+  /**
+   * A unique identifier representing your end-user, which can help providers to
+   * monitor and detect abuse.
+   */
+  user: import_zod6.z.string().optional()
+});
+
+// src/openai-compatible-embedding-model.ts
 var OpenAICompatibleEmbeddingModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
   }
   get provider() {
@@ -1094,12 +1114,28 @@ var OpenAICompatibleEmbeddingModel = class {
     var _a;
     return (_a = this.config.supportsParallelCalls) != null ? _a : true;
   }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
   async doEmbed({
     values,
     headers,
-    abortSignal
+    abortSignal,
+    providerOptions
   }) {
-    var _a;
+    var _a, _b, _c;
+    const compatibleOptions = Object.assign(
+      (_a = (0, import_provider_utils3.parseProviderOptions)({
+        provider: "openai-compatible",
+        providerOptions,
+        schema: openaiCompatibleEmbeddingProviderOptions
+      })) != null ? _a : {},
+      (_b = (0, import_provider_utils3.parseProviderOptions)({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleEmbeddingProviderOptions
+      })) != null ? _b : {}
+    );
     if (values.length > this.maxEmbeddingsPerCall) {
       throw new import_provider5.TooManyEmbeddingValuesForCallError({
         provider: this.provider,
@@ -1108,7 +1144,11 @@ var OpenAICompatibleEmbeddingModel = class {
         values
       });
     }
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await (0, import_provider_utils3.postJsonToApi)({
       url: this.config.url({
         path: "/embeddings",
         modelId: this.modelId
@@ -1118,11 +1158,11 @@ var OpenAICompatibleEmbeddingModel = class {
         model: this.modelId,
         input: values,
         encoding_format: "float",
-        dimensions: this.settings.dimensions,
-        user: this.settings.user
+        dimensions: compatibleOptions.dimensions,
+        user: compatibleOptions.user
       },
       failedResponseHandler: (0, import_provider_utils3.createJsonErrorResponseHandler)(
-        (_a = this.config.errorStructure) != null ? _a : defaultOpenAICompatibleErrorStructure
+        (_c = this.config.errorStructure) != null ? _c : defaultOpenAICompatibleErrorStructure
       ),
       successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
         openaiTextEmbeddingResponseSchema
@@ -1133,18 +1173,18 @@ var OpenAICompatibleEmbeddingModel = class {
     return {
       embeddings: response.data.map((item) => item.embedding),
       usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
-      rawResponse: { headers: responseHeaders }
+      response: { headers: responseHeaders, body: rawValue }
     };
   }
 };
-var openaiTextEmbeddingResponseSchema = import_zod4.z.object({
-  data: import_zod4.z.array(import_zod4.z.object({ embedding: import_zod4.z.array(import_zod4.z.number()) })),
-  usage: import_zod4.z.object({ prompt_tokens: import_zod4.z.number() }).nullish()
+var openaiTextEmbeddingResponseSchema = import_zod7.z.object({
+  data: import_zod7.z.array(import_zod7.z.object({ embedding: import_zod7.z.array(import_zod7.z.number()) })),
+  usage: import_zod7.z.object({ prompt_tokens: import_zod7.z.number() }).nullish()
 });
 
 // src/openai-compatible-image-model.ts
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod5 = require("zod");
+var import_zod8 = require("zod");
 var OpenAICompatibleImageModel = class {
   constructor(modelId, settings, config) {
     this.modelId = modelId;
@@ -1217,8 +1257,8 @@ var OpenAICompatibleImageModel = class {
     };
   }
 };
-var openaiCompatibleImageResponseSchema = import_zod5.z.object({
-  data: import_zod5.z.array(import_zod5.z.object({ b64_json: import_zod5.z.string() }))
+var openaiCompatibleImageResponseSchema = import_zod8.z.object({
+  data: import_zod8.z.array(import_zod8.z.object({ b64_json: import_zod8.z.string() }))
 });
 
 // src/openai-compatible-provider.ts
@@ -1242,27 +1282,24 @@ function createOpenAICompatible(options) {
     headers: getHeaders,
     fetch: options.fetch
   });
-  const createLanguageModel = (modelId, settings = {}) => createChatModel(modelId, settings);
-  const createChatModel = (modelId, settings = {}) => new OpenAICompatibleChatLanguageModel(modelId, settings, {
+  const createLanguageModel = (modelId) => createChatModel(modelId);
+  const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(modelId, {
     ...getCommonModelConfig("chat"),
     defaultObjectGenerationMode: "tool"
   });
-  const createCompletionModel = (modelId, settings = {}) => new OpenAICompatibleCompletionLanguageModel(
+  const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(
     modelId,
-    settings,
     getCommonModelConfig("completion")
   );
-  const createEmbeddingModel = (modelId, settings = {}) => new OpenAICompatibleEmbeddingModel(
-    modelId,
-    settings,
-    getCommonModelConfig("embedding")
-  );
+  const createEmbeddingModel = (modelId) => new OpenAICompatibleEmbeddingModel(modelId, {
+    ...getCommonModelConfig("embedding")
+  });
   const createImageModel = (modelId, settings = {}) => new OpenAICompatibleImageModel(
     modelId,
     settings,
     getCommonModelConfig("image")
   );
-  const provider = (modelId, settings) => createLanguageModel(modelId, settings);
+  const provider = (modelId) => createLanguageModel(modelId);
   provider.languageModel = createLanguageModel;
   provider.chatModel = createChatModel;
   provider.completionModel = createCompletionModel;