modelfusion 0.55.0 → 0.56.0

package/README.md

@@ -290,7 +290,7 @@ const embeddings = await embedMany(
 );
 ```
 
-Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Cohere](https://modelfusion.dev/integration/model-provider/cohere), [Llama.cpp](https://modelfusion.dev/integration/model-provider/llamacpp), [Hugging Face](https://modelfusion.dev/integration/model-provider/huggingface)
+Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Cohere](https://modelfusion.dev/integration/model-provider/cohere), [Llama.cpp](https://modelfusion.dev/integration/model-provider/llamacpp), [Ollama](https://modelfusion.dev/integration/model-provider/ollama), [Hugging Face](https://modelfusion.dev/integration/model-provider/huggingface)
 
 ### [Tokenize Text](https://modelfusion.dev/guide/function/tokenize-text)
 

package/model-function/embed/EmbeddingModel.d.ts

@@ -12,6 +12,10 @@ export interface EmbeddingModel<VALUE, SETTINGS extends EmbeddingModelSettings =
      * Limit of how many values can be sent in a single API call.
      */
     readonly maxValuesPerCall: number | undefined;
+    /**
+     * True if the model can handle multiple embedding calls in parallel.
+     */
+    readonly isParallizable: boolean;
     doEmbedValues(values: VALUE[], options?: FunctionOptions): PromiseLike<{
         response: unknown;
         embeddings: Vector[];

package/model-function/embed/embed.cjs

@@ -41,7 +41,18 @@ function embedMany(model, values, options) {
                     valueGroups.push(values.slice(i, i + maxValuesPerCall));
                 }
             }
-            const responses = await Promise.all(valueGroups.map((valueGroup) => model.doEmbedValues(valueGroup, options)));
+            // call the model for each group:
+            let responses;
+            if (model.isParallizable) {
+                responses = await Promise.all(valueGroups.map((valueGroup) => model.doEmbedValues(valueGroup, options)));
+            }
+            else {
+                responses = [];
+                for (const valueGroup of valueGroups) {
+                    const response = await model.doEmbedValues(valueGroup, options);
+                    responses.push(response);
+                }
+            }
             const rawResponses = responses.map((response) => response.response);
             const embeddings = [];
             for (const response of responses) {

package/model-function/embed/embed.js

@@ -38,7 +38,18 @@ export function embedMany(model, values, options) {
                     valueGroups.push(values.slice(i, i + maxValuesPerCall));
                 }
             }
-            const responses = await Promise.all(valueGroups.map((valueGroup) => model.doEmbedValues(valueGroup, options)));
+            // call the model for each group:
+            let responses;
+            if (model.isParallizable) {
+                responses = await Promise.all(valueGroups.map((valueGroup) => model.doEmbedValues(valueGroup, options)));
+            }
+            else {
+                responses = [];
+                for (const valueGroup of valueGroups) {
+                    const response = await model.doEmbedValues(valueGroup, options);
+                    responses.push(response);
+                }
+            }
             const rawResponses = responses.map((response) => response.response);
             const embeddings = [];
             for (const response of responses) {

package/model-provider/cohere/CohereTextEmbeddingModel.cjs

@@ -51,6 +51,12 @@ class CohereTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             writable: true,
             value: 96
         });
+        Object.defineProperty(this, "isParallizable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "embeddingDimensions", {
             enumerable: true,
             configurable: true,

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

@@ -43,6 +43,7 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
     readonly provider: "cohere";
     get modelName(): "embed-english-light-v2.0" | "embed-english-v2.0" | "embed-multilingual-v2.0";
     readonly maxValuesPerCall = 96;
+    readonly isParallizable = true;
     readonly embeddingDimensions: number;
     readonly contextWindowSize: number;
     private readonly tokenizer;

package/model-provider/cohere/CohereTextEmbeddingModel.js

@@ -48,6 +48,12 @@ export class CohereTextEmbeddingModel extends AbstractModel {
             writable: true,
             value: 96
         });
+        Object.defineProperty(this, "isParallizable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "embeddingDimensions", {
             enumerable: true,
             configurable: true,

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.cjs

@@ -42,6 +42,12 @@ class HuggingFaceTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "isParallizable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "contextWindowSize", {
             enumerable: true,
             configurable: true,

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.d.ts

@@ -38,6 +38,7 @@ export declare class HuggingFaceTextEmbeddingModel extends AbstractModel<Hugging
     readonly provider = "huggingface";
     get modelName(): string;
     readonly maxValuesPerCall: number;
+    readonly isParallizable = true;
     readonly contextWindowSize: undefined;
     readonly embeddingDimensions: number | undefined;
     readonly tokenizer: undefined;

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.js

@@ -39,6 +39,12 @@ export class HuggingFaceTextEmbeddingModel extends AbstractModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "isParallizable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "contextWindowSize", {
             enumerable: true,
             configurable: true,

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.cjs

@@ -29,12 +29,6 @@ class LlamaCppTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             writable: true,
             value: undefined
         });
-        Object.defineProperty(this, "embeddingDimensions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "tokenizer", {
             enumerable: true,
             configurable: true,
@@ -42,11 +36,16 @@ class LlamaCppTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             value: void 0
         });
         this.tokenizer = new LlamaCppTokenizer_js_1.LlamaCppTokenizer(this.settings.api);
-        this.embeddingDimensions = this.settings.embeddingDimensions;
     }
     get modelName() {
         return null;
     }
+    get isParallizable() {
+        return this.settings.isParallizable ?? false;
+    }
+    get embeddingDimensions() {
+        return this.settings.embeddingDimensions;
+    }
     async tokenize(text) {
         return this.tokenizer.tokenize(text);
     }

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.d.ts

@@ -6,14 +6,16 @@ import { EmbeddingModel, EmbeddingModelSettings } from "../../model-function/emb
 export interface LlamaCppTextEmbeddingModelSettings extends EmbeddingModelSettings {
     api?: ApiConfiguration;
     embeddingDimensions?: number;
+    isParallizable?: boolean;
 }
 export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTextEmbeddingModelSettings> implements EmbeddingModel<string, LlamaCppTextEmbeddingModelSettings> {
     constructor(settings?: LlamaCppTextEmbeddingModelSettings);
     readonly provider: "llamacpp";
     get modelName(): null;
     readonly maxValuesPerCall = 1;
+    get isParallizable(): boolean;
     readonly contextWindowSize: undefined;
-    readonly embeddingDimensions: number | undefined;
+    get embeddingDimensions(): number | undefined;
     private readonly tokenizer;
     tokenize(text: string): Promise<number[]>;
     callAPI(texts: Array<string>, options?: FunctionOptions): Promise<LlamaCppTextEmbeddingResponse>;

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.js

@@ -26,12 +26,6 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
             writable: true,
             value: undefined
         });
-        Object.defineProperty(this, "embeddingDimensions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "tokenizer", {
             enumerable: true,
             configurable: true,
@@ -39,11 +33,16 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
             value: void 0
         });
         this.tokenizer = new LlamaCppTokenizer(this.settings.api);
-        this.embeddingDimensions = this.settings.embeddingDimensions;
     }
     get modelName() {
         return null;
     }
+    get isParallizable() {
+        return this.settings.isParallizable ?? false;
+    }
+    get embeddingDimensions() {
+        return this.settings.embeddingDimensions;
+    }
     async tokenize(text) {
         return this.tokenizer.tokenize(text);
     }

package/model-provider/ollama/OllamaError.cjs

@@ -1,14 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.failedOllamaCallResponseHandler = exports.OllamaError = exports.ollamaErrorDataSchema = void 0;
-const zod_1 = require("zod");
+exports.failedOllamaCallResponseHandler = exports.OllamaError = void 0;
 const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
-const parseJSON_js_1 = require("../../util/parseJSON.cjs");
-exports.ollamaErrorDataSchema = zod_1.z.object({
-    error: zod_1.z.string(),
-});
 class OllamaError extends ApiCallError_js_1.ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message = data.error, }) {
+    constructor({ statusCode, url, requestBodyValues, message, }) {
         super({ message, statusCode, requestBodyValues, url });
         Object.defineProperty(this, "data", {
             enumerable: true,
@@ -16,7 +11,6 @@ class OllamaError extends ApiCallError_js_1.ApiCallError {
             writable: true,
             value: void 0
         });
-        this.data = data;
     }
 }
 exports.OllamaError = OllamaError;
@@ -24,6 +18,6 @@ const failedOllamaCallResponseHandler = async ({ response, url, requestBodyValue
     url,
     requestBodyValues,
     statusCode: response.status,
-    data: (0, parseJSON_js_1.parseJsonWithZod)(await response.text(), exports.ollamaErrorDataSchema),
+    message: await response.text(),
 });
 exports.failedOllamaCallResponseHandler = failedOllamaCallResponseHandler;

package/model-provider/ollama/OllamaError.d.ts

@@ -1,22 +1,12 @@
-import { z } from "zod";
 import { ApiCallError } from "../../core/api/ApiCallError.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
-export declare const ollamaErrorDataSchema: z.ZodObject<{
-    error: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    error: string;
-}, {
-    error: string;
-}>;
-export type OllamaErrorData = z.infer<typeof ollamaErrorDataSchema>;
 export declare class OllamaError extends ApiCallError {
-    readonly data: OllamaErrorData;
-    constructor({ data, statusCode, url, requestBodyValues, message, }: {
-        message?: string;
+    readonly data: string;
+    constructor({ statusCode, url, requestBodyValues, message, }: {
+        message: string;
         statusCode: number;
         url: string;
         requestBodyValues: unknown;
-        data: OllamaErrorData;
     });
 }
 export declare const failedOllamaCallResponseHandler: ResponseHandler<ApiCallError>;

package/model-provider/ollama/OllamaError.js

@@ -1,11 +1,6 @@
-import { z } from "zod";
 import { ApiCallError } from "../../core/api/ApiCallError.js";
-import { parseJsonWithZod } from "../../util/parseJSON.js";
-export const ollamaErrorDataSchema = z.object({
-    error: z.string(),
-});
 export class OllamaError extends ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message = data.error, }) {
+    constructor({ statusCode, url, requestBodyValues, message, }) {
         super({ message, statusCode, requestBodyValues, url });
         Object.defineProperty(this, "data", {
             enumerable: true,
@@ -13,12 +8,11 @@ export class OllamaError extends ApiCallError {
             writable: true,
             value: void 0
         });
-        this.data = data;
     }
 }
 export const failedOllamaCallResponseHandler = async ({ response, url, requestBodyValues }) => new OllamaError({
     url,
     requestBodyValues,
     statusCode: response.status,
-    data: parseJsonWithZod(await response.text(), ollamaErrorDataSchema),
+    message: await response.text(),
 });

package/model-provider/ollama/OllamaTextEmbeddingModel.cjs

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaTextEmbeddingModel = void 0;
+const zod_1 = require("zod");
+const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const OllamaApiConfiguration_js_1 = require("./OllamaApiConfiguration.cjs");
+const OllamaError_js_1 = require("./OllamaError.cjs");
+class OllamaTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ollama"
+        });
+        Object.defineProperty(this, "maxValuesPerCall", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get modelName() {
+        return null;
+    }
+    get isParallizable() {
+        return this.settings.isParallizable ?? false;
+    }
+    get embeddingDimensions() {
+        return this.settings.embeddingDimensions;
+    }
+    async callAPI(texts, options) {
+        if (texts.length > this.maxValuesPerCall) {
+            throw new Error(`The Llama.cpp embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
+        }
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOllamaEmbeddingAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                prompt: texts[0],
+            }),
+        });
+    }
+    get settingsForEvent() {
+        return {
+            embeddingDimensions: this.settings.embeddingDimensions,
+        };
+    }
+    async doEmbedValues(texts, options) {
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: [response.embedding],
+        };
+    }
+    withSettings(additionalSettings) {
+        return new OllamaTextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.OllamaTextEmbeddingModel = OllamaTextEmbeddingModel;
+const ollamaTextEmbeddingResponseSchema = zod_1.z.object({
+    embedding: zod_1.z.array(zod_1.z.number()),
+});
+async function callOllamaEmbeddingAPI({ api = new OllamaApiConfiguration_js_1.OllamaApiConfiguration(), abortSignal, model, prompt, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: api.assembleUrl(`/api/embeddings`),
+        headers: api.headers,
+        body: { model, prompt },
+        failedResponseHandler: OllamaError_js_1.failedOllamaCallResponseHandler,
+        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(ollamaTextEmbeddingResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/ollama/OllamaTextEmbeddingModel.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { EmbeddingModel, EmbeddingModelSettings } from "../../model-function/embed/EmbeddingModel.js";
+export interface OllamaTextEmbeddingModelSettings extends EmbeddingModelSettings {
+    api?: ApiConfiguration;
+    model: string;
+    embeddingDimensions?: number;
+    isParallizable?: boolean;
+}
+export declare class OllamaTextEmbeddingModel extends AbstractModel<OllamaTextEmbeddingModelSettings> implements EmbeddingModel<string, OllamaTextEmbeddingModelSettings> {
+    constructor(settings: OllamaTextEmbeddingModelSettings);
+    readonly provider: "ollama";
+    get modelName(): null;
+    readonly maxValuesPerCall = 1;
+    get isParallizable(): boolean;
+    readonly contextWindowSize: undefined;
+    get embeddingDimensions(): number | undefined;
+    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<OllamaTextEmbeddingResponse>;
+    get settingsForEvent(): Partial<OllamaTextEmbeddingModelSettings>;
+    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+        response: {
+            embedding: number[];
+        };
+        embeddings: number[][];
+    }>;
+    withSettings(additionalSettings: Partial<OllamaTextEmbeddingModelSettings>): this;
+}
+declare const ollamaTextEmbeddingResponseSchema: z.ZodObject<{
+    embedding: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    embedding: number[];
+}, {
+    embedding: number[];
+}>;
+export type OllamaTextEmbeddingResponse = z.infer<typeof ollamaTextEmbeddingResponseSchema>;
+export {};

package/model-provider/ollama/OllamaTextEmbeddingModel.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { OllamaApiConfiguration } from "./OllamaApiConfiguration.js";
+import { failedOllamaCallResponseHandler } from "./OllamaError.js";
+export class OllamaTextEmbeddingModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ollama"
+        });
+        Object.defineProperty(this, "maxValuesPerCall", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get modelName() {
+        return null;
+    }
+    get isParallizable() {
+        return this.settings.isParallizable ?? false;
+    }
+    get embeddingDimensions() {
+        return this.settings.embeddingDimensions;
+    }
+    async callAPI(texts, options) {
+        if (texts.length > this.maxValuesPerCall) {
+            throw new Error(`The Llama.cpp embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
+        }
+        return callWithRetryAndThrottle({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOllamaEmbeddingAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                prompt: texts[0],
+            }),
+        });
+    }
+    get settingsForEvent() {
+        return {
+            embeddingDimensions: this.settings.embeddingDimensions,
+        };
+    }
+    async doEmbedValues(texts, options) {
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: [response.embedding],
+        };
+    }
+    withSettings(additionalSettings) {
+        return new OllamaTextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+const ollamaTextEmbeddingResponseSchema = z.object({
+    embedding: z.array(z.number()),
+});
+async function callOllamaEmbeddingAPI({ api = new OllamaApiConfiguration(), abortSignal, model, prompt, }) {
+    return postJsonToApi({
+        url: api.assembleUrl(`/api/embeddings`),
+        headers: api.headers,
+        body: { model, prompt },
+        failedResponseHandler: failedOllamaCallResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(ollamaTextEmbeddingResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/ollama/index.cjs

@@ -18,4 +18,5 @@ exports.OllamaError = void 0;
 __exportStar(require("./OllamaApiConfiguration.cjs"), exports);
 var OllamaError_js_1 = require("./OllamaError.cjs");
 Object.defineProperty(exports, "OllamaError", { enumerable: true, get: function () { return OllamaError_js_1.OllamaError; } });
+__exportStar(require("./OllamaTextEmbeddingModel.cjs"), exports);
 __exportStar(require("./OllamaTextGenerationModel.cjs"), exports);

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

@@ -1,3 +1,4 @@
 export * from "./OllamaApiConfiguration.js";
-export { OllamaError, OllamaErrorData } from "./OllamaError.js";
+export { OllamaError } from "./OllamaError.js";
+export * from "./OllamaTextEmbeddingModel.js";
 export * from "./OllamaTextGenerationModel.js";

package/model-provider/ollama/index.js

@@ -1,3 +1,4 @@
 export * from "./OllamaApiConfiguration.js";
 export { OllamaError } from "./OllamaError.js";
+export * from "./OllamaTextEmbeddingModel.js";
 export * from "./OllamaTextGenerationModel.js";

package/model-provider/openai/OpenAITextEmbeddingModel.cjs

@@ -57,6 +57,12 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             writable: true,
             value: 2048
         });
+        Object.defineProperty(this, "isParallizable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "embeddingDimensions", {
             enumerable: true,
             configurable: true,

package/model-provider/openai/OpenAITextEmbeddingModel.d.ts

@@ -41,6 +41,7 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     readonly provider: "openai";
     get modelName(): "text-embedding-ada-002";
     readonly maxValuesPerCall = 2048;
+    readonly isParallizable = true;
     readonly embeddingDimensions: number;
     readonly tokenizer: TikTokenTokenizer;
     readonly contextWindowSize: number;

package/model-provider/openai/OpenAITextEmbeddingModel.js

@@ -52,6 +52,12 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
             writable: true,
             value: 2048
         });
+        Object.defineProperty(this, "isParallizable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "embeddingDimensions", {
             enumerable: true,
             configurable: true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [