@ai-sdk/cohere 1.2.10 → 2.0.0-alpha.1

package/dist/index.js

@@ -26,10 +26,10 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/cohere-provider.ts
+var import_provider4 = require("@ai-sdk/provider");
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
 
 // src/cohere-chat-language-model.ts
-var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_zod2 = require("zod");
 
@@ -62,9 +62,9 @@ function convertToCohereChatPrompt(prompt) {
               case "text": {
                 return part.text;
               }
-              case "image": {
+              case "file": {
                 throw new import_provider.UnsupportedFunctionalityError({
-                  functionality: "image-part"
+                  functionality: "File URL data"
                 });
               }
             }
@@ -140,9 +140,11 @@ function mapCohereFinishReason(finishReason) {
 
 // src/cohere-prepare-tools.ts
 var import_provider2 = require("@ai-sdk/provider");
-function prepareTools(mode) {
-  var _a;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+function prepareTools({
+  tools,
+  toolChoice
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   if (tools == null) {
     return { tools: void 0, toolChoice: void 0, toolWarnings };
@@ -162,7 +164,6 @@ function prepareTools(mode) {
       });
     }
   }
-  const toolChoice = mode.toolChoice;
   if (toolChoice == null) {
     return { tools: cohereTools, toolChoice: void 0, toolWarnings };
   }
@@ -185,7 +186,7 @@ function prepareTools(mode) {
     default: {
       const _exhaustiveCheck = type;
       throw new import_provider2.UnsupportedFunctionalityError({
-        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+        functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
   }
@@ -193,20 +194,20 @@ function prepareTools(mode) {
 
 // src/cohere-chat-language-model.ts
 var CohereChatLanguageModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
-    this.defaultObjectGenerationMode = "json";
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.supportedUrls = {
+      // No URLs are supported.
+    };
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
   }
   get provider() {
     return this.config.provider;
   }
   getArgs({
-    mode,
     prompt,
-    maxTokens,
+    maxOutputTokens,
     temperature,
     topP,
     topK,
@@ -214,78 +215,42 @@ var CohereChatLanguageModel = class {
     presencePenalty,
     stopSequences,
     responseFormat,
-    seed
+    seed,
+    tools,
+    toolChoice
   }) {
-    var _a;
-    const type = mode.type;
     const chatPrompt = convertToCohereChatPrompt(prompt);
-    const baseArgs = {
-      // model id:
-      model: this.modelId,
-      // standardized settings:
-      frequency_penalty: frequencyPenalty,
-      presence_penalty: presencePenalty,
-      max_tokens: maxTokens,
-      temperature,
-      p: topP,
-      k: topK,
-      seed,
-      stop_sequences: stopSequences,
-      // response format:
-      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? { type: "json_object", json_schema: responseFormat.schema } : void 0,
-      // messages:
-      messages: chatPrompt
+    const {
+      tools: cohereTools,
+      toolChoice: cohereToolChoice,
+      toolWarnings
+    } = prepareTools({ tools, toolChoice });
+    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 == null ? void 0 : responseFormat.type) === "json" ? { type: "json_object", json_schema: responseFormat.schema } : void 0,
+        // messages:
+        messages: chatPrompt,
+        // tools:
+        tools: cohereTools,
+        tool_choice: cohereToolChoice
+      },
+      warnings: toolWarnings
     };
-    switch (type) {
-      case "regular": {
-        const { tools, toolChoice, toolWarnings } = prepareTools(mode);
-        return {
-          args: {
-            ...baseArgs,
-            tools,
-            tool_choice: toolChoice
-          },
-          warnings: toolWarnings
-        };
-      }
-      case "object-json": {
-        return {
-          args: {
-            ...baseArgs,
-            response_format: mode.schema == null ? { type: "json_object" } : { type: "json_object", json_schema: mode.schema }
-          },
-          warnings: []
-        };
-      }
-      case "object-tool": {
-        return {
-          args: {
-            ...baseArgs,
-            tools: [
-              {
-                type: "function",
-                function: {
-                  name: mode.tool.name,
-                  description: (_a = mode.tool.description) != null ? _a : "",
-                  parameters: mode.tool.parameters
-                }
-              }
-            ],
-            tool_choice: "REQUIRED"
-          },
-          warnings: []
-        };
-      }
-      default: {
-        const _exhaustiveCheck = type;
-        throw new import_provider3.UnsupportedFunctionalityError({
-          functionality: `Unsupported mode: ${_exhaustiveCheck}`
-        });
-      }
-    }
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     const { args, warnings } = this.getArgs(options);
     const {
       responseHeaders,
@@ -302,38 +267,40 @@ var CohereChatLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { messages, ...rawSettings } = args;
-    const text = (_c = (_b = (_a = response.message.content) == null ? void 0 : _a[0]) == null ? void 0 : _b.text) != null ? _c : "";
+    const content = [];
+    const text = (_b = (_a = response.message.content) == null ? void 0 : _a[0]) == null ? void 0 : _b.text;
+    if (text != null && text.length > 0) {
+      content.push({ type: "text", text });
+    }
+    if (response.message.tool_calls != null) {
+      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.
+          args: toolCall.function.arguments.replace(/^null$/, "{}"),
+          toolCallType: "function"
+        });
+      }
+    }
     return {
-      text,
-      toolCalls: response.message.tool_calls ? response.message.tool_calls.map((toolCall) => ({
-        toolCallId: toolCall.id,
-        toolName: toolCall.function.name,
-        // Cohere sometimes returns `null` for tool call arguments for tools
-        // defined as having no arguments.
-        args: toolCall.function.arguments.replace(/^null$/, "{}"),
-        toolCallType: "function"
-      })) : [],
+      content,
       finishReason: mapCohereFinishReason(response.finish_reason),
       usage: {
-        promptTokens: response.usage.tokens.input_tokens,
-        completionTokens: response.usage.tokens.output_tokens
-      },
-      rawCall: {
-        rawPrompt: {
-          messages
-        },
-        rawSettings
+        inputTokens: response.usage.tokens.input_tokens,
+        outputTokens: response.usage.tokens.output_tokens,
+        totalTokens: response.usage.tokens.input_tokens + response.usage.tokens.output_tokens
       },
+      request: { body: args },
       response: {
-        id: (_d = response.generation_id) != null ? _d : void 0
-      },
-      rawResponse: {
+        // TODO timestamp, model id
+        id: (_c = response.generation_id) != null ? _c : void 0,
         headers: responseHeaders,
         body: rawResponse
       },
-      warnings,
-      request: { body: JSON.stringify(args) }
+      warnings
     };
   }
   async doStream(options) {
@@ -349,11 +316,11 @@ var CohereChatLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { messages, ...rawSettings } = args;
     let finishReason = "unknown";
-    let usage = {
-      promptTokens: Number.NaN,
-      completionTokens: Number.NaN
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let pendingToolCallDelta = {
       toolCallId: "",
@@ -363,6 +330,9 @@ var CohereChatLanguageModel = class {
     return {
       stream: response.pipeThrough(
         new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
           transform(chunk, controller) {
             var _a, _b;
             if (!chunk.success) {
@@ -375,8 +345,8 @@ var CohereChatLanguageModel = class {
             switch (type) {
               case "content-delta": {
                 controller.enqueue({
-                  type: "text-delta",
-                  textDelta: value.delta.message.content.text
+                  type: "text",
+                  text: value.delta.message.content.text
                 });
                 return;
               }
@@ -435,10 +405,9 @@ var CohereChatLanguageModel = class {
               case "message-end": {
                 finishReason = mapCohereFinishReason(value.delta.finish_reason);
                 const tokens = value.delta.usage.tokens;
-                usage = {
-                  promptTokens: tokens.input_tokens,
-                  completionTokens: tokens.output_tokens
-                };
+                usage.inputTokens = tokens.input_tokens;
+                usage.outputTokens = tokens.output_tokens;
+                usage.totalTokens = tokens.input_tokens + tokens.output_tokens;
               }
               default: {
                 return;
@@ -454,15 +423,8 @@ var CohereChatLanguageModel = class {
           }
         })
       ),
-      rawCall: {
-        rawPrompt: {
-          messages
-        },
-        rawSettings
-      },
-      rawResponse: { headers: responseHeaders },
-      warnings,
-      request: { body: JSON.stringify({ ...args, stream: true }) }
+      request: { body: { ...args, stream: true } },
+      response: { headers: responseHeaders }
     };
   }
 };
@@ -584,16 +546,40 @@ var cohereChatChunkSchema = import_zod2.z.discriminatedUnion("type", [
 ]);
 
 // src/cohere-embedding-model.ts
-var import_provider4 = require("@ai-sdk/provider");
+var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_zod4 = require("zod");
+
+// src/cohere-embedding-options.ts
 var import_zod3 = require("zod");
+var cohereEmbeddingOptions = import_zod3.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: import_zod3.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: import_zod3.z.enum(["NONE", "START", "END"]).optional()
+});
+
+// src/cohere-embedding-model.ts
 var CohereEmbeddingModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
     this.maxEmbeddingsPerCall = 96;
     this.supportsParallelCalls = true;
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
   }
   get provider() {
@@ -602,18 +588,28 @@ var CohereEmbeddingModel = class {
   async doEmbed({
     values,
     headers,
-    abortSignal
+    abortSignal,
+    providerOptions
   }) {
     var _a;
+    const embeddingOptions = await (0, import_provider_utils3.parseProviderOptions)({
+      provider: "cohere",
+      providerOptions,
+      schema: cohereEmbeddingOptions
+    });
     if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider4.TooManyEmbeddingValuesForCallError({
+      throw new import_provider3.TooManyEmbeddingValuesForCallError({
         provider: this.provider,
         modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
         values
       });
     }
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await (0, import_provider_utils3.postJsonToApi)({
       url: `${this.config.baseURL}/embed`,
       headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), headers),
       body: {
@@ -623,8 +619,8 @@ var CohereEmbeddingModel = class {
         // https://docs.cohere.com/v2/reference/embed#request.body.embedding_types
         embedding_types: ["float"],
         texts: values,
-        input_type: (_a = this.settings.inputType) != null ? _a : "search_query",
-        truncate: this.settings.truncate
+        input_type: (_a = embeddingOptions == null ? void 0 : embeddingOptions.inputType) != null ? _a : "search_query",
+        truncate: embeddingOptions == null ? void 0 : embeddingOptions.truncate
       },
       failedResponseHandler: cohereFailedResponseHandler,
       successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
@@ -636,17 +632,17 @@ var CohereEmbeddingModel = class {
     return {
       embeddings: response.embeddings.float,
       usage: { tokens: response.meta.billed_units.input_tokens },
-      rawResponse: { headers: responseHeaders }
+      response: { headers: responseHeaders, body: rawValue }
     };
   }
 };
-var cohereTextEmbeddingResponseSchema = import_zod3.z.object({
-  embeddings: import_zod3.z.object({
-    float: import_zod3.z.array(import_zod3.z.array(import_zod3.z.number()))
+var cohereTextEmbeddingResponseSchema = import_zod4.z.object({
+  embeddings: import_zod4.z.object({
+    float: import_zod4.z.array(import_zod4.z.array(import_zod4.z.number()))
   }),
-  meta: import_zod3.z.object({
-    billed_units: import_zod3.z.object({
-      input_tokens: import_zod3.z.number()
+  meta: import_zod4.z.object({
+    billed_units: import_zod4.z.object({
+      input_tokens: import_zod4.z.number()
     })
   })
 });
@@ -663,29 +659,32 @@ function createCohere(options = {}) {
     })}`,
     ...options.headers
   });
-  const createChatModel = (modelId, settings = {}) => new CohereChatLanguageModel(modelId, settings, {
+  const createChatModel = (modelId) => new CohereChatLanguageModel(modelId, {
     provider: "cohere.chat",
     baseURL,
     headers: getHeaders,
     fetch: options.fetch
   });
-  const createTextEmbeddingModel = (modelId, settings = {}) => new CohereEmbeddingModel(modelId, settings, {
+  const createTextEmbeddingModel = (modelId) => new CohereEmbeddingModel(modelId, {
     provider: "cohere.textEmbedding",
     baseURL,
     headers: getHeaders,
     fetch: options.fetch
   });
-  const provider = function(modelId, settings) {
+  const provider = function(modelId) {
     if (new.target) {
       throw new Error(
         "The Cohere model function cannot be called with the new keyword."
       );
     }
-    return createChatModel(modelId, settings);
+    return createChatModel(modelId);
   };
   provider.languageModel = createChatModel;
   provider.embedding = createTextEmbeddingModel;
   provider.textEmbeddingModel = createTextEmbeddingModel;
+  provider.imageModel = (modelId) => {
+    throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
   return provider;
 }
 var cohere = createCohere();