@ai-sdk/cohere 4.0.0-beta.5 → 4.0.0-beta.53

package/dist/index.js

@@ -1,42 +1,33 @@
-"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_utils7 = 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_utils2 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  parseProviderOptions as parseProviderOptions2,
+  parseJSON,
+  postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} 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({
+// src/cohere-chat-language-model-options.ts
+import { z } from "zod/v4";
+var cohereLanguageModelChatOptions = z.object({
   /**
    * Configuration for reasoning features (optional)
    *
@@ -45,25 +36,35 @@ 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()
 });
+var cohereImagePartProviderOptions = z.object({
+  /**
+   * Image fidelity level passed through as `image_url.detail` on the Cohere chat API.
+   *
+   * @see https://docs.cohere.com/docs/image-inputs
+   */
+  detail: z.enum(["auto", "low", "high"]).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 +113,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -156,8 +157,17 @@ function convertCohereUsage(tokens) {
 }
 
 // src/convert-to-cohere-chat-prompt.ts
-var import_provider2 = require("@ai-sdk/provider");
-function convertToCohereChatPrompt(prompt) {
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+import {
+  convertToBase64,
+  getTopLevelMediaType,
+  parseProviderOptions,
+  resolveFullMediaType
+} from "@ai-sdk/provider-utils";
+async function convertToCohereChatPrompt(prompt) {
+  var _a;
   const messages = [];
   const documents = [];
   const warnings = [];
@@ -168,43 +178,74 @@ function convertToCohereChatPrompt(prompt) {
         break;
       }
       case "user": {
-        messages.push({
-          role: "user",
-          content: content.map((part) => {
-            var _a;
-            switch (part.type) {
-              case "text": {
-                return part.text;
+        const userContentParts = [];
+        let hasImage = false;
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              if (part.text.length > 0) {
+                userContentParts.push({ type: "text", text: part.text });
               }
-              case "file": {
-                let textContent;
-                if (typeof part.data === "string") {
-                  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({
-                      functionality: `document media type: ${part.mediaType}`,
-                      message: `Media type '${part.mediaType}' is not supported. Supported media types are: text/* and application/json.`
-                    });
+              break;
+            }
+            case "file": {
+              if (getTopLevelMediaType(part.mediaType) === "image") {
+                hasImage = true;
+                const url = buildImageUrl({ part });
+                const cohereOptions = (_a = await parseProviderOptions({
+                  provider: "cohere",
+                  providerOptions: part.providerOptions,
+                  schema: cohereImagePartProviderOptions
+                })) != null ? _a : {};
+                userContentParts.push({
+                  type: "image_url",
+                  image_url: {
+                    url,
+                    ...cohereOptions.detail ? { detail: cohereOptions.detail } : {}
                   }
-                  textContent = new TextDecoder().decode(part.data);
-                } else {
-                  throw new import_provider2.UnsupportedFunctionalityError({
+                });
+                break;
+              }
+              let textContent;
+              switch (part.data.type) {
+                case "reference": {
+                  throw new UnsupportedFunctionalityError2({
+                    functionality: "file parts with provider references"
+                  });
+                }
+                case "url": {
+                  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."
                   });
                 }
-                documents.push({
-                  data: {
-                    text: textContent,
-                    title: part.filename
-                  }
-                });
-                return "";
+                case "text": {
+                  textContent = part.data.text;
+                  break;
+                }
+                case "data": {
+                  textContent = typeof part.data.data === "string" ? part.data.data : new TextDecoder().decode(part.data.data);
+                  break;
+                }
               }
+              documents.push({
+                data: {
+                  text: textContent,
+                  title: part.filename
+                }
+              });
+              break;
             }
-          }).join("")
-        });
+          }
+        }
+        if (hasImage) {
+          messages.push({ role: "user", content: userContentParts });
+        } else {
+          messages.push({
+            role: "user",
+            content: userContentParts.map((p) => p.type === "text" ? p.text : "").join("")
+          });
+        }
         break;
       }
       case "assistant": {
@@ -240,7 +281,7 @@ function convertToCohereChatPrompt(prompt) {
       case "tool": {
         messages.push(
           ...content.filter((toolResult) => toolResult.type !== "tool-approval-response").map((toolResult) => {
-            var _a;
+            var _a2;
             const output = toolResult.output;
             let contentValue;
             switch (output.type) {
@@ -249,7 +290,7 @@ function convertToCohereChatPrompt(prompt) {
                 contentValue = output.value;
                 break;
               case "execution-denied":
-                contentValue = (_a = output.reason) != null ? _a : "Tool execution denied.";
+                contentValue = (_a2 = output.reason) != null ? _a2 : "Tool call execution denied.";
                 break;
               case "content":
               case "json":
@@ -274,6 +315,26 @@ function convertToCohereChatPrompt(prompt) {
   }
   return { messages, documents, warnings };
 }
+function buildImageUrl({ part }) {
+  switch (part.data.type) {
+    case "url": {
+      return part.data.url.toString();
+    }
+    case "data": {
+      return `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`;
+    }
+    case "reference": {
+      throw new UnsupportedFunctionalityError2({
+        functionality: "image file parts with provider references"
+      });
+    }
+    case "text": {
+      throw new UnsupportedFunctionalityError2({
+        functionality: "image file parts with text data"
+      });
+    }
+  }
+}
 
 // src/map-cohere-finish-reason.ts
 function mapCohereFinishReason(finishReason) {
@@ -293,15 +354,24 @@ function mapCohereFinishReason(finishReason) {
 }
 
 // src/cohere-chat-language-model.ts
-var CohereChatLanguageModel = class {
+var CohereChatLanguageModel = class _CohereChatLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.supportedUrls = {
-      // No URLs are supported.
+      "image/*": [/^https?:\/\/.*$/]
     };
     this.modelId = modelId;
     this.config = config;
   }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _CohereChatLanguageModel(options.modelId, options.config);
+  }
   get provider() {
     return this.config.provider;
   }
@@ -316,26 +386,29 @@ var CohereChatLanguageModel = class {
     stopSequences,
     responseFormat,
     seed,
+    reasoning,
     tools,
     toolChoice,
     providerOptions
   }) {
-    var _a, _b;
-    const cohereOptions = (_a = await (0, import_provider_utils2.parseProviderOptions)({
+    var _a;
+    const warnings = [];
+    const cohereOptions = (_a = await parseProviderOptions2({
       provider: "cohere",
       providerOptions,
-      schema: cohereLanguageModelOptions
+      schema: cohereLanguageModelChatOptions
     })) != null ? _a : {};
     const {
       messages: chatPrompt,
       documents: cohereDocuments,
       warnings: promptWarnings
-    } = convertToCohereChatPrompt(prompt);
+    } = await convertToCohereChatPrompt(prompt);
     const {
       tools: cohereTools,
       toolChoice: cohereToolChoice,
       toolWarnings
     } = prepareTools({ tools, toolChoice });
+    warnings.push(...toolWarnings, ...promptWarnings);
     return {
       args: {
         // model id:
@@ -358,37 +431,36 @@ var CohereChatLanguageModel = class {
         tool_choice: cohereToolChoice,
         // documents for RAG:
         ...cohereDocuments.length > 0 && { documents: cohereDocuments },
-        // reasoning
-        ...cohereOptions.thinking && {
-          thinking: {
-            type: (_b = cohereOptions.thinking.type) != null ? _b : "enabled",
-            token_budget: cohereOptions.thinking.tokenBudget
-          }
-        }
+        // reasoning:
+        ...resolveCohereThinking({
+          reasoning,
+          cohereOptions,
+          warnings
+        })
       },
-      warnings: [...toolWarnings, ...promptWarnings]
+      warnings
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const { args, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils2.postJsonToApi)({
+    } = await postJsonToApi({
       url: `${this.config.baseURL}/chat`,
-      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body: args,
       failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         cohereChatResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     const content = [];
-    for (const item of (_a = response.message.content) != null ? _a : []) {
+    for (const item of (_c = response.message.content) != null ? _c : []) {
       if (item.type === "text" && item.text.length > 0) {
         content.push({ type: "text", text: item.text });
         continue;
@@ -398,13 +470,13 @@ var CohereChatLanguageModel = class {
         continue;
       }
     }
-    for (const citation of (_b = response.message.citations) != null ? _b : []) {
+    for (const citation of (_d = response.message.citations) != null ? _d : []) {
       content.push({
         type: "source",
         sourceType: "document",
         id: this.config.generateId(),
         mediaType: "text/plain",
-        title: ((_d = (_c = citation.sources[0]) == null ? void 0 : _c.document) == null ? void 0 : _d.title) || "Document",
+        title: ((_f = (_e = citation.sources[0]) == null ? void 0 : _e.document) == null ? void 0 : _f.title) || "Document",
         providerMetadata: {
           cohere: {
             start: citation.start,
@@ -416,7 +488,7 @@ var CohereChatLanguageModel = class {
         }
       });
     }
-    for (const toolCall of (_e = response.message.tool_calls) != null ? _e : []) {
+    for (const toolCall of (_g = response.message.tool_calls) != null ? _g : []) {
       content.push({
         type: "tool-call",
         toolCallId: toolCall.id,
@@ -430,13 +502,13 @@ var CohereChatLanguageModel = class {
       content,
       finishReason: {
         unified: mapCohereFinishReason(response.finish_reason),
-        raw: (_f = response.finish_reason) != null ? _f : void 0
+        raw: (_h = response.finish_reason) != null ? _h : void 0
       },
       usage: convertCohereUsage(response.usage.tokens),
       request: { body: args },
       response: {
         // TODO timestamp, model id
-        id: (_g = response.generation_id) != null ? _g : void 0,
+        id: (_i = response.generation_id) != null ? _i : void 0,
         headers: responseHeaders,
         body: rawResponse
       },
@@ -444,13 +516,14 @@ var CohereChatLanguageModel = class {
     };
   }
   async doStream(options) {
+    var _a, _b;
     const { args, warnings } = await this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils2.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: `${this.config.baseURL}/chat`,
-      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body: { ...args, stream: true },
       failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         cohereChatChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -469,8 +542,8 @@ var CohereChatLanguageModel = class {
           start(controller) {
             controller.enqueue({ type: "stream-start", warnings });
           },
-          transform(chunk, controller) {
-            var _a, _b;
+          async transform(chunk, controller) {
+            var _a2, _b2;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -575,7 +648,9 @@ var CohereChatLanguageModel = class {
                     toolCallId: pendingToolCall.id,
                     toolName: pendingToolCall.name,
                     input: JSON.stringify(
-                      JSON.parse(((_a = pendingToolCall.arguments) == null ? void 0 : _a.trim()) || "{}")
+                      await parseJSON({
+                        text: ((_a2 = pendingToolCall.arguments) == null ? void 0 : _a2.trim()) || "{}"
+                      })
                     )
                   });
                   pendingToolCall.hasFinished = true;
@@ -586,7 +661,7 @@ var CohereChatLanguageModel = class {
               case "message-start": {
                 controller.enqueue({
                   type: "response-metadata",
-                  id: (_b = value.id) != null ? _b : void 0
+                  id: (_b2 = value.id) != null ? _b2 : void 0
                 });
                 return;
               }
@@ -617,145 +692,176 @@ var CohereChatLanguageModel = class {
     };
   }
 };
-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()
+function resolveCohereThinking({
+  reasoning,
+  cohereOptions,
+  warnings
+}) {
+  var _a;
+  if (cohereOptions.thinking) {
+    return {
+      thinking: {
+        type: (_a = cohereOptions.thinking.type) != null ? _a : "enabled",
+        token_budget: cohereOptions.thinking.tokenBudget
+      }
+    };
+  }
+  if (!isCustomReasoning(reasoning)) {
+    return {};
+  }
+  if (reasoning === "none") {
+    return { thinking: { type: "disabled" } };
+  }
+  const tokenBudget = mapReasoningToProviderBudget({
+    reasoning,
+    maxOutputTokens: 32768,
+    maxReasoningBudget: 32768,
+    warnings
+  });
+  if (tokenBudget == null) {
+    return {};
+  }
+  return { thinking: { type: "enabled", token_budget: tokenBudget } };
+}
+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()
           })
         })
       })
@@ -764,31 +870,41 @@ 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_utils3 = 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 parseProviderOptions3,
+  postJsonToApi as postJsonToApi2,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
+} 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({
+// src/cohere-embedding-model-options.ts
+import { z as z4 } from "zod/v4";
+var cohereEmbeddingModelOptions = z4.object({
   /**
    * Specifies the type of input passed to the model. Default is `search_query`.
    *
@@ -797,7 +913,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`.
@@ -806,7 +922,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.
@@ -814,11 +930,11 @@ 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
-var CohereEmbeddingModel = class {
+var CohereEmbeddingModel = class _CohereEmbeddingModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.maxEmbeddingsPerCall = 96;
@@ -826,6 +942,15 @@ var CohereEmbeddingModel = class {
     this.modelId = modelId;
     this.config = config;
   }
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _CohereEmbeddingModel(options.modelId, options.config);
+  }
   get provider() {
     return this.config.provider;
   }
@@ -835,14 +960,14 @@ var CohereEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    var _a;
-    const embeddingOptions = await (0, import_provider_utils3.parseProviderOptions)({
+    var _a, _b, _c;
+    const embeddingOptions = await parseProviderOptions3({
       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,
@@ -853,9 +978,9 @@ var CohereEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await postJsonToApi2({
       url: `${this.config.baseURL}/embed`,
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders2((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), headers),
       body: {
         model: this.modelId,
         // The AI SDK only supports 'float' embeddings. Note that the Cohere API
@@ -863,12 +988,12 @@ var CohereEmbeddingModel = class {
         // https://docs.cohere.com/v2/reference/embed#request.body.embedding_types
         embedding_types: ["float"],
         texts: values,
-        input_type: (_a = embeddingOptions == null ? void 0 : embeddingOptions.inputType) != null ? _a : "search_query",
+        input_type: (_c = embeddingOptions == null ? void 0 : embeddingOptions.inputType) != null ? _c : "search_query",
         truncate: embeddingOptions == null ? void 0 : embeddingOptions.truncate,
         output_dimension: embeddingOptions == null ? void 0 : embeddingOptions.outputDimension
       },
       failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         cohereTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -882,46 +1007,54 @@ 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_utils6 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi3
+} from "@ai-sdk/provider-utils";
 
 // src/reranking/cohere-reranking-api.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var cohereRerankingResponseSchema = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.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_utils5 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-var cohereRerankingModelOptionsSchema = (0, import_provider_utils5.lazySchema)(
-  () => (0, import_provider_utils5.zodSchema)(
-    import_v47.z.object({
-      maxTokensPerDoc: import_v47.z.number().optional(),
-      priority: import_v47.z.number().optional()
+// src/reranking/cohere-reranking-model-options.ts
+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()
     })
   )
 );
@@ -946,7 +1079,7 @@ var CohereRerankingModel = class {
     providerOptions
   }) {
     var _a;
-    const rerankingOptions = await (0, import_provider_utils6.parseProviderOptions)({
+    const rerankingOptions = await parseProviderOptions4({
       provider: "cohere",
       providerOptions,
       schema: cohereRerankingModelOptionsSchema
@@ -963,9 +1096,9 @@ var CohereRerankingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils6.postJsonToApi)({
+    } = await postJsonToApi3({
       url: `${this.config.baseURL}/rerank`,
-      headers: (0, import_provider_utils6.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders3(this.config.headers(), headers),
       body: {
         model: this.modelId,
         query,
@@ -975,7 +1108,7 @@ var CohereRerankingModel = class {
         priority: rerankingOptions == null ? void 0 : rerankingOptions.priority
       },
       failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         cohereRerankingResponseSchema
       ),
       abortSignal,
@@ -997,15 +1130,15 @@ var CohereRerankingModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.0-beta.5" : "0.0.0-test";
+var VERSION = true ? "4.0.0-beta.53" : "0.0.0-test";
 
 // src/cohere-provider.ts
 function createCohere(options = {}) {
   var _a;
-  const baseURL = (_a = (0, import_provider_utils7.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://api.cohere.com/v2";
-  const getHeaders = () => (0, import_provider_utils7.withUserAgentSuffix)(
+  const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://api.cohere.com/v2";
+  const getHeaders = () => withUserAgentSuffix(
     {
-      Authorization: `Bearer ${(0, import_provider_utils7.loadApiKey)({
+      Authorization: `Bearer ${loadApiKey({
         apiKey: options.apiKey,
         environmentVariableName: "COHERE_API_KEY",
         description: "Cohere"
@@ -1021,7 +1154,7 @@ function createCohere(options = {}) {
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils7.generateId
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId
     });
   };
   const createEmbeddingModel = (modelId) => new CohereEmbeddingModel(modelId, {
@@ -1053,15 +1186,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