modelfusion 0.113.0 → 0.114.1

package/core/cache/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Cache.cjs"), exports);
+__exportStar(require("./MemoryCache.cjs"), exports);

package/core/cache/index.d.ts

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

package/core/cache/index.js

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

package/core/index.cjs

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

package/core/index.d.ts

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

package/core/index.js

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

package/core/schema/TypeValidationError.cjs

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

package/core/schema/TypeValidationError.d.ts

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

package/core/schema/TypeValidationError.js

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

package/core/schema/index.cjs

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

package/core/schema/index.d.ts

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

package/core/schema/index.js

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

package/core/schema/parseJSON.cjs

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

package/core/schema/parseJSON.d.ts

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

package/core/schema/parseJSON.js

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

package/core/schema/validateTypes.cjs

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

package/core/schema/validateTypes.d.ts

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

package/core/schema/validateTypes.js

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

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

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

package/model-function/executeStandardCall.cjs

@@ -43,11 +43,13 @@ async function executeStandardCall({ model, options, input, functionType, genera
         ...startMetadata,
     });
     const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
+        functionType: startMetadata.functionType,
         functionId: options?.functionId,
+        callId: startMetadata.callId,
         logging: options?.logging,
         observers: options?.observers,
+        cache: options?.cache,
         run,
-        parentCallId: startMetadata.callId,
     }));
     const finishMetadata = {
         eventType: "finished",

package/model-function/executeStandardCall.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
+import { FunctionCallOptions, FunctionOptions } from "../core/FunctionOptions.js";
 import { Model, ModelSettings } from "./Model.js";
 import { ModelCallStartedEvent } from "./ModelCallEvent.js";
 import { ModelCallMetadata } from "./ModelCallMetadata.js";
@@ -7,7 +7,7 @@ export declare function executeStandardCall<VALUE, MODEL extends Model<ModelSett
     options?: FunctionOptions;
     input: unknown;
     functionType: ModelCallStartedEvent["functionType"];
-    generateResponse: (options?: FunctionOptions) => PromiseLike<{
+    generateResponse: (options: FunctionCallOptions) => PromiseLike<{
         response: unknown;
         extractedValue: VALUE;
         usage?: unknown;

package/model-function/executeStandardCall.js

@@ -40,11 +40,13 @@ export async function executeStandardCall({ model, options, input, functionType,
         ...startMetadata,
     });
     const result = await runSafe(() => generateResponse({
+        functionType: startMetadata.functionType,
         functionId: options?.functionId,
+        callId: startMetadata.callId,
         logging: options?.logging,
         observers: options?.observers,
+        cache: options?.cache,
         run,
-        parentCallId: startMetadata.callId,
     }));
     const finishMetadata = {
         eventType: "finished",

package/model-function/executeStreamCall.cjs

@@ -45,11 +45,12 @@ async function executeStreamCall({ model, options, input, functionType, startStr
     });
     const result = await (0, runSafe_js_1.runSafe)(async () => {
         const deltaIterable = await startStream({
+            functionType: startMetadata.functionType,
             functionId: options?.functionId,
+            callId: startMetadata.callId,
             logging: options?.logging,
             observers: options?.observers,
             run,
-            parentCallId: startMetadata.callId,
         });
         // Return a queue that can be iterated over several times:
         const responseQueue = new AsyncQueue_js_1.AsyncQueue();

package/model-function/executeStreamCall.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
+import { FunctionCallOptions, FunctionOptions } from "../core/FunctionOptions.js";
 import { Delta } from "./Delta.js";
 import { Model, ModelSettings } from "./Model.js";
 import { ModelCallStartedEvent } from "./ModelCallEvent.js";
@@ -8,7 +8,7 @@ export declare function executeStreamCall<DELTA_VALUE, VALUE, MODEL extends Mode
     options?: FunctionOptions;
     input: unknown;
     functionType: ModelCallStartedEvent["functionType"];
-    startStream: (options?: FunctionOptions) => PromiseLike<AsyncIterable<Delta<DELTA_VALUE>>>;
+    startStream: (options: FunctionCallOptions) => PromiseLike<AsyncIterable<Delta<DELTA_VALUE>>>;
     processDelta: (delta: Delta<DELTA_VALUE> & {
         type: "delta";
     }) => VALUE | undefined;

package/model-function/executeStreamCall.js

@@ -42,11 +42,12 @@ export async function executeStreamCall({ model, options, input, functionType, s
     });
     const result = await runSafe(async () => {
         const deltaIterable = await startStream({
+            functionType: startMetadata.functionType,
             functionId: options?.functionId,
+            callId: startMetadata.callId,
             logging: options?.logging,
             observers: options?.observers,
             run,
-            parentCallId: startMetadata.callId,
         });
         // Return a queue that can be iterated over several times:
         const responseQueue = new AsyncQueue();

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 import { PromptTemplate } from "../PromptTemplate.js";
 export interface ImageGenerationModelSettings extends ModelSettings {
@@ -14,7 +14,7 @@ export interface ImageGenerationModelSettings extends ModelSettings {
     numberOfGenerations?: number;
 }
 export interface ImageGenerationModel<PROMPT, SETTINGS extends ImageGenerationModelSettings = ImageGenerationModelSettings> extends Model<SETTINGS> {
-    doGenerateImages(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateImages(prompt: PROMPT, options: FunctionCallOptions): PromiseLike<{
         response: unknown;
         base64Images: string[];
     }>;

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+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> {
@@ -10,7 +10,7 @@ export declare class PromptTemplateImageGenerationModel<PROMPT, MODEL_PROMPT, SE
     });
     get modelInformation(): import("../ModelInformation.js").ModelInformation;
     get settings(): SETTINGS;
-    doGenerateImages(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateImages(prompt: PROMPT, options: FunctionCallOptions): PromiseLike<{
         response: unknown;
         base64Images: string[];
     }>;

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

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

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

@@ -10,7 +10,10 @@ async function generateStructure(model, schema, prompt, options) {
         : prompt;
     const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-structure",
-        input: expandedPrompt,
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
         model,
         options,
         generateResponse: async (options) => {

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

@@ -7,7 +7,10 @@ export async function generateStructure(model, schema, prompt, options) {
         : prompt;
     const fullResponse = await executeStandardCall({
         functionType: "generate-structure",
-        input: expandedPrompt,
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
         model,
         options,
         generateResponse: async (options) => {

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

@@ -12,7 +12,10 @@ async function streamStructure(model, schema, prompt, options) {
     let lastStructure;
     const fullResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
         functionType: "stream-structure",
-        input: prompt,
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
         model,
         options,
         startStream: async (options) => model.doStreamStructure(schema, expandedPrompt, options),

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

@@ -9,7 +9,10 @@ export async function streamStructure(model, schema, prompt, options) {
     let lastStructure;
     const fullResponse = await executeStreamCall({
         functionType: "stream-structure",
-        input: prompt,
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
         model,
         options,
         startStream: async (options) => model.doStreamStructure(schema, expandedPrompt, options),