ai-lcr 0.6.2 → 0.6.4

package/CHANGELOG.md

@@ -4,6 +4,58 @@ All notable changes to `ai-lcr` are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and the project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## [0.6.4] — 2026-06-16
+
+DX improvements that eliminate per-project boilerplate for consumers.
+
+### Added
+
+- **`DEFAULT_PROVIDERS`** — canonical URL + env-var-name for common providers
+  (openrouter, deepinfra, tokenmart, deepseek, kunavo, runware, fal). Import
+  instead of redeclaring in every app; a URL change propagates on `npm update`.
+- **`createEnvSink(dispatch)`** — reads `LCR_INGEST_URL` / `LCR_PROJECT` /
+  `LCR_INGEST_KEY` from env and returns a ready-to-use `onCall` handler (or
+  `undefined` when unset). Replaces the identical 30-line `sink.ts` every
+  consumer was copy-pasting. Pass `after` from `next/server` as `dispatch`.
+- **`AnyLanguageModel`** — duck-typed model interface on `ProviderEntry` so
+  consumers no longer need `as` casts when their `@ai-sdk/provider` version
+  differs from ai-lcr's. Runtime behavior unchanged.
+
+## [0.6.3] — 2026-06-11
+
+Caching — both kinds, each off by default and each a pure config flag with no
+service to run. The response cache is the layer Vercel AI Gateway notably
+doesn't offer; ai-lcr does it in-process and folds it into its cost truth.
+
+### Added
+
+- **`createLCR({ cache })`** — exact-match **response cache**. An identical
+  request replays the stored response and calls **no provider at all**: zero
+  latency, `costUsd: 0`. Storage is pluggable with **zero added dependencies**:
+  `cache: true` uses a bundled in-memory store, `cache: myStore` brings your own
+  (Redis / Vercel KV — required for cross-request hits on serverless, where
+  memory isn't shared), `cache: { store?, ttlMs? }` sets a TTL. A hit settles a
+  `CallRecord` with `cacheHit: true` and the avoided cost on its own
+  `cacheHitSavingUsd` line (a caching saving, never folded into routing savings).
+  Empty completions and usage-less results are never cached. New exports:
+  `createMemoryCacheStore`, types `CacheStore` / `CacheOptions` / `CachedCall` /
+  `CachedMeta` / `MemoryCacheOptions`.
+- **`createLCR({ promptCache })`** — automatic provider-side **prompt-cache**
+  breakpoint. Inserts an Anthropic `cache_control` marker on the last system
+  message so the static prompt head bills at the cache-read rate (~0.1× input)
+  on repeats; the model still runs. `true` for the 5-minute window,
+  `{ ttl: "1h" }` for the longer one. Only writes the `anthropic` namespace
+  (ignored by other providers, safe on a mixed chain) and steps aside if you set
+  `cacheControl` yourself. Savings surface via the existing `cachedInputTokens` /
+  `cachedSavingUsd`. New exported type `PromptCacheOptions`.
+- `CallRecord` gains **`cacheHit`** and **`cacheHitSavingUsd`** for response-cache
+  hits.
+
+### Compatibility
+
+- Fully backward compatible. Both `cache` and `promptCache` are **off by
+  default** — unset, routing behaves exactly as before.
+
 ## [0.6.2] — 2026-06-11
 
 Circuit breaker for persistently-failing providers. Until now the only recovery

package/README.md

@@ -182,6 +182,42 @@ const lcr = createLCR({
 
 With `cooldown` on, a provider that fails enough times in a window is *skipped* for a cooldown period rather than tried every request — and a single success clears it. Defaults are 3 failures / 60s → 60s cooldown; tune with `cooldown: { maxFailures, windowMs, cooldownMs }`. It only ever **reorders** the attempt list (cooling providers go last), so if *every* provider is cooling a request still tries them all rather than failing outright. Off by default — routing is unchanged unless you opt in.
 
+## Cache
+
+There are two completely different "caches" in LLM land, and ai-lcr does both — each off by default, each a pure config flag with no service to run.
+
+### Skip the call entirely (`cache`) — response cache
+
+When a request is byte-for-byte identical to one already answered, replay the stored response and call **no provider at all**: zero latency, `costUsd: 0`. This is the layer Vercel AI Gateway notably *doesn't* offer.
+
+```ts
+const lcr = createLCR({
+  models: { /* … */ },
+  cache: true, // exact-match response cache (in-memory by default)
+});
+```
+
+Storage is pluggable and ai-lcr ships **zero dependencies** for it:
+
+- **`cache: true`** uses a process-local in-memory store. Real on a long-running server, and useful *within* one serverless invocation (an agent loop repeating a sub-call) — but it does **not** survive across serverless requests, because separate function instances don't share memory.
+- **For cross-request hits on serverless**, bring your own store backed by a shared layer (Upstash Redis, Vercel KV): `cache: myStore`. ai-lcr runs no service of its own — any shared store is yours. A custom store is just `{ get, set }` (see `CacheStore`); `createMemoryCacheStore({ maxEntries })` is exported if you want the bundled one with a cap.
+- **`cache: { store?, ttlMs? }`** sets an entry lifetime.
+
+A hit settles a `CallRecord` with `cacheHit: true`, `costUsd: 0`, and the money it avoided on its own `cacheHitSavingUsd` line — a *caching* saving, kept separate from routing savings (`baselineUsd − costUsd`), never folded in. Empty completions and usage-less results are never cached. One caveat worth stating: caching makes identical requests return identical responses — exactly right for idempotent / `temperature: 0` calls, a behavior change for sampled ones.
+
+### Pay less for the call (`promptCache`) — provider prompt cache
+
+Different mechanism: the model still runs, but the **static head of the prompt** (your system prompt) bills at the provider's cache-read rate (~0.1× input) on repeats. Anthropic needs an explicit `cache_control` marker; OpenAI / Gemini / DeepSeek cache the prefix automatically. `promptCache: true` inserts that marker on the last system message for you:
+
+```ts
+const lcr = createLCR({
+  models: { /* … */ },
+  promptCache: true,          // 5-minute window; { ttl: "1h" } for the longer one
+});
+```
+
+It only writes the `anthropic` provider-options namespace, which every other provider ignores — so it's safe on a mixed chain. And it **steps aside entirely** if you set `cacheControl` yourself anywhere in the prompt. The savings then show up exactly as before: `cachedInputTokens` and `cachedSavingUsd` on the `CallRecord` (see [Cache-aware cost](#see-what-happened-oncall) below).
+
 ## See what happened (`onCall`)
 
 `onError`/`onCost` fire separately and uncorrelated, so a failover is hard to read after the fact. `onCall` gives you **one record per request** — the full chain, the winner, the reason for each failed hop, latency, and cost — and `formatCallRecord` turns it into a one-liner you can scan:

package/README.zh-CN.md

@@ -144,6 +144,42 @@ DeepInfra 只承载开源权重——没有第一方 Claude / GPT / Gemini。那
 2. **失败时向下穿透。** 遇到任何 provider 失败——限流、5xx、超时、**额度耗尽**（402 / 欠费 / 余额不足），以及 **400** 这类 client 错误——都会前进到下一个 provider，且对流式安全。400 会 failover 是有意为之：在 OpenAI 兼容聚合层里，400 往往是"*这家* provider 不吃这个请求"（不支持的参数、它没上架这个 model、更严格的 schema），而非请求本身坏了——换一家很可能就能服务。若所有 provider 都拒绝，请求仍会失败，并抛出**第一个**（原始）错误，让真正的调用方 bug 保持可调试。唯一永远不 failover 的是调用方主动取消（`AbortSignal`）。想恢复旧的"client 错误立即失败"行为，给 `createLCR` 传 `shouldRetry: isRetryableError`。
 3. **恢复。** 在一段空闲窗口（`resetIntervalMs`，默认 60s）之后，自动回到最便宜的 provider。
 
+## 缓存
+
+LLM 世界里有两种完全不同的"缓存"，ai-lcr 两种都做——都默认关闭，都只是一个配置开关，**不需要你跑任何服务**。
+
+### 整次调用都省掉（`cache`）—— 响应缓存
+
+当一个请求和之前回答过的一模一样时，直接重放已存的响应、**完全不调用任何 provider**：零延迟、`costUsd: 0`。这正是 Vercel AI Gateway 明显没做的那一层。
+
+```ts
+const lcr = createLCR({
+  models: { /* … */ },
+  cache: true, // 精确匹配响应缓存（默认进程内内存）
+});
+```
+
+存储可插拔，且 ai-lcr 为此**零依赖**：
+
+- **`cache: true`** 用进程内内存。在长驻 server 上是真缓存；在单次 serverless 调用内（比如 agent 循环里重复的子调用）也有用——但它**不会跨 serverless 请求存活**，因为不同函数实例之间不共享内存。
+- **想在 serverless 上跨请求命中**，自带一个由共享层（Upstash Redis、Vercel KV）支撑的 store：`cache: myStore`。ai-lcr 自己不跑任何服务——共享层是你的。自定义 store 就是 `{ get, set }`（见 `CacheStore`）；想要带上限的内置实现，用导出的 `createMemoryCacheStore({ maxEntries })`。
+- **`cache: { store?, ttlMs? }`** 可设置过期时间。
+
+命中会落一条 `CallRecord`：`cacheHit: true`、`costUsd: 0`，并把省下的钱单独记在 `cacheHitSavingUsd` 一行——这是**缓存**省的钱，和路由省的钱（`baselineUsd − costUsd`）分开，绝不混在一起。空回复和无 usage 的结果永不缓存。一个要点：缓存会让相同请求返回相同响应——对幂等 / `temperature: 0` 的调用正好，对采样型调用则是行为改变。
+
+### 让这次调用更便宜（`promptCache`）—— provider 提示缓存
+
+另一套机制：模型照样跑，但**提示的静态开头**（你的 system prompt）在重复时按 provider 的缓存读价（约 0.1× input）计费。Anthropic 需要显式 `cache_control` 标记；OpenAI / Gemini / DeepSeek 自动缓存前缀。`promptCache: true` 帮你在最后一条 system 消息上插入这个标记：
+
+```ts
+const lcr = createLCR({
+  models: { /* … */ },
+  promptCache: true,          // 5 分钟窗口；想要更长用 { ttl: "1h" }
+});
+```
+
+它只写 `anthropic` 这个 provider-options 命名空间，其他 provider 一律忽略——所以在混合链路上也安全。而且只要你在 prompt 里自己设了 `cacheControl`，它就**完全让位**。省下的钱照旧体现在 `CallRecord` 的 `cachedInputTokens` 和 `cachedSavingUsd` 上。
+
 ## 看清每次调用发生了什么（`onCall`）
 
 `onError`/`onCost` 各自独立触发、互不关联，事后很难还原一次 failover 的全貌。`onCall` 给你**每个请求一条记录**——完整的尝试链、最终服务者、每跳失败的原因、延迟和成本；`formatCallRecord` 把它变成一行可扫读的日志：

package/dist/index.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEFAULT_PROVIDERS: () => DEFAULT_PROVIDERS,
   DEFAULT_REFERENCE: () => DEFAULT_REFERENCE,
   MEDIA_PRICING: () => MEDIA_PRICING,
   MODEL_PRICES: () => MODEL_PRICES,
@@ -29,11 +30,13 @@ __export(index_exports, {
   classifyError: () => classifyError,
   classifyErrorKind: () => classifyErrorKind,
   comparePrices: () => comparePrices,
+  createEnvSink: () => createEnvSink,
   createFalMediaAdapter: () => createFalMediaAdapter,
   createHttpSink: () => createHttpSink,
   createKunavoMediaAdapter: () => createKunavoMediaAdapter,
   createLCR: () => createLCR,
   createMediaLCR: () => createMediaLCR,
+  createMemoryCacheStore: () => createMemoryCacheStore,
   createRunwareMediaAdapter: () => createRunwareMediaAdapter,
   durationFromInput: () => durationFromInput,
   formatCallRecord: () => formatCallRecord,
@@ -49,6 +52,105 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/cache.ts
+function isCacheStore(x) {
+  return typeof x === "object" && x !== null && typeof x.get === "function" && typeof x.set === "function";
+}
+function resolveCache(opt) {
+  if (!opt) return void 0;
+  if (opt === true) return { store: createMemoryCacheStore() };
+  if (isCacheStore(opt)) return { store: opt };
+  return {
+    store: opt.store ?? createMemoryCacheStore(),
+    ...opt.ttlMs !== void 0 ? { ttlMs: opt.ttlMs } : {}
+  };
+}
+function cacheKeyOf(modelName, options) {
+  const rest = options.providerOptions ? Object.entries(options.providerOptions).filter(([ns]) => ns !== "lcr") : [];
+  const po = rest.length > 0 ? Object.fromEntries(rest) : void 0;
+  return JSON.stringify({
+    m: modelName,
+    prompt: options.prompt,
+    maxOutputTokens: options.maxOutputTokens,
+    temperature: options.temperature,
+    topP: options.topP,
+    topK: options.topK,
+    frequencyPenalty: options.frequencyPenalty,
+    presencePenalty: options.presencePenalty,
+    stopSequences: options.stopSequences,
+    seed: options.seed,
+    responseFormat: options.responseFormat,
+    tools: options.tools,
+    toolChoice: options.toolChoice,
+    po
+  });
+}
+function streamFromParts(parts) {
+  return new ReadableStream({
+    start(controller) {
+      for (const part of parts) controller.enqueue(part);
+      controller.close();
+    }
+  });
+}
+function createMemoryCacheStore(opts = {}) {
+  const maxEntries = opts.maxEntries ?? 1e3;
+  const map = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const entry = map.get(key);
+      if (!entry) return void 0;
+      if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
+        map.delete(key);
+        return void 0;
+      }
+      return entry.value;
+    },
+    set(key, value, ttlMs) {
+      const entry = ttlMs !== void 0 ? { value, expiresAt: Date.now() + ttlMs } : { value };
+      map.delete(key);
+      map.set(key, entry);
+      if (map.size > maxEntries) {
+        const oldest = map.keys().next().value;
+        if (oldest !== void 0) map.delete(oldest);
+      }
+    }
+  };
+}
+
+// src/prompt-cache.ts
+function resolvePromptCache(opt) {
+  if (!opt) return void 0;
+  if (opt === true) return { ttl: "5m" };
+  return { ttl: opt.ttl ?? "5m" };
+}
+function hasAnthropicCacheControl(message) {
+  const anthropic = message.providerOptions?.anthropic;
+  return !!anthropic && "cacheControl" in anthropic;
+}
+function withPromptCacheBreakpoint(options, cfg) {
+  const prompt = options.prompt;
+  if (!Array.isArray(prompt) || prompt.length === 0) return options;
+  if (prompt.some(hasAnthropicCacheControl)) return options;
+  let target = -1;
+  for (let i = 0; i < prompt.length; i++) {
+    if (prompt[i].role === "system") target = i;
+  }
+  if (target === -1) return options;
+  const cacheControl = cfg.ttl === "1h" ? { type: "ephemeral", ttl: "1h" } : { type: "ephemeral" };
+  const newPrompt = prompt.map((message, i) => {
+    if (i !== target) return message;
+    return {
+      ...message,
+      providerOptions: {
+        ...message.providerOptions,
+        anthropic: { ...message.providerOptions?.anthropic, cacheControl }
+      }
+    };
+  });
+  return { ...options, prompt: newPrompt };
+}
+
 // src/fallback.ts
 var EmptyCompletionError = class extends Error {
   constructor(provider) {
@@ -447,6 +549,16 @@ var LcrFallbackModel = class {
     const usageMissing = inputTokens === 0 && outputTokens === 0;
     const emptyCompletion = inputTokens > 0 && outputTokens === 0;
     const baselineUsd = this.baselineUsd(inputTokens, outputTokens, cacheReadTokens);
+    ctx.settled = {
+      meta: {
+        winner: provider.label,
+        costUsd,
+        inputTokens,
+        outputTokens,
+        ...cacheReadTokens > 0 ? { cachedInputTokens: cacheReadTokens } : {}
+      },
+      cacheable: !emptyCompletion && !usageMissing
+    };
     this.emitCost({
       model: this.opts.modelName,
       provider: provider.label,
@@ -491,6 +603,16 @@ var LcrFallbackModel = class {
     });
   }
   async doGenerate(options) {
+    const cache = this.opts.cache;
+    const cacheKey = cache ? cacheKeyOf(this.opts.modelName, options) : void 0;
+    if (cache && cacheKey !== void 0) {
+      const hit = await cache.store.get(cacheKey);
+      if (hit && hit.kind === "generate") {
+        this.finalizeCacheHit(this.startCall(options), hit.meta);
+        return hit.result;
+      }
+    }
+    const callOptions = this.opts.promptCache ? withPromptCacheBreakpoint(options, this.opts.promptCache) : options;
     const ctx = this.startCall(options);
     const providers = this.opts.providers;
     const order = this.routeOrder(this.startIndex());
@@ -501,7 +623,7 @@ var LcrFallbackModel = class {
       const isLast = pos === order.length - 1;
       const attemptStart = Date.now();
       try {
-        const result = await provider.model.doGenerate(options);
+        const result = await provider.model.doGenerate(callOptions);
         const out = result.usage?.outputTokens?.total ?? 0;
         const inp = result.usage?.inputTokens?.total ?? 0;
         if (inp > 0 && out === 0 && !isLast) {
@@ -514,6 +636,9 @@ var LcrFallbackModel = class {
         this.recordProviderSuccess(idx);
         this.settleSticky(idx);
         this.finalizeOk(ctx, provider, attemptStart, result.usage);
+        if (cache && cacheKey !== void 0 && ctx.settled?.cacheable) {
+          this.storeCache(cacheKey, { kind: "generate", result, meta: ctx.settled.meta });
+        }
         return result;
       } catch (error) {
         lastError = error;
@@ -530,7 +655,76 @@ var LcrFallbackModel = class {
     throw ctx.firstError ?? lastError;
   }
   async doStream(options) {
-    return this.doStreamWithCtx(options, this.startCall(options), this.routeOrder(this.startIndex()), 0);
+    const cache = this.opts.cache;
+    const cacheKey = cache ? cacheKeyOf(this.opts.modelName, options) : void 0;
+    if (cache && cacheKey !== void 0) {
+      const hit = await cache.store.get(cacheKey);
+      if (hit && hit.kind === "stream") {
+        this.finalizeCacheHit(this.startCall(options), hit.meta);
+        return { stream: streamFromParts(hit.parts) };
+      }
+    }
+    const ctx = this.startCall(options);
+    const callOptions = this.opts.promptCache ? withPromptCacheBreakpoint(options, this.opts.promptCache) : options;
+    const inner = await this.doStreamWithCtx(
+      callOptions,
+      ctx,
+      this.routeOrder(this.startIndex()),
+      0
+    );
+    if (!cache || cacheKey === void 0) return inner;
+    const collected = [];
+    const self = this;
+    const wrapped = inner.stream.pipeThrough(
+      new TransformStream({
+        transform(part, controller) {
+          collected.push(part);
+          controller.enqueue(part);
+        },
+        flush() {
+          if (ctx.settled?.cacheable) {
+            self.storeCache(cacheKey, { kind: "stream", parts: collected, meta: ctx.settled.meta });
+          }
+        }
+      })
+    );
+    return { ...inner, stream: wrapped };
+  }
+  /** A response-cache hit: replay a stored answer with no provider call. Settles
+   *  one {@link CallRecord} with `cacheHit`, `costUsd: 0`, and the avoided cost
+   *  on its own `cacheHitSavingUsd` line. */
+  finalizeCacheHit(ctx, meta) {
+    this.emitCall({
+      id: ctx.id,
+      model: this.opts.modelName,
+      attempts: [{ provider: meta.winner, ok: true, latencyMs: Date.now() - ctx.startedAt }],
+      winner: meta.winner,
+      ok: true,
+      failedOver: false,
+      latencyMs: Date.now() - ctx.startedAt,
+      inputTokens: meta.inputTokens,
+      outputTokens: meta.outputTokens,
+      ...meta.cachedInputTokens ? { cachedInputTokens: meta.cachedInputTokens } : {},
+      costUsd: 0,
+      cacheHit: true,
+      ...meta.costUsd > 0 ? { cacheHitSavingUsd: meta.costUsd } : {},
+      ...ctx.requestId ? { requestId: ctx.requestId } : {}
+    });
+  }
+  /** Best-effort write to the response cache: a sync throw or a rejected async
+   *  `set` must never break the request. Caching is an optimization, not a
+   *  guarantee. */
+  storeCache(key, value) {
+    const cache = this.opts.cache;
+    if (!cache) return;
+    try {
+      const r = cache.store.set(key, value, cache.ttlMs);
+      if (r && typeof r.catch === "function") {
+        r.catch(() => {
+        });
+      }
+    } catch {
+    }
   }
   // The stream's failover recursion re-enters here with the SAME `ctx` and the
   // SAME `order` snapshot, advancing only the local position `pos`, so a
@@ -713,6 +907,30 @@ function createHttpSink(options) {
   };
 }
 
+// src/env-sink.ts
+function createEnvSink(dispatch) {
+  const base = process.env.LCR_INGEST_URL?.replace(/\/+$/, "");
+  if (!base) return void 0;
+  return createHttpSink({
+    url: `${base}/api/ingest`,
+    headers: process.env.LCR_INGEST_KEY ? { authorization: `Bearer ${process.env.LCR_INGEST_KEY}` } : void 0,
+    project: process.env.LCR_PROJECT ?? process.env.SITE_KEY,
+    dispatch,
+    onError: (err) => console.error("[lcr] ingest POST failed:", err)
+  });
+}
+
+// src/providers.ts
+var DEFAULT_PROVIDERS = {
+  openrouter: { baseURL: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY" },
+  deepinfra: { baseURL: "https://api.deepinfra.com/v1/openai", apiKeyEnv: "DEEPINFRA_API_KEY" },
+  tokenmart: { baseURL: "https://model.service-inference.ai/v1", apiKeyEnv: "INFERENCE_API_KEY" },
+  deepseek: { baseURL: "https://api.deepseek.com", apiKeyEnv: "DEEPSEEK_API_KEY" },
+  kunavo: { baseURL: "https://api.kunavo.com/v1", apiKeyEnv: "KUNAVO_API_KEY" },
+  runware: { baseURL: "https://api.runware.ai/v1", apiKeyEnv: "RUNWARE_API_KEY" },
+  fal: { baseURL: "https://queue.fal.run", apiKeyEnv: "FAL_KEY" }
+};
+
 // src/text-prices.ts
 var MODEL_PRICES = {
   "chatgpt-4o-latest": { input: 5, output: 15 },
@@ -2012,12 +2230,16 @@ function createLCR(config) {
     autoPrice = false,
     resetIntervalMs,
     cooldown,
+    cache,
+    promptCache,
     onError,
     onCost,
     onCall,
     shouldRetry,
     defaultCacheReadRatio
   } = config;
+  const resolvedCache = resolveCache(cache);
+  const resolvedPromptCache = resolvePromptCache(promptCache);
   if (defaultCacheReadRatio !== void 0 && (defaultCacheReadRatio < 0 || defaultCacheReadRatio > 1)) {
     throw new Error(
       `ai-lcr: defaultCacheReadRatio must be in [0, 1], got ${defaultCacheReadRatio}`
@@ -2037,7 +2259,18 @@ function createLCR(config) {
     }
     routed.set(
       name,
-      new LcrFallbackModel({ modelName: name, providers, resetIntervalMs, cooldown, onError, onCost, onCall, shouldRetry })
+      new LcrFallbackModel({
+        modelName: name,
+        providers,
+        resetIntervalMs,
+        cooldown,
+        ...resolvedCache ? { cache: resolvedCache } : {},
+        ...resolvedPromptCache ? { promptCache: resolvedPromptCache } : {},
+        onError,
+        onCost,
+        onCall,
+        shouldRetry
+      })
     );
   }
   return (modelName) => {
@@ -2052,6 +2285,7 @@ function createLCR(config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_PROVIDERS,
   DEFAULT_REFERENCE,
   MEDIA_PRICING,
   MODEL_PRICES,
@@ -2061,11 +2295,13 @@ function createLCR(config) {
   classifyError,
   classifyErrorKind,
   comparePrices,
+  createEnvSink,
   createFalMediaAdapter,
   createHttpSink,
   createKunavoMediaAdapter,
   createLCR,
   createMediaLCR,
+  createMemoryCacheStore,
   createRunwareMediaAdapter,
   durationFromInput,
   formatCallRecord,