modelfusion 0.40.0 → 0.41.0

package/README.md

@@ -114,9 +114,8 @@ const textStream = await streamText(
 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 { output, response, metadata } = await generateText(
+// access the full response (needs to be typed) and the metadata:
+const { value, response, metadata } = await generateText(
   new OpenAITextGenerationModel({
     model: "gpt-3.5-turbo-instruct",
     maxCompletionTokens: 1000,
@@ -125,11 +124,12 @@ const { output, response, metadata } = await generateText(
   "Write a short story about a robot learning to love:\n\n"
 ).asFullResponse();
 
-for (const choice of response.choices) {
+console.log(metadata);
+
+// cast to the response type:
+for (const choice of (response as OpenAITextGenerationResponse).choices) {
   console.log(choice.text);
 }
-
-console.log(`Duration: ${metadata.durationInMs}ms`);
 ```
 
 ### [Generate Structure](https://modelfusion.dev/guide/function/generate-structure#generatestructure)
@@ -381,6 +381,13 @@ Providers: [OpenAI (Dall·E)](https://modelfusion.dev/integration/model-provider
 Create embeddings for text and other values. Embeddings are vectors that represent the essence of the values in the context of the model.
 
 ```ts
+// embed single value:
+const embedding = await embed(
+  new OpenAITextEmbeddingModel({ model: "text-embedding-ada-002" }),
+  "At first, Nox didn't know what to do with the pup."
+);
+
+// embed many values:
 const embeddings = await embedMany(
   new OpenAITextEmbeddingModel({ model: "text-embedding-ada-002" }),
   [
@@ -456,7 +463,7 @@ Integrations: [Helicone](https://modelfusion.dev/integration/observability/helic
 
 - [Model Functions](https://modelfusion.dev/guide/function/)
   - [Generate and stream text](https://modelfusion.dev/guide/function/generate-text)
-  - [Generate structure](https://modelfusion.dev/guide/function/generate-structure)
+  - [Generate and stream structure](https://modelfusion.dev/guide/function/generate-structure)
   - [Generate structure or text](https://modelfusion.dev/guide/function/generate-structure-or-text)
   - [Embed Value](https://modelfusion.dev/guide/function/embed)
   - [Tokenize Text](https://modelfusion.dev/guide/function/tokenize-text)

package/composed-function/summarize/summarizeRecursivelyWithTextGenerationAndTokenSplitting.d.ts

@@ -1,6 +1,6 @@
-import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
-import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
 import { Run } from "../../core/Run.js";
+import { TextGenerationModel } from "../../model-function/generate-text/TextGenerationModel.js";
+import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
 /**
  * Recursively summarizes a text using a text generation model, e.g. for summarization or text extraction.
  * It automatically splits the text into optimal chunks that are small enough to be processed by the model,
@@ -8,7 +8,7 @@ import { Run } from "../../core/Run.js";
  */
 export declare function summarizeRecursivelyWithTextGenerationAndTokenSplitting<PROMPT>({ text, model, prompt, tokenLimit, join, }: {
     text: string;
-    model: TextGenerationModel<PROMPT, any, any, TextGenerationModelSettings> & {
+    model: TextGenerationModel<PROMPT> & {
         contextWindowSize: number;
         tokenizer: FullTokenizer;
         countPromptTokens: (prompt: PROMPT) => PromiseLike<number>;

package/core/FunctionEvent.d.ts

@@ -47,7 +47,7 @@ export interface BaseFunctionStartedEvent extends BaseFunctionEvent {
 }
 export type BaseFunctionFinishedEventResult = {
     status: "success";
-    output: unknown;
+    value: unknown;
 } | {
     status: "error";
     error: unknown;

package/model-function/AsyncIterableResultPromise.d.ts

@@ -1,4 +1,4 @@
-import { ModelCallMetadata } from "./executeCall.js";
+import { ModelCallMetadata } from "./ModelCallMetadata.js";
 export declare class AsyncIterableResultPromise<T> extends Promise<AsyncIterable<T>> {
     private fullPromise;
     private outputPromise;

package/model-function/Delta.d.ts

@@ -0,0 +1,8 @@
+export type Delta<T> = {
+    type: "delta";
+    fullDelta: unknown;
+    valueDelta: T;
+} | {
+    type: "error";
+    error: unknown;
+};

package/model-function/ModelCallEvent.d.ts

@@ -23,7 +23,7 @@ export interface BaseModelCallStartedEvent extends BaseFunctionStartedEvent {
 export type BaseModelCallFinishedEventResult = {
     status: "success";
     response: unknown;
-    output: unknown;
+    value: unknown;
     /**
      * Optional usage information for the model call. The type depends on the call type.
      */

package/model-function/ModelCallMetadata.d.ts

@@ -0,0 +1,13 @@
+import { ModelInformation } from "./ModelInformation.js";
+export type ModelCallMetadata = {
+    model: ModelInformation;
+    callId: string;
+    runId?: string;
+    sessionId?: string;
+    userId?: string;
+    functionId?: string;
+    startTimestamp: Date;
+    finishTimestamp: Date;
+    durationInMs: number;
+    usage?: unknown;
+};

package/model-function/describe-image/ImageDescriptionEvent.d.ts

@@ -5,7 +5,7 @@ export interface ImageDescriptionStartedEvent extends BaseModelCallStartedEvent
 export type ImageDescriptionFinishedEventResult = {
     status: "success";
     response: unknown;
-    output: string;
+    value: string;
 } | {
     status: "error";
     error: unknown;

package/model-function/describe-image/ImageDescriptionModel.d.ts

@@ -1,8 +1,10 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface ImageDescriptionModelSettings extends ModelSettings {
 }
-export interface ImageDescriptionModel<DATA, RESPONSE, SETTINGS extends ImageDescriptionModelSettings> extends Model<SETTINGS> {
-    generateImageDescriptionResponse: (data: DATA, options?: ModelFunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
-    extractImageDescription: (response: RESPONSE) => string;
+export interface ImageDescriptionModel<DATA, SETTINGS extends ImageDescriptionModelSettings = ImageDescriptionModelSettings> extends Model<SETTINGS> {
+    doDescribeImage: (data: DATA, options?: FunctionOptions) => PromiseLike<{
+        response: unknown;
+        description: string;
+    }>;
 }

package/model-function/describe-image/describeImage.cjs

@@ -13,8 +13,13 @@ function describeImage(model, data, options) {
         input: data,
         model,
         options,
-        generateResponse: (options) => model.generateImageDescriptionResponse(data, options),
-        extractOutputValue: model.extractImageDescription,
+        generateResponse: async (options) => {
+            const result = await model.doDescribeImage(data, options);
+            return {
+                response: result.response,
+                extractedValue: result.description,
+            };
+        },
     });
 }
 exports.describeImage = describeImage;

package/model-function/describe-image/describeImage.d.ts

@@ -1,4 +1,4 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { ImageDescriptionModel, ImageDescriptionModelSettings } from "./ImageDescriptionModel.js";
 /**
@@ -6,4 +6,4 @@ import { ImageDescriptionModel, ImageDescriptionModelSettings } from "./ImageDes
  *
  * Depending on the model, this can be used for image captioning, for describing the contents of an image, or for OCR.
  */
-export declare function describeImage<DATA, RESPONSE, SETTINGS extends ImageDescriptionModelSettings>(model: ImageDescriptionModel<DATA, RESPONSE, SETTINGS>, data: DATA, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<string, RESPONSE>;
+export declare function describeImage<DATA>(model: ImageDescriptionModel<DATA, ImageDescriptionModelSettings>, data: DATA, options?: FunctionOptions): ModelFunctionPromise<string>;

package/model-function/describe-image/describeImage.js

@@ -10,7 +10,12 @@ export function describeImage(model, data, options) {
         input: data,
         model,
         options,
-        generateResponse: (options) => model.generateImageDescriptionResponse(data, options),
-        extractOutputValue: model.extractImageDescription,
+        generateResponse: async (options) => {
+            const result = await model.doDescribeImage(data, options);
+            return {
+                response: result.response,
+                extractedValue: result.description,
+            };
+        },
     });
 }

package/model-function/embed/EmbeddingEvent.d.ts

@@ -7,7 +7,7 @@ export interface EmbeddingStartedEvent extends BaseModelCallStartedEvent {
 export type EmbeddingFinishedEventResult = {
     status: "success";
     response: unknown;
-    output: Vector | Array<Vector>;
+    value: Vector | Array<Vector>;
 } | {
     status: "error";
     error: unknown;

package/model-function/embed/EmbeddingModel.d.ts

@@ -1,9 +1,9 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Vector } from "../../core/Vector.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface EmbeddingModelSettings extends ModelSettings {
 }
-export interface EmbeddingModel<VALUE, RESPONSE, SETTINGS extends EmbeddingModelSettings> extends Model<SETTINGS> {
+export interface EmbeddingModel<VALUE, SETTINGS extends EmbeddingModelSettings = EmbeddingModelSettings> extends Model<SETTINGS> {
     /**
      * The size of the embedding vector.
      */
@@ -12,6 +12,8 @@ export interface EmbeddingModel<VALUE, RESPONSE, SETTINGS extends EmbeddingModel
      * Limit of how many values can be sent in a single API call.
      */
     readonly maxValuesPerCall: number | undefined;
-    generateEmbeddingResponse(values: VALUE[], options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
-    extractEmbeddings(response: RESPONSE): Vector[];
+    doEmbedValues(values: VALUE[], options?: FunctionOptions): PromiseLike<{
+        response: unknown;
+        embeddings: Vector[];
+    }>;
 }

package/model-function/embed/embed.cjs

@@ -20,7 +20,7 @@ function embedMany(model, values, options) {
         input: values,
         model,
         options,
-        generateResponse: (options) => {
+        generateResponse: async (options) => {
             // split the values into groups that are small enough to be sent in one call:
             const maxValuesPerCall = model.maxValuesPerCall;
             const valueGroups = [];
@@ -32,14 +32,16 @@ function embedMany(model, values, options) {
                     valueGroups.push(values.slice(i, i + maxValuesPerCall));
                 }
             }
-            return Promise.all(valueGroups.map((valueGroup) => model.generateEmbeddingResponse(valueGroup, options)));
-        },
-        extractOutputValue: (result) => {
+            const responses = await Promise.all(valueGroups.map((valueGroup) => model.doEmbedValues(valueGroup, options)));
+            const rawResponses = responses.map((response) => response.response);
             const embeddings = [];
-            for (const response of result) {
-                embeddings.push(...model.extractEmbeddings(response));
+            for (const response of responses) {
+                embeddings.push(...response.embeddings);
             }
-            return embeddings;
+            return {
+                response: rawResponses,
+                extractedValue: embeddings,
+            };
         },
     });
 }
@@ -59,10 +61,13 @@ function embed(model, value, options) {
         input: value,
         model,
         options,
-        generateResponse: async (options) => [
-            await model.generateEmbeddingResponse([value], options),
-        ],
-        extractOutputValue: (result) => model.extractEmbeddings(result[0])[0],
+        generateResponse: async (options) => {
+            const result = await model.doEmbedValues([value], options);
+            return {
+                response: result.response,
+                extractedValue: result.embeddings[0],
+            };
+        },
     });
 }
 exports.embed = embed;

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

@@ -1,5 +1,5 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Vector } from "../../core/Vector.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { EmbeddingModel, EmbeddingModelSettings } from "./EmbeddingModel.js";
 /**
@@ -14,7 +14,7 @@ import { EmbeddingModel, EmbeddingModelSettings } from "./EmbeddingModel.js";
  *   ]
  * );
  */
-export declare function embedMany<VALUE, RESPONSE, SETTINGS extends EmbeddingModelSettings>(model: EmbeddingModel<VALUE, RESPONSE, SETTINGS>, values: VALUE[], options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<Vector[], RESPONSE[]>;
+export declare function embedMany<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, values: VALUE[], options?: FunctionOptions): ModelFunctionPromise<Vector[]>;
 /**
  * Generate an embedding for a single value.
  *
@@ -24,4 +24,4 @@ export declare function embedMany<VALUE, RESPONSE, SETTINGS extends EmbeddingMod
  *   "At first, Nox didn't know what to do with the pup."
  * );
  */
-export declare function embed<VALUE, RESPONSE, SETTINGS extends EmbeddingModelSettings>(model: EmbeddingModel<VALUE, RESPONSE, SETTINGS>, value: VALUE, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<Vector, RESPONSE[]>;
+export declare function embed<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, value: VALUE, options?: FunctionOptions): ModelFunctionPromise<Vector>;

package/model-function/embed/embed.js

@@ -17,7 +17,7 @@ export function embedMany(model, values, options) {
         input: values,
         model,
         options,
-        generateResponse: (options) => {
+        generateResponse: async (options) => {
             // split the values into groups that are small enough to be sent in one call:
             const maxValuesPerCall = model.maxValuesPerCall;
             const valueGroups = [];
@@ -29,14 +29,16 @@ export function embedMany(model, values, options) {
                     valueGroups.push(values.slice(i, i + maxValuesPerCall));
                 }
             }
-            return Promise.all(valueGroups.map((valueGroup) => model.generateEmbeddingResponse(valueGroup, options)));
-        },
-        extractOutputValue: (result) => {
+            const responses = await Promise.all(valueGroups.map((valueGroup) => model.doEmbedValues(valueGroup, options)));
+            const rawResponses = responses.map((response) => response.response);
             const embeddings = [];
-            for (const response of result) {
-                embeddings.push(...model.extractEmbeddings(response));
+            for (const response of responses) {
+                embeddings.push(...response.embeddings);
             }
-            return embeddings;
+            return {
+                response: rawResponses,
+                extractedValue: embeddings,
+            };
         },
     });
 }
@@ -55,9 +57,12 @@ export function embed(model, value, options) {
         input: value,
         model,
         options,
-        generateResponse: async (options) => [
-            await model.generateEmbeddingResponse([value], options),
-        ],
-        extractOutputValue: (result) => model.extractEmbeddings(result[0])[0],
+        generateResponse: async (options) => {
+            const result = await model.doEmbedValues([value], options);
+            return {
+                response: result.response,
+                extractedValue: result.embeddings[0],
+            };
+        },
     });
 }

package/model-function/executeCall.cjs

@@ -5,9 +5,9 @@ const nanoid_1 = require("nanoid");
 const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
 const GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
 const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
+const AbortError_js_1 = require("../core/api/AbortError.cjs");
 const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
 const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
-const AbortError_js_1 = require("../core/api/AbortError.cjs");
 const runSafe_js_1 = require("../util/runSafe.cjs");
 class ModelFunctionPromise extends Promise {
     constructor(fullPromise) {
@@ -21,50 +21,39 @@ class ModelFunctionPromise extends Promise {
             writable: true,
             value: fullPromise
         });
-        Object.defineProperty(this, "outputPromise", {
+        Object.defineProperty(this, "valuePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.outputPromise = fullPromise.then((result) => result.output);
+        this.valuePromise = fullPromise.then((result) => result.value);
     }
     asFullResponse() {
         return this.fullPromise;
     }
     then(onfulfilled, onrejected) {
-        return this.outputPromise.then(onfulfilled, onrejected);
+        return this.valuePromise.then(onfulfilled, onrejected);
     }
     catch(onrejected) {
-        return this.outputPromise.catch(onrejected);
+        return this.valuePromise.catch(onrejected);
     }
     finally(onfinally) {
-        return this.outputPromise.finally(onfinally);
+        return this.valuePromise.finally(onfinally);
     }
 }
 exports.ModelFunctionPromise = ModelFunctionPromise;
-function executeCall({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }) {
+function executeCall({ model, options, input, functionType, generateResponse, }) {
     return new ModelFunctionPromise(doExecuteCall({
         model,
         options,
         input,
         functionType,
         generateResponse,
-        extractOutputValue,
-        extractUsage,
     }));
 }
 exports.executeCall = executeCall;
-async function doExecuteCall({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }) {
-    if (options?.settings != null) {
-        model = model.withSettings(options.settings);
-        options = {
-            functionId: options.functionId,
-            logging: options.logging,
-            observers: options.observers,
-            run: options.run,
-        };
-    }
+async function doExecuteCall({ model, options, input, functionType, generateResponse, }) {
     const run = options?.run;
     const settings = model.settings;
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
@@ -95,11 +84,7 @@ async function doExecuteCall({ model, options, input, functionType, generateResp
         eventType: "started",
         ...startMetadata,
     });
-    const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
-        functionId: options?.functionId,
-        settings,
-        run,
-    }));
+    const result = await (0, runSafe_js_1.runSafe)(() => generateResponse(options));
     const finishMetadata = {
         eventType: "finished",
         ...startMetadata,
@@ -127,9 +112,9 @@ async function doExecuteCall({ model, options, input, functionType, generateResp
         });
         throw result.error;
     }
-    const response = result.output;
-    const output = extractOutputValue(response);
-    const usage = extractUsage?.(response);
+    const response = result.value.response;
+    const value = result.value.extractedValue;
+    const usage = result.value.usage;
     eventSource.notify({
         ...finishMetadata,
         eventType: "finished",
@@ -137,12 +122,23 @@ async function doExecuteCall({ model, options, input, functionType, generateResp
             status: "success",
             usage,
             response,
-            output,
+            value,
         },
     });
     return {
-        output,
+        value,
         response,
-        metadata: finishMetadata,
+        metadata: {
+            model: model.modelInformation,
+            callId: finishMetadata.callId,
+            runId: finishMetadata.runId,
+            sessionId: finishMetadata.sessionId,
+            userId: finishMetadata.userId,
+            functionId: finishMetadata.functionId,
+            startTimestamp: startMetadata.startTimestamp,
+            finishTimestamp: finishMetadata.finishTimestamp,
+            durationInMs: finishMetadata.durationInMs,
+            usage,
+        },
     };
 }

package/model-function/executeCall.d.ts

@@ -1,41 +1,32 @@
+import { FunctionOptions } from "../core/FunctionOptions.js";
 import { Model, ModelSettings } from "./Model.js";
 import { ModelCallStartedEvent } from "./ModelCallEvent.js";
-import { ModelFunctionOptions } from "./ModelFunctionOptions.js";
-import { ModelInformation } from "./ModelInformation.js";
-export type ModelCallMetadata = {
-    callId: string;
-    runId?: string;
-    sessionId?: string;
-    userId?: string;
-    functionId?: string;
-    startTimestamp: Date;
-    finishTimestamp: Date;
-    durationInMs: number;
-    model: ModelInformation;
-};
-export declare class ModelFunctionPromise<OUTPUT, RESPONSE> extends Promise<OUTPUT> {
+import { ModelCallMetadata } from "./ModelCallMetadata.js";
+export declare class ModelFunctionPromise<VALUE> extends Promise<VALUE> {
     private fullPromise;
-    private outputPromise;
+    private valuePromise;
     constructor(fullPromise: Promise<{
-        output: OUTPUT;
-        response: RESPONSE;
+        value: VALUE;
+        response: unknown;
         metadata: ModelCallMetadata;
     }>);
     asFullResponse(): Promise<{
-        output: OUTPUT;
-        response: RESPONSE;
+        value: VALUE;
+        response: unknown;
         metadata: ModelCallMetadata;
     }>;
-    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>;
+    then<TResult1 = VALUE, TResult2 = never>(onfulfilled?: ((value: VALUE) => 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<VALUE | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<VALUE>;
 }
-export declare function executeCall<SETTINGS extends ModelSettings, MODEL extends Model<SETTINGS>, OUTPUT, RESPONSE>({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }: {
+export declare function executeCall<VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, generateResponse, }: {
     model: MODEL;
-    options?: ModelFunctionOptions<SETTINGS>;
+    options?: FunctionOptions;
     input: unknown;
     functionType: ModelCallStartedEvent["functionType"];
-    generateResponse: (options: ModelFunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
-    extractOutputValue: (response: RESPONSE) => OUTPUT;
-    extractUsage?: (response: RESPONSE) => unknown;
-}): ModelFunctionPromise<OUTPUT, RESPONSE>;
+    generateResponse: (options?: FunctionOptions) => PromiseLike<{
+        response: unknown;
+        extractedValue: VALUE;
+        usage?: unknown;
+    }>;
+}): ModelFunctionPromise<VALUE>;

package/model-function/executeCall.js

@@ -2,9 +2,9 @@ import { nanoid as createId } from "nanoid";
 import { FunctionEventSource } from "../core/FunctionEventSource.js";
 import { getGlobalFunctionLogging } from "../core/GlobalFunctionLogging.js";
 import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
+import { AbortError } from "../core/api/AbortError.js";
 import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
-import { AbortError } from "../core/api/AbortError.js";
 import { runSafe } from "../util/runSafe.js";
 export class ModelFunctionPromise extends Promise {
     constructor(fullPromise) {
@@ -18,48 +18,37 @@ export class ModelFunctionPromise extends Promise {
             writable: true,
             value: fullPromise
         });
-        Object.defineProperty(this, "outputPromise", {
+        Object.defineProperty(this, "valuePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.outputPromise = fullPromise.then((result) => result.output);
+        this.valuePromise = fullPromise.then((result) => result.value);
     }
     asFullResponse() {
         return this.fullPromise;
     }
     then(onfulfilled, onrejected) {
-        return this.outputPromise.then(onfulfilled, onrejected);
+        return this.valuePromise.then(onfulfilled, onrejected);
     }
     catch(onrejected) {
-        return this.outputPromise.catch(onrejected);
+        return this.valuePromise.catch(onrejected);
     }
     finally(onfinally) {
-        return this.outputPromise.finally(onfinally);
+        return this.valuePromise.finally(onfinally);
     }
 }
-export function executeCall({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }) {
+export function executeCall({ model, options, input, functionType, generateResponse, }) {
     return new ModelFunctionPromise(doExecuteCall({
         model,
         options,
         input,
         functionType,
         generateResponse,
-        extractOutputValue,
-        extractUsage,
     }));
 }
-async function doExecuteCall({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }) {
-    if (options?.settings != null) {
-        model = model.withSettings(options.settings);
-        options = {
-            functionId: options.functionId,
-            logging: options.logging,
-            observers: options.observers,
-            run: options.run,
-        };
-    }
+async function doExecuteCall({ model, options, input, functionType, generateResponse, }) {
     const run = options?.run;
     const settings = model.settings;
     const eventSource = new FunctionEventSource({
@@ -90,11 +79,7 @@ async function doExecuteCall({ model, options, input, functionType, generateResp
         eventType: "started",
         ...startMetadata,
     });
-    const result = await runSafe(() => generateResponse({
-        functionId: options?.functionId,
-        settings,
-        run,
-    }));
+    const result = await runSafe(() => generateResponse(options));
     const finishMetadata = {
         eventType: "finished",
         ...startMetadata,
@@ -122,9 +107,9 @@ async function doExecuteCall({ model, options, input, functionType, generateResp
         });
         throw result.error;
     }
-    const response = result.output;
-    const output = extractOutputValue(response);
-    const usage = extractUsage?.(response);
+    const response = result.value.response;
+    const value = result.value.extractedValue;
+    const usage = result.value.usage;
     eventSource.notify({
         ...finishMetadata,
         eventType: "finished",
@@ -132,12 +117,23 @@ async function doExecuteCall({ model, options, input, functionType, generateResp
             status: "success",
             usage,
             response,
-            output,
+            value,
         },
     });
     return {
-        output,
+        value,
         response,
-        metadata: finishMetadata,
+        metadata: {
+            model: model.modelInformation,
+            callId: finishMetadata.callId,
+            runId: finishMetadata.runId,
+            sessionId: finishMetadata.sessionId,
+            userId: finishMetadata.userId,
+            functionId: finishMetadata.functionId,
+            startTimestamp: startMetadata.startTimestamp,
+            finishTimestamp: finishMetadata.finishTimestamp,
+            durationInMs: finishMetadata.durationInMs,
+            usage,
+        },
     };
 }