modelfusion 0.112.0 → 0.114.0

package/CHANGELOG.md

@@ -1,5 +1,110 @@
 # Changelog
 
+## v0.114.0 - 2024-01-05
+
+### Added
+
+- Custom call header support for APIs. You can pass a `customCallHeaders` function into API configurations to add custom headers. The function is called with `functionType`, `functionId`, `run`, and `callId` parameters. Example for Helicone:
+
+  ```ts
+  const text = await generateText(
+    openai
+      .ChatTextGenerator({
+        api: new HeliconeOpenAIApiConfiguration({
+          customCallHeaders: ({ functionId, callId }) => ({
+            "Helicone-Property-FunctionId": functionId,
+            "Helicone-Property-CallId": callId,
+          }),
+        }),
+        model: "gpt-3.5-turbo",
+        temperature: 0.7,
+        maxGenerationTokens: 500,
+      })
+      .withTextPrompt(),
+
+    "Write a short story about a robot learning to love",
+
+    { functionId: "example-function" }
+  );
+  ```
+
+- Rudimentary caching support for `generateText`. You can use a `MemoryCache` to store the response of a `generateText` call. Example:
+
+  ```ts
+  import { MemoryCache, generateText, ollama } from "modelfusion";
+
+  const model = ollama
+    .ChatTextGenerator({ model: "llama2:chat", maxGenerationTokens: 100 })
+    .withTextPrompt();
+
+  const cache = new MemoryCache();
+
+  const text1 = await generateText(
+    model,
+    "Write a short story about a robot learning to love:",
+    { cache }
+  );
+
+  console.log(text1);
+
+  // 2nd call will use cached response:
+  const text2 = await generateText(
+    model,
+    "Write a short story about a robot learning to love:", // same text
+    { cache }
+  );
+
+  console.log(text2);
+  ```
+
+- `validateTypes` and `safeValidateTypes` helpers that perform type checking of an object against a `Schema` (e.g., a `zodSchema`).
+
+## v0.113.0 - 2024-01-03
+
+[Structure generation](https://modelfusion.dev/guide/function/generate-structure) improvements.
+
+### Added
+
+- `.asStructureGenerationModel(...)` function to `OpenAIChatModel` and `OllamaChatModel` to create structure generation models from chat models.
+- `jsonStructurePrompt` helper function to create structure generation models.
+
+### Example
+
+```ts
+import {
+  generateStructure,
+  jsonStructurePrompt,
+  ollama,
+  zodSchema,
+} from "modelfusion";
+
+const structure = await generateStructure(
+  ollama
+    .ChatTextGenerator({
+      model: "openhermes2.5-mistral",
+      maxGenerationTokens: 1024,
+      temperature: 0,
+    })
+    .asStructureGenerationModel(jsonStructurePrompt.text()),
+
+  zodSchema(
+    z.object({
+      characters: z.array(
+        z.object({
+          name: z.string(),
+          class: z
+            .string()
+            .describe("Character class, e.g. warrior, mage, or thief."),
+          description: z.string(),
+        })
+      ),
+    })
+  ),
+
+  "Generate 3 character descriptions for a fantasy role playing game. "
+);
+```
+
 ## v0.112.0 - 2024-01-02
 
 ### Changed

package/README.md

@@ -1,6 +1,6 @@
 # ModelFusion
 
-> ### The TypeScript library for building multi-modal AI applications.
+> ### The TypeScript library for building AI applications.
 
 [![NPM Version](https://img.shields.io/npm/v/modelfusion?color=33cd56&logo=npm)](https://www.npmjs.com/package/modelfusion)
 [![MIT License](https://img.shields.io/github/license/lgrammel/modelfusion)](https://opensource.org/licenses/MIT)
@@ -12,7 +12,7 @@
 
 ## Introduction
 
-**ModelFusion** is an abstraction layer for integrating AI models into JavaScript and TypeScript applications, unifying the API for common operations such as text streaming, structure generation, and tool usage. It provides features to support production environments, including observability hooks, logging, and automatic retries. You can use ModelFusion to build AI applications, chatbots, and agents.
+**ModelFusion** is an abstraction layer for integrating AI models into JavaScript and TypeScript applications, unifying the API for common operations such as **text streaming**, **structure generation**, and **tool usage**. It provides features to support production environments, including observability hooks, logging, and automatic retries. You can use ModelFusion to build AI applications, chatbots, and agents.
 
 - **Vendor-neutral**: ModelFusion is a non-commercial open source project that is community-driven. You can use it with any supported provider.
 - **Multi-modal**: ModelFusion supports a wide range of models including text generation, image generation, vision, text-to-speech, speech-to-text, and embedding models.
@@ -105,6 +105,101 @@ for await (const textPart of textStream) {
 
 Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [OpenAI compatible](https://modelfusion.dev/integration/model-provider/openaicompatible), [Llama.cpp](https://modelfusion.dev/integration/model-provider/llamacpp), [Ollama](https://modelfusion.dev/integration/model-provider/ollama)
 
+### [Generate Structure](https://modelfusion.dev/guide/function/generate-structure)
+
+Generate typed objects using a language model and a schema.
+
+#### generateStructure
+
+Generate a structure that matches a schema.
+
+```ts
+import {
+  ollama,
+  zodSchema,
+  generateStructure,
+  jsonStructurePrompt,
+} from "modelfusion";
+
+const sentiment = await generateStructure(
+  // model:
+  ollama
+    .ChatTextGenerator({
+      model: "openhermes2.5-mistral",
+      maxGenerationTokens: 1024,
+      temperature: 0,
+    })
+    .asStructureGenerationModel(jsonStructurePrompt.instruction()),
+
+  // schema:
+  zodSchema(
+    z.object({
+      sentiment: z
+        .enum(["positive", "neutral", "negative"])
+        .describe("Sentiment."),
+    })
+  ),
+
+  // prompt:
+  {
+    system:
+      "You are a sentiment evaluator. " +
+      "Analyze the sentiment of the following product review:",
+    instruction:
+      "After I opened the package, I was met by a very unpleasant smell " +
+      "that did not disappear even after washing. Never again!",
+  }
+);
+```
+
+Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Ollama](https://modelfusion.dev//integration/model-provider/ollama)
+
+#### streamStructure
+
+Stream a structure that matches a schema. Partial structures before the final part are untyped JSON.
+
+```ts
+import { zodSchema, openai, streamStructure } from "modelfusion";
+
+const structureStream = await streamStructure(
+  openai
+    .ChatTextGenerator(/* ... */)
+    .asFunctionCallStructureGenerationModel({
+      fnName: "generateCharacter",
+      fnDescription: "Generate character descriptions.",
+    })
+    .withTextPrompt(),
+
+  zodSchema(
+    z.object({
+      characters: z.array(
+        z.object({
+          name: z.string(),
+          class: z
+            .string()
+            .describe("Character class, e.g. warrior, mage, or thief."),
+          description: z.string(),
+        })
+      ),
+    })
+  ),
+
+  "Generate 3 character descriptions for a fantasy role playing game."
+);
+
+for await (const part of structureStream) {
+  if (!part.isComplete) {
+    const unknownPartialStructure = part.value;
+    console.log("partial value", unknownPartialStructure);
+  } else {
+    const fullyTypedStructure = part.value;
+    console.log("final value", fullyTypedStructure);
+  }
+}
+```
+
+Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Ollama](https://modelfusion.dev//integration/model-provider/ollama)
+
 ### [Generate Image](https://modelfusion.dev/guide/function/generate-image)
 
 Generate an image from a prompt.
@@ -192,97 +287,6 @@ const transcription = await generateTranscription(
 
 Providers: [OpenAI (Whisper)](https://modelfusion.dev/integration/model-provider/openai), [Whisper.cpp](https://modelfusion.dev/integration/model-provider/whispercpp)
 
-### [Generate Structure](https://modelfusion.dev/guide/function/generate-structure#generatestructure)
-
-Generate typed objects using a language model and a schema.
-
-#### generateStructure
-
-Generate a structure that matches a schema.
-
-```ts
-import { zodSchema, generateStructure, openai } from "modelfusion";
-
-const sentiment = await generateStructure(
-  // model:
-  openai
-    .ChatTextGenerator({
-      model: "gpt-3.5-turbo",
-      temperature: 0,
-      maxGenerationTokens: 50,
-    })
-    .asFunctionCallStructureGenerationModel({ fnName: "sentiment" })
-    .withInstructionPrompt(),
-
-  // schema:
-  zodSchema(
-    z.object({
-      sentiment: z
-        .enum(["positive", "neutral", "negative"])
-        .describe("Sentiment."),
-    })
-  ),
-
-  // prompt:
-  {
-    system:
-      "You are a sentiment evaluator. " +
-      "Analyze the sentiment of the following product review:",
-    instruction:
-      "After I opened the package, I was met by a very unpleasant smell " +
-      "that did not disappear even after washing. Never again!",
-  }
-);
-```
-
-Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Ollama](https://modelfusion.dev//integration/model-provider/ollama)
-
-#### streamStructure
-
-Stream a structure that matches a schema. Partial structures before the final part are untyped JSON.
-
-```ts
-import { zodSchema, openai, streamStructure } from "modelfusion";
-
-const structureStream = await streamStructure(
-  openai
-    .ChatTextGenerator(/* ... */)
-    .asFunctionCallStructureGenerationModel({
-      fnName: "generateCharacter",
-      fnDescription: "Generate character descriptions.",
-    })
-    .withTextPrompt(),
-
-  zodSchema(
-    z.object({
-      characters: z.array(
-        z.object({
-          name: z.string(),
-          class: z
-            .string()
-            .describe("Character class, e.g. warrior, mage, or thief."),
-          description: z.string(),
-        })
-      ),
-    })
-  ),
-
-  "Generate 3 character descriptions for a fantasy role playing game."
-);
-
-for await (const part of structureStream) {
-  if (!part.isComplete) {
-    const unknownPartialStructure = part.value;
-    console.log("partial value", unknownPartialStructure);
-  } else {
-    const fullyTypedStructure = part.value;
-    console.log("final value", fullyTypedStructure);
-  }
-}
-```
-
-Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Ollama](https://modelfusion.dev//integration/model-provider/ollama)
-
 ### [Embed Value](https://modelfusion.dev/guide/function/embed)
 
 Create embeddings for text and other values. Embeddings are vectors that represent the essence of the values in the context of the model.
@@ -326,25 +330,13 @@ Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai),
 
 ### [Tools](https://modelfusion.dev/guide/tools)
 
-Tools are functions that can be executed by an AI model. They are useful for building chatbots and agents.
-
-Predefined tools: [Math.js](https://modelfusion.dev/guide/tools/predefined-tools/mathjs), [MediaWiki Search](https://modelfusion.dev/guide/tools/predefined-tools/mediawiki-search), [SerpAPI](https://modelfusion.dev/guide/tools/predefined-tools/serpapi), [Google Custom Search](https://modelfusion.dev/guide/tools/predefined-tools/google-custom-search)
-
-#### [executeTool](https://modelfusion.dev/guide/tools/execute-tool)
-
-You can directly invoke a tool with `executeTool`:
+Tools are functions (and associated metadata) that can be executed by an AI model. They are useful for building chatbots and agents.
 
-```ts
-const result = await executeTool(calculator, {
-  a: 14,
-  b: 12,
-  operator: "*",
-});
-```
+ModelFusion offers several tools out-of-the-box: [Math.js](https://modelfusion.dev/guide/tools/available-tools/mathjs), [MediaWiki Search](https://modelfusion.dev/guide/tools/available-tools/mediawiki-search), [SerpAPI](https://modelfusion.dev/guide/tools/available-tools/serpapi), [Google Custom Search](https://modelfusion.dev/guide/tools/available-tools/google-custom-search). You can also create [custom tools](https://modelfusion.dev/guide/tools).
 
 #### [useTool](https://modelfusion.dev/guide/tools/use-tool)
 
-With `useTool`, you can use a tool with a language model that supports tools calls (e.g. OpenAI Chat). `useTool` first generates a tool call and then executes the tool with the arguments.
+With `useTool`, you can ask a tool-compatible language model (e.g. OpenAI chat) to invoke a single tool. `useTool` first generates a tool call and then executes the tool with the arguments.
 
 ```ts
 const { tool, toolCall, args, ok, result } = await useTool(
@@ -360,7 +352,7 @@ console.log(`Ok:`, ok);
 console.log(`Result or Error:`, result);
 ```
 
-#### [useTools](https://modelfusion.dev/guide/tools/use-tools-or-generate-text)
+#### [useTools](https://modelfusion.dev/guide/tools/use-tools)
 
 With `useTools`, you can ask a language model to generate several tool calls as well as text. The model will choose which tools (if any) should be called with which arguments. Both the text and the tool calls are optional. This function executes the tools.
 
@@ -372,42 +364,6 @@ const { text, toolResults } = await useTools(
 );
 ```
 
-#### [Creating Tools](https://modelfusion.dev/guide/tools/create-tools)
-
-A tool is comprised of an async execute function, a name, a description, and a schema for the input parameters.
-
-```ts
-const calculator = new Tool({
-  name: "calculator",
-  description: "Execute a calculation",
-
-  parameters: zodSchema(
-    z.object({
-      a: z.number().describe("The first number."),
-      b: z.number().describe("The second number."),
-      operator: z
-        .enum(["+", "-", "*", "/"])
-        .describe("The operator (+, -, *, /)."),
-    })
-  ),
-
-  execute: async ({ a, b, operator }) => {
-    switch (operator) {
-      case "+":
-        return a + b;
-      case "-":
-        return a - b;
-      case "*":
-        return a * b;
-      case "/":
-        return a / b;
-      default:
-        throw new Error(`Unknown operator: ${operator}`);
-    }
-  },
-});
-```
-
 #### [Agent Loop](https://modelfusion.dev/guide/tools/agent-loop)
 
 You can use `useTools` to implement an agent loop that responds to user messages and executes tools. [Learn more](https://modelfusion.dev/guide/tools/agent-loop).
@@ -582,85 +538,25 @@ import { modelfusion } from "modelfusion";
 modelfusion.setLogFormat("detailed-object"); // log full events
 ```
 
-### [Server](https://modelfusion.dev/guide/experimental/server/)
-
-> [!WARNING]
-> ModelFusion Server is in its initial development phase and not feature-complete. The API is experimental and breaking changes are likely. Feedback and suggestions are welcome.
-
-ModelFusion Server is desigend for running multi-modal generative AI flows that take up to several minutes to complete. It provides the following benefits:
-
-- 🔄 Real-time progress updates via custom server-sent events
-- 🔒Type-safety with Zod-schema for inputs/events
-- 📦 Efficient handling of dynamically created binary assets (images, audio)
-- 📜 Auto-logging for AI model interactions within flows
-
-ModelFusion provides a [Fastify](https://fastify.dev/) plugin that allows you to set up a server that exposes your ModelFusion flows as REST endpoints using server-sent events.
-
-```ts
-import {
-  FileSystemAssetStorage,
-  FileSystemLogger,
-  modelFusionFastifyPlugin,
-} from "modelfusion-experimental/fastify-server"; // '/fastify-server' import path
-
-// configurable logging for all runs using ModelFusion observability:
-const logger = new FileSystemLogger({
-  path: (run) => path.join(fsBasePath, run.runId, "logs"),
-});
-
-// configurable storage for large files like images and audio files:
-const assetStorage = new FileSystemAssetStorage({
-  path: (run) => path.join(fsBasePath, run.runId, "assets"),
-  logger,
-});
-
-fastify.register(modelFusionFastifyPlugin, {
-  baseUrl,
-  basePath: "/myFlow",
-  logger,
-  assetStorage,
-  flow: exampleFlow,
-});
-```
-
-Using `invokeFlow`, you can easily connect your client to a ModelFusion flow endpoint:
-
-```ts
-import { invokeFlow } from "modelfusion-experimental/browser"; // '/browser' import path
-
-invokeFlow({
-  url: `${BASE_URL}/myFlow`,
-  schema: myFlowSchema,
-  input: { prompt },
-  onEvent(event) {
-    switch (event.type) {
-      case "my-event": {
-        // do something with the event
-        break;
-      }
-      // more events...
-    }
-  },
-  onStop() {
-    // flow finished
-  },
-});
-```
-
 ## Documentation
 
 ### [Guide](https://modelfusion.dev/guide)
 
 - [Model Functions](https://modelfusion.dev/guide/function/)
   - [Generate text](https://modelfusion.dev/guide/function/generate-text)
+  - [Generate structure](https://modelfusion.dev/guide/function/generate-structure)
   - [Generate image](https://modelfusion.dev/guide/function/generate-image)
   - [Generate speech](https://modelfusion.dev/guide/function/generate-speech)
   - [Generate transcription](https://modelfusion.dev/guide/function/generation-transcription)
-  - [Generate structure](https://modelfusion.dev/guide/function/generate-structure)
-  - [Generate structure or text](https://modelfusion.dev/guide/function/generate-structure-or-text)
   - [Tokenize Text](https://modelfusion.dev/guide/function/tokenize-text)
   - [Embed Value](https://modelfusion.dev/guide/function/embed)
 - [Tools](https://modelfusion.dev/guide/tools)
+  - [Use Tool](https://modelfusion.dev/guide/tools/use-tool)
+  - [Use Tools](https://modelfusion.dev/guide/tools/use-tools)
+  - [Agent Loop](https://modelfusion.dev/guide/tools/agent-loop)
+  - [Available Tools](https://modelfusion.dev/guide/tools/available-tools/)
+  - [Custom Tools](https://modelfusion.dev/guide/tools/custom-tools)
+  - [Advanced](https://modelfusion.dev/guide/tools/advanced)
 - [Vector Indices](https://modelfusion.dev/guide/vector-index)
   - [Upsert](https://modelfusion.dev/guide/vector-index/upsert)
   - [Retrieve](https://modelfusion.dev/guide/vector-index/retrieve)

package/core/FunctionOptions.d.ts

@@ -1,6 +1,7 @@
 import { FunctionObserver } from "./FunctionObserver.js";
 import { LogFormat } from "./LogFormat.js";
 import { Run } from "./Run.js";
+import { Cache } from "./cache/Cache.js";
 /**
  * Additional settings for ModelFusion functions.
  */
@@ -18,6 +19,11 @@ export type FunctionOptions = {
      * Optional observers that are called when the function is invoked.
      */
     observers?: Array<FunctionObserver>;
+    /**
+     * Optional cache that can be used by the function to store and retrieve cached values.
+     * Not supported by all functions.
+     */
+    cache?: Cache;
     /**
      * Optional run as part of which this function is called. Used in events and logging.
      * Run callbacks are invoked when it is provided.
@@ -28,3 +34,11 @@ export type FunctionOptions = {
      */
     parentCallId?: string | undefined;
 };
+/**
+ * Extended options that are passed to models when functions are called. They are passed
+ * into e.g. API providers to create custom headers.
+ */
+export type FunctionCallOptions = Omit<FunctionOptions, "parentCallId"> & {
+    functionType: string;
+    callId: string;
+};

package/core/api/AbstractApiConfiguration.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractApiConfiguration = void 0;
 class AbstractApiConfiguration {
-    constructor({ retry, throttle, }) {
+    constructor({ retry, throttle, customCallHeaders = () => ({}), }) {
         Object.defineProperty(this, "retry", {
             enumerable: true,
             configurable: true,
@@ -15,8 +15,23 @@ class AbstractApiConfiguration {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "customCallHeaders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.retry = retry;
         this.throttle = throttle;
+        this.customCallHeaders = customCallHeaders;
+    }
+    headers(params) {
+        return Object.fromEntries([
+            ...Object.entries(this.fixedHeaders(params)),
+            ...Object.entries(this.customCallHeaders(params)),
+        ].filter(
+        // remove undefined values:
+        (entry) => typeof entry[1] === "string"));
     }
 }
 exports.AbstractApiConfiguration = AbstractApiConfiguration;

package/core/api/AbstractApiConfiguration.d.ts

@@ -1,13 +1,17 @@
 import { RetryFunction } from "./RetryFunction.js";
 import { ThrottleFunction } from "./ThrottleFunction.js";
-import { ApiConfiguration } from "./ApiConfiguration.js";
+import { ApiConfiguration, HeaderParameters } from "./ApiConfiguration.js";
+import { CustomHeaderProvider } from "./CustomHeaderProvider.js";
 export declare abstract class AbstractApiConfiguration implements ApiConfiguration {
     readonly retry?: RetryFunction;
     readonly throttle?: ThrottleFunction;
-    constructor({ retry, throttle, }: {
+    protected readonly customCallHeaders: CustomHeaderProvider;
+    constructor({ retry, throttle, customCallHeaders, }: {
         retry?: RetryFunction;
         throttle?: ThrottleFunction;
+        customCallHeaders?: CustomHeaderProvider;
     });
     abstract assembleUrl(path: string): string;
-    abstract readonly headers: Record<string, string>;
+    protected abstract fixedHeaders(params: HeaderParameters): Record<string, string>;
+    headers(params: HeaderParameters): Record<string, string>;
 }

package/core/api/AbstractApiConfiguration.js

@@ -1,5 +1,5 @@
 export class AbstractApiConfiguration {
-    constructor({ retry, throttle, }) {
+    constructor({ retry, throttle, customCallHeaders = () => ({}), }) {
         Object.defineProperty(this, "retry", {
             enumerable: true,
             configurable: true,
@@ -12,7 +12,22 @@ export class AbstractApiConfiguration {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "customCallHeaders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.retry = retry;
         this.throttle = throttle;
+        this.customCallHeaders = customCallHeaders;
+    }
+    headers(params) {
+        return Object.fromEntries([
+            ...Object.entries(this.fixedHeaders(params)),
+            ...Object.entries(this.customCallHeaders(params)),
+        ].filter(
+        // remove undefined values:
+        (entry) => typeof entry[1] === "string"));
     }
 }

package/core/api/ApiConfiguration.d.ts

@@ -1,5 +1,12 @@
+import { Run } from "../Run.js";
 import { RetryFunction } from "./RetryFunction.js";
 import { ThrottleFunction } from "./ThrottleFunction.js";
+export type HeaderParameters = {
+    functionType: string;
+    functionId?: string;
+    run?: Run;
+    callId: string;
+};
 /**
  * Settings for how to call an API, e.g. OpenAI.
  *
@@ -19,8 +26,10 @@ export interface ApiConfiguration {
      * This is intended for authentication headers and proxy settings.
      *
      * The model may add additional headers, in particular "Content-Type"."
+     *
+     * @param params Parameters that can be used to create the headers.
      */
-    readonly headers: Record<string, string>;
+    headers(params: HeaderParameters): Record<string, string>;
     /**
      * Defines how failed API calls should be retried.
      */

package/core/api/BaseUrlApiConfiguration.cjs

@@ -8,22 +8,25 @@ const AbstractApiConfiguration_js_1 = require("./AbstractApiConfiguration.cjs");
  * You can use it to configure custom APIs for models, e.g. your own internal OpenAI proxy with custom headers.
  */
 class BaseUrlApiConfiguration extends AbstractApiConfiguration_js_1.AbstractApiConfiguration {
-    constructor({ baseUrl, headers, retry, throttle, }) {
-        super({ retry, throttle });
+    constructor({ baseUrl, headers, retry, throttle, customCallHeaders, }) {
+        super({ retry, throttle, customCallHeaders });
         Object.defineProperty(this, "baseUrl", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "headers", {
+        Object.defineProperty(this, "fixedHeadersValue", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
         this.baseUrl = typeof baseUrl == "string" ? parseBaseUrl(baseUrl) : baseUrl;
-        this.headers = headers ?? {};
+        this.fixedHeadersValue = headers ?? {};
+    }
+    fixedHeaders() {
+        return this.fixedHeadersValue;
     }
     assembleUrl(path) {
         let basePath = this.baseUrl.path;
@@ -40,12 +43,13 @@ class BaseUrlApiConfiguration extends AbstractApiConfiguration_js_1.AbstractApiC
 }
 exports.BaseUrlApiConfiguration = BaseUrlApiConfiguration;
 class BaseUrlApiConfigurationWithDefaults extends BaseUrlApiConfiguration {
-    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, }) {
+    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, customCallHeaders, }) {
         super({
             baseUrl: resolveBaseUrl(baseUrl, baseUrlDefaults),
             headers,
             retry,
             throttle,
+            customCallHeaders,
         });
     }
 }