modelfusion 0.130.1 → 0.131.0

package/model-function/{generate-structure/generateStructure.cjs → generate-object/generateObject.cjs}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStructure = void 0;
+exports.generateObject = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
-async function generateStructure({ model, schema, prompt, fullResponse, ...options }) {
+const ObjectValidationError_js_1 = require("./ObjectValidationError.cjs");
+async function generateObject({ model, schema, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(schema)
         : prompt;
     const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "generate-structure",
+        functionType: "generate-object",
         input: {
             schema,
             prompt: expandedPrompt,
@@ -17,17 +17,16 @@ async function generateStructure({ model, schema, prompt, fullResponse, ...optio
         model,
         options,
         generateResponse: async (options) => {
-            const result = await model.doGenerateStructure(schema, expandedPrompt, options);
-            const structure = result.value;
-            const parseResult = schema.validate(structure);
+            const result = await model.doGenerateObject(schema, expandedPrompt, options);
+            const parseResult = schema.validate(result.value);
             if (!parseResult.success) {
-                throw new StructureValidationError_js_1.StructureValidationError({
+                throw new ObjectValidationError_js_1.ObjectValidationError({
                     valueText: result.valueText,
-                    value: structure,
+                    value: result.value,
                     cause: parseResult.error,
                 });
             }
-            const value = parseResult.data;
+            const value = parseResult.value;
             return {
                 rawResponse: result.rawResponse,
                 extractedValue: value,
@@ -37,10 +36,10 @@ async function generateStructure({ model, schema, prompt, fullResponse, ...optio
     });
     return fullResponse
         ? {
-            structure: callResponse.value,
+            value: callResponse.value,
             rawResponse: callResponse.rawResponse,
             metadata: callResponse.metadata,
         }
         : callResponse.value;
 }
-exports.generateStructure = generateStructure;
+exports.generateObject = generateObject;

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

@@ -0,0 +1,56 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../core/schema/Schema.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
+import { ObjectGenerationModel, ObjectGenerationModelSettings } from "./ObjectGenerationModel.js";
+/**
+ * Generate a typed object for a prompt and a schema.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-object
+ *
+ * @example
+ * const sentiment = await generateObject({
+ *   model: openai.ChatTextGenerator(...).asFunctionCallObjectGenerationModel(...),
+ *
+ *   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:"
+ *     ),
+ *     openai.ChatMessage.user(
+ *       "After I opened the package, I was met by a very unpleasant smell " +
+ *         "that did not disappear even after washing. Never again!"
+ *     ),
+ *   ]
+ * });
+ *
+ * @param {ObjectGenerationModel<PROMPT, SETTINGS>} options.model - The model to generate the object.
+ * @param {Schema<OBJECT>} options.schema - The schema to be used.
+ * @param {PROMPT | ((schema: Schema<OBJECT>) => PROMPT)} options.prompt
+ * The prompt to be used.
+ * You can also pass a function that takes the schema as an argument and returns the prompt.
+ *
+ * @returns {Promise<OBJECT>} - Returns a promise that resolves to the generated object.
+ */
+export declare function generateObject<OBJECT, PROMPT, SETTINGS extends ObjectGenerationModelSettings>(args: {
+    model: ObjectGenerationModel<PROMPT, SETTINGS>;
+    schema: Schema<OBJECT> & JsonSchemaProducer;
+    prompt: PROMPT | ((schema: Schema<OBJECT>) => PROMPT);
+    fullResponse?: false;
+} & FunctionOptions): Promise<OBJECT>;
+export declare function generateObject<OBJECT, PROMPT, SETTINGS extends ObjectGenerationModelSettings>(args: {
+    model: ObjectGenerationModel<PROMPT, SETTINGS>;
+    schema: Schema<OBJECT> & JsonSchemaProducer;
+    prompt: PROMPT | ((schema: Schema<OBJECT>) => PROMPT);
+    fullResponse: true;
+} & FunctionOptions): Promise<{
+    value: OBJECT;
+    rawResponse: unknown;
+    metadata: ModelCallMetadata;
+}>;

package/model-function/{generate-structure/generateStructure.js → generate-object/generateObject.js}

@@ -1,12 +1,12 @@
 import { executeStandardCall } from "../executeStandardCall.js";
-import { StructureValidationError } from "./StructureValidationError.js";
-export async function generateStructure({ model, schema, prompt, fullResponse, ...options }) {
+import { ObjectValidationError } from "./ObjectValidationError.js";
+export async function generateObject({ model, schema, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(schema)
         : prompt;
     const callResponse = await executeStandardCall({
-        functionType: "generate-structure",
+        functionType: "generate-object",
         input: {
             schema,
             prompt: expandedPrompt,
@@ -14,17 +14,16 @@ export async function generateStructure({ model, schema, prompt, fullResponse, .
         model,
         options,
         generateResponse: async (options) => {
-            const result = await model.doGenerateStructure(schema, expandedPrompt, options);
-            const structure = result.value;
-            const parseResult = schema.validate(structure);
+            const result = await model.doGenerateObject(schema, expandedPrompt, options);
+            const parseResult = schema.validate(result.value);
             if (!parseResult.success) {
-                throw new StructureValidationError({
+                throw new ObjectValidationError({
                     valueText: result.valueText,
-                    value: structure,
+                    value: result.value,
                     cause: parseResult.error,
                 });
             }
-            const value = parseResult.data;
+            const value = parseResult.value;
             return {
                 rawResponse: result.rawResponse,
                 extractedValue: value,
@@ -34,7 +33,7 @@ export async function generateStructure({ model, schema, prompt, fullResponse, .
     });
     return fullResponse
         ? {
-            structure: callResponse.value,
+            value: callResponse.value,
             rawResponse: callResponse.rawResponse,
             metadata: callResponse.metadata,
         }

package/model-function/{generate-structure → generate-object}/index.cjs

@@ -14,14 +14,15 @@ 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("./StructureFromTextGenerationModel.cjs"), exports);
-__exportStar(require("./StructureFromTextPromptTemplate.cjs"), exports);
-__exportStar(require("./StructureFromTextStreamingModel.cjs"), exports);
-__exportStar(require("./StructureGenerationEvent.cjs"), exports);
-__exportStar(require("./StructureGenerationModel.cjs"), exports);
-__exportStar(require("./StructureParseError.cjs"), exports);
-__exportStar(require("./StructureStreamingEvent.cjs"), exports);
-__exportStar(require("./StructureValidationError.cjs"), exports);
-__exportStar(require("./generateStructure.cjs"), exports);
-__exportStar(require("./jsonStructurePrompt.cjs"), exports);
-__exportStar(require("./streamStructure.cjs"), exports);
+__exportStar(require("./ObjectFromTextGenerationModel.cjs"), exports);
+__exportStar(require("./ObjectFromTextPromptTemplate.cjs"), exports);
+__exportStar(require("./ObjectFromTextStreamingModel.cjs"), exports);
+__exportStar(require("./ObjectGenerationEvent.cjs"), exports);
+__exportStar(require("./ObjectGenerationModel.cjs"), exports);
+__exportStar(require("./ObjectParseError.cjs"), exports);
+__exportStar(require("./ObjectStream.cjs"), exports);
+__exportStar(require("./ObjectStreamingEvent.cjs"), exports);
+__exportStar(require("./ObjectValidationError.cjs"), exports);
+__exportStar(require("./generateObject.cjs"), exports);
+__exportStar(require("./jsonObjectPrompt.cjs"), exports);
+__exportStar(require("./streamObject.cjs"), exports);

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

@@ -0,0 +1,12 @@
+export * from "./ObjectFromTextGenerationModel.js";
+export * from "./ObjectFromTextPromptTemplate.js";
+export * from "./ObjectFromTextStreamingModel.js";
+export * from "./ObjectGenerationEvent.js";
+export * from "./ObjectGenerationModel.js";
+export * from "./ObjectParseError.js";
+export * from "./ObjectStream.js";
+export * from "./ObjectStreamingEvent.js";
+export * from "./ObjectValidationError.js";
+export * from "./generateObject.js";
+export * from "./jsonObjectPrompt.js";
+export * from "./streamObject.js";

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

@@ -0,0 +1,12 @@
+export * from "./ObjectFromTextGenerationModel.js";
+export * from "./ObjectFromTextPromptTemplate.js";
+export * from "./ObjectFromTextStreamingModel.js";
+export * from "./ObjectGenerationEvent.js";
+export * from "./ObjectGenerationModel.js";
+export * from "./ObjectParseError.js";
+export * from "./ObjectStream.js";
+export * from "./ObjectStreamingEvent.js";
+export * from "./ObjectValidationError.js";
+export * from "./generateObject.js";
+export * from "./jsonObjectPrompt.js";
+export * from "./streamObject.js";

package/model-function/{generate-structure/jsonStructurePrompt.cjs → generate-object/jsonObjectPrompt.cjs}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonStructurePrompt = void 0;
+exports.jsonObjectPrompt = void 0;
 const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
 const DEFAULT_SCHEMA_PREFIX = "JSON schema:";
 const DEFAULT_SCHEMA_SUFFIX = "\nYou MUST answer with a JSON object matches the above schema.";
-exports.jsonStructurePrompt = {
+exports.jsonObjectPrompt = {
     custom(createPrompt) {
-        return { createPrompt, extractStructure };
+        return { createPrompt, extractObject };
     },
     text({ schemaPrefix, schemaSuffix, } = {}) {
         return {
@@ -14,7 +14,7 @@ exports.jsonStructurePrompt = {
                 system: createSystemPrompt({ schema, schemaPrefix, schemaSuffix }),
                 instruction: prompt,
             }),
-            extractStructure,
+            extractObject,
             adaptModel: (model) => model.withInstructionPrompt(),
             withJsonOutput: ({ model, schema }) => model.withJsonOutput(schema),
         };
@@ -30,7 +30,7 @@ exports.jsonStructurePrompt = {
                 }),
                 instruction: prompt.instruction,
             }),
-            extractStructure,
+            extractObject,
             adaptModel: (model) => model.withInstructionPrompt(),
             withJsonOutput: ({ model, schema }) => model.withJsonOutput(schema),
         };
@@ -46,6 +46,6 @@ function createSystemPrompt({ originalSystemPrompt, schema, schemaPrefix = DEFAU
         .filter(Boolean)
         .join("\n");
 }
-function extractStructure(response) {
+function extractObject(response) {
     return (0, parseJSON_js_1.parseJSON)({ text: response });
 }

package/model-function/{generate-structure/jsonStructurePrompt.d.ts → generate-object/jsonObjectPrompt.d.ts}

@@ -1,15 +1,15 @@
 import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
 import { Schema } from "../../core/schema/Schema.js";
-import { InstructionPrompt } from "../../model-function/generate-text/prompt-template/InstructionPrompt.js";
-import { FlexibleStructureFromTextPromptTemplate, StructureFromTextPromptTemplate } from "./StructureFromTextPromptTemplate.js";
-export declare const jsonStructurePrompt: {
-    custom<SOURCE_PROMPT, TARGET_PROMPT>(createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => TARGET_PROMPT): StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
+import { InstructionPrompt } from "../generate-text/prompt-template/InstructionPrompt.js";
+import { FlexibleObjectFromTextPromptTemplate, ObjectFromTextPromptTemplate } from "./ObjectFromTextPromptTemplate.js";
+export declare const jsonObjectPrompt: {
+    custom<SOURCE_PROMPT, TARGET_PROMPT>(createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => TARGET_PROMPT): ObjectFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
     text({ schemaPrefix, schemaSuffix, }?: {
         schemaPrefix?: string | undefined;
         schemaSuffix?: string | undefined;
-    }): FlexibleStructureFromTextPromptTemplate<string, InstructionPrompt>;
+    }): FlexibleObjectFromTextPromptTemplate<string, InstructionPrompt>;
     instruction({ schemaPrefix, schemaSuffix, }?: {
         schemaPrefix?: string | undefined;
         schemaSuffix?: string | undefined;
-    }): FlexibleStructureFromTextPromptTemplate<InstructionPrompt, InstructionPrompt>;
+    }): FlexibleObjectFromTextPromptTemplate<InstructionPrompt, InstructionPrompt>;
 };

package/model-function/{generate-structure/jsonStructurePrompt.js → generate-object/jsonObjectPrompt.js}

@@ -1,9 +1,9 @@
 import { parseJSON } from "../../core/schema/parseJSON.js";
 const DEFAULT_SCHEMA_PREFIX = "JSON schema:";
 const DEFAULT_SCHEMA_SUFFIX = "\nYou MUST answer with a JSON object matches the above schema.";
-export const jsonStructurePrompt = {
+export const jsonObjectPrompt = {
     custom(createPrompt) {
-        return { createPrompt, extractStructure };
+        return { createPrompt, extractObject };
     },
     text({ schemaPrefix, schemaSuffix, } = {}) {
         return {
@@ -11,7 +11,7 @@ export const jsonStructurePrompt = {
                 system: createSystemPrompt({ schema, schemaPrefix, schemaSuffix }),
                 instruction: prompt,
             }),
-            extractStructure,
+            extractObject,
             adaptModel: (model) => model.withInstructionPrompt(),
             withJsonOutput: ({ model, schema }) => model.withJsonOutput(schema),
         };
@@ -27,7 +27,7 @@ export const jsonStructurePrompt = {
                 }),
                 instruction: prompt.instruction,
             }),
-            extractStructure,
+            extractObject,
             adaptModel: (model) => model.withInstructionPrompt(),
             withJsonOutput: ({ model, schema }) => model.withJsonOutput(schema),
         };
@@ -43,6 +43,6 @@ function createSystemPrompt({ originalSystemPrompt, schema, schemaPrefix = DEFAU
         .filter(Boolean)
         .join("\n");
 }
-function extractStructure(response) {
+function extractObject(response) {
     return parseJSON({ text: response });
 }

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamObject = void 0;
+const isDeepEqualData_js_1 = require("../../util/isDeepEqualData.cjs");
+const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
+async function streamObject({ model, schema, prompt, fullResponse, ...options }) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(schema)
+        : prompt;
+    let accumulatedText = "";
+    let accumulatedTextDelta = "";
+    let latestObject;
+    let resolveObject;
+    let rejectObject;
+    const objectPromise = new Promise((resolve, reject) => {
+        resolveObject = resolve;
+        rejectObject = reject;
+    });
+    const callResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
+        functionType: "stream-object",
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
+        model,
+        options,
+        startStream: async (options) => model.doStreamObject(schema, expandedPrompt, options),
+        processDelta(delta) {
+            const textDelta = model.extractObjectTextDelta(delta.deltaValue);
+            if (textDelta == null) {
+                return undefined;
+            }
+            accumulatedText += textDelta;
+            accumulatedTextDelta += textDelta;
+            const currentObject = model.parseAccumulatedObjectText(accumulatedText);
+            // only send a new part into the stream when the partial object has changed:
+            if (!(0, isDeepEqualData_js_1.isDeepEqualData)(latestObject, currentObject)) {
+                latestObject = currentObject;
+                // reset delta accumulation:
+                const currentAccumulatedTextDelta = accumulatedTextDelta;
+                accumulatedTextDelta = "";
+                // TODO add type checking
+                return {
+                    partialObject: latestObject,
+                    partialText: accumulatedText,
+                    textDelta: currentAccumulatedTextDelta,
+                };
+            }
+            return undefined;
+        },
+        // The last object is processed and returned, even if it was already returned previously.
+        // The reason is that the full text delta should be returned (and no characters should be omitted).
+        processFinished() {
+            return {
+                partialObject: latestObject,
+                partialText: accumulatedText,
+                textDelta: accumulatedTextDelta,
+            };
+        },
+        onDone() {
+            // process the final result (full type validation):
+            const parseResult = schema.validate(latestObject);
+            if (parseResult.success) {
+                resolveObject(parseResult.value);
+            }
+            else {
+                rejectObject(parseResult.error);
+            }
+        },
+    });
+    return fullResponse
+        ? {
+            objectStream: callResponse.value,
+            objectPromise: objectPromise,
+            metadata: callResponse.metadata,
+        }
+        : callResponse.value;
+}
+exports.streamObject = streamObject;

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

@@ -0,0 +1,57 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../core/schema/Schema.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
+import { ObjectStreamingModel } from "./ObjectGenerationModel.js";
+import { ObjectStream } from "./ObjectStream.js";
+/**
+ * Generate and stream an object for a prompt and a schema.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-object
+ *
+ * @example
+ * const objectStream = await streamObject({
+ *   model: openai.ChatTextGenerator(...).asFunctionCallObjectGenerationModel(...),
+ *   schema: zodSchema(
+ *     z.array(
+ *       z.object({
+ *         name: z.string(),
+ *         class: z
+ *           .string()
+ *           .describe("Character class, e.g. warrior, mage, or thief."),
+ *         description: z.string(),
+ *       })
+ *     ),
+ *   prompt: [
+ *     openai.ChatMessage.user(
+ *       "Generate 3 character descriptions for a fantasy role playing game."
+ *     ),
+ *   ]
+ * });
+ *
+ * for await (const { partialObject } of objectStream) {
+ *   // ...
+ * }
+ *
+ * @param {ObjectStreamingModel<PROMPT>} options.model - The model that generates the object
+ * @param {Schema<OBJECT>} options.schema - The schema of the object to be generated.
+ * @param {PROMPT | ((schema: Schema<OBJECT>) => PROMPT)} options.prompt
+ * The prompt to be used.
+ * You can also pass a function that takes the schema as an argument and returns the prompt.
+ */
+export declare function streamObject<OBJECT, PROMPT>(args: {
+    model: ObjectStreamingModel<PROMPT>;
+    schema: Schema<OBJECT> & JsonSchemaProducer;
+    prompt: PROMPT | ((schema: Schema<OBJECT>) => PROMPT);
+    fullResponse?: false;
+} & FunctionOptions): Promise<ObjectStream<OBJECT>>;
+export declare function streamObject<OBJECT, PROMPT>(args: {
+    model: ObjectStreamingModel<PROMPT>;
+    schema: Schema<OBJECT> & JsonSchemaProducer;
+    prompt: PROMPT | ((schema: Schema<OBJECT>) => PROMPT);
+    fullResponse: true;
+} & FunctionOptions): Promise<{
+    objectStream: ObjectStream<OBJECT>;
+    objectPromise: PromiseLike<OBJECT>;
+    metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
+}>;

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

@@ -0,0 +1,76 @@
+import { isDeepEqualData } from "../../util/isDeepEqualData.js";
+import { executeStreamCall } from "../executeStreamCall.js";
+export async function streamObject({ model, schema, prompt, fullResponse, ...options }) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(schema)
+        : prompt;
+    let accumulatedText = "";
+    let accumulatedTextDelta = "";
+    let latestObject;
+    let resolveObject;
+    let rejectObject;
+    const objectPromise = new Promise((resolve, reject) => {
+        resolveObject = resolve;
+        rejectObject = reject;
+    });
+    const callResponse = await executeStreamCall({
+        functionType: "stream-object",
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
+        model,
+        options,
+        startStream: async (options) => model.doStreamObject(schema, expandedPrompt, options),
+        processDelta(delta) {
+            const textDelta = model.extractObjectTextDelta(delta.deltaValue);
+            if (textDelta == null) {
+                return undefined;
+            }
+            accumulatedText += textDelta;
+            accumulatedTextDelta += textDelta;
+            const currentObject = model.parseAccumulatedObjectText(accumulatedText);
+            // only send a new part into the stream when the partial object has changed:
+            if (!isDeepEqualData(latestObject, currentObject)) {
+                latestObject = currentObject;
+                // reset delta accumulation:
+                const currentAccumulatedTextDelta = accumulatedTextDelta;
+                accumulatedTextDelta = "";
+                // TODO add type checking
+                return {
+                    partialObject: latestObject,
+                    partialText: accumulatedText,
+                    textDelta: currentAccumulatedTextDelta,
+                };
+            }
+            return undefined;
+        },
+        // The last object is processed and returned, even if it was already returned previously.
+        // The reason is that the full text delta should be returned (and no characters should be omitted).
+        processFinished() {
+            return {
+                partialObject: latestObject,
+                partialText: accumulatedText,
+                textDelta: accumulatedTextDelta,
+            };
+        },
+        onDone() {
+            // process the final result (full type validation):
+            const parseResult = schema.validate(latestObject);
+            if (parseResult.success) {
+                resolveObject(parseResult.value);
+            }
+            else {
+                rejectObject(parseResult.error);
+            }
+        },
+    });
+    return fullResponse
+        ? {
+            objectStream: callResponse.value,
+            objectPromise: objectPromise,
+            metadata: callResponse.metadata,
+        }
+        : callResponse.value;
+}

package/model-function/generate-text/PromptTemplateTextGenerationModel.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptTemplateTextGenerationModel = void 0;
 const TextGenerationToolCallModel_js_1 = require("../../tool/generate-tool-call/TextGenerationToolCallModel.cjs");
 const TextGenerationToolCallsModel_js_1 = require("../../tool/generate-tool-calls/TextGenerationToolCallsModel.cjs");
-const StructureFromTextGenerationModel_js_1 = require("../generate-structure/StructureFromTextGenerationModel.cjs");
+const ObjectFromTextGenerationModel_js_1 = require("../generate-object/ObjectFromTextGenerationModel.cjs");
 class PromptTemplateTextGenerationModel {
     constructor({ model, promptTemplate, }) {
         Object.defineProperty(this, "model", {
@@ -62,8 +62,8 @@ class PromptTemplateTextGenerationModel {
             template: promptTemplate,
         });
     }
-    asStructureGenerationModel(promptTemplate) {
-        return new StructureFromTextGenerationModel_js_1.StructureFromTextGenerationModel({
+    asObjectGenerationModel(promptTemplate) {
+        return new ObjectFromTextGenerationModel_js_1.ObjectFromTextGenerationModel({
             model: this,
             template: promptTemplate,
         });

package/model-function/generate-text/PromptTemplateTextGenerationModel.d.ts

@@ -4,8 +4,8 @@ import { Schema } from "../../core/schema/Schema.js";
 import { TextGenerationToolCallModel, ToolCallPromptTemplate } from "../../tool/generate-tool-call/TextGenerationToolCallModel.js";
 import { TextGenerationToolCallsModel } from "../../tool/generate-tool-calls/TextGenerationToolCallsModel.js";
 import { ToolCallsPromptTemplate } from "../../tool/generate-tool-calls/ToolCallsPromptTemplate.js";
-import { StructureFromTextGenerationModel } from "../generate-structure/StructureFromTextGenerationModel.js";
-import { StructureFromTextPromptTemplate } from "../generate-structure/StructureFromTextPromptTemplate.js";
+import { ObjectFromTextGenerationModel } from "../generate-object/ObjectFromTextGenerationModel.js";
+import { ObjectFromTextPromptTemplate } from "../generate-object/ObjectFromTextPromptTemplate.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
 import { TextGenerationPromptTemplate } from "./TextGenerationPromptTemplate.js";
 export declare class PromptTemplateTextGenerationModel<PROMPT, MODEL_PROMPT, SETTINGS extends TextGenerationModelSettings, MODEL extends TextGenerationModel<MODEL_PROMPT, SETTINGS>> implements TextGenerationModel<PROMPT, SETTINGS> {
@@ -41,7 +41,7 @@ export declare class PromptTemplateTextGenerationModel<PROMPT, MODEL_PROMPT, SET
     get settingsForEvent(): Partial<SETTINGS>;
     asToolCallGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallModel<INPUT_PROMPT, PROMPT, this>;
     asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallsModel<INPUT_PROMPT, PROMPT, this>;
-    asStructureGenerationModel<INPUT_PROMPT>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): StructureFromTextGenerationModel<INPUT_PROMPT, PROMPT, this>;
+    asObjectGenerationModel<INPUT_PROMPT>(promptTemplate: ObjectFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): ObjectFromTextGenerationModel<INPUT_PROMPT, PROMPT, this>;
     withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): this;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/model-function/generate-text/PromptTemplateTextGenerationModel.js

@@ -1,6 +1,6 @@
 import { TextGenerationToolCallModel, } from "../../tool/generate-tool-call/TextGenerationToolCallModel.js";
 import { TextGenerationToolCallsModel } from "../../tool/generate-tool-calls/TextGenerationToolCallsModel.js";
-import { StructureFromTextGenerationModel } from "../generate-structure/StructureFromTextGenerationModel.js";
+import { ObjectFromTextGenerationModel } from "../generate-object/ObjectFromTextGenerationModel.js";
 export class PromptTemplateTextGenerationModel {
     constructor({ model, promptTemplate, }) {
         Object.defineProperty(this, "model", {
@@ -59,8 +59,8 @@ export class PromptTemplateTextGenerationModel {
             template: promptTemplate,
         });
     }
-    asStructureGenerationModel(promptTemplate) {
-        return new StructureFromTextGenerationModel({
+    asObjectGenerationModel(promptTemplate) {
+        return new ObjectFromTextGenerationModel({
             model: this,
             template: promptTemplate,
         });

package/model-function/generate-text/PromptTemplateTextStreamingModel.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptTemplateTextStreamingModel = void 0;
-const StructureFromTextStreamingModel_js_1 = require("../generate-structure/StructureFromTextStreamingModel.cjs");
+const ObjectFromTextStreamingModel_js_1 = require("../generate-object/ObjectFromTextStreamingModel.cjs");
 const PromptTemplateTextGenerationModel_js_1 = require("./PromptTemplateTextGenerationModel.cjs");
 class PromptTemplateTextStreamingModel extends PromptTemplateTextGenerationModel_js_1.PromptTemplateTextGenerationModel {
     constructor(options) {
@@ -14,8 +14,8 @@ class PromptTemplateTextStreamingModel extends PromptTemplateTextGenerationModel
     extractTextDelta(delta) {
         return this.model.extractTextDelta(delta);
     }
-    asStructureGenerationModel(promptTemplate) {
-        return new StructureFromTextStreamingModel_js_1.StructureFromTextStreamingModel({
+    asObjectGenerationModel(promptTemplate) {
+        return new ObjectFromTextStreamingModel_js_1.ObjectFromTextStreamingModel({
             model: this,
             template: promptTemplate,
         });

package/model-function/generate-text/PromptTemplateTextStreamingModel.d.ts

@@ -1,8 +1,8 @@
 import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
 import { Schema } from "../../core/schema/Schema.js";
-import { StructureFromTextPromptTemplate } from "../generate-structure/StructureFromTextPromptTemplate.js";
-import { StructureFromTextStreamingModel } from "../generate-structure/StructureFromTextStreamingModel.js";
+import { ObjectFromTextPromptTemplate } from "../generate-object/ObjectFromTextPromptTemplate.js";
+import { ObjectFromTextStreamingModel } from "../generate-object/ObjectFromTextStreamingModel.js";
 import { PromptTemplateTextGenerationModel } from "./PromptTemplateTextGenerationModel.js";
 import { TextGenerationModelSettings, TextStreamingModel } from "./TextGenerationModel.js";
 import { TextGenerationPromptTemplate } from "./TextGenerationPromptTemplate.js";
@@ -13,7 +13,7 @@ export declare class PromptTemplateTextStreamingModel<PROMPT, MODEL_PROMPT, SETT
     });
     doStreamText(prompt: PROMPT, options?: FunctionCallOptions): PromiseLike<AsyncIterable<import("../Delta.js").Delta<unknown>>>;
     extractTextDelta(delta: unknown): string | undefined;
-    asStructureGenerationModel<INPUT_PROMPT>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): StructureFromTextStreamingModel<INPUT_PROMPT, PROMPT, this>;
+    asObjectGenerationModel<INPUT_PROMPT>(promptTemplate: ObjectFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): ObjectFromTextStreamingModel<INPUT_PROMPT, PROMPT, this>;
     withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): this;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }