modelfusion 0.29.1 → 0.30.1

package/tool/useTool.js

@@ -1,17 +1,17 @@
-import { generateJson } from "../model-function/generate-json/generateJson.js";
+import { generateStructure } from "../model-function/generate-structure/generateStructure.js";
 import { executeTool } from "./executeTool.js";
 // In this file, using 'any' is required to allow for flexibility in the inputs. The actual types are
 // retrieved through lookups such as TOOL["name"], such that any does not affect any client.
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
- * `useTool` uses `generateJson` to generate parameters for a tool and then executes the tool with the parameters.
+ * `useTool` uses `generateStructure` to generate parameters for a tool and then executes the tool with the parameters.
  *
  * @returns The result contains the name of the tool (`tool` property),
  * the parameters (`parameters` property, typed),
  * and the result of the tool execution (`result` property, typed).
  */
 export async function useTool(model, tool, prompt, options) {
-    const { output: value } = await generateJson(model, {
+    const { output: value } = await generateStructure(model, {
         name: tool.name,
         description: tool.description,
         schema: tool.inputSchema,

package/tool/useToolOrGenerateText.cjs

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useToolOrGenerateText = void 0;
-const generateJsonOrText_js_1 = require("../model-function/generate-json/generateJsonOrText.cjs");
+const generateStructureOrText_js_1 = require("../model-function/generate-structure/generateStructureOrText.cjs");
 const NoSuchToolError_js_1 = require("./NoSuchToolError.cjs");
 const executeTool_js_1 = require("./executeTool.cjs");
 async function useToolOrGenerateText(model, tools, prompt, options) {
     const expandedPrompt = prompt(tools);
-    const modelResponse = await (0, generateJsonOrText_js_1.generateJsonOrText)(model, tools.map((tool) => ({
+    const modelResponse = await (0, generateStructureOrText_js_1.generateStructureOrText)(model, tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
         schema: tool.inputSchema,
     })), () => expandedPrompt, options);
-    const { schema, text } = modelResponse;
-    if (schema == null) {
+    const { structure, text } = modelResponse;
+    if (structure == null) {
         return {
             tool: null,
             parameters: null,
@@ -20,14 +20,14 @@ async function useToolOrGenerateText(model, tools, prompt, options) {
             text,
         };
     }
-    const tool = tools.find((tool) => tool.name === schema);
+    const tool = tools.find((tool) => tool.name === structure);
     if (tool == null) {
-        throw new NoSuchToolError_js_1.NoSuchToolError(schema.toString());
+        throw new NoSuchToolError_js_1.NoSuchToolError(structure.toString());
     }
     const toolParameters = modelResponse.value;
     const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, options);
     return {
-        tool: schema,
+        tool: structure,
         result,
         parameters: toolParameters,
         text: text, // string | null is the expected value here

package/tool/useToolOrGenerateText.d.ts

@@ -1,5 +1,5 @@
 import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
-import { JsonOrTextGenerationModel, JsonOrTextGenerationModelSettings, JsonOrTextGenerationPrompt } from "../model-function/generate-json/JsonOrTextGenerationModel.js";
+import { StructureOrTextGenerationModel, StructureOrTextGenerationModelSettings, StructureOrTextGenerationPrompt } from "../model-function/generate-structure/StructureOrTextGenerationModel.js";
 import { Tool } from "./Tool.js";
 type ToolArray<T extends Tool<any, any, any>[]> = T;
 type ToToolMap<T extends ToolArray<Tool<any, any, any>[]>> = {
@@ -14,7 +14,7 @@ type ToToolUnion<T> = {
     } : never;
 }[keyof T];
 type ToOutputValue<TOOLS extends ToolArray<Tool<any, any, any>[]>> = ToToolUnion<ToToolMap<TOOLS>>;
-export declare function useToolOrGenerateText<PROMPT, RESPONSE, SETTINGS extends JsonOrTextGenerationModelSettings, TOOLS extends Array<Tool<any, any, any>>>(model: JsonOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS>, tools: TOOLS, prompt: (tools: TOOLS) => PROMPT & JsonOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): Promise<{
+export declare function useToolOrGenerateText<PROMPT, RESPONSE, SETTINGS extends StructureOrTextGenerationModelSettings, TOOLS extends Array<Tool<any, any, any>>>(model: StructureOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS>, tools: TOOLS, prompt: (tools: TOOLS) => PROMPT & StructureOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): Promise<{
     tool: null;
     parameters: null;
     result: null;

package/tool/useToolOrGenerateText.js

@@ -1,15 +1,15 @@
-import { generateJsonOrText } from "../model-function/generate-json/generateJsonOrText.js";
+import { generateStructureOrText } from "../model-function/generate-structure/generateStructureOrText.js";
 import { NoSuchToolError } from "./NoSuchToolError.js";
 import { executeTool } from "./executeTool.js";
 export async function useToolOrGenerateText(model, tools, prompt, options) {
     const expandedPrompt = prompt(tools);
-    const modelResponse = await generateJsonOrText(model, tools.map((tool) => ({
+    const modelResponse = await generateStructureOrText(model, tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
         schema: tool.inputSchema,
     })), () => expandedPrompt, options);
-    const { schema, text } = modelResponse;
-    if (schema == null) {
+    const { structure, text } = modelResponse;
+    if (structure == null) {
         return {
             tool: null,
             parameters: null,
@@ -17,14 +17,14 @@ export async function useToolOrGenerateText(model, tools, prompt, options) {
             text,
         };
     }
-    const tool = tools.find((tool) => tool.name === schema);
+    const tool = tools.find((tool) => tool.name === structure);
     if (tool == null) {
-        throw new NoSuchToolError(schema.toString());
+        throw new NoSuchToolError(structure.toString());
     }
     const toolParameters = modelResponse.value;
     const result = await executeTool(tool, toolParameters, options);
     return {
-        tool: schema,
+        tool: structure,
         result,
         parameters: toolParameters,
         text: text, // string | null is the expected value here

package/util/getErrorMessage.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMessage = void 0;
+function getErrorMessage(error) {
+    if (typeof error === "string") {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return JSON.stringify(error);
+}
+exports.getErrorMessage = getErrorMessage;

package/util/getErrorMessage.d.ts

@@ -0,0 +1 @@
+export declare function getErrorMessage(error: unknown): string;

package/util/getErrorMessage.js

@@ -0,0 +1,9 @@
+export function getErrorMessage(error) {
+    if (typeof error === "string") {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return JSON.stringify(error);
+}

package/model-function/generate-json/InstructionWithSchemaPrompt.cjs

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InstructionWithSchemaPrompt = void 0;
-exports.InstructionWithSchemaPrompt = {
-    forSchema({ instruction, schemaDefinition, }) {
-        return { schemaDefinition, instruction };
-    },
-    forTool({ instruction, tool, }) {
-        return exports.InstructionWithSchemaPrompt.forSchema({
-            instruction,
-            schemaDefinition: tool.inputSchemaDefinition,
-        });
-    },
-    forToolCurried(instruction) {
-        return (tool) => this.forTool({ instruction, tool });
-    },
-};

package/model-function/generate-json/InstructionWithSchemaPrompt.d.ts

@@ -1,26 +0,0 @@
-import { Tool } from "../../tool/Tool.js";
-import { SchemaDefinition } from "./SchemaDefinition.js";
-export type InstructionWithSchema<NAME extends string, STRUCTURE> = {
-    instruction: string;
-    schemaDefinition: SchemaDefinition<NAME, STRUCTURE>;
-};
-export declare const InstructionWithSchemaPrompt: {
-    forSchema<STRUCTURE>({ instruction, schemaDefinition, }: {
-        instruction: string;
-        schemaDefinition: SchemaDefinition<string, STRUCTURE>;
-    }): {
-        schemaDefinition: SchemaDefinition<string, STRUCTURE>;
-        instruction: string;
-    };
-    forTool<INPUT, OUTPUT>({ instruction, tool, }: {
-        instruction: string;
-        tool: Tool<string, INPUT, OUTPUT>;
-    }): {
-        schemaDefinition: SchemaDefinition<string, INPUT>;
-        instruction: string;
-    };
-    forToolCurried<INPUT_1, OUTPUT_1>(instruction: string): (tool: Tool<string, INPUT_1, OUTPUT_1>) => {
-        schemaDefinition: SchemaDefinition<string, INPUT_1>;
-        instruction: string;
-    };
-};

package/model-function/generate-json/InstructionWithSchemaPrompt.js

@@ -1,14 +0,0 @@
-export const InstructionWithSchemaPrompt = {
-    forSchema({ instruction, schemaDefinition, }) {
-        return { schemaDefinition, instruction };
-    },
-    forTool({ instruction, tool, }) {
-        return InstructionWithSchemaPrompt.forSchema({
-            instruction,
-            schemaDefinition: tool.inputSchemaDefinition,
-        });
-    },
-    forToolCurried(instruction) {
-        return (tool) => this.forTool({ instruction, tool });
-    },
-};

package/model-function/generate-json/JsonGenerationEvent.d.ts

@@ -1,23 +0,0 @@
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export interface JsonGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "json-generation" | "json-or-text-generation";
-}
-export type JsonGenerationFinishedEventResult = {
-    status: "success";
-    response: unknown;
-    output: unknown;
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-} | {
-    status: "error";
-    error: unknown;
-} | {
-    status: "abort";
-};
-export type JsonGenerationFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "json-generation" | "json-or-text-generation";
-    result: JsonGenerationFinishedEventResult;
-};

package/model-function/generate-json/JsonGenerationModel.d.ts

@@ -1,13 +0,0 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
-import { Model, ModelSettings } from "../Model.js";
-export interface JsonGenerationModelSettings extends ModelSettings {
-}
-export interface JsonGenerationModel<PROMPT, RESPONSE, SETTINGS extends JsonGenerationModelSettings> extends Model<SETTINGS> {
-    generateJsonResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
-    extractJson(response: RESPONSE): unknown;
-    extractUsage?(response: RESPONSE): {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-}

package/model-function/generate-json/JsonOrTextGenerationModel.d.ts

@@ -1,23 +0,0 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
-import { Model, ModelSettings } from "../Model.js";
-export interface JsonOrTextGenerationModelSettings extends ModelSettings {
-}
-export interface JsonOrTextGenerationPrompt<RESPONSE> {
-    extractJsonAndText(response: RESPONSE): {
-        schema: null;
-        value: null;
-        text: string;
-    } | {
-        schema: string;
-        value: unknown;
-        text: string | null;
-    };
-}
-export interface JsonOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS extends JsonOrTextGenerationModelSettings> extends Model<SETTINGS> {
-    generateJsonResponse(prompt: PROMPT & JsonOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
-    extractUsage?(response: RESPONSE): {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-}

package/model-function/generate-json/JsonTextGenerationModel.d.ts

@@ -1,26 +0,0 @@
-import { TextGenerationModel, TextGenerationModelSettings } from "../generate-text/TextGenerationModel.js";
-import { SchemaDefinition } from "./SchemaDefinition.js";
-import { InstructionWithSchema } from "./InstructionWithSchemaPrompt.js";
-import { JsonGenerationModel } from "./JsonGenerationModel.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
-export type JsonTextPromptFormat = {
-    createPrompt: (prompt: {
-        instruction: string;
-        schemaDefinition: SchemaDefinition<string, unknown>;
-    }) => string;
-    extractJson: (response: string) => unknown;
-};
-export declare class JsonTextGenerationModel<MODEL extends TextGenerationModel<string, any, any, TextGenerationModelSettings>> implements JsonGenerationModel<InstructionWithSchema<string, unknown>, string, MODEL["settings"]> {
-    private readonly model;
-    private readonly format;
-    constructor({ model, format, }: {
-        model: MODEL;
-        format: JsonTextPromptFormat;
-    });
-    get modelInformation(): import("../ModelInformation.js").ModelInformation;
-    get settings(): TextGenerationModelSettings;
-    get settingsForEvent(): Partial<MODEL["settings"]>;
-    generateJsonResponse(prompt: InstructionWithSchema<string, unknown>, options?: ModelFunctionOptions<MODEL["settings"]> | undefined): Promise<string>;
-    extractJson(response: string): unknown;
-    withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
-}

package/model-function/generate-json/NoSuchSchemaError.cjs

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoSuchSchemaError = void 0;
-class NoSuchSchemaError extends Error {
-    constructor(schemaName) {
-        super(`No such schema: ${schemaName}`);
-        Object.defineProperty(this, "schemaName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "NoSuchSchemaError";
-        this.schemaName = schemaName;
-    }
-}
-exports.NoSuchSchemaError = NoSuchSchemaError;

package/model-function/generate-json/NoSuchSchemaError.d.ts

@@ -1,4 +0,0 @@
-export declare class NoSuchSchemaError extends Error {
-    readonly schemaName: string;
-    constructor(schemaName: string);
-}

package/model-function/generate-json/NoSuchSchemaError.js

@@ -1,13 +0,0 @@
-export class NoSuchSchemaError extends Error {
-    constructor(schemaName) {
-        super(`No such schema: ${schemaName}`);
-        Object.defineProperty(this, "schemaName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "NoSuchSchemaError";
-        this.schemaName = schemaName;
-    }
-}

package/model-function/generate-json/SchemaDefinition.d.ts

@@ -1,6 +0,0 @@
-import { z } from "zod";
-export type SchemaDefinition<NAME extends string, STRUCTURE> = {
-    name: NAME;
-    description?: string;
-    schema: z.Schema<STRUCTURE>;
-};

package/model-function/generate-json/SchemaValidationError.cjs

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaValidationError = void 0;
-class SchemaValidationError extends Error {
-    constructor({ schemaName, value, errors, }) {
-        super(`Schema validation error for '${schemaName}'. ` +
-            `Value: ${JSON.stringify(value)}.\n` +
-            `Error details: ${errors.message}\n` +
-            `Error field(s): ${errors.errors
-                .map((err) => err.path.join("."))
-                .join(", ")}`);
-        Object.defineProperty(this, "schemaName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "errors", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "SchemaValidationError";
-        this.schemaName = schemaName;
-        this.errors = errors;
-        this.value = value;
-    }
-}
-exports.SchemaValidationError = SchemaValidationError;

package/model-function/generate-json/SchemaValidationError.d.ts

@@ -1,11 +0,0 @@
-import { z } from "zod";
-export declare class SchemaValidationError extends Error {
-    readonly schemaName: string;
-    readonly errors: z.ZodError;
-    readonly value: unknown;
-    constructor({ schemaName, value, errors, }: {
-        schemaName: string;
-        value: unknown;
-        errors: z.ZodError;
-    });
-}

package/model-function/generate-json/SchemaValidationError.js

@@ -1,32 +0,0 @@
-export class SchemaValidationError extends Error {
-    constructor({ schemaName, value, errors, }) {
-        super(`Schema validation error for '${schemaName}'. ` +
-            `Value: ${JSON.stringify(value)}.\n` +
-            `Error details: ${errors.message}\n` +
-            `Error field(s): ${errors.errors
-                .map((err) => err.path.join("."))
-                .join(", ")}`);
-        Object.defineProperty(this, "schemaName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "errors", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "SchemaValidationError";
-        this.schemaName = schemaName;
-        this.errors = errors;
-        this.value = value;
-    }
-}

package/model-function/generate-json/generateJson.cjs

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateJson = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
-const SchemaValidationError_js_1 = require("./SchemaValidationError.cjs");
-function generateJson(model, schemaDefinition, prompt, options) {
-    const expandedPrompt = prompt(schemaDefinition);
-    return (0, executeCall_js_1.executeCall)({
-        functionType: "json-generation",
-        input: expandedPrompt,
-        model,
-        options,
-        generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
-        extractOutputValue: (response) => {
-            const json = model.extractJson(response);
-            const parseResult = schemaDefinition.schema.safeParse(json);
-            if (!parseResult.success) {
-                throw new SchemaValidationError_js_1.SchemaValidationError({
-                    schemaName: schemaDefinition.name,
-                    value: json,
-                    errors: parseResult.error,
-                });
-            }
-            return parseResult.data;
-        },
-        extractUsage: (result) => model.extractUsage?.(result),
-    });
-}
-exports.generateJson = generateJson;

package/model-function/generate-json/generateJson.d.ts

@@ -1,5 +0,0 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
-import { ModelFunctionPromise } from "../executeCall.js";
-import { JsonGenerationModel, JsonGenerationModelSettings } from "./JsonGenerationModel.js";
-import { SchemaDefinition } from "./SchemaDefinition.js";
-export declare function generateJson<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends JsonGenerationModelSettings>(model: JsonGenerationModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinition: SchemaDefinition<NAME, STRUCTURE>, prompt: (schemaDefinition: SchemaDefinition<NAME, STRUCTURE>) => PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<STRUCTURE, RESPONSE>;

package/model-function/generate-json/generateJson.js

@@ -1,25 +0,0 @@
-import { executeCall } from "../executeCall.js";
-import { SchemaValidationError } from "./SchemaValidationError.js";
-export function generateJson(model, schemaDefinition, prompt, options) {
-    const expandedPrompt = prompt(schemaDefinition);
-    return executeCall({
-        functionType: "json-generation",
-        input: expandedPrompt,
-        model,
-        options,
-        generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
-        extractOutputValue: (response) => {
-            const json = model.extractJson(response);
-            const parseResult = schemaDefinition.schema.safeParse(json);
-            if (!parseResult.success) {
-                throw new SchemaValidationError({
-                    schemaName: schemaDefinition.name,
-                    value: json,
-                    errors: parseResult.error,
-                });
-            }
-            return parseResult.data;
-        },
-        extractUsage: (result) => model.extractUsage?.(result),
-    });
-}

package/model-function/generate-json/generateJsonOrText.cjs

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateJsonOrText = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
-const NoSuchSchemaError_js_1 = require("./NoSuchSchemaError.cjs");
-const SchemaValidationError_js_1 = require("./SchemaValidationError.cjs");
-function generateJsonOrText(model, schemaDefinitions, prompt, options) {
-    const expandedPrompt = prompt(schemaDefinitions);
-    return (0, executeCall_js_1.executeCall)({
-        functionType: "json-or-text-generation",
-        input: expandedPrompt,
-        model,
-        options,
-        generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
-        extractOutputValue: (response) => {
-            const { schema, value, text } = expandedPrompt.extractJsonAndText(response);
-            // text generation:
-            if (schema == null) {
-                return { schema, value, text };
-            }
-            const definition = schemaDefinitions.find((d) => d.name === schema);
-            if (definition == undefined) {
-                throw new NoSuchSchemaError_js_1.NoSuchSchemaError(schema);
-            }
-            const parseResult = definition.schema.safeParse(value);
-            if (!parseResult.success) {
-                throw new SchemaValidationError_js_1.SchemaValidationError({
-                    schemaName: schema,
-                    value,
-                    errors: parseResult.error,
-                });
-            }
-            return {
-                schema: schema,
-                value: parseResult.data,
-                text: text, // text is string | null, which is part of the response for schema values
-            };
-        },
-        extractUsage: (result) => model.extractUsage?.(result),
-    });
-}
-exports.generateJsonOrText = generateJsonOrText;

package/model-function/generate-json/generateJsonOrText.d.ts

@@ -1,22 +0,0 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
-import { ModelFunctionPromise } from "../executeCall.js";
-import { JsonOrTextGenerationModel, JsonOrTextGenerationModelSettings, JsonOrTextGenerationPrompt } from "./JsonOrTextGenerationModel.js";
-import { SchemaDefinition } from "./SchemaDefinition.js";
-type SchemaDefinitionArray<T extends SchemaDefinition<any, any>[]> = T;
-type ToSchemaDefinitionsMap<T extends SchemaDefinitionArray<SchemaDefinition<any, any>[]>> = {
-    [K in T[number]["name"]]: Extract<T[number], SchemaDefinition<K, any>>;
-};
-type ToSchemaUnion<T> = {
-    [KEY in keyof T]: T[KEY] extends SchemaDefinition<any, infer SCHEMA> ? {
-        schema: KEY;
-        value: SCHEMA;
-        text: string | null;
-    } : never;
-}[keyof T];
-type ToOutputValue<SCHEMAS extends SchemaDefinitionArray<SchemaDefinition<any, any>[]>> = ToSchemaUnion<ToSchemaDefinitionsMap<SCHEMAS>>;
-export declare function generateJsonOrText<SCHEMAS extends SchemaDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends JsonOrTextGenerationModelSettings>(model: JsonOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinitions: SCHEMAS, prompt: (schemaDefinitions: SCHEMAS) => PROMPT & JsonOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<{
-    schema: null;
-    value: null;
-    text: string;
-} | ToOutputValue<SCHEMAS>, RESPONSE>;
-export {};

package/model-function/generate-json/generateJsonOrText.js

@@ -1,38 +0,0 @@
-import { executeCall } from "../executeCall.js";
-import { NoSuchSchemaError } from "./NoSuchSchemaError.js";
-import { SchemaValidationError } from "./SchemaValidationError.js";
-export function generateJsonOrText(model, schemaDefinitions, prompt, options) {
-    const expandedPrompt = prompt(schemaDefinitions);
-    return executeCall({
-        functionType: "json-or-text-generation",
-        input: expandedPrompt,
-        model,
-        options,
-        generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
-        extractOutputValue: (response) => {
-            const { schema, value, text } = expandedPrompt.extractJsonAndText(response);
-            // text generation:
-            if (schema == null) {
-                return { schema, value, text };
-            }
-            const definition = schemaDefinitions.find((d) => d.name === schema);
-            if (definition == undefined) {
-                throw new NoSuchSchemaError(schema);
-            }
-            const parseResult = definition.schema.safeParse(value);
-            if (!parseResult.success) {
-                throw new SchemaValidationError({
-                    schemaName: schema,
-                    value,
-                    errors: parseResult.error,
-                });
-            }
-            return {
-                schema: schema,
-                value: parseResult.data,
-                text: text, // text is string | null, which is part of the response for schema values
-            };
-        },
-        extractUsage: (result) => model.extractUsage?.(result),
-    });
-}