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

package/src/cohere-chat-language-model.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   LanguageModelV4,
   LanguageModelV4CallOptions,
   LanguageModelV4Content,
@@ -6,31 +6,42 @@ import {
   LanguageModelV4GenerateResult,
   LanguageModelV4StreamPart,
   LanguageModelV4StreamResult,
+  SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
-  ParseResult,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
   parseProviderOptions,
+  parseJSON,
   postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type InferSchema,
+  type FetchFunction,
+  type ParseResult,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import {
-  CohereChatModelId,
-  cohereLanguageModelOptions,
-} from './cohere-chat-options';
+  cohereLanguageModelChatOptions,
+  type CohereChatModelId,
+} from './cohere-chat-language-model-options';
 import { cohereFailedResponseHandler } from './cohere-error';
 import { prepareTools } from './cohere-prepare-tools';
-import { CohereUsageTokens, convertCohereUsage } from './convert-cohere-usage';
+import {
+  convertCohereUsage,
+  type CohereUsageTokens,
+} from './convert-cohere-usage';
 import { convertToCohereChatPrompt } from './convert-to-cohere-chat-prompt';
 import { mapCohereFinishReason } from './map-cohere-finish-reason';
 
 type CohereChatConfig = {
   provider: string;
   baseURL: string;
-  headers: () => Record<string, string | undefined>;
+  headers?: () => Record<string, string | undefined>;
   fetch?: FetchFunction;
   generateId: () => string;
 };
@@ -40,12 +51,26 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
 
   readonly modelId: CohereChatModelId;
 
-  readonly supportedUrls = {
-    // No URLs are supported.
+  readonly supportedUrls: Record<string, RegExp[]> = {
+    'image/*': [/^https?:\/\/.*$/],
   };
 
   private readonly config: CohereChatConfig;
 
+  static [WORKFLOW_SERIALIZE](model: CohereChatLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: CohereChatModelId;
+    config: CohereChatConfig;
+  }) {
+    return new CohereChatLanguageModel(options.modelId, options.config);
+  }
+
   constructor(modelId: CohereChatModelId, config: CohereChatConfig) {
     this.modelId = modelId;
     this.config = config;
@@ -66,23 +91,25 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
     stopSequences,
     responseFormat,
     seed,
+    reasoning,
     tools,
     toolChoice,
     providerOptions,
   }: LanguageModelV4CallOptions) {
-    // Parse provider options
+    const warnings: SharedV4Warning[] = [];
+
     const cohereOptions =
       (await parseProviderOptions({
         provider: 'cohere',
         providerOptions,
-        schema: cohereLanguageModelOptions,
+        schema: cohereLanguageModelChatOptions,
       })) ?? {};
 
     const {
       messages: chatPrompt,
       documents: cohereDocuments,
       warnings: promptWarnings,
-    } = convertToCohereChatPrompt(prompt);
+    } = await convertToCohereChatPrompt(prompt);
 
     const {
       tools: cohereTools,
@@ -90,6 +117,8 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
       toolWarnings,
     } = prepareTools({ tools, toolChoice });
 
+    warnings.push(...toolWarnings, ...promptWarnings);
+
     return {
       args: {
         // model id:
@@ -121,15 +150,14 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
         // documents for RAG:
         ...(cohereDocuments.length > 0 && { documents: cohereDocuments }),
 
-        // reasoning
-        ...(cohereOptions.thinking && {
-          thinking: {
-            type: cohereOptions.thinking.type ?? 'enabled',
-            token_budget: cohereOptions.thinking.tokenBudget,
-          },
+        // reasoning:
+        ...resolveCohereThinking({
+          reasoning,
+          cohereOptions,
+          warnings,
         }),
       },
-      warnings: [...toolWarnings, ...promptWarnings],
+      warnings,
     };
   }
 
@@ -144,7 +172,7 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
       rawValue: rawResponse,
     } = await postJsonToApi({
       url: `${this.config.baseURL}/chat`,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body: args,
       failedResponseHandler: cohereFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
@@ -225,7 +253,7 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
 
     const { responseHeaders, value: response } = await postJsonToApi({
       url: `${this.config.baseURL}/chat`,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body: { ...args, stream: true },
       failedResponseHandler: cohereFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
@@ -260,7 +288,7 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
             controller.enqueue({ type: 'stream-start', warnings });
           },
 
-          transform(chunk, controller) {
+          async transform(chunk, controller) {
             if (options.includeRawChunks) {
               controller.enqueue({ type: 'raw', rawValue: chunk.rawValue });
             }
@@ -385,7 +413,9 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
                     toolCallId: pendingToolCall.id,
                     toolName: pendingToolCall.name,
                     input: JSON.stringify(
-                      JSON.parse(pendingToolCall.arguments?.trim() || '{}'),
+                      await parseJSON({
+                        text: pendingToolCall.arguments?.trim() || '{}',
+                      }),
                     ),
                   });
 
@@ -433,6 +463,46 @@ export class CohereChatLanguageModel implements LanguageModelV4 {
   }
 }
 
+function resolveCohereThinking({
+  reasoning,
+  cohereOptions,
+  warnings,
+}: {
+  reasoning: LanguageModelV4CallOptions['reasoning'];
+  cohereOptions: InferSchema<typeof cohereLanguageModelChatOptions>;
+  warnings: SharedV4Warning[];
+}): { thinking?: { type: string; token_budget?: number } } {
+  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 } };
+}
+
 const cohereChatResponseSchema = z.object({
   generation_id: z.string().nullish(),
   message: z.object({

package/src/cohere-chat-prompt.ts

@@ -13,9 +13,16 @@ export interface CohereSystemMessage {
 
 export interface CohereUserMessage {
   role: 'user';
-  content: string;
+  content: string | Array<CohereUserMessageContent>;
 }
 
+export type CohereUserMessageContent =
+  | { type: 'text'; text: string }
+  | {
+      type: 'image_url';
+      image_url: { url: string; detail?: 'auto' | 'low' | 'high' };
+    };
+
 export interface CohereAssistantMessage {
   role: 'assistant';
   content: string | undefined;

package/src/cohere-embedding-model.ts

@@ -1,25 +1,28 @@
 import {
-  EmbeddingModelV4,
   TooManyEmbeddingValuesForCallError,
+  type EmbeddingModelV4,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   createJsonResponseHandler,
-  FetchFunction,
   parseProviderOptions,
   postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import {
-  CohereEmbeddingModelId,
   cohereEmbeddingModelOptions,
-} from './cohere-embedding-options';
+  type CohereEmbeddingModelId,
+} from './cohere-embedding-model-options';
 import { cohereFailedResponseHandler } from './cohere-error';
 
 type CohereEmbeddingConfig = {
   provider: string;
   baseURL: string;
-  headers: () => Record<string, string | undefined>;
+  headers?: () => Record<string, string | undefined>;
   fetch?: FetchFunction;
 };
 
@@ -32,6 +35,20 @@ export class CohereEmbeddingModel implements EmbeddingModelV4 {
 
   private readonly config: CohereEmbeddingConfig;
 
+  static [WORKFLOW_SERIALIZE](model: CohereEmbeddingModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: CohereEmbeddingModelId;
+    config: CohereEmbeddingConfig;
+  }) {
+    return new CohereEmbeddingModel(options.modelId, options.config);
+  }
+
   constructor(modelId: CohereEmbeddingModelId, config: CohereEmbeddingConfig) {
     this.modelId = modelId;
     this.config = config;
@@ -70,7 +87,7 @@ export class CohereEmbeddingModel implements EmbeddingModelV4 {
       rawValue,
     } = await postJsonToApi({
       url: `${this.config.baseURL}/embed`,
-      headers: combineHeaders(this.config.headers(), headers),
+      headers: combineHeaders(this.config.headers?.(), headers),
       body: {
         model: this.modelId,
         // The AI SDK only supports 'float' embeddings. Note that the Cohere API

package/src/cohere-prepare-tools.ts

@@ -1,9 +1,9 @@
 import {
-  LanguageModelV4CallOptions,
-  SharedV4Warning,
   UnsupportedFunctionalityError,
+  type LanguageModelV4CallOptions,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
-import { CohereToolChoice } from './cohere-chat-prompt';
+import type { CohereToolChoice } from './cohere-chat-prompt';
 
 export function prepareTools({
   tools,

package/src/cohere-provider.ts

@@ -1,24 +1,23 @@
 import {
-  EmbeddingModelV4,
-  LanguageModelV4,
   NoSuchModelError,
-  RerankingModelV4,
-  ProviderV4,
+  type EmbeddingModelV4,
+  type LanguageModelV4,
+  type RerankingModelV4,
+  type ProviderV4,
 } from '@ai-sdk/provider';
-
 import {
-  FetchFunction,
   generateId,
   loadApiKey,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { CohereChatLanguageModel } from './cohere-chat-language-model';
-import { CohereChatModelId } from './cohere-chat-options';
+import type { CohereChatModelId } from './cohere-chat-language-model-options';
 import { CohereEmbeddingModel } from './cohere-embedding-model';
-import { CohereRerankingModelId } from './reranking/cohere-reranking-options';
+import type { CohereRerankingModelId } from './reranking/cohere-reranking-model-options';
 import { CohereRerankingModel } from './reranking/cohere-reranking-model';
-import { CohereEmbeddingModelId } from './cohere-embedding-options';
+import type { CohereEmbeddingModelId } from './cohere-embedding-model-options';
 import { VERSION } from './version';
 
 export interface CohereProvider extends ProviderV4 {

package/src/convert-cohere-usage.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV4Usage } from '@ai-sdk/provider';
+import type { LanguageModelV4Usage } from '@ai-sdk/provider';
 
 export type CohereUsageTokens = {
   input_tokens: number;

package/src/convert-to-cohere-chat-prompt.ts

@@ -1,17 +1,31 @@
 import {
-  SharedV4Warning,
-  LanguageModelV4Prompt,
   UnsupportedFunctionalityError,
+  type LanguageModelV4FilePart,
+  type LanguageModelV4Prompt,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
-import { CohereAssistantMessage, CohereChatPrompt } from './cohere-chat-prompt';
+import {
+  convertToBase64,
+  getTopLevelMediaType,
+  parseProviderOptions,
+  resolveFullMediaType,
+} from '@ai-sdk/provider-utils';
+import { cohereImagePartProviderOptions } from './cohere-chat-language-model-options';
+import type {
+  CohereAssistantMessage,
+  CohereChatPrompt,
+  CohereUserMessageContent,
+} from './cohere-chat-prompt';
 
-export function convertToCohereChatPrompt(prompt: LanguageModelV4Prompt): {
+export async function convertToCohereChatPrompt(
+  prompt: LanguageModelV4Prompt,
+): Promise<{
   messages: CohereChatPrompt;
   documents: Array<{
     data: { text: string; title?: string };
   }>;
   warnings: SharedV4Warning[];
-} {
+}> {
   const messages: CohereChatPrompt = [];
   const documents: Array<{ data: { text: string; title?: string } }> = [];
   const warnings: SharedV4Warning[] = [];
@@ -24,58 +38,88 @@ export function convertToCohereChatPrompt(prompt: LanguageModelV4Prompt): {
       }
 
       case 'user': {
-        messages.push({
-          role: 'user',
-          content: content
-            .map(part => {
-              switch (part.type) {
-                case 'text': {
-                  return part.text;
+        const userContentParts: Array<CohereUserMessageContent> = [];
+        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: string;
+              switch (part.data.type) {
+                case 'reference': {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: 'file parts with provider references',
+                  });
                 }
-                case 'file': {
-                  // Extract documents for RAG
-                  let textContent: string;
-
-                  if (typeof part.data === 'string') {
-                    // Base64 or text data
-                    textContent = part.data;
-                  } else if (part.data instanceof Uint8Array) {
-                    // Check if the media type is supported for text extraction
-                    if (
-                      !(
-                        part.mediaType?.startsWith('text/') ||
-                        part.mediaType === 'application/json'
-                      )
-                    ) {
-                      throw new UnsupportedFunctionalityError({
-                        functionality: `document media type: ${part.mediaType}`,
-                        message: `Media type '${part.mediaType}' is not supported. Supported media types are: text/* and application/json.`,
-                      });
-                    }
-                    textContent = new TextDecoder().decode(part.data);
-                  } else {
-                    throw new UnsupportedFunctionalityError({
-                      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,
-                    },
+                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.',
                   });
-
-                  // Files are handled separately via the documents parameter
-                  // Return empty string to not include file content in message text
-                  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;
                 }
               }
-            })
-            .join(''),
-        });
+
+              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;
       }
 
@@ -126,7 +170,7 @@ export function convertToCohereChatPrompt(prompt: LanguageModelV4Prompt): {
                   contentValue = output.value;
                   break;
                 case 'execution-denied':
-                  contentValue = output.reason ?? 'Tool execution denied.';
+                  contentValue = output.reason ?? 'Tool call execution denied.';
                   break;
                 case 'content':
                 case 'json':
@@ -154,3 +198,24 @@ export function convertToCohereChatPrompt(prompt: LanguageModelV4Prompt): {
 
   return { messages, documents, warnings };
 }
+
+function buildImageUrl({ part }: { part: LanguageModelV4FilePart }): string {
+  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',
+      });
+    }
+  }
+}

package/src/index.ts

@@ -1,14 +1,16 @@
 export type {
-  CohereLanguageModelOptions,
-  /** @deprecated Use `CohereLanguageModelOptions` instead. */
-  CohereLanguageModelOptions as CohereChatModelOptions,
-} from './cohere-chat-options';
+  CohereLanguageModelChatOptions,
+  /** @deprecated Use `CohereLanguageModelChatOptions` instead. */
+  CohereLanguageModelChatOptions as CohereLanguageModelOptions,
+  /** @deprecated Use `CohereLanguageModelChatOptions` instead. */
+  CohereLanguageModelChatOptions as CohereChatModelOptions,
+} from './cohere-chat-language-model-options';
 export { cohere, createCohere } from './cohere-provider';
 export type { CohereProvider, CohereProviderSettings } from './cohere-provider';
-export type { CohereEmbeddingModelOptions } from './cohere-embedding-options';
+export type { CohereEmbeddingModelOptions } from './cohere-embedding-model-options';
 export type {
   CohereRerankingModelOptions,
   /** @deprecated Use `CohereRerankingModelOptions` instead. */
   CohereRerankingModelOptions as CohereRerankingOptions,
-} from './reranking/cohere-reranking-options';
+} from './reranking/cohere-reranking-model-options';
 export { VERSION } from './version';

package/src/map-cohere-finish-reason.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV4FinishReason } from '@ai-sdk/provider';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 export function mapCohereFinishReason(
   finishReason: string | null | undefined,

package/src/reranking/{cohere-reranking-options.ts → cohere-reranking-model-options.ts}

@@ -1,4 +1,8 @@
-import { FlexibleSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import {
+  lazySchema,
+  zodSchema,
+  type FlexibleSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 // https://docs.cohere.com/docs/rerank

package/src/reranking/cohere-reranking-model.ts

@@ -1,21 +1,20 @@
-import { RerankingModelV4, SharedV4Warning } from '@ai-sdk/provider';
+import type { RerankingModelV4, SharedV4Warning } from '@ai-sdk/provider';
 import {
   combineHeaders,
   createJsonResponseHandler,
-  FetchFunction,
   parseProviderOptions,
   postJsonToApi,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { cohereFailedResponseHandler } from '../cohere-error';
 import {
-  CohereRerankingInput,
   cohereRerankingResponseSchema,
+  type CohereRerankingInput,
 } from './cohere-reranking-api';
 import {
-  CohereRerankingModelId,
   cohereRerankingModelOptionsSchema,
-} from './cohere-reranking-options';
-
+  type CohereRerankingModelId,
+} from './cohere-reranking-model-options';
 type CohereRerankingConfig = {
   provider: string;
   baseURL: string;