@ai-sdk/cohere 2.0.8 → 2.0.9

package/dist/index.mjs

@@ -13,15 +13,33 @@ import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
+  parseProviderOptions,
   postJsonToApi
 } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod/v4";
+import { z as z3 } from "zod/v4";
+
+// src/cohere-chat-options.ts
+import { z } from "zod/v4";
+var cohereChatModelOptions = 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()
+});
 
 // src/cohere-error.ts
 import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
-var cohereErrorDataSchema = z.object({
-  message: z.string()
+import { z as z2 } from "zod/v4";
+var cohereErrorDataSchema = z2.object({
+  message: z2.string()
 });
 var cohereFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: cohereErrorDataSchema,
@@ -232,7 +250,7 @@ var CohereChatLanguageModel = class {
   get provider() {
     return this.config.provider;
   }
-  getArgs({
+  async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -244,8 +262,15 @@ var CohereChatLanguageModel = class {
     responseFormat,
     seed,
     tools,
-    toolChoice
+    toolChoice,
+    providerOptions
   }) {
+    var _a, _b;
+    const cohereOptions = (_a = await parseProviderOptions({
+      provider: "cohere",
+      providerOptions,
+      schema: cohereChatModelOptions
+    })) != null ? _a : {};
     const {
       messages: chatPrompt,
       documents: cohereDocuments,
@@ -277,14 +302,21 @@ var CohereChatLanguageModel = class {
         tools: cohereTools,
         tool_choice: cohereToolChoice,
         // documents for RAG:
-        ...cohereDocuments.length > 0 && { documents: cohereDocuments }
+        ...cohereDocuments.length > 0 && { documents: cohereDocuments },
+        // reasoning
+        ...cohereOptions.thinking && {
+          thinking: {
+            type: (_b = cohereOptions.thinking.type) != null ? _b : "enabled",
+            token_budget: cohereOptions.thinking.tokenBudget
+          }
+        }
       },
       warnings: [...toolWarnings, ...promptWarnings]
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-    const { args, warnings } = this.getArgs(options);
+    var _a, _b, _c, _d, _e, _f;
+    const { args, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
       value: response,
@@ -301,16 +333,23 @@ var CohereChatLanguageModel = class {
       fetch: this.config.fetch
     });
     const content = [];
-    if (((_b = (_a = response.message.content) == null ? void 0 : _a[0]) == null ? void 0 : _b.text) != null && ((_d = (_c = response.message.content) == null ? void 0 : _c[0]) == null ? void 0 : _d.text.length) > 0) {
-      content.push({ type: "text", text: response.message.content[0].text });
+    for (const item of (_a = response.message.content) != null ? _a : []) {
+      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 (_e = response.message.citations) != null ? _e : []) {
+    for (const citation of (_b = response.message.citations) != null ? _b : []) {
       content.push({
         type: "source",
         sourceType: "document",
         id: this.config.generateId(),
         mediaType: "text/plain",
-        title: ((_g = (_f = citation.sources[0]) == null ? void 0 : _f.document) == null ? void 0 : _g.title) || "Document",
+        title: ((_d = (_c = citation.sources[0]) == null ? void 0 : _c.document) == null ? void 0 : _d.title) || "Document",
         providerMetadata: {
           cohere: {
             start: citation.start,
@@ -322,7 +361,7 @@ var CohereChatLanguageModel = class {
         }
       });
     }
-    for (const toolCall of (_h = response.message.tool_calls) != null ? _h : []) {
+    for (const toolCall of (_e = response.message.tool_calls) != null ? _e : []) {
       content.push({
         type: "tool-call",
         toolCallId: toolCall.id,
@@ -343,7 +382,7 @@ var CohereChatLanguageModel = class {
       request: { body: args },
       response: {
         // TODO timestamp, model id
-        id: (_i = response.generation_id) != null ? _i : void 0,
+        id: (_f = response.generation_id) != null ? _f : void 0,
         headers: responseHeaders,
         body: rawResponse
       },
@@ -351,7 +390,7 @@ var CohereChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    const { args, warnings } = this.getArgs(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),
@@ -370,6 +409,7 @@ var CohereChatLanguageModel = class {
       totalTokens: void 0
     };
     let pendingToolCall = null;
+    let isActiveReasoning = false;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -390,6 +430,14 @@ var CohereChatLanguageModel = class {
             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)
@@ -397,6 +445,14 @@ var CohereChatLanguageModel = class {
                 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),
@@ -405,6 +461,14 @@ var CohereChatLanguageModel = class {
                 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)
@@ -500,120 +564,145 @@ var CohereChatLanguageModel = class {
     };
   }
 };
-var cohereChatResponseSchema = z2.object({
-  generation_id: z2.string().nullish(),
-  message: z2.object({
-    role: z2.string(),
-    content: z2.array(
-      z2.object({
-        type: z2.string(),
-        text: z2.string()
-      })
+var cohereChatResponseSchema = z3.object({
+  generation_id: z3.string().nullish(),
+  message: z3.object({
+    role: z3.string(),
+    content: z3.array(
+      z3.union([
+        z3.object({
+          type: z3.literal("text"),
+          text: z3.string()
+        }),
+        z3.object({
+          type: z3.literal("thinking"),
+          thinking: z3.string()
+        })
+      ])
     ).nullish(),
-    tool_plan: z2.string().nullish(),
-    tool_calls: z2.array(
-      z2.object({
-        id: z2.string(),
-        type: z2.literal("function"),
-        function: z2.object({
-          name: z2.string(),
-          arguments: z2.string()
+    tool_plan: z3.string().nullish(),
+    tool_calls: z3.array(
+      z3.object({
+        id: z3.string(),
+        type: z3.literal("function"),
+        function: z3.object({
+          name: z3.string(),
+          arguments: z3.string()
         })
       })
     ).nullish(),
-    citations: z2.array(
-      z2.object({
-        start: z2.number(),
-        end: z2.number(),
-        text: z2.string(),
-        sources: z2.array(
-          z2.object({
-            type: z2.string().optional(),
-            id: z2.string().optional(),
-            document: z2.object({
-              id: z2.string().optional(),
-              text: z2.string(),
-              title: z2.string()
+    citations: z3.array(
+      z3.object({
+        start: z3.number(),
+        end: z3.number(),
+        text: z3.string(),
+        sources: z3.array(
+          z3.object({
+            type: z3.string().optional(),
+            id: z3.string().optional(),
+            document: z3.object({
+              id: z3.string().optional(),
+              text: z3.string(),
+              title: z3.string()
             })
           })
         ),
-        type: z2.string().optional()
+        type: z3.string().optional()
       })
     ).nullish()
   }),
-  finish_reason: z2.string(),
-  usage: z2.object({
-    billed_units: z2.object({
-      input_tokens: z2.number(),
-      output_tokens: z2.number()
+  finish_reason: z3.string(),
+  usage: z3.object({
+    billed_units: z3.object({
+      input_tokens: z3.number(),
+      output_tokens: z3.number()
     }),
-    tokens: z2.object({
-      input_tokens: z2.number(),
-      output_tokens: z2.number()
+    tokens: z3.object({
+      input_tokens: z3.number(),
+      output_tokens: z3.number()
     })
   })
 });
-var cohereChatChunkSchema = z2.discriminatedUnion("type", [
-  z2.object({
-    type: z2.literal("citation-start")
+var cohereChatChunkSchema = z3.discriminatedUnion("type", [
+  z3.object({
+    type: z3.literal("citation-start")
   }),
-  z2.object({
-    type: z2.literal("citation-end")
+  z3.object({
+    type: z3.literal("citation-end")
   }),
-  z2.object({
-    type: z2.literal("content-start"),
-    index: z2.number()
+  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()
+          })
+        ])
+      })
+    })
   }),
-  z2.object({
-    type: z2.literal("content-delta"),
-    index: z2.number(),
-    delta: z2.object({
-      message: z2.object({
-        content: z2.object({
-          text: z2.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()
+          })
+        ])
       })
     })
   }),
-  z2.object({
-    type: z2.literal("content-end"),
-    index: z2.number()
+  z3.object({
+    type: z3.literal("content-end"),
+    index: z3.number()
   }),
-  z2.object({
-    type: z2.literal("message-start"),
-    id: z2.string().nullish()
+  z3.object({
+    type: z3.literal("message-start"),
+    id: z3.string().nullish()
   }),
-  z2.object({
-    type: z2.literal("message-end"),
-    delta: z2.object({
-      finish_reason: z2.string(),
-      usage: z2.object({
-        tokens: z2.object({
-          input_tokens: z2.number(),
-          output_tokens: z2.number()
+  z3.object({
+    type: z3.literal("message-end"),
+    delta: z3.object({
+      finish_reason: z3.string(),
+      usage: z3.object({
+        tokens: z3.object({
+          input_tokens: z3.number(),
+          output_tokens: z3.number()
         })
       })
     })
   }),
   // https://docs.cohere.com/v2/docs/streaming#tool-use-stream-events-for-tool-calling
-  z2.object({
-    type: z2.literal("tool-plan-delta"),
-    delta: z2.object({
-      message: z2.object({
-        tool_plan: z2.string()
+  z3.object({
+    type: z3.literal("tool-plan-delta"),
+    delta: z3.object({
+      message: z3.object({
+        tool_plan: z3.string()
       })
     })
   }),
-  z2.object({
-    type: z2.literal("tool-call-start"),
-    delta: z2.object({
-      message: z2.object({
-        tool_calls: z2.object({
-          id: z2.string(),
-          type: z2.literal("function"),
-          function: z2.object({
-            name: z2.string(),
-            arguments: z2.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()
           })
         })
       })
@@ -622,20 +711,20 @@ var cohereChatChunkSchema = z2.discriminatedUnion("type", [
   // A single tool call's `arguments` stream in chunks and must be accumulated
   // in a string and so the full tool object info can only be parsed once we see
   // `tool-call-end`.
-  z2.object({
-    type: z2.literal("tool-call-delta"),
-    delta: z2.object({
-      message: z2.object({
-        tool_calls: z2.object({
-          function: z2.object({
-            arguments: z2.string()
+  z3.object({
+    type: z3.literal("tool-call-delta"),
+    delta: z3.object({
+      message: z3.object({
+        tool_calls: z3.object({
+          function: z3.object({
+            arguments: z3.string()
           })
         })
       })
     })
   }),
-  z2.object({
-    type: z2.literal("tool-call-end")
+  z3.object({
+    type: z3.literal("tool-call-end")
   })
 ]);
 
@@ -646,14 +735,14 @@ import {
 import {
   combineHeaders as combineHeaders2,
   createJsonResponseHandler as createJsonResponseHandler2,
-  parseProviderOptions,
+  parseProviderOptions as parseProviderOptions2,
   postJsonToApi as postJsonToApi2
 } from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
+import { z as z5 } from "zod/v4";
 
 // src/cohere-embedding-options.ts
-import { z as z3 } from "zod/v4";
-var cohereEmbeddingOptions = z3.object({
+import { z as z4 } from "zod/v4";
+var cohereEmbeddingOptions = z4.object({
   /**
    * Specifies the type of input passed to the model. Default is `search_query`.
    *
@@ -662,7 +751,7 @@ var cohereEmbeddingOptions = z3.object({
    * - "classification": Used for embeddings passed through a text classifier.
    * - "clustering": Used for embeddings run through a clustering algorithm.
    */
-  inputType: z3.enum(["search_document", "search_query", "classification", "clustering"]).optional(),
+  inputType: z4.enum(["search_document", "search_query", "classification", "clustering"]).optional(),
   /**
    * Specifies how the API will handle inputs longer than the maximum token length.
    * Default is `END`.
@@ -671,7 +760,7 @@ var cohereEmbeddingOptions = z3.object({
    * - "START": Will discard the start of the input until the remaining input is exactly the maximum input token length for the model.
    * - "END": Will discard the end of the input until the remaining input is exactly the maximum input token length for the model.
    */
-  truncate: z3.enum(["NONE", "START", "END"]).optional()
+  truncate: z4.enum(["NONE", "START", "END"]).optional()
 });
 
 // src/cohere-embedding-model.ts
@@ -693,7 +782,7 @@ var CohereEmbeddingModel = class {
     providerOptions
   }) {
     var _a;
-    const embeddingOptions = await parseProviderOptions({
+    const embeddingOptions = await parseProviderOptions2({
       provider: "cohere",
       providerOptions,
       schema: cohereEmbeddingOptions
@@ -737,13 +826,13 @@ var CohereEmbeddingModel = class {
     };
   }
 };
-var cohereTextEmbeddingResponseSchema = z4.object({
-  embeddings: z4.object({
-    float: z4.array(z4.array(z4.number()))
+var cohereTextEmbeddingResponseSchema = z5.object({
+  embeddings: z5.object({
+    float: z5.array(z5.array(z5.number()))
   }),
-  meta: z4.object({
-    billed_units: z4.object({
-      input_tokens: z4.number()
+  meta: z5.object({
+    billed_units: z5.object({
+      input_tokens: z5.number()
     })
   })
 });