@llmgateway/ai-sdk-provider 1.0.0 → 1.0.2

package/dist/internal/{index.cjs → index.mjs}

@@ -1,9 +1,6 @@
-"use strict";
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -32,61 +29,50 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/internal/index.ts
-var index_exports = {};
-__export(index_exports, {
-  LLMGatewayChatLanguageModel: () => LLMGatewayChatLanguageModel,
-  LLMGatewayCompletionLanguageModel: () => LLMGatewayCompletionLanguageModel
-});
-module.exports = __toCommonJS(index_exports);
 
 // src/schemas/reasoning-details.ts
-var import_zod = require("zod");
-var ReasoningDetailSummarySchema = import_zod.z.object({
-  type: import_zod.z.literal("reasoning.summary" /* Summary */),
-  summary: import_zod.z.string()
+import { z } from "zod";
+var ReasoningDetailSummarySchema = z.object({
+  type: z.literal("reasoning.summary" /* Summary */),
+  summary: z.string()
 });
-var ReasoningDetailEncryptedSchema = import_zod.z.object({
-  type: import_zod.z.literal("reasoning.encrypted" /* Encrypted */),
-  data: import_zod.z.string()
+var ReasoningDetailEncryptedSchema = z.object({
+  type: z.literal("reasoning.encrypted" /* Encrypted */),
+  data: z.string()
 });
-var ReasoningDetailTextSchema = import_zod.z.object({
-  type: import_zod.z.literal("reasoning.text" /* Text */),
-  text: import_zod.z.string().nullish(),
-  signature: import_zod.z.string().nullish()
+var ReasoningDetailTextSchema = z.object({
+  type: z.literal("reasoning.text" /* Text */),
+  text: z.string().nullish(),
+  signature: z.string().nullish()
 });
-var ReasoningDetailUnionSchema = import_zod.z.union([
+var ReasoningDetailUnionSchema = z.union([
   ReasoningDetailSummarySchema,
   ReasoningDetailEncryptedSchema,
   ReasoningDetailTextSchema
 ]);
-var ReasoningDetailsWithUnknownSchema = import_zod.z.union([
+var ReasoningDetailsWithUnknownSchema = z.union([
   ReasoningDetailUnionSchema,
-  import_zod.z.unknown().transform(() => null)
+  z.unknown().transform(() => null)
 ]);
-var ReasoningDetailArraySchema = import_zod.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
+var ReasoningDetailArraySchema = z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
 
 // src/llmgateway-chat-language-model.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+import {
+  InvalidResponseDataError,
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isParsableJson,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod";
 
 // src/convert-to-llmgateway-chat-messages.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
+import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
 function getCacheControl(providerMetadata) {
   var _a, _b, _c;
   const anthropic = providerMetadata == null ? void 0 : providerMetadata.anthropic;
@@ -132,7 +118,7 @@ function convertToLLMGatewayChatMessages(prompt) {
                 return {
                   type: "image_url",
                   image_url: {
-                    url: part.image instanceof URL ? part.image.toString() : `data:${(_b2 = part.mimeType) != null ? _b2 : "image/jpeg"};base64,${(0, import_provider_utils.convertUint8ArrayToBase64)(
+                    url: part.image instanceof URL ? part.image.toString() : `data:${(_b2 = part.mimeType) != null ? _b2 : "image/jpeg"};base64,${convertUint8ArrayToBase64(
                       part.image
                     )}`
                   },
@@ -146,7 +132,7 @@ function convertToLLMGatewayChatMessages(prompt) {
                     filename: String(
                       (_d = (_c2 = part.providerMetadata) == null ? void 0 : _c2.llmgateway) == null ? void 0 : _d.filename
                     ),
-                    file_data: part.data instanceof Uint8Array ? `data:${part.mimeType};base64,${(0, import_provider_utils.convertUint8ArrayToBase64)(part.data)}` : `data:${part.mimeType};base64,${part.data}`
+                    file_data: part.data instanceof Uint8Array ? `data:${part.mimeType};base64,${convertUint8ArrayToBase64(part.data)}` : `data:${part.mimeType};base64,${part.data}`
                   },
                   cache_control: cacheControl
                 };
@@ -272,17 +258,17 @@ function mapLLMGatewayFinishReason(finishReason) {
 }
 
 // src/llmgateway-error.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
-var LLMGatewayErrorResponseSchema = import_zod2.z.object({
-  error: import_zod2.z.object({
-    message: import_zod2.z.string(),
-    type: import_zod2.z.string(),
-    param: import_zod2.z.any().nullable(),
-    code: import_zod2.z.string().nullable()
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod";
+var LLMGatewayErrorResponseSchema = z2.object({
+  error: z2.object({
+    message: z2.string(),
+    type: z2.string(),
+    param: z2.any().nullable(),
+    code: z2.string().nullable()
   })
 });
-var llmgatewayFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
+var llmgatewayFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: LLMGatewayErrorResponseSchema,
   errorToMessage: (data) => data.error.message
 });
@@ -373,7 +359,7 @@ var LLMGatewayChatLanguageModel = class {
       // Handle all non-text types with a single default case
       default: {
         const _exhaustiveCheck = type;
-        throw new import_provider.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError({
           functionality: `${_exhaustiveCheck} mode`
         });
       }
@@ -382,15 +368,15 @@ var LLMGatewayChatLanguageModel = class {
   async doGenerate(options) {
     var _b, _c, _d, _e, _f, _g, _h, _i, _j;
     const args = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: llmgatewayFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         LLMGatewayNonStreamChatCompletionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -480,7 +466,7 @@ var LLMGatewayChatLanguageModel = class {
         var _a2;
         return {
           toolCallType: "function",
-          toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils3.generateId)(),
+          toolCallId: (_a2 = toolCall.id) != null ? _a2 : generateId(),
           toolName: toolCall.function.name,
           args: toolCall.function.arguments
         };
@@ -496,12 +482,12 @@ var LLMGatewayChatLanguageModel = class {
   async doStream(options) {
     var _a, _c;
     const args = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body: __spreadProps(__spreadValues({}, args), {
         stream: true,
         // only include stream_options when in strict compatibility mode:
@@ -510,7 +496,7 @@ var LLMGatewayChatLanguageModel = class {
         }, ((_a = this.settings.usage) == null ? void 0 : _a.include) ? { include_usage: true } : {}) : void 0
       }),
       failedResponseHandler: llmgatewayFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         LLMGatewayStreamChatCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -651,19 +637,19 @@ var LLMGatewayChatLanguageModel = class {
                 const index = toolCallDelta.index;
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.type !== "function") {
-                    throw new import_provider.InvalidResponseDataError({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function' type.`
                     });
                   }
                   if (toolCallDelta.id == null) {
-                    throw new import_provider.InvalidResponseDataError({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'id' to be a string.`
                     });
                   }
                   if (((_c2 = toolCallDelta.function) == null ? void 0 : _c2.name) == null) {
-                    throw new import_provider.InvalidResponseDataError({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
                     });
@@ -681,7 +667,7 @@ var LLMGatewayChatLanguageModel = class {
                   if (toolCall2 == null) {
                     throw new Error("Tool call is missing");
                   }
-                  if (((_e = toolCall2.function) == null ? void 0 : _e.name) != null && ((_f = toolCall2.function) == null ? void 0 : _f.arguments) != null && (0, import_provider_utils3.isParsableJson)(toolCall2.function.arguments)) {
+                  if (((_e = toolCall2.function) == null ? void 0 : _e.name) != null && ((_f = toolCall2.function) == null ? void 0 : _f.arguments) != null && isParsableJson(toolCall2.function.arguments)) {
                     controller.enqueue({
                       type: "tool-call-delta",
                       toolCallType: "function",
@@ -692,7 +678,7 @@ var LLMGatewayChatLanguageModel = class {
                     controller.enqueue({
                       type: "tool-call",
                       toolCallType: "function",
-                      toolCallId: (_g = toolCall2.id) != null ? _g : (0, import_provider_utils3.generateId)(),
+                      toolCallId: (_g = toolCall2.id) != null ? _g : generateId(),
                       toolName: toolCall2.function.name,
                       args: toolCall2.function.arguments
                     });
@@ -714,11 +700,11 @@ var LLMGatewayChatLanguageModel = class {
                   toolName: toolCall.function.name,
                   argsTextDelta: (_k = toolCallDelta.function.arguments) != null ? _k : ""
                 });
-                if (((_l = toolCall.function) == null ? void 0 : _l.name) != null && ((_m = toolCall.function) == null ? void 0 : _m.arguments) != null && (0, import_provider_utils3.isParsableJson)(toolCall.function.arguments)) {
+                if (((_l = toolCall.function) == null ? void 0 : _l.name) != null && ((_m = toolCall.function) == null ? void 0 : _m.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-call",
                     toolCallType: "function",
-                    toolCallId: (_n = toolCall.id) != null ? _n : (0, import_provider_utils3.generateId)(),
+                    toolCallId: (_n = toolCall.id) != null ? _n : generateId(),
                     toolName: toolCall.function.name,
                     args: toolCall.function.arguments
                   });
@@ -735,10 +721,10 @@ var LLMGatewayChatLanguageModel = class {
                   controller.enqueue({
                     type: "tool-call",
                     toolCallType: "function",
-                    toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils3.generateId)(),
+                    toolCallId: (_a2 = toolCall.id) != null ? _a2 : generateId(),
                     toolName: toolCall.function.name,
                     // Coerce invalid arguments to an empty JSON object
-                    args: (0, import_provider_utils3.isParsableJson)(toolCall.function.arguments) ? toolCall.function.arguments : "{}"
+                    args: isParsableJson(toolCall.function.arguments) ? toolCall.function.arguments : "{}"
                   });
                   toolCall.sent = true;
                 }
@@ -766,97 +752,97 @@ var LLMGatewayChatLanguageModel = class {
     };
   }
 };
-var LLMGatewayChatCompletionBaseResponseSchema = import_zod3.z.object({
-  id: import_zod3.z.string().optional(),
-  model: import_zod3.z.string().optional(),
-  usage: import_zod3.z.object({
-    prompt_tokens: import_zod3.z.number(),
-    prompt_tokens_details: import_zod3.z.object({
-      cached_tokens: import_zod3.z.number()
+var LLMGatewayChatCompletionBaseResponseSchema = z3.object({
+  id: z3.string().optional(),
+  model: z3.string().optional(),
+  usage: z3.object({
+    prompt_tokens: z3.number(),
+    prompt_tokens_details: z3.object({
+      cached_tokens: z3.number()
     }).nullish(),
-    completion_tokens: import_zod3.z.number(),
-    completion_tokens_details: import_zod3.z.object({
-      reasoning_tokens: import_zod3.z.number()
+    completion_tokens: z3.number(),
+    completion_tokens_details: z3.object({
+      reasoning_tokens: z3.number()
     }).nullish(),
-    total_tokens: import_zod3.z.number(),
-    cost: import_zod3.z.number().optional()
+    total_tokens: z3.number(),
+    cost: z3.number().optional()
   }).nullish()
 });
 var LLMGatewayNonStreamChatCompletionResponseSchema = LLMGatewayChatCompletionBaseResponseSchema.extend({
-  choices: import_zod3.z.array(
-    import_zod3.z.object({
-      message: import_zod3.z.object({
-        role: import_zod3.z.literal("assistant"),
-        content: import_zod3.z.string().nullable().optional(),
-        reasoning: import_zod3.z.string().nullable().optional(),
+  choices: z3.array(
+    z3.object({
+      message: z3.object({
+        role: z3.literal("assistant"),
+        content: z3.string().nullable().optional(),
+        reasoning: z3.string().nullable().optional(),
         reasoning_details: ReasoningDetailArraySchema.nullish(),
-        tool_calls: import_zod3.z.array(
-          import_zod3.z.object({
-            id: import_zod3.z.string().optional().nullable(),
-            type: import_zod3.z.literal("function"),
-            function: import_zod3.z.object({
-              name: import_zod3.z.string(),
-              arguments: import_zod3.z.string()
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string().optional().nullable(),
+            type: z3.literal("function"),
+            function: z3.object({
+              name: z3.string(),
+              arguments: z3.string()
             })
           })
         ).optional()
       }),
-      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()
+      index: z3.number(),
+      logprobs: z3.object({
+        content: z3.array(
+          z3.object({
+            token: z3.string(),
+            logprob: z3.number(),
+            top_logprobs: z3.array(
+              z3.object({
+                token: z3.string(),
+                logprob: z3.number()
               })
             )
           })
         ).nullable()
       }).nullable().optional(),
-      finish_reason: import_zod3.z.string().optional().nullable()
+      finish_reason: z3.string().optional().nullable()
     })
   )
 });
-var LLMGatewayStreamChatCompletionChunkSchema = import_zod3.z.union([
+var LLMGatewayStreamChatCompletionChunkSchema = z3.union([
   LLMGatewayChatCompletionBaseResponseSchema.extend({
-    choices: import_zod3.z.array(
-      import_zod3.z.object({
-        delta: import_zod3.z.object({
-          role: import_zod3.z.enum(["assistant"]).optional(),
-          content: import_zod3.z.string().nullish(),
-          reasoning: import_zod3.z.string().nullish().optional(),
+    choices: z3.array(
+      z3.object({
+        delta: z3.object({
+          role: z3.enum(["assistant"]).optional(),
+          content: z3.string().nullish(),
+          reasoning: z3.string().nullish().optional(),
           reasoning_details: ReasoningDetailArraySchema.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()
+          tool_calls: z3.array(
+            z3.object({
+              index: z3.number(),
+              id: z3.string().nullish(),
+              type: z3.literal("function").optional(),
+              function: z3.object({
+                name: z3.string().nullish(),
+                arguments: z3.string().nullish()
               })
             })
           ).nullish()
         }).nullish(),
-        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()
+        logprobs: z3.object({
+          content: z3.array(
+            z3.object({
+              token: z3.string(),
+              logprob: z3.number(),
+              top_logprobs: z3.array(
+                z3.object({
+                  token: z3.string(),
+                  logprob: z3.number()
                 })
               )
             })
           ).nullable()
         }).nullish(),
-        finish_reason: import_zod3.z.string().nullable().optional(),
-        index: import_zod3.z.number()
+        finish_reason: z3.string().nullable().optional(),
+        index: z3.number()
       })
     )
   }),
@@ -914,12 +900,20 @@ function prepareToolsAndToolChoice(mode) {
 }
 
 // src/llmgateway-completion-language-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod4 = require("zod");
+import { UnsupportedFunctionalityError as UnsupportedFunctionalityError3 } from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders2,
+  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  postJsonToApi as postJsonToApi2
+} from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod";
 
 // src/convert-to-llmgateway-completion-prompt.ts
-var import_provider2 = require("@ai-sdk/provider");
+import {
+  InvalidPromptError,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 function convertToLLMGatewayCompletionPrompt({
   prompt,
   inputFormat,
@@ -939,7 +933,7 @@ function convertToLLMGatewayCompletionPrompt({
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
-        throw new import_provider2.InvalidPromptError({
+        throw new InvalidPromptError({
           message: "Unexpected system message in prompt: ${content}",
           prompt
         });
@@ -951,12 +945,12 @@ function convertToLLMGatewayCompletionPrompt({
               return part.text;
             }
             case "image": {
-              throw new import_provider2.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError2({
                 functionality: "images"
               });
             }
             case "file": {
-              throw new import_provider2.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError2({
                 functionality: "file attachments"
               });
             }
@@ -981,22 +975,22 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new import_provider2.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError2({
                 functionality: "tool-call messages"
               });
             }
             case "reasoning": {
-              throw new import_provider2.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError2({
                 functionality: "reasoning messages"
               });
             }
             case "redacted-reasoning": {
-              throw new import_provider2.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError2({
                 functionality: "redacted reasoning messages"
               });
             }
             case "file": {
-              throw new import_provider2.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError2({
                 functionality: "file attachments"
               });
             }
@@ -1015,7 +1009,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new import_provider2.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError2({
           functionality: "tool messages"
         });
       }
@@ -1108,31 +1102,31 @@ var LLMGatewayCompletionLanguageModel = class {
     switch (type) {
       case "regular": {
         if ((_b = mode.tools) == null ? void 0 : _b.length) {
-          throw new import_provider3.UnsupportedFunctionalityError({
+          throw new UnsupportedFunctionalityError3({
             functionality: "tools"
           });
         }
         if (mode.toolChoice) {
-          throw new import_provider3.UnsupportedFunctionalityError({
+          throw new UnsupportedFunctionalityError3({
             functionality: "toolChoice"
           });
         }
         return baseArgs;
       }
       case "object-json": {
-        throw new import_provider3.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError3({
           functionality: "object-json mode"
         });
       }
       case "object-tool": {
-        throw new import_provider3.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError3({
           functionality: "object-tool mode"
         });
       }
       // Handle all non-text types with a single default case
       default: {
         const _exhaustiveCheck = type;
-        throw new import_provider3.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError3({
           functionality: `${_exhaustiveCheck} mode`
         });
       }
@@ -1141,15 +1135,15 @@ var LLMGatewayCompletionLanguageModel = class {
   async doGenerate(options) {
     var _b, _c, _d, _e, _f;
     const args = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders2(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: llmgatewayFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         LLMGatewayCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -1183,19 +1177,19 @@ var LLMGatewayCompletionLanguageModel = class {
   }
   async doStream(options) {
     const args = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders2(this.config.headers(), options.headers),
       body: __spreadProps(__spreadValues({}, this.getArgs(options)), {
         stream: true,
         // only include stream_options when in strict compatibility mode:
         stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
       }),
       failedResponseHandler: llmgatewayFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler2(
         LLMGatewayCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -1265,34 +1259,33 @@ var LLMGatewayCompletionLanguageModel = class {
     };
   }
 };
-var LLMGatewayCompletionChunkSchema = import_zod4.z.union([
-  import_zod4.z.object({
-    id: import_zod4.z.string().optional(),
-    model: import_zod4.z.string().optional(),
-    choices: import_zod4.z.array(
-      import_zod4.z.object({
-        text: import_zod4.z.string(),
-        reasoning: import_zod4.z.string().nullish().optional(),
+var LLMGatewayCompletionChunkSchema = z4.union([
+  z4.object({
+    id: z4.string().optional(),
+    model: z4.string().optional(),
+    choices: z4.array(
+      z4.object({
+        text: z4.string(),
+        reasoning: z4.string().nullish().optional(),
         reasoning_details: ReasoningDetailArraySchema.nullish(),
-        finish_reason: import_zod4.z.string().nullish(),
-        index: import_zod4.z.number(),
-        logprobs: import_zod4.z.object({
-          tokens: import_zod4.z.array(import_zod4.z.string()),
-          token_logprobs: import_zod4.z.array(import_zod4.z.number()),
-          top_logprobs: import_zod4.z.array(import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number())).nullable()
+        finish_reason: z4.string().nullish(),
+        index: z4.number(),
+        logprobs: z4.object({
+          tokens: z4.array(z4.string()),
+          token_logprobs: z4.array(z4.number()),
+          top_logprobs: z4.array(z4.record(z4.string(), z4.number())).nullable()
         }).nullable().optional()
       })
     ),
-    usage: import_zod4.z.object({
-      prompt_tokens: import_zod4.z.number(),
-      completion_tokens: import_zod4.z.number()
+    usage: z4.object({
+      prompt_tokens: z4.number(),
+      completion_tokens: z4.number()
     }).optional().nullable()
   }),
   LLMGatewayErrorResponseSchema
 ]);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   LLMGatewayChatLanguageModel,
   LLMGatewayCompletionLanguageModel
-});
-//# sourceMappingURL=index.cjs.map
+};
+//# sourceMappingURL=index.mjs.map