modelfusion 0.132.0 → 0.134.0

package/model-function/executeStreamCall.js

@@ -1,176 +0,0 @@
-import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "../core/FunctionEventSource.js";
-import { getLogFormat } from "../core/ModelFusionConfiguration.js";
-import { getFunctionObservers } from "../core/ModelFusionConfiguration.js";
-import { AbortError } from "../core/api/AbortError.js";
-import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
-import { getRun } from "../core/getRun.js";
-import { AsyncQueue } from "../util/AsyncQueue.js";
-import { startDurationMeasurement } from "../util/DurationMeasurement.js";
-import { runSafe } from "../util/runSafe.js";
-export async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, onDone, }) {
-    const run = await getRun(options?.run);
-    const settings = model.settings;
-    const eventSource = new FunctionEventSource({
-        observers: [
-            ...getFunctionCallLogger(options?.logging ?? getLogFormat()),
-            ...getFunctionObservers(),
-            ...(settings.observers ?? []),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = startDurationMeasurement();
-    const startMetadata = {
-        functionType,
-        callId: `call-${createId()}`,
-        parentCallId: options?.callId,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        model: model.modelInformation,
-        settings: model.settingsForEvent,
-        input,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await runSafe(async () => {
-        const deltaIterable = await startStream({
-            functionType,
-            functionId: options?.functionId,
-            callId: startMetadata.callId,
-            logging: options?.logging,
-            observers: options?.observers,
-            run,
-        });
-        // Return a queue that can be iterated over several times:
-        const responseQueue = new AsyncQueue();
-        // run async:
-        (async function () {
-            try {
-                const loopResult = await runSafe(async () => {
-                    for await (const event of deltaIterable) {
-                        if (event?.type === "error") {
-                            const error = event.error;
-                            const finishMetadata = {
-                                eventType: "finished",
-                                ...startMetadata,
-                                finishTimestamp: new Date(),
-                                durationInMs: durationMeasurement.durationInMs,
-                            };
-                            eventSource.notify(error instanceof AbortError
-                                ? {
-                                    ...finishMetadata,
-                                    result: { status: "abort" },
-                                }
-                                : {
-                                    ...finishMetadata,
-                                    result: { status: "error", error },
-                                });
-                            throw error;
-                        }
-                        if (event?.type === "delta") {
-                            const value = processDelta(event);
-                            if (value !== undefined) {
-                                responseQueue.push(value);
-                            }
-                        }
-                    }
-                    if (processFinished != null) {
-                        const value = processFinished();
-                        if (value !== undefined) {
-                            responseQueue.push(value);
-                        }
-                    }
-                });
-                // deal with abort or errors that happened during streaming:
-                if (!loopResult.ok) {
-                    const finishMetadata = {
-                        eventType: "finished",
-                        ...startMetadata,
-                        finishTimestamp: new Date(),
-                        durationInMs: durationMeasurement.durationInMs,
-                    };
-                    if (loopResult.isAborted) {
-                        eventSource.notify({
-                            ...finishMetadata,
-                            eventType: "finished",
-                            result: {
-                                status: "abort",
-                            },
-                        });
-                        responseQueue.error(new AbortError());
-                        return; // error is handled through queue
-                    }
-                    eventSource.notify({
-                        ...finishMetadata,
-                        eventType: "finished",
-                        result: {
-                            status: "error",
-                            error: loopResult.error,
-                        },
-                    });
-                    responseQueue.error(loopResult.error);
-                    return; // error is handled through queue
-                }
-                onDone?.();
-                const finishMetadata = {
-                    eventType: "finished",
-                    ...startMetadata,
-                    finishTimestamp: new Date(),
-                    durationInMs: durationMeasurement.durationInMs,
-                };
-                eventSource.notify({
-                    ...finishMetadata,
-                    result: {
-                        status: "success",
-                    },
-                });
-            }
-            finally {
-                // always close the queue when done, no matter where a potential error happened:
-                responseQueue.close();
-            }
-        })();
-        return {
-            stream: responseQueue,
-        };
-    });
-    if (!result.ok) {
-        const finishMetadata = {
-            eventType: "finished",
-            ...startMetadata,
-            finishTimestamp: new Date(),
-            durationInMs: durationMeasurement.durationInMs,
-        };
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                eventType: "finished",
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            eventType: "finished",
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    return {
-        value: result.value.stream,
-        metadata: startMetadata,
-    };
-}

package/model-function/generate-image/ImageGenerationEvent.cjs

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

package/model-function/generate-image/ImageGenerationEvent.d.ts

@@ -1,18 +0,0 @@
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export interface ImageGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "generate-image";
-}
-export type ImageGenerationFinishedEventResult = {
-    status: "success";
-    rawResponse: unknown;
-    value: string;
-} | {
-    status: "error";
-    error: unknown;
-} | {
-    status: "abort";
-};
-export interface ImageGenerationFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "generate-image";
-    result: ImageGenerationFinishedEventResult;
-}

package/model-function/generate-image/ImageGenerationEvent.js

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

package/model-function/generate-image/ImageGenerationModel.cjs

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

package/model-function/generate-image/ImageGenerationModel.d.ts

@@ -1,22 +0,0 @@
-import { FunctionCallOptions } from "../../core/FunctionOptions.js";
-import { Model, ModelSettings } from "../Model.js";
-import { PromptTemplate } from "../PromptTemplate.js";
-export interface ImageGenerationModelSettings extends ModelSettings {
-    /**
-     * Number of images to generate.
-     *
-     * Specifies the number of images the model should generate for a given prompt.
-     *
-     * Does nothing if the model does not support this setting.
-     *
-     * Example: `numberOfGenerations: 2` // The model will produce 2 images
-     */
-    numberOfGenerations?: number;
-}
-export interface ImageGenerationModel<PROMPT, SETTINGS extends ImageGenerationModelSettings = ImageGenerationModelSettings> extends Model<SETTINGS> {
-    doGenerateImages(prompt: PROMPT, options: FunctionCallOptions): PromiseLike<{
-        rawResponse: unknown;
-        base64Images: string[];
-    }>;
-    withPromptTemplate<INPUT_PROMPT>(promptTemplate: PromptTemplate<INPUT_PROMPT, PROMPT>): ImageGenerationModel<INPUT_PROMPT, SETTINGS>;
-}

package/model-function/generate-image/ImageGenerationModel.js

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

package/model-function/generate-image/PromptTemplateImageGenerationModel.cjs

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptTemplateImageGenerationModel = void 0;
-class PromptTemplateImageGenerationModel {
-    constructor({ model, promptTemplate, }) {
-        Object.defineProperty(this, "model", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "promptTemplate", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.model = model;
-        this.promptTemplate = promptTemplate;
-    }
-    get modelInformation() {
-        return this.model.modelInformation;
-    }
-    get settings() {
-        return this.model.settings;
-    }
-    doGenerateImages(prompt, options) {
-        const mappedPrompt = this.promptTemplate.format(prompt);
-        return this.model.doGenerateImages(mappedPrompt, options);
-    }
-    get settingsForEvent() {
-        return this.model.settingsForEvent;
-    }
-    withPromptTemplate(promptTemplate) {
-        return new PromptTemplateImageGenerationModel({ model: this, promptTemplate });
-    }
-    withSettings(additionalSettings) {
-        return new PromptTemplateImageGenerationModel({
-            model: this.model.withSettings(additionalSettings),
-            promptTemplate: this.promptTemplate,
-        });
-    }
-}
-exports.PromptTemplateImageGenerationModel = PromptTemplateImageGenerationModel;

package/model-function/generate-image/PromptTemplateImageGenerationModel.d.ts

@@ -1,20 +0,0 @@
-import { FunctionCallOptions } from "../../core/FunctionOptions.js";
-import { PromptTemplate } from "../PromptTemplate.js";
-import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGenerationModel.js";
-export declare class PromptTemplateImageGenerationModel<PROMPT, MODEL_PROMPT, SETTINGS extends ImageGenerationModelSettings, MODEL extends ImageGenerationModel<MODEL_PROMPT, SETTINGS>> implements ImageGenerationModel<PROMPT, SETTINGS> {
-    readonly model: MODEL;
-    readonly promptTemplate: PromptTemplate<PROMPT, MODEL_PROMPT>;
-    constructor({ model, promptTemplate, }: {
-        model: MODEL;
-        promptTemplate: PromptTemplate<PROMPT, MODEL_PROMPT>;
-    });
-    get modelInformation(): import("../ModelInformation.js").ModelInformation;
-    get settings(): SETTINGS;
-    doGenerateImages(prompt: PROMPT, options: FunctionCallOptions): PromiseLike<{
-        rawResponse: unknown;
-        base64Images: string[];
-    }>;
-    get settingsForEvent(): Partial<SETTINGS>;
-    withPromptTemplate<INPUT_PROMPT>(promptTemplate: PromptTemplate<INPUT_PROMPT, PROMPT>): PromptTemplateImageGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
-    withSettings(additionalSettings: Partial<SETTINGS>): this;
-}

package/model-function/generate-image/PromptTemplateImageGenerationModel.js

@@ -1,40 +0,0 @@
-export class PromptTemplateImageGenerationModel {
-    constructor({ model, promptTemplate, }) {
-        Object.defineProperty(this, "model", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "promptTemplate", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.model = model;
-        this.promptTemplate = promptTemplate;
-    }
-    get modelInformation() {
-        return this.model.modelInformation;
-    }
-    get settings() {
-        return this.model.settings;
-    }
-    doGenerateImages(prompt, options) {
-        const mappedPrompt = this.promptTemplate.format(prompt);
-        return this.model.doGenerateImages(mappedPrompt, options);
-    }
-    get settingsForEvent() {
-        return this.model.settingsForEvent;
-    }
-    withPromptTemplate(promptTemplate) {
-        return new PromptTemplateImageGenerationModel({ model: this, promptTemplate });
-    }
-    withSettings(additionalSettings) {
-        return new PromptTemplateImageGenerationModel({
-            model: this.model.withSettings(additionalSettings),
-            promptTemplate: this.promptTemplate,
-        });
-    }
-}

package/model-function/generate-image/generateImage.cjs

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImage = void 0;
-const UInt8Utils_js_1 = require("../../util/format/UInt8Utils.cjs");
-const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-async function generateImage({ model, prompt, fullResponse, ...options }) {
-    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "generate-image",
-        input: prompt,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doGenerateImages(prompt, options);
-            return {
-                rawResponse: result.rawResponse,
-                extractedValue: result.base64Images,
-            };
-        },
-    });
-    const imagesBase64 = callResponse.value;
-    const images = imagesBase64.map(UInt8Utils_js_1.base64ToUint8Array);
-    return fullResponse
-        ? {
-            image: images[0],
-            imageBase64: imagesBase64[0],
-            images,
-            imagesBase64,
-            rawResponse: callResponse.rawResponse,
-            metadata: callResponse.metadata,
-        }
-        : images[0];
-}
-exports.generateImage = generateImage;

package/model-function/generate-image/generateImage.d.ts

@@ -1,43 +0,0 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { ModelCallMetadata } from "../ModelCallMetadata.js";
-import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGenerationModel.js";
-/**
- * Generates an image using a prompt.
- *
- * The prompt depends on the model. For example, OpenAI image models expect a string prompt,
- * and Stability AI models expect an array of text prompts with optional weights.
- *
- * @see https://modelfusion.dev/guide/function/generate-image
- *
- * @example
- * const image = await generateImage({
- *   imageGenerator: stability.ImageGenerator(...),
- *   prompt: [
- *     { text: "the wicked witch of the west" },
- *     { text: "style of early 19th century painting", weight: 0.5 },
- *   ]
- * });
- *
- * @param {ImageGenerationModel<PROMPT, ImageGenerationModelSettings>} model - The image generation model to be used.
- * @param {PROMPT} prompt - The prompt to be used for image generation.
- *
- * @returns {Promise} - Returns a promise that resolves to the generated image.
- * The image is a Uint8Array containing the image data in PNG format.
- */
-export declare function generateImage<PROMPT>(args: {
-    model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>;
-    prompt: PROMPT;
-    fullResponse?: false;
-} & FunctionOptions): Promise<Uint8Array>;
-export declare function generateImage<PROMPT>(args: {
-    model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>;
-    prompt: PROMPT;
-    fullResponse: true;
-} & FunctionOptions): Promise<{
-    image: Uint8Array;
-    imageBase64: string;
-    images: Uint8Array[];
-    imagesBase64: string[];
-    rawResponse: unknown;
-    metadata: ModelCallMetadata;
-}>;

package/model-function/generate-image/generateImage.js

@@ -1,29 +0,0 @@
-import { base64ToUint8Array } from "../../util/format/UInt8Utils.js";
-import { executeStandardCall } from "../executeStandardCall.js";
-export async function generateImage({ model, prompt, fullResponse, ...options }) {
-    const callResponse = await executeStandardCall({
-        functionType: "generate-image",
-        input: prompt,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doGenerateImages(prompt, options);
-            return {
-                rawResponse: result.rawResponse,
-                extractedValue: result.base64Images,
-            };
-        },
-    });
-    const imagesBase64 = callResponse.value;
-    const images = imagesBase64.map(base64ToUint8Array);
-    return fullResponse
-        ? {
-            image: images[0],
-            imageBase64: imagesBase64[0],
-            images,
-            imagesBase64,
-            rawResponse: callResponse.rawResponse,
-            metadata: callResponse.metadata,
-        }
-        : images[0];
-}

package/model-function/generate-object/ObjectFromTextGenerationModel.cjs

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectFromTextGenerationModel = void 0;
-const generateText_js_1 = require("../generate-text/generateText.cjs");
-const ObjectParseError_js_1 = require("./ObjectParseError.cjs");
-class ObjectFromTextGenerationModel {
-    constructor({ model, template, }) {
-        Object.defineProperty(this, "model", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "template", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.model = model;
-        this.template = template;
-    }
-    get modelInformation() {
-        return this.model.modelInformation;
-    }
-    get settings() {
-        return this.model.settings;
-    }
-    get settingsForEvent() {
-        return this.model.settingsForEvent;
-    }
-    getModelWithJsonOutput(schema) {
-        if (this.template.withJsonOutput != null) {
-            return this.template.withJsonOutput({
-                model: this.model,
-                schema,
-            });
-        }
-        return this.model;
-    }
-    async doGenerateObject(schema, prompt, options) {
-        const { rawResponse, text } = await (0, generateText_js_1.generateText)({
-            model: this.getModelWithJsonOutput(schema),
-            prompt: this.template.createPrompt(prompt, schema),
-            fullResponse: true,
-            ...options,
-        });
-        try {
-            return {
-                rawResponse,
-                value: this.template.extractObject(text),
-                valueText: text,
-            };
-        }
-        catch (error) {
-            throw new ObjectParseError_js_1.ObjectParseError({
-                valueText: text,
-                cause: error,
-            });
-        }
-    }
-    withSettings(additionalSettings) {
-        return new ObjectFromTextGenerationModel({
-            model: this.model.withSettings(additionalSettings),
-            template: this.template,
-        });
-    }
-}
-exports.ObjectFromTextGenerationModel = ObjectFromTextGenerationModel;

package/model-function/generate-object/ObjectFromTextGenerationModel.d.ts

@@ -1,24 +0,0 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
-import { Schema } from "../../core/schema/Schema.js";
-import { TextGenerationModel, TextGenerationModelSettings } from "../generate-text/TextGenerationModel.js";
-import { ObjectFromTextPromptTemplate } from "./ObjectFromTextPromptTemplate.js";
-import { ObjectGenerationModel } from "./ObjectGenerationModel.js";
-export declare class ObjectFromTextGenerationModel<SOURCE_PROMPT, TARGET_PROMPT, MODEL extends TextGenerationModel<TARGET_PROMPT, TextGenerationModelSettings>> implements ObjectGenerationModel<SOURCE_PROMPT, MODEL["settings"]> {
-    protected readonly model: MODEL;
-    protected readonly template: ObjectFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
-    constructor({ model, template, }: {
-        model: MODEL;
-        template: ObjectFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
-    });
-    get modelInformation(): import("../ModelInformation.js").ModelInformation;
-    get settings(): TextGenerationModelSettings;
-    get settingsForEvent(): Partial<MODEL["settings"]>;
-    getModelWithJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): MODEL;
-    doGenerateObject(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<{
-        rawResponse: unknown;
-        value: unknown;
-        valueText: string;
-    }>;
-    withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
-}

package/model-function/generate-object/ObjectFromTextGenerationModel.js

@@ -1,65 +0,0 @@
-import { generateText } from "../generate-text/generateText.js";
-import { ObjectParseError } from "./ObjectParseError.js";
-export class ObjectFromTextGenerationModel {
-    constructor({ model, template, }) {
-        Object.defineProperty(this, "model", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "template", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.model = model;
-        this.template = template;
-    }
-    get modelInformation() {
-        return this.model.modelInformation;
-    }
-    get settings() {
-        return this.model.settings;
-    }
-    get settingsForEvent() {
-        return this.model.settingsForEvent;
-    }
-    getModelWithJsonOutput(schema) {
-        if (this.template.withJsonOutput != null) {
-            return this.template.withJsonOutput({
-                model: this.model,
-                schema,
-            });
-        }
-        return this.model;
-    }
-    async doGenerateObject(schema, prompt, options) {
-        const { rawResponse, text } = await generateText({
-            model: this.getModelWithJsonOutput(schema),
-            prompt: this.template.createPrompt(prompt, schema),
-            fullResponse: true,
-            ...options,
-        });
-        try {
-            return {
-                rawResponse,
-                value: this.template.extractObject(text),
-                valueText: text,
-            };
-        }
-        catch (error) {
-            throw new ObjectParseError({
-                valueText: text,
-                cause: error,
-            });
-        }
-    }
-    withSettings(additionalSettings) {
-        return new ObjectFromTextGenerationModel({
-            model: this.model.withSettings(additionalSettings),
-            template: this.template,
-        });
-    }
-}

package/model-function/generate-object/ObjectFromTextPromptTemplate.cjs

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

package/model-function/generate-object/ObjectFromTextPromptTemplate.d.ts

@@ -1,30 +0,0 @@
-import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
-import { Schema } from "../../core/schema/Schema.js";
-import { TextStreamingModel } from "../generate-text/TextGenerationModel.js";
-import { ChatPrompt } from "../generate-text/prompt-template/ChatPrompt.js";
-import { InstructionPrompt } from "../generate-text/prompt-template/InstructionPrompt.js";
-export type ObjectFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> = {
-    createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => TARGET_PROMPT;
-    extractObject: (response: string) => unknown;
-    withJsonOutput?({ model, schema, }: {
-        model: {
-            withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): typeof model;
-        };
-        schema: Schema<unknown> & JsonSchemaProducer;
-    }): typeof model;
-};
-export type FlexibleObjectFromTextPromptTemplate<SOURCE_PROMPT, INTERMEDIATE_PROMPT> = {
-    createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => INTERMEDIATE_PROMPT;
-    extractObject: (response: string) => unknown;
-    adaptModel: (model: TextStreamingModel<never> & {
-        withTextPrompt(): TextStreamingModel<string>;
-        withInstructionPrompt(): TextStreamingModel<InstructionPrompt>;
-        withChatPrompt(): TextStreamingModel<ChatPrompt>;
-    }) => TextStreamingModel<INTERMEDIATE_PROMPT>;
-    withJsonOutput?({ model, schema, }: {
-        model: {
-            withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): typeof model;
-        };
-        schema: Schema<unknown> & JsonSchemaProducer;
-    }): typeof model;
-};

package/model-function/generate-object/ObjectFromTextPromptTemplate.js

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