modelfusion 0.0.44

package/model-provider/cohere/CohereTextGenerationModel.js

@@ -0,0 +1,276 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { AsyncQueue } from "../../model-function/generate-text/AsyncQueue.js";
+import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
+import { PromptMappingTextGenerationModel } from "../../prompt/PromptMappingTextGenerationModel.js";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedCohereCallResponseHandler } from "./CohereError.js";
+import { CohereTokenizer } from "./CohereTokenizer.js";
+export const COHERE_TEXT_GENERATION_MODELS = {
+    command: {
+        contextWindowSize: 2048,
+    },
+    "command-nightly": {
+        contextWindowSize: 2048,
+    },
+    "command-light": {
+        contextWindowSize: 2048,
+    },
+    "command-light-nightly": {
+        contextWindowSize: 2048,
+    },
+};
+/**
+ * Create a text generation model that calls the Cohere Co.Generate API.
+ *
+ * @see https://docs.cohere.com/reference/generate
+ *
+ * @example
+ * const model = new CohereTextGenerationModel({
+ *   model: "command-nightly",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ * });
+ *
+ * const { text } = await generateText(
+ *    model,
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+export class CohereTextGenerationModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "cohere"
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.contextWindowSize =
+            COHERE_TEXT_GENERATION_MODELS[this.settings.model].contextWindowSize;
+        this.tokenizer = new CohereTokenizer({
+            baseUrl: this.settings.baseUrl,
+            apiKey: this.settings.apiKey,
+            model: this.settings.model,
+            retry: this.settings.tokenizerSettings?.retry,
+            throttle: this.settings.tokenizerSettings?.throttle,
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.COHERE_API_KEY;
+        if (apiKey == null) {
+            throw new Error("No Cohere API key provided. Pass an API key to the constructor or set the COHERE_API_KEY environment variable.");
+        }
+        return apiKey;
+    }
+    async countPromptTokens(input) {
+        return countTokens(this.tokenizer, input);
+    }
+    async callAPI(prompt, options) {
+        const { run, settings, responseFormat } = options;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            prompt,
+            responseFormat,
+        });
+        return callWithRetryAndThrottle({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callCohereTextGenerationAPI(callSettings),
+        });
+    }
+    generateTextResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: CohereTextGenerationResponseFormat.json,
+        });
+    }
+    extractText(response) {
+        return response.generations[0].text;
+    }
+    generateDeltaStreamResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: CohereTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    extractTextDelta(fullDelta) {
+        return fullDelta.delta;
+    }
+    mapPrompt(promptMapping) {
+        return new PromptMappingTextGenerationModel({
+            model: this.withStopTokens(promptMapping.stopTokens),
+            promptMapping,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new CohereTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+    get maxCompletionTokens() {
+        return this.settings.maxTokens;
+    }
+    withMaxCompletionTokens(maxCompletionTokens) {
+        return this.withSettings({ maxTokens: maxCompletionTokens });
+    }
+    withStopTokens(stopTokens) {
+        // use endSequences instead of stopSequences
+        // to exclude stop tokens from the generated text
+        return this.withSettings({ endSequences: stopTokens });
+    }
+}
+const cohereTextGenerationResponseSchema = z.object({
+    id: z.string(),
+    generations: z.array(z.object({
+        id: z.string(),
+        text: z.string(),
+        finish_reason: z.string().optional(),
+    })),
+    prompt: z.string(),
+    meta: z
+        .object({
+        api_version: z.object({
+            version: z.string(),
+        }),
+    })
+        .optional(),
+});
+/**
+ * Call the Cohere Co.Generate API to generate a text completion for the given prompt.
+ *
+ * @see https://docs.cohere.com/reference/generate
+ *
+ * @example
+ * const response = await callCohereTextGenerationAPI({
+ *   apiKey: COHERE_API_KEY,
+ *   model: "command-nightly",
+ *   prompt: "Write a short story about a robot learning to love:\n\n",
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ * });
+ *
+ * console.log(response.generations[0].text);
+ */
+async function callCohereTextGenerationAPI({ baseUrl = "https://api.cohere.ai/v1", abortSignal, responseFormat, apiKey, model, prompt, numGenerations, maxTokens, temperature, k, p, frequencyPenalty, presencePenalty, endSequences, stopSequences, returnLikelihoods, logitBias, truncate, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/generate`,
+        apiKey,
+        body: {
+            stream: responseFormat.stream,
+            model,
+            prompt,
+            num_generations: numGenerations,
+            max_tokens: maxTokens,
+            temperature,
+            k,
+            p,
+            frequency_penalty: frequencyPenalty,
+            presence_penalty: presencePenalty,
+            end_sequences: endSequences,
+            stop_sequences: stopSequences,
+            return_likelihoods: returnLikelihoods,
+            logit_bias: logitBias,
+            truncate,
+        },
+        failedResponseHandler: failedCohereCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+const cohereTextStreamingResponseSchema = z.discriminatedUnion("is_finished", [
+    z.object({
+        text: z.string(),
+        is_finished: z.literal(false),
+    }),
+    z.object({
+        is_finished: z.literal(true),
+        finish_reason: z.string(),
+        response: cohereTextGenerationResponseSchema,
+    }),
+]);
+async function createCohereTextGenerationFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue();
+    let accumulatedText = "";
+    function processLine(line) {
+        const event = cohereTextStreamingResponseSchema.parse(SecureJSON.parse(line));
+        if (event.is_finished === true) {
+            queue.push({
+                type: "delta",
+                fullDelta: {
+                    content: accumulatedText,
+                    isComplete: true,
+                    delta: "",
+                },
+            });
+        }
+        else {
+            accumulatedText += event.text;
+            queue.push({
+                type: "delta",
+                fullDelta: {
+                    content: accumulatedText,
+                    isComplete: false,
+                    delta: event.text,
+                },
+            });
+        }
+    }
+    // process the stream asynchonously (no 'await' on purpose):
+    (async () => {
+        let unprocessedText = "";
+        const reader = new ReadableStreamDefaultReader(stream);
+        const utf8Decoder = new TextDecoder("utf-8");
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const { value: chunk, done } = await reader.read();
+            if (done) {
+                break;
+            }
+            unprocessedText += utf8Decoder.decode(chunk, { stream: true });
+            const processableLines = unprocessedText.split(/\r\n|\n|\r/g);
+            unprocessedText = processableLines.pop() || "";
+            processableLines.forEach(processLine);
+        }
+        // processing remaining text:
+        if (unprocessedText) {
+            processLine(unprocessedText);
+        }
+        queue.close();
+    })();
+    return queue;
+}
+export const CohereTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: createJsonResponseHandler(cohereTextGenerationResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createCohereTextGenerationFullDeltaIterableQueue(response.body),
+    },
+};

package/model-provider/cohere/CohereTokenizer.cjs

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereTokenizer = void 0;
+const zod_1 = __importDefault(require("zod"));
+const callWithRetryAndThrottle_js_1 = require("../../util/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../util/api/postToApi.cjs");
+const CohereError_js_1 = require("./CohereError.cjs");
+/**
+ * Tokenizer for the Cohere models. It uses the Co.Tokenize and Co.Detokenize APIs.
+ *
+ * @see https://docs.cohere.com/reference/tokenize
+ * @see https://docs.cohere.com/reference/detokenize-1
+ *
+ * @example
+ * const tokenizer = new CohereTokenizer({ model: "command-nightly" });
+ *
+ * const text = "At first, Nox didn't know what to do with the pup.";
+ *
+ * const tokenCount = await countTokens(tokenizer, text);
+ * const tokens = await tokenizer.tokenize(text);
+ * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
+ * const reconstructedText = await tokenizer.detokenize(tokens);
+ */
+class CohereTokenizer {
+    constructor(settings) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.COHERE_API_KEY;
+        if (apiKey == null) {
+            throw new Error("No Cohere API key provided. Pass an API key to the constructor or set the COHERE_API_KEY environment variable.");
+        }
+        return apiKey;
+    }
+    async callTokenizeAPI(text, context) {
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callCohereTokenizeAPI({
+                abortSignal: context?.abortSignal,
+                apiKey: this.apiKey,
+                text,
+                ...this.settings,
+            }),
+        });
+    }
+    async callDeTokenizeAPI(tokens, context) {
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callCohereDetokenizeAPI({
+                abortSignal: context?.abortSignal,
+                apiKey: this.apiKey,
+                tokens,
+                ...this.settings,
+            }),
+        });
+    }
+    async tokenize(text) {
+        return (await this.tokenizeWithTexts(text)).tokens;
+    }
+    async tokenizeWithTexts(text) {
+        const response = await this.callTokenizeAPI(text);
+        return {
+            tokens: response.tokens,
+            tokenTexts: response.token_strings,
+        };
+    }
+    async detokenize(tokens) {
+        const response = await this.callDeTokenizeAPI(tokens);
+        return response.text;
+    }
+}
+exports.CohereTokenizer = CohereTokenizer;
+const cohereDetokenizationResponseSchema = zod_1.default.object({
+    text: zod_1.default.string(),
+    meta: zod_1.default.object({
+        api_version: zod_1.default.object({
+            version: zod_1.default.string(),
+        }),
+    }),
+});
+/**
+ * Call the Cohere Co.Detokenize API to detokenize a text.
+ *
+ * https://docs.cohere.com/reference/detokenize-1
+ */
+async function callCohereDetokenizeAPI({ baseUrl = "https://api.cohere.ai/v1", abortSignal, apiKey, model, tokens, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/detokenize`,
+        apiKey,
+        body: {
+            model,
+            tokens,
+        },
+        failedResponseHandler: CohereError_js_1.failedCohereCallResponseHandler,
+        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(cohereDetokenizationResponseSchema),
+        abortSignal,
+    });
+}
+const cohereTokenizationResponseSchema = zod_1.default.object({
+    tokens: zod_1.default.array(zod_1.default.number()),
+    token_strings: zod_1.default.array(zod_1.default.string()),
+    meta: zod_1.default.object({
+        api_version: zod_1.default.object({
+            version: zod_1.default.string(),
+        }),
+    }),
+});
+/**
+ * Call the Cohere Co.Tokenize API to tokenize a text.
+ *
+ * https://docs.cohere.com/reference/tokenize
+ */
+async function callCohereTokenizeAPI({ baseUrl = "https://api.cohere.ai/v1", abortSignal, apiKey, model, text, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/tokenize`,
+        apiKey,
+        body: {
+            model,
+            text,
+        },
+        failedResponseHandler: CohereError_js_1.failedCohereCallResponseHandler,
+        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(cohereTokenizationResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/cohere/CohereTokenizer.d.ts

@@ -0,0 +1,118 @@
+import z from "zod";
+import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
+import { Run } from "../../run/Run.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+import { CohereTextGenerationModelType } from "./CohereTextGenerationModel.js";
+import { CohereTextEmbeddingModelType } from "./index.js";
+export type CohereTokenizerModelType = CohereTextGenerationModelType | CohereTextEmbeddingModelType;
+export interface CohereTokenizerSettings {
+    model: CohereTokenizerModelType;
+    baseUrl?: string;
+    apiKey?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+}
+/**
+ * Tokenizer for the Cohere models. It uses the Co.Tokenize and Co.Detokenize APIs.
+ *
+ * @see https://docs.cohere.com/reference/tokenize
+ * @see https://docs.cohere.com/reference/detokenize-1
+ *
+ * @example
+ * const tokenizer = new CohereTokenizer({ model: "command-nightly" });
+ *
+ * const text = "At first, Nox didn't know what to do with the pup.";
+ *
+ * const tokenCount = await countTokens(tokenizer, text);
+ * const tokens = await tokenizer.tokenize(text);
+ * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
+ * const reconstructedText = await tokenizer.detokenize(tokens);
+ */
+export declare class CohereTokenizer implements FullTokenizer {
+    readonly settings: CohereTokenizerSettings;
+    constructor(settings: CohereTokenizerSettings);
+    private get apiKey();
+    callTokenizeAPI(text: string, context?: Run): Promise<CohereTokenizationResponse>;
+    callDeTokenizeAPI(tokens: number[], context?: Run): Promise<CohereDetokenizationResponse>;
+    tokenize(text: string): Promise<number[]>;
+    tokenizeWithTexts(text: string): Promise<{
+        tokens: number[];
+        tokenTexts: string[];
+    }>;
+    detokenize(tokens: number[]): Promise<string>;
+}
+declare const cohereDetokenizationResponseSchema: z.ZodObject<{
+    text: z.ZodString;
+    meta: z.ZodObject<{
+        api_version: z.ZodObject<{
+            version: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+        }, {
+            version: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        api_version: {
+            version: string;
+        };
+    }, {
+        api_version: {
+            version: string;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    meta: {
+        api_version: {
+            version: string;
+        };
+    };
+}, {
+    text: string;
+    meta: {
+        api_version: {
+            version: string;
+        };
+    };
+}>;
+export type CohereDetokenizationResponse = z.infer<typeof cohereDetokenizationResponseSchema>;
+declare const cohereTokenizationResponseSchema: z.ZodObject<{
+    tokens: z.ZodArray<z.ZodNumber, "many">;
+    token_strings: z.ZodArray<z.ZodString, "many">;
+    meta: z.ZodObject<{
+        api_version: z.ZodObject<{
+            version: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+        }, {
+            version: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        api_version: {
+            version: string;
+        };
+    }, {
+        api_version: {
+            version: string;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    meta: {
+        api_version: {
+            version: string;
+        };
+    };
+    tokens: number[];
+    token_strings: string[];
+}, {
+    meta: {
+        api_version: {
+            version: string;
+        };
+    };
+    tokens: number[];
+    token_strings: string[];
+}>;
+export type CohereTokenizationResponse = z.infer<typeof cohereTokenizationResponseSchema>;
+export {};

package/model-provider/cohere/CohereTokenizer.js

@@ -0,0 +1,129 @@
+import z from "zod";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedCohereCallResponseHandler } from "./CohereError.js";
+/**
+ * Tokenizer for the Cohere models. It uses the Co.Tokenize and Co.Detokenize APIs.
+ *
+ * @see https://docs.cohere.com/reference/tokenize
+ * @see https://docs.cohere.com/reference/detokenize-1
+ *
+ * @example
+ * const tokenizer = new CohereTokenizer({ model: "command-nightly" });
+ *
+ * const text = "At first, Nox didn't know what to do with the pup.";
+ *
+ * const tokenCount = await countTokens(tokenizer, text);
+ * const tokens = await tokenizer.tokenize(text);
+ * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
+ * const reconstructedText = await tokenizer.detokenize(tokens);
+ */
+export class CohereTokenizer {
+    constructor(settings) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.COHERE_API_KEY;
+        if (apiKey == null) {
+            throw new Error("No Cohere API key provided. Pass an API key to the constructor or set the COHERE_API_KEY environment variable.");
+        }
+        return apiKey;
+    }
+    async callTokenizeAPI(text, context) {
+        return callWithRetryAndThrottle({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callCohereTokenizeAPI({
+                abortSignal: context?.abortSignal,
+                apiKey: this.apiKey,
+                text,
+                ...this.settings,
+            }),
+        });
+    }
+    async callDeTokenizeAPI(tokens, context) {
+        return callWithRetryAndThrottle({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callCohereDetokenizeAPI({
+                abortSignal: context?.abortSignal,
+                apiKey: this.apiKey,
+                tokens,
+                ...this.settings,
+            }),
+        });
+    }
+    async tokenize(text) {
+        return (await this.tokenizeWithTexts(text)).tokens;
+    }
+    async tokenizeWithTexts(text) {
+        const response = await this.callTokenizeAPI(text);
+        return {
+            tokens: response.tokens,
+            tokenTexts: response.token_strings,
+        };
+    }
+    async detokenize(tokens) {
+        const response = await this.callDeTokenizeAPI(tokens);
+        return response.text;
+    }
+}
+const cohereDetokenizationResponseSchema = z.object({
+    text: z.string(),
+    meta: z.object({
+        api_version: z.object({
+            version: z.string(),
+        }),
+    }),
+});
+/**
+ * Call the Cohere Co.Detokenize API to detokenize a text.
+ *
+ * https://docs.cohere.com/reference/detokenize-1
+ */
+async function callCohereDetokenizeAPI({ baseUrl = "https://api.cohere.ai/v1", abortSignal, apiKey, model, tokens, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/detokenize`,
+        apiKey,
+        body: {
+            model,
+            tokens,
+        },
+        failedResponseHandler: failedCohereCallResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(cohereDetokenizationResponseSchema),
+        abortSignal,
+    });
+}
+const cohereTokenizationResponseSchema = z.object({
+    tokens: z.array(z.number()),
+    token_strings: z.array(z.string()),
+    meta: z.object({
+        api_version: z.object({
+            version: z.string(),
+        }),
+    }),
+});
+/**
+ * Call the Cohere Co.Tokenize API to tokenize a text.
+ *
+ * https://docs.cohere.com/reference/tokenize
+ */
+async function callCohereTokenizeAPI({ baseUrl = "https://api.cohere.ai/v1", abortSignal, apiKey, model, text, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/tokenize`,
+        apiKey,
+        body: {
+            model,
+            text,
+        },
+        failedResponseHandler: failedCohereCallResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(cohereTokenizationResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/cohere/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereError = void 0;
+var CohereError_js_1 = require("./CohereError.cjs");
+Object.defineProperty(exports, "CohereError", { enumerable: true, get: function () { return CohereError_js_1.CohereError; } });
+__exportStar(require("./CohereTextEmbeddingModel.cjs"), exports);
+__exportStar(require("./CohereTextGenerationModel.cjs"), exports);
+__exportStar(require("./CohereTokenizer.cjs"), exports);

package/model-provider/cohere/index.d.ts

@@ -0,0 +1,4 @@
+export { CohereError, CohereErrorData } from "./CohereError.js";
+export * from "./CohereTextEmbeddingModel.js";
+export * from "./CohereTextGenerationModel.js";
+export * from "./CohereTokenizer.js";

package/model-provider/cohere/index.js

@@ -0,0 +1,4 @@
+export { CohereError } from "./CohereError.js";
+export * from "./CohereTextEmbeddingModel.js";
+export * from "./CohereTextGenerationModel.js";
+export * from "./CohereTokenizer.js";