modelfusion 0.112.0 → 0.114.0

package/model-function/executeStandardCall.cjs

@@ -43,11 +43,13 @@ async function executeStandardCall({ model, options, input, functionType, genera
         ...startMetadata,
     });
     const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
+        functionType: startMetadata.functionType,
         functionId: options?.functionId,
+        callId: startMetadata.callId,
         logging: options?.logging,
         observers: options?.observers,
+        cache: options?.cache,
         run,
-        parentCallId: startMetadata.callId,
     }));
     const finishMetadata = {
         eventType: "finished",

package/model-function/executeStandardCall.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
+import { FunctionCallOptions, FunctionOptions } from "../core/FunctionOptions.js";
 import { Model, ModelSettings } from "./Model.js";
 import { ModelCallStartedEvent } from "./ModelCallEvent.js";
 import { ModelCallMetadata } from "./ModelCallMetadata.js";
@@ -7,7 +7,7 @@ export declare function executeStandardCall<VALUE, MODEL extends Model<ModelSett
     options?: FunctionOptions;
     input: unknown;
     functionType: ModelCallStartedEvent["functionType"];
-    generateResponse: (options?: FunctionOptions) => PromiseLike<{
+    generateResponse: (options: FunctionCallOptions) => PromiseLike<{
         response: unknown;
         extractedValue: VALUE;
         usage?: unknown;

package/model-function/executeStandardCall.js

@@ -40,11 +40,13 @@ export async function executeStandardCall({ model, options, input, functionType,
         ...startMetadata,
     });
     const result = await runSafe(() => generateResponse({
+        functionType: startMetadata.functionType,
         functionId: options?.functionId,
+        callId: startMetadata.callId,
         logging: options?.logging,
         observers: options?.observers,
+        cache: options?.cache,
         run,
-        parentCallId: startMetadata.callId,
     }));
     const finishMetadata = {
         eventType: "finished",

package/model-function/executeStreamCall.cjs

@@ -45,11 +45,12 @@ async function executeStreamCall({ model, options, input, functionType, startStr
     });
     const result = await (0, runSafe_js_1.runSafe)(async () => {
         const deltaIterable = await startStream({
+            functionType: startMetadata.functionType,
             functionId: options?.functionId,
+            callId: startMetadata.callId,
             logging: options?.logging,
             observers: options?.observers,
             run,
-            parentCallId: startMetadata.callId,
         });
         // Return a queue that can be iterated over several times:
         const responseQueue = new AsyncQueue_js_1.AsyncQueue();

package/model-function/executeStreamCall.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
+import { FunctionCallOptions, FunctionOptions } from "../core/FunctionOptions.js";
 import { Delta } from "./Delta.js";
 import { Model, ModelSettings } from "./Model.js";
 import { ModelCallStartedEvent } from "./ModelCallEvent.js";
@@ -8,7 +8,7 @@ export declare function executeStreamCall<DELTA_VALUE, VALUE, MODEL extends Mode
     options?: FunctionOptions;
     input: unknown;
     functionType: ModelCallStartedEvent["functionType"];
-    startStream: (options?: FunctionOptions) => PromiseLike<AsyncIterable<Delta<DELTA_VALUE>>>;
+    startStream: (options: FunctionCallOptions) => PromiseLike<AsyncIterable<Delta<DELTA_VALUE>>>;
     processDelta: (delta: Delta<DELTA_VALUE> & {
         type: "delta";
     }) => VALUE | undefined;

package/model-function/executeStreamCall.js

@@ -42,11 +42,12 @@ export async function executeStreamCall({ model, options, input, functionType, s
     });
     const result = await runSafe(async () => {
         const deltaIterable = await startStream({
+            functionType: startMetadata.functionType,
             functionId: options?.functionId,
+            callId: startMetadata.callId,
             logging: options?.logging,
             observers: options?.observers,
             run,
-            parentCallId: startMetadata.callId,
         });
         // Return a queue that can be iterated over several times:
         const responseQueue = new AsyncQueue();

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 import { PromptTemplate } from "../PromptTemplate.js";
 export interface ImageGenerationModelSettings extends ModelSettings {
@@ -14,7 +14,7 @@ export interface ImageGenerationModelSettings extends ModelSettings {
     numberOfGenerations?: number;
 }
 export interface ImageGenerationModel<PROMPT, SETTINGS extends ImageGenerationModelSettings = ImageGenerationModelSettings> extends Model<SETTINGS> {
-    doGenerateImages(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateImages(prompt: PROMPT, options: FunctionCallOptions): PromiseLike<{
         response: unknown;
         base64Images: string[];
     }>;

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { PromptTemplate } from "../PromptTemplate.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGenerationModel.js";
 export declare class PromptTemplateImageGenerationModel<PROMPT, MODEL_PROMPT, SETTINGS extends ImageGenerationModelSettings, MODEL extends ImageGenerationModel<MODEL_PROMPT, SETTINGS>> implements ImageGenerationModel<PROMPT, SETTINGS> {
@@ -10,7 +10,7 @@ export declare class PromptTemplateImageGenerationModel<PROMPT, MODEL_PROMPT, SE
     });
     get modelInformation(): import("../ModelInformation.js").ModelInformation;
     get settings(): SETTINGS;
-    doGenerateImages(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateImages(prompt: PROMPT, options: FunctionCallOptions): PromiseLike<{
         response: unknown;
         base64Images: string[];
     }>;

package/model-function/generate-speech/SpeechGenerationModel.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { Delta } from "../Delta.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface SpeechGenerationModelSettings extends ModelSettings {
@@ -8,8 +8,8 @@ export interface SpeechGenerationModel<SETTINGS extends SpeechGenerationModelSet
     /**
      * Generates an mp3 audio buffer that contains the speech for the given text.
      */
-    doGenerateSpeechStandard(text: string, options?: FunctionOptions): PromiseLike<Buffer>;
+    doGenerateSpeechStandard(text: string, options: FunctionCallOptions): PromiseLike<Buffer>;
 }
 export interface StreamingSpeechGenerationModel<SETTINGS extends SpeechGenerationModelSettings = SpeechGenerationModelSettings> extends SpeechGenerationModel<SETTINGS> {
-    doGenerateSpeechStreamDuplex(textStream: AsyncIterable<string>, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<Buffer>>>;
+    doGenerateSpeechStreamDuplex(textStream: AsyncIterable<string>, options: FunctionCallOptions): PromiseLike<AsyncIterable<Delta<Buffer>>>;
 }

package/model-function/generate-structure/StructureFromTextPromptTemplate.d.ts

@@ -1,6 +1,19 @@
 import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
 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> = {
     createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => TARGET_PROMPT;
     extractStructure: (response: string) => unknown;
 };
+export type FlexibleStructureFromTextPromptTemplate<SOURCE_PROMPT, INTERMEDIATE_PROMPT> = {
+    createPrompt: (prompt: SOURCE_PROMPT, schema: Schema<unknown> & JsonSchemaProducer) => INTERMEDIATE_PROMPT;
+    extractStructure: (response: string) => unknown;
+    adaptModel: (model: TextStreamingModel<never> & {
+        withTextPrompt(): TextStreamingModel<string>;
+        withInstructionPrompt(): TextStreamingModel<InstructionPrompt>;
+        withChatPrompt(): TextStreamingModel<ChatPrompt>;
+        withJsonOutput?: () => typeof model;
+    }) => TextStreamingModel<INTERMEDIATE_PROMPT>;
+};

package/model-function/generate-structure/generateStructure.cjs

@@ -10,7 +10,10 @@ async function generateStructure(model, schema, prompt, options) {
         : prompt;
     const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-structure",
-        input: expandedPrompt,
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
         model,
         options,
         generateResponse: async (options) => {

package/model-function/generate-structure/generateStructure.js

@@ -7,7 +7,10 @@ export async function generateStructure(model, schema, prompt, options) {
         : prompt;
     const fullResponse = await executeStandardCall({
         functionType: "generate-structure",
-        input: expandedPrompt,
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
         model,
         options,
         generateResponse: async (options) => {

package/model-function/generate-structure/jsonStructurePrompt.cjs

@@ -15,6 +15,12 @@ exports.jsonStructurePrompt = {
                 instruction: prompt,
             }),
             extractStructure,
+            adaptModel: (model) => {
+                if (model.withJsonOutput != null) {
+                    model = model.withJsonOutput();
+                }
+                return model.withInstructionPrompt();
+            },
         };
     },
     instruction({ schemaPrefix, schemaSuffix, } = {}) {
@@ -29,6 +35,12 @@ exports.jsonStructurePrompt = {
                 instruction: prompt.instruction,
             }),
             extractStructure,
+            adaptModel: (model) => {
+                if (model.withJsonOutput != null) {
+                    model = model.withJsonOutput();
+                }
+                return model.withInstructionPrompt();
+            },
         };
     },
 };

package/model-function/generate-structure/jsonStructurePrompt.d.ts

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

package/model-function/generate-structure/jsonStructurePrompt.js

@@ -12,6 +12,12 @@ export const jsonStructurePrompt = {
                 instruction: prompt,
             }),
             extractStructure,
+            adaptModel: (model) => {
+                if (model.withJsonOutput != null) {
+                    model = model.withJsonOutput();
+                }
+                return model.withInstructionPrompt();
+            },
         };
     },
     instruction({ schemaPrefix, schemaSuffix, } = {}) {
@@ -26,6 +32,12 @@ export const jsonStructurePrompt = {
                 instruction: prompt.instruction,
             }),
             extractStructure,
+            adaptModel: (model) => {
+                if (model.withJsonOutput != null) {
+                    model = model.withJsonOutput();
+                }
+                return model.withInstructionPrompt();
+            },
         };
     },
 };

package/model-function/generate-structure/streamStructure.cjs

@@ -12,7 +12,10 @@ async function streamStructure(model, schema, prompt, options) {
     let lastStructure;
     const fullResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
         functionType: "stream-structure",
-        input: prompt,
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
         model,
         options,
         startStream: async (options) => model.doStreamStructure(schema, expandedPrompt, options),

package/model-function/generate-structure/streamStructure.js

@@ -9,7 +9,10 @@ export async function streamStructure(model, schema, prompt, options) {
     let lastStructure;
     const fullResponse = await executeStreamCall({
         functionType: "stream-structure",
-        input: prompt,
+        input: {
+            schema,
+            prompt: expandedPrompt,
+        },
         model,
         options,
         startStream: async (options) => model.doStreamStructure(schema, expandedPrompt, options),

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

@@ -44,6 +44,9 @@ class PromptTemplateTextGenerationModel {
         const mappedPrompt = this.promptTemplate.format(prompt);
         return this.model.doGenerateTexts(mappedPrompt, options);
     }
+    restoreGeneratedTexts(rawResponse) {
+        return this.model.restoreGeneratedTexts(rawResponse);
+    }
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { TextGenerationToolCallModel, ToolCallPromptTemplate } from "../../tool/generate-tool-call/TextGenerationToolCallModel.js";
 import { TextGenerationToolCallsModel } from "../../tool/generate-tool-calls/TextGenerationToolCallsModel.js";
 import { ToolCallsPromptTemplate } from "../../tool/generate-tool-calls/ToolCallsPromptTemplate.js";
@@ -18,7 +18,7 @@ export declare class PromptTemplateTextGenerationModel<PROMPT, MODEL_PROMPT, SET
     get tokenizer(): MODEL["tokenizer"];
     get contextWindowSize(): MODEL["contextWindowSize"];
     get countPromptTokens(): MODEL["countPromptTokens"] extends undefined ? undefined : (prompt: PROMPT) => PromiseLike<number>;
-    doGenerateTexts(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateTexts(prompt: PROMPT, options?: FunctionCallOptions): PromiseLike<{
         response: unknown;
         textGenerationResults: import("./TextGenerationResult.js").TextGenerationResult[];
         usage?: {
@@ -27,6 +27,15 @@ export declare class PromptTemplateTextGenerationModel<PROMPT, MODEL_PROMPT, SET
             totalTokens: number;
         } | undefined;
     }>;
+    restoreGeneratedTexts(rawResponse: unknown): {
+        response: unknown;
+        textGenerationResults: import("./TextGenerationResult.js").TextGenerationResult[];
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
     get settingsForEvent(): Partial<SETTINGS>;
     asToolCallGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallModel<INPUT_PROMPT, PROMPT, this>;
     asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationToolCallsModel<INPUT_PROMPT, PROMPT, this>;

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

@@ -41,6 +41,9 @@ export class PromptTemplateTextGenerationModel {
         const mappedPrompt = this.promptTemplate.format(prompt);
         return this.model.doGenerateTexts(mappedPrompt, options);
     }
+    restoreGeneratedTexts(rawResponse) {
+        return this.model.restoreGeneratedTexts(rawResponse);
+    }
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { StructureFromTextPromptTemplate } from "../generate-structure/StructureFromTextPromptTemplate.js";
 import { StructureFromTextStreamingModel } from "../generate-structure/StructureFromTextStreamingModel.js";
 import { PromptTemplateTextGenerationModel } from "./PromptTemplateTextGenerationModel.js";
@@ -9,7 +9,7 @@ export declare class PromptTemplateTextStreamingModel<PROMPT, MODEL_PROMPT, SETT
         model: MODEL;
         promptTemplate: TextGenerationPromptTemplate<PROMPT, MODEL_PROMPT>;
     });
-    doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<import("../Delta.js").Delta<unknown>>>;
+    doStreamText(prompt: PROMPT, options?: FunctionCallOptions): PromiseLike<AsyncIterable<import("../Delta.js").Delta<unknown>>>;
     extractTextDelta(delta: unknown): string | undefined;
     asStructureGenerationModel<INPUT_PROMPT>(promptTemplate: StructureFromTextPromptTemplate<INPUT_PROMPT, PROMPT>): StructureFromTextStreamingModel<INPUT_PROMPT, PROMPT, this>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): PromptTemplateTextStreamingModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { Delta } from "../Delta.js";
 import { Model, ModelSettings } from "../Model.js";
 import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
@@ -62,7 +62,7 @@ export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationMode
      * Optional. Implement if you have a tokenizer and want to count the number of tokens in a prompt.
      */
     readonly countPromptTokens: ((prompt: PROMPT) => PromiseLike<number>) | undefined;
-    doGenerateTexts(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateTexts(prompt: PROMPT, options?: FunctionCallOptions): PromiseLike<{
         response: unknown;
         textGenerationResults: TextGenerationResult[];
         usage?: {
@@ -71,10 +71,23 @@ export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationMode
             totalTokens: number;
         };
     }>;
+    restoreGeneratedTexts(rawResponse: unknown): {
+        response: unknown;
+        textGenerationResults: TextGenerationResult[];
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    };
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): TextGenerationModel<INPUT_PROMPT, SETTINGS>;
+    /**
+     * Optional. When available, forces the model to return JSON as the text output.
+     */
+    withJsonOutput?(): this;
 }
 export interface TextStreamingModel<PROMPT, SETTINGS extends TextGenerationModelSettings = TextGenerationModelSettings> extends TextGenerationModel<PROMPT, SETTINGS> {
-    doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<unknown>>>;
+    doStreamText(prompt: PROMPT, options?: FunctionCallOptions): PromiseLike<AsyncIterable<Delta<unknown>>>;
     extractTextDelta(delta: unknown): string | undefined;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, PROMPT>): TextStreamingModel<INPUT_PROMPT, SETTINGS>;
 }

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

@@ -9,7 +9,48 @@ async function generateText(model, prompt, options) {
         model,
         options,
         generateResponse: async (options) => {
-            const result = await model.doGenerateTexts(prompt, options);
+            async function getGeneratedTexts() {
+                if (options?.cache == null) {
+                    return {
+                        ...(await model.doGenerateTexts(prompt, options)),
+                        cache: undefined,
+                    };
+                }
+                let cacheErrors = undefined;
+                const cacheKey = {
+                    functionType: "generate-text",
+                    functionId: options?.functionId,
+                    input: {
+                        model,
+                        settings: model.settingsForEvent, // TODO should include full model information
+                        prompt,
+                    },
+                };
+                try {
+                    const cachedRawResponse = await options.cache.lookupValue(cacheKey);
+                    if (cachedRawResponse != null) {
+                        return {
+                            ...model.restoreGeneratedTexts(cachedRawResponse),
+                            cache: { status: "hit" },
+                        };
+                    }
+                }
+                catch (err) {
+                    cacheErrors = [err];
+                }
+                const result = await model.doGenerateTexts(prompt, options);
+                try {
+                    await options.cache.storeValue(cacheKey, result.response);
+                }
+                catch (err) {
+                    cacheErrors = [...(cacheErrors ?? []), err];
+                }
+                return {
+                    ...result,
+                    cache: { status: "miss", errors: cacheErrors },
+                };
+            }
+            const result = await getGeneratedTexts();
             const shouldTrimWhitespace = model.settings.trimWhitespace ?? true;
             const textGenerationResults = shouldTrimWhitespace
                 ? result.textGenerationResults.map((textGeneration) => ({
@@ -17,6 +58,7 @@ async function generateText(model, prompt, options) {
                     finishReason: textGeneration.finishReason,
                 }))
                 : result.textGenerationResults;
+            // TODO add cache information
             return {
                 response: result.response,
                 extractedValue: textGenerationResults,

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

@@ -6,7 +6,48 @@ export async function generateText(model, prompt, options) {
         model,
         options,
         generateResponse: async (options) => {
-            const result = await model.doGenerateTexts(prompt, options);
+            async function getGeneratedTexts() {
+                if (options?.cache == null) {
+                    return {
+                        ...(await model.doGenerateTexts(prompt, options)),
+                        cache: undefined,
+                    };
+                }
+                let cacheErrors = undefined;
+                const cacheKey = {
+                    functionType: "generate-text",
+                    functionId: options?.functionId,
+                    input: {
+                        model,
+                        settings: model.settingsForEvent, // TODO should include full model information
+                        prompt,
+                    },
+                };
+                try {
+                    const cachedRawResponse = await options.cache.lookupValue(cacheKey);
+                    if (cachedRawResponse != null) {
+                        return {
+                            ...model.restoreGeneratedTexts(cachedRawResponse),
+                            cache: { status: "hit" },
+                        };
+                    }
+                }
+                catch (err) {
+                    cacheErrors = [err];
+                }
+                const result = await model.doGenerateTexts(prompt, options);
+                try {
+                    await options.cache.storeValue(cacheKey, result.response);
+                }
+                catch (err) {
+                    cacheErrors = [...(cacheErrors ?? []), err];
+                }
+                return {
+                    ...result,
+                    cache: { status: "miss", errors: cacheErrors },
+                };
+            }
+            const result = await getGeneratedTexts();
             const shouldTrimWhitespace = model.settings.trimWhitespace ?? true;
             const textGenerationResults = shouldTrimWhitespace
                 ? result.textGenerationResults.map((textGeneration) => ({
@@ -14,6 +55,7 @@ export async function generateText(model, prompt, options) {
                     finishReason: textGeneration.finishReason,
                 }))
                 : result.textGenerationResults;
+            // TODO add cache information
             return {
                 response: result.response,
                 extractedValue: textGenerationResults,

package/model-function/generate-transcription/TranscriptionModel.d.ts

@@ -1,9 +1,9 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface TranscriptionModelSettings extends ModelSettings {
 }
 export interface TranscriptionModel<DATA, SETTINGS extends TranscriptionModelSettings = TranscriptionModelSettings> extends Model<SETTINGS> {
-    doTranscribe: (data: DATA, options?: FunctionOptions) => PromiseLike<{
+    doTranscribe: (data: DATA, options: FunctionCallOptions) => PromiseLike<{
         response: unknown;
         transcription: string;
     }>;

package/model-provider/anthropic/AnthropicTextGenerationModel.cjs

@@ -6,6 +6,7 @@ const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndTh
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
 const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
+const validateTypes_js_1 = require("../../core/schema/validateTypes.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptTemplateTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptTemplateTextStreamingModel.cjs");
 const TextGenerationModel_js_1 = require("../../model-function/generate-text/TextGenerationModel.cjs");
@@ -69,17 +70,22 @@ class AnthropicTextGenerationModel extends AbstractModel_js_1.AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions, options) {
         const api = this.settings.api ?? new AnthropicApiConfiguration_js_1.AnthropicApiConfiguration();
         const responseFormat = options.responseFormat;
-        const abortSignal = options.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         const userId = this.settings.userId;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => (0, postToApi_js_1.postJsonToApi)({
                 url: api.assembleUrl(`/complete`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     model: this.settings.model,
                     prompt,
@@ -108,10 +114,17 @@ class AnthropicTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
     async doGenerateTexts(prompt, options) {
-        const response = await this.callAPI(prompt, {
-            ...options,
+        return this.processTextGenerationResponse(await this.callAPI(prompt, options, {
             responseFormat: exports.AnthropicTextGenerationResponseFormat.json,
-        });
+        }));
+    }
+    restoreGeneratedTexts(rawResponse) {
+        return this.processTextGenerationResponse((0, validateTypes_js_1.validateTypes)({
+            structure: rawResponse,
+            schema: (0, ZodSchema_js_1.zodSchema)(anthropicTextGenerationResponseSchema),
+        }));
+    }
+    processTextGenerationResponse(response) {
         return {
             response,
             textGenerationResults: [
@@ -133,8 +146,7 @@ class AnthropicTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         }
     }
     doStreamText(prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
+        return this.callAPI(prompt, options, {
             responseFormat: exports.AnthropicTextGenerationResponseFormat.deltaIterable,
         });
     }