modelfusion 0.48.0 → 0.50.0

package/model-function/executeStreamCall.cjs

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeStreamCall = void 0;
+const nanoid_1 = require("nanoid");
+const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
+const GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
+const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
+const AbortError_js_1 = require("../core/api/AbortError.cjs");
+const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
+const getRun_js_1 = require("../core/getRun.cjs");
+const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
+const runSafe_js_1 = require("../util/runSafe.cjs");
+async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }) {
+    const run = await (0, getRun_js_1.getRun)(options?.run);
+    const settings = model.settings;
+    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
+        observers: [
+            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
+            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
+            ...(settings.observers ?? []),
+            ...(run?.functionObserver != null ? [run.functionObserver] : []),
+            ...(options?.observers ?? []),
+        ],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
+    const startMetadata = {
+        functionType,
+        callId: `call-${(0, nanoid_1.nanoid)()}`,
+        parentCallId: options?.parentCallId,
+        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 (0, runSafe_js_1.runSafe)(async () => {
+        const deltaIterable = await startStream({
+            functionId: options?.functionId,
+            logging: options?.logging,
+            observers: options?.observers,
+            run,
+            parentCallId: startMetadata.callId,
+        });
+        return (async function* () {
+            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_js_1.AbortError
+                        ? {
+                            ...finishMetadata,
+                            result: { status: "abort" },
+                        }
+                        : {
+                            ...finishMetadata,
+                            result: { status: "error", error },
+                        });
+                    throw error;
+                }
+                if (event?.type === "delta") {
+                    const value = processDelta(event);
+                    if (value !== undefined) {
+                        yield value;
+                    }
+                }
+            }
+            if (processFinished != null) {
+                const value = processFinished();
+                if (value !== undefined) {
+                    yield value;
+                }
+            }
+            const finishMetadata = {
+                eventType: "finished",
+                ...startMetadata,
+                finishTimestamp: new Date(),
+                durationInMs: durationMeasurement.durationInMs,
+            };
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "success",
+                    ...getResult(),
+                },
+            });
+        })();
+    });
+    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_js_1.AbortError();
+        }
+        eventSource.notify({
+            ...finishMetadata,
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
+        throw result.error;
+    }
+    return {
+        value: result.value,
+        metadata: startMetadata,
+    };
+}
+exports.executeStreamCall = executeStreamCall;

package/model-function/executeStreamCall.d.ts

@@ -0,0 +1,20 @@
+import { FunctionOptions } from "../core/FunctionOptions.js";
+import { Delta } from "./Delta.js";
+import { Model, ModelSettings } from "./Model.js";
+import { ModelCallStartedEvent } from "./ModelCallEvent.js";
+import { ModelCallMetadata } from "./ModelCallMetadata.js";
+export declare function executeStreamCall<DELTA_VALUE, VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }: {
+    model: MODEL;
+    options?: FunctionOptions;
+    input: unknown;
+    functionType: ModelCallStartedEvent["functionType"];
+    startStream: (options?: FunctionOptions) => PromiseLike<AsyncIterable<Delta<DELTA_VALUE>>>;
+    processDelta: (delta: Delta<DELTA_VALUE> & {
+        type: "delta";
+    }) => VALUE | undefined;
+    processFinished?: () => VALUE | undefined;
+    getResult: () => Record<string, unknown>;
+}): Promise<{
+    value: AsyncIterable<VALUE>;
+    metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
+}>;

package/model-function/executeStreamCall.js

@@ -0,0 +1,130 @@
+import { nanoid as createId } from "nanoid";
+import { FunctionEventSource } from "../core/FunctionEventSource.js";
+import { getGlobalFunctionLogging } from "../core/GlobalFunctionLogging.js";
+import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
+import { AbortError } from "../core/api/AbortError.js";
+import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
+import { getRun } from "../core/getRun.js";
+import { startDurationMeasurement } from "../util/DurationMeasurement.js";
+import { runSafe } from "../util/runSafe.js";
+export async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }) {
+    const run = await getRun(options?.run);
+    const settings = model.settings;
+    const eventSource = new FunctionEventSource({
+        observers: [
+            ...getFunctionCallLogger(options?.logging ?? getGlobalFunctionLogging()),
+            ...getGlobalFunctionObservers(),
+            ...(settings.observers ?? []),
+            ...(run?.functionObserver != null ? [run.functionObserver] : []),
+            ...(options?.observers ?? []),
+        ],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = startDurationMeasurement();
+    const startMetadata = {
+        functionType,
+        callId: `call-${createId()}`,
+        parentCallId: options?.parentCallId,
+        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({
+            functionId: options?.functionId,
+            logging: options?.logging,
+            observers: options?.observers,
+            run,
+            parentCallId: startMetadata.callId,
+        });
+        return (async function* () {
+            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) {
+                        yield value;
+                    }
+                }
+            }
+            if (processFinished != null) {
+                const value = processFinished();
+                if (value !== undefined) {
+                    yield value;
+                }
+            }
+            const finishMetadata = {
+                eventType: "finished",
+                ...startMetadata,
+                finishTimestamp: new Date(),
+                durationInMs: durationMeasurement.durationInMs,
+            };
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "success",
+                    ...getResult(),
+                },
+            });
+        })();
+    });
+    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,
+        metadata: startMetadata,
+    };
+}

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

@@ -1,6 +1,6 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface ImageGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "image-generation";
+    functionType: "generate-image";
 }
 export type ImageGenerationFinishedEventResult = {
     status: "success";
@@ -13,6 +13,6 @@ export type ImageGenerationFinishedEventResult = {
     status: "abort";
 };
 export interface ImageGenerationFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "image-generation";
+    functionType: "generate-image";
     result: ImageGenerationFinishedEventResult;
 }

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateImage = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const ImageGenerationPromise_js_1 = require("./ImageGenerationPromise.cjs");
 /**
  * Generates a base64-encoded image using a prompt.
@@ -19,8 +19,8 @@ const ImageGenerationPromise_js_1 = require("./ImageGenerationPromise.cjs");
  * );
  */
 function generateImage(model, prompt, options) {
-    return new ImageGenerationPromise_js_1.ImageGenerationPromise((0, executeCall_js_1.executeCall)({
-        functionType: "image-generation",
+    return new ImageGenerationPromise_js_1.ImageGenerationPromise((0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "generate-image",
         input: prompt,
         model,
         options,

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

@@ -1,4 +1,4 @@
-import { executeCall } from "../executeCall.js";
+import { executeStandardCall } from "../executeStandardCall.js";
 import { ImageGenerationPromise } from "./ImageGenerationPromise.js";
 /**
  * Generates a base64-encoded image using a prompt.
@@ -16,8 +16,8 @@ import { ImageGenerationPromise } from "./ImageGenerationPromise.js";
  * );
  */
 export function generateImage(model, prompt, options) {
-    return new ImageGenerationPromise(executeCall({
-        functionType: "image-generation",
+    return new ImageGenerationPromise(executeStandardCall({
+        functionType: "generate-image",
         input: prompt,
         model,
         options,

package/model-function/generate-speech/SpeechGenerationEvent.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export interface SpeechGenerationStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "generate-speech";
+    input: string;
+}
+export type SpeechGenerationFinishedEventResult = {
+    status: "success";
+    response: unknown;
+    value: Buffer;
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "abort";
+};
+export interface SpeechGenerationFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "generate-speech";
+    input: string;
+    result: SpeechGenerationFinishedEventResult;
+}
+export interface SpeechStreamingStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "stream-speech";
+}
+export interface SpeechStreamingFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "stream-speech";
+}

package/model-function/generate-speech/SpeechGenerationModel.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Delta } from "../Delta.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface SpeechGenerationModelSettings extends ModelSettings {
+}
+export interface SpeechGenerationModel<SETTINGS extends SpeechGenerationModelSettings = SpeechGenerationModelSettings> extends Model<SETTINGS> {
+    /**
+     * Generates an mp3 audio buffer that contains the speech for the given text.
+     */
+    doGenerateSpeechStandard(text: string, options?: FunctionOptions): PromiseLike<Buffer>;
+}
+export interface StreamingSpeechGenerationModel<SETTINGS extends SpeechGenerationModelSettings = SpeechGenerationModelSettings> extends SpeechGenerationModel<SETTINGS> {
+    doGenerateSpeechStreamDuplex(textStream: AsyncIterable<string>, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<Buffer>>>;
+}

package/model-function/generate-speech/generateSpeech.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSpeech = void 0;
+const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
+/**
+ * Synthesizes speech from text.
+ */
+function generateSpeech(model, text, options) {
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "generate-speech",
+        input: text,
+        model,
+        options,
+        generateResponse: async (options) => {
+            const response = await model.doGenerateSpeechStandard(text, options);
+            return {
+                response,
+                extractedValue: response,
+            };
+        },
+    }));
+}
+exports.generateSpeech = generateSpeech;

package/model-function/generate-speech/generateSpeech.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
+import { SpeechGenerationModel, SpeechGenerationModelSettings } from "./SpeechGenerationModel.js";
+/**
+ * Synthesizes speech from text.
+ */
+export declare function generateSpeech(model: SpeechGenerationModel<SpeechGenerationModelSettings>, text: string, options?: FunctionOptions): ModelFunctionPromise<Buffer>;

package/model-function/generate-speech/generateSpeech.js

@@ -0,0 +1,20 @@
+import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
+import { executeStandardCall } from "../executeStandardCall.js";
+/**
+ * Synthesizes speech from text.
+ */
+export function generateSpeech(model, text, options) {
+    return new ModelFunctionPromise(executeStandardCall({
+        functionType: "generate-speech",
+        input: text,
+        model,
+        options,
+        generateResponse: async (options) => {
+            const response = await model.doGenerateSpeechStandard(text, options);
+            return {
+                response,
+                extractedValue: response,
+            };
+        },
+    }));
+}

package/model-function/generate-speech/index.cjs

@@ -0,0 +1,20 @@
+"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("./SpeechGenerationEvent.cjs"), exports);
+__exportStar(require("./SpeechGenerationModel.cjs"), exports);
+__exportStar(require("./generateSpeech.cjs"), exports);
+__exportStar(require("./streamSpeech.cjs"), exports);

package/model-function/generate-speech/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./SpeechGenerationEvent.js";
+export * from "./SpeechGenerationModel.js";
+export * from "./generateSpeech.js";
+export * from "./streamSpeech.js";

package/model-function/generate-speech/index.js

@@ -0,0 +1,4 @@
+export * from "./SpeechGenerationEvent.js";
+export * from "./SpeechGenerationModel.js";
+export * from "./generateSpeech.js";
+export * from "./streamSpeech.js";

package/model-function/generate-speech/streamSpeech.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamSpeech = void 0;
+const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const AsyncIterableResultPromise_js_1 = require("../AsyncIterableResultPromise.cjs");
+const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
+/**
+ * Synthesizes speech from text.
+ */
+function streamSpeech(model, text, options) {
+    let textStream;
+    // simulate a stream with a single value for a string input:
+    if (typeof text === "string") {
+        const queue = new AsyncQueue_js_1.AsyncQueue();
+        queue.push(text);
+        queue.close();
+        textStream = queue;
+    }
+    else {
+        textStream = text;
+    }
+    return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise((0, executeStreamCall_js_1.executeStreamCall)({
+        functionType: "stream-speech",
+        input: text,
+        model,
+        options,
+        startStream: async (options) => model.doGenerateSpeechStreamDuplex(textStream, options),
+        processDelta: (delta) => {
+            return delta.valueDelta;
+        },
+        getResult: () => ({}),
+    }));
+}
+exports.streamSpeech = streamSpeech;

package/model-function/generate-speech/streamSpeech.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
+import { StreamingSpeechGenerationModel, SpeechGenerationModelSettings } from "./SpeechGenerationModel.js";
+/**
+ * Synthesizes speech from text.
+ */
+export declare function streamSpeech(model: StreamingSpeechGenerationModel<SpeechGenerationModelSettings>, text: AsyncIterable<string> | string, options?: FunctionOptions): AsyncIterableResultPromise<Buffer>;

package/model-function/generate-speech/streamSpeech.js

@@ -0,0 +1,30 @@
+import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
+import { executeStreamCall } from "../executeStreamCall.js";
+/**
+ * Synthesizes speech from text.
+ */
+export function streamSpeech(model, text, options) {
+    let textStream;
+    // simulate a stream with a single value for a string input:
+    if (typeof text === "string") {
+        const queue = new AsyncQueue();
+        queue.push(text);
+        queue.close();
+        textStream = queue;
+    }
+    else {
+        textStream = text;
+    }
+    return new AsyncIterableResultPromise(executeStreamCall({
+        functionType: "stream-speech",
+        input: text,
+        model,
+        options,
+        startStream: async (options) => model.doGenerateSpeechStreamDuplex(textStream, options),
+        processDelta: (delta) => {
+            return delta.valueDelta;
+        },
+        getResult: () => ({}),
+    }));
+}

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

@@ -1,6 +1,6 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface StructureGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "structure-generation" | "structure-or-text-generation";
+    functionType: "generate-structure" | "generate-structure-or-text";
 }
 export type StructureGenerationFinishedEventResult = {
     status: "success";
@@ -18,6 +18,6 @@ export type StructureGenerationFinishedEventResult = {
     status: "abort";
 };
 export type StructureGenerationFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "structure-generation" | "structure-or-text-generation";
+    functionType: "generate-structure" | "generate-structure-or-text";
     result: StructureGenerationFinishedEventResult;
 };

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

@@ -1,7 +1,7 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface StructureStreamingStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "structure-streaming";
+    functionType: "stream-structure";
 }
 export interface StructureStreamingFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "structure-streaming";
+    functionType: "stream-structure";
 }

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStructure = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
 function generateStructure(model, structureDefinition, prompt, options) {
@@ -9,8 +9,8 @@ function generateStructure(model, structureDefinition, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinition)
         : prompt;
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
-        functionType: "structure-generation",
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "generate-structure",
         input: expandedPrompt,
         model,
         options,

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

@@ -1,4 +1,4 @@
-import { executeCall } from "../executeCall.js";
+import { executeStandardCall } from "../executeStandardCall.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 import { StructureValidationError } from "./StructureValidationError.js";
 export function generateStructure(model, structureDefinition, prompt, options) {
@@ -6,8 +6,8 @@ export function generateStructure(model, structureDefinition, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinition)
         : prompt;
-    return new ModelFunctionPromise(executeCall({
-        functionType: "structure-generation",
+    return new ModelFunctionPromise(executeStandardCall({
+        functionType: "generate-structure",
         input: expandedPrompt,
         model,
         options,

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStructureOrText = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 const NoSuchStructureError_js_1 = require("./NoSuchStructureError.cjs");
 const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
@@ -10,8 +10,8 @@ function generateStructureOrText(model, structureDefinitions, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinitions)
         : prompt;
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
-        functionType: "structure-or-text-generation",
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "generate-structure-or-text",
         input: expandedPrompt,
         model,
         options,

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

@@ -1,4 +1,4 @@
-import { executeCall } from "../executeCall.js";
+import { executeStandardCall } from "../executeStandardCall.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 import { NoSuchStructureError } from "./NoSuchStructureError.js";
 import { StructureValidationError } from "./StructureValidationError.js";
@@ -7,8 +7,8 @@ export function generateStructureOrText(model, structureDefinitions, prompt, opt
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinitions)
         : prompt;
-    return new ModelFunctionPromise(executeCall({
-        functionType: "structure-or-text-generation",
+    return new ModelFunctionPromise(executeStandardCall({
+        functionType: "generate-structure-or-text",
         input: expandedPrompt,
         model,
         options,