modelfusion 0.29.0 → 0.30.0

package/model-function/generate-structure/NoSuchStructureError.d.ts

@@ -0,0 +1,4 @@
+export declare class NoSuchStructureError extends Error {
+    readonly structureName: string;
+    constructor(structureName: string);
+}

package/model-function/generate-structure/NoSuchStructureError.js

@@ -0,0 +1,13 @@
+export class NoSuchStructureError extends Error {
+    constructor(structureName) {
+        super(`No such structure: ${structureName}`);
+        Object.defineProperty(this, "structureName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "NoSuchStructureError";
+        this.structureName = structureName;
+    }
+}

package/model-function/{generate-json/JsonTextGenerationModel.cjs → generate-structure/StructureFromTextGenerationModel.cjs}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonTextGenerationModel = void 0;
+exports.StructureFromTextGenerationModel = void 0;
 const generateText_js_1 = require("../generate-text/generateText.cjs");
-class JsonTextGenerationModel {
+class StructureFromTextGenerationModel {
     constructor({ model, format, }) {
         Object.defineProperty(this, "model", {
             enumerable: true,
@@ -28,17 +28,17 @@ class JsonTextGenerationModel {
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }
-    async generateJsonResponse(prompt, options) {
+    async generateStructureResponse(prompt, options) {
         return await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt), options);
     }
-    extractJson(response) {
-        return this.format.extractJson(response);
+    extractStructure(response) {
+        return this.format.extractStructure(response);
     }
     withSettings(additionalSettings) {
-        return new JsonTextGenerationModel({
+        return new StructureFromTextGenerationModel({
             model: this.model.withSettings(additionalSettings),
             format: this.format,
         });
     }
 }
-exports.JsonTextGenerationModel = JsonTextGenerationModel;
+exports.StructureFromTextGenerationModel = StructureFromTextGenerationModel;

package/model-function/generate-structure/StructureFromTextGenerationModel.d.ts

@@ -0,0 +1,26 @@
+import { TextGenerationModel, TextGenerationModelSettings } from "../generate-text/TextGenerationModel.js";
+import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
+import { InstructionWithStructure } from "./InstructionWithStructurePrompt.js";
+import { StructureGenerationModel } from "./StructureGenerationModel.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+export type StructureFromTextPromptFormat = {
+    createPrompt: (prompt: {
+        instruction: string;
+        structure: StructureDefinition<string, unknown>;
+    }) => string;
+    extractStructure: (response: string) => unknown;
+};
+export declare class StructureFromTextGenerationModel<MODEL extends TextGenerationModel<string, any, any, TextGenerationModelSettings>> implements StructureGenerationModel<InstructionWithStructure<string, unknown>, string, MODEL["settings"]> {
+    private readonly model;
+    private readonly format;
+    constructor({ model, format, }: {
+        model: MODEL;
+        format: StructureFromTextPromptFormat;
+    });
+    get modelInformation(): import("../ModelInformation.js").ModelInformation;
+    get settings(): TextGenerationModelSettings;
+    get settingsForEvent(): Partial<MODEL["settings"]>;
+    generateStructureResponse(prompt: InstructionWithStructure<string, unknown>, options?: ModelFunctionOptions<MODEL["settings"]> | undefined): Promise<string>;
+    extractStructure(response: string): unknown;
+    withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
+}

package/model-function/{generate-json/JsonTextGenerationModel.js → generate-structure/StructureFromTextGenerationModel.js}

@@ -1,5 +1,5 @@
 import { generateText } from "../generate-text/generateText.js";
-export class JsonTextGenerationModel {
+export class StructureFromTextGenerationModel {
     constructor({ model, format, }) {
         Object.defineProperty(this, "model", {
             enumerable: true,
@@ -25,14 +25,14 @@ export class JsonTextGenerationModel {
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }
-    async generateJsonResponse(prompt, options) {
+    async generateStructureResponse(prompt, options) {
         return await generateText(this.model, this.format.createPrompt(prompt), options);
     }
-    extractJson(response) {
-        return this.format.extractJson(response);
+    extractStructure(response) {
+        return this.format.extractStructure(response);
     }
     withSettings(additionalSettings) {
-        return new JsonTextGenerationModel({
+        return new StructureFromTextGenerationModel({
             model: this.model.withSettings(additionalSettings),
             format: this.format,
         });

package/model-function/generate-structure/StructureGenerationEvent.d.ts

@@ -0,0 +1,23 @@
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export interface StructureGenerationStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "structure-generation" | "structure-or-text-generation";
+}
+export type StructureGenerationFinishedEventResult = {
+    status: "success";
+    response: unknown;
+    output: unknown;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "abort";
+};
+export type StructureGenerationFinishedEvent = BaseModelCallFinishedEvent & {
+    functionType: "structure-generation" | "structure-or-text-generation";
+    result: StructureGenerationFinishedEventResult;
+};

package/model-function/generate-structure/StructureGenerationModel.d.ts

@@ -0,0 +1,13 @@
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface StructureGenerationModelSettings extends ModelSettings {
+}
+export interface StructureGenerationModel<PROMPT, RESPONSE, SETTINGS extends StructureGenerationModelSettings> extends Model<SETTINGS> {
+    generateStructureResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    extractStructure(response: RESPONSE): unknown;
+    extractUsage?(response: RESPONSE): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}

package/model-function/generate-structure/StructureOrTextGenerationModel.cjs

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

package/model-function/generate-structure/StructureOrTextGenerationModel.d.ts

@@ -0,0 +1,23 @@
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface StructureOrTextGenerationModelSettings extends ModelSettings {
+}
+export interface StructureOrTextGenerationPrompt<RESPONSE> {
+    extractStructureAndText(response: RESPONSE): {
+        structure: null;
+        value: null;
+        text: string;
+    } | {
+        structure: string;
+        value: unknown;
+        text: string | null;
+    };
+}
+export interface StructureOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS extends StructureOrTextGenerationModelSettings> extends Model<SETTINGS> {
+    generateStructureResponse(prompt: PROMPT & StructureOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    extractUsage?(response: RESPONSE): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}

package/model-function/generate-structure/StructureOrTextGenerationModel.js

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

package/model-function/generate-structure/StructureValidationError.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureValidationError = void 0;
+const getErrorMessage_js_1 = require("../../util/getErrorMessage.cjs");
+class StructureValidationError extends Error {
+    constructor({ structureName, value, cause, }) {
+        super(`Structure validation error for '${structureName}'. ` +
+            `Value: ${JSON.stringify(value)}.\n` +
+            `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
+        Object.defineProperty(this, "structureName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "StructureValidationError";
+        this.structureName = structureName;
+        this.cause = cause;
+        this.value = value;
+    }
+}
+exports.StructureValidationError = StructureValidationError;

package/model-function/generate-structure/StructureValidationError.d.ts

@@ -0,0 +1,10 @@
+export declare class StructureValidationError extends Error {
+    readonly structureName: string;
+    readonly cause: unknown;
+    readonly value: unknown;
+    constructor({ structureName, value, cause, }: {
+        structureName: string;
+        value: unknown;
+        cause: unknown;
+    });
+}

package/model-function/generate-structure/StructureValidationError.js

@@ -0,0 +1,30 @@
+import { getErrorMessage } from "../../util/getErrorMessage.js";
+export class StructureValidationError extends Error {
+    constructor({ structureName, value, cause, }) {
+        super(`Structure validation error for '${structureName}'. ` +
+            `Value: ${JSON.stringify(value)}.\n` +
+            `Error message: ${getErrorMessage(cause)}`);
+        Object.defineProperty(this, "structureName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "StructureValidationError";
+        this.structureName = structureName;
+        this.cause = cause;
+        this.value = value;
+    }
+}

package/model-function/generate-structure/generateStructure.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStructure = void 0;
+const executeCall_js_1 = require("../executeCall.cjs");
+const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
+function generateStructure(model, structureDefinition, prompt, options) {
+    const expandedPrompt = prompt(structureDefinition);
+    return (0, executeCall_js_1.executeCall)({
+        functionType: "structure-generation",
+        input: expandedPrompt,
+        model,
+        options,
+        generateResponse: (options) => model.generateStructureResponse(expandedPrompt, options),
+        extractOutputValue: (response) => {
+            const structure = model.extractStructure(response);
+            const parseResult = structureDefinition.schema.validate(structure);
+            if (!parseResult.success) {
+                throw new StructureValidationError_js_1.StructureValidationError({
+                    structureName: structureDefinition.name,
+                    value: structure,
+                    cause: parseResult.error,
+                });
+            }
+            return parseResult.value;
+        },
+        extractUsage: (result) => model.extractUsage?.(result),
+    });
+}
+exports.generateStructure = generateStructure;

package/model-function/generate-structure/generateStructure.d.ts

@@ -0,0 +1,5 @@
+import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { ModelFunctionPromise } from "../executeCall.js";
+import { StructureGenerationModel, StructureGenerationModelSettings } from "./StructureGenerationModel.js";
+export declare function generateStructure<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, RESPONSE, SETTINGS>, structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: (structureDefinition: StructureDefinition<NAME, STRUCTURE>) => PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<STRUCTURE, RESPONSE>;

package/model-function/generate-structure/generateStructure.js

@@ -0,0 +1,25 @@
+import { executeCall } from "../executeCall.js";
+import { StructureValidationError } from "./StructureValidationError.js";
+export function generateStructure(model, structureDefinition, prompt, options) {
+    const expandedPrompt = prompt(structureDefinition);
+    return executeCall({
+        functionType: "structure-generation",
+        input: expandedPrompt,
+        model,
+        options,
+        generateResponse: (options) => model.generateStructureResponse(expandedPrompt, options),
+        extractOutputValue: (response) => {
+            const structure = model.extractStructure(response);
+            const parseResult = structureDefinition.schema.validate(structure);
+            if (!parseResult.success) {
+                throw new StructureValidationError({
+                    structureName: structureDefinition.name,
+                    value: structure,
+                    cause: parseResult.error,
+                });
+            }
+            return parseResult.value;
+        },
+        extractUsage: (result) => model.extractUsage?.(result),
+    });
+}

package/model-function/generate-structure/generateStructureOrText.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStructureOrText = void 0;
+const executeCall_js_1 = require("../executeCall.cjs");
+const NoSuchStructureError_js_1 = require("./NoSuchStructureError.cjs");
+const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
+function generateStructureOrText(model, structures, prompt, options) {
+    const expandedPrompt = prompt(structures);
+    return (0, executeCall_js_1.executeCall)({
+        functionType: "structure-or-text-generation",
+        input: expandedPrompt,
+        model,
+        options,
+        generateResponse: (options) => model.generateStructureResponse(expandedPrompt, options),
+        extractOutputValue: (response) => {
+            const { structure, value, text } = expandedPrompt.extractStructureAndText(response);
+            // text generation:
+            if (structure == null) {
+                return { structure, value, text };
+            }
+            const definition = structures.find((d) => d.name === structure);
+            if (definition == undefined) {
+                throw new NoSuchStructureError_js_1.NoSuchStructureError(structure);
+            }
+            const parseResult = definition.schema.validate(value);
+            if (!parseResult.success) {
+                throw new StructureValidationError_js_1.StructureValidationError({
+                    structureName: structure,
+                    value,
+                    cause: parseResult.error,
+                });
+            }
+            return {
+                structure: structure,
+                value: parseResult.value,
+                text: text, // text is string | null, which is part of the response for schema values
+            };
+        },
+        extractUsage: (result) => model.extractUsage?.(result),
+    });
+}
+exports.generateStructureOrText = generateStructureOrText;

package/model-function/generate-structure/generateStructureOrText.d.ts

@@ -0,0 +1,22 @@
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { ModelFunctionPromise } from "../executeCall.js";
+import { StructureOrTextGenerationModel, StructureOrTextGenerationModelSettings, StructureOrTextGenerationPrompt } from "./StructureOrTextGenerationModel.js";
+import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
+type StructureDefinitionArray<T extends StructureDefinition<any, any>[]> = T;
+type ToStructureDefinitionMap<T extends StructureDefinitionArray<StructureDefinition<any, any>[]>> = {
+    [K in T[number]["name"]]: Extract<T[number], StructureDefinition<K, any>>;
+};
+type ToStructureUnion<T> = {
+    [KEY in keyof T]: T[KEY] extends StructureDefinition<any, infer STRUCTURE> ? {
+        structure: KEY;
+        value: STRUCTURE;
+        text: string | null;
+    } : never;
+}[keyof T];
+type ToOutputValue<STRUCTURES extends StructureDefinitionArray<StructureDefinition<any, any>[]>> = ToStructureUnion<ToStructureDefinitionMap<STRUCTURES>>;
+export declare function generateStructureOrText<STRUCTURES extends StructureDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends StructureOrTextGenerationModelSettings>(model: StructureOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS>, structures: STRUCTURES, prompt: (structures: STRUCTURES) => PROMPT & StructureOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<{
+    structure: null;
+    value: null;
+    text: string;
+} | ToOutputValue<STRUCTURES>, RESPONSE>;
+export {};

package/model-function/generate-structure/generateStructureOrText.js

@@ -0,0 +1,38 @@
+import { executeCall } from "../executeCall.js";
+import { NoSuchStructureError } from "./NoSuchStructureError.js";
+import { StructureValidationError } from "./StructureValidationError.js";
+export function generateStructureOrText(model, structures, prompt, options) {
+    const expandedPrompt = prompt(structures);
+    return executeCall({
+        functionType: "structure-or-text-generation",
+        input: expandedPrompt,
+        model,
+        options,
+        generateResponse: (options) => model.generateStructureResponse(expandedPrompt, options),
+        extractOutputValue: (response) => {
+            const { structure, value, text } = expandedPrompt.extractStructureAndText(response);
+            // text generation:
+            if (structure == null) {
+                return { structure, value, text };
+            }
+            const definition = structures.find((d) => d.name === structure);
+            if (definition == undefined) {
+                throw new NoSuchStructureError(structure);
+            }
+            const parseResult = definition.schema.validate(value);
+            if (!parseResult.success) {
+                throw new StructureValidationError({
+                    structureName: structure,
+                    value,
+                    cause: parseResult.error,
+                });
+            }
+            return {
+                structure: structure,
+                value: parseResult.value,
+                text: text, // text is string | null, which is part of the response for schema values
+            };
+        },
+        extractUsage: (result) => model.extractUsage?.(result),
+    });
+}

package/model-function/index.cjs

@@ -28,16 +28,15 @@ __exportStar(require("./embed-text/embedText.cjs"), exports);
 __exportStar(require("./generate-image/ImageGenerationEvent.cjs"), exports);
 __exportStar(require("./generate-image/ImageGenerationModel.cjs"), exports);
 __exportStar(require("./generate-image/generateImage.cjs"), exports);
-__exportStar(require("./generate-json/InstructionWithSchemaPrompt.cjs"), exports);
-__exportStar(require("./generate-json/JsonGenerationEvent.cjs"), exports);
-__exportStar(require("./generate-json/JsonGenerationModel.cjs"), exports);
-__exportStar(require("./generate-json/JsonOrTextGenerationModel.cjs"), exports);
-__exportStar(require("./generate-json/JsonTextGenerationModel.cjs"), exports);
-__exportStar(require("./generate-json/NoSuchSchemaError.cjs"), exports);
-__exportStar(require("./generate-json/SchemaDefinition.cjs"), exports);
-__exportStar(require("./generate-json/SchemaValidationError.cjs"), exports);
-__exportStar(require("./generate-json/generateJson.cjs"), exports);
-__exportStar(require("./generate-json/generateJsonOrText.cjs"), exports);
+__exportStar(require("./generate-structure/InstructionWithStructurePrompt.cjs"), exports);
+__exportStar(require("./generate-structure/StructureGenerationEvent.cjs"), exports);
+__exportStar(require("./generate-structure/StructureGenerationModel.cjs"), exports);
+__exportStar(require("./generate-structure/StructureOrTextGenerationModel.cjs"), exports);
+__exportStar(require("./generate-structure/StructureFromTextGenerationModel.cjs"), exports);
+__exportStar(require("./generate-structure/NoSuchStructureError.cjs"), exports);
+__exportStar(require("./generate-structure/StructureValidationError.cjs"), exports);
+__exportStar(require("./generate-structure/generateStructure.cjs"), exports);
+__exportStar(require("./generate-structure/generateStructureOrText.cjs"), exports);
 __exportStar(require("./generate-text/DeltaEvent.cjs"), exports);
 __exportStar(require("./generate-text/TextDeltaEventSource.cjs"), exports);
 __exportStar(require("./generate-text/TextGenerationEvent.cjs"), exports);

package/model-function/index.d.ts

@@ -12,16 +12,15 @@ export * from "./embed-text/embedText.js";
 export * from "./generate-image/ImageGenerationEvent.js";
 export * from "./generate-image/ImageGenerationModel.js";
 export * from "./generate-image/generateImage.js";
-export * from "./generate-json/InstructionWithSchemaPrompt.js";
-export * from "./generate-json/JsonGenerationEvent.js";
-export * from "./generate-json/JsonGenerationModel.js";
-export * from "./generate-json/JsonOrTextGenerationModel.js";
-export * from "./generate-json/JsonTextGenerationModel.js";
-export * from "./generate-json/NoSuchSchemaError.js";
-export * from "./generate-json/SchemaDefinition.js";
-export * from "./generate-json/SchemaValidationError.js";
-export * from "./generate-json/generateJson.js";
-export * from "./generate-json/generateJsonOrText.js";
+export * from "./generate-structure/InstructionWithStructurePrompt.js";
+export * from "./generate-structure/StructureGenerationEvent.js";
+export * from "./generate-structure/StructureGenerationModel.js";
+export * from "./generate-structure/StructureOrTextGenerationModel.js";
+export * from "./generate-structure/StructureFromTextGenerationModel.js";
+export * from "./generate-structure/NoSuchStructureError.js";
+export * from "./generate-structure/StructureValidationError.js";
+export * from "./generate-structure/generateStructure.js";
+export * from "./generate-structure/generateStructureOrText.js";
 export * from "./generate-text/DeltaEvent.js";
 export * from "./generate-text/TextDeltaEventSource.js";
 export * from "./generate-text/TextGenerationEvent.js";

package/model-function/index.js

@@ -12,16 +12,15 @@ export * from "./embed-text/embedText.js";
 export * from "./generate-image/ImageGenerationEvent.js";
 export * from "./generate-image/ImageGenerationModel.js";
 export * from "./generate-image/generateImage.js";
-export * from "./generate-json/InstructionWithSchemaPrompt.js";
-export * from "./generate-json/JsonGenerationEvent.js";
-export * from "./generate-json/JsonGenerationModel.js";
-export * from "./generate-json/JsonOrTextGenerationModel.js";
-export * from "./generate-json/JsonTextGenerationModel.js";
-export * from "./generate-json/NoSuchSchemaError.js";
-export * from "./generate-json/SchemaDefinition.js";
-export * from "./generate-json/SchemaValidationError.js";
-export * from "./generate-json/generateJson.js";
-export * from "./generate-json/generateJsonOrText.js";
+export * from "./generate-structure/InstructionWithStructurePrompt.js";
+export * from "./generate-structure/StructureGenerationEvent.js";
+export * from "./generate-structure/StructureGenerationModel.js";
+export * from "./generate-structure/StructureOrTextGenerationModel.js";
+export * from "./generate-structure/StructureFromTextGenerationModel.js";
+export * from "./generate-structure/NoSuchStructureError.js";
+export * from "./generate-structure/StructureValidationError.js";
+export * from "./generate-structure/generateStructure.js";
+export * from "./generate-structure/generateStructureOrText.js";
 export * from "./generate-text/DeltaEvent.js";
 export * from "./generate-text/TextDeltaEventSource.js";
 export * from "./generate-text/TextGenerationEvent.js";

package/model-provider/openai/OpenAICostCalculator.cjs

@@ -36,7 +36,7 @@ class OpenAICostCalculator {
                 }
                 break;
             }
-            case "json-generation":
+            case "structure-generation":
             case "text-generation": {
                 if (model == null) {
                     return null;

package/model-provider/openai/OpenAICostCalculator.js

@@ -33,7 +33,7 @@ export class OpenAICostCalculator {
                 }
                 break;
             }
-            case "json-generation":
+            case "structure-generation":
             case "text-generation": {
                 if (model == null) {
                     return null;

package/model-provider/openai/OpenAITextEmbeddingModel.cjs

@@ -58,7 +58,7 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 1
+            value: 2048
         });
         Object.defineProperty(this, "embeddingDimensions", {
             enumerable: true,
@@ -90,7 +90,7 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
     async countTokens(input) {
         return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
     }
-    async callAPI(text, options) {
+    async callAPI(texts, options) {
         const run = options?.run;
         const settings = options?.settings;
         const combinedSettings = {
@@ -103,7 +103,7 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
             ...combinedSettings,
             // other settings:
             abortSignal: run?.abortSignal,
-            input: text,
+            input: texts,
         };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: callSettings.api?.retry,
@@ -118,7 +118,7 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
         if (texts.length > this.maxTextsPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxTextsPerCall} texts per API call.`);
         }
-        return this.callAPI(texts[0], options);
+        return this.callAPI(texts, options);
     }
     extractEmbeddings(response) {
         return [response.data[0].embedding];
@@ -130,13 +130,11 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
 exports.OpenAITextEmbeddingModel = OpenAITextEmbeddingModel;
 const openAITextEmbeddingResponseSchema = zod_1.default.object({
     object: zod_1.default.literal("list"),
-    data: zod_1.default
-        .array(zod_1.default.object({
+    data: zod_1.default.array(zod_1.default.object({
         object: zod_1.default.literal("embedding"),
         embedding: zod_1.default.array(zod_1.default.number()),
         index: zod_1.default.number(),
-    }))
-        .length(1),
+    })),
     model: zod_1.default.string(),
     usage: zod_1.default.object({
         prompt_tokens: zod_1.default.number(),

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

@@ -40,12 +40,12 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     constructor(settings: OpenAITextEmbeddingModelSettings);
     readonly provider: "openai";
     get modelName(): "text-embedding-ada-002";
-    readonly maxTextsPerCall = 1;
+    readonly maxTextsPerCall = 2048;
     readonly embeddingDimensions: number;
     readonly tokenizer: TikTokenTokenizer;
     readonly contextWindowSize: number;
     countTokens(input: string): Promise<number>;
-    callAPI(text: string, options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
+    callAPI(texts: Array<string>, options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
     get settingsForEvent(): Partial<OpenAITextEmbeddingModelSettings>;
     generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
         object: "list";