modelfusion 0.130.1 → 0.131.0

package/core/schema/validateTypes.js

@@ -4,26 +4,26 @@ import { TypeValidationError } from "./TypeValidationError.js";
  * 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.
+ * @param {string} options.value - The object to validate.
+ * @param {Schema<T>} options.schema - The schema to use for validating the JSON.
  * @returns {T} - The typed object.
  */
-export function validateTypes({ structure, schema, }) {
+export function validateTypes({ value, schema, }) {
     try {
-        const validationResult = schema.validate(structure);
+        const validationResult = schema.validate(value);
         if (!validationResult.success) {
             throw new TypeValidationError({
-                structure,
+                value,
                 cause: validationResult.error,
             });
         }
-        return validationResult.data;
+        return validationResult.value;
     }
     catch (error) {
         if (error instanceof TypeValidationError) {
             throw error;
         }
-        throw new TypeValidationError({ structure: structure, cause: error });
+        throw new TypeValidationError({ value, cause: error });
     }
 }
 /**
@@ -31,20 +31,20 @@ export function validateTypes({ structure, schema, }) {
  * 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.
+ * @param {string} options.value - The JSON object to validate.
+ * @param {Schema<T>} options.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, }) {
+export function safeValidateTypes({ value, schema, }) {
     try {
-        const validationResult = schema.validate(structure);
+        const validationResult = schema.validate(value);
         if (validationResult.success) {
             return validationResult;
         }
         return {
             success: false,
             error: new TypeValidationError({
-                structure: structure,
+                value,
                 cause: validationResult.error,
             }),
         };
@@ -54,7 +54,7 @@ export function safeValidateTypes({ structure, schema, }) {
             success: false,
             error: error instanceof TypeValidationError
                 ? error
-                : new TypeValidationError({ structure: structure, cause: error }),
+                : new TypeValidationError({ value, cause: error }),
         };
     }
 }

package/model-function/ModelCallEvent.d.ts

@@ -6,8 +6,8 @@ import { ClassifyFinishedEvent, ClassifyStartedEvent } from "./classify/Classify
 import { EmbeddingFinishedEvent, EmbeddingStartedEvent } from "./embed/EmbeddingEvent.js";
 import { ImageGenerationFinishedEvent, ImageGenerationStartedEvent } from "./generate-image/ImageGenerationEvent.js";
 import { SpeechGenerationFinishedEvent, SpeechGenerationStartedEvent, SpeechStreamingFinishedEvent, SpeechStreamingStartedEvent } from "./generate-speech/SpeechGenerationEvent.js";
-import { StructureGenerationFinishedEvent, StructureGenerationStartedEvent } from "./generate-structure/StructureGenerationEvent.js";
-import { StructureStreamingFinishedEvent, StructureStreamingStartedEvent } from "./generate-structure/StructureStreamingEvent.js";
+import { ObjectGenerationFinishedEvent, ObjectGenerationStartedEvent } from "./generate-object/ObjectGenerationEvent.js";
+import { ObjectStreamingFinishedEvent, ObjectStreamingStartedEvent } from "./generate-object/ObjectStreamingEvent.js";
 import { TextGenerationFinishedEvent, TextGenerationStartedEvent, TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextGenerationEvent.js";
 import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./generate-transcription/TranscriptionEvent.js";
 export interface BaseModelCallStartedEvent extends BaseFunctionStartedEvent {
@@ -53,5 +53,5 @@ export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
      */
     result: BaseModelCallFinishedEventResult;
 }
-export type ModelCallStartedEvent = ClassifyStartedEvent | EmbeddingStartedEvent | ImageGenerationStartedEvent | SpeechGenerationStartedEvent | SpeechStreamingStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | ToolCallGenerationStartedEvent | ToolCallsGenerationStartedEvent | TranscriptionStartedEvent;
-export type ModelCallFinishedEvent = ClassifyFinishedEvent | EmbeddingFinishedEvent | ImageGenerationFinishedEvent | SpeechGenerationFinishedEvent | SpeechStreamingFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | ToolCallGenerationFinishedEvent | ToolCallsGenerationFinishedEvent | TranscriptionFinishedEvent;
+export type ModelCallStartedEvent = ClassifyStartedEvent | EmbeddingStartedEvent | ImageGenerationStartedEvent | SpeechGenerationStartedEvent | SpeechStreamingStartedEvent | ObjectGenerationStartedEvent | ObjectStreamingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | ToolCallGenerationStartedEvent | ToolCallsGenerationStartedEvent | TranscriptionStartedEvent;
+export type ModelCallFinishedEvent = ClassifyFinishedEvent | EmbeddingFinishedEvent | ImageGenerationFinishedEvent | SpeechGenerationFinishedEvent | SpeechStreamingFinishedEvent | ObjectGenerationFinishedEvent | ObjectStreamingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | ToolCallGenerationFinishedEvent | ToolCallsGenerationFinishedEvent | TranscriptionFinishedEvent;

package/model-function/PromptTemplate.d.ts

@@ -1,9 +1,9 @@
 /**
- * Prompt templates format a source prompt into the structure of a target prompt.
+ * Prompt templates format a source prompt as a target prompt.
  */
 export interface PromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> {
     /**
-     * Formats the source prompt into the structure of the target prompt.
+     * Formats the source prompt as a target prompt.
      */
     format(sourcePrompt: SOURCE_PROMPT): TARGET_PROMPT;
 }

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructureFromTextGenerationModel = void 0;
+exports.ObjectFromTextGenerationModel = void 0;
 const generateText_js_1 = require("../generate-text/generateText.cjs");
-const StructureParseError_js_1 = require("./StructureParseError.cjs");
-class StructureFromTextGenerationModel {
+const ObjectParseError_js_1 = require("./ObjectParseError.cjs");
+class ObjectFromTextGenerationModel {
     constructor({ model, template, }) {
         Object.defineProperty(this, "model", {
             enumerable: true,
@@ -38,7 +38,7 @@ class StructureFromTextGenerationModel {
         }
         return this.model;
     }
-    async doGenerateStructure(schema, prompt, options) {
+    async doGenerateObject(schema, prompt, options) {
         const { rawResponse, text } = await (0, generateText_js_1.generateText)({
             model: this.getModelWithJsonOutput(schema),
             prompt: this.template.createPrompt(prompt, schema),
@@ -48,22 +48,22 @@ class StructureFromTextGenerationModel {
         try {
             return {
                 rawResponse,
-                value: this.template.extractStructure(text),
+                value: this.template.extractObject(text),
                 valueText: text,
             };
         }
         catch (error) {
-            throw new StructureParseError_js_1.StructureParseError({
+            throw new ObjectParseError_js_1.ObjectParseError({
                 valueText: text,
                 cause: error,
             });
         }
     }
     withSettings(additionalSettings) {
-        return new StructureFromTextGenerationModel({
+        return new ObjectFromTextGenerationModel({
             model: this.model.withSettings(additionalSettings),
             template: this.template,
         });
     }
 }
-exports.StructureFromTextGenerationModel = StructureFromTextGenerationModel;
+exports.ObjectFromTextGenerationModel = ObjectFromTextGenerationModel;

package/model-function/{generate-structure/StructureFromTextGenerationModel.d.ts → generate-object/ObjectFromTextGenerationModel.d.ts}

@@ -2,20 +2,20 @@ import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
 import { Schema } from "../../core/schema/Schema.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../generate-text/TextGenerationModel.js";
-import { StructureFromTextPromptTemplate } from "./StructureFromTextPromptTemplate.js";
-import { StructureGenerationModel } from "./StructureGenerationModel.js";
-export declare class StructureFromTextGenerationModel<SOURCE_PROMPT, TARGET_PROMPT, MODEL extends TextGenerationModel<TARGET_PROMPT, TextGenerationModelSettings>> implements StructureGenerationModel<SOURCE_PROMPT, MODEL["settings"]> {
+import { ObjectFromTextPromptTemplate } from "./ObjectFromTextPromptTemplate.js";
+import { ObjectGenerationModel } from "./ObjectGenerationModel.js";
+export declare class ObjectFromTextGenerationModel<SOURCE_PROMPT, TARGET_PROMPT, MODEL extends TextGenerationModel<TARGET_PROMPT, TextGenerationModelSettings>> implements ObjectGenerationModel<SOURCE_PROMPT, MODEL["settings"]> {
     protected readonly model: MODEL;
-    protected readonly template: StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
+    protected readonly template: ObjectFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
     constructor({ model, template, }: {
         model: MODEL;
-        template: StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
+        template: ObjectFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
     });
     get modelInformation(): import("../ModelInformation.js").ModelInformation;
     get settings(): TextGenerationModelSettings;
     get settingsForEvent(): Partial<MODEL["settings"]>;
     getModelWithJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): MODEL;
-    doGenerateStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<{
+    doGenerateObject(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<{
         rawResponse: unknown;
         value: unknown;
         valueText: string;

package/model-function/{generate-structure/StructureFromTextGenerationModel.js → generate-object/ObjectFromTextGenerationModel.js}

@@ -1,6 +1,6 @@
 import { generateText } from "../generate-text/generateText.js";
-import { StructureParseError } from "./StructureParseError.js";
-export class StructureFromTextGenerationModel {
+import { ObjectParseError } from "./ObjectParseError.js";
+export class ObjectFromTextGenerationModel {
     constructor({ model, template, }) {
         Object.defineProperty(this, "model", {
             enumerable: true,
@@ -35,7 +35,7 @@ export class StructureFromTextGenerationModel {
         }
         return this.model;
     }
-    async doGenerateStructure(schema, prompt, options) {
+    async doGenerateObject(schema, prompt, options) {
         const { rawResponse, text } = await generateText({
             model: this.getModelWithJsonOutput(schema),
             prompt: this.template.createPrompt(prompt, schema),
@@ -45,19 +45,19 @@ export class StructureFromTextGenerationModel {
         try {
             return {
                 rawResponse,
-                value: this.template.extractStructure(text),
+                value: this.template.extractObject(text),
                 valueText: text,
             };
         }
         catch (error) {
-            throw new StructureParseError({
+            throw new ObjectParseError({
                 valueText: text,
                 cause: error,
             });
         }
     }
     withSettings(additionalSettings) {
-        return new StructureFromTextGenerationModel({
+        return new ObjectFromTextGenerationModel({
             model: this.model.withSettings(additionalSettings),
             template: this.template,
         });

package/model-function/{generate-structure/StructureFromTextPromptTemplate.d.ts → generate-object/ObjectFromTextPromptTemplate.d.ts}

@@ -3,9 +3,9 @@ import { Schema } from "../../core/schema/Schema.js";
 import { TextStreamingModel } from "../generate-text/TextGenerationModel.js";
 import { ChatPrompt } from "../generate-text/prompt-template/ChatPrompt.js";
 import { InstructionPrompt } from "../generate-text/prompt-template/InstructionPrompt.js";
-export type StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> = {
+export type ObjectFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> = {
     createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => TARGET_PROMPT;
-    extractStructure: (response: string) => unknown;
+    extractObject: (response: string) => unknown;
     withJsonOutput?({ model, schema, }: {
         model: {
             withJsonOutput(schema: Schema<unknown> & JsonSchemaProducer): typeof model;
@@ -13,9 +13,9 @@ export type StructureFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT> = {
         schema: Schema<unknown> & JsonSchemaProducer;
     }): typeof model;
 };
-export type FlexibleStructureFromTextPromptTemplate<SOURCE_PROMPT, INTERMEDIATE_PROMPT> = {
+export type FlexibleObjectFromTextPromptTemplate<SOURCE_PROMPT, INTERMEDIATE_PROMPT> = {
     createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => INTERMEDIATE_PROMPT;
-    extractStructure: (response: string) => unknown;
+    extractObject: (response: string) => unknown;
     adaptModel: (model: TextStreamingModel<never> & {
         withTextPrompt(): TextStreamingModel<string>;
         withInstructionPrompt(): TextStreamingModel<InstructionPrompt>;

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

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructureFromTextStreamingModel = void 0;
-const streamText_js_1 = require("../../model-function/generate-text/streamText.cjs");
+exports.ObjectFromTextStreamingModel = void 0;
+const streamText_js_1 = require("../generate-text/streamText.cjs");
 const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
-const StructureFromTextGenerationModel_js_1 = require("./StructureFromTextGenerationModel.cjs");
-const parsePartialJson_js_1 = require("./parsePartialJson.cjs");
-class StructureFromTextStreamingModel extends StructureFromTextGenerationModel_js_1.StructureFromTextGenerationModel {
+const parsePartialJson_js_1 = require("../../util/parsePartialJson.cjs");
+const ObjectFromTextGenerationModel_js_1 = require("./ObjectFromTextGenerationModel.cjs");
+class ObjectFromTextStreamingModel extends ObjectFromTextGenerationModel_js_1.ObjectFromTextGenerationModel {
     constructor(options) {
         super(options);
     }
-    async doStreamStructure(schema, prompt, options) {
+    async doStreamObject(schema, prompt, options) {
         const textStream = await (0, streamText_js_1.streamText)({
             model: this.getModelWithJsonOutput(schema),
             prompt: this.template.createPrompt(prompt, schema),
@@ -32,17 +32,17 @@ class StructureFromTextStreamingModel extends StructureFromTextGenerationModel_j
         })();
         return queue;
     }
-    extractStructureTextDelta(delta) {
+    extractObjectTextDelta(delta) {
         return delta;
     }
-    parseAccumulatedStructureText(accumulatedText) {
+    parseAccumulatedObjectText(accumulatedText) {
         return (0, parsePartialJson_js_1.parsePartialJson)(accumulatedText);
     }
     withSettings(additionalSettings) {
-        return new StructureFromTextStreamingModel({
+        return new ObjectFromTextStreamingModel({
             model: this.model.withSettings(additionalSettings),
             template: this.template,
         });
     }
 }
-exports.StructureFromTextStreamingModel = StructureFromTextStreamingModel;
+exports.ObjectFromTextStreamingModel = ObjectFromTextStreamingModel;

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

@@ -0,0 +1,19 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../core/schema/Schema.js";
+import { Delta } from "../Delta.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
+import { TextGenerationModelSettings, TextStreamingModel } from "../generate-text/TextGenerationModel.js";
+import { ObjectFromTextGenerationModel } from "./ObjectFromTextGenerationModel.js";
+import { ObjectFromTextPromptTemplate } from "./ObjectFromTextPromptTemplate.js";
+import { ObjectStreamingModel } from "./ObjectGenerationModel.js";
+export declare class ObjectFromTextStreamingModel<SOURCE_PROMPT, TARGET_PROMPT, MODEL extends TextStreamingModel<TARGET_PROMPT, TextGenerationModelSettings>> extends ObjectFromTextGenerationModel<SOURCE_PROMPT, TARGET_PROMPT, MODEL> implements ObjectStreamingModel<SOURCE_PROMPT, MODEL["settings"]> {
+    constructor(options: {
+        model: MODEL;
+        template: ObjectFromTextPromptTemplate<SOURCE_PROMPT, TARGET_PROMPT>;
+    });
+    doStreamObject(schema: Schema<unknown> & JsonSchemaProducer, prompt: SOURCE_PROMPT, options?: FunctionOptions): Promise<AsyncQueue<Delta<string>>>;
+    extractObjectTextDelta(delta: unknown): string;
+    parseAccumulatedObjectText(accumulatedText: string): unknown;
+    withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
+}

package/model-function/{generate-structure/StructureFromTextStreamingModel.js → generate-object/ObjectFromTextStreamingModel.js}

@@ -1,12 +1,12 @@
-import { streamText } from "../../model-function/generate-text/streamText.js";
+import { streamText } from "../generate-text/streamText.js";
 import { AsyncQueue } from "../../util/AsyncQueue.js";
-import { StructureFromTextGenerationModel } from "./StructureFromTextGenerationModel.js";
-import { parsePartialJson } from "./parsePartialJson.js";
-export class StructureFromTextStreamingModel extends StructureFromTextGenerationModel {
+import { parsePartialJson } from "../../util/parsePartialJson.js";
+import { ObjectFromTextGenerationModel } from "./ObjectFromTextGenerationModel.js";
+export class ObjectFromTextStreamingModel extends ObjectFromTextGenerationModel {
     constructor(options) {
         super(options);
     }
-    async doStreamStructure(schema, prompt, options) {
+    async doStreamObject(schema, prompt, options) {
         const textStream = await streamText({
             model: this.getModelWithJsonOutput(schema),
             prompt: this.template.createPrompt(prompt, schema),
@@ -29,14 +29,14 @@ export class StructureFromTextStreamingModel extends StructureFromTextGeneration
         })();
         return queue;
     }
-    extractStructureTextDelta(delta) {
+    extractObjectTextDelta(delta) {
         return delta;
     }
-    parseAccumulatedStructureText(accumulatedText) {
+    parseAccumulatedObjectText(accumulatedText) {
         return parsePartialJson(accumulatedText);
     }
     withSettings(additionalSettings) {
-        return new StructureFromTextStreamingModel({
+        return new ObjectFromTextStreamingModel({
             model: this.model.withSettings(additionalSettings),
             template: this.template,
         });

package/model-function/{generate-structure/StructureGenerationEvent.d.ts → generate-object/ObjectGenerationEvent.d.ts}

@@ -1,8 +1,8 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export interface StructureGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "generate-structure";
+export interface ObjectGenerationStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "generate-object";
 }
-export type StructureGenerationFinishedEventResult = {
+export type ObjectGenerationFinishedEventResult = {
     status: "success";
     rawResponse: unknown;
     value: unknown;
@@ -17,7 +17,7 @@ export type StructureGenerationFinishedEventResult = {
 } | {
     status: "abort";
 };
-export type StructureGenerationFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "generate-structure";
-    result: StructureGenerationFinishedEventResult;
+export type ObjectGenerationFinishedEvent = BaseModelCallFinishedEvent & {
+    functionType: "generate-object";
+    result: ObjectGenerationFinishedEventResult;
 };

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

@@ -0,0 +1,24 @@
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Schema } from "../../core/schema/Schema.js";
+import { Delta } from "../Delta.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface ObjectGenerationModelSettings extends ModelSettings {
+}
+export interface ObjectGenerationModel<PROMPT, SETTINGS extends ObjectGenerationModelSettings = ObjectGenerationModelSettings> extends Model<SETTINGS> {
+    doGenerateObject(schema: Schema<unknown> & JsonSchemaProducer, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+        rawResponse: unknown;
+        valueText: string;
+        value: unknown;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+}
+export interface ObjectStreamingModel<PROMPT, SETTINGS extends ObjectGenerationModelSettings = ObjectGenerationModelSettings> extends ObjectGenerationModel<PROMPT, SETTINGS> {
+    doStreamObject(schema: Schema<unknown> & JsonSchemaProducer, prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<unknown>>>;
+    extractObjectTextDelta(delta: unknown): string | undefined;
+    parseAccumulatedObjectText(accumulatedText: string): unknown;
+}

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructureParseError = void 0;
+exports.ObjectParseError = void 0;
 const getErrorMessage_js_1 = require("../../util/getErrorMessage.cjs");
-class StructureParseError extends Error {
+class ObjectParseError extends Error {
     constructor({ valueText, cause }) {
-        super(`Structure parsing failed. ` +
+        super(`Object parsing failed. ` +
             `Value: ${valueText}.\n` +
             `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
         Object.defineProperty(this, "cause", {
@@ -19,7 +19,7 @@ class StructureParseError extends Error {
             writable: true,
             value: void 0
         });
-        this.name = "StructureParseError";
+        this.name = "ObjectParseError";
         this.cause = cause;
         this.valueText = valueText;
     }
@@ -33,4 +33,4 @@ class StructureParseError extends Error {
         };
     }
 }
-exports.StructureParseError = StructureParseError;
+exports.ObjectParseError = ObjectParseError;

package/model-function/{generate-structure/StructureParseError.d.ts → generate-object/ObjectParseError.d.ts}

@@ -1,4 +1,4 @@
-export declare class StructureParseError extends Error {
+export declare class ObjectParseError extends Error {
     readonly cause: unknown;
     readonly valueText: string;
     constructor({ valueText, cause }: {

package/model-function/{generate-structure/StructureParseError.js → generate-object/ObjectParseError.js}

@@ -1,7 +1,7 @@
 import { getErrorMessage } from "../../util/getErrorMessage.js";
-export class StructureParseError extends Error {
+export class ObjectParseError extends Error {
     constructor({ valueText, cause }) {
-        super(`Structure parsing failed. ` +
+        super(`Object parsing failed. ` +
             `Value: ${valueText}.\n` +
             `Error message: ${getErrorMessage(cause)}`);
         Object.defineProperty(this, "cause", {
@@ -16,7 +16,7 @@ export class StructureParseError extends Error {
             writable: true,
             value: void 0
         });
-        this.name = "StructureParseError";
+        this.name = "ObjectParseError";
         this.cause = cause;
         this.valueText = valueText;
     }

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectStreamFromResponse = exports.ObjectStreamResponse = void 0;
+const parsePartialJson_js_1 = require("../../util/parsePartialJson.cjs");
+class ObjectStreamResponse extends Response {
+    constructor(stream, init) {
+        super(ObjectStreamToTextStream(stream), {
+            ...init,
+            status: 200,
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+        });
+    }
+}
+exports.ObjectStreamResponse = ObjectStreamResponse;
+async function* ObjectStreamFromResponse({ response, }) {
+    let text = "";
+    const reader = response.body.getReader();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        text += new TextDecoder().decode(value);
+        const partialObject = (0, parsePartialJson_js_1.parsePartialJson)(text);
+        yield { partialObject };
+    }
+}
+exports.ObjectStreamFromResponse = ObjectStreamFromResponse;
+function ObjectStreamToTextStream(stream) {
+    const textEncoder = new TextEncoder();
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const { textDelta } of stream) {
+                    controller.enqueue(textEncoder.encode(textDelta));
+                }
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+}

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

@@ -0,0 +1,18 @@
+import type { PartialDeep } from "type-fest";
+import { Schema } from "../../core/schema/Schema.js";
+export type ObjectStream<OBJECT> = AsyncIterable<{
+    partialObject: PartialDeep<OBJECT, {
+        recurseIntoArrays: true;
+    }>;
+    partialText: string;
+    textDelta: string;
+}>;
+export declare class ObjectStreamResponse extends Response {
+    constructor(stream: ObjectStream<unknown>, init?: ResponseInit);
+}
+export declare function ObjectStreamFromResponse<OBJECT>({ response, }: {
+    schema: Schema<OBJECT>;
+    response: Response;
+}): AsyncGenerator<{
+    partialObject: OBJECT;
+}, void, unknown>;

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

@@ -0,0 +1,38 @@
+import { parsePartialJson } from "../../util/parsePartialJson.js";
+export class ObjectStreamResponse extends Response {
+    constructor(stream, init) {
+        super(ObjectStreamToTextStream(stream), {
+            ...init,
+            status: 200,
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+        });
+    }
+}
+export async function* ObjectStreamFromResponse({ response, }) {
+    let text = "";
+    const reader = response.body.getReader();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        text += new TextDecoder().decode(value);
+        const partialObject = parsePartialJson(text);
+        yield { partialObject };
+    }
+}
+function ObjectStreamToTextStream(stream) {
+    const textEncoder = new TextEncoder();
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const { textDelta } of stream) {
+                    controller.enqueue(textEncoder.encode(textDelta));
+                }
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+}

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

@@ -0,0 +1,7 @@
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export interface ObjectStreamingStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "stream-object";
+}
+export interface ObjectStreamingFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "stream-object";
+}

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructureValidationError = void 0;
+exports.ObjectValidationError = void 0;
 const getErrorMessage_js_1 = require("../../util/getErrorMessage.cjs");
-class StructureValidationError extends Error {
+class ObjectValidationError extends Error {
     constructor({ value, valueText, cause, }) {
-        super(`Structure validation failed. ` +
+        super(`Object validation failed. ` +
             `Value: ${valueText}.\n` +
             `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
         Object.defineProperty(this, "cause", {
@@ -25,7 +25,7 @@ class StructureValidationError extends Error {
             writable: true,
             value: void 0
         });
-        this.name = "StructureValidationError";
+        this.name = "ObjectValidationError";
         this.cause = cause;
         this.value = value;
         this.valueText = valueText;
@@ -41,4 +41,4 @@ class StructureValidationError extends Error {
         };
     }
 }
-exports.StructureValidationError = StructureValidationError;
+exports.ObjectValidationError = ObjectValidationError;

package/model-function/{generate-structure/StructureValidationError.d.ts → generate-object/ObjectValidationError.d.ts}

@@ -1,4 +1,4 @@
-export declare class StructureValidationError extends Error {
+export declare class ObjectValidationError extends Error {
     readonly cause: unknown;
     readonly valueText: string;
     readonly value: unknown;

package/model-function/{generate-structure/StructureValidationError.js → generate-object/ObjectValidationError.js}

@@ -1,7 +1,7 @@
 import { getErrorMessage } from "../../util/getErrorMessage.js";
-export class StructureValidationError extends Error {
+export class ObjectValidationError extends Error {
     constructor({ value, valueText, cause, }) {
-        super(`Structure validation failed. ` +
+        super(`Object validation failed. ` +
             `Value: ${valueText}.\n` +
             `Error message: ${getErrorMessage(cause)}`);
         Object.defineProperty(this, "cause", {
@@ -22,7 +22,7 @@ export class StructureValidationError extends Error {
             writable: true,
             value: void 0
         });
-        this.name = "StructureValidationError";
+        this.name = "ObjectValidationError";
         this.cause = cause;
         this.value = value;
         this.valueText = valueText;