@ai-sdk/cohere 4.0.52 → 4.0.54

package/dist/index.js

@@ -1,1171 +1,918 @@
-// src/cohere-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
-import {
-  generateId,
-  loadApiKey,
-  withoutTrailingSlash,
-  withUserAgentSuffix
-} from "@ai-sdk/provider-utils";
-
-// src/cohere-chat-language-model.ts
-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-language-model-options.ts
+import { NoSuchModelError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createNullLanguageModelUsage, generateId, getTopLevelMediaType, isCustomReasoning, lazySchema, loadApiKey, mapReasoningToProviderBudget, parseJSON, parseProviderOptions, postJsonToApi, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
-var cohereLanguageModelChatOptions = z.object({
-  /**
-   * Configuration for reasoning features (optional)
-   *
-   * Can be set to an object with the two properties `type` and `tokenBudget`. `type` can be set to `'enabled'` or `'disabled'` (defaults to `'enabled'`).
-   * `tokenBudget` is the maximum number of tokens the model can use for thinking, which must be set to a positive integer. The model will stop thinking if it reaches the thinking token budget and will proceed with the response
-   *
-   * @see https://docs.cohere.com/reference/chat#request.body.thinking
-   */
-  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
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod/v4";
-var cohereErrorDataSchema = z2.object({
-  message: z2.string()
-});
-var cohereFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: cohereErrorDataSchema,
-  errorToMessage: (data) => data.message
+//#region src/cohere-chat-language-model-options.ts
+const cohereLanguageModelChatOptions = z.object({ 
+/**
+* Configuration for reasoning features (optional)
+*
+* Can be set to an object with the two properties `type` and `tokenBudget`. `type` can be set to `'enabled'` or `'disabled'` (defaults to `'enabled'`).
+* `tokenBudget` is the maximum number of tokens the model can use for thinking, which must be set to a positive integer. The model will stop thinking if it reaches the thinking token budget and will proceed with the response
+*
+* @see https://docs.cohere.com/reference/chat#request.body.thinking
+*/
+thinking: z.object({
+	type: z.enum(["enabled", "disabled"]).optional(),
+	tokenBudget: z.number().optional()
+}).optional() });
+const 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() });
+//#endregion
+//#region src/cohere-error.ts
+const cohereErrorDataSchema = z.object({ message: z.string() });
+const cohereFailedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema: cohereErrorDataSchema,
+	errorToMessage: (data) => data.message
 });
-
-// src/cohere-prepare-tools.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-function prepareTools({
-  tools,
-  toolChoice
-}) {
-  tools = tools?.length ? tools : void 0;
-  const toolWarnings = [];
-  if (tools == null) {
-    return { tools: void 0, toolChoice: void 0, toolWarnings };
-  }
-  const cohereTools = [];
-  for (const tool of tools) {
-    if (tool.type === "provider") {
-      toolWarnings.push({
-        type: "unsupported",
-        feature: `provider-defined tool ${tool.id}`
-      });
-    } else {
-      cohereTools.push({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.inputSchema
-        }
-      });
-    }
-  }
-  if (toolChoice == null) {
-    return { tools: cohereTools, toolChoice: void 0, toolWarnings };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-      return { tools: cohereTools, toolChoice: void 0, toolWarnings };
-    case "none":
-      return { tools: cohereTools, toolChoice: "NONE", toolWarnings };
-    case "required":
-      return { tools: cohereTools, toolChoice: "REQUIRED", toolWarnings };
-    case "tool":
-      return {
-        tools: cohereTools.filter(
-          (tool) => tool.function.name === toolChoice.toolName
-        ),
-        toolChoice: "REQUIRED",
-        toolWarnings
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError({
-        functionality: `tool choice type: ${_exhaustiveCheck}`
-      });
-    }
-  }
+//#endregion
+//#region src/cohere-prepare-tools.ts
+function prepareTools({ tools, toolChoice }) {
+	tools = tools?.length ? tools : void 0;
+	const toolWarnings = [];
+	if (tools == null) return {
+		tools: void 0,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const cohereTools = [];
+	for (const tool of tools) if (tool.type === "provider") toolWarnings.push({
+		type: "unsupported",
+		feature: `provider-defined tool ${tool.id}`
+	});
+	else cohereTools.push({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.inputSchema
+		}
+	});
+	if (toolChoice == null) return {
+		tools: cohereTools,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const type = toolChoice.type;
+	switch (type) {
+		case "auto": return {
+			tools: cohereTools,
+			toolChoice: void 0,
+			toolWarnings
+		};
+		case "none": return {
+			tools: cohereTools,
+			toolChoice: "NONE",
+			toolWarnings
+		};
+		case "required": return {
+			tools: cohereTools,
+			toolChoice: "REQUIRED",
+			toolWarnings
+		};
+		case "tool": return {
+			tools: cohereTools.filter((tool) => tool.function.name === toolChoice.toolName),
+			toolChoice: "REQUIRED",
+			toolWarnings
+		};
+		default: throw new UnsupportedFunctionalityError({ functionality: `tool choice type: ${type}` });
+	}
 }
-
-// src/convert-cohere-usage.ts
-import { createNullLanguageModelUsage } from "@ai-sdk/provider-utils";
+//#endregion
+//#region src/convert-cohere-usage.ts
 function convertCohereUsage(usage) {
-  if (usage == null) {
-    return createNullLanguageModelUsage();
-  }
-  const tokens = usage.tokens;
-  const inputTokens = tokens.input_tokens;
-  const outputTokens = tokens.output_tokens;
-  return {
-    inputTokens: {
-      total: inputTokens,
-      noCache: inputTokens,
-      cacheRead: void 0,
-      cacheWrite: void 0
-    },
-    outputTokens: {
-      total: outputTokens,
-      text: outputTokens,
-      reasoning: void 0
-    },
-    raw: usage
-  };
+	if (usage == null) return createNullLanguageModelUsage();
+	const tokens = usage.tokens;
+	const inputTokens = tokens.input_tokens;
+	const outputTokens = tokens.output_tokens;
+	return {
+		inputTokens: {
+			total: inputTokens,
+			noCache: inputTokens,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: outputTokens,
+			text: outputTokens,
+			reasoning: void 0
+		},
+		raw: usage
+	};
 }
-
-// src/convert-to-cohere-chat-prompt.ts
-import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
-} from "@ai-sdk/provider";
-import {
-  convertToBase64,
-  getTopLevelMediaType,
-  parseProviderOptions,
-  resolveFullMediaType
-} from "@ai-sdk/provider-utils";
+//#endregion
+//#region src/convert-to-cohere-chat-prompt.ts
 async function convertToCohereChatPrompt(prompt) {
-  const messages = [];
-  const documents = [];
-  const warnings = [];
-  for (const { role, content } of prompt) {
-    switch (role) {
-      case "system": {
-        messages.push({ role: "system", content });
-        break;
-      }
-      case "user": {
-        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 });
-              }
-              break;
-            }
-            case "file": {
-              if (getTopLevelMediaType(part.mediaType) === "image") {
-                hasImage = true;
-                const url = buildImageUrl({ part });
-                const cohereOptions = await parseProviderOptions({
-                  provider: "cohere",
-                  providerOptions: part.providerOptions,
-                  schema: cohereImagePartProviderOptions
-                }) ?? {};
-                userContentParts.push({
-                  type: "image_url",
-                  image_url: {
-                    url,
-                    ...cohereOptions.detail ? { detail: cohereOptions.detail } : {}
-                  }
-                });
-                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."
-                  });
-                }
-                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;
-            }
-          }
-        }
-        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": {
-        let text = "";
-        const toolCalls = [];
-        for (const part of content) {
-          switch (part.type) {
-            case "text": {
-              text += part.text;
-              break;
-            }
-            case "tool-call": {
-              toolCalls.push({
-                id: part.toolCallId,
-                type: "function",
-                function: {
-                  name: part.toolName,
-                  arguments: JSON.stringify(part.input)
-                }
-              });
-              break;
-            }
-          }
-        }
-        messages.push({
-          role: "assistant",
-          content: toolCalls.length > 0 ? void 0 : text,
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
-          tool_plan: void 0
-        });
-        break;
-      }
-      case "tool": {
-        messages.push(
-          ...content.filter((toolResult) => toolResult.type !== "tool-approval-response").map((toolResult) => {
-            const output = toolResult.output;
-            let contentValue;
-            switch (output.type) {
-              case "text":
-              case "error-text":
-                contentValue = output.value;
-                break;
-              case "execution-denied":
-                contentValue = output.reason ?? "Tool call execution denied.";
-                break;
-              case "content":
-              case "json":
-              case "error-json":
-                contentValue = JSON.stringify(output.value);
-                break;
-            }
-            return {
-              role: "tool",
-              content: contentValue,
-              tool_call_id: toolResult.toolCallId
-            };
-          })
-        );
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-  return { messages, documents, warnings };
+	const messages = [];
+	const documents = [];
+	const warnings = [];
+	for (const { role, content } of prompt) switch (role) {
+		case "system":
+			messages.push({
+				role: "system",
+				content
+			});
+			break;
+		case "user": {
+			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
+					});
+					break;
+				case "file": {
+					if (getTopLevelMediaType(part.mediaType) === "image") {
+						hasImage = true;
+						const url = buildImageUrl({ part });
+						const cohereOptions = await parseProviderOptions({
+							provider: "cohere",
+							providerOptions: part.providerOptions,
+							schema: cohereImagePartProviderOptions
+						}) ?? {};
+						userContentParts.push({
+							type: "image_url",
+							image_url: {
+								url,
+								...cohereOptions.detail ? { detail: cohereOptions.detail } : {}
+							}
+						});
+						break;
+					}
+					let textContent;
+					switch (part.data.type) {
+						case "reference": throw new UnsupportedFunctionalityError({ functionality: "file parts with provider references" });
+						case "url": throw new UnsupportedFunctionalityError({
+							functionality: "File URL data",
+							message: "URLs should be downloaded by the AI SDK and not reach this point. This indicates a configuration issue."
+						});
+						case "text":
+							textContent = part.data.text;
+							break;
+						case "data": textContent = typeof part.data.data === "string" ? part.data.data : new TextDecoder().decode(part.data.data);
+					}
+					documents.push({ data: {
+						text: textContent,
+						title: part.filename
+					} });
+					break;
+				}
+			}
+			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": {
+			let text = "";
+			const toolCalls = [];
+			for (const part of content) switch (part.type) {
+				case "text":
+					text += part.text;
+					break;
+				case "tool-call": toolCalls.push({
+					id: part.toolCallId,
+					type: "function",
+					function: {
+						name: part.toolName,
+						arguments: JSON.stringify(part.input)
+					}
+				});
+			}
+			messages.push({
+				role: "assistant",
+				content: toolCalls.length > 0 ? void 0 : text,
+				tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+				tool_plan: void 0
+			});
+			break;
+		}
+		case "tool":
+			messages.push(...content.filter((toolResult) => toolResult.type !== "tool-approval-response").map((toolResult) => {
+				const output = toolResult.output;
+				let contentValue;
+				switch (output.type) {
+					case "text":
+					case "error-text":
+						contentValue = output.value;
+						break;
+					case "execution-denied":
+						contentValue = output.reason ?? "Tool call execution denied.";
+						break;
+					case "content":
+					case "json":
+					case "error-json": contentValue = JSON.stringify(output.value);
+				}
+				return {
+					role: "tool",
+					content: contentValue,
+					tool_call_id: toolResult.toolCallId
+				};
+			}));
+			break;
+		default: throw new Error(`Unsupported role: ${role}`);
+	}
+	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"
-      });
-    }
-  }
+	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 UnsupportedFunctionalityError({ functionality: "image file parts with provider references" });
+		case "text": throw new UnsupportedFunctionalityError({ functionality: "image file parts with text data" });
+	}
 }
-
-// src/map-cohere-finish-reason.ts
+//#endregion
+//#region src/map-cohere-finish-reason.ts
 function mapCohereFinishReason(finishReason) {
-  switch (finishReason) {
-    case "COMPLETE":
-    case "STOP_SEQUENCE":
-      return "stop";
-    case "MAX_TOKENS":
-      return "length";
-    case "ERROR":
-      return "error";
-    case "TOOL_CALL":
-      return "tool-calls";
-    default:
-      return "other";
-  }
+	switch (finishReason) {
+		case "COMPLETE":
+		case "STOP_SEQUENCE": return "stop";
+		case "MAX_TOKENS": return "length";
+		case "ERROR": return "error";
+		case "TOOL_CALL": return "tool-calls";
+		default: return "other";
+	}
 }
-
-// src/cohere-chat-language-model.ts
-var CohereChatLanguageModel = class _CohereChatLanguageModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    this.supportedUrls = {
-      "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;
-  }
-  async getArgs({
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    frequencyPenalty,
-    presencePenalty,
-    stopSequences,
-    responseFormat,
-    seed,
-    reasoning,
-    tools,
-    toolChoice,
-    providerOptions
-  }) {
-    const warnings = [];
-    const cohereOptions = await parseProviderOptions2({
-      provider: "cohere",
-      providerOptions,
-      schema: cohereLanguageModelChatOptions
-    }) ?? {};
-    const {
-      messages: chatPrompt,
-      documents: cohereDocuments,
-      warnings: promptWarnings
-    } = await convertToCohereChatPrompt(prompt);
-    const {
-      tools: cohereTools,
-      toolChoice: cohereToolChoice,
-      toolWarnings
-    } = prepareTools({ tools, toolChoice });
-    warnings.push(...toolWarnings, ...promptWarnings);
-    return {
-      args: {
-        // model id:
-        model: this.modelId,
-        // standardized settings:
-        frequency_penalty: frequencyPenalty,
-        presence_penalty: presencePenalty,
-        max_tokens: maxOutputTokens,
-        temperature,
-        p: topP,
-        k: topK,
-        seed,
-        stop_sequences: stopSequences,
-        // response format:
-        response_format: responseFormat?.type === "json" ? { type: "json_object", json_schema: responseFormat.schema } : void 0,
-        // messages:
-        messages: chatPrompt,
-        // tools:
-        tools: cohereTools,
-        tool_choice: cohereToolChoice,
-        // documents for RAG:
-        ...cohereDocuments.length > 0 && { documents: cohereDocuments },
-        // reasoning:
-        ...resolveCohereThinking({
-          reasoning,
-          cohereOptions,
-          warnings
-        })
-      },
-      warnings
-    };
-  }
-  async doGenerate(options) {
-    const { args, warnings } = await this.getArgs(options);
-    const {
-      responseHeaders,
-      value: response,
-      rawValue: rawResponse
-    } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat`,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body: args,
-      failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        cohereChatResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const content = [];
-    for (const item of response.message.content ?? []) {
-      if (item.type === "text" && item.text.length > 0) {
-        content.push({ type: "text", text: item.text });
-        continue;
-      }
-      if (item.type === "thinking" && item.thinking.length > 0) {
-        content.push({ type: "reasoning", text: item.thinking });
-        continue;
-      }
-    }
-    for (const citation of response.message.citations ?? []) {
-      content.push({
-        type: "source",
-        sourceType: "document",
-        id: this.config.generateId(),
-        mediaType: "text/plain",
-        title: citation.sources[0]?.document?.title || "Document",
-        providerMetadata: {
-          cohere: {
-            start: citation.start,
-            end: citation.end,
-            text: citation.text,
-            sources: citation.sources,
-            ...citation.type && { citationType: citation.type }
-          }
-        }
-      });
-    }
-    for (const toolCall of response.message.tool_calls ?? []) {
-      content.push({
-        type: "tool-call",
-        toolCallId: toolCall.id,
-        toolName: toolCall.function.name,
-        // Cohere sometimes returns `null` for tool call arguments for tools
-        // defined as having no arguments.
-        input: toolCall.function.arguments.replace(/^null$/, "{}")
-      });
-    }
-    return {
-      content,
-      finishReason: {
-        unified: mapCohereFinishReason(response.finish_reason),
-        raw: response.finish_reason ?? void 0
-      },
-      usage: convertCohereUsage(response.usage),
-      request: { body: args },
-      response: {
-        // TODO timestamp, model id
-        id: response.generation_id ?? void 0,
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      warnings
-    };
-  }
-  async doStream(options) {
-    const { args, warnings } = await this.getArgs(options);
-    const { responseHeaders, value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat`,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body: { ...args, stream: true },
-      failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler(
-        cohereChatChunkSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    let finishReason = {
-      unified: "other",
-      raw: void 0
-    };
-    let usage = void 0;
-    let pendingToolCall = null;
-    let isActiveReasoning = false;
-    return {
-      stream: response.pipeThrough(
-        new TransformStream({
-          start(controller) {
-            controller.enqueue({ type: "stream-start", warnings });
-          },
-          async transform(chunk, controller) {
-            if (options.includeRawChunks) {
-              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
-            }
-            if (!chunk.success) {
-              finishReason = { unified: "error", raw: void 0 };
-              controller.enqueue({ type: "error", error: chunk.error });
-              return;
-            }
-            const value = chunk.value;
-            const type = value.type;
-            switch (type) {
-              case "content-start": {
-                if (value.delta.message.content.type === "thinking") {
-                  controller.enqueue({
-                    type: "reasoning-start",
-                    id: String(value.index)
-                  });
-                  isActiveReasoning = true;
-                  return;
-                }
-                controller.enqueue({
-                  type: "text-start",
-                  id: String(value.index)
-                });
-                return;
-              }
-              case "content-delta": {
-                if ("thinking" in value.delta.message.content) {
-                  controller.enqueue({
-                    type: "reasoning-delta",
-                    id: String(value.index),
-                    delta: value.delta.message.content.thinking
-                  });
-                  return;
-                }
-                controller.enqueue({
-                  type: "text-delta",
-                  id: String(value.index),
-                  delta: value.delta.message.content.text
-                });
-                return;
-              }
-              case "content-end": {
-                if (isActiveReasoning) {
-                  controller.enqueue({
-                    type: "reasoning-end",
-                    id: String(value.index)
-                  });
-                  isActiveReasoning = false;
-                  return;
-                }
-                controller.enqueue({
-                  type: "text-end",
-                  id: String(value.index)
-                });
-                return;
-              }
-              case "tool-call-start": {
-                const toolId = value.delta.message.tool_calls.id;
-                const toolName = value.delta.message.tool_calls.function.name;
-                const initialArgs = value.delta.message.tool_calls.function.arguments;
-                pendingToolCall = {
-                  id: toolId,
-                  name: toolName,
-                  arguments: initialArgs,
-                  hasFinished: false
-                };
-                controller.enqueue({
-                  type: "tool-input-start",
-                  id: toolId,
-                  toolName
-                });
-                if (initialArgs.length > 0) {
-                  controller.enqueue({
-                    type: "tool-input-delta",
-                    id: toolId,
-                    delta: initialArgs
-                  });
-                }
-                return;
-              }
-              case "tool-call-delta": {
-                if (pendingToolCall && !pendingToolCall.hasFinished) {
-                  const argsDelta = value.delta.message.tool_calls.function.arguments;
-                  pendingToolCall.arguments += argsDelta;
-                  controller.enqueue({
-                    type: "tool-input-delta",
-                    id: pendingToolCall.id,
-                    delta: argsDelta
-                  });
-                }
-                return;
-              }
-              case "tool-call-end": {
-                if (pendingToolCall && !pendingToolCall.hasFinished) {
-                  controller.enqueue({
-                    type: "tool-input-end",
-                    id: pendingToolCall.id
-                  });
-                  controller.enqueue({
-                    type: "tool-call",
-                    toolCallId: pendingToolCall.id,
-                    toolName: pendingToolCall.name,
-                    input: JSON.stringify(
-                      await parseJSON({
-                        text: pendingToolCall.arguments?.trim() || "{}"
-                      })
-                    )
-                  });
-                  pendingToolCall.hasFinished = true;
-                  pendingToolCall = null;
-                }
-                return;
-              }
-              case "message-start": {
-                controller.enqueue({
-                  type: "response-metadata",
-                  id: value.id ?? void 0
-                });
-                return;
-              }
-              case "message-end": {
-                finishReason = {
-                  unified: mapCohereFinishReason(value.delta.finish_reason),
-                  raw: value.delta.finish_reason
-                };
-                usage = value.delta.usage;
-                return;
-              }
-              default: {
-              }
-            }
-          },
-          flush(controller) {
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage: convertCohereUsage(usage)
-            });
-          }
-        })
-      ),
-      request: { body: { ...args, stream: true } },
-      response: { headers: responseHeaders }
-    };
-  }
+//#endregion
+//#region src/cohere-chat-language-model.ts
+var CohereChatLanguageModel = class CohereChatLanguageModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new CohereChatLanguageModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.supportedUrls = { "image/*": [/^https?:\/\/.*$/] };
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences, responseFormat, seed, reasoning, tools, toolChoice, providerOptions }) {
+		const warnings = [];
+		const cohereOptions = await parseProviderOptions({
+			provider: "cohere",
+			providerOptions,
+			schema: cohereLanguageModelChatOptions
+		}) ?? {};
+		const { messages: chatPrompt, documents: cohereDocuments, warnings: promptWarnings } = await convertToCohereChatPrompt(prompt);
+		const { tools: cohereTools, toolChoice: cohereToolChoice, toolWarnings } = prepareTools({
+			tools,
+			toolChoice
+		});
+		warnings.push(...toolWarnings, ...promptWarnings);
+		return {
+			args: {
+				model: this.modelId,
+				frequency_penalty: frequencyPenalty,
+				presence_penalty: presencePenalty,
+				max_tokens: maxOutputTokens,
+				temperature,
+				p: topP,
+				k: topK,
+				seed,
+				stop_sequences: stopSequences,
+				response_format: responseFormat?.type === "json" ? {
+					type: "json_object",
+					json_schema: responseFormat.schema
+				} : void 0,
+				messages: chatPrompt,
+				tools: cohereTools,
+				tool_choice: cohereToolChoice,
+				...cohereDocuments.length > 0 && { documents: cohereDocuments },
+				...resolveCohereThinking({
+					reasoning,
+					cohereOptions,
+					warnings
+				})
+			},
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
+			url: `${this.config.baseURL}/chat`,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body: args,
+			failedResponseHandler: cohereFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(cohereChatResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const content = [];
+		for (const item of response.message.content ?? []) {
+			if (item.type === "text" && item.text.length > 0) {
+				content.push({
+					type: "text",
+					text: item.text
+				});
+				continue;
+			}
+			if (item.type === "thinking" && item.thinking.length > 0) {
+				content.push({
+					type: "reasoning",
+					text: item.thinking
+				});
+				continue;
+			}
+		}
+		for (const citation of response.message.citations ?? []) content.push({
+			type: "source",
+			sourceType: "document",
+			id: this.config.generateId(),
+			mediaType: "text/plain",
+			title: citation.sources[0]?.document?.title || "Document",
+			providerMetadata: { cohere: {
+				start: citation.start,
+				end: citation.end,
+				text: citation.text,
+				sources: citation.sources,
+				...citation.type && { citationType: citation.type }
+			} }
+		});
+		for (const toolCall of response.message.tool_calls ?? []) content.push({
+			type: "tool-call",
+			toolCallId: toolCall.id,
+			toolName: toolCall.function.name,
+			input: toolCall.function.arguments.replace(/^null$/, "{}")
+		});
+		return {
+			content,
+			finishReason: {
+				unified: mapCohereFinishReason(response.finish_reason),
+				raw: response.finish_reason ?? void 0
+			},
+			usage: convertCohereUsage(response.usage),
+			request: { body: args },
+			response: {
+				id: response.generation_id ?? void 0,
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/chat`,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body: {
+				...args,
+				stream: true
+			},
+			failedResponseHandler: cohereFailedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(cohereChatChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		let usage = void 0;
+		let pendingToolCall = null;
+		let isActiveReasoning = false;
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				async transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const value = chunk.value;
+					switch (value.type) {
+						case "content-start":
+							if (value.delta.message.content.type === "thinking") {
+								controller.enqueue({
+									type: "reasoning-start",
+									id: String(value.index)
+								});
+								isActiveReasoning = true;
+								return;
+							}
+							controller.enqueue({
+								type: "text-start",
+								id: String(value.index)
+							});
+							return;
+						case "content-delta":
+							if ("thinking" in value.delta.message.content) {
+								controller.enqueue({
+									type: "reasoning-delta",
+									id: String(value.index),
+									delta: value.delta.message.content.thinking
+								});
+								return;
+							}
+							controller.enqueue({
+								type: "text-delta",
+								id: String(value.index),
+								delta: value.delta.message.content.text
+							});
+							return;
+						case "content-end":
+							if (isActiveReasoning) {
+								controller.enqueue({
+									type: "reasoning-end",
+									id: String(value.index)
+								});
+								isActiveReasoning = false;
+								return;
+							}
+							controller.enqueue({
+								type: "text-end",
+								id: String(value.index)
+							});
+							return;
+						case "tool-call-start": {
+							const toolId = value.delta.message.tool_calls.id;
+							const toolName = value.delta.message.tool_calls.function.name;
+							const initialArgs = value.delta.message.tool_calls.function.arguments;
+							pendingToolCall = {
+								id: toolId,
+								name: toolName,
+								arguments: initialArgs,
+								hasFinished: false
+							};
+							controller.enqueue({
+								type: "tool-input-start",
+								id: toolId,
+								toolName
+							});
+							if (initialArgs.length > 0) controller.enqueue({
+								type: "tool-input-delta",
+								id: toolId,
+								delta: initialArgs
+							});
+							return;
+						}
+						case "tool-call-delta":
+							if (pendingToolCall && !pendingToolCall.hasFinished) {
+								const argsDelta = value.delta.message.tool_calls.function.arguments;
+								pendingToolCall.arguments += argsDelta;
+								controller.enqueue({
+									type: "tool-input-delta",
+									id: pendingToolCall.id,
+									delta: argsDelta
+								});
+							}
+							return;
+						case "tool-call-end":
+							if (pendingToolCall && !pendingToolCall.hasFinished) {
+								controller.enqueue({
+									type: "tool-input-end",
+									id: pendingToolCall.id
+								});
+								controller.enqueue({
+									type: "tool-call",
+									toolCallId: pendingToolCall.id,
+									toolName: pendingToolCall.name,
+									input: JSON.stringify(await parseJSON({ text: pendingToolCall.arguments?.trim() || "{}" }))
+								});
+								pendingToolCall.hasFinished = true;
+								pendingToolCall = null;
+							}
+							return;
+						case "message-start":
+							controller.enqueue({
+								type: "response-metadata",
+								id: value.id ?? void 0
+							});
+							return;
+						case "message-end":
+							finishReason = {
+								unified: mapCohereFinishReason(value.delta.finish_reason),
+								raw: value.delta.finish_reason
+							};
+							usage = value.delta.usage;
+							return;
+					}
+				},
+				flush(controller) {
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage: convertCohereUsage(usage)
+					});
+				}
+			})),
+			request: { body: {
+				...args,
+				stream: true
+			} },
+			response: { headers: responseHeaders }
+		};
+	}
 };
-function resolveCohereThinking({
-  reasoning,
-  cohereOptions,
-  warnings
-}) {
-  if (cohereOptions.thinking) {
-    return {
-      thinking: {
-        type: cohereOptions.thinking.type ?? "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 } };
+function resolveCohereThinking({ reasoning, cohereOptions, warnings }) {
+	if (cohereOptions.thinking) return { thinking: {
+		type: cohereOptions.thinking.type ?? "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 cohereUsageSchema = z3.looseObject({
-  billed_units: z3.looseObject({
-    input_tokens: z3.number(),
-    output_tokens: z3.number()
-  }).nullish(),
-  tokens: z3.looseObject({
-    input_tokens: z3.number(),
-    output_tokens: z3.number()
-  }),
-  cached_tokens: z3.number().nullish()
+const cohereUsageSchema = z.looseObject({
+	billed_units: z.looseObject({
+		input_tokens: z.number(),
+		output_tokens: z.number()
+	}).nullish(),
+	tokens: z.looseObject({
+		input_tokens: z.number(),
+		output_tokens: z.number()
+	}),
+	cached_tokens: z.number().nullish()
 });
-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()
-        }),
-        z3.object({
-          type: z3.literal("thinking"),
-          thinking: z3.string()
-        })
-      ])
-    ).nullish(),
-    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: 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: z3.string().optional()
-      })
-    ).nullish()
-  }),
-  finish_reason: z3.string(),
-  usage: cohereUsageSchema
+const cohereChatResponseSchema = z.object({
+	generation_id: z.string().nullish(),
+	message: z.object({
+		role: z.string(),
+		content: z.array(z.union([z.object({
+			type: z.literal("text"),
+			text: z.string()
+		}), z.object({
+			type: z.literal("thinking"),
+			thinking: z.string()
+		})])).nullish(),
+		tool_plan: z.string().nullish(),
+		tool_calls: z.array(z.object({
+			id: z.string(),
+			type: z.literal("function"),
+			function: z.object({
+				name: z.string(),
+				arguments: z.string()
+			})
+		})).nullish(),
+		citations: z.array(z.object({
+			start: z.number(),
+			end: z.number(),
+			text: z.string(),
+			sources: z.array(z.object({
+				type: z.string().optional(),
+				id: z.string().optional(),
+				document: z.object({
+					id: z.string().optional(),
+					text: z.string(),
+					title: z.string()
+				})
+			})),
+			type: z.string().optional()
+		})).nullish()
+	}),
+	finish_reason: z.string(),
+	usage: cohereUsageSchema
 });
-var cohereChatChunkSchema = z3.discriminatedUnion("type", [
-  z3.object({
-    type: z3.literal("citation-start")
-  }),
-  z3.object({
-    type: z3.literal("citation-end")
-  }),
-  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()
-          }),
-          z3.object({
-            type: z3.literal("thinking"),
-            thinking: z3.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()
-          }),
-          z3.object({
-            thinking: z3.string()
-          })
-        ])
-      })
-    })
-  }),
-  z3.object({
-    type: z3.literal("content-end"),
-    index: z3.number()
-  }),
-  z3.object({
-    type: z3.literal("message-start"),
-    id: z3.string().nullish()
-  }),
-  z3.object({
-    type: z3.literal("message-end"),
-    delta: z3.object({
-      finish_reason: z3.string(),
-      usage: cohereUsageSchema
-    })
-  }),
-  // https://docs.cohere.com/v2/docs/streaming#tool-use-stream-events-for-tool-calling
-  z3.object({
-    type: z3.literal("tool-plan-delta"),
-    delta: z3.object({
-      message: z3.object({
-        tool_plan: z3.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()
-          })
-        })
-      })
-    })
-  }),
-  // 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`.
-  z3.object({
-    type: z3.literal("tool-call-delta"),
-    delta: z3.object({
-      message: z3.object({
-        tool_calls: z3.object({
-          function: z3.object({
-            arguments: z3.string()
-          })
-        })
-      })
-    })
-  }),
-  z3.object({
-    type: z3.literal("tool-call-end")
-  })
+const cohereChatChunkSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("citation-start") }),
+	z.object({ type: z.literal("citation-end") }),
+	z.object({
+		type: z.literal("content-start"),
+		index: z.number(),
+		delta: z.object({ message: z.object({ content: z.union([z.object({
+			type: z.literal("text"),
+			text: z.string()
+		}), z.object({
+			type: z.literal("thinking"),
+			thinking: z.string()
+		})]) }) })
+	}),
+	z.object({
+		type: z.literal("content-delta"),
+		index: z.number(),
+		delta: z.object({ message: z.object({ content: z.union([z.object({ text: z.string() }), z.object({ thinking: z.string() })]) }) })
+	}),
+	z.object({
+		type: z.literal("content-end"),
+		index: z.number()
+	}),
+	z.object({
+		type: z.literal("message-start"),
+		id: z.string().nullish()
+	}),
+	z.object({
+		type: z.literal("message-end"),
+		delta: z.object({
+			finish_reason: z.string(),
+			usage: cohereUsageSchema
+		})
+	}),
+	z.object({
+		type: z.literal("tool-plan-delta"),
+		delta: z.object({ message: z.object({ tool_plan: z.string() }) })
+	}),
+	z.object({
+		type: z.literal("tool-call-start"),
+		delta: z.object({ message: z.object({ tool_calls: z.object({
+			id: z.string(),
+			type: z.literal("function"),
+			function: z.object({
+				name: z.string(),
+				arguments: z.string()
+			})
+		}) }) })
+	}),
+	z.object({
+		type: z.literal("tool-call-delta"),
+		delta: z.object({ message: z.object({ tool_calls: z.object({ function: z.object({ arguments: z.string() }) }) }) })
+	}),
+	z.object({ type: z.literal("tool-call-end") })
 ]);
-
-// src/cohere-embedding-model.ts
-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-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`.
-   *
-   * - "search_document": Used for embeddings stored in a vector database for search use-cases.
-   * - "search_query": Used for embeddings of search queries run against a vector DB to find relevant documents.
-   * - "classification": Used for embeddings passed through a text classifier.
-   * - "clustering": Used for embeddings run through a clustering algorithm.
-   */
-  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`.
-   *
-   * - "NONE": If selected, when the input exceeds the maximum input token length will return an error.
-   * - "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: z4.enum(["NONE", "START", "END"]).optional(),
-  /**
-   * The number of dimensions of the output embedding.
-   * Only available for `embed-v4.0` and newer models.
-   *
-   * Possible values are `256`, `512`, `1024`, and `1536`.
-   * The default is `1536`.
-   */
-  outputDimension: z4.union([z4.literal(256), z4.literal(512), z4.literal(1024), z4.literal(1536)]).optional()
+//#endregion
+//#region src/cohere-embedding-model-options.ts
+const cohereEmbeddingModelOptions = z.object({
+	/**
+	* Specifies the type of input passed to the model. Default is `search_query`.
+	*
+	* - "search_document": Used for embeddings stored in a vector database for search use-cases.
+	* - "search_query": Used for embeddings of search queries run against a vector DB to find relevant documents.
+	* - "classification": Used for embeddings passed through a text classifier.
+	* - "clustering": Used for embeddings run through a clustering algorithm.
+	*/
+	inputType: z.enum([
+		"search_document",
+		"search_query",
+		"classification",
+		"clustering"
+	]).optional(),
+	/**
+	* Specifies how the API will handle inputs longer than the maximum token length.
+	* Default is `END`.
+	*
+	* - "NONE": If selected, when the input exceeds the maximum input token length will return an error.
+	* - "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: z.enum([
+		"NONE",
+		"START",
+		"END"
+	]).optional(),
+	/**
+	* The number of dimensions of the output embedding.
+	* Only available for `embed-v4.0` and newer models.
+	*
+	* Possible values are `256`, `512`, `1024`, and `1536`.
+	* The default is `1536`.
+	*/
+	outputDimension: z.union([
+		z.literal(256),
+		z.literal(512),
+		z.literal(1024),
+		z.literal(1536)
+	]).optional()
 });
-
-// src/cohere-embedding-model.ts
-var CohereEmbeddingModel = class _CohereEmbeddingModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    this.maxEmbeddingsPerCall = 96;
-    this.supportsParallelCalls = true;
-    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;
-  }
-  async doEmbed({
-    values,
-    headers,
-    abortSignal,
-    providerOptions
-  }) {
-    const embeddingOptions = await parseProviderOptions3({
-      provider: "cohere",
-      providerOptions,
-      schema: cohereEmbeddingModelOptions
-    });
-    if (values.length > this.maxEmbeddingsPerCall) {
-      throw new TooManyEmbeddingValuesForCallError({
-        provider: this.provider,
-        modelId: this.modelId,
-        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
-        values
-      });
-    }
-    const {
-      responseHeaders,
-      value: response,
-      rawValue
-    } = await postJsonToApi2({
-      url: `${this.config.baseURL}/embed`,
-      headers: combineHeaders2(this.config.headers?.(), headers),
-      body: {
-        model: this.modelId,
-        // The AI SDK only supports 'float' embeddings. Note that the Cohere API
-        // supports other embedding types, but they are not currently supported by the AI SDK.
-        // https://docs.cohere.com/v2/reference/embed#request.body.embedding_types
-        embedding_types: ["float"],
-        texts: values,
-        input_type: embeddingOptions?.inputType ?? "search_query",
-        truncate: embeddingOptions?.truncate,
-        output_dimension: embeddingOptions?.outputDimension
-      },
-      failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler2(
-        cohereTextEmbeddingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      warnings: [],
-      embeddings: response.embeddings.float,
-      usage: { tokens: response.meta.billed_units.input_tokens },
-      response: { headers: responseHeaders, body: rawValue }
-    };
-  }
+//#endregion
+//#region src/cohere-embedding-model.ts
+var CohereEmbeddingModel = class CohereEmbeddingModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new CohereEmbeddingModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.maxEmbeddingsPerCall = 96;
+		this.supportsParallelCalls = true;
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async doEmbed({ values, headers, abortSignal, providerOptions }) {
+		const embeddingOptions = await parseProviderOptions({
+			provider: "cohere",
+			providerOptions,
+			schema: cohereEmbeddingModelOptions
+		});
+		if (values.length > this.maxEmbeddingsPerCall) throw new TooManyEmbeddingValuesForCallError({
+			provider: this.provider,
+			modelId: this.modelId,
+			maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+			values
+		});
+		const { responseHeaders, value: response, rawValue } = await postJsonToApi({
+			url: `${this.config.baseURL}/embed`,
+			headers: combineHeaders(this.config.headers?.(), headers),
+			body: {
+				model: this.modelId,
+				embedding_types: ["float"],
+				texts: values,
+				input_type: embeddingOptions?.inputType ?? "search_query",
+				truncate: embeddingOptions?.truncate,
+				output_dimension: embeddingOptions?.outputDimension
+			},
+			failedResponseHandler: cohereFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(cohereTextEmbeddingResponseSchema),
+			abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			warnings: [],
+			embeddings: response.embeddings.float,
+			usage: { tokens: response.meta.billed_units.input_tokens },
+			response: {
+				headers: responseHeaders,
+				body: rawValue
+			}
+		};
+	}
 };
-var cohereTextEmbeddingResponseSchema = z5.object({
-  embeddings: z5.object({
-    float: z5.array(z5.array(z5.number()))
-  }),
-  meta: z5.object({
-    billed_units: z5.object({
-      input_tokens: z5.number()
-    })
-  })
+const cohereTextEmbeddingResponseSchema = z.object({
+	embeddings: z.object({ float: z.array(z.array(z.number())) }),
+	meta: z.object({ billed_units: z.object({ input_tokens: z.number() }) })
 });
-
-// src/reranking/cohere-reranking-model.ts
-import {
-  combineHeaders as combineHeaders3,
-  createJsonResponseHandler as createJsonResponseHandler3,
-  parseProviderOptions as parseProviderOptions4,
-  postJsonToApi as postJsonToApi3
-} from "@ai-sdk/provider-utils";
-
-// src/reranking/cohere-reranking-api.ts
-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: z6.any()
-    })
-  )
-);
-
-// 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()
-    })
-  )
-);
-
-// src/reranking/cohere-reranking-model.ts
+//#endregion
+//#region src/reranking/cohere-reranking-api.ts
+const cohereRerankingResponseSchema = lazySchema(() => zodSchema(z.object({
+	id: z.string().nullish(),
+	results: z.array(z.object({
+		index: z.number(),
+		relevance_score: z.number()
+	})),
+	meta: z.any()
+})));
+//#endregion
+//#region src/reranking/cohere-reranking-model-options.ts
+const cohereRerankingModelOptionsSchema = lazySchema(() => zodSchema(z.object({
+	maxTokensPerDoc: z.number().optional(),
+	priority: z.number().optional()
+})));
+//#endregion
+//#region src/reranking/cohere-reranking-model.ts
 var CohereRerankingModel = class {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    this.modelId = modelId;
-    this.config = config;
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  // current implementation is based on v2 of the API: https://docs.cohere.com/v2/reference/rerank
-  async doRerank({
-    documents,
-    headers,
-    query,
-    topN,
-    abortSignal,
-    providerOptions
-  }) {
-    const rerankingOptions = await parseProviderOptions4({
-      provider: "cohere",
-      providerOptions,
-      schema: cohereRerankingModelOptionsSchema
-    });
-    const warnings = [];
-    if (documents.type === "object") {
-      warnings.push({
-        type: "compatibility",
-        feature: "object documents",
-        details: "Object documents are converted to strings."
-      });
-    }
-    const {
-      responseHeaders,
-      value: response,
-      rawValue
-    } = await postJsonToApi3({
-      url: `${this.config.baseURL}/rerank`,
-      headers: combineHeaders3(this.config.headers(), headers),
-      body: {
-        model: this.modelId,
-        query,
-        documents: documents.type === "text" ? documents.values : documents.values.map((value) => JSON.stringify(value)),
-        top_n: topN,
-        max_tokens_per_doc: rerankingOptions?.maxTokensPerDoc,
-        priority: rerankingOptions?.priority
-      },
-      failedResponseHandler: cohereFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler3(
-        cohereRerankingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      ranking: response.results.map((result) => ({
-        index: result.index,
-        relevanceScore: result.relevance_score
-      })),
-      warnings,
-      response: {
-        id: response.id ?? void 0,
-        headers: responseHeaders,
-        body: rawValue
-      }
-    };
-  }
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async doRerank({ documents, headers, query, topN, abortSignal, providerOptions }) {
+		const rerankingOptions = await parseProviderOptions({
+			provider: "cohere",
+			providerOptions,
+			schema: cohereRerankingModelOptionsSchema
+		});
+		const warnings = [];
+		if (documents.type === "object") warnings.push({
+			type: "compatibility",
+			feature: "object documents",
+			details: "Object documents are converted to strings."
+		});
+		const { responseHeaders, value: response, rawValue } = await postJsonToApi({
+			url: `${this.config.baseURL}/rerank`,
+			headers: combineHeaders(this.config.headers(), headers),
+			body: {
+				model: this.modelId,
+				query,
+				documents: documents.type === "text" ? documents.values : documents.values.map((value) => JSON.stringify(value)),
+				top_n: topN,
+				max_tokens_per_doc: rerankingOptions?.maxTokensPerDoc,
+				priority: rerankingOptions?.priority
+			},
+			failedResponseHandler: cohereFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(cohereRerankingResponseSchema),
+			abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			ranking: response.results.map((result) => ({
+				index: result.index,
+				relevanceScore: result.relevance_score
+			})),
+			warnings,
+			response: {
+				id: response.id ?? void 0,
+				headers: responseHeaders,
+				body: rawValue
+			}
+		};
+	}
 };
-
-// src/version.ts
-var VERSION = true ? "4.0.52" : "0.0.0-test";
-
-// src/cohere-provider.ts
+//#endregion
+//#region src/version.ts
+const VERSION = "4.0.54";
+//#endregion
+//#region src/cohere-provider.ts
+/**
+* Create a Cohere AI provider instance.
+*/
 function createCohere(options = {}) {
-  const baseURL = withoutTrailingSlash(options.baseURL) ?? "https://api.cohere.com/v2";
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      Authorization: `Bearer ${loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "COHERE_API_KEY",
-        description: "Cohere"
-      })}`,
-      ...options.headers
-    },
-    `ai-sdk-cohere/${VERSION}`
-  );
-  const createChatModel = (modelId) => new CohereChatLanguageModel(modelId, {
-    provider: "cohere.chat",
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch,
-    generateId: options.generateId ?? generateId
-  });
-  const createEmbeddingModel = (modelId) => new CohereEmbeddingModel(modelId, {
-    provider: "cohere.textEmbedding",
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const createRerankingModel = (modelId) => new CohereRerankingModel(modelId, {
-    provider: "cohere.reranking",
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const provider = function(modelId) {
-    if (new.target) {
-      throw new Error(
-        "The Cohere model function cannot be called with the new keyword."
-      );
-    }
-    return createChatModel(modelId);
-  };
-  provider.specificationVersion = "v4";
-  provider.languageModel = createChatModel;
-  provider.embedding = createEmbeddingModel;
-  provider.embeddingModel = createEmbeddingModel;
-  provider.textEmbedding = createEmbeddingModel;
-  provider.textEmbeddingModel = createEmbeddingModel;
-  provider.reranking = createRerankingModel;
-  provider.rerankingModel = createRerankingModel;
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
-  };
-  return provider;
+	const baseURL = withoutTrailingSlash(options.baseURL) ?? "https://api.cohere.com/v2";
+	const getHeaders = () => withUserAgentSuffix({
+		Authorization: `Bearer ${loadApiKey({
+			apiKey: options.apiKey,
+			environmentVariableName: "COHERE_API_KEY",
+			description: "Cohere"
+		})}`,
+		...options.headers
+	}, `ai-sdk-cohere/${VERSION}`);
+	const createChatModel = (modelId) => new CohereChatLanguageModel(modelId, {
+		provider: "cohere.chat",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch,
+		generateId: options.generateId ?? generateId
+	});
+	const createEmbeddingModel = (modelId) => new CohereEmbeddingModel(modelId, {
+		provider: "cohere.textEmbedding",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createRerankingModel = (modelId) => new CohereRerankingModel(modelId, {
+		provider: "cohere.reranking",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const provider = function(modelId) {
+		if (new.target) throw new Error("The Cohere model function cannot be called with the new keyword.");
+		return createChatModel(modelId);
+	};
+	provider.specificationVersion = "v4";
+	provider.languageModel = createChatModel;
+	provider.embedding = createEmbeddingModel;
+	provider.embeddingModel = createEmbeddingModel;
+	provider.textEmbedding = createEmbeddingModel;
+	provider.textEmbeddingModel = createEmbeddingModel;
+	provider.reranking = createRerankingModel;
+	provider.rerankingModel = createRerankingModel;
+	provider.imageModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "imageModel"
+		});
+	};
+	return provider;
 }
-var cohere = createCohere();
-export {
-  VERSION,
-  cohere,
-  createCohere
-};
+/**
+* Default Cohere provider instance.
+*/
+const cohere = createCohere();
+//#endregion
+export { VERSION, cohere, createCohere };
+
 //# sourceMappingURL=index.js.map