modelfusion 0.0.44

package/model-provider/cohere/CohereTextEmbeddingModel.js

@@ -0,0 +1,165 @@
+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 { failedCohereCallResponseHandler } from "./CohereError.js";
+import { CohereTokenizer } from "./CohereTokenizer.js";
+export const 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.",
+ *   ]
+ * );
+ */
+export class CohereTextEmbeddingModel extends 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 =
+            COHERE_TEXT_EMBEDDING_MODELS[this.modelName].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,
+        });
+        this.embeddingDimensions =
+            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 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));
+    }
+}
+const cohereTextEmbeddingResponseSchema = z.object({
+    id: z.string(),
+    texts: z.array(z.string()),
+    embeddings: z.array(z.array(z.number())),
+    meta: z.object({
+        api_version: z.object({
+            version: z.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 postJsonToApi({
+        url: `${baseUrl}/embed`,
+        apiKey,
+        body: {
+            model,
+            texts,
+            truncate,
+        },
+        failedResponseHandler: failedCohereCallResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(cohereTextEmbeddingResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/cohere/CohereTextGenerationModel.cjs

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereTextGenerationResponseFormat = exports.CohereTextGenerationModel = exports.COHERE_TEXT_GENERATION_MODELS = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const AsyncQueue_js_1 = require("../../model-function/generate-text/AsyncQueue.cjs");
+const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
+const PromptMappingTextGenerationModel_js_1 = require("../../prompt/PromptMappingTextGenerationModel.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_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"
+ * );
+ */
+class CohereTextGenerationModel extends AbstractModel_js_1.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 =
+            exports.COHERE_TEXT_GENERATION_MODELS[this.settings.model].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,
+        });
+    }
+    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 (0, countTokens_js_1.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 (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callCohereTextGenerationAPI(callSettings),
+        });
+    }
+    generateTextResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.CohereTextGenerationResponseFormat.json,
+        });
+    }
+    extractText(response) {
+        return response.generations[0].text;
+    }
+    generateDeltaStreamResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.CohereTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    extractTextDelta(fullDelta) {
+        return fullDelta.delta;
+    }
+    mapPrompt(promptMapping) {
+        return new PromptMappingTextGenerationModel_js_1.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 });
+    }
+}
+exports.CohereTextGenerationModel = CohereTextGenerationModel;
+const cohereTextGenerationResponseSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    generations: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        text: zod_1.z.string(),
+        finish_reason: zod_1.z.string().optional(),
+    })),
+    prompt: zod_1.z.string(),
+    meta: zod_1.z
+        .object({
+        api_version: zod_1.z.object({
+            version: zod_1.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 (0, postToApi_js_1.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: CohereError_js_1.failedCohereCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+const cohereTextStreamingResponseSchema = zod_1.z.discriminatedUnion("is_finished", [
+    zod_1.z.object({
+        text: zod_1.z.string(),
+        is_finished: zod_1.z.literal(false),
+    }),
+    zod_1.z.object({
+        is_finished: zod_1.z.literal(true),
+        finish_reason: zod_1.z.string(),
+        response: cohereTextGenerationResponseSchema,
+    }),
+]);
+async function createCohereTextGenerationFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    let accumulatedText = "";
+    function processLine(line) {
+        const event = cohereTextStreamingResponseSchema.parse(secure_json_parse_1.default.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;
+}
+exports.CohereTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: (0, postToApi_js_1.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/CohereTextGenerationModel.d.ts

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { DeltaEvent } from "../../model-function/generate-text/DeltaEvent.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { PromptMapping } from "../../prompt/PromptMapping.js";
+import { PromptMappingTextGenerationModel } from "../../prompt/PromptMappingTextGenerationModel.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+import { CohereTokenizer } from "./CohereTokenizer.js";
+export declare const COHERE_TEXT_GENERATION_MODELS: {
+    command: {
+        contextWindowSize: number;
+    };
+    "command-nightly": {
+        contextWindowSize: number;
+    };
+    "command-light": {
+        contextWindowSize: number;
+    };
+    "command-light-nightly": {
+        contextWindowSize: number;
+    };
+};
+export type CohereTextGenerationModelType = keyof typeof COHERE_TEXT_GENERATION_MODELS;
+export interface CohereTextGenerationModelSettings extends TextGenerationModelSettings {
+    model: CohereTextGenerationModelType;
+    baseUrl?: string;
+    apiKey?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+    tokenizerSettings?: {
+        retry?: RetryFunction;
+        throttle?: ThrottleFunction;
+    };
+    numGenerations?: number;
+    maxTokens?: number;
+    temperature?: number;
+    k?: number;
+    p?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    endSequences?: string[];
+    stopSequences?: string[];
+    returnLikelihoods?: "GENERATION" | "ALL" | "NONE";
+    logitBias?: Record<string, number>;
+    truncate?: "NONE" | "START" | "END";
+}
+/**
+ * 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 declare class CohereTextGenerationModel extends AbstractModel<CohereTextGenerationModelSettings> implements TextGenerationModel<string, CohereTextGenerationResponse, CohereTextGenerationDelta, CohereTextGenerationModelSettings> {
+    constructor(settings: CohereTextGenerationModelSettings);
+    readonly provider: "cohere";
+    get modelName(): "command" | "command-nightly" | "command-light" | "command-light-nightly";
+    readonly contextWindowSize: number;
+    readonly tokenizer: CohereTokenizer;
+    private get apiKey();
+    countPromptTokens(input: string): Promise<number>;
+    callAPI<RESPONSE>(prompt: string, options: {
+        responseFormat: CohereTextGenerationResponseFormatType<RESPONSE>;
+    } & FunctionOptions<CohereTextGenerationModelSettings>): Promise<RESPONSE>;
+    generateTextResponse(prompt: string, options?: FunctionOptions<CohereTextGenerationModelSettings>): Promise<{
+        prompt: string;
+        id: string;
+        generations: {
+            text: string;
+            id: string;
+            finish_reason?: string | undefined;
+        }[];
+        meta?: {
+            api_version: {
+                version: string;
+            };
+        } | undefined;
+    }>;
+    extractText(response: CohereTextGenerationResponse): string;
+    generateDeltaStreamResponse(prompt: string, options?: FunctionOptions<CohereTextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<CohereTextGenerationDelta>>>;
+    extractTextDelta(fullDelta: CohereTextGenerationDelta): string | undefined;
+    mapPrompt<INPUT_PROMPT>(promptMapping: PromptMapping<INPUT_PROMPT, string>): PromptMappingTextGenerationModel<INPUT_PROMPT, string, CohereTextGenerationResponse, CohereTextGenerationDelta, CohereTextGenerationModelSettings, this>;
+    withSettings(additionalSettings: Partial<CohereTextGenerationModelSettings>): this;
+    get maxCompletionTokens(): number | undefined;
+    withMaxCompletionTokens(maxCompletionTokens: number): this;
+    withStopTokens(stopTokens: string[]): this;
+}
+declare const cohereTextGenerationResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    generations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        finish_reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        id: string;
+        finish_reason?: string | undefined;
+    }, {
+        text: string;
+        id: string;
+        finish_reason?: string | undefined;
+    }>, "many">;
+    prompt: z.ZodString;
+    meta: z.ZodOptional<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, {
+    prompt: string;
+    id: string;
+    generations: {
+        text: string;
+        id: string;
+        finish_reason?: string | undefined;
+    }[];
+    meta?: {
+        api_version: {
+            version: string;
+        };
+    } | undefined;
+}, {
+    prompt: string;
+    id: string;
+    generations: {
+        text: string;
+        id: string;
+        finish_reason?: string | undefined;
+    }[];
+    meta?: {
+        api_version: {
+            version: string;
+        };
+    } | undefined;
+}>;
+export type CohereTextGenerationResponse = z.infer<typeof cohereTextGenerationResponseSchema>;
+export type CohereTextGenerationDelta = {
+    content: string;
+    isComplete: boolean;
+    delta: string;
+};
+export type CohereTextGenerationResponseFormatType<T> = {
+    stream: boolean;
+    handler: ResponseHandler<T>;
+};
+export declare const CohereTextGenerationResponseFormat: {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false;
+        handler: ResponseHandler<{
+            prompt: string;
+            id: string;
+            generations: {
+                text: string;
+                id: string;
+                finish_reason?: string | undefined;
+            }[];
+            meta?: {
+                api_version: {
+                    version: string;
+                };
+            } | undefined;
+        }>;
+    };
+    /**
+     * 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: ({ response }: {
+            response: Response;
+        }) => Promise<AsyncIterable<DeltaEvent<CohereTextGenerationDelta>>>;
+    };
+};
+export {};