modelfusion 0.0.44

package/model-provider/automatic1111/Automatic1111Error.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+export declare const automatic1111ErrorDataSchema: z.ZodObject<{
+    error: z.ZodString;
+    detail: z.ZodString;
+    body: z.ZodString;
+    errors: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    errors: string;
+    body: string;
+    detail: string;
+}, {
+    error: string;
+    errors: string;
+    body: string;
+    detail: string;
+}>;
+export type Automatic1111ErrorData = z.infer<typeof automatic1111ErrorDataSchema>;
+export declare class Automatic1111Error extends ApiCallError {
+    readonly data: Automatic1111ErrorData;
+    constructor({ data, statusCode, url, requestBodyValues, message, }: {
+        message?: string;
+        statusCode: number;
+        url: string;
+        requestBodyValues: unknown;
+        data: Automatic1111ErrorData;
+    });
+}
+export declare const failedAutomatic1111CallResponseHandler: ResponseHandler<ApiCallError>;

package/model-provider/automatic1111/Automatic1111Error.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import SecureJSON from "secure-json-parse";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+export const automatic1111ErrorDataSchema = z.object({
+    error: z.string(),
+    detail: z.string(),
+    body: z.string(),
+    errors: z.string(),
+});
+export class Automatic1111Error extends ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.detail, }) {
+        super({ message, statusCode, requestBodyValues, url });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+export const failedAutomatic1111CallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = automatic1111ErrorDataSchema.parse(SecureJSON.parse(responseBody));
+    return new Automatic1111Error({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Automatic1111ImageGenerationModel = void 0;
+const zod_1 = require("zod");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const callWithRetryAndThrottle_js_1 = require("../../util/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../util/api/postToApi.cjs");
+const Automatic1111Error_js_1 = require("./Automatic1111Error.cjs");
+/**
+ * Create an image generation model that calls the AUTOMATIC1111 Stable Diffusion Web UI API.
+ *
+ * @see https://github.com/AUTOMATIC1111/stable-diffusion-webui
+ */
+class Automatic1111ImageGenerationModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Automatic1111"
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    async callAPI(input, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const callSettings = Object.assign(this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            engineId: this.settings.model,
+            prompt: input.prompt,
+        });
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callAutomatic1111ImageGenerationAPI(callSettings),
+        });
+    }
+    generateImageResponse(prompt, options) {
+        return this.callAPI(prompt, options);
+    }
+    extractBase64Image(response) {
+        return response.images[0];
+    }
+    withSettings(additionalSettings) {
+        return new Automatic1111ImageGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.Automatic1111ImageGenerationModel = Automatic1111ImageGenerationModel;
+const Automatic1111ImageGenerationResponseSchema = zod_1.z.object({
+    images: zod_1.z.array(zod_1.z.string()),
+    parameters: zod_1.z.object({}),
+    info: zod_1.z.string(),
+});
+async function callAutomatic1111ImageGenerationAPI({ baseUrl = "http://127.0.0.1:7860", abortSignal, height, width, prompt, negativePrompt, sampler, steps, seed, model, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/sdapi/v1/txt2img`,
+        body: {
+            height,
+            width,
+            prompt,
+            negative_prompt: negativePrompt,
+            sampler_index: sampler,
+            steps,
+            seed,
+            override_settings: {
+                sd_model_checkpoint: model,
+            },
+        },
+        failedResponseHandler: Automatic1111Error_js_1.failedAutomatic1111CallResponseHandler,
+        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(Automatic1111ImageGenerationResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+/**
+ * Create an image generation model that calls the AUTOMATIC1111 Stable Diffusion Web UI API.
+ *
+ * @see https://github.com/AUTOMATIC1111/stable-diffusion-webui
+ */
+export declare class Automatic1111ImageGenerationModel extends AbstractModel<Automatic1111ImageGenerationModelSettings> implements ImageGenerationModel<A111ImageGenerationPrompt, Automatic1111ImageGenerationResponse, Automatic1111ImageGenerationModelSettings> {
+    constructor(settings: Automatic1111ImageGenerationModelSettings);
+    readonly provider: "Automatic1111";
+    get modelName(): string;
+    callAPI(input: A111ImageGenerationPrompt, options?: FunctionOptions<Automatic1111ImageGenerationModelSettings>): Promise<Automatic1111ImageGenerationResponse>;
+    generateImageResponse(prompt: A111ImageGenerationPrompt, options?: FunctionOptions<Automatic1111ImageGenerationModelSettings>): Promise<{
+        parameters: {};
+        images: string[];
+        info: string;
+    }>;
+    extractBase64Image(response: Automatic1111ImageGenerationResponse): string;
+    withSettings(additionalSettings: Automatic1111ImageGenerationModelSettings): this;
+}
+export interface Automatic1111ImageGenerationModelSettings extends ImageGenerationModelSettings {
+    baseUrl?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+    model: string;
+    height?: number;
+    width?: number;
+    sampler?: string;
+    steps?: number;
+}
+declare const Automatic1111ImageGenerationResponseSchema: z.ZodObject<{
+    images: z.ZodArray<z.ZodString, "many">;
+    parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    info: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    parameters: {};
+    images: string[];
+    info: string;
+}, {
+    parameters: {};
+    images: string[];
+    info: string;
+}>;
+export type Automatic1111ImageGenerationResponse = z.infer<typeof Automatic1111ImageGenerationResponseSchema>;
+export type A111ImageGenerationPrompt = {
+    prompt: string;
+    negativePrompt?: string;
+    seed?: number;
+};
+export {};

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedAutomatic1111CallResponseHandler } from "./Automatic1111Error.js";
+/**
+ * Create an image generation model that calls the AUTOMATIC1111 Stable Diffusion Web UI API.
+ *
+ * @see https://github.com/AUTOMATIC1111/stable-diffusion-webui
+ */
+export class Automatic1111ImageGenerationModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Automatic1111"
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    async callAPI(input, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const callSettings = Object.assign(this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            engineId: this.settings.model,
+            prompt: input.prompt,
+        });
+        return callWithRetryAndThrottle({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callAutomatic1111ImageGenerationAPI(callSettings),
+        });
+    }
+    generateImageResponse(prompt, options) {
+        return this.callAPI(prompt, options);
+    }
+    extractBase64Image(response) {
+        return response.images[0];
+    }
+    withSettings(additionalSettings) {
+        return new Automatic1111ImageGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+const Automatic1111ImageGenerationResponseSchema = z.object({
+    images: z.array(z.string()),
+    parameters: z.object({}),
+    info: z.string(),
+});
+async function callAutomatic1111ImageGenerationAPI({ baseUrl = "http://127.0.0.1:7860", abortSignal, height, width, prompt, negativePrompt, sampler, steps, seed, model, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/sdapi/v1/txt2img`,
+        body: {
+            height,
+            width,
+            prompt,
+            negative_prompt: negativePrompt,
+            sampler_index: sampler,
+            steps,
+            seed,
+            override_settings: {
+                sd_model_checkpoint: model,
+            },
+        },
+        failedResponseHandler: failedAutomatic1111CallResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(Automatic1111ImageGenerationResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/automatic1111/index.cjs

@@ -0,0 +1,20 @@
+"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.Automatic1111Error = void 0;
+var Automatic1111Error_js_1 = require("./Automatic1111Error.cjs");
+Object.defineProperty(exports, "Automatic1111Error", { enumerable: true, get: function () { return Automatic1111Error_js_1.Automatic1111Error; } });
+__exportStar(require("./Automatic1111ImageGenerationModel.cjs"), exports);

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

@@ -0,0 +1,2 @@
+export { Automatic1111Error, Automatic1111ErrorData, } from "./Automatic1111Error.js";
+export * from "./Automatic1111ImageGenerationModel.js";

package/model-provider/automatic1111/index.js

@@ -0,0 +1,2 @@
+export { Automatic1111Error, } from "./Automatic1111Error.js";
+export * from "./Automatic1111ImageGenerationModel.js";

package/model-provider/cohere/CohereError.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failedCohereCallResponseHandler = exports.CohereError = exports.cohereErrorDataSchema = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const ApiCallError_js_1 = require("../../util/api/ApiCallError.cjs");
+exports.cohereErrorDataSchema = zod_1.z.object({
+    message: zod_1.z.string(),
+});
+class CohereError extends ApiCallError_js_1.ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.message, }) {
+        super({ message, statusCode, requestBodyValues, url });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+exports.CohereError = CohereError;
+const failedCohereCallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = exports.cohereErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
+    return new CohereError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};
+exports.failedCohereCallResponseHandler = failedCohereCallResponseHandler;

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+export declare const cohereErrorDataSchema: z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>;
+export type CohereErrorData = z.infer<typeof cohereErrorDataSchema>;
+export declare class CohereError extends ApiCallError {
+    readonly data: CohereErrorData;
+    constructor({ data, statusCode, url, requestBodyValues, message, }: {
+        message?: string;
+        statusCode: number;
+        url: string;
+        requestBodyValues: unknown;
+        data: CohereErrorData;
+    });
+}
+export declare const failedCohereCallResponseHandler: ResponseHandler<ApiCallError>;

package/model-provider/cohere/CohereError.js

@@ -0,0 +1,28 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+export const cohereErrorDataSchema = z.object({
+    message: z.string(),
+});
+export class CohereError extends ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.message, }) {
+        super({ message, statusCode, requestBodyValues, url });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+export const failedCohereCallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = cohereErrorDataSchema.parse(SecureJSON.parse(responseBody));
+    return new CohereError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};

package/model-provider/cohere/CohereTextEmbeddingModel.cjs

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereTextEmbeddingModel = exports.COHERE_TEXT_EMBEDDING_MODELS = void 0;
+const zod_1 = __importDefault(require("zod"));
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+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");
+const CohereTokenizer_js_1 = require("./CohereTokenizer.cjs");
+exports.COHERE_TEXT_EMBEDDING_MODELS = {
+    "embed-english-light-v2.0": {
+        contextWindowSize: 4096,
+        embeddingDimensions: 1024,
+    },
+    "embed-english-v2.0": {
+        contextWindowSize: 4096,
+        embeddingDimensions: 4096,
+    },
+    "embed-multilingual-v2.0": {
+        contextWindowSize: 4096,
+        embeddingDimensions: 768,
+    },
+};
+/**
+ * Create a text embedding model that calls the Cohere Co.Embed API.
+ *
+ * @see https://docs.cohere.com/reference/embed
+ *
+ * @example
+ * const { embeddings } = await embedTexts(
+ *   new CohereTextEmbeddingModel({ model: "embed-english-light-v2.0" }),
+ *   [
+ *     "At first, Nox didn't know what to do with the pup.",
+ *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
+ *   ]
+ * );
+ */
+class CohereTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "cohere"
+        });
+        Object.defineProperty(this, "maxTextsPerCall", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 96
+        });
+        Object.defineProperty(this, "embeddingDimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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 =
+            exports.COHERE_TEXT_EMBEDDING_MODELS[this.modelName].contextWindowSize;
+        this.tokenizer = new CohereTokenizer_js_1.CohereTokenizer({
+            baseUrl: this.settings.baseUrl,
+            apiKey: this.settings.apiKey,
+            model: this.settings.model,
+            retry: this.settings.tokenizerSettings?.retry,
+            throttle: this.settings.tokenizerSettings?.throttle,
+        });
+        this.embeddingDimensions =
+            exports.COHERE_TEXT_EMBEDDING_MODELS[this.modelName].embeddingDimensions;
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    async tokenize(text) {
+        return this.tokenizer.tokenize(text);
+    }
+    async tokenizeWithTexts(text) {
+        return this.tokenizer.tokenizeWithTexts(text);
+    }
+    async detokenize(tokens) {
+        return this.tokenizer.detokenize(tokens);
+    }
+    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 callAPI(texts, options) {
+        if (texts.length > this.maxTextsPerCall) {
+            throw new Error(`The Cohere embedding API only supports ${this.maxTextsPerCall} texts per API call.`);
+        }
+        const run = options?.run;
+        const settings = options?.settings;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            texts,
+        });
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callCohereEmbeddingAPI(callSettings),
+        });
+    }
+    generateEmbeddingResponse(texts, options) {
+        return this.callAPI(texts, options);
+    }
+    extractEmbeddings(response) {
+        return response.embeddings;
+    }
+    withSettings(additionalSettings) {
+        return new CohereTextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.CohereTextEmbeddingModel = CohereTextEmbeddingModel;
+const cohereTextEmbeddingResponseSchema = zod_1.default.object({
+    id: zod_1.default.string(),
+    texts: zod_1.default.array(zod_1.default.string()),
+    embeddings: zod_1.default.array(zod_1.default.array(zod_1.default.number())),
+    meta: zod_1.default.object({
+        api_version: zod_1.default.object({
+            version: zod_1.default.string(),
+        }),
+    }),
+});
+/**
+ * Call the Cohere Co.Embed API to generate an embedding for the given input.
+ *
+ * @see https://docs.cohere.com/reference/embed
+ *
+ * @example
+ * const response = await callCohereEmbeddingAPI({
+ *   apiKey: COHERE_API_KEY,
+ *   model: "embed-english-light-v2.0",
+ *   texts: [
+ *     "At first, Nox didn't know what to do with the pup.",
+ *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
+ *   ],
+ * });
+ */
+async function callCohereEmbeddingAPI({ baseUrl = "https://api.cohere.ai/v1", abortSignal, apiKey, model, texts, truncate, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/embed`,
+        apiKey,
+        body: {
+            model,
+            texts,
+            truncate,
+        },
+        failedResponseHandler: CohereError_js_1.failedCohereCallResponseHandler,
+        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(cohereTextEmbeddingResponseSchema),
+        abortSignal,
+    });
+}

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

@@ -0,0 +1,119 @@
+import z from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../../model-function/embed-text/TextEmbeddingModel.js";
+import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+export declare const COHERE_TEXT_EMBEDDING_MODELS: {
+    "embed-english-light-v2.0": {
+        contextWindowSize: number;
+        embeddingDimensions: number;
+    };
+    "embed-english-v2.0": {
+        contextWindowSize: number;
+        embeddingDimensions: number;
+    };
+    "embed-multilingual-v2.0": {
+        contextWindowSize: number;
+        embeddingDimensions: number;
+    };
+};
+export type CohereTextEmbeddingModelType = keyof typeof COHERE_TEXT_EMBEDDING_MODELS;
+export interface CohereTextEmbeddingModelSettings extends TextEmbeddingModelSettings {
+    model: CohereTextEmbeddingModelType;
+    baseUrl?: string;
+    apiKey?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+    tokenizerSettings?: {
+        retry?: RetryFunction;
+        throttle?: ThrottleFunction;
+    };
+    truncate?: "NONE" | "START" | "END";
+}
+/**
+ * Create a text embedding model that calls the Cohere Co.Embed API.
+ *
+ * @see https://docs.cohere.com/reference/embed
+ *
+ * @example
+ * const { embeddings } = await embedTexts(
+ *   new CohereTextEmbeddingModel({ model: "embed-english-light-v2.0" }),
+ *   [
+ *     "At first, Nox didn't know what to do with the pup.",
+ *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
+ *   ]
+ * );
+ */
+export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEmbeddingModelSettings> implements TextEmbeddingModel<CohereTextEmbeddingResponse, CohereTextEmbeddingModelSettings>, FullTokenizer {
+    constructor(settings: CohereTextEmbeddingModelSettings);
+    readonly provider: "cohere";
+    get modelName(): "embed-english-light-v2.0" | "embed-english-v2.0" | "embed-multilingual-v2.0";
+    readonly maxTextsPerCall = 96;
+    readonly embeddingDimensions: number;
+    readonly contextWindowSize: number;
+    private readonly tokenizer;
+    tokenize(text: string): Promise<number[]>;
+    tokenizeWithTexts(text: string): Promise<{
+        tokens: number[];
+        tokenTexts: string[];
+    }>;
+    detokenize(tokens: number[]): Promise<string>;
+    private get apiKey();
+    callAPI(texts: Array<string>, options?: FunctionOptions<CohereTextEmbeddingModelSettings>): Promise<CohereTextEmbeddingResponse>;
+    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<CohereTextEmbeddingModelSettings>): Promise<{
+        texts: string[];
+        embeddings: number[][];
+        id: string;
+        meta: {
+            api_version: {
+                version: string;
+            };
+        };
+    }>;
+    extractEmbeddings(response: CohereTextEmbeddingResponse): number[][];
+    withSettings(additionalSettings: Partial<CohereTextEmbeddingModelSettings>): this;
+}
+declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    texts: z.ZodArray<z.ZodString, "many">;
+    embeddings: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "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, {
+    texts: string[];
+    embeddings: number[][];
+    id: string;
+    meta: {
+        api_version: {
+            version: string;
+        };
+    };
+}, {
+    texts: string[];
+    embeddings: number[][];
+    id: string;
+    meta: {
+        api_version: {
+            version: string;
+        };
+    };
+}>;
+export type CohereTextEmbeddingResponse = z.infer<typeof cohereTextEmbeddingResponseSchema>;
+export {};