modelfusion 0.112.0 → 0.114.0

package/model-provider/elevenlabs/ElevenLabsSpeechModel.js

@@ -35,9 +35,9 @@ export class ElevenLabsSpeechModel extends AbstractModel {
     get modelName() {
         return this.settings.voice;
     }
-    async callAPI(text, options) {
+    async callAPI(text, callOptions) {
         const api = this.settings.api ?? new ElevenLabsApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
@@ -46,7 +46,12 @@ export class ElevenLabsSpeechModel extends 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/huggingface/HuggingFaceTextEmbeddingModel.cjs

@@ -80,18 +80,23 @@ class HuggingFaceTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(texts, options) {
+    async callAPI(texts, callOptions) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The HuggingFace feature extraction API is configured to only support ${this.maxValuesPerCall} texts per API call.`);
         }
         const api = this.settings.api ?? new HuggingFaceApiConfiguration_js_1.HuggingFaceApiConfiguration();
-        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(`/${this.settings.model}`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     inputs: texts,
                     options: {

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.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";
@@ -42,10 +42,10 @@ export declare class HuggingFaceTextEmbeddingModel extends AbstractModel<Hugging
     readonly contextWindowSize: undefined;
     readonly embeddingDimensions: number | undefined;
     readonly tokenizer: undefined;
-    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<HuggingFaceTextEmbeddingResponse>;
+    callAPI(texts: Array<string>, callOptions: FunctionCallOptions): Promise<HuggingFaceTextEmbeddingResponse>;
     get settingsForEvent(): Partial<HuggingFaceTextEmbeddingModelSettings>;
     readonly countPromptTokens: undefined;
-    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+    doEmbedValues(texts: string[], options: FunctionCallOptions): Promise<{
         response: number[][];
         embeddings: number[][];
     }>;

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.js

@@ -77,18 +77,23 @@ export class HuggingFaceTextEmbeddingModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(texts, options) {
+    async callAPI(texts, callOptions) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The HuggingFace feature extraction API is configured to only support ${this.maxValuesPerCall} texts per API call.`);
         }
         const api = this.settings.api ?? new HuggingFaceApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/${this.settings.model}`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     inputs: texts,
                     options: {

package/model-provider/huggingface/HuggingFaceTextGenerationModel.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 PromptTemplateTextGenerationModel_js_1 = require("../../model-function/generate-text/PromptTemplateTextGenerationModel.cjs");
 const TextGenerationModel_js_1 = require("../../model-function/generate-text/TextGenerationModel.cjs");
@@ -59,15 +60,20 @@ class HuggingFaceTextGenerationModel extends AbstractModel_js_1.AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions) {
         const api = this.settings.api ?? new HuggingFaceApiConfiguration_js_1.HuggingFaceApiConfiguration();
-        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(`/${this.settings.model}`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     inputs: prompt,
                     top_k: this.settings.topK,
@@ -102,7 +108,15 @@ class HuggingFaceTextGenerationModel 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));
+    }
+    restoreGeneratedTexts(rawResponse) {
+        return this.processTextGenerationResponse((0, validateTypes_js_1.validateTypes)({
+            structure: rawResponse,
+            schema: (0, ZodSchema_js_1.zodSchema)(huggingFaceTextGenerationResponseSchema),
+        }));
+    }
+    processTextGenerationResponse(response) {
         return {
             response,
             textGenerationResults: response.map((response) => ({

package/model-provider/huggingface/HuggingFaceTextGenerationModel.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 { PromptTemplateTextGenerationModel } from "../../model-function/generate-text/PromptTemplateTextGenerationModel.js";
@@ -40,9 +40,9 @@ export declare class HuggingFaceTextGenerationModel extends AbstractModel<Huggin
     readonly contextWindowSize: undefined;
     readonly tokenizer: undefined;
     readonly countPromptTokens: undefined;
-    callAPI(prompt: string, options?: FunctionOptions): Promise<HuggingFaceTextGenerationResponse>;
+    callAPI(prompt: string, callOptions: FunctionCallOptions): Promise<HuggingFaceTextGenerationResponse>;
     get settingsForEvent(): Partial<HuggingFaceTextGenerationModelSettings>;
-    doGenerateTexts(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: string, options: FunctionCallOptions): Promise<{
         response: {
             generated_text: string;
         }[];
@@ -51,6 +51,24 @@ export declare class HuggingFaceTextGenerationModel extends AbstractModel<Huggin
             finishReason: "unknown";
         }[];
     }>;
+    restoreGeneratedTexts(rawResponse: unknown): {
+        response: {
+            generated_text: string;
+        }[];
+        textGenerationResults: {
+            text: string;
+            finishReason: "unknown";
+        }[];
+    };
+    processTextGenerationResponse(response: HuggingFaceTextGenerationResponse): {
+        response: {
+            generated_text: string;
+        }[];
+        textGenerationResults: {
+            text: string;
+            finishReason: "unknown";
+        }[];
+    };
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, string>): PromptTemplateTextGenerationModel<INPUT_PROMPT, string, HuggingFaceTextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<HuggingFaceTextGenerationModelSettings>): this;
 }

package/model-provider/huggingface/HuggingFaceTextGenerationModel.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 { PromptTemplateTextGenerationModel } from "../../model-function/generate-text/PromptTemplateTextGenerationModel.js";
 import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
@@ -56,15 +57,20 @@ export class HuggingFaceTextGenerationModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions) {
         const api = this.settings.api ?? new HuggingFaceApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/${this.settings.model}`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     inputs: prompt,
                     top_k: this.settings.topK,
@@ -99,7 +105,15 @@ export class HuggingFaceTextGenerationModel 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));
+    }
+    restoreGeneratedTexts(rawResponse) {
+        return this.processTextGenerationResponse(validateTypes({
+            structure: rawResponse,
+            schema: zodSchema(huggingFaceTextGenerationResponseSchema),
+        }));
+    }
+    processTextGenerationResponse(response) {
         return {
             response,
             textGenerationResults: response.map((response) => ({

package/model-provider/llamacpp/LlamaCppCompletionModel.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");
@@ -37,16 +38,21 @@ class LlamaCppCompletionModel extends AbstractModel_js_1.AbstractModel {
     get contextWindowSize() {
         return this.settings.contextWindowSize;
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions, options) {
         const api = this.settings.api ?? new LlamaCppApiConfiguration_js_1.LlamaCppApiConfiguration();
         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(`/completion`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     stream: responseFormat.stream,
                     prompt: prompt.text,
@@ -123,10 +129,17 @@ class LlamaCppCompletionModel extends AbstractModel_js_1.AbstractModel {
         return tokens.length;
     }
     async doGenerateTexts(prompt, options) {
-        const response = await this.callAPI(prompt, {
-            ...options,
+        return this.processTextGenerationResponse(await this.callAPI(prompt, options, {
             responseFormat: exports.LlamaCppCompletionResponseFormat.json,
-        });
+        }));
+    }
+    restoreGeneratedTexts(rawResponse) {
+        return this.processTextGenerationResponse((0, validateTypes_js_1.validateTypes)({
+            structure: rawResponse,
+            schema: (0, ZodSchema_js_1.zodSchema)(llamaCppTextGenerationResponseSchema),
+        }));
+    }
+    processTextGenerationResponse(response) {
         return {
             response,
             textGenerationResults: [
@@ -147,8 +160,7 @@ class LlamaCppCompletionModel extends AbstractModel_js_1.AbstractModel {
         };
     }
     doStreamText(prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
+        return this.callAPI(prompt, options, {
             responseFormat: exports.LlamaCppCompletionResponseFormat.deltaIterable,
         });
     }

package/model-provider/llamacpp/LlamaCppCompletionModel.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";
@@ -138,12 +138,12 @@ export declare class LlamaCppCompletionModel<CONTEXT_WINDOW_SIZE extends number
     get modelName(): null;
     get contextWindowSize(): CONTEXT_WINDOW_SIZE;
     readonly tokenizer: LlamaCppTokenizer;
-    callAPI<RESPONSE>(prompt: LlamaCppCompletionPrompt, options: {
+    callAPI<RESPONSE>(prompt: LlamaCppCompletionPrompt, callOptions: FunctionCallOptions, options: {
         responseFormat: LlamaCppCompletionResponseFormatType<RESPONSE>;
-    } & FunctionOptions): Promise<RESPONSE>;
+    }): Promise<RESPONSE>;
     get settingsForEvent(): Partial<LlamaCppCompletionModelSettings<CONTEXT_WINDOW_SIZE>>;
     countPromptTokens(prompt: LlamaCppCompletionPrompt): Promise<number>;
-    doGenerateTexts(prompt: LlamaCppCompletionPrompt, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: LlamaCppCompletionPrompt, options: FunctionCallOptions): Promise<{
         response: {
             model: string;
             stop: true;
@@ -203,7 +203,127 @@ export declare class LlamaCppCompletionModel<CONTEXT_WINDOW_SIZE extends number
             totalTokens: number;
         };
     }>;
-    doStreamText(prompt: LlamaCppCompletionPrompt, options?: FunctionOptions): Promise<AsyncIterable<Delta<{
+    restoreGeneratedTexts(rawResponse: unknown): {
+        response: {
+            model: string;
+            stop: true;
+            content: string;
+            prompt: string;
+            generation_settings: {
+                model: string;
+                stream: boolean;
+                stop: string[];
+                seed: number;
+                mirostat: number;
+                frequency_penalty: number;
+                ignore_eos: boolean;
+                logit_bias: number[];
+                mirostat_eta: number;
+                mirostat_tau: number;
+                n_ctx: number;
+                n_keep: number;
+                n_predict: number;
+                n_probs: number;
+                penalize_nl: boolean;
+                presence_penalty: number;
+                repeat_last_n: number;
+                repeat_penalty: number;
+                tfs_z: number;
+                top_k: number;
+                top_p: number;
+                typical_p: number;
+                temperature?: number | undefined;
+            };
+            stopped_eos: boolean;
+            stopped_limit: boolean;
+            stopped_word: boolean;
+            stopping_word: string;
+            timings: {
+                predicted_ms: number;
+                predicted_n: number;
+                predicted_per_second: number | null;
+                predicted_per_token_ms: number | null;
+                prompt_n: number;
+                prompt_per_second: number | null;
+                prompt_per_token_ms: number | null;
+                prompt_ms?: number | null | undefined;
+            };
+            tokens_cached: number;
+            tokens_evaluated: number;
+            tokens_predicted: number;
+            truncated: boolean;
+        };
+        textGenerationResults: {
+            text: string;
+            finishReason: "length" | "stop" | "unknown";
+        }[];
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    };
+    processTextGenerationResponse(response: LlamaCppTextGenerationResponse): {
+        response: {
+            model: string;
+            stop: true;
+            content: string;
+            prompt: string;
+            generation_settings: {
+                model: string;
+                stream: boolean;
+                stop: string[];
+                seed: number;
+                mirostat: number;
+                frequency_penalty: number;
+                ignore_eos: boolean;
+                logit_bias: number[];
+                mirostat_eta: number;
+                mirostat_tau: number;
+                n_ctx: number;
+                n_keep: number;
+                n_predict: number;
+                n_probs: number;
+                penalize_nl: boolean;
+                presence_penalty: number;
+                repeat_last_n: number;
+                repeat_penalty: number;
+                tfs_z: number;
+                top_k: number;
+                top_p: number;
+                typical_p: number;
+                temperature?: number | undefined;
+            };
+            stopped_eos: boolean;
+            stopped_limit: boolean;
+            stopped_word: boolean;
+            stopping_word: string;
+            timings: {
+                predicted_ms: number;
+                predicted_n: number;
+                predicted_per_second: number | null;
+                predicted_per_token_ms: number | null;
+                prompt_n: number;
+                prompt_per_second: number | null;
+                prompt_per_token_ms: number | null;
+                prompt_ms?: number | null | undefined;
+            };
+            tokens_cached: number;
+            tokens_evaluated: number;
+            tokens_predicted: number;
+            truncated: boolean;
+        };
+        textGenerationResults: {
+            text: string;
+            finishReason: "length" | "stop" | "unknown";
+        }[];
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    };
+    doStreamText(prompt: LlamaCppCompletionPrompt, options: FunctionCallOptions): Promise<AsyncIterable<Delta<{
         model: string;
         stop: true;
         content: string;

package/model-provider/llamacpp/LlamaCppCompletionModel.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";
@@ -34,16 +35,21 @@ export class LlamaCppCompletionModel extends AbstractModel {
     get contextWindowSize() {
         return this.settings.contextWindowSize;
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions, options) {
         const api = this.settings.api ?? new LlamaCppApiConfiguration();
         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(`/completion`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     stream: responseFormat.stream,
                     prompt: prompt.text,
@@ -120,10 +126,17 @@ export class LlamaCppCompletionModel extends AbstractModel {
         return tokens.length;
     }
     async doGenerateTexts(prompt, options) {
-        const response = await this.callAPI(prompt, {
-            ...options,
+        return this.processTextGenerationResponse(await this.callAPI(prompt, options, {
             responseFormat: LlamaCppCompletionResponseFormat.json,
-        });
+        }));
+    }
+    restoreGeneratedTexts(rawResponse) {
+        return this.processTextGenerationResponse(validateTypes({
+            structure: rawResponse,
+            schema: zodSchema(llamaCppTextGenerationResponseSchema),
+        }));
+    }
+    processTextGenerationResponse(response) {
         return {
             response,
             textGenerationResults: [
@@ -144,8 +157,7 @@ export class LlamaCppCompletionModel extends AbstractModel {
         };
     }
     doStreamText(prompt, options) {
-        return this.callAPI(prompt, {
-            ...options,
+        return this.callAPI(prompt, options, {
             responseFormat: LlamaCppCompletionResponseFormat.deltaIterable,
         });
     }

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.cjs

@@ -50,18 +50,23 @@ class LlamaCppTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
     async tokenize(text) {
         return this.tokenizer.tokenize(text);
     }
-    async callAPI(texts, options) {
+    async callAPI(texts, callOptions) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Llama.cpp embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
         const api = this.settings.api ?? new LlamaCppApiConfiguration_js_1.LlamaCppApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
             call: async () => (0, postToApi_js_1.postJsonToApi)({
                 url: api.assembleUrl(`/embedding`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: { content: texts[0] },
                 failedResponseHandler: LlamaCppError_js_1.failedLlamaCppCallResponseHandler,
                 successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(llamaCppTextEmbeddingResponseSchema)),

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.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";
@@ -18,9 +18,9 @@ export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTe
     get embeddingDimensions(): number | undefined;
     private readonly tokenizer;
     tokenize(text: string): Promise<number[]>;
-    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<LlamaCppTextEmbeddingResponse>;
+    callAPI(texts: Array<string>, callOptions: FunctionCallOptions): Promise<LlamaCppTextEmbeddingResponse>;
     get settingsForEvent(): Partial<LlamaCppTextEmbeddingModelSettings>;
-    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+    doEmbedValues(texts: string[], options: FunctionCallOptions): Promise<{
         response: {
             embedding: number[];
         };

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.js

@@ -47,18 +47,23 @@ export class LlamaCppTextEmbeddingModel extends AbstractModel {
     async tokenize(text) {
         return this.tokenizer.tokenize(text);
     }
-    async callAPI(texts, options) {
+    async callAPI(texts, callOptions) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Llama.cpp embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
         const api = this.settings.api ?? new LlamaCppApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/embedding`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: { content: texts[0] },
                 failedResponseHandler: failedLlamaCppCallResponseHandler,
                 successfulResponseHandler: createJsonResponseHandler(zodSchema(llamaCppTextEmbeddingResponseSchema)),

package/model-provider/llamacpp/LlamaCppTokenizer.cjs

@@ -30,15 +30,20 @@ class LlamaCppTokenizer {
         });
         this.api = api;
     }
-    async callTokenizeAPI(text, context) {
+    async callTokenizeAPI(text, callOptions) {
         const api = this.api;
-        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: {
                     content: text,
                 },

package/model-provider/llamacpp/LlamaCppTokenizer.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 { BasicTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
 /**
@@ -18,7 +18,7 @@ import { BasicTokenizer } from "../../model-function/tokenize-text/Tokenizer.js"
 export declare class LlamaCppTokenizer implements BasicTokenizer {
     readonly api: ApiConfiguration;
     constructor(api?: ApiConfiguration);
-    callTokenizeAPI(text: string, context?: Run): Promise<LlamaCppTokenizationResponse>;
+    callTokenizeAPI(text: string, callOptions?: FunctionCallOptions): Promise<LlamaCppTokenizationResponse>;
     tokenize(text: string): Promise<number[]>;
 }
 declare const llamaCppTokenizationResponseSchema: z.ZodObject<{