modelfusion 0.113.0 → 0.114.0

package/model-provider/openai/OpenAIChatFunctionCallStructureGenerationModel.js

@@ -38,10 +38,18 @@ export class OpenAIChatFunctionCallStructureGenerationModel {
         return this.model.modelInformation;
     }
     get settings() {
-        return this.model.settings;
+        return {
+            ...this.model.settings,
+            fnName: this.fnName,
+            fnDescription: this.fnDescription,
+        };
     }
     get settingsForEvent() {
-        return this.model.settingsForEvent;
+        return {
+            ...this.model.settingsForEvent,
+            fnName: this.fnName,
+            fnDescription: this.fnDescription,
+        };
     }
     /**
      * Returns this model with a text prompt template.
@@ -94,8 +102,7 @@ export class OpenAIChatFunctionCallStructureGenerationModel {
                 ...this.promptTemplate.stopSequences,
             ],
         })
-            .callAPI(expandedPrompt, {
-            ...options,
+            .callAPI(expandedPrompt, options, {
             responseFormat: OpenAIChatResponseFormat.json,
             functionCall: { name: this.fnName },
             functions: [
@@ -125,8 +132,7 @@ export class OpenAIChatFunctionCallStructureGenerationModel {
     async doStreamStructure(schema, prompt, // first argument of the function
     options) {
         const expandedPrompt = this.promptTemplate.format(prompt);
-        return this.model.callAPI(expandedPrompt, {
-            ...options,
+        return this.model.callAPI(expandedPrompt, options, {
             responseFormat: OpenAIChatResponseFormat.deltaIterable,
             functionCall: { name: this.fnName },
             functions: [

package/model-provider/openai/OpenAIImageGenerationModel.cjs

@@ -88,17 +88,22 @@ class OpenAIImageGenerationModel 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 OpenAIApiConfiguration_js_1.OpenAIApiConfiguration();
-        const abortSignal = options.run?.abortSignal;
-        const userId = options.run?.userId;
+        const abortSignal = callOptions.run?.abortSignal;
+        const userId = callOptions.run?.userId;
         const responseFormat = options.responseFormat;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => (0, postToApi_js_1.postJsonToApi)({
                 url: api.assembleUrl("/images/generations"),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     prompt,
                     n: this.settings.numberOfGenerations,
@@ -122,9 +127,8 @@ class OpenAIImageGenerationModel extends AbstractModel_js_1.AbstractModel {
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
     async doGenerateImages(prompt, options) {
-        const response = await this.callAPI(prompt, {
+        const response = await this.callAPI(prompt, options, {
             responseFormat: exports.OpenAIImageGenerationResponseFormat.base64Json,
-            ...options,
         });
         return {
             response,

package/model-provider/openai/OpenAIImageGenerationModel.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";
@@ -47,11 +47,11 @@ export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImag
     constructor(settings: OpenAIImageGenerationSettings);
     readonly provider: "openai";
     get modelName(): "dall-e-2" | "dall-e-3";
-    callAPI<RESULT>(prompt: string, options: {
+    callAPI<RESULT>(prompt: string, callOptions: FunctionCallOptions, options: {
         responseFormat: OpenAIImageGenerationResponseFormatType<RESULT>;
-    } & FunctionOptions): Promise<RESULT>;
+    }): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAIImageGenerationSettings>;
-    doGenerateImages(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateImages(prompt: string, options: FunctionCallOptions): Promise<{
         response: {
             data: {
                 b64_json: string;

package/model-provider/openai/OpenAIImageGenerationModel.js

@@ -84,17 +84,22 @@ export class OpenAIImageGenerationModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(prompt, options) {
+    async callAPI(prompt, callOptions, options) {
         const api = this.settings.api ?? new OpenAIApiConfiguration();
-        const abortSignal = options.run?.abortSignal;
-        const userId = options.run?.userId;
+        const abortSignal = callOptions.run?.abortSignal;
+        const userId = callOptions.run?.userId;
         const responseFormat = options.responseFormat;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl("/images/generations"),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     prompt,
                     n: this.settings.numberOfGenerations,
@@ -118,9 +123,8 @@ export class OpenAIImageGenerationModel extends AbstractModel {
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
     async doGenerateImages(prompt, options) {
-        const response = await this.callAPI(prompt, {
+        const response = await this.callAPI(prompt, options, {
             responseFormat: OpenAIImageGenerationResponseFormat.base64Json,
-            ...options,
         });
         return {
             response,

package/model-provider/openai/OpenAISpeechModel.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAISpeechModel = exports.calculateOpenAISpeechCostInMillicents = exports.OPENAI_SPEECH_MODELS = void 0;
-const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("./OpenAIError.cjs");
 /**
@@ -45,15 +45,20 @@ class OpenAISpeechModel extends AbstractModel_js_1.AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(text, options) {
+    async callAPI(text, callOptions) {
         const api = this.settings.api ?? new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration();
-        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(`/audio/speech`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     input: text,
                     voice: this.settings.voice,

package/model-provider/openai/OpenAISpeechModel.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { SpeechGenerationModel, SpeechGenerationModelSettings } from "../../model-function/generate-speech/SpeechGenerationModel.js";
 /**
  * @see https://openai.com/pricing
@@ -46,7 +46,7 @@ export declare class OpenAISpeechModel extends AbstractModel<OpenAISpeechModelSe
     get modelName(): "tts-1" | "tts-1-hd";
     private callAPI;
     get settingsForEvent(): Partial<OpenAISpeechModelSettings>;
-    doGenerateSpeechStandard(text: string, options?: FunctionOptions): Promise<Buffer>;
+    doGenerateSpeechStandard(text: string, options: FunctionCallOptions): Promise<Buffer>;
     withSettings(additionalSettings: Partial<OpenAISpeechModelSettings>): this;
 }
 export {};

package/model-provider/openai/OpenAISpeechModel.js

@@ -1,6 +1,6 @@
-import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createAudioMpegResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 /**
@@ -41,15 +41,20 @@ export class OpenAISpeechModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(text, options) {
+    async callAPI(text, callOptions) {
         const api = this.settings.api ?? new OpenAIApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl(`/audio/speech`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     input: text,
                     voice: this.settings.voice,

package/model-provider/openai/OpenAITextEmbeddingModel.cjs

@@ -91,20 +91,25 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
     async countTokens(input) {
         return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
     }
-    async callAPI(texts, options) {
+    async callAPI(texts, callOptions) {
         const api = this.settings.api ?? new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration();
-        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("/embeddings"),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     model: this.modelName,
                     input: texts,
                     user: this.settings.isUserIdForwardingEnabled
-                        ? options?.run?.userId
+                        ? callOptions.run?.userId
                         : undefined,
                 },
                 failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
@@ -116,11 +121,11 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
     get settingsForEvent() {
         return {};
     }
-    async doEmbedValues(texts, options) {
+    async doEmbedValues(texts, callOptions) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
-        const response = await this.callAPI(texts, options);
+        const response = await this.callAPI(texts, callOptions);
         return {
             response,
             embeddings: response.data.map((data) => data.embedding),

package/model-provider/openai/OpenAITextEmbeddingModel.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";
@@ -47,9 +47,9 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     readonly tokenizer: TikTokenTokenizer;
     readonly contextWindowSize: number;
     countTokens(input: string): Promise<number>;
-    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<OpenAITextEmbeddingResponse>;
+    callAPI(texts: Array<string>, callOptions: FunctionCallOptions): Promise<OpenAITextEmbeddingResponse>;
     get settingsForEvent(): Partial<OpenAITextEmbeddingModelSettings>;
-    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+    doEmbedValues(texts: string[], callOptions: FunctionCallOptions): Promise<{
         response: {
             object: "list";
             data: {

package/model-provider/openai/OpenAITextEmbeddingModel.js

@@ -86,20 +86,25 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
     async countTokens(input) {
         return countTokens(this.tokenizer, input);
     }
-    async callAPI(texts, options) {
+    async callAPI(texts, callOptions) {
         const api = this.settings.api ?? new OpenAIApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
             call: async () => postJsonToApi({
                 url: api.assembleUrl("/embeddings"),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     model: this.modelName,
                     input: texts,
                     user: this.settings.isUserIdForwardingEnabled
-                        ? options?.run?.userId
+                        ? callOptions.run?.userId
                         : undefined,
                 },
                 failedResponseHandler: failedOpenAICallResponseHandler,
@@ -111,11 +116,11 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
     get settingsForEvent() {
         return {};
     }
-    async doEmbedValues(texts, options) {
+    async doEmbedValues(texts, callOptions) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
-        const response = await this.callAPI(texts, options);
+        const response = await this.callAPI(texts, callOptions);
         return {
             response,
             embeddings: response.data.map((data) => data.embedding),

package/model-provider/openai/OpenAITranscriptionModel.cjs

@@ -55,19 +55,17 @@ class OpenAITranscriptionModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.model;
     }
     async doTranscribe(data, options) {
-        const response = await this.callAPI(data, {
+        const response = await this.callAPI(data, options, {
             responseFormat: exports.OpenAITranscriptionResponseFormat.verboseJson,
-            functionId: options?.functionId,
-            run: options?.run,
         });
         return {
             response,
             transcription: response.text,
         };
     }
-    async callAPI(data, options) {
+    async callAPI(data, callOptions, options) {
         const api = this.settings.api ?? new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
@@ -90,7 +88,12 @@ class OpenAITranscriptionModel extends AbstractModel_js_1.AbstractModel {
                 }
                 return (0, postToApi_js_1.postToApi)({
                     url: api.assembleUrl("/audio/transcriptions"),
-                    headers: api.headers,
+                    headers: api.headers({
+                        functionType: callOptions.functionType,
+                        functionId: callOptions.functionId,
+                        run: callOptions.run,
+                        callId: callOptions.callId,
+                    }),
                     body: {
                         content: formData,
                         values: {

package/model-provider/openai/OpenAITranscriptionModel.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 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";
@@ -65,7 +65,7 @@ export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITransc
     constructor(settings: OpenAITranscriptionModelSettings);
     readonly provider: "openai";
     get modelName(): "whisper-1";
-    doTranscribe(data: OpenAITranscriptionInput, options?: FunctionOptions): Promise<{
+    doTranscribe(data: OpenAITranscriptionInput, options: FunctionCallOptions): Promise<{
         response: {
             text: string;
             duration: number;
@@ -87,9 +87,9 @@ export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITransc
         };
         transcription: string;
     }>;
-    callAPI<RESULT>(data: OpenAITranscriptionInput, options: {
+    callAPI<RESULT>(data: OpenAITranscriptionInput, callOptions: FunctionCallOptions, options: {
         responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
-    } & FunctionOptions): Promise<RESULT>;
+    }): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAITranscriptionModelSettings>;
     withSettings(additionalSettings: OpenAITranscriptionModelSettings): this;
 }

package/model-provider/openai/OpenAITranscriptionModel.js

@@ -51,19 +51,17 @@ export class OpenAITranscriptionModel extends AbstractModel {
         return this.settings.model;
     }
     async doTranscribe(data, options) {
-        const response = await this.callAPI(data, {
+        const response = await this.callAPI(data, options, {
             responseFormat: OpenAITranscriptionResponseFormat.verboseJson,
-            functionId: options?.functionId,
-            run: options?.run,
         });
         return {
             response,
             transcription: response.text,
         };
     }
-    async callAPI(data, options) {
+    async callAPI(data, callOptions, options) {
         const api = this.settings.api ?? new OpenAIApiConfiguration();
-        const abortSignal = options?.run?.abortSignal;
+        const abortSignal = callOptions?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
@@ -86,7 +84,12 @@ export class OpenAITranscriptionModel extends AbstractModel {
                 }
                 return postToApi({
                     url: api.assembleUrl("/audio/transcriptions"),
-                    headers: api.headers,
+                    headers: api.headers({
+                        functionType: callOptions.functionType,
+                        functionId: callOptions.functionId,
+                        run: callOptions.run,
+                        callId: callOptions.callId,
+                    }),
                     body: {
                         content: formData,
                         values: {

package/model-provider/stability/StabilityImageGenerationModel.cjs

@@ -48,15 +48,20 @@ class StabilityImageGenerationModel 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 StabilityApiConfiguration_js_1.StabilityApiConfiguration();
-        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(`/generation/${this.settings.model}/text-to-image`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     height: this.settings.height,
                     width: this.settings.width,
@@ -88,8 +93,8 @@ class StabilityImageGenerationModel extends AbstractModel_js_1.AbstractModel {
             stylePreset: this.settings.stylePreset,
         };
     }
-    async doGenerateImages(prompt, options) {
-        const response = await this.callAPI(prompt, options);
+    async doGenerateImages(prompt, callOptions) {
+        const response = await this.callAPI(prompt, callOptions);
         return {
             response,
             base64Images: response.artifacts.map((artifact) => artifact.base64),

package/model-provider/stability/StabilityImageGenerationModel.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";
@@ -64,9 +64,9 @@ export declare class StabilityImageGenerationModel extends AbstractModel<Stabili
     constructor(settings: StabilityImageGenerationSettings);
     readonly provider: "stability";
     get modelName(): StabilityImageGenerationModelType;
-    callAPI(input: StabilityImageGenerationPrompt, options?: FunctionOptions): Promise<StabilityImageGenerationResponse>;
+    callAPI(input: StabilityImageGenerationPrompt, callOptions: FunctionCallOptions): Promise<StabilityImageGenerationResponse>;
     get settingsForEvent(): Partial<StabilityImageGenerationSettings>;
-    doGenerateImages(prompt: StabilityImageGenerationPrompt, options?: FunctionOptions): Promise<{
+    doGenerateImages(prompt: StabilityImageGenerationPrompt, callOptions: FunctionCallOptions): Promise<{
         response: {
             artifacts: {
                 base64: string;

package/model-provider/stability/StabilityImageGenerationModel.js

@@ -45,15 +45,20 @@ export class StabilityImageGenerationModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    async callAPI(input, options) {
+    async callAPI(input, callOptions) {
         const api = this.settings.api ?? new StabilityApiConfiguration();
-        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(`/generation/${this.settings.model}/text-to-image`),
-                headers: api.headers,
+                headers: api.headers({
+                    functionType: callOptions.functionType,
+                    functionId: callOptions.functionId,
+                    run: callOptions.run,
+                    callId: callOptions.callId,
+                }),
                 body: {
                     height: this.settings.height,
                     width: this.settings.width,
@@ -85,8 +90,8 @@ export class StabilityImageGenerationModel extends AbstractModel {
             stylePreset: this.settings.stylePreset,
         };
     }
-    async doGenerateImages(prompt, options) {
-        const response = await this.callAPI(prompt, options);
+    async doGenerateImages(prompt, callOptions) {
+        const response = await this.callAPI(prompt, callOptions);
         return {
             response,
             base64Images: response.artifacts.map((artifact) => artifact.base64),

package/model-provider/whispercpp/WhisperCppTranscriptionModel.cjs

@@ -26,19 +26,16 @@ class WhisperCppTranscriptionModel extends AbstractModel_js_1.AbstractModel {
         });
     }
     async doTranscribe(data, options) {
-        const response = await this.callAPI(data, {
-            functionId: options?.functionId,
-            run: options?.run,
-        });
+        const response = await this.callAPI(data, options);
         return {
             response,
             transcription: response.text,
         };
     }
-    async callAPI(data, options) {
+    async callAPI(data, callOptions) {
         const { temperature } = this.settings;
         const api = this.settings.api ?? new WhisperCppApiConfiguration_js_1.WhisperCppApiConfiguration();
-        const abortSignal = options.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
@@ -51,7 +48,12 @@ class WhisperCppTranscriptionModel extends AbstractModel_js_1.AbstractModel {
                 }
                 return (0, postToApi_js_1.postToApi)({
                     url: api.assembleUrl("/inference"),
-                    headers: api.headers,
+                    headers: api.headers({
+                        functionType: callOptions.functionType,
+                        functionId: callOptions.functionId,
+                        run: callOptions.run,
+                        callId: callOptions.callId,
+                    }),
                     body: {
                         content: formData,
                         values: { temperature },

package/model-provider/whispercpp/WhisperCppTranscriptionModel.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 { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/generate-transcription/TranscriptionModel.js";
@@ -15,13 +15,13 @@ export declare class WhisperCppTranscriptionModel extends AbstractModel<WhisperC
     constructor(settings: WhisperCppTranscriptionModelSettings);
     readonly provider: "whispercpp";
     readonly modelName: null;
-    doTranscribe(data: WhisperCppTranscriptionInput, options?: FunctionOptions): Promise<{
+    doTranscribe(data: WhisperCppTranscriptionInput, options: FunctionCallOptions): Promise<{
         response: {
             text: string;
         };
         transcription: string;
     }>;
-    callAPI(data: WhisperCppTranscriptionInput, options: FunctionOptions): Promise<{
+    callAPI(data: WhisperCppTranscriptionInput, callOptions: FunctionCallOptions): Promise<{
         text: string;
     }>;
     get settingsForEvent(): Partial<WhisperCppTranscriptionModelSettings>;

package/model-provider/whispercpp/WhisperCppTranscriptionModel.js

@@ -23,19 +23,16 @@ export class WhisperCppTranscriptionModel extends AbstractModel {
         });
     }
     async doTranscribe(data, options) {
-        const response = await this.callAPI(data, {
-            functionId: options?.functionId,
-            run: options?.run,
-        });
+        const response = await this.callAPI(data, options);
         return {
             response,
             transcription: response.text,
         };
     }
-    async callAPI(data, options) {
+    async callAPI(data, callOptions) {
         const { temperature } = this.settings;
         const api = this.settings.api ?? new WhisperCppApiConfiguration();
-        const abortSignal = options.run?.abortSignal;
+        const abortSignal = callOptions.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
@@ -48,7 +45,12 @@ export class WhisperCppTranscriptionModel extends AbstractModel {
                 }
                 return postToApi({
                     url: api.assembleUrl("/inference"),
-                    headers: api.headers,
+                    headers: api.headers({
+                        functionType: callOptions.functionType,
+                        functionId: callOptions.functionId,
+                        run: callOptions.run,
+                        callId: callOptions.callId,
+                    }),
                     body: {
                         content: formData,
                         values: { temperature },

package/observability/helicone/HeliconeOpenAIApiConfiguration.cjs

@@ -4,7 +4,7 @@ exports.HeliconeOpenAIApiConfiguration = void 0;
 const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
 const loadApiKey_js_1 = require("../../core/api/loadApiKey.cjs");
 class HeliconeOpenAIApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://oai.hconeai.com/v1", openAIApiKey, heliconeApiKey, retry, throttle, } = {}) {
+    constructor({ baseUrl = "https://oai.hconeai.com/v1", openAIApiKey, heliconeApiKey, retry, throttle, customCallHeaders, } = {}) {
         super({
             baseUrl,
             headers: {
@@ -23,6 +23,7 @@ class HeliconeOpenAIApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUr
             },
             retry,
             throttle,
+            customCallHeaders,
         });
     }
 }