@ai-sdk/cohere 3.0.72 → 3.0.74

package/dist/index.mjs

@@ -11,6 +11,8 @@ import {
 
 // src/cohere-chat-language-model.ts
 import {
+  lazySchema as lazySchema3,
+  zodSchema as zodSchema3,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
@@ -21,36 +23,56 @@ import {
 import { z as z3 } from "zod/v4";
 
 // src/cohere-chat-options.ts
+import {
+  lazySchema,
+  zodSchema
+} from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
-var cohereLanguageModelOptions = 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()
-});
+var cohereLanguageModelOptions = lazySchema(
+  () => zodSchema(
+    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 = lazySchema(
+  () => zodSchema(
+    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 {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2,
+  createJsonErrorResponseHandler
+} from "@ai-sdk/provider-utils";
 import { z as z2 } from "zod/v4";
-var cohereErrorDataSchema = z2.object({
-  message: z2.string()
-});
+var cohereErrorDataSchema = lazySchema2(
+  () => zodSchema2(
+    z2.object({
+      message: z2.string()
+    })
+  )
+);
 var cohereFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: cohereErrorDataSchema,
   errorToMessage: (data) => data.message
@@ -655,7 +677,7 @@ var CohereChatLanguageModel = class {
     };
   }
 };
-var cohereUsageSchema = z3.looseObject({
+var cohereUsageSchema = () => z3.looseObject({
   billed_units: z3.looseObject({
     input_tokens: z3.number(),
     output_tokens: z3.number()
@@ -666,161 +688,171 @@ var cohereUsageSchema = z3.looseObject({
   }),
   cached_tokens: z3.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
-});
-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({
+var cohereChatResponseSchema = lazySchema3(
+  () => zodSchema3(
+    z3.object({
+      generation_id: z3.string().nullish(),
       message: z3.object({
-        content: z3.union([
-          z3.object({
-            type: z3.literal("text"),
-            text: z3.string()
-          }),
+        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({
-            type: z3.literal("thinking"),
-            thinking: z3.string()
+            id: z3.string(),
+            type: z3.literal("function"),
+            function: z3.object({
+              name: z3.string(),
+              arguments: 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()
-          }),
+        ).nullish(),
+        citations: z3.array(
           z3.object({
-            thinking: z3.string()
+            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()
           })
-        ])
-      })
-    })
-  }),
-  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({
+        ).nullish()
+      }),
       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()
-      })
+      usage: cohereUsageSchema()
     })
-  }),
-  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()
+  )
+);
+var cohereChatChunkSchema = lazySchema3(
+  () => zodSchema3(
+    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()
+              })
+            ])
           })
         })
-      })
-    })
-  }),
-  // 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("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")
       })
-    })
-  }),
-  z3.object({
-    type: z3.literal("tool-call-end")
-  })
-]);
+    ])
+  )
+);
 
 // src/cohere-embedding-model.ts
 import {
   TooManyEmbeddingValuesForCallError
 } from "@ai-sdk/provider";
 import {
+  lazySchema as lazySchema5,
+  zodSchema as zodSchema5,
   combineHeaders as combineHeaders2,
   createJsonResponseHandler as createJsonResponseHandler2,
   parseProviderOptions as parseProviderOptions3,
@@ -829,42 +861,55 @@ import {
 import { z as z5 } from "zod/v4";
 
 // src/cohere-embedding-options.ts
+import {
+  lazySchema as lazySchema4,
+  zodSchema as zodSchema4
+} from "@ai-sdk/provider-utils";
 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.
-   *
-   * Embed v4.0 supports `256`, `512`, `1024`, and `1536` (default).
-   * Embed v5.0 Pro and Fast also support `768` and `2048` (default).
-   */
-  outputDimension: z4.union([
-    z4.literal(256),
-    z4.literal(512),
-    z4.literal(768),
-    z4.literal(1024),
-    z4.literal(1536),
-    z4.literal(2048)
-  ]).optional()
-});
+var cohereEmbeddingModelOptions = lazySchema4(
+  () => zodSchema4(
+    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.
+       *
+       * Embed v4.0 supports `256`, `512`, `1024`, and `1536` (default).
+       * Embed v5.0 Pro and Fast also support `768` and `2048` (default).
+       */
+      outputDimension: z4.union([
+        z4.literal(256),
+        z4.literal(512),
+        z4.literal(768),
+        z4.literal(1024),
+        z4.literal(1536),
+        z4.literal(2048)
+      ]).optional()
+    })
+  )
+);
 
 // src/cohere-embedding-model.ts
 var CohereEmbeddingModel = class {
@@ -931,16 +976,20 @@ var CohereEmbeddingModel = class {
     };
   }
 };
-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()
+var cohereTextEmbeddingResponseSchema = lazySchema5(
+  () => zodSchema5(
+    z5.object({
+      embeddings: z5.object({
+        float: z5.array(z5.array(z5.number()))
+      }),
+      meta: z5.object({
+        billed_units: z5.object({
+          input_tokens: z5.number()
+        })
+      })
     })
-  })
-});
+  )
+);
 
 // src/reranking/cohere-reranking-model.ts
 import {
@@ -951,10 +1000,10 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/reranking/cohere-reranking-api.ts
-import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { lazySchema as lazySchema6, zodSchema as zodSchema6 } from "@ai-sdk/provider-utils";
 import { z as z6 } from "zod/v4";
-var cohereRerankingResponseSchema = lazySchema(
-  () => zodSchema(
+var cohereRerankingResponseSchema = lazySchema6(
+  () => zodSchema6(
     z6.object({
       id: z6.string().nullish(),
       results: z6.array(
@@ -970,12 +1019,12 @@ var cohereRerankingResponseSchema = lazySchema(
 
 // src/reranking/cohere-reranking-options.ts
 import {
-  lazySchema as lazySchema2,
-  zodSchema as zodSchema2
+  lazySchema as lazySchema7,
+  zodSchema as zodSchema7
 } from "@ai-sdk/provider-utils";
 import { z as z7 } from "zod/v4";
-var cohereRerankingModelOptionsSchema = lazySchema2(
-  () => zodSchema2(
+var cohereRerankingModelOptionsSchema = lazySchema7(
+  () => zodSchema7(
     z7.object({
       maxTokensPerDoc: z7.number().optional(),
       priority: z7.number().optional()
@@ -1054,7 +1103,7 @@ var CohereRerankingModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "3.0.72" : "0.0.0-test";
+var VERSION = true ? "3.0.74" : "0.0.0-test";
 
 // src/cohere-provider.ts
 function createCohere(options = {}) {