modelfusion 0.19.0 → 0.20.1

package/README.md

@@ -106,20 +106,19 @@ const textStream = await streamText(
 
 #### Metadata and original responses
 
-ModelFusion model functions return rich results that include the original response and metadata when you set the `fullResponse` option to `true`.
+ModelFusion model functions return rich results that include the original response and metadata when you call `.asFullResponse()` before resolving the promise.
 
 ```ts
 // access the full response and the metadata:
 // the response type is specific to the model that's being used
-const { response, metadata } = await generateText(
+const { output, response, metadata } = await generateText(
   new OpenAITextGenerationModel({
     model: "text-davinci-003",
     maxCompletionTokens: 1000,
     n: 2, // generate 2 completions
   }),
-  "Write a short story about a robot learning to love:\n\n",
-  { fullResponse: true }
-);
+  "Write a short story about a robot learning to love:\n\n"
+).asFullResponse();
 
 for (const choice of response.choices) {
   console.log(choice.text);
@@ -253,7 +252,7 @@ Text is generated as a fallback.
 ```ts
 const { tool, parameters, result, text } = await useToolOrGenerateText(
   new OpenAIChatModel({ model: "gpt-3.5-turbo" }),
-  [calculator /* ... */],
+  [calculator /* and other tools... */],
   OpenAIChatFunctionPrompt.forToolsCurried([
     OpenAIChatMessage.user("What's fourteen times twelve?"),
   ])

package/model-function/embed-text/embedText.cjs

@@ -2,8 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.embedText = exports.embedTexts = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
-async function embedTexts(model, texts, options) {
-    const result = await (0, executeCall_js_1.executeCall)({
+/**
+ * Generate embeddings for multiple texts.
+ *
+ * @example
+ * const embeddings = await embedTexts(
+ *   new OpenAITextEmbeddingModel(...),
+ *   [
+ *     "At first, Nox didn't know what to do with the pup.",
+ *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
+ *   ]
+ * );
+ */
+function embedTexts(model, texts, options) {
+    return (0, executeCall_js_1.executeCall)({
         model,
         options,
         generateResponse: (options) => {
@@ -53,24 +65,58 @@ async function embedTexts(model, texts, options) {
             generatedEmbeddings: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            embeddings: result.output,
-            metadata: result.metadata,
-        }
-        : result.output;
 }
 exports.embedTexts = embedTexts;
-async function embedText(model, text, options) {
-    const result = await embedTexts(model, [text], {
-        ...(options ?? {}),
-        fullResponse: true,
+/**
+ * Generate an embedding for a single text.
+ *
+ * @example
+ * const embedding = await embedText(
+ *   new OpenAITextEmbeddingModel(...),
+ *   "At first, Nox didn't know what to do with the pup."
+ * );
+ */
+function embedText(model, text, options) {
+    const texts = [text];
+    return (0, executeCall_js_1.executeCall)({
+        model,
+        options,
+        generateResponse: (options) => {
+            return model.generateEmbeddingResponse(texts, options);
+        },
+        extractOutputValue: (result) => {
+            return model.extractEmbeddings(result)[0];
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "text-embedding-started",
+            metadata,
+            settings,
+            texts,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "text-embedding-finished",
+            status: "abort",
+            metadata,
+            settings,
+            texts,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "text-embedding-finished",
+            status: "failure",
+            metadata,
+            settings,
+            error,
+            texts,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "text-embedding-finished",
+            status: "success",
+            metadata,
+            settings,
+            texts,
+            response,
+            generatedEmbeddings: [output],
+        }),
     });
-    return options?.fullResponse === true
-        ? {
-            embedding: result.embeddings[0],
-            metadata: result.metadata,
-        }
-        : result.embeddings[0];
 }
 exports.embedText = embedText;

package/model-function/embed-text/embedText.d.ts

@@ -1,6 +1,6 @@
 import { Vector } from "../../run/Vector.js";
 import { FunctionOptions } from "../FunctionOptions.js";
-import { CallMetadata } from "../executeCall.js";
+import { ModelFunctionPromise } from "../executeCall.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "./TextEmbeddingModel.js";
 /**
  * Generate embeddings for multiple texts.
@@ -14,15 +14,7 @@ import { TextEmbeddingModel, TextEmbeddingModelSettings } from "./TextEmbeddingM
  *   ]
  * );
  */
-export declare function embedTexts<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, texts: string[], options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<{
-    embeddings: Array<Vector>;
-    metadata: CallMetadata<TextEmbeddingModel<RESPONSE, SETTINGS>>;
-}>;
-export declare function embedTexts<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, texts: string[], options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<Array<Vector>>;
+export declare function embedTexts<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, texts: string[], options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<TextEmbeddingModel<RESPONSE, SETTINGS>, Vector[], RESPONSE[]>;
 /**
  * Generate an embedding for a single text.
  *
@@ -32,12 +24,4 @@ export declare function embedTexts<RESPONSE, SETTINGS extends TextEmbeddingModel
  *   "At first, Nox didn't know what to do with the pup."
  * );
  */
-export declare function embedText<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, text: string, options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<{
-    embedding: Vector;
-    metadata: CallMetadata<TextEmbeddingModel<RESPONSE, SETTINGS>>;
-}>;
-export declare function embedText<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, text: string, options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<Vector>;
+export declare function embedText<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, text: string, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<TextEmbeddingModel<RESPONSE, SETTINGS>, Vector, RESPONSE>;

package/model-function/embed-text/embedText.js

@@ -1,6 +1,18 @@
 import { executeCall } from "../executeCall.js";
-export async function embedTexts(model, texts, options) {
-    const result = await executeCall({
+/**
+ * Generate embeddings for multiple texts.
+ *
+ * @example
+ * const embeddings = await embedTexts(
+ *   new OpenAITextEmbeddingModel(...),
+ *   [
+ *     "At first, Nox didn't know what to do with the pup.",
+ *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
+ *   ]
+ * );
+ */
+export function embedTexts(model, texts, options) {
+    return executeCall({
         model,
         options,
         generateResponse: (options) => {
@@ -50,22 +62,56 @@ export async function embedTexts(model, texts, options) {
             generatedEmbeddings: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            embeddings: result.output,
-            metadata: result.metadata,
-        }
-        : result.output;
 }
-export async function embedText(model, text, options) {
-    const result = await embedTexts(model, [text], {
-        ...(options ?? {}),
-        fullResponse: true,
+/**
+ * Generate an embedding for a single text.
+ *
+ * @example
+ * const embedding = await embedText(
+ *   new OpenAITextEmbeddingModel(...),
+ *   "At first, Nox didn't know what to do with the pup."
+ * );
+ */
+export function embedText(model, text, options) {
+    const texts = [text];
+    return executeCall({
+        model,
+        options,
+        generateResponse: (options) => {
+            return model.generateEmbeddingResponse(texts, options);
+        },
+        extractOutputValue: (result) => {
+            return model.extractEmbeddings(result)[0];
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "text-embedding-started",
+            metadata,
+            settings,
+            texts,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "text-embedding-finished",
+            status: "abort",
+            metadata,
+            settings,
+            texts,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "text-embedding-finished",
+            status: "failure",
+            metadata,
+            settings,
+            error,
+            texts,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "text-embedding-finished",
+            status: "success",
+            metadata,
+            settings,
+            texts,
+            response,
+            generatedEmbeddings: [output],
+        }),
     });
-    return options?.fullResponse === true
-        ? {
-            embedding: result.embeddings[0],
-            metadata: result.metadata,
-        }
-        : result.embeddings[0];
 }

package/model-function/executeCall.cjs

@@ -1,12 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeCall = void 0;
+exports.ModelFunctionPromise = exports.executeCall = void 0;
 const nanoid_1 = require("nanoid");
 const RunFunctionEventSource_js_1 = require("../run/RunFunctionEventSource.cjs");
 const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
 const AbortError_js_1 = require("../util/api/AbortError.cjs");
 const runSafe_js_1 = require("../util/runSafe.cjs");
-async function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+    return new ModelFunctionPromise(doExecuteCall({
+        model,
+        options,
+        getStartEvent,
+        getAbortEvent,
+        getFailureEvent,
+        getSuccessEvent,
+        generateResponse,
+        extractOutputValue,
+    }));
+}
+exports.executeCall = executeCall;
+class ModelFunctionPromise extends Promise {
+    constructor(fullPromise) {
+        super((resolve) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve(null); // we override the resolve function
+        });
+        Object.defineProperty(this, "fullPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fullPromise
+        });
+        Object.defineProperty(this, "outputPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.outputPromise = fullPromise.then((result) => result.output);
+    }
+    asFullResponse() {
+        return this.fullPromise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.outputPromise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.outputPromise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.outputPromise.finally(onfinally);
+    }
+}
+exports.ModelFunctionPromise = ModelFunctionPromise;
+async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
     if (options?.settings != null) {
         model = model.withSettings(options.settings);
         options = {
@@ -57,4 +104,3 @@ async function executeCall({ model, options, getStartEvent, getAbortEvent, getFa
         metadata: finishMetadata,
     };
 }
-exports.executeCall = executeCall;

package/model-function/executeCall.d.ts

@@ -20,8 +20,21 @@ export declare function executeCall<SETTINGS extends ModelSettings, MODEL extend
     getSuccessEvent: (metadata: ModelCallFinishedEventMetadata, settings: SETTINGS, response: RESPONSE, output: OUTPUT) => ModelCallFinishedEvent;
     generateResponse: (options: FunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
     extractOutputValue: (response: RESPONSE) => OUTPUT;
-}): Promise<{
-    output: OUTPUT;
-    response: RESPONSE;
-    metadata: CallMetadata<MODEL>;
-}>;
+}): ModelFunctionPromise<MODEL, OUTPUT, RESPONSE>;
+export declare class ModelFunctionPromise<MODEL extends Model<any>, OUTPUT, RESPONSE> extends Promise<OUTPUT> {
+    private fullPromise;
+    private outputPromise;
+    constructor(fullPromise: Promise<{
+        output: OUTPUT;
+        response: RESPONSE;
+        metadata: CallMetadata<MODEL>;
+    }>);
+    asFullResponse(): Promise<{
+        output: OUTPUT;
+        response: RESPONSE;
+        metadata: CallMetadata<MODEL>;
+    }>;
+    then<TResult1 = OUTPUT, TResult2 = never>(onfulfilled?: ((value: OUTPUT) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<OUTPUT | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<OUTPUT>;
+}

package/model-function/executeCall.js

@@ -3,7 +3,52 @@ import { RunFunctionEventSource } from "../run/RunFunctionEventSource.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { AbortError } from "../util/api/AbortError.js";
 import { runSafe } from "../util/runSafe.js";
-export async function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+export function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+    return new ModelFunctionPromise(doExecuteCall({
+        model,
+        options,
+        getStartEvent,
+        getAbortEvent,
+        getFailureEvent,
+        getSuccessEvent,
+        generateResponse,
+        extractOutputValue,
+    }));
+}
+export class ModelFunctionPromise extends Promise {
+    constructor(fullPromise) {
+        super((resolve) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve(null); // we override the resolve function
+        });
+        Object.defineProperty(this, "fullPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fullPromise
+        });
+        Object.defineProperty(this, "outputPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.outputPromise = fullPromise.then((result) => result.output);
+    }
+    asFullResponse() {
+        return this.fullPromise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.outputPromise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.outputPromise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.outputPromise.finally(onfinally);
+    }
+}
+async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
     if (options?.settings != null) {
         model = model.withSettings(options.settings);
         options = {

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

@@ -2,8 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateImage = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
-async function generateImage(model, prompt, options) {
-    const result = await (0, executeCall_js_1.executeCall)({
+/**
+ * Generates a base64-encoded image using a prompt.
+ * The prompt format depends on the model.
+ * For example, OpenAI image models expect a string prompt,
+ * and Stability AI models expect an array of text prompts with optional weights.
+ *
+ * @example
+ * const image = await generateImage(
+ *   new StabilityImageGenerationModel(...),
+ *   [
+ *     { text: "the wicked witch of the west" },
+ *     { text: "style of early 19th century painting", weight: 0.5 },
+ *   ]
+ * );
+ */
+function generateImage(model, prompt, options) {
+    return (0, executeCall_js_1.executeCall)({
         model,
         options,
         generateResponse: (options) => model.generateImageResponse(prompt, options),
@@ -39,12 +54,5 @@ async function generateImage(model, prompt, options) {
             generatedImage: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            image: result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }
 exports.generateImage = generateImage;

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

@@ -1,5 +1,5 @@
 import { FunctionOptions } from "../FunctionOptions.js";
-import { CallMetadata } from "../executeCall.js";
+import { ModelFunctionPromise } from "../executeCall.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGenerationModel.js";
 /**
  * Generates a base64-encoded image using a prompt.
@@ -16,13 +16,4 @@ import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGener
  *   ]
  * );
  */
-export declare function generateImage<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings>(model: ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, prompt: PROMPT, options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<{
-    image: string;
-    response: RESPONSE;
-    metadata: CallMetadata<ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>>;
-}>;
-export declare function generateImage<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings>(model: ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, prompt: PROMPT, options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<string>;
+export declare function generateImage<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings>(model: ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, prompt: PROMPT, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, string, RESPONSE>;

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

@@ -1,6 +1,21 @@
 import { executeCall } from "../executeCall.js";
-export async function generateImage(model, prompt, options) {
-    const result = await executeCall({
+/**
+ * Generates a base64-encoded image using a prompt.
+ * The prompt format depends on the model.
+ * For example, OpenAI image models expect a string prompt,
+ * and Stability AI models expect an array of text prompts with optional weights.
+ *
+ * @example
+ * const image = await generateImage(
+ *   new StabilityImageGenerationModel(...),
+ *   [
+ *     { text: "the wicked witch of the west" },
+ *     { text: "style of early 19th century painting", weight: 0.5 },
+ *   ]
+ * );
+ */
+export function generateImage(model, prompt, options) {
+    return executeCall({
         model,
         options,
         generateResponse: (options) => model.generateImageResponse(prompt, options),
@@ -36,11 +51,4 @@ export async function generateImage(model, prompt, options) {
             generatedImage: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            image: result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }

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

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateJson = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
 const SchemaValidationError_js_1 = require("./SchemaValidationError.cjs");
-async function generateJson(model, schemaDefinition, prompt, options) {
+function generateJson(model, schemaDefinition, prompt, options) {
     const expandedPrompt = prompt(schemaDefinition);
-    const result = await (0, executeCall_js_1.executeCall)({
+    return (0, executeCall_js_1.executeCall)({
         model,
         options,
         generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
@@ -52,12 +52,5 @@ async function generateJson(model, schemaDefinition, prompt, options) {
             generatedJson: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            value: result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }
 exports.generateJson = generateJson;

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

@@ -1,14 +1,5 @@
 import { FunctionOptions } from "../FunctionOptions.js";
-import { CallMetadata } from "../executeCall.js";
+import { ModelFunctionPromise } from "../executeCall.js";
 import { GenerateJsonModel, GenerateJsonModelSettings } from "./GenerateJsonModel.js";
 import { SchemaDefinition } from "./SchemaDefinition.js";
-export declare function generateJson<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends GenerateJsonModelSettings>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinition: SchemaDefinition<NAME, STRUCTURE>, prompt: (schemaDefinition: SchemaDefinition<NAME, STRUCTURE>) => PROMPT, options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<{
-    value: STRUCTURE;
-    response: RESPONSE;
-    metadata: CallMetadata<GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>>;
-}>;
-export declare function generateJson<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends GenerateJsonModelSettings>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinition: SchemaDefinition<NAME, STRUCTURE>, prompt: (schemaDefinition: SchemaDefinition<NAME, STRUCTURE>) => PROMPT, options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<STRUCTURE>;
+export declare function generateJson<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends GenerateJsonModelSettings>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinition: SchemaDefinition<NAME, STRUCTURE>, prompt: (schemaDefinition: SchemaDefinition<NAME, STRUCTURE>) => PROMPT, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, STRUCTURE, RESPONSE>;

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

@@ -1,8 +1,8 @@
 import { executeCall } from "../executeCall.js";
 import { SchemaValidationError } from "./SchemaValidationError.js";
-export async function generateJson(model, schemaDefinition, prompt, options) {
+export function generateJson(model, schemaDefinition, prompt, options) {
     const expandedPrompt = prompt(schemaDefinition);
-    const result = await executeCall({
+    return executeCall({
         model,
         options,
         generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
@@ -49,11 +49,4 @@ export async function generateJson(model, schemaDefinition, prompt, options) {
             generatedJson: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            value: result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }

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

@@ -4,9 +4,9 @@ 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");
-async function generateJsonOrText(model, schemaDefinitions, prompt, options) {
+function generateJsonOrText(model, schemaDefinitions, prompt, options) {
     const expandedPrompt = prompt(schemaDefinitions);
-    const result = await (0, executeCall_js_1.executeCall)({
+    return (0, executeCall_js_1.executeCall)({
         model,
         options,
         generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
@@ -65,12 +65,5 @@ async function generateJsonOrText(model, schemaDefinitions, prompt, options) {
             generatedJson: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            ...result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }
 exports.generateJsonOrText = generateJsonOrText;

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

@@ -1,5 +1,5 @@
 import { FunctionOptions } from "../FunctionOptions.js";
-import { CallMetadata } from "../executeCall.js";
+import { ModelFunctionPromise } from "../executeCall.js";
 import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "./GenerateJsonOrTextModel.js";
 import { SchemaDefinition } from "./SchemaDefinition.js";
 type SchemaDefinitionArray<T extends SchemaDefinition<any, any>[]> = T;
@@ -14,21 +14,9 @@ type ToSchemaUnion<T> = {
     } : 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 GenerateJsonOrTextModelSettings>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinitions: SCHEMAS, prompt: (schemaDefinitions: SCHEMAS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<({
+export declare function generateJsonOrText<SCHEMAS extends SchemaDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinitions: SCHEMAS, prompt: (schemaDefinitions: SCHEMAS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, {
     schema: null;
     value: null;
     text: string;
-} | ToOutputValue<SCHEMAS>) & {
-    response: RESPONSE;
-    metadata: CallMetadata<GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>>;
-}>;
-export declare function generateJsonOrText<SCHEMAS extends SchemaDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinitions: SCHEMAS, prompt: (schemaDefinitions: SCHEMAS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<{
-    schema: null;
-    value: null;
-    text: string;
-} | ToOutputValue<SCHEMAS>>;
+} | ToOutputValue<SCHEMAS>, RESPONSE>;
 export {};

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

@@ -1,9 +1,9 @@
 import { executeCall } from "../executeCall.js";
 import { NoSuchSchemaError } from "./NoSuchSchemaError.js";
 import { SchemaValidationError } from "./SchemaValidationError.js";
-export async function generateJsonOrText(model, schemaDefinitions, prompt, options) {
+export function generateJsonOrText(model, schemaDefinitions, prompt, options) {
     const expandedPrompt = prompt(schemaDefinitions);
-    const result = await executeCall({
+    return executeCall({
         model,
         options,
         generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
@@ -62,11 +62,4 @@ export async function generateJsonOrText(model, schemaDefinitions, prompt, optio
             generatedJson: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            ...result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }