modelfusion 0.121.1 → 0.122.0

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateImage = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-async function generateImage(model, prompt, options) {
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+async function generateImage({ model, prompt, fullResponse, ...options }) {
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-image",
         input: prompt,
         model,
@@ -16,16 +16,16 @@ async function generateImage(model, prompt, options) {
             };
         },
     });
-    const imagesBase64 = fullResponse.value;
+    const imagesBase64 = callResponse.value;
     const images = imagesBase64.map((imageBase64) => Buffer.from(imageBase64, "base64"));
-    return options?.fullResponse
+    return fullResponse
         ? {
             image: images[0],
             imageBase64: imagesBase64[0],
             images,
             imagesBase64,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
         : images[0];
 }

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

@@ -11,27 +11,30 @@ import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGener
  * @see https://modelfusion.dev/guide/function/generate-image
  *
  * @example
- * const image = await generateImage(
- *   stability.ImageGenerator(...),
- *   [
+ * 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.
- * @param {FunctionOptions} [options] - Optional settings for the function.
  *
  * @returns {Promise} - Returns a promise that resolves to the generated image.
  * The image is a Buffer containing the image data in PNG format.
  */
-export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>, prompt: PROMPT, options?: FunctionOptions & {
+export declare function generateImage<PROMPT>(args: {
+    model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>;
+    prompt: PROMPT;
     fullResponse?: false;
-}): Promise<Buffer>;
-export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>, prompt: PROMPT, options: FunctionOptions & {
+} & FunctionOptions): Promise<Buffer>;
+export declare function generateImage<PROMPT>(args: {
+    model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>;
+    prompt: PROMPT;
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     image: Buffer;
     imageBase64: string;
     images: Buffer[];

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

@@ -1,6 +1,6 @@
 import { executeStandardCall } from "../executeStandardCall.js";
-export async function generateImage(model, prompt, options) {
-    const fullResponse = await executeStandardCall({
+export async function generateImage({ model, prompt, fullResponse, ...options }) {
+    const callResponse = await executeStandardCall({
         functionType: "generate-image",
         input: prompt,
         model,
@@ -13,16 +13,16 @@ export async function generateImage(model, prompt, options) {
             };
         },
     });
-    const imagesBase64 = fullResponse.value;
+    const imagesBase64 = callResponse.value;
     const images = imagesBase64.map((imageBase64) => Buffer.from(imageBase64, "base64"));
-    return options?.fullResponse
+    return fullResponse
         ? {
             image: images[0],
             imageBase64: imagesBase64[0],
             images,
             imagesBase64,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
         : images[0];
 }

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSpeech = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-async function generateSpeech(model, text, options) {
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+async function generateSpeech({ model, text, fullResponse, ...options }) {
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-speech",
         input: text,
         model,
@@ -16,12 +16,12 @@ async function generateSpeech(model, text, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            speech: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            speech: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
 exports.generateSpeech = generateSpeech;

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

@@ -8,24 +8,27 @@ import { SpeechGenerationModel, SpeechGenerationModelSettings } from "./SpeechGe
  * @see https://modelfusion.dev/guide/function/generate-speech
  *
  * @example
- * const speech = await generateSpeech(
- *   lmnt.SpeechGenerator(...),
- *   "Good evening, ladies and gentlemen! Exciting news on the airwaves tonight " +
+ * const speech = await generateSpeech({
+ *   model: lmnt.SpeechGenerator(...),
+ *   text: "Good evening, ladies and gentlemen! Exciting news on the airwaves tonight " +
  *    "as The Rolling Stones unveil 'Hackney Diamonds.'
- * );
+ * });
  *
  * @param {SpeechGenerationModel<SpeechGenerationModelSettings>} model - The speech generation model.
  * @param {string} text - The text to be converted to speech.
- * @param {FunctionOptions} [options] - Optional function options.
  *
  * @returns {Promise<Buffer>} - A promise that resolves to a buffer containing the synthesized speech.
  */
-export declare function generateSpeech(model: SpeechGenerationModel<SpeechGenerationModelSettings>, text: string, options?: FunctionOptions & {
+export declare function generateSpeech(args: {
+    model: SpeechGenerationModel<SpeechGenerationModelSettings>;
+    text: string;
     fullResponse?: false;
-}): Promise<Buffer>;
-export declare function generateSpeech(model: SpeechGenerationModel<SpeechGenerationModelSettings>, text: string, options: FunctionOptions & {
+} & FunctionOptions): Promise<Buffer>;
+export declare function generateSpeech(args: {
+    model: SpeechGenerationModel<SpeechGenerationModelSettings>;
+    text: string;
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     speech: Buffer;
     rawResponse: unknown;
     metadata: ModelCallMetadata;

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

@@ -1,6 +1,6 @@
 import { executeStandardCall } from "../executeStandardCall.js";
-export async function generateSpeech(model, text, options) {
-    const fullResponse = await executeStandardCall({
+export async function generateSpeech({ model, text, fullResponse, ...options }) {
+    const callResponse = await executeStandardCall({
         functionType: "generate-speech",
         input: text,
         model,
@@ -13,11 +13,11 @@ export async function generateSpeech(model, text, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            speech: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            speech: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamSpeech = void 0;
 const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
-async function streamSpeech(model, text, options) {
+async function streamSpeech({ model, text, fullResponse, ...options }) {
     let textStream;
     // simulate a stream with a single value for a string input:
     if (typeof text === "string") {
@@ -15,7 +15,7 @@ async function streamSpeech(model, text, options) {
     else {
         textStream = text;
     }
-    const fullResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
+    const callResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
         functionType: "stream-speech",
         input: text,
         model,
@@ -23,11 +23,11 @@ async function streamSpeech(model, text, options) {
         startStream: async (options) => model.doGenerateSpeechStreamDuplex(textStream, options),
         processDelta: (delta) => delta.deltaValue,
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            speechStream: fullResponse.value,
-            metadata: fullResponse.metadata,
+            speechStream: callResponse.value,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
 exports.streamSpeech = streamSpeech;

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

@@ -11,10 +11,10 @@ import { SpeechGenerationModelSettings, StreamingSpeechGenerationModel } from ".
  * @example
  * const textStream = await streamText(...);
  *
- * const speechStream = await streamSpeech(
- *   elevenlabs.SpeechGenerator(...),
- *   textStream
- * );
+ * const speechStream = await streamSpeech({
+ *   model: elevenlabs.SpeechGenerator(...),
+ *   text: textStream
+ * });
  *
  * for await (const speechPart of speechStream) {
  *   // ...
@@ -26,12 +26,16 @@ import { SpeechGenerationModelSettings, StreamingSpeechGenerationModel } from ".
  *
  * @returns {AsyncIterableResultPromise<Buffer>} An async iterable promise that contains the synthesized speech chunks.
  */
-export declare function streamSpeech(model: StreamingSpeechGenerationModel<SpeechGenerationModelSettings>, text: AsyncIterable<string> | string, options?: FunctionOptions & {
+export declare function streamSpeech(args: {
+    model: StreamingSpeechGenerationModel<SpeechGenerationModelSettings>;
+    text: AsyncIterable<string> | string;
     fullResponse?: false;
-}): Promise<AsyncIterable<Buffer>>;
-export declare function streamSpeech(model: StreamingSpeechGenerationModel<SpeechGenerationModelSettings>, text: AsyncIterable<string> | string, options: FunctionOptions & {
+} & FunctionOptions): Promise<AsyncIterable<Buffer>>;
+export declare function streamSpeech(args: {
+    model: StreamingSpeechGenerationModel<SpeechGenerationModelSettings>;
+    text: AsyncIterable<string> | string;
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     speechStream: AsyncIterable<Buffer>;
     metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
 }>;

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

@@ -1,6 +1,6 @@
 import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { executeStreamCall } from "../executeStreamCall.js";
-export async function streamSpeech(model, text, options) {
+export async function streamSpeech({ model, text, fullResponse, ...options }) {
     let textStream;
     // simulate a stream with a single value for a string input:
     if (typeof text === "string") {
@@ -12,7 +12,7 @@ export async function streamSpeech(model, text, options) {
     else {
         textStream = text;
     }
-    const fullResponse = await executeStreamCall({
+    const callResponse = await executeStreamCall({
         functionType: "stream-speech",
         input: text,
         model,
@@ -20,10 +20,10 @@ export async function streamSpeech(model, text, options) {
         startStream: async (options) => model.doGenerateSpeechStreamDuplex(textStream, options),
         processDelta: (delta) => delta.deltaValue,
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            speechStream: fullResponse.value,
-            metadata: fullResponse.metadata,
+            speechStream: callResponse.value,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }

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

@@ -39,13 +39,15 @@ class StructureFromTextGenerationModel {
         return this.model;
     }
     async doGenerateStructure(schema, prompt, options) {
-        const { rawResponse: response, text } = await (0, generateText_js_1.generateText)(this.getModelWithJsonOutput(schema), this.template.createPrompt(prompt, schema), {
-            ...options,
+        const { rawResponse, text } = await (0, generateText_js_1.generateText)({
+            model: this.model,
+            prompt: this.template.createPrompt(prompt, schema),
             fullResponse: true,
+            ...options,
         });
         try {
             return {
-                response,
+                rawResponse,
                 value: this.template.extractStructure(text),
                 valueText: text,
             };

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

@@ -16,7 +16,7 @@ export declare class StructureFromTextGenerationModel<SOURCE_PROMPT, TARGET_PROM
     get settingsForEvent(): Partial<MODEL["settings"]>;
     getModelWithJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): MODEL;
     doGenerateStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<{
-        response: unknown;
+        rawResponse: unknown;
         value: unknown;
         valueText: string;
     }>;

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

@@ -36,13 +36,15 @@ export class StructureFromTextGenerationModel {
         return this.model;
     }
     async doGenerateStructure(schema, prompt, options) {
-        const { rawResponse: response, text } = await generateText(this.getModelWithJsonOutput(schema), this.template.createPrompt(prompt, schema), {
-            ...options,
+        const { rawResponse, text } = await generateText({
+            model: this.model,
+            prompt: this.template.createPrompt(prompt, schema),
             fullResponse: true,
+            ...options,
         });
         try {
             return {
-                response,
+                rawResponse,
                 value: this.template.extractStructure(text),
                 valueText: text,
             };

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

@@ -10,7 +10,11 @@ class StructureFromTextStreamingModel extends StructureFromTextGenerationModel_j
         super(options);
     }
     async doStreamStructure(schema, prompt, options) {
-        const textStream = await (0, streamText_js_1.streamText)(this.getModelWithJsonOutput(schema), this.template.createPrompt(prompt, schema), options);
+        const textStream = await (0, streamText_js_1.streamText)({
+            model: this.model,
+            prompt: this.template.createPrompt(prompt, schema),
+            ...options,
+        });
         const queue = new AsyncQueue_js_1.AsyncQueue();
         // run async on purpose:
         (async () => {

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

@@ -7,7 +7,11 @@ export class StructureFromTextStreamingModel extends StructureFromTextGeneration
         super(options);
     }
     async doStreamStructure(schema, prompt, options) {
-        const textStream = await streamText(this.getModelWithJsonOutput(schema), this.template.createPrompt(prompt, schema), options);
+        const textStream = await streamText({
+            model: this.model,
+            prompt: this.template.createPrompt(prompt, schema),
+            ...options,
+        });
         const queue = new AsyncQueue();
         // run async on purpose:
         (async () => {

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

@@ -7,7 +7,7 @@ export interface StructureGenerationModelSettings extends ModelSettings {
 }
 export interface StructureGenerationModel<PROMPT, SETTINGS extends StructureGenerationModelSettings = StructureGenerationModelSettings> extends Model<SETTINGS> {
     doGenerateStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
-        response: unknown;
+        rawResponse: unknown;
         valueText: string;
         value: unknown;
         usage?: {

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

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStructure = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
-async function generateStructure(model, schema, prompt, options) {
+async function generateStructure({ model, schema, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(schema)
         : prompt;
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-structure",
         input: {
             schema,
@@ -29,18 +29,18 @@ async function generateStructure(model, schema, prompt, options) {
             }
             const value = parseResult.data;
             return {
-                rawResponse: result.response,
+                rawResponse: result.rawResponse,
                 extractedValue: value,
                 usage: result.usage,
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            structure: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            structure: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
 exports.generateStructure = generateStructure;

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

@@ -9,14 +9,16 @@ import { StructureGenerationModel, StructureGenerationModelSettings } from "./St
  * @see https://modelfusion.dev/guide/function/generate-structure
  *
  * @example
- * const sentiment = await generateStructure(
- *   openai.ChatTextGenerator(...).asFunctionCallStructureGenerationModel(...),
- *   zodSchema(z.object({
+ * const sentiment = await generateStructure({
+ *   model: openai.ChatTextGenerator(...).asFunctionCallStructureGenerationModel(...),
+ *
+ *   schema: zodSchema(z.object({
  *     sentiment: z
  *       .enum(["positive", "neutral", "negative"])
  *       .describe("Sentiment."),
  *   })),
- *   [
+ *
+ *   prompt: [
  *     openai.ChatMessage.system(
  *       "You are a sentiment evaluator. " +
  *         "Analyze the sentiment of the following product review:"
@@ -26,23 +28,28 @@ import { StructureGenerationModel, StructureGenerationModelSettings } from "./St
  *         "that did not disappear even after washing. Never again!"
  *     ),
  *   ]
- * );
+ * });
  *
  * @param {StructureGenerationModel<PROMPT, SETTINGS>} model - The model to generate the structure.
  * @param {Schema<STRUCTURE>} schema - The schema to be used.
  * @param {PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT)} prompt
  * The prompt to be used.
  * You can also pass a function that takes the schema as an argument and returns the prompt.
- * @param {FunctionOptions} [options] - Optional function options.
  *
  * @returns {Promise<STRUCTURE>} - Returns a promise that resolves to the generated structure.
  */
-export declare function generateStructure<STRUCTURE, PROMPT, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, SETTINGS>, schema: Schema<STRUCTURE> & JsonSchemaProducer, prompt: PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT), options?: FunctionOptions & {
+export declare function generateStructure<STRUCTURE, PROMPT, SETTINGS extends StructureGenerationModelSettings>(args: {
+    model: StructureGenerationModel<PROMPT, SETTINGS>;
+    schema: Schema<STRUCTURE> & JsonSchemaProducer;
+    prompt: PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT);
     fullResponse?: false;
-}): Promise<STRUCTURE>;
-export declare function generateStructure<STRUCTURE, PROMPT, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, SETTINGS>, schema: Schema<STRUCTURE> & JsonSchemaProducer, prompt: PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT), options: FunctionOptions & {
+} & FunctionOptions): Promise<STRUCTURE>;
+export declare function generateStructure<STRUCTURE, PROMPT, SETTINGS extends StructureGenerationModelSettings>(args: {
+    model: StructureGenerationModel<PROMPT, SETTINGS>;
+    schema: Schema<STRUCTURE> & JsonSchemaProducer;
+    prompt: PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT);
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     structure: STRUCTURE;
     rawResponse: unknown;
     metadata: ModelCallMetadata;

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

@@ -1,11 +1,11 @@
 import { executeStandardCall } from "../executeStandardCall.js";
 import { StructureValidationError } from "./StructureValidationError.js";
-export async function generateStructure(model, schema, prompt, options) {
+export async function generateStructure({ model, schema, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(schema)
         : prompt;
-    const fullResponse = await executeStandardCall({
+    const callResponse = await executeStandardCall({
         functionType: "generate-structure",
         input: {
             schema,
@@ -26,17 +26,17 @@ export async function generateStructure(model, schema, prompt, options) {
             }
             const value = parseResult.data;
             return {
-                rawResponse: result.response,
+                rawResponse: result.rawResponse,
                 extractedValue: value,
                 usage: result.usage,
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            structure: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            structure: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }

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

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamStructure = void 0;
 const isDeepEqualData_js_1 = require("../../util/isDeepEqualData.cjs");
 const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
-async function streamStructure(model, schema, prompt, options) {
+async function streamStructure({ model, schema, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(schema)
         : prompt;
     let accumulatedText = "";
     let lastStructure;
-    const fullResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
+    const callResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
         functionType: "stream-structure",
         input: {
             schema,
@@ -49,11 +49,11 @@ async function streamStructure(model, schema, prompt, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            structureStream: fullResponse.value,
-            metadata: fullResponse.metadata,
+            structureStream: callResponse.value,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
 exports.streamStructure = streamStructure;

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

@@ -25,9 +25,9 @@ export type StructureStreamPart<STRUCTURE> = {
  * @see https://modelfusion.dev/guide/function/generate-structure
  *
  * @example
- * const structureStream = await streamStructure(
- *   openai.ChatTextGenerator(...).asFunctionCallStructureGenerationModel(...),
- *   zodSchema(
+ * const structureStream = await streamStructure({
+ *   structureGenerator: openai.ChatTextGenerator(...).asFunctionCallStructureGenerationModel(...),
+ *   schema: zodSchema(
  *     z.array(
  *       z.object({
  *         name: z.string(),
@@ -37,12 +37,12 @@ export type StructureStreamPart<STRUCTURE> = {
  *         description: z.string(),
  *       })
  *     ),
- *   [
+ *   prompt: [
  *     openai.ChatMessage.user(
  *       "Generate 3 character descriptions for a fantasy role playing game."
  *     ),
  *   ]
- * );
+ * });
  *
  * for await (const part of structureStream) {
  *   if (!part.isComplete) {
@@ -55,7 +55,7 @@ export type StructureStreamPart<STRUCTURE> = {
  *   }
  * }
  *
- * @param {StructureStreamingModel<PROMPT>} model - The model to use for streaming
+ * @param {StructureStreamingModel<PROMPT>} structureGenerator - The model to use for streaming
  * @param {Schema<STRUCTURE>} schema - The schema to be used.
  * @param {PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT)} prompt
  * The prompt to be used.
@@ -68,12 +68,18 @@ export type StructureStreamPart<STRUCTURE> = {
  * It contains a isComplete flag to indicate whether the structure is complete,
  * and a value that is either the partial structure or the final structure.
  */
-export declare function streamStructure<STRUCTURE, PROMPT>(model: StructureStreamingModel<PROMPT>, schema: Schema<STRUCTURE> & JsonSchemaProducer, prompt: PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT), options?: FunctionOptions & {
+export declare function streamStructure<STRUCTURE, PROMPT>(args: {
+    model: StructureStreamingModel<PROMPT>;
+    schema: Schema<STRUCTURE> & JsonSchemaProducer;
+    prompt: PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT);
     fullResponse?: false;
-}): Promise<AsyncIterable<StructureStreamPart<STRUCTURE>>>;
-export declare function streamStructure<STRUCTURE, PROMPT>(model: StructureStreamingModel<PROMPT>, schema: Schema<STRUCTURE> & JsonSchemaProducer, prompt: PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT), options: FunctionOptions & {
+} & FunctionOptions): Promise<AsyncIterable<StructureStreamPart<STRUCTURE>>>;
+export declare function streamStructure<STRUCTURE, PROMPT>(args: {
+    model: StructureStreamingModel<PROMPT>;
+    schema: Schema<STRUCTURE> & JsonSchemaProducer;
+    prompt: PROMPT | ((schema: Schema<STRUCTURE>) => PROMPT);
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     structureStream: AsyncIterable<StructureStreamPart<STRUCTURE>>;
     metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
 }>;

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

@@ -1,13 +1,13 @@
 import { isDeepEqualData } from "../../util/isDeepEqualData.js";
 import { executeStreamCall } from "../executeStreamCall.js";
-export async function streamStructure(model, schema, prompt, options) {
+export async function streamStructure({ model, schema, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(schema)
         : prompt;
     let accumulatedText = "";
     let lastStructure;
-    const fullResponse = await executeStreamCall({
+    const callResponse = await executeStreamCall({
         functionType: "stream-structure",
         input: {
             schema,
@@ -46,10 +46,10 @@ export async function streamStructure(model, schema, prompt, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            structureStream: fullResponse.value,
-            metadata: fullResponse.metadata,
+            structureStream: callResponse.value,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }