modelfusion 0.112.0 → 0.114.0

package/model-provider/anthropic/AnthropicTextGenerationModel.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
@@ -46,11 +46,11 @@ export declare class AnthropicTextGenerationModel extends AbstractModel<Anthropi
     readonly contextWindowSize: number;
     readonly tokenizer: undefined;
     readonly countPromptTokens: undefined;
-    callAPI<RESPONSE>(prompt: string, options: {
+    callAPI<RESPONSE>(prompt: string, callOptions: FunctionCallOptions, options: {
         responseFormat: AnthropicTextGenerationResponseFormatType<RESPONSE>;
-    } & FunctionOptions): Promise<RESPONSE>;
+    }): Promise<RESPONSE>;
     get settingsForEvent(): Partial<AnthropicTextGenerationModelSettings>;
-    doGenerateTexts(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: string, options: FunctionCallOptions): Promise<{
         response: {
             model: string;
             completion: string;
@@ -61,8 +61,30 @@ export declare class AnthropicTextGenerationModel extends AbstractModel<Anthropi
             finishReason: TextGenerationFinishReason;
         }[];
     }>;
+    restoreGeneratedTexts(rawResponse: unknown): {
+        response: {
+            model: string;
+            completion: string;
+            stop_reason: string;
+        };
+        textGenerationResults: {
+            text: string;
+            finishReason: TextGenerationFinishReason;
+        }[];
+    };
+    processTextGenerationResponse(response: AnthropicTextGenerationResponse): {
+        response: {
+            model: string;
+            completion: string;
+            stop_reason: string;
+        };
+        textGenerationResults: {
+            text: string;
+            finishReason: TextGenerationFinishReason;
+        }[];
+    };
     private translateFinishReason;
-    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<{
+    doStreamText(prompt: string, options: FunctionCallOptions): Promise<AsyncIterable<Delta<{
         model: string;
         completion: string;
         stop_reason: string | null;

package/model-provider/anthropic/AnthropicTextGenerationModel.js

@@ -3,6 +3,7 @@ import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottl
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
 import { zodSchema } from "../../core/schema/ZodSchema.js";
 import { parseJSON } from "../../core/schema/parseJSON.js";
+import { validateTypes } from "../../core/schema/validateTypes.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
 import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
@@ -66,17 +67,22 @@ export class AnthropicTextGenerationModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions, options) {
         const api = this.settings.api ?? new AnthropicApiConfiguration();
         const responseFormat = options.responseFormat;
-        const abortSignal = options.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         const userId = this.settings.userId;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => 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,
@@ -105,10 +111,17 @@ export class AnthropicTextGenerationModel extends 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: AnthropicTextGenerationResponseFormat.json,
-        });
+        }));
+    }
+    restoreGeneratedTexts(rawResponse) {
+        return this.processTextGenerationResponse(validateTypes({
+            structure: rawResponse,
+            schema: zodSchema(anthropicTextGenerationResponseSchema),
+        }));
+    }
+    processTextGenerationResponse(response) {
         return {
             response,
             textGenerationResults: [
@@ -130,8 +143,7 @@ export class AnthropicTextGenerationModel extends AbstractModel {
         }
     }
     doStreamText(prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
+        return this.callAPI(prompt, options, {
             responseFormat: AnthropicTextGenerationResponseFormat.deltaIterable,
         });
     }

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.cjs

@@ -28,15 +28,20 @@ class Automatic1111ImageGenerationModel extends AbstractModel_js_1.AbstractModel
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(input, options) {
+    async callAPI(input, callOptions) {
         const api = this.settings.api ?? new Automatic1111ApiConfiguration_js_1.Automatic1111ApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => (0, postToApi_js_1.postJsonToApi)({
                 url: api.assembleUrl(`/txt2img`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     prompt: input.prompt,
                     negative_prompt: input.negativePrompt,

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptTemplate } from "../../model-function/PromptTemplate.js";
@@ -37,9 +37,9 @@ export declare class Automatic1111ImageGenerationModel extends AbstractModel<Aut
     constructor(settings: Automatic1111ImageGenerationSettings);
     readonly provider: "Automatic1111";
     get modelName(): string;
-    callAPI(input: Automatic1111ImageGenerationPrompt, options?: FunctionOptions): Promise<Automatic1111ImageGenerationResponse>;
+    callAPI(input: Automatic1111ImageGenerationPrompt, callOptions: FunctionCallOptions): Promise<Automatic1111ImageGenerationResponse>;
     get settingsForEvent(): Partial<Automatic1111ImageGenerationSettings>;
-    doGenerateImages(prompt: Automatic1111ImageGenerationPrompt, options?: FunctionOptions): Promise<{
+    doGenerateImages(prompt: Automatic1111ImageGenerationPrompt, options: FunctionCallOptions): Promise<{
         response: {
             images: string[];
             parameters: {};

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.js

@@ -25,15 +25,20 @@ export class Automatic1111ImageGenerationModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(input, options) {
+    async callAPI(input, callOptions) {
         const api = this.settings.api ?? new Automatic1111ApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/txt2img`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     prompt: input.prompt,
                     negative_prompt: input.negativePrompt,

package/model-provider/cohere/CohereTextEmbeddingModel.cjs

@@ -113,18 +113,23 @@ class CohereTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
     async detokenize(tokens) {
         return this.tokenizer.detokenize(tokens);
     }
-    async callAPI(texts, options) {
+    async callAPI(texts, callOptions) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Cohere embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
         const api = this.settings.api ?? new CohereApiConfiguration_js_1.CohereApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => (0, postToApi_js_1.postJsonToApi)({
                 url: api.assembleUrl(`/embed`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     model: this.settings.model,
                     texts,

package/model-provider/cohere/CohereTextEmbeddingModel.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { EmbeddingModel, EmbeddingModelSettings } from "../../model-function/embed/EmbeddingModel.js";
@@ -70,9 +70,9 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
         tokenTexts: string[];
     }>;
     detokenize(tokens: number[]): Promise<string>;
-    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<CohereTextEmbeddingResponse>;
+    callAPI(texts: Array<string>, callOptions: FunctionCallOptions): Promise<CohereTextEmbeddingResponse>;
     get settingsForEvent(): Partial<CohereTextEmbeddingModelSettings>;
-    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+    doEmbedValues(texts: string[], options: FunctionCallOptions): Promise<{
         response: {
             embeddings: number[][];
             texts: string[];

package/model-provider/cohere/CohereTextEmbeddingModel.js

@@ -110,18 +110,23 @@ export class CohereTextEmbeddingModel extends AbstractModel {
     async detokenize(tokens) {
         return this.tokenizer.detokenize(tokens);
     }
-    async callAPI(texts, options) {
+    async callAPI(texts, callOptions) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Cohere embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
         const api = this.settings.api ?? new CohereApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/embed`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     model: this.settings.model,
                     texts,

package/model-provider/cohere/CohereTextGenerationModel.cjs

@@ -5,6 +5,7 @@ const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const ZodSchema_js_1 = require("../../core/schema/ZodSchema.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");
@@ -73,16 +74,21 @@ class CohereTextGenerationModel extends AbstractModel_js_1.AbstractModel {
     async countPromptTokens(input) {
         return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions, options) {
         const api = this.settings.api ?? new CohereApiConfiguration_js_1.CohereApiConfiguration();
         const responseFormat = options.responseFormat;
-        const abortSignal = options.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => (0, postToApi_js_1.postJsonToApi)({
                 url: api.assembleUrl(`/generate`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     stream: responseFormat.stream,
                     model: this.settings.model,
@@ -122,10 +128,17 @@ class CohereTextGenerationModel 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.CohereTextGenerationResponseFormat.json,
-        });
+        }));
+    }
+    restoreGeneratedTexts(rawResponse) {
+        return this.processTextGenerationResponse((0, validateTypes_js_1.validateTypes)({
+            structure: rawResponse,
+            schema: (0, ZodSchema_js_1.zodSchema)(cohereTextGenerationResponseSchema),
+        }));
+    }
+    processTextGenerationResponse(response) {
         return {
             response,
             textGenerationResults: response.generations.map((generation) => ({
@@ -149,8 +162,7 @@ class CohereTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         }
     }
     doStreamText(prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
+        return this.callAPI(prompt, options, {
             responseFormat: exports.CohereTextGenerationResponseFormat.deltaIterable,
         });
     }

package/model-provider/cohere/CohereTextGenerationModel.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
@@ -54,11 +54,11 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
     readonly contextWindowSize: number;
     readonly tokenizer: CohereTokenizer;
     countPromptTokens(input: string): Promise<number>;
-    callAPI<RESPONSE>(prompt: string, options: {
+    callAPI<RESPONSE>(prompt: string, callOptions: FunctionCallOptions, options: {
         responseFormat: CohereTextGenerationResponseFormatType<RESPONSE>;
-    } & FunctionOptions): Promise<RESPONSE>;
+    }): Promise<RESPONSE>;
     get settingsForEvent(): Partial<CohereTextGenerationModelSettings>;
-    doGenerateTexts(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: string, options: FunctionCallOptions): Promise<{
         response: {
             id: string;
             prompt: string;
@@ -78,8 +78,48 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
             finishReason: TextGenerationFinishReason;
         }[];
     }>;
+    restoreGeneratedTexts(rawResponse: unknown): {
+        response: {
+            id: string;
+            prompt: string;
+            generations: {
+                text: string;
+                id: string;
+                finish_reason?: string | undefined;
+            }[];
+            meta?: {
+                api_version: {
+                    version: string;
+                };
+            } | undefined;
+        };
+        textGenerationResults: {
+            text: string;
+            finishReason: TextGenerationFinishReason;
+        }[];
+    };
+    processTextGenerationResponse(response: CohereTextGenerationResponse): {
+        response: {
+            id: string;
+            prompt: string;
+            generations: {
+                text: string;
+                id: string;
+                finish_reason?: string | undefined;
+            }[];
+            meta?: {
+                api_version: {
+                    version: string;
+                };
+            } | undefined;
+        };
+        textGenerationResults: {
+            text: string;
+            finishReason: TextGenerationFinishReason;
+        }[];
+    };
     private translateFinishReason;
-    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<import("../../index.js").Delta<{
+    doStreamText(prompt: string, options: FunctionCallOptions): Promise<AsyncIterable<import("../../index.js").Delta<{
         text: string;
         is_finished: false;
     } | {

package/model-provider/cohere/CohereTextGenerationModel.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
 import { zodSchema } from "../../core/schema/ZodSchema.js";
+import { validateTypes } from "../../core/schema/validateTypes.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
 import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
@@ -70,16 +71,21 @@ export class CohereTextGenerationModel extends AbstractModel {
     async countPromptTokens(input) {
         return countTokens(this.tokenizer, input);
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions, options) {
         const api = this.settings.api ?? new CohereApiConfiguration();
         const responseFormat = options.responseFormat;
-        const abortSignal = options.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/generate`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     stream: responseFormat.stream,
                     model: this.settings.model,
@@ -119,10 +125,17 @@ export class CohereTextGenerationModel extends 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: CohereTextGenerationResponseFormat.json,
-        });
+        }));
+    }
+    restoreGeneratedTexts(rawResponse) {
+        return this.processTextGenerationResponse(validateTypes({
+            structure: rawResponse,
+            schema: zodSchema(cohereTextGenerationResponseSchema),
+        }));
+    }
+    processTextGenerationResponse(response) {
         return {
             response,
             textGenerationResults: response.generations.map((generation) => ({
@@ -146,8 +159,7 @@ export class CohereTextGenerationModel extends AbstractModel {
         }
     }
     doStreamText(prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
+        return this.callAPI(prompt, options, {
             responseFormat: CohereTextGenerationResponseFormat.deltaIterable,
         });
     }

package/model-provider/cohere/CohereTokenizer.cjs

@@ -33,15 +33,20 @@ class CohereTokenizer {
         });
         this.settings = settings;
     }
-    async callTokenizeAPI(text, context) {
+    async callTokenizeAPI(text, callOptions) {
         const api = this.settings.api ?? new CohereApiConfiguration_js_1.CohereApiConfiguration();
-        const abortSignal = context?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => (0, postToApi_js_1.postJsonToApi)({
                 url: api.assembleUrl(`/tokenize`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: "tokenize",
+                    functionId: callOptions?.functionId,
+                    run: callOptions?.run,
+                    callId: "",
+                }),
                 body: {
                     model: this.settings.model,
                     text,
@@ -52,15 +57,20 @@ class CohereTokenizer {
             }),
         });
     }
-    async callDeTokenizeAPI(tokens, context) {
+    async callDeTokenizeAPI(tokens, callOptions) {
         const api = this.settings.api ?? new CohereApiConfiguration_js_1.CohereApiConfiguration();
-        const abortSignal = context?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => (0, postToApi_js_1.postJsonToApi)({
                 url: api.assembleUrl(`/detokenize`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: "detokenize",
+                    functionId: callOptions?.functionId,
+                    run: callOptions?.run,
+                    callId: "",
+                }),
                 body: {
                     model: this.settings.model,
                     tokens,

package/model-provider/cohere/CohereTokenizer.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Run } from "../../core/Run.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
 import { CohereTextEmbeddingModelType } from "./CohereTextEmbeddingModel.js";
@@ -28,8 +28,8 @@ export interface CohereTokenizerSettings {
 export declare class CohereTokenizer implements FullTokenizer {
     readonly settings: CohereTokenizerSettings;
     constructor(settings: CohereTokenizerSettings);
-    callTokenizeAPI(text: string, context?: Run): Promise<CohereTokenizationResponse>;
-    callDeTokenizeAPI(tokens: number[], context?: Run): Promise<CohereDetokenizationResponse>;
+    callTokenizeAPI(text: string, callOptions?: FunctionCallOptions): Promise<CohereTokenizationResponse>;
+    callDeTokenizeAPI(tokens: number[], callOptions?: FunctionCallOptions): Promise<CohereDetokenizationResponse>;
     tokenize(text: string): Promise<number[]>;
     tokenizeWithTexts(text: string): Promise<{
         tokens: number[];

package/model-provider/cohere/CohereTokenizer.js

@@ -30,15 +30,20 @@ export class CohereTokenizer {
         });
         this.settings = settings;
     }
-    async callTokenizeAPI(text, context) {
+    async callTokenizeAPI(text, callOptions) {
         const api = this.settings.api ?? new CohereApiConfiguration();
-        const abortSignal = context?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/tokenize`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: "tokenize",
+                    functionId: callOptions?.functionId,
+                    run: callOptions?.run,
+                    callId: "",
+                }),
                 body: {
                     model: this.settings.model,
                     text,
@@ -49,15 +54,20 @@ export class CohereTokenizer {
             }),
         });
     }
-    async callDeTokenizeAPI(tokens, context) {
+    async callDeTokenizeAPI(tokens, callOptions) {
         const api = this.settings.api ?? new CohereApiConfiguration();
-        const abortSignal = context?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/detokenize`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: "detokenize",
+                    functionId: callOptions?.functionId,
+                    run: callOptions?.run,
+                    callId: "",
+                }),
                 body: {
                     model: this.settings.model,
                     tokens,

package/model-provider/elevenlabs/ElevenLabsApiConfiguration.cjs

@@ -27,7 +27,7 @@ class ElevenLabsApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApi
         });
     }
     get apiKey() {
-        return this.headers["xi-api-key"];
+        return this.fixedHeadersValue["xi-api-key"];
     }
 }
 exports.ElevenLabsApiConfiguration = ElevenLabsApiConfiguration;

package/model-provider/elevenlabs/ElevenLabsApiConfiguration.js

@@ -24,6 +24,6 @@ export class ElevenLabsApiConfiguration extends BaseUrlApiConfigurationWithDefau
         });
     }
     get apiKey() {
-        return this.headers["xi-api-key"];
+        return this.fixedHeadersValue["xi-api-key"];
     }
 }

package/model-provider/elevenlabs/ElevenLabsSpeechModel.cjs

@@ -38,9 +38,9 @@ class ElevenLabsSpeechModel extends AbstractModel_js_1.AbstractModel {
     get modelName() {
         return this.settings.voice;
     }
-    async callAPI(text, options) {
+    async callAPI(text, callOptions) {
         const api = this.settings.api ?? new ElevenLabsApiConfiguration_js_1.ElevenLabsApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
@@ -49,7 +49,12 @@ class ElevenLabsSpeechModel extends AbstractModel_js_1.AbstractModel {
                     optimize_streaming_latency: this.settings.optimizeStreamingLatency,
                     output_format: this.settings.outputFormat,
                 })}`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     text,
                     model_id: this.settings.model ?? defaultModel,

package/model-provider/elevenlabs/ElevenLabsSpeechModel.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { Delta } from "../../model-function/Delta.js";
@@ -37,7 +37,7 @@ export declare class ElevenLabsSpeechModel extends AbstractModel<ElevenLabsSpeec
     get modelName(): string;
     private callAPI;
     get settingsForEvent(): Partial<ElevenLabsSpeechModelSettings>;
-    doGenerateSpeechStandard(text: string, options?: FunctionOptions): Promise<Buffer>;
+    doGenerateSpeechStandard(text: string, options: FunctionCallOptions): Promise<Buffer>;
     doGenerateSpeechStreamDuplex(textStream: AsyncIterable<string>): Promise<AsyncIterable<Delta<Buffer>>>;
     withSettings(additionalSettings: Partial<ElevenLabsSpeechModelSettings>): this;
 }