modelfusion 0.112.0 → 0.114.0

package/core/api/BaseUrlApiConfiguration.d.ts

@@ -1,4 +1,5 @@
 import { AbstractApiConfiguration } from "./AbstractApiConfiguration.js";
+import { CustomHeaderProvider } from "./CustomHeaderProvider.js";
 import { RetryFunction } from "./RetryFunction.js";
 import { ThrottleFunction } from "./ThrottleFunction.js";
 export type UrlParts = {
@@ -10,6 +11,7 @@ export type UrlParts = {
 export type BaseUrlPartsApiConfigurationOptions = {
     baseUrl: string | UrlParts;
     headers?: Record<string, string>;
+    customCallHeaders?: CustomHeaderProvider;
     retry?: RetryFunction;
     throttle?: ThrottleFunction;
 };
@@ -20,18 +22,16 @@ export type BaseUrlPartsApiConfigurationOptions = {
  */
 export declare class BaseUrlApiConfiguration extends AbstractApiConfiguration {
     readonly baseUrl: UrlParts;
-    readonly headers: Record<string, string>;
-    constructor({ baseUrl, headers, retry, throttle, }: BaseUrlPartsApiConfigurationOptions);
+    protected readonly fixedHeadersValue: Record<string, string>;
+    constructor({ baseUrl, headers, retry, throttle, customCallHeaders, }: BaseUrlPartsApiConfigurationOptions);
+    fixedHeaders(): Record<string, string>;
     assembleUrl(path: string): string;
 }
-export type PartialBaseUrlPartsApiConfigurationOptions = {
+export type PartialBaseUrlPartsApiConfigurationOptions = Omit<BaseUrlPartsApiConfigurationOptions, "baseUrl"> & {
     baseUrl?: string | Partial<UrlParts>;
-    headers?: Record<string, string>;
-    retry?: RetryFunction;
-    throttle?: ThrottleFunction;
 };
 export declare class BaseUrlApiConfigurationWithDefaults extends BaseUrlApiConfiguration {
-    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, }: {
+    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, customCallHeaders, }: {
         baseUrlDefaults: UrlParts;
     } & PartialBaseUrlPartsApiConfigurationOptions);
 }

package/core/api/BaseUrlApiConfiguration.js

@@ -5,22 +5,25 @@ import { AbstractApiConfiguration } from "./AbstractApiConfiguration.js";
  * You can use it to configure custom APIs for models, e.g. your own internal OpenAI proxy with custom headers.
  */
 export class BaseUrlApiConfiguration extends AbstractApiConfiguration {
-    constructor({ baseUrl, headers, retry, throttle, }) {
-        super({ retry, throttle });
+    constructor({ baseUrl, headers, retry, throttle, customCallHeaders, }) {
+        super({ retry, throttle, customCallHeaders });
         Object.defineProperty(this, "baseUrl", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "headers", {
+        Object.defineProperty(this, "fixedHeadersValue", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
         this.baseUrl = typeof baseUrl == "string" ? parseBaseUrl(baseUrl) : baseUrl;
-        this.headers = headers ?? {};
+        this.fixedHeadersValue = headers ?? {};
+    }
+    fixedHeaders() {
+        return this.fixedHeadersValue;
     }
     assembleUrl(path) {
         let basePath = this.baseUrl.path;
@@ -36,12 +39,13 @@ export class BaseUrlApiConfiguration extends AbstractApiConfiguration {
     }
 }
 export class BaseUrlApiConfigurationWithDefaults extends BaseUrlApiConfiguration {
-    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, }) {
+    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, customCallHeaders, }) {
         super({
             baseUrl: resolveBaseUrl(baseUrl, baseUrlDefaults),
             headers,
             retry,
             throttle,
+            customCallHeaders,
         });
     }
 }

package/core/api/CustomHeaderProvider.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/api/CustomHeaderProvider.d.ts

@@ -0,0 +1,2 @@
+import { HeaderParameters } from "./ApiConfiguration.js";
+export type CustomHeaderProvider = (headerParameters: HeaderParameters) => Record<string, string | undefined>;

package/core/api/CustomHeaderProvider.js

@@ -0,0 +1 @@
+export {};

package/core/api/index.cjs

@@ -32,6 +32,7 @@ __exportStar(require("./ApiCallError.cjs"), exports);
 __exportStar(require("./ApiConfiguration.cjs"), exports);
 exports.api = __importStar(require("./ApiFacade.cjs"));
 __exportStar(require("./BaseUrlApiConfiguration.cjs"), exports);
+__exportStar(require("./CustomHeaderProvider.cjs"), exports);
 __exportStar(require("./RetryError.cjs"), exports);
 __exportStar(require("./RetryFunction.cjs"), exports);
 __exportStar(require("./ThrottleFunction.cjs"), exports);

package/core/api/index.d.ts

@@ -3,6 +3,7 @@ export * from "./ApiCallError.js";
 export * from "./ApiConfiguration.js";
 export * as api from "./ApiFacade.js";
 export * from "./BaseUrlApiConfiguration.js";
+export * from "./CustomHeaderProvider.js";
 export * from "./RetryError.js";
 export * from "./RetryFunction.js";
 export * from "./ThrottleFunction.js";

package/core/api/index.js

@@ -3,6 +3,7 @@ export * from "./ApiCallError.js";
 export * from "./ApiConfiguration.js";
 export * as api from "./ApiFacade.js";
 export * from "./BaseUrlApiConfiguration.js";
+export * from "./CustomHeaderProvider.js";
 export * from "./RetryError.js";
 export * from "./RetryFunction.js";
 export * from "./ThrottleFunction.js";

package/core/cache/Cache.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/cache/Cache.d.ts

@@ -0,0 +1,12 @@
+export interface Cache {
+    lookupValue(key: {
+        functionType: string;
+        functionId?: string | undefined;
+        input: unknown;
+    }): Promise<object | null>;
+    storeValue(key: {
+        functionType: string;
+        functionId?: string | undefined;
+        input: unknown;
+    }, value: unknown): Promise<void>;
+}

package/core/cache/Cache.js

@@ -0,0 +1 @@
+export {};

package/core/cache/MemoryCache.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCache = void 0;
+class MemoryCache {
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    hashKey(key) {
+        return JSON.stringify(key);
+    }
+    async lookupValue(key) {
+        return this.cache.get(this.hashKey(key)) ?? null;
+    }
+    async storeValue(key, value) {
+        this.cache.set(this.hashKey(key), value);
+    }
+}
+exports.MemoryCache = MemoryCache;

package/core/cache/MemoryCache.d.ts

@@ -0,0 +1,15 @@
+import { Cache } from "./Cache.js";
+export declare class MemoryCache implements Cache {
+    private readonly cache;
+    private hashKey;
+    lookupValue(key: {
+        functionType: string;
+        functionId?: string | undefined;
+        input: unknown;
+    }): Promise<object | null>;
+    storeValue(key: {
+        functionType: string;
+        functionId?: string | undefined;
+        input: unknown;
+    }, value: unknown): Promise<void>;
+}

package/core/cache/MemoryCache.js

@@ -0,0 +1,19 @@
+export class MemoryCache {
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    hashKey(key) {
+        return JSON.stringify(key);
+    }
+    async lookupValue(key) {
+        return this.cache.get(this.hashKey(key)) ?? null;
+    }
+    async storeValue(key, value) {
+        this.cache.set(this.hashKey(key), value);
+    }
+}

package/core/cache/index.cjs

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./Cache.cjs"), exports);
+__exportStar(require("./MemoryCache.cjs"), exports);

package/core/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Cache.js";
+export * from "./MemoryCache.js";

package/core/cache/index.js

@@ -0,0 +1,2 @@
+export * from "./Cache.js";
+export * from "./MemoryCache.js";

package/core/index.cjs

@@ -38,6 +38,7 @@ exports.modelfusion = __importStar(require("./ModelFusionConfiguration.cjs"));
 __exportStar(require("./Run.cjs"), exports);
 __exportStar(require("./Vector.cjs"), exports);
 __exportStar(require("./api/index.cjs"), exports);
+__exportStar(require("./cache/index.cjs"), exports);
 __exportStar(require("./executeFunction.cjs"), exports);
 __exportStar(require("./getRun.cjs"), exports);
 __exportStar(require("./schema/index.cjs"), exports);

package/core/index.d.ts

@@ -9,6 +9,7 @@ export * as modelfusion from "./ModelFusionConfiguration.js";
 export * from "./Run.js";
 export * from "./Vector.js";
 export * from "./api/index.js";
+export * from "./cache/index.js";
 export * from "./executeFunction.js";
 export * from "./getRun.js";
 export * from "./schema/index.js";

package/core/index.js

@@ -9,6 +9,7 @@ export * as modelfusion from "./ModelFusionConfiguration.js";
 export * from "./Run.js";
 export * from "./Vector.js";
 export * from "./api/index.js";
+export * from "./cache/index.js";
 export * from "./executeFunction.js";
 export * from "./getRun.js";
 export * from "./schema/index.js";

package/core/schema/TypeValidationError.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeValidationError = void 0;
+const getErrorMessage_js_1 = require("../../util/getErrorMessage.cjs");
+class TypeValidationError extends Error {
+    constructor({ structure, cause }) {
+        super(`Type validation failed: ` +
+            `Structure: ${JSON.stringify(structure)}.\n` +
+            `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
+        Object.defineProperty(this, "structure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "TypeValidationError";
+        this.cause = cause;
+        this.structure = structure;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            object: this.structure,
+        };
+    }
+}
+exports.TypeValidationError = TypeValidationError;

package/core/schema/TypeValidationError.d.ts

@@ -0,0 +1,15 @@
+export declare class TypeValidationError extends Error {
+    readonly structure: unknown;
+    readonly cause: unknown;
+    constructor({ structure, cause }: {
+        structure: unknown;
+        cause: unknown;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        cause: unknown;
+        stack: string | undefined;
+        object: unknown;
+    };
+}

package/core/schema/TypeValidationError.js

@@ -0,0 +1,32 @@
+import { getErrorMessage } from "../../util/getErrorMessage.js";
+export class TypeValidationError extends Error {
+    constructor({ structure, cause }) {
+        super(`Type validation failed: ` +
+            `Structure: ${JSON.stringify(structure)}.\n` +
+            `Error message: ${getErrorMessage(cause)}`);
+        Object.defineProperty(this, "structure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "TypeValidationError";
+        this.cause = cause;
+        this.structure = structure;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            object: this.structure,
+        };
+    }
+}

package/core/schema/index.cjs

@@ -17,6 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./JSONParseError.cjs"), exports);
 __exportStar(require("./JsonSchemaProducer.cjs"), exports);
 __exportStar(require("./Schema.cjs"), exports);
+__exportStar(require("./TypeValidationError.cjs"), exports);
 __exportStar(require("./UncheckedSchema.cjs"), exports);
 __exportStar(require("./ZodSchema.cjs"), exports);
 __exportStar(require("./parseJSON.cjs"), exports);
+__exportStar(require("./validateTypes.cjs"), exports);

package/core/schema/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./JSONParseError.js";
 export * from "./JsonSchemaProducer.js";
 export * from "./Schema.js";
+export * from "./TypeValidationError.js";
 export * from "./UncheckedSchema.js";
 export * from "./ZodSchema.js";
 export * from "./parseJSON.js";
+export * from "./validateTypes.js";

package/core/schema/index.js

@@ -1,6 +1,8 @@
 export * from "./JSONParseError.js";
 export * from "./JsonSchemaProducer.js";
 export * from "./Schema.js";
+export * from "./TypeValidationError.js";
 export * from "./UncheckedSchema.js";
 export * from "./ZodSchema.js";
 export * from "./parseJSON.js";
+export * from "./validateTypes.js";

package/core/schema/parseJSON.cjs

@@ -6,20 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.safeParseJSON = exports.parseJSON = void 0;
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const JSONParseError_js_1 = require("./JSONParseError.cjs");
+const validateTypes_js_1 = require("./validateTypes.cjs");
+const TypeValidationError_js_1 = require("./TypeValidationError.cjs");
 function parseJSON({ text, schema, }) {
     try {
         const json = secure_json_parse_1.default.parse(text);
         if (schema == null) {
             return json;
         }
-        const validationResult = schema.validate(json);
-        if (!validationResult.success) {
-            throw new JSONParseError_js_1.JSONParseError({ text, cause: validationResult.error });
-        }
-        return validationResult.data;
+        return (0, validateTypes_js_1.validateTypes)({ structure: json, schema });
     }
     catch (error) {
-        if (error instanceof JSONParseError_js_1.JSONParseError) {
+        if (error instanceof JSONParseError_js_1.JSONParseError ||
+            error instanceof TypeValidationError_js_1.TypeValidationError) {
             throw error;
         }
         throw new JSONParseError_js_1.JSONParseError({ text, cause: error });
@@ -35,14 +34,7 @@ function safeParseJSON({ text, schema, }) {
                 data: json,
             };
         }
-        const validationResult = schema.validate(json);
-        if (validationResult.success) {
-            return validationResult;
-        }
-        return {
-            success: false,
-            error: new JSONParseError_js_1.JSONParseError({ text, cause: validationResult.error }),
-        };
+        return (0, validateTypes_js_1.safeValidateTypes)({ structure: json, schema });
     }
     catch (error) {
         return {

package/core/schema/parseJSON.d.ts

@@ -1,5 +1,6 @@
 import { JSONParseError } from "./JSONParseError.js";
 import { Schema } from "./Schema.js";
+import { TypeValidationError } from "./TypeValidationError.js";
 /**
  * Parses a JSON string into an unknown object.
  *
@@ -34,7 +35,7 @@ export declare function safeParseJSON({ text, }: {
     data: unknown;
 } | {
     success: false;
-    error: JSONParseError;
+    error: JSONParseError | TypeValidationError;
 };
 /**
  * Safely parses a JSON string into a strongly-typed object, using a provided schema to validate the structure.
@@ -52,5 +53,5 @@ export declare function safeParseJSON<T>({ text, schema, }: {
     data: T;
 } | {
     success: false;
-    error: JSONParseError;
+    error: JSONParseError | TypeValidationError;
 };

package/core/schema/parseJSON.js

@@ -1,19 +1,18 @@
 import SecureJSON from "secure-json-parse";
 import { JSONParseError } from "./JSONParseError.js";
+import { safeValidateTypes, validateTypes } from "./validateTypes.js";
+import { TypeValidationError } from "./TypeValidationError.js";
 export function parseJSON({ text, schema, }) {
     try {
         const json = SecureJSON.parse(text);
         if (schema == null) {
             return json;
         }
-        const validationResult = schema.validate(json);
-        if (!validationResult.success) {
-            throw new JSONParseError({ text, cause: validationResult.error });
-        }
-        return validationResult.data;
+        return validateTypes({ structure: json, schema });
     }
     catch (error) {
-        if (error instanceof JSONParseError) {
+        if (error instanceof JSONParseError ||
+            error instanceof TypeValidationError) {
             throw error;
         }
         throw new JSONParseError({ text, cause: error });
@@ -28,14 +27,7 @@ export function safeParseJSON({ text, schema, }) {
                 data: json,
             };
         }
-        const validationResult = schema.validate(json);
-        if (validationResult.success) {
-            return validationResult;
-        }
-        return {
-            success: false,
-            error: new JSONParseError({ text, cause: validationResult.error }),
-        };
+        return safeValidateTypes({ structure: json, schema });
     }
     catch (error) {
         return {

package/core/schema/validateTypes.cjs

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeValidateTypes = exports.validateTypes = void 0;
+const TypeValidationError_js_1 = require("./TypeValidationError.cjs");
+/**
+ * Validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} structure - The JSON structure to validate.
+ * @param {Schema<T>} schema - The schema to use for validating the JSON.
+ * @returns {T} - The typed object.
+ */
+function validateTypes({ structure, schema, }) {
+    try {
+        const validationResult = schema.validate(structure);
+        if (!validationResult.success) {
+            throw new TypeValidationError_js_1.TypeValidationError({
+                structure,
+                cause: validationResult.error,
+            });
+        }
+        return validationResult.data;
+    }
+    catch (error) {
+        if (error instanceof TypeValidationError_js_1.TypeValidationError) {
+            throw error;
+        }
+        throw new TypeValidationError_js_1.TypeValidationError({ structure: structure, cause: error });
+    }
+}
+exports.validateTypes = validateTypes;
+/**
+ * Safely validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} structure - The JSON object to validate.
+ * @param {Schema<T>} schema - The schema to use for validating the JSON.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+function safeValidateTypes({ structure, schema, }) {
+    try {
+        const validationResult = schema.validate(structure);
+        if (validationResult.success) {
+            return validationResult;
+        }
+        return {
+            success: false,
+            error: new TypeValidationError_js_1.TypeValidationError({
+                structure: structure,
+                cause: validationResult.error,
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof TypeValidationError_js_1.TypeValidationError
+                ? error
+                : new TypeValidationError_js_1.TypeValidationError({ structure: structure, cause: error }),
+        };
+    }
+}
+exports.safeValidateTypes = safeValidateTypes;

package/core/schema/validateTypes.d.ts

@@ -0,0 +1,34 @@
+import { Schema } from "./Schema.js";
+import { TypeValidationError } from "./TypeValidationError.js";
+/**
+ * Validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} structure - The JSON structure to validate.
+ * @param {Schema<T>} schema - The schema to use for validating the JSON.
+ * @returns {T} - The typed object.
+ */
+export declare function validateTypes<T>({ structure, schema, }: {
+    structure: unknown;
+    schema: Schema<T>;
+}): T;
+/**
+ * Safely validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} structure - The JSON object to validate.
+ * @param {Schema<T>} schema - The schema to use for validating the JSON.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+export declare function safeValidateTypes<T>({ structure, schema, }: {
+    structure: unknown;
+    schema: Schema<T>;
+}): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: TypeValidationError;
+};

package/core/schema/validateTypes.js

@@ -0,0 +1,60 @@
+import { TypeValidationError } from "./TypeValidationError.js";
+/**
+ * Validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} structure - The JSON structure to validate.
+ * @param {Schema<T>} schema - The schema to use for validating the JSON.
+ * @returns {T} - The typed object.
+ */
+export function validateTypes({ structure, schema, }) {
+    try {
+        const validationResult = schema.validate(structure);
+        if (!validationResult.success) {
+            throw new TypeValidationError({
+                structure,
+                cause: validationResult.error,
+            });
+        }
+        return validationResult.data;
+    }
+    catch (error) {
+        if (error instanceof TypeValidationError) {
+            throw error;
+        }
+        throw new TypeValidationError({ structure: structure, cause: error });
+    }
+}
+/**
+ * Safely validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} structure - The JSON object to validate.
+ * @param {Schema<T>} schema - The schema to use for validating the JSON.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+export function safeValidateTypes({ structure, schema, }) {
+    try {
+        const validationResult = schema.validate(structure);
+        if (validationResult.success) {
+            return validationResult;
+        }
+        return {
+            success: false,
+            error: new TypeValidationError({
+                structure: structure,
+                cause: validationResult.error,
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof TypeValidationError
+                ? error
+                : new TypeValidationError({ structure: structure, cause: error }),
+        };
+    }
+}

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { Vector } from "../../core/Vector.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface EmbeddingModelSettings extends ModelSettings {
@@ -16,7 +16,7 @@ export interface EmbeddingModel<VALUE, SETTINGS extends EmbeddingModelSettings =
      * True if the model can handle multiple embedding calls in parallel.
      */
     readonly isParallelizable: boolean;
-    doEmbedValues(values: VALUE[], options?: FunctionOptions): PromiseLike<{
+    doEmbedValues(values: VALUE[], options: FunctionCallOptions): PromiseLike<{
         response: unknown;
         embeddings: Vector[];
     }>;