modelfusion 0.113.0 → 0.114.0

package/CHANGELOG.md

@@ -1,5 +1,64 @@
 # 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.

package/README.md

@@ -1,6 +1,6 @@
 # ModelFusion
 
-> ### The TypeScript library for building sAI 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)
@@ -105,94 +105,7 @@ 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 Image](https://modelfusion.dev/guide/function/generate-image)
-
-Generate an image from a prompt.
-
-```ts
-import { generateImage, openai } from "modelfusion";
-
-const image = await generateImage(
-  openai.ImageGenerator({ model: "dall-e-3", size: "1024x1024" }),
-  "the wicked witch of the west in the style of early 19th century painting"
-);
-```
-
-Providers: [OpenAI (Dall·E)](https://modelfusion.dev/integration/model-provider/openai), [Stability AI](https://modelfusion.dev/integration/model-provider/stability), [Automatic1111](https://modelfusion.dev/integration/model-provider/automatic1111)
-
-### [Generate Speech](https://modelfusion.dev/guide/function/generate-speech)
-
-Synthesize speech (audio) from text. Also called TTS (text-to-speech).
-
-#### generateSpeech
-
-`generateSpeech` synthesizes speech from text.
-
-```ts
-import { generateSpeech, lmnt } from "modelfusion";
-
-// `speech` is a Buffer with MP3 audio data
-const speech = await generateSpeech(
-  lmnt.SpeechGenerator({
-    voice: "034b632b-df71-46c8-b440-86a42ffc3cf3", // Henry
-  }),
-  "Good evening, ladies and gentlemen! Exciting news on the airwaves tonight " +
-    "as The Rolling Stones unveil 'Hackney Diamonds,' their first collection of " +
-    "fresh tunes in nearly twenty years, featuring the illustrious Lady Gaga, the " +
-    "magical Stevie Wonder, and the final beats from the late Charlie Watts."
-);
-```
-
-Providers: [Eleven Labs](https://modelfusion.dev/integration/model-provider/elevenlabs), [LMNT](https://modelfusion.dev/integration/model-provider/lmnt), [OpenAI](https://modelfusion.dev/integration/model-provider/openai)
-
-#### streamSpeech
-
-`generateSpeech` generates a stream of speech chunks from text or from a text stream. Depending on the model, this can be fully duplex.
-
-```ts
-import { streamSpeech, elevenlabs } from "modelfusion";
-
-const textStream: AsyncIterable<string>;
-
-const speechStream = await streamSpeech(
-  elevenlabs.SpeechGenerator({
-    model: "eleven_turbo_v2",
-    voice: "pNInz6obpgDQGcFmaJgB", // Adam
-    optimizeStreamingLatency: 1,
-    voiceSettings: { stability: 1, similarityBoost: 0.35 },
-    generationConfig: {
-      chunkLengthSchedule: [50, 90, 120, 150, 200],
-    },
-  }),
-  textStream
-);
-
-for await (const part of speechStream) {
-  // each part is a Buffer with MP3 audio data
-}
-```
-
-Providers: [Eleven Labs](https://modelfusion.dev/integration/model-provider/elevenlabs)
-
-### [Generate Transcription](https://modelfusion.dev/guide/function/generate-transcription)
-
-Transcribe speech (audio) data into text. Also called speech-to-text (STT).
-
-```ts
-import { generateTranscription, openai } from "modelfusion";
-
-const transcription = await generateTranscription(
-  openai.Transcriber({ model: "whisper-1" }),
-  {
-    type: "mp3",
-    data: await fs.promises.readFile("data/test.mp3"),
-  }
-);
-```
-
-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 Structure](https://modelfusion.dev/guide/function/generate-structure)
 
 Generate typed objects using a language model and a schema.
 
@@ -287,6 +200,93 @@ for await (const part of structureStream) {
 
 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.
+
+```ts
+import { generateImage, openai } from "modelfusion";
+
+const image = await generateImage(
+  openai.ImageGenerator({ model: "dall-e-3", size: "1024x1024" }),
+  "the wicked witch of the west in the style of early 19th century painting"
+);
+```
+
+Providers: [OpenAI (Dall·E)](https://modelfusion.dev/integration/model-provider/openai), [Stability AI](https://modelfusion.dev/integration/model-provider/stability), [Automatic1111](https://modelfusion.dev/integration/model-provider/automatic1111)
+
+### [Generate Speech](https://modelfusion.dev/guide/function/generate-speech)
+
+Synthesize speech (audio) from text. Also called TTS (text-to-speech).
+
+#### generateSpeech
+
+`generateSpeech` synthesizes speech from text.
+
+```ts
+import { generateSpeech, lmnt } from "modelfusion";
+
+// `speech` is a Buffer with MP3 audio data
+const speech = await generateSpeech(
+  lmnt.SpeechGenerator({
+    voice: "034b632b-df71-46c8-b440-86a42ffc3cf3", // Henry
+  }),
+  "Good evening, ladies and gentlemen! Exciting news on the airwaves tonight " +
+    "as The Rolling Stones unveil 'Hackney Diamonds,' their first collection of " +
+    "fresh tunes in nearly twenty years, featuring the illustrious Lady Gaga, the " +
+    "magical Stevie Wonder, and the final beats from the late Charlie Watts."
+);
+```
+
+Providers: [Eleven Labs](https://modelfusion.dev/integration/model-provider/elevenlabs), [LMNT](https://modelfusion.dev/integration/model-provider/lmnt), [OpenAI](https://modelfusion.dev/integration/model-provider/openai)
+
+#### streamSpeech
+
+`generateSpeech` generates a stream of speech chunks from text or from a text stream. Depending on the model, this can be fully duplex.
+
+```ts
+import { streamSpeech, elevenlabs } from "modelfusion";
+
+const textStream: AsyncIterable<string>;
+
+const speechStream = await streamSpeech(
+  elevenlabs.SpeechGenerator({
+    model: "eleven_turbo_v2",
+    voice: "pNInz6obpgDQGcFmaJgB", // Adam
+    optimizeStreamingLatency: 1,
+    voiceSettings: { stability: 1, similarityBoost: 0.35 },
+    generationConfig: {
+      chunkLengthSchedule: [50, 90, 120, 150, 200],
+    },
+  }),
+  textStream
+);
+
+for await (const part of speechStream) {
+  // each part is a Buffer with MP3 audio data
+}
+```
+
+Providers: [Eleven Labs](https://modelfusion.dev/integration/model-provider/elevenlabs)
+
+### [Generate Transcription](https://modelfusion.dev/guide/function/generate-transcription)
+
+Transcribe speech (audio) data into text. Also called speech-to-text (STT).
+
+```ts
+import { generateTranscription, openai } from "modelfusion";
+
+const transcription = await generateTranscription(
+  openai.Transcriber({ model: "whisper-1" }),
+  {
+    type: "mp3",
+    data: await fs.promises.readFile("data/test.mp3"),
+  }
+);
+```
+
+Providers: [OpenAI (Whisper)](https://modelfusion.dev/integration/model-provider/openai), [Whisper.cpp](https://modelfusion.dev/integration/model-provider/whispercpp)
+
 ### [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.

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,
         });
     }
 }

package/core/api/BaseUrlApiConfiguration.d.ts

@@ -1,4 +1,5 @@
 import { AbstractApiConfiguration } from "./AbstractApiConfiguration.js";
+import { CustomHeaderProvider } from "./CustomHeaderProvider.js";
 import { RetryFunction } from "./RetryFunction.js";
 import { ThrottleFunction } from "./ThrottleFunction.js";
 export type UrlParts = {
@@ -10,6 +11,7 @@ export type UrlParts = {
 export type BaseUrlPartsApiConfigurationOptions = {
     baseUrl: string | UrlParts;
     headers?: Record<string, string>;
+    customCallHeaders?: CustomHeaderProvider;
     retry?: RetryFunction;
     throttle?: ThrottleFunction;
 };
@@ -20,18 +22,16 @@ export type BaseUrlPartsApiConfigurationOptions = {
  */
 export declare class BaseUrlApiConfiguration extends AbstractApiConfiguration {
     readonly baseUrl: UrlParts;
-    readonly headers: Record<string, string>;
-    constructor({ baseUrl, headers, retry, throttle, }: BaseUrlPartsApiConfigurationOptions);
+    protected readonly fixedHeadersValue: Record<string, string>;
+    constructor({ baseUrl, headers, retry, throttle, customCallHeaders, }: BaseUrlPartsApiConfigurationOptions);
+    fixedHeaders(): Record<string, string>;
     assembleUrl(path: string): string;
 }
-export type PartialBaseUrlPartsApiConfigurationOptions = {
+export type PartialBaseUrlPartsApiConfigurationOptions = Omit<BaseUrlPartsApiConfigurationOptions, "baseUrl"> & {
     baseUrl?: string | Partial<UrlParts>;
-    headers?: Record<string, string>;
-    retry?: RetryFunction;
-    throttle?: ThrottleFunction;
 };
 export declare class BaseUrlApiConfigurationWithDefaults extends BaseUrlApiConfiguration {
-    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, }: {
+    constructor({ baseUrlDefaults, baseUrl, headers, retry, throttle, customCallHeaders, }: {
         baseUrlDefaults: UrlParts;
     } & PartialBaseUrlPartsApiConfigurationOptions);
 }

package/core/api/BaseUrlApiConfiguration.js

@@ -5,22 +5,25 @@ import { AbstractApiConfiguration } from "./AbstractApiConfiguration.js";
  * You can use it to configure custom APIs for models, e.g. your own internal OpenAI proxy with custom headers.
  */
 export class BaseUrlApiConfiguration extends 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;
@@ -36,12 +39,13 @@ export class BaseUrlApiConfiguration extends AbstractApiConfiguration {
     }
 }
 export 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,
         });
     }
 }

package/core/api/CustomHeaderProvider.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/api/CustomHeaderProvider.d.ts

@@ -0,0 +1,2 @@
+import { HeaderParameters } from "./ApiConfiguration.js";
+export type CustomHeaderProvider = (headerParameters: HeaderParameters) => Record<string, string | undefined>;

package/core/api/CustomHeaderProvider.js

@@ -0,0 +1 @@
+export {};

package/core/api/index.cjs

@@ -32,6 +32,7 @@ __exportStar(require("./ApiCallError.cjs"), exports);
 __exportStar(require("./ApiConfiguration.cjs"), exports);
 exports.api = __importStar(require("./ApiFacade.cjs"));
 __exportStar(require("./BaseUrlApiConfiguration.cjs"), exports);
+__exportStar(require("./CustomHeaderProvider.cjs"), exports);
 __exportStar(require("./RetryError.cjs"), exports);
 __exportStar(require("./RetryFunction.cjs"), exports);
 __exportStar(require("./ThrottleFunction.cjs"), exports);

package/core/api/index.d.ts

@@ -3,6 +3,7 @@ export * from "./ApiCallError.js";
 export * from "./ApiConfiguration.js";
 export * as api from "./ApiFacade.js";
 export * from "./BaseUrlApiConfiguration.js";
+export * from "./CustomHeaderProvider.js";
 export * from "./RetryError.js";
 export * from "./RetryFunction.js";
 export * from "./ThrottleFunction.js";

package/core/api/index.js

@@ -3,6 +3,7 @@ export * from "./ApiCallError.js";
 export * from "./ApiConfiguration.js";
 export * as api from "./ApiFacade.js";
 export * from "./BaseUrlApiConfiguration.js";
+export * from "./CustomHeaderProvider.js";
 export * from "./RetryError.js";
 export * from "./RetryFunction.js";
 export * from "./ThrottleFunction.js";

package/core/cache/Cache.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/cache/Cache.d.ts

@@ -0,0 +1,12 @@
+export interface Cache {
+    lookupValue(key: {
+        functionType: string;
+        functionId?: string | undefined;
+        input: unknown;
+    }): Promise<object | null>;
+    storeValue(key: {
+        functionType: string;
+        functionId?: string | undefined;
+        input: unknown;
+    }, value: unknown): Promise<void>;
+}

package/core/cache/Cache.js

@@ -0,0 +1 @@
+export {};

package/core/cache/MemoryCache.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCache = void 0;
+class MemoryCache {
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    hashKey(key) {
+        return JSON.stringify(key);
+    }
+    async lookupValue(key) {
+        return this.cache.get(this.hashKey(key)) ?? null;
+    }
+    async storeValue(key, value) {
+        this.cache.set(this.hashKey(key), value);
+    }
+}
+exports.MemoryCache = MemoryCache;

package/core/cache/MemoryCache.d.ts

@@ -0,0 +1,15 @@
+import { Cache } from "./Cache.js";
+export declare class MemoryCache implements Cache {
+    private readonly cache;
+    private hashKey;
+    lookupValue(key: {
+        functionType: string;
+        functionId?: string | undefined;
+        input: unknown;
+    }): Promise<object | null>;
+    storeValue(key: {
+        functionType: string;
+        functionId?: string | undefined;
+        input: unknown;
+    }, value: unknown): Promise<void>;
+}

package/core/cache/MemoryCache.js

@@ -0,0 +1,19 @@
+export class MemoryCache {
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    hashKey(key) {
+        return JSON.stringify(key);
+    }
+    async lookupValue(key) {
+        return this.cache.get(this.hashKey(key)) ?? null;
+    }
+    async storeValue(key, value) {
+        this.cache.set(this.hashKey(key), value);
+    }
+}