cachegate 1.1.1 → 1.2.0

package/.env.example

@@ -1,112 +1,127 @@
-# cachegate environment template
-# Copy the values you need into your real .env file.
-# NEVER commit .env to Git.
-
-PORT=4000
-
-# Required: protects the router from unauthorized use. The server
-# refuses to start without this UNLESS ALLOW_INSECURE_LOCAL_DEV=true
-# (below) is explicitly set - a missing key never silently means "no
-# auth enforced."
-# Generate with: openssl rand -hex 32
-MODEL_ROUTER_INTERNAL_KEY=your-random-internal-key
-
-# Optional: skip the MODEL_ROUTER_INTERNAL_KEY requirement above, for a
-# throwaway LOCAL instance only. Never set this on anything reachable
-# from outside your own machine.
-# ALLOW_INSECURE_LOCAL_DEV=true
-
-# Required (at least one provider key - Anthropic, OpenAI, or both).
-# The model itself is named PER REQUEST in the API call's own "model"
-# field (see README's "Usage" section), not configured here - there is
-# no ANTHROPIC_MODEL/OPENAI_MODEL env var to set.
-ANTHROPIC_API_KEY=sk-ant-api03-...
-
-# Also required for the semantic cache's embeddings, regardless of
-# which provider actually serves chat requests - it's the only
-# embedding backend implemented (see semanticCache.js / README).
-# OPENAI_API_KEY=sk-proj-...
-
-# Optional: which OpenAI embedding model the semantic cache uses.
-# Only matters if OPENAI_API_KEY is set. Default is a good balance of
-# cost and quality; change only if you know you want a different one.
-# EMBEDDING_MODEL=text-embedding-3-small
-
-# Optional: Redis for response caching (strongly recommended for cost savings)
-# Local development:
-# REDIS_URL=redis://localhost:6379
-# Render Key Value:
-# REDIS_URL=rediss://default:PASSWORD@HOST:PORT
-
-# Optional: persistent metrics storage (see metrics.js's own comment).
-# Unset (the default) keeps metrics as local JSONL files, which don't
-# survive a restart/redeploy on most hosts - fine for a standalone
-# deployment with no database of its own. Set this to a real Postgres
-# connection string to persist metrics there instead.
-# DATABASE_URL=postgres://user:pass@host:5432/dbname
-#
-# MEMOCODE_ROUTER_DATABASE_URL does the exact same thing and takes
-# priority over DATABASE_URL if both are set - use this instead when
-# embedding cachegate inside an app that already has its own
-# DATABASE_URL pointed at a different database (so the two never
-# collide), or just to keep this router's own connection string
-# explicitly distinct from whatever else reads DATABASE_URL in your stack.
-# MEMOCODE_ROUTER_DATABASE_URL=postgres://user:pass@host:5432/dbname
-
-# Optional: where JSONL metrics files live, if Postgres isn't
-# configured. Despite the name, this now names a DIRECTORY (kept for
-# backward compatibility with older configs that pointed it at a
-# single file - see metrics.js's own comment). Defaults to ./data
-# next to this file.
-# METRICS_LOG_PATH=./data
-
-# Optional: how long metrics history is kept before pruneOlderThan()'s
-# scheduled daily job deletes it. Default 90 days deliberately matches
-# /dashboard/data's own longest supported range - pruning any sooner
-# would make its "Last 90 days" option quietly lie.
-# METRICS_RETENTION_DAYS=90
-
-# Optional: semantic cache tuning (all have sane defaults - see README's
-# "Two kinds of cache hit" section before changing these).
-# SEMANTIC_CACHE_ENABLED=false          # hard off-switch, even with a key configured
-# SEMANTIC_CACHE_THRESHOLD=0.93         # cosine similarity floor for a match
-# SEMANTIC_CACHE_MAX_CANDIDATES=200     # per-model list cap (brute-force scan size)
-# SEMANTIC_CACHE_TTL_SECONDS=3600
-
-# Optional: override the default "router:" virtual-model tiers
-# (router.js's own DEFAULT_TIERS) with your own JSON, e.g. to add a
-# model, swap a provider, or define a new tier name entirely. Must be
-# valid JSON matching the shape:
-# {"router:fast-cheap":[{"provider":"openai","model":"gpt-4o-mini"}]}
-# Invalid JSON logs a warning and falls back to the built-in defaults
-# rather than crashing.
-# ROUTER_TIERS_JSON={"router:fast-cheap":[...]}
-
-# Optional: routing strategy for "router:" virtual models (router.js).
-# See README's "Where this leaves things" section for what each one
-# actually does before changing this - there's no blended cost/latency
-# score, only these three explicit options.
-# ROUTER_STRATEGY=cost                        # default: cheapest healthy candidate
-# ROUTER_STRATEGY=latency                     # fastest healthy candidate, cost only as a tiebreaker
-# ROUTER_STRATEGY=latency-guarded-cost        # cheapest healthy candidate, excluding any that's too much slower than the fastest known one
-# ROUTER_LATENCY_GUARD_MULTIPLIER=3           # only used by latency-guarded-cost
-
-# Optional: rate limiting on /v1/* (server.js). Default 300 requests
-# per 60 seconds - shared across EVERY caller of this router combined,
-# not per end user if you're fronting it with your own per-user auth.
-# See server.js's own comment above the rate limiter for the reasoning.
-# RATE_LIMIT_MAX=300
-# RATE_LIMIT_WINDOW_MS=60000
-
-# Optional: separate, more generous rate limit for the read-only
-# aggregate endpoints (/stats, /dashboard/data) - lower stakes than
-# /v1 (no provider spend on the line) but still real server work.
-# Shares RATE_LIMIT_WINDOW_MS above.
-# READ_RATE_LIMIT_MAX=120
-
-# Optional: max JSON body size accepted on /v1/* (server.js). Default
-# 2mb comfortably covers even a very long text conversation - this
-# router doesn't support image/multimodal content, so there's no
-# legitimate reason for a much larger payload. Raise only if you have
-# a specific reason to expect longer request bodies.
-# JSON_BODY_LIMIT=2mb
+# cachegate environment template
+# Copy the values you need into your real .env file.
+# NEVER commit .env to Git.
+
+PORT=4000
+
+# Required: protects the router from unauthorized use. The server
+# refuses to start without this UNLESS ALLOW_INSECURE_LOCAL_DEV=true
+# (below) is explicitly set - a missing key never silently means "no
+# auth enforced."
+# Generate with: openssl rand -hex 32
+MODEL_ROUTER_INTERNAL_KEY=your-random-internal-key
+
+# Optional: skip the MODEL_ROUTER_INTERNAL_KEY requirement above, for a
+# throwaway LOCAL instance only. Never set this on anything reachable
+# from outside your own machine.
+# ALLOW_INSECURE_LOCAL_DEV=true
+
+# Required (at least one provider key - Anthropic, OpenAI, or both).
+# The model itself is named PER REQUEST in the API call's own "model"
+# field (see README's "Usage" section), not configured here - there is
+# no ANTHROPIC_MODEL/OPENAI_MODEL env var to set.
+ANTHROPIC_API_KEY=sk-ant-api03-...
+
+# Also required for the semantic cache's embeddings, regardless of
+# which provider actually serves chat requests - it's the only
+# embedding backend implemented (see semanticCache.js / README).
+# OPENAI_API_KEY=sk-proj-...
+
+# Optional: which OpenAI embedding model the semantic cache uses.
+# Only matters if OPENAI_API_KEY is set. Default is a good balance of
+# cost and quality; change only if you know you want a different one.
+# EMBEDDING_MODEL=text-embedding-3-small
+
+# Optional: Redis for response caching (strongly recommended for cost savings)
+# Local development:
+# REDIS_URL=redis://localhost:6379
+# Render Key Value:
+# REDIS_URL=rediss://default:PASSWORD@HOST:PORT
+
+# Optional: persistent metrics storage (see metrics.js's own comment).
+# Unset (the default) keeps metrics as local JSONL files, which don't
+# survive a restart/redeploy on most hosts - fine for a standalone
+# deployment with no database of its own. Set this to a real Postgres
+# connection string to persist metrics there instead.
+# DATABASE_URL=postgres://user:pass@host:5432/dbname
+#
+# MEMOCODE_ROUTER_DATABASE_URL does the exact same thing and takes
+# priority over DATABASE_URL if both are set - use this instead when
+# embedding cachegate inside an app that already has its own
+# DATABASE_URL pointed at a different database (so the two never
+# collide), or just to keep this router's own connection string
+# explicitly distinct from whatever else reads DATABASE_URL in your stack.
+# MEMOCODE_ROUTER_DATABASE_URL=postgres://user:pass@host:5432/dbname
+
+# Optional: where JSONL metrics files live, if Postgres isn't
+# configured. Despite the name, this now names a DIRECTORY (kept for
+# backward compatibility with older configs that pointed it at a
+# single file - see metrics.js's own comment). Defaults to ./data
+# next to this file.
+# METRICS_LOG_PATH=./data
+
+# Optional: how long metrics history is kept before pruneOlderThan()'s
+# scheduled daily job deletes it. Default 90 days deliberately matches
+# /dashboard/data's own longest supported range - pruning any sooner
+# would make its "Last 90 days" option quietly lie.
+# METRICS_RETENTION_DAYS=90
+
+# Optional: semantic cache tuning (all have sane defaults - see README's
+# "Two kinds of cache hit" section before changing these).
+# SEMANTIC_CACHE_ENABLED=false          # hard off-switch, even with a key configured
+# SEMANTIC_CACHE_THRESHOLD=0.93         # cosine similarity floor for a match
+# SEMANTIC_CACHE_MAX_CANDIDATES=200     # per-model list cap (brute-force scan size)
+# SEMANTIC_CACHE_TTL_SECONDS=3600
+
+# Optional: how many recent requests a provider needs before its error
+# rate is treated as meaningful health data (router.js). Below this
+# sample size, a provider is always considered healthy - a single
+# unlucky request (1/1 or 1/2 errors) shouldn't bounce it out of
+# rotation; it's noise, not a signal, until enough requests have run.
+# ROUTER_HEALTH_MIN_SAMPLES=5
+
+# Optional: hard timeout (ms) on each semantic-cache embedding call
+# (embeddings.js). These sit on the hot request path (1-2 per cache
+# miss, when SEMANTIC_CACHE_ENABLED is on) - a hung embedding provider
+# would otherwise stall every chat request, including Anthropic-only
+# ones with nothing to do with OpenAI. On timeout, the request degrades
+# to "skip semantic caching" rather than hanging.
+# EMBEDDING_TIMEOUT_MS=5000
+
+# Optional: override the default "router:" virtual-model tiers
+# (router.js's own DEFAULT_TIERS) with your own JSON, e.g. to add a
+# model, swap a provider, or define a new tier name entirely. Must be
+# valid JSON matching the shape:
+# {"router:fast-cheap":[{"provider":"openai","model":"gpt-4o-mini"}]}
+# Invalid JSON logs a warning and falls back to the built-in defaults
+# rather than crashing.
+# ROUTER_TIERS_JSON={"router:fast-cheap":[...]}
+
+# Optional: routing strategy for "router:" virtual models (router.js).
+# See README's "Where this leaves things" section for what each one
+# actually does before changing this - there's no blended cost/latency
+# score, only these three explicit options.
+# ROUTER_STRATEGY=cost                        # default: cheapest healthy candidate
+# ROUTER_STRATEGY=latency                     # fastest healthy candidate, cost only as a tiebreaker
+# ROUTER_STRATEGY=latency-guarded-cost        # cheapest healthy candidate, excluding any that's too much slower than the fastest known one
+# ROUTER_LATENCY_GUARD_MULTIPLIER=3           # only used by latency-guarded-cost
+
+# Optional: rate limiting on /v1/* (server.js). Default 300 requests
+# per 60 seconds - shared across EVERY caller of this router combined,
+# not per end user if you're fronting it with your own per-user auth.
+# See server.js's own comment above the rate limiter for the reasoning.
+# RATE_LIMIT_MAX=300
+# RATE_LIMIT_WINDOW_MS=60000
+
+# Optional: separate, more generous rate limit for the read-only
+# aggregate endpoints (/stats, /dashboard/data) - lower stakes than
+# /v1 (no provider spend on the line) but still real server work.
+# Shares RATE_LIMIT_WINDOW_MS above.
+# READ_RATE_LIMIT_MAX=120
+
+# Optional: max JSON body size accepted on /v1/* (server.js). Default
+# 2mb comfortably covers even a very long text conversation - this
+# router doesn't support image/multimodal content, so there's no
+# legitimate reason for a much larger payload. Raise only if you have
+# a specific reason to expect longer request bodies.
+# JSON_BODY_LIMIT=2mb

package/README.md

@@ -21,8 +21,9 @@ fills instead:
   now ship a more sophisticated vector-indexed semantic cache than this
   project's brute-force cosine scan — stated plainly, not glossed over;
   see "Two kinds of cache hit" below for what this one actually does.)
-- **Node.js/TypeScript-native** — most comparable gateways are Python;
-  this fits directly into a JS/TS stack with no cross-language bridge.
+- **Node.js-native (plain JavaScript, no build step)** — most comparable
+  gateways are Python; this fits directly into a JS/TS stack with no
+  cross-language bridge.
 - **Small and embeddable** — a handful of files, no framework beyond
   Express, easy to read end to end and drop into an existing app's own
   backend rather than standing up a separate service.
@@ -224,12 +225,15 @@ curl http://localhost:4000/v1/chat/completions \
   }'
 ```
 
-`GET /health` lists the configured tiers and the active routing
-strategy. Tiers are defined in `router.js` (`DEFAULT_TIERS`) and can be
-overridden per deployment via the `ROUTER_TIERS_JSON` env var; the
-strategy is `ROUTER_STRATEGY` (`cost` / `latency` / `latency-guarded-cost`,
-default `cost`) - see "Where this leaves things" below for what each
-one actually does.
+`GET /stats` (auth required) lists the configured tiers and the active
+routing strategy, alongside which providers have a key configured -
+security-review finding (2026-09-02): this used to live on the PUBLIC
+`GET /health` instead, world-readable internal routing configuration
+with no reason to be. Tiers are defined in `router.js`
+(`DEFAULT_TIERS`) and can be overridden per deployment via the
+`ROUTER_TIERS_JSON` env var; the strategy is `ROUTER_STRATEGY` (`cost` /
+`latency` / `latency-guarded-cost`, default `cost`) - see "Where this
+leaves things" below for what each one actually does.
 
 Streamed dispatch - add `"stream": true` to either form above and get
 back SSE chunks instead of one JSON body (see "Streaming" below for
@@ -263,7 +267,12 @@ auth, for local development only.
 - OpenAI-compatible `/v1/chat/completions` endpoint - direct dispatch to
   a named provider model, or routed dispatch via a `router:` capability
   tier (cheapest currently-healthy candidate, by estimated cost; see
-  `router.js`).
+  `router.js`). "Unhealthy" means a recent error rate of 50% or higher
+  over that provider's own rolling request window - but only once it has
+  at least `ROUTER_HEALTH_MIN_SAMPLES` (default 5) recent requests to
+  judge from; below that, a provider is always treated as healthy, so a
+  single unlucky request (1/1 or 1/2 errors) can't bounce it out of
+  rotation on noise alone.
 - **`stream: true` works** for plain text content, on both providers,
   including replaying a cache hit (exact or semantic) as a stream so a
   streaming caller still gets the caching benefit. See "Streaming"
@@ -287,10 +296,12 @@ auth, for local development only.
   history to work from, not just a number thrown away after each
   response.
 - Rate limiting on `/v1/*` (`RATE_LIMIT_MAX` requests per
-  `RATE_LIMIT_WINDOW_MS`, defaults 60/60s) - this proxy sits in front of
+  `RATE_LIMIT_WINDOW_MS`, defaults 300/60s) - this proxy sits in front of
   paid, metered keys, so an unbounded client has no ceiling otherwise.
-- `GET /health` for monitoring (public, no auth) and `GET /stats` for a
-  quick record-count-windowed aggregate snapshot (auth required).
+- `GET /health` for monitoring (public, no auth - deliberately minimal:
+  process/dependency status only, no provider or routing configuration)
+  and `GET /stats` for a quick record-count-windowed aggregate snapshot,
+  plus the configured providers/tiers/strategy (auth required).
 - **A cost dashboard** at `GET /dashboard` - a static page (no auth
   itself; its own JS asks for the internal key and stores it in
   localStorage, then calls the authenticated data endpoint below) with
@@ -333,6 +344,13 @@ near-duplicate traffic is common; it's pure overhead when it isn't. Set
 `SEMANTIC_CACHE_ENABLED=false` to disable it outright while keeping the
 exact-match cache and `OPENAI_API_KEY` for other things.
 
+Both embedding calls carry a hard timeout (`EMBEDDING_TIMEOUT_MS`,
+default 5000ms) - they sit on the hot request path of every cache miss,
+so a hung embedding provider degrades to "skip semantic caching for this
+request" instead of stalling chat traffic that has nothing to do with
+OpenAI (an Anthropic-only request still needs an embedding call to check
+the semantic cache).
+
 Storage is a plain Redis list per model, capped at
 `SEMANTIC_CACHE_MAX_CANDIDATES` (default 200) - a lookup does a
 brute-force cosine-similarity scan over that list in Node, not an
@@ -447,7 +465,7 @@ positioning. A few things worth knowing before relying on it:
     fraction of a cent, not a full re-ranking. With no latency data at
     all yet, it degrades to plain `cost`.
 
-  `GET /health` reports the active strategy (`routing_strategy`); a
+  `GET /stats` reports the active strategy (`routing_strategy`); a
   decision's `reason.strategy` and `reason.latencyGuardExcludedACandidate`
   say which one ran and whether the guard actually did anything, same
   transparency style as the rest of the routing decision. Tier

package/cache.js

@@ -1,51 +1,72 @@
-// model-router/cache.js
-//
-// The exact-match cache: same model + same messages + same params ->
-// same cached response, by content hash. First and free - checked
-// before the semantic cache (semanticCache.js), which is slower (an
-// embedding call) and probabilistic (a similarity threshold, not an
-// exact match). Connection is shared via redisClient.js.
-
-const crypto = require('crypto');
-const redis = require('./redisClient');
-
-function buildCacheKey(payload) {
-  const normalized = JSON.stringify({
-    model: payload.model,
-    messages: payload.messages,
-    temperature: payload.temperature ?? 0.0,
-    max_tokens: payload.max_tokens,
-    tools: payload.tools,
-    tool_choice: payload.tool_choice
-  });
-  const hash = crypto.createHash('sha256').update(normalized).digest('hex');
-  return `ROUTER:${payload.model}:${hash}`;
-}
-
-module.exports = {
-  buildCacheKey,
-
-  isConnected() {
-    return redis.isConnected();
-  },
-
-  async get(payload) {
-    if (!redis.isConnected()) return null;
-    try {
-      const cached = await redis.client.get(buildCacheKey(payload));
-      return cached ? JSON.parse(cached) : null;
-    } catch (err) {
-      return null;
-    }
-  },
-
-  async set(payload, response, ttlSeconds = 3600) {
-    if (!redis.isConnected()) return false;
-    try {
-      await redis.client.set(buildCacheKey(payload), JSON.stringify(response), { EX: ttlSeconds });
-      return true;
-    } catch (err) {
-      return false;
-    }
-  }
-};
+// model-router/cache.js
+//
+// The exact-match cache: same model + same messages + same params ->
+// same cached response, by content hash. First and free - checked
+// before the semantic cache (semanticCache.js), which is slower (an
+// embedding call) and probabilistic (a similarity threshold, not an
+// exact match). Connection is shared via redisClient.js.
+
+const crypto = require('crypto');
+const redis = require('./redisClient');
+
+// `scope` (seams work, roadmap: engine/cloud "wrap it, don't fork it"):
+// an opaque, caller-supplied isolation key - a tenant id, a namespace,
+// whatever a wrapping deployment needs two callers to never share a
+// cache entry over. null/undefined (every call in this codebase today)
+// means exactly what it always has: one global cache, no isolation -
+// scope is omitted from both the key prefix AND the hashed payload in
+// that case, so an unconfigured deployment's cache keys are BYTE-
+// IDENTICAL to before this parameter existed (no cache invalidation on
+// upgrade). When a caller does pass a scope, it's folded into both the
+// prefix and the hash (not the prefix alone) - so two scopes are
+// isolated even if the caller's own scope-naming convention were ever
+// guessed or leaked; a compromised/guessed prefix alone can't be walked
+// into another scope's cached content.
+function buildCacheKey(scope, payload) {
+  const normalized = JSON.stringify({
+    ...(scope != null ? { scope } : {}),
+    model: payload.model,
+    messages: payload.messages,
+    temperature: payload.temperature ?? 0.0,
+    max_tokens: payload.max_tokens,
+    tools: payload.tools,
+    tool_choice: payload.tool_choice,
+    // response_format changes the SHAPE of the answer (json_object vs
+    // plain text), so it must participate in the key too - otherwise a
+    // cached plain-text response could be served to a json_object caller
+    // (or vice versa). openai.js forwards it (see its own chat()); this
+    // file used to omit it, making an "exact" hit not always exact.
+    response_format: payload.response_format
+  });
+  const hash = crypto.createHash('sha256').update(normalized).digest('hex');
+  const prefix = scope != null ? `ROUTER:${scope}:` : 'ROUTER:';
+  return `${prefix}${payload.model}:${hash}`;
+}
+
+module.exports = {
+  buildCacheKey,
+
+  isConnected() {
+    return redis.isConnected();
+  },
+
+  async get(scope, payload) {
+    if (!redis.isConnected()) return null;
+    try {
+      const cached = await redis.client.get(buildCacheKey(scope, payload));
+      return cached ? JSON.parse(cached) : null;
+    } catch (err) {
+      return null;
+    }
+  },
+
+  async set(scope, payload, response, ttlSeconds = 3600) {
+    if (!redis.isConnected()) return false;
+    try {
+      await redis.client.set(buildCacheKey(scope, payload), JSON.stringify(response), { EX: ttlSeconds });
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+};

package/embeddings.js

@@ -1,32 +1,42 @@
-// model-router/embeddings.js
-//
-// The only embedding backend right now is OpenAI's - which means
-// semantic caching needs an OPENAI_API_KEY configured even for a
-// deployment that only ever talks to Anthropic for chat. That's a real
-// constraint, not hidden: isEnabled() is what semanticCache.js checks
-// before doing anything, and it degrades to "disabled" (not an error)
-// when the key isn't set, same as the Redis cache does when REDIS_URL
-// isn't set.
-
-const { OpenAI } = require('openai');
-
-let client;
-function getClient() {
-  if (!client) client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-  return client;
-}
-
-function isEnabled() {
-  return Boolean(process.env.OPENAI_API_KEY);
-}
-
-async function embed(text) {
-  if (!isEnabled()) {
-    throw new Error('OPENAI_API_KEY not configured - embeddings unavailable');
-  }
-  const model = process.env.EMBEDDING_MODEL || 'text-embedding-3-small';
-  const response = await getClient().embeddings.create({ model, input: text });
-  return response.data[0].embedding;
-}
-
-module.exports = { isEnabled, embed };
+// model-router/embeddings.js
+//
+// The only embedding backend right now is OpenAI's - which means
+// semantic caching needs an OPENAI_API_KEY configured even for a
+// deployment that only ever talks to Anthropic for chat. That's a real
+// constraint, not hidden: isEnabled() is what semanticCache.js checks
+// before doing anything, and it degrades to "disabled" (not an error)
+// when the key isn't set, same as the Redis cache does when REDIS_URL
+// isn't set.
+
+const { OpenAI } = require('openai');
+
+let client;
+function getClient() {
+  if (!client) client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+  return client;
+}
+
+function isEnabled() {
+  return Boolean(process.env.OPENAI_API_KEY);
+}
+
+async function embed(text) {
+  if (!isEnabled()) {
+    throw new Error('OPENAI_API_KEY not configured - embeddings unavailable');
+  }
+  const model = process.env.EMBEDDING_MODEL || 'text-embedding-3-small';
+  // A hard timeout per embedding call: these run on the hot request path
+  // (semanticCache.js's findMatch/store, one or two per miss), so a hung
+  // embedding provider must not be able to stall every chat request -
+  // including ones that never touch embeddings at all if the semantic
+  // cache is enabled. AbortSignal.timeout aborts the underlying fetch, and
+  // the thrown error is caught by semanticCache.js's own try/catch, which
+  // degrades to "skip semantic caching" rather than failing the request.
+  const response = await getClient().embeddings.create(
+    { model, input: text },
+    { signal: AbortSignal.timeout(Number(process.env.EMBEDDING_TIMEOUT_MS) || 5000) }
+  );
+  return response.data[0].embedding;
+}
+
+module.exports = { isEnabled, embed };