@ai-sdk/cohere 3.0.72 → 3.0.73

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

@@ -8,6 +8,9 @@ import type {
   LanguageModelV3StreamResult,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
@@ -254,7 +257,7 @@ export class CohereChatLanguageModel implements LanguageModelV3 {
     return {
       stream: response.pipeThrough(
         new TransformStream<
-          ParseResult<z.infer<typeof cohereChatChunkSchema>>,
+          ParseResult<InferSchema<typeof cohereChatChunkSchema>>,
           LanguageModelV3StreamPart
         >({
           start(controller) {
@@ -436,175 +439,184 @@ export class CohereChatLanguageModel implements LanguageModelV3 {
 }
 
 // Loose, nested objects included: the parsed value is returned as `usage.raw`.
-const cohereUsageSchema = z.looseObject({
-  billed_units: z
-    .looseObject({
+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(),
-    })
-    .nullish(),
-  tokens: z.looseObject({
-    input_tokens: z.number(),
-    output_tokens: z.number(),
-  }),
-  cached_tokens: z.number().nullish(),
-});
-
-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(),
+    }),
+    cached_tokens: z.number().nullish(),
+  });
+
+const cohereChatResponseSchema = lazySchema(() =>
+  zodSchema(
+    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(),
-                title: 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(),
               }),
             }),
-          ),
-          type: z.string().optional(),
-        }),
-      )
-      .nullish(),
-  }),
-  finish_reason: z.string(),
-  usage: cohereUsageSchema,
-});
+          )
+          .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(),
+    }),
+  ),
+);
 
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-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(),
-          }),
-        ]),
+const cohereChatChunkSchema = lazySchema(() =>
+  zodSchema(
+    z.discriminatedUnion('type', [
+      z.object({
+        type: z.literal('citation-start'),
       }),
-    }),
-  }),
-  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({
+        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({
-            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,
-    }),
-  }),
-  // https://docs.cohere.com/v2/docs/streaming#tool-use-stream-events-for-tool-calling
-  z.object({
-    type: z.literal('tool-plan-delta'),
-    delta: z.object({
-      message: z.object({
-        tool_plan: z.string(),
+      z.object({
+        type: z.literal('content-end'),
+        index: z.number(),
       }),
-    }),
-  }),
-  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('message-start'),
+        id: z.string().nullish(),
+      }),
+      z.object({
+        type: z.literal('message-end'),
+        delta: z.object({
+          finish_reason: z.string(),
+          usage: cohereUsageSchema(),
+        }),
+      }),
+      // https://docs.cohere.com/v2/docs/streaming#tool-use-stream-events-for-tool-calling
+      z.object({
+        type: z.literal('tool-plan-delta'),
+        delta: z.object({
+          message: z.object({
+            tool_plan: z.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`.
-  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-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-end'),
-  }),
-]);
+      // 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`.
+      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'),
+      }),
+    ]),
+  ),
+);

package/src/cohere-chat-options.ts

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 // https://docs.cohere.com/docs/models
@@ -17,36 +22,44 @@ export type CohereChatModelId =
   | 'command-light-nightly'
   | (string & {});
 
-export const 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(),
-});
+export const 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(),
+    }),
+  ),
+);
 
-export type CohereLanguageModelOptions = z.infer<
+export type CohereLanguageModelOptions = InferSchema<
   typeof cohereLanguageModelOptions
 >;
 
-export 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(),
-});
+export const 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(),
+    }),
+  ),
+);
 
-export type CohereImagePartProviderOptions = z.infer<
+export type CohereImagePartProviderOptions = InferSchema<
   typeof cohereImagePartProviderOptions
 >;

package/src/cohere-embedding-model.ts

@@ -3,6 +3,8 @@ import {
   type EmbeddingModelV3,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonResponseHandler,
   parseProviderOptions,
@@ -101,13 +103,17 @@ export class CohereEmbeddingModel implements EmbeddingModelV3 {
 
 // minimal version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-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(),
+const cohereTextEmbeddingResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      embeddings: z.object({
+        float: z.array(z.array(z.number())),
+      }),
+      meta: z.object({
+        billed_units: z.object({
+          input_tokens: z.number(),
+        }),
+      }),
     }),
-  }),
-});
+  ),
+);

package/src/cohere-embedding-options.ts

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 export type CohereEmbeddingModelId =
@@ -10,48 +15,57 @@ export type CohereEmbeddingModelId =
   | 'embed-multilingual-v2.0'
   | (string & {});
 
-export 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(),
+export const cohereEmbeddingModelOptions = lazySchema(() =>
+  zodSchema(
+    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(),
+      /**
+       * 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.
-   *
-   * Embed v4.0 supports `256`, `512`, `1024`, and `1536` (default).
-   * Embed v5.0 Pro and Fast also support `768` and `2048` (default).
-   */
-  outputDimension: z
-    .union([
-      z.literal(256),
-      z.literal(512),
-      z.literal(768),
-      z.literal(1024),
-      z.literal(1536),
-      z.literal(2048),
-    ])
-    .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: z
+        .union([
+          z.literal(256),
+          z.literal(512),
+          z.literal(768),
+          z.literal(1024),
+          z.literal(1536),
+          z.literal(2048),
+        ])
+        .optional(),
+    }),
+  ),
+);
 
-export type CohereEmbeddingModelOptions = z.infer<
+export type CohereEmbeddingModelOptions = InferSchema<
   typeof cohereEmbeddingModelOptions
 >;

package/src/cohere-error.ts

@@ -1,11 +1,20 @@
-import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+  createJsonErrorResponseHandler,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-const cohereErrorDataSchema = z.object({
-  message: z.string(),
-});
+const cohereErrorDataSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      message: z.string(),
+    }),
+  ),
+);
 
-export type CohereErrorData = z.infer<typeof cohereErrorDataSchema>;
+export type CohereErrorData = InferSchema<typeof cohereErrorDataSchema>;
 
 export const cohereFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: cohereErrorDataSchema,