@ai-sdk/cohere 4.0.0-beta.20 → 4.0.0-beta.21

package/dist/index.js

@@ -1,42 +1,29 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VERSION: () => VERSION,
-  cohere: () => cohere,
-  createCohere: () => createCohere
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/cohere-provider.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  generateId,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // src/cohere-chat-language-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  parseProviderOptions,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/cohere-chat-options.ts
-var import_v4 = require("zod/v4");
-var cohereLanguageModelOptions = import_v4.z.object({
+import { z } from "zod/v4";
+var cohereLanguageModelOptions = z.object({
   /**
    * Configuration for reasoning features (optional)
    *
@@ -45,25 +32,27 @@ var cohereLanguageModelOptions = import_v4.z.object({
    *
    * @see https://docs.cohere.com/reference/chat#request.body.thinking
    */
-  thinking: import_v4.z.object({
-    type: import_v4.z.enum(["enabled", "disabled"]).optional(),
-    tokenBudget: import_v4.z.number().optional()
+  thinking: z.object({
+    type: z.enum(["enabled", "disabled"]).optional(),
+    tokenBudget: z.number().optional()
   }).optional()
 });
 
 // src/cohere-error.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
-var cohereErrorDataSchema = import_v42.z.object({
-  message: import_v42.z.string()
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+var cohereErrorDataSchema = z2.object({
+  message: z2.string()
 });
-var cohereFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+var cohereFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: cohereErrorDataSchema,
   errorToMessage: (data) => data.message
 });
 
 // src/cohere-prepare-tools.ts
-var import_provider = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
 function prepareTools({
   tools,
   toolChoice
@@ -112,7 +101,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -156,8 +145,10 @@ function convertCohereUsage(tokens) {
 }
 
 // src/convert-to-cohere-chat-prompt.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+import { isProviderReference } from "@ai-sdk/provider-utils";
 function convertToCohereChatPrompt(prompt) {
   const messages = [];
   const documents = [];
@@ -178,8 +169,8 @@ function convertToCohereChatPrompt(prompt) {
                 return part.text;
               }
               case "file": {
-                if ((0, import_provider_utils2.isProviderReference)(part.data)) {
-                  throw new import_provider2.UnsupportedFunctionalityError({
+                if (isProviderReference(part.data)) {
+                  throw new UnsupportedFunctionalityError2({
                     functionality: "file parts with provider references"
                   });
                 }
@@ -188,14 +179,14 @@ function convertToCohereChatPrompt(prompt) {
                   textContent = part.data;
                 } else if (part.data instanceof Uint8Array) {
                   if (!(((_a = part.mediaType) == null ? void 0 : _a.startsWith("text/")) || part.mediaType === "application/json")) {
-                    throw new import_provider2.UnsupportedFunctionalityError({
+                    throw new UnsupportedFunctionalityError2({
                       functionality: `document media type: ${part.mediaType}`,
                       message: `Media type '${part.mediaType}' is not supported. Supported media types are: text/* and application/json.`
                     });
                   }
                   textContent = new TextDecoder().decode(part.data);
                 } else {
-                  throw new import_provider2.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError2({
                     functionality: "File URL data",
                     message: "URLs should be downloaded by the AI SDK and not reach this point. This indicates a configuration issue."
                   });
@@ -329,7 +320,7 @@ var CohereChatLanguageModel = class {
   }) {
     var _a;
     const warnings = [];
-    const cohereOptions = (_a = await (0, import_provider_utils3.parseProviderOptions)({
+    const cohereOptions = (_a = await parseProviderOptions({
       provider: "cohere",
       providerOptions,
       schema: cohereLanguageModelOptions
@@ -384,12 +375,12 @@ var CohereChatLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await postJsonToApi({
       url: `${this.config.baseURL}/chat`,
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         cohereChatResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -453,12 +444,12 @@ var CohereChatLanguageModel = class {
   }
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: `${this.config.baseURL}/chat`,
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body: { ...args, stream: true },
       failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         cohereChatChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -639,13 +630,13 @@ function resolveCohereThinking({
       }
     };
   }
-  if (!(0, import_provider_utils3.isCustomReasoning)(reasoning)) {
+  if (!isCustomReasoning(reasoning)) {
     return {};
   }
   if (reasoning === "none") {
     return { thinking: { type: "disabled" } };
   }
-  const tokenBudget = (0, import_provider_utils3.mapReasoningToProviderBudget)({
+  const tokenBudget = mapReasoningToProviderBudget({
     reasoning,
     maxOutputTokens: 32768,
     maxReasoningBudget: 32768,
@@ -656,145 +647,145 @@ function resolveCohereThinking({
   }
   return { thinking: { type: "enabled", token_budget: tokenBudget } };
 }
-var cohereChatResponseSchema = import_v43.z.object({
-  generation_id: import_v43.z.string().nullish(),
-  message: import_v43.z.object({
-    role: import_v43.z.string(),
-    content: import_v43.z.array(
-      import_v43.z.union([
-        import_v43.z.object({
-          type: import_v43.z.literal("text"),
-          text: import_v43.z.string()
+var cohereChatResponseSchema = z3.object({
+  generation_id: z3.string().nullish(),
+  message: z3.object({
+    role: z3.string(),
+    content: z3.array(
+      z3.union([
+        z3.object({
+          type: z3.literal("text"),
+          text: z3.string()
         }),
-        import_v43.z.object({
-          type: import_v43.z.literal("thinking"),
-          thinking: import_v43.z.string()
+        z3.object({
+          type: z3.literal("thinking"),
+          thinking: z3.string()
         })
       ])
     ).nullish(),
-    tool_plan: import_v43.z.string().nullish(),
-    tool_calls: import_v43.z.array(
-      import_v43.z.object({
-        id: import_v43.z.string(),
-        type: import_v43.z.literal("function"),
-        function: import_v43.z.object({
-          name: import_v43.z.string(),
-          arguments: import_v43.z.string()
+    tool_plan: z3.string().nullish(),
+    tool_calls: z3.array(
+      z3.object({
+        id: z3.string(),
+        type: z3.literal("function"),
+        function: z3.object({
+          name: z3.string(),
+          arguments: z3.string()
         })
       })
     ).nullish(),
-    citations: import_v43.z.array(
-      import_v43.z.object({
-        start: import_v43.z.number(),
-        end: import_v43.z.number(),
-        text: import_v43.z.string(),
-        sources: import_v43.z.array(
-          import_v43.z.object({
-            type: import_v43.z.string().optional(),
-            id: import_v43.z.string().optional(),
-            document: import_v43.z.object({
-              id: import_v43.z.string().optional(),
-              text: import_v43.z.string(),
-              title: import_v43.z.string()
+    citations: z3.array(
+      z3.object({
+        start: z3.number(),
+        end: z3.number(),
+        text: z3.string(),
+        sources: z3.array(
+          z3.object({
+            type: z3.string().optional(),
+            id: z3.string().optional(),
+            document: z3.object({
+              id: z3.string().optional(),
+              text: z3.string(),
+              title: z3.string()
             })
           })
         ),
-        type: import_v43.z.string().optional()
+        type: z3.string().optional()
       })
     ).nullish()
   }),
-  finish_reason: import_v43.z.string(),
-  usage: import_v43.z.object({
-    billed_units: import_v43.z.object({
-      input_tokens: import_v43.z.number(),
-      output_tokens: import_v43.z.number()
+  finish_reason: z3.string(),
+  usage: z3.object({
+    billed_units: z3.object({
+      input_tokens: z3.number(),
+      output_tokens: z3.number()
     }),
-    tokens: import_v43.z.object({
-      input_tokens: import_v43.z.number(),
-      output_tokens: import_v43.z.number()
+    tokens: z3.object({
+      input_tokens: z3.number(),
+      output_tokens: z3.number()
     })
   })
 });
-var cohereChatChunkSchema = import_v43.z.discriminatedUnion("type", [
-  import_v43.z.object({
-    type: import_v43.z.literal("citation-start")
+var cohereChatChunkSchema = z3.discriminatedUnion("type", [
+  z3.object({
+    type: z3.literal("citation-start")
   }),
-  import_v43.z.object({
-    type: import_v43.z.literal("citation-end")
+  z3.object({
+    type: z3.literal("citation-end")
   }),
-  import_v43.z.object({
-    type: import_v43.z.literal("content-start"),
-    index: import_v43.z.number(),
-    delta: import_v43.z.object({
-      message: import_v43.z.object({
-        content: import_v43.z.union([
-          import_v43.z.object({
-            type: import_v43.z.literal("text"),
-            text: import_v43.z.string()
+  z3.object({
+    type: z3.literal("content-start"),
+    index: z3.number(),
+    delta: z3.object({
+      message: z3.object({
+        content: z3.union([
+          z3.object({
+            type: z3.literal("text"),
+            text: z3.string()
           }),
-          import_v43.z.object({
-            type: import_v43.z.literal("thinking"),
-            thinking: import_v43.z.string()
+          z3.object({
+            type: z3.literal("thinking"),
+            thinking: z3.string()
           })
         ])
       })
     })
   }),
-  import_v43.z.object({
-    type: import_v43.z.literal("content-delta"),
-    index: import_v43.z.number(),
-    delta: import_v43.z.object({
-      message: import_v43.z.object({
-        content: import_v43.z.union([
-          import_v43.z.object({
-            text: import_v43.z.string()
+  z3.object({
+    type: z3.literal("content-delta"),
+    index: z3.number(),
+    delta: z3.object({
+      message: z3.object({
+        content: z3.union([
+          z3.object({
+            text: z3.string()
           }),
-          import_v43.z.object({
-            thinking: import_v43.z.string()
+          z3.object({
+            thinking: z3.string()
           })
         ])
       })
     })
   }),
-  import_v43.z.object({
-    type: import_v43.z.literal("content-end"),
-    index: import_v43.z.number()
+  z3.object({
+    type: z3.literal("content-end"),
+    index: z3.number()
   }),
-  import_v43.z.object({
-    type: import_v43.z.literal("message-start"),
-    id: import_v43.z.string().nullish()
+  z3.object({
+    type: z3.literal("message-start"),
+    id: z3.string().nullish()
   }),
-  import_v43.z.object({
-    type: import_v43.z.literal("message-end"),
-    delta: import_v43.z.object({
-      finish_reason: import_v43.z.string(),
-      usage: import_v43.z.object({
-        tokens: import_v43.z.object({
-          input_tokens: import_v43.z.number(),
-          output_tokens: import_v43.z.number()
+  z3.object({
+    type: z3.literal("message-end"),
+    delta: z3.object({
+      finish_reason: z3.string(),
+      usage: z3.object({
+        tokens: z3.object({
+          input_tokens: z3.number(),
+          output_tokens: z3.number()
         })
       })
     })
   }),
   // https://docs.cohere.com/v2/docs/streaming#tool-use-stream-events-for-tool-calling
-  import_v43.z.object({
-    type: import_v43.z.literal("tool-plan-delta"),
-    delta: import_v43.z.object({
-      message: import_v43.z.object({
-        tool_plan: import_v43.z.string()
+  z3.object({
+    type: z3.literal("tool-plan-delta"),
+    delta: z3.object({
+      message: z3.object({
+        tool_plan: z3.string()
       })
     })
   }),
-  import_v43.z.object({
-    type: import_v43.z.literal("tool-call-start"),
-    delta: import_v43.z.object({
-      message: import_v43.z.object({
-        tool_calls: import_v43.z.object({
-          id: import_v43.z.string(),
-          type: import_v43.z.literal("function"),
-          function: import_v43.z.object({
-            name: import_v43.z.string(),
-            arguments: import_v43.z.string()
+  z3.object({
+    type: z3.literal("tool-call-start"),
+    delta: z3.object({
+      message: z3.object({
+        tool_calls: z3.object({
+          id: z3.string(),
+          type: z3.literal("function"),
+          function: z3.object({
+            name: z3.string(),
+            arguments: z3.string()
           })
         })
       })
@@ -803,31 +794,38 @@ var cohereChatChunkSchema = import_v43.z.discriminatedUnion("type", [
   // A single tool call's `arguments` stream in chunks and must be accumulated
   // in a string and so the full tool object info can only be parsed once we see
   // `tool-call-end`.
-  import_v43.z.object({
-    type: import_v43.z.literal("tool-call-delta"),
-    delta: import_v43.z.object({
-      message: import_v43.z.object({
-        tool_calls: import_v43.z.object({
-          function: import_v43.z.object({
-            arguments: import_v43.z.string()
+  z3.object({
+    type: z3.literal("tool-call-delta"),
+    delta: z3.object({
+      message: z3.object({
+        tool_calls: z3.object({
+          function: z3.object({
+            arguments: z3.string()
           })
         })
       })
     })
   }),
-  import_v43.z.object({
-    type: import_v43.z.literal("tool-call-end")
+  z3.object({
+    type: z3.literal("tool-call-end")
   })
 ]);
 
 // src/cohere-embedding-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi2
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
 
 // src/cohere-embedding-options.ts
-var import_v44 = require("zod/v4");
-var cohereEmbeddingModelOptions = import_v44.z.object({
+import { z as z4 } from "zod/v4";
+var cohereEmbeddingModelOptions = z4.object({
   /**
    * Specifies the type of input passed to the model. Default is `search_query`.
    *
@@ -836,7 +834,7 @@ var cohereEmbeddingModelOptions = import_v44.z.object({
    * - "classification": Used for embeddings passed through a text classifier.
    * - "clustering": Used for embeddings run through a clustering algorithm.
    */
-  inputType: import_v44.z.enum(["search_document", "search_query", "classification", "clustering"]).optional(),
+  inputType: z4.enum(["search_document", "search_query", "classification", "clustering"]).optional(),
   /**
    * Specifies how the API will handle inputs longer than the maximum token length.
    * Default is `END`.
@@ -845,7 +843,7 @@ var cohereEmbeddingModelOptions = import_v44.z.object({
    * - "START": Will discard the start of the input until the remaining input is exactly the maximum input token length for the model.
    * - "END": Will discard the end of the input until the remaining input is exactly the maximum input token length for the model.
    */
-  truncate: import_v44.z.enum(["NONE", "START", "END"]).optional(),
+  truncate: z4.enum(["NONE", "START", "END"]).optional(),
   /**
    * The number of dimensions of the output embedding.
    * Only available for `embed-v4.0` and newer models.
@@ -853,7 +851,7 @@ var cohereEmbeddingModelOptions = import_v44.z.object({
    * Possible values are `256`, `512`, `1024`, and `1536`.
    * The default is `1536`.
    */
-  outputDimension: import_v44.z.union([import_v44.z.literal(256), import_v44.z.literal(512), import_v44.z.literal(1024), import_v44.z.literal(1536)]).optional()
+  outputDimension: z4.union([z4.literal(256), z4.literal(512), z4.literal(1024), z4.literal(1536)]).optional()
 });
 
 // src/cohere-embedding-model.ts
@@ -875,13 +873,13 @@ var CohereEmbeddingModel = class {
     providerOptions
   }) {
     var _a;
-    const embeddingOptions = await (0, import_provider_utils4.parseProviderOptions)({
+    const embeddingOptions = await parseProviderOptions2({
       provider: "cohere",
       providerOptions,
       schema: cohereEmbeddingModelOptions
     });
     if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider3.TooManyEmbeddingValuesForCallError({
+      throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
         modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
@@ -892,9 +890,9 @@ var CohereEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils4.postJsonToApi)({
+    } = await postJsonToApi2({
       url: `${this.config.baseURL}/embed`,
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders2(this.config.headers(), headers),
       body: {
         model: this.modelId,
         // The AI SDK only supports 'float' embeddings. Note that the Cohere API
@@ -907,7 +905,7 @@ var CohereEmbeddingModel = class {
         output_dimension: embeddingOptions == null ? void 0 : embeddingOptions.outputDimension
       },
       failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         cohereTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -921,46 +919,51 @@ var CohereEmbeddingModel = class {
     };
   }
 };
-var cohereTextEmbeddingResponseSchema = import_v45.z.object({
-  embeddings: import_v45.z.object({
-    float: import_v45.z.array(import_v45.z.array(import_v45.z.number()))
+var cohereTextEmbeddingResponseSchema = z5.object({
+  embeddings: z5.object({
+    float: z5.array(z5.array(z5.number()))
   }),
-  meta: import_v45.z.object({
-    billed_units: import_v45.z.object({
-      input_tokens: import_v45.z.number()
+  meta: z5.object({
+    billed_units: z5.object({
+      input_tokens: z5.number()
     })
   })
 });
 
 // src/reranking/cohere-reranking-model.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3
+} from "@ai-sdk/provider-utils";
 
 // src/reranking/cohere-reranking-api.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var cohereRerankingResponseSchema = (0, import_provider_utils5.lazySchema)(
-  () => (0, import_provider_utils5.zodSchema)(
-    import_v46.z.object({
-      id: import_v46.z.string().nullish(),
-      results: import_v46.z.array(
-        import_v46.z.object({
-          index: import_v46.z.number(),
-          relevance_score: import_v46.z.number()
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var cohereRerankingResponseSchema = lazySchema(
+  () => zodSchema(
+    z6.object({
+      id: z6.string().nullish(),
+      results: z6.array(
+        z6.object({
+          index: z6.number(),
+          relevance_score: z6.number()
         })
       ),
-      meta: import_v46.z.any()
+      meta: z6.any()
     })
   )
 );
 
 // src/reranking/cohere-reranking-options.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-var cohereRerankingModelOptionsSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    import_v47.z.object({
-      maxTokensPerDoc: import_v47.z.number().optional(),
-      priority: import_v47.z.number().optional()
+import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var cohereRerankingModelOptionsSchema = lazySchema2(
+  () => zodSchema2(
+    z7.object({
+      maxTokensPerDoc: z7.number().optional(),
+      priority: z7.number().optional()
     })
   )
 );
@@ -985,7 +988,7 @@ var CohereRerankingModel = class {
     providerOptions
   }) {
     var _a;
-    const rerankingOptions = await (0, import_provider_utils7.parseProviderOptions)({
+    const rerankingOptions = await parseProviderOptions3({
       provider: "cohere",
       providerOptions,
       schema: cohereRerankingModelOptionsSchema
@@ -1002,9 +1005,9 @@ var CohereRerankingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils7.postJsonToApi)({
+    } = await postJsonToApi3({
       url: `${this.config.baseURL}/rerank`,
-      headers: (0, import_provider_utils7.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders3(this.config.headers(), headers),
       body: {
         model: this.modelId,
         query,
@@ -1014,7 +1017,7 @@ var CohereRerankingModel = class {
         priority: rerankingOptions == null ? void 0 : rerankingOptions.priority
       },
       failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils7.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         cohereRerankingResponseSchema
       ),
       abortSignal,
@@ -1036,15 +1039,15 @@ var CohereRerankingModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.0-beta.20" : "0.0.0-test";
+var VERSION = true ? "4.0.0-beta.21" : "0.0.0-test";
 
 // src/cohere-provider.ts
 function createCohere(options = {}) {
   var _a;
-  const baseURL = (_a = (0, import_provider_utils8.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://api.cohere.com/v2";
-  const getHeaders = () => (0, import_provider_utils8.withUserAgentSuffix)(
+  const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://api.cohere.com/v2";
+  const getHeaders = () => withUserAgentSuffix(
     {
-      Authorization: `Bearer ${(0, import_provider_utils8.loadApiKey)({
+      Authorization: `Bearer ${loadApiKey({
         apiKey: options.apiKey,
         environmentVariableName: "COHERE_API_KEY",
         description: "Cohere"
@@ -1060,7 +1063,7 @@ function createCohere(options = {}) {
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils8.generateId
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId
     });
   };
   const createEmbeddingModel = (modelId) => new CohereEmbeddingModel(modelId, {
@@ -1092,15 +1095,14 @@ function createCohere(options = {}) {
   provider.reranking = createRerankingModel;
   provider.rerankingModel = createRerankingModel;
   provider.imageModel = (modelId) => {
-    throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
   };
   return provider;
 }
 var cohere = createCohere();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   VERSION,
   cohere,
   createCohere
-});
+};
 //# sourceMappingURL=index.js.map