modelfusion 0.0.44

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImage = void 0;
+const executeCall_js_1 = require("../executeCall.cjs");
+/**
+ * Generates a base64-encoded image using a prompt.
+ * The prompt format 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.
+ *
+ * @example
+ * const { image } = await generateImage(
+ *   new StabilityImageGenerationModel(...),
+ *   [
+ *     { text: "the wicked witch of the west" },
+ *     { text: "style of early 19th century painting", weight: 0.5 },
+ *   ]
+ * );
+ */
+async function generateImage(model, prompt, options) {
+    const result = await (0, executeCall_js_1.executeCall)({
+        model,
+        options,
+        generateResponse: (options) => model.generateImageResponse(prompt, options),
+        extractOutputValue: model.extractBase64Image,
+        getStartEvent: (metadata, settings) => ({
+            type: "image-generation-started",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "image-generation-finished",
+            status: "abort",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "image-generation-finished",
+            status: "failure",
+            metadata,
+            settings,
+            prompt,
+            error,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "image-generation-finished",
+            status: "success",
+            metadata,
+            settings,
+            prompt,
+            response,
+            generatedImage: output,
+        }),
+    });
+    return {
+        image: result.output,
+        response: result.response,
+        metadata: result.metadata,
+    };
+}
+exports.generateImage = generateImage;

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

@@ -0,0 +1,23 @@
+import { FunctionOptions } from "../FunctionOptions.js";
+import { CallMetadata } from "../executeCall.js";
+import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGenerationModel.js";
+/**
+ * Generates a base64-encoded image using a prompt.
+ * The prompt format 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.
+ *
+ * @example
+ * const { image } = await generateImage(
+ *   new StabilityImageGenerationModel(...),
+ *   [
+ *     { text: "the wicked witch of the west" },
+ *     { text: "style of early 19th century painting", weight: 0.5 },
+ *   ]
+ * );
+ */
+export declare function generateImage<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings>(model: ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, prompt: PROMPT, options?: FunctionOptions<SETTINGS>): Promise<{
+    image: string;
+    response: RESPONSE;
+    metadata: CallMetadata<ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>>;
+}>;

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

@@ -0,0 +1,59 @@
+import { executeCall } from "../executeCall.js";
+/**
+ * Generates a base64-encoded image using a prompt.
+ * The prompt format 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.
+ *
+ * @example
+ * const { image } = await generateImage(
+ *   new StabilityImageGenerationModel(...),
+ *   [
+ *     { text: "the wicked witch of the west" },
+ *     { text: "style of early 19th century painting", weight: 0.5 },
+ *   ]
+ * );
+ */
+export async function generateImage(model, prompt, options) {
+    const result = await executeCall({
+        model,
+        options,
+        generateResponse: (options) => model.generateImageResponse(prompt, options),
+        extractOutputValue: model.extractBase64Image,
+        getStartEvent: (metadata, settings) => ({
+            type: "image-generation-started",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "image-generation-finished",
+            status: "abort",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "image-generation-finished",
+            status: "failure",
+            metadata,
+            settings,
+            prompt,
+            error,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "image-generation-finished",
+            status: "success",
+            metadata,
+            settings,
+            prompt,
+            response,
+            generatedImage: output,
+        }),
+    });
+    return {
+        image: result.output,
+        response: result.response,
+        metadata: result.metadata,
+    };
+}

package/model-function/generate-json/GenerateJsonModel.cjs

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

package/model-function/generate-json/GenerateJsonModel.d.ts

@@ -0,0 +1,10 @@
+import { FunctionOptions } from "../FunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface GenerateJsonModelSettings extends ModelSettings {
+}
+export interface GenerateJsonPrompt<RESPONSE> {
+    extractJson(response: RESPONSE): unknown;
+}
+export interface GenerateJsonModel<PROMPT, RESPONSE, SETTINGS extends GenerateJsonModelSettings> extends Model<SETTINGS> {
+    generateJsonResponse(prompt: PROMPT & GenerateJsonPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+}

package/model-function/generate-json/GenerateJsonModel.js

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

package/model-function/generate-json/GenerateJsonOrTextModel.cjs

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

package/model-function/generate-json/GenerateJsonOrTextModel.d.ts

@@ -0,0 +1,18 @@
+import { FunctionOptions } from "../FunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface GenerateJsonOrTextModelSettings extends ModelSettings {
+}
+export interface GenerateJsonOrTextPrompt<RESPONSE> {
+    extractJsonAndText(response: RESPONSE): {
+        schema: null;
+        value: null;
+        text: string;
+    } | {
+        schema: string;
+        value: unknown;
+        text: string | null;
+    };
+}
+export interface GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings> extends Model<SETTINGS> {
+    generateJsonResponse(prompt: PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+}

package/model-function/generate-json/GenerateJsonOrTextModel.js

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

package/model-function/generate-json/JsonGenerationEvent.cjs

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

package/model-function/generate-json/JsonGenerationEvent.d.ts

@@ -0,0 +1,22 @@
+import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
+export type JsonGenerationStartedEvent = {
+    type: "json-generation-started";
+    metadata: ModelCallStartedEventMetadata;
+    settings: unknown;
+    prompt: unknown;
+};
+export type JsonGenerationFinishedEvent = {
+    type: "json-generation-finished";
+    metadata: ModelCallFinishedEventMetadata;
+    settings: unknown;
+    prompt: unknown;
+} & ({
+    status: "success";
+    response: unknown;
+    generatedJson: unknown;
+} | {
+    status: "failure";
+    error: unknown;
+} | {
+    status: "abort";
+});

package/model-function/generate-json/JsonGenerationEvent.js

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

package/model-function/generate-json/NoSuchSchemaError.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoSuchSchemaError = void 0;
+class NoSuchSchemaError extends Error {
+    constructor(schemaName) {
+        super(`No such schema: ${schemaName}`);
+        Object.defineProperty(this, "schemaName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "NoSuchSchemaError";
+        this.schemaName = schemaName;
+    }
+}
+exports.NoSuchSchemaError = NoSuchSchemaError;

package/model-function/generate-json/NoSuchSchemaError.d.ts

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

package/model-function/generate-json/NoSuchSchemaError.js

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

package/model-function/generate-json/SchemaDefinition.cjs

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

package/model-function/generate-json/SchemaDefinition.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export type SchemaDefinition<NAME extends string, STRUCTURE> = {
+    name: NAME;
+    description?: string;
+    schema: z.Schema<STRUCTURE>;
+};

package/model-function/generate-json/SchemaDefinition.js

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

package/model-function/generate-json/SchemaValidationError.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidationError = void 0;
+class SchemaValidationError extends Error {
+    constructor({ schemaName, value, errors, }) {
+        super(`Schema validation error for '${schemaName}'. ` +
+            `Value: ${JSON.stringify(value)}.\n` +
+            `Error details: ${errors.message}\n` +
+            `Error field(s): ${errors.errors
+                .map((err) => err.path.join("."))
+                .join(", ")}`);
+        Object.defineProperty(this, "schemaName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "errors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "SchemaValidationError";
+        this.schemaName = schemaName;
+        this.errors = errors;
+        this.value = value;
+    }
+}
+exports.SchemaValidationError = SchemaValidationError;

package/model-function/generate-json/SchemaValidationError.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare class SchemaValidationError extends Error {
+    readonly schemaName: string;
+    readonly errors: z.ZodError;
+    readonly value: unknown;
+    constructor({ schemaName, value, errors, }: {
+        schemaName: string;
+        value: unknown;
+        errors: z.ZodError;
+    });
+}

package/model-function/generate-json/SchemaValidationError.js

@@ -0,0 +1,32 @@
+export class SchemaValidationError extends Error {
+    constructor({ schemaName, value, errors, }) {
+        super(`Schema validation error for '${schemaName}'. ` +
+            `Value: ${JSON.stringify(value)}.\n` +
+            `Error details: ${errors.message}\n` +
+            `Error field(s): ${errors.errors
+                .map((err) => err.path.join("."))
+                .join(", ")}`);
+        Object.defineProperty(this, "schemaName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "errors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "SchemaValidationError";
+        this.schemaName = schemaName;
+        this.errors = errors;
+        this.value = value;
+    }
+}

package/model-function/generate-json/generateJson.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJson = void 0;
+const executeCall_js_1 = require("../executeCall.cjs");
+const SchemaValidationError_js_1 = require("./SchemaValidationError.cjs");
+async function generateJson(model, schemaDefinition, prompt, options) {
+    const expandedPrompt = prompt(schemaDefinition);
+    const result = await (0, executeCall_js_1.executeCall)({
+        model,
+        options,
+        generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
+        extractOutputValue: (response) => {
+            const json = expandedPrompt.extractJson(response);
+            const parseResult = schemaDefinition.schema.safeParse(json);
+            if (!parseResult.success) {
+                throw new SchemaValidationError_js_1.SchemaValidationError({
+                    schemaName: schemaDefinition.name,
+                    value: json,
+                    errors: parseResult.error,
+                });
+            }
+            return parseResult.data;
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "json-generation-started",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "json-generation-finished",
+            status: "abort",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "json-generation-finished",
+            status: "failure",
+            metadata,
+            settings,
+            prompt,
+            error,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "json-generation-finished",
+            status: "success",
+            metadata,
+            settings,
+            prompt,
+            response,
+            generatedJson: output,
+        }),
+    });
+    return {
+        value: result.output,
+        response: result.response,
+        metadata: result.metadata,
+    };
+}
+exports.generateJson = generateJson;

package/model-function/generate-json/generateJson.d.ts

@@ -0,0 +1,9 @@
+import { FunctionOptions } from "../FunctionOptions.js";
+import { CallMetadata } from "../executeCall.js";
+import { GenerateJsonModel, GenerateJsonModelSettings, GenerateJsonPrompt } from "./GenerateJsonModel.js";
+import { SchemaDefinition } from "./SchemaDefinition.js";
+export declare function generateJson<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends GenerateJsonModelSettings>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinition: SchemaDefinition<NAME, STRUCTURE>, prompt: (schemaDefinition: SchemaDefinition<NAME, STRUCTURE>) => PROMPT & GenerateJsonPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): Promise<{
+    value: STRUCTURE;
+    response: RESPONSE;
+    metadata: CallMetadata<GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>>;
+}>;

package/model-function/generate-json/generateJson.js

@@ -0,0 +1,57 @@
+import { executeCall } from "../executeCall.js";
+import { SchemaValidationError } from "./SchemaValidationError.js";
+export async function generateJson(model, schemaDefinition, prompt, options) {
+    const expandedPrompt = prompt(schemaDefinition);
+    const result = await executeCall({
+        model,
+        options,
+        generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
+        extractOutputValue: (response) => {
+            const json = expandedPrompt.extractJson(response);
+            const parseResult = schemaDefinition.schema.safeParse(json);
+            if (!parseResult.success) {
+                throw new SchemaValidationError({
+                    schemaName: schemaDefinition.name,
+                    value: json,
+                    errors: parseResult.error,
+                });
+            }
+            return parseResult.data;
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "json-generation-started",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "json-generation-finished",
+            status: "abort",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "json-generation-finished",
+            status: "failure",
+            metadata,
+            settings,
+            prompt,
+            error,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "json-generation-finished",
+            status: "success",
+            metadata,
+            settings,
+            prompt,
+            response,
+            generatedJson: output,
+        }),
+    });
+    return {
+        value: result.output,
+        response: result.response,
+        metadata: result.metadata,
+    };
+}

package/model-function/generate-json/generateJsonOrText.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJsonOrText = void 0;
+const executeCall_js_1 = require("../executeCall.cjs");
+const NoSuchSchemaError_js_1 = require("./NoSuchSchemaError.cjs");
+const SchemaValidationError_js_1 = require("./SchemaValidationError.cjs");
+async function generateJsonOrText(model, schemaDefinitions, prompt, options) {
+    const expandedPrompt = prompt(schemaDefinitions);
+    const result = await (0, executeCall_js_1.executeCall)({
+        model,
+        options,
+        generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
+        extractOutputValue: (response) => {
+            const { schema, value, text } = expandedPrompt.extractJsonAndText(response);
+            // text generation:
+            if (schema == null) {
+                return { schema, value, text };
+            }
+            const definition = schemaDefinitions.find((d) => d.name === schema);
+            if (definition == undefined) {
+                throw new NoSuchSchemaError_js_1.NoSuchSchemaError(schema);
+            }
+            const parseResult = definition.schema.safeParse(value);
+            if (!parseResult.success) {
+                throw new SchemaValidationError_js_1.SchemaValidationError({
+                    schemaName: schema,
+                    value,
+                    errors: parseResult.error,
+                });
+            }
+            return {
+                schema: schema,
+                value: parseResult.data,
+                text: text, // text is string | null, which is part of the response for schema values
+            };
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "json-generation-started",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "json-generation-finished",
+            status: "abort",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "json-generation-finished",
+            status: "failure",
+            metadata,
+            settings,
+            prompt,
+            error,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "json-generation-finished",
+            status: "success",
+            metadata,
+            settings,
+            prompt,
+            response,
+            generatedJson: output,
+        }),
+    });
+    return {
+        ...result.output,
+        response: result.response,
+        metadata: result.metadata,
+    };
+}
+exports.generateJsonOrText = generateJsonOrText;

package/model-function/generate-json/generateJsonOrText.d.ts

@@ -0,0 +1,25 @@
+import { FunctionOptions } from "../FunctionOptions.js";
+import { CallMetadata } from "../executeCall.js";
+import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "./GenerateJsonOrTextModel.js";
+import { SchemaDefinition } from "./SchemaDefinition.js";
+type SchemaDefinitionArray<T extends SchemaDefinition<any, any>[]> = T;
+type ToSchemaDefinitionsMap<T extends SchemaDefinitionArray<SchemaDefinition<any, any>[]>> = {
+    [K in T[number]["name"]]: Extract<T[number], SchemaDefinition<K, any>>;
+};
+type ToSchemaUnion<T> = {
+    [KEY in keyof T]: T[KEY] extends SchemaDefinition<any, infer SCHEMA> ? {
+        schema: KEY;
+        value: SCHEMA;
+        text: string | null;
+    } : never;
+}[keyof T];
+type ToOutputValue<SCHEMAS extends SchemaDefinitionArray<SchemaDefinition<any, any>[]>> = ToSchemaUnion<ToSchemaDefinitionsMap<SCHEMAS>>;
+export declare function generateJsonOrText<SCHEMAS extends SchemaDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinitions: SCHEMAS, prompt: (schemaDefinitions: SCHEMAS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): Promise<({
+    schema: null;
+    value: null;
+    text: string;
+} | ToOutputValue<SCHEMAS>) & {
+    response: RESPONSE;
+    metadata: CallMetadata<GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>>;
+}>;
+export {};

package/model-function/generate-json/generateJsonOrText.js

@@ -0,0 +1,70 @@
+import { executeCall } from "../executeCall.js";
+import { NoSuchSchemaError } from "./NoSuchSchemaError.js";
+import { SchemaValidationError } from "./SchemaValidationError.js";
+export async function generateJsonOrText(model, schemaDefinitions, prompt, options) {
+    const expandedPrompt = prompt(schemaDefinitions);
+    const result = await executeCall({
+        model,
+        options,
+        generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
+        extractOutputValue: (response) => {
+            const { schema, value, text } = expandedPrompt.extractJsonAndText(response);
+            // text generation:
+            if (schema == null) {
+                return { schema, value, text };
+            }
+            const definition = schemaDefinitions.find((d) => d.name === schema);
+            if (definition == undefined) {
+                throw new NoSuchSchemaError(schema);
+            }
+            const parseResult = definition.schema.safeParse(value);
+            if (!parseResult.success) {
+                throw new SchemaValidationError({
+                    schemaName: schema,
+                    value,
+                    errors: parseResult.error,
+                });
+            }
+            return {
+                schema: schema,
+                value: parseResult.data,
+                text: text, // text is string | null, which is part of the response for schema values
+            };
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "json-generation-started",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "json-generation-finished",
+            status: "abort",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "json-generation-finished",
+            status: "failure",
+            metadata,
+            settings,
+            prompt,
+            error,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "json-generation-finished",
+            status: "success",
+            metadata,
+            settings,
+            prompt,
+            response,
+            generatedJson: output,
+        }),
+    });
+    return {
+        ...result.output,
+        response: result.response,
+        metadata: result.metadata,
+    };
+}