hydramcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PicklePixel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,192 @@
+<p align="center">
+  <img src="assets/HydraMCP.png" width="200" />
+</p>
+
+<h1 align="center">HydraMCP</h1>
+<p align="center">Connect agents to agents.</p>
+
+An MCP server that lets Claude Code query any LLM — compare, vote, and synthesize across GPT, Gemini, Claude, and local models from one terminal.
+
+## Quick Start
+
+```bash
+npx hydramcp setup
+```
+
+That's it. The wizard walks you through everything — API keys, subscriptions, local models. At the end it gives you the one-liner to add to Claude Code.
+
+Or if you already have API keys:
+
+```bash
+claude mcp add hydramcp -e OPENAI_API_KEY=sk-... -- npx hydramcp
+```
+
+## What It Looks Like
+
+Four models, four ecosystems, one prompt. Real output from a live session:
+
+```
+> compare gpt-5-codex, gemini-3, claude-sonnet, and local qwen on this function review
+
+## Model Comparison (4 models, 11637ms total)
+
+| Model                      | Latency         | Tokens |
+|----------------------------|-----------------|--------|
+| gpt-5-codex                | 1630ms fastest  | 194    |
+| gemini-3-pro-preview       | 11636ms         | 1235   |
+| claude-sonnet-4-5-20250929 | 3010ms          | 202    |
+| ollama/qwen2.5-coder:14b   | 8407ms          | 187    |
+```
+
+All four independently found the same async bug. Then each one caught something different the others missed.
+
+And this is consensus with a local judge:
+
+```
+> get consensus from gpt-5, gemini-3, and claude-sonnet. use local qwen as judge.
+
+## Consensus: REACHED
+
+Strategy: majority (needed 2/3)
+Agreement: 3/3 models (100%)
+Judge: ollama/qwen2.5-coder:14b (686ms)
+```
+
+Three cloud models polled, local model judging them. 686ms to evaluate agreement.
+
+## Tools
+
+| Tool | What It Does |
+|------|-------------|
+| **list_models** | See what's available across all providers |
+| **ask_model** | Query any model, optional response distillation |
+| **compare_models** | Same prompt to 2-5 models in parallel |
+| **consensus** | Poll 3-7 models, LLM-as-judge evaluates agreement |
+| **synthesize** | Combine best ideas from multiple models into one answer |
+| **analyze_file** | Offload file analysis to a worker model |
+| **smart_read** | Extract specific code sections without reading the whole file |
+| **session_recap** | Restore context from previous Claude Code sessions |
+
+From inside Claude Code, just say things like:
+- "ask gpt-5 to review this function"
+- "compare gemini and claude on this approach"
+- "get consensus from 3 models on whether this is thread safe"
+- "synthesize responses from all models on how to design this API"
+
+## How It Works
+
+```
+Claude Code
+    |
+    HydraMCP (MCP Server)
+    |
+    SmartProvider (circuit breaker, cache, metrics)
+    |
+    MultiProvider (routes to the right backend)
+    |
+    |-- OpenAI     -> api.openai.com (API key)
+    |-- Google     -> Gemini API (API key)
+    |-- Anthropic  -> api.anthropic.com (API key)
+    |-- Sub        -> CLI tools (Gemini CLI, Claude Code, Codex CLI)
+    |-- Ollama     -> local models (your hardware)
+```
+
+## Three Ways to Connect Models
+
+### API Keys (fastest setup)
+
+Set environment variables. HydraMCP auto-detects them.
+
+| Variable | Provider |
+|----------|----------|
+| `OPENAI_API_KEY` | OpenAI (GPT-4o, GPT-5, o3, etc.) |
+| `GOOGLE_API_KEY` | Google Gemini (2.5 Flash, Pro, etc.) |
+| `ANTHROPIC_API_KEY` | Anthropic Claude (Opus, Sonnet, Haiku) |
+
+### Subscriptions (use your monthly plan)
+
+Already paying for ChatGPT Plus, Claude Pro, or Gemini Advanced? HydraMCP wraps the CLI tools those subscriptions include. No API billing.
+
+```bash
+npx hydramcp setup   # auto-installs CLIs and runs auth
+```
+
+The setup wizard detects which CLIs you have, installs missing ones, and walks you through authentication. Each CLI authenticates via browser once — then it's stored forever.
+
+| Subscription | CLI Tool | What You Get |
+|-------------|----------|-------------|
+| Gemini Advanced | `gemini` | Gemini 2.5 Flash, Pro, etc. |
+| Claude Pro/Max | `claude` | Claude Opus, Sonnet, Haiku |
+| ChatGPT Plus/Pro | `codex` | GPT-5, o3, Codex models |
+
+### Local Models
+
+Install [Ollama](https://ollama.com), pull a model, done. Auto-detected.
+
+```bash
+ollama pull qwen2.5-coder:14b
+```
+
+### Mix and Match
+
+All three methods stack. Use API keys for some providers, subscriptions for others, and Ollama for local. They all show up in `list_models` together.
+
+Route explicitly with prefixes:
+- `openai/gpt-5` — force OpenAI API
+- `google/gemini-2.5-flash` — force Google API
+- `sub/gemini-2.5-flash` — force subscription CLI
+- `ollama/qwen2.5-coder:14b` — force local
+- `gpt-5` — auto-detect (tries each provider)
+
+## Setup Details
+
+### Option A: npx (recommended)
+
+```bash
+npx hydramcp setup                           # interactive wizard
+claude mcp add hydramcp -- npx hydramcp      # register with Claude Code
+```
+
+Config is saved to `~/.hydramcp/.env` and persists across npx runs.
+
+### Option B: Clone
+
+```bash
+git clone https://github.com/Pickle-Pixel/HydraMCP.git
+cd HydraMCP
+npm install && npm run build
+claude mcp add hydramcp -- node /path/to/HydraMCP/dist/index.js
+```
+
+### Verify
+
+Restart Claude Code and say "list models". You should see everything you configured.
+
+## Architecture
+
+HydraMCP wraps all providers in a **SmartProvider** layer that adds:
+
+- **Circuit breaker** — per-model failure tracking. After 3 failures, the model is disabled for 60s and auto-recovers.
+- **Response cache** — SHA-256 keyed, 15-minute TTL. Identical queries are served instantly.
+- **Metrics** — per-model query counts, latency, token usage, cache hit rates.
+- **Response distillation** — set `max_response_tokens` on any query and a cheap model compresses the response while preserving code, errors, and specifics.
+
+## Contributing
+
+Want to add a provider? The interface is three methods:
+
+```typescript
+interface Provider {
+  healthCheck(): Promise<boolean>;
+  listModels(): Promise<ModelInfo[]>;
+  query(model: string, prompt: string, options?: QueryOptions): Promise<QueryResponse>;
+}
+```
+
+See `src/providers/ollama.ts` for a working example. Implement it, register in `src/index.ts`, done.
+
+Providers we'd love to see: LM Studio, OpenRouter, Groq, Together AI, or anything that speaks HTTP.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * HydraMCP — Entry point.
+ *
+ * Auto-detects available providers from environment and installed tools:
+ *
+ *   API Keys (direct, fast):
+ *     OPENAI_API_KEY      → OpenAI (GPT-4o, GPT-5, o3, etc.)
+ *     GOOGLE_API_KEY      → Google Gemini (or GEMINI_API_KEY)
+ *     ANTHROPIC_API_KEY   → Anthropic Claude
+ *
+ *   Subscriptions (via installed CLI tools):
+ *     gemini CLI           → Gemini Advanced subscription
+ *     claude CLI           → Claude Pro/Max subscription
+ *     codex CLI            → ChatGPT Plus/Pro subscription
+ *
+ *   Local models:
+ *     OLLAMA_URL           → Ollama local models (auto-detected)
+ *
+ * Set any combination. HydraMCP registers what's available.
+ *
+ * Model routing:
+ *   "openai/gpt-4o"          → OpenAI API key
+ *   "google/gemini-2.5-flash" → Google API key
+ *   "anthropic/claude-..."    → Anthropic API key
+ *   "sub/gemini-2.5-flash"    → Gemini CLI subscription
+ *   "sub/claude-..."          → Claude CLI subscription
+ *   "ollama/llama3"           → local Ollama instance
+ *   "gpt-4o"                  → auto-detect (tries each provider)
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * HydraMCP — Entry point.
+ *
+ * Auto-detects available providers from environment and installed tools:
+ *
+ *   API Keys (direct, fast):
+ *     OPENAI_API_KEY      → OpenAI (GPT-4o, GPT-5, o3, etc.)
+ *     GOOGLE_API_KEY      → Google Gemini (or GEMINI_API_KEY)
+ *     ANTHROPIC_API_KEY   → Anthropic Claude
+ *
+ *   Subscriptions (via installed CLI tools):
+ *     gemini CLI           → Gemini Advanced subscription
+ *     claude CLI           → Claude Pro/Max subscription
+ *     codex CLI            → ChatGPT Plus/Pro subscription
+ *
+ *   Local models:
+ *     OLLAMA_URL           → Ollama local models (auto-detected)
+ *
+ * Set any combination. HydraMCP registers what's available.
+ *
+ * Model routing:
+ *   "openai/gpt-4o"          → OpenAI API key
+ *   "google/gemini-2.5-flash" → Google API key
+ *   "anthropic/claude-..."    → Anthropic API key
+ *   "sub/gemini-2.5-flash"    → Gemini CLI subscription
+ *   "sub/claude-..."          → Claude CLI subscription
+ *   "ollama/llama3"           → local Ollama instance
+ *   "gpt-4o"                  → auto-detect (tries each provider)
+ */
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { OpenAIProvider } from "./providers/openai.js";
+import { GoogleProvider } from "./providers/google.js";
+import { AnthropicProvider } from "./providers/anthropic.js";
+import { SubscriptionProvider } from "./providers/subscription.js";
+import { OllamaProvider } from "./providers/ollama.js";
+import { MultiProvider } from "./providers/multi-provider.js";
+import { SmartProvider } from "./orchestrator/index.js";
+import { createServer } from "./server.js";
+import { logger } from "./utils/logger.js";
+import { loadEnv } from "./utils/env.js";
+async function main() {
+    // Setup wizard: npx hydramcp setup
+    if (process.argv.includes("setup")) {
+        const { runSetup } = await import("./setup.js");
+        await runSetup();
+        return;
+    }
+    // Load .env before anything reads process.env
+    loadEnv();
+    const multi = new MultiProvider();
+    const active = [];
+    // --- Native API providers (preferred — direct, fast, reliable) ---
+    if (process.env.OPENAI_API_KEY) {
+        multi.register("openai", new OpenAIProvider());
+        active.push("OpenAI");
+    }
+    if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {
+        multi.register("google", new GoogleProvider());
+        active.push("Google");
+    }
+    if (process.env.ANTHROPIC_API_KEY) {
+        multi.register("anthropic", new AnthropicProvider());
+        active.push("Anthropic");
+    }
+    // --- Subscription providers (CLI-based, uses monthly subscriptions) ---
+    const sub = new SubscriptionProvider();
+    const subCount = await sub.detect();
+    if (subCount > 0) {
+        multi.register("sub", sub);
+        active.push(`Subscriptions (${subCount} CLI tools)`);
+    }
+    // --- Local models ---
+    const ollama = new OllamaProvider();
+    if (await ollama.healthCheck()) {
+        multi.register("ollama", ollama);
+        active.push("Ollama");
+    }
+    // --- Startup summary ---
+    if (active.length === 0) {
+        logger.warn("No providers detected. Set at least one:\n" +
+            "\n" +
+            "  API Keys (direct access):\n" +
+            "    OPENAI_API_KEY      — OpenAI (GPT-4o, GPT-5, o3, ...)\n" +
+            "    GOOGLE_API_KEY      — Google Gemini\n" +
+            "    ANTHROPIC_API_KEY   — Anthropic Claude\n" +
+            "\n" +
+            "  Subscriptions (install CLI tools, auth once):\n" +
+            "    npm i -g @google/gemini-cli   → then: gemini auth\n" +
+            "    npm i -g @anthropic-ai/claude-code → then: claude\n" +
+            "    npm i -g @openai/codex         → then: codex auth\n" +
+            "\n" +
+            "  Local models:\n" +
+            "    Install Ollama → ollama pull llama3\n" +
+            "\n" +
+            "HydraMCP will start anyway and retry on first request.");
+    }
+    else {
+        logger.info(`Providers: ${active.join(", ")}`);
+    }
+    // Wrap with SmartProvider (orchestrator: circuit breaker, caching, metrics)
+    const provider = new SmartProvider(multi);
+    const server = createServer(provider);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info(`HydraMCP running — ${active.length} provider(s) active`);
+}
+main().catch((err) => {
+    logger.error(`Fatal: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

package/dist/orchestrator/cache.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Caches for the orchestrator layer.
+ *
+ * ResponseCache — caches query() results by content hash (SHA-256).
+ *   15-min TTL, 100 max entries, LRU eviction.
+ *
+ * ModelListCache — caches listModels() results.
+ *   30-sec TTL, single entry (latest result).
+ *   Deduplicates the 3-4 listModels() calls that happen per tool invocation
+ *   (pickCompressorModel, pickLargeContextModel, etc.)
+ */
+import { QueryResponse, QueryOptions, ModelInfo } from "../providers/provider.js";
+export interface ResponseCacheConfig {
+    ttlMs: number;
+    maxEntries: number;
+}
+export declare class ResponseCache {
+    private cache;
+    private config;
+    constructor(config: ResponseCacheConfig);
+    /** Build a cache key from query parameters. */
+    key(model: string, prompt: string, options?: QueryOptions): string;
+    /** Get a cached response, or null if missing/expired. */
+    get(key: string): QueryResponse | null;
+    /** Store a response in the cache. */
+    set(key: string, response: QueryResponse): void;
+    /** Number of entries in cache. */
+    get size(): number;
+}
+export interface ModelListCacheConfig {
+    ttlMs: number;
+}
+export declare class ModelListCache {
+    private models;
+    private timestamp;
+    private config;
+    constructor(config: ModelListCacheConfig);
+    /** Get cached model list, or null if stale/empty. */
+    get(): ModelInfo[] | null;
+    /** Store model list. */
+    set(models: ModelInfo[]): void;
+    /** Invalidate the cache (e.g., when circuit breaker state changes). */
+    invalidate(): void;
+}

package/dist/orchestrator/cache.js

@@ -0,0 +1,80 @@
+/**
+ * Caches for the orchestrator layer.
+ *
+ * ResponseCache — caches query() results by content hash (SHA-256).
+ *   15-min TTL, 100 max entries, LRU eviction.
+ *
+ * ModelListCache — caches listModels() results.
+ *   30-sec TTL, single entry (latest result).
+ *   Deduplicates the 3-4 listModels() calls that happen per tool invocation
+ *   (pickCompressorModel, pickLargeContextModel, etc.)
+ */
+import { createHash } from "node:crypto";
+export class ResponseCache {
+    cache = new Map();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /** Build a cache key from query parameters. */
+    key(model, prompt, options) {
+        const raw = `${model}|${prompt}|${JSON.stringify(options ?? {})}`;
+        return createHash("sha256").update(raw).digest("hex");
+    }
+    /** Get a cached response, or null if missing/expired. */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() - entry.timestamp > this.config.ttlMs) {
+            this.cache.delete(key);
+            return null;
+        }
+        // Move to end for LRU (delete + re-add preserves Map insertion order)
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.response;
+    }
+    /** Store a response in the cache. */
+    set(key, response) {
+        // LRU eviction: remove oldest entry if at capacity
+        if (this.cache.size >= this.config.maxEntries) {
+            const oldest = this.cache.keys().next().value;
+            if (oldest) {
+                this.cache.delete(oldest);
+            }
+        }
+        this.cache.set(key, { response, timestamp: Date.now() });
+    }
+    /** Number of entries in cache. */
+    get size() {
+        return this.cache.size;
+    }
+}
+export class ModelListCache {
+    models = null;
+    timestamp = 0;
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /** Get cached model list, or null if stale/empty. */
+    get() {
+        if (!this.models)
+            return null;
+        if (Date.now() - this.timestamp > this.config.ttlMs) {
+            this.models = null;
+            return null;
+        }
+        return this.models;
+    }
+    /** Store model list. */
+    set(models) {
+        this.models = models;
+        this.timestamp = Date.now();
+    }
+    /** Invalidate the cache (e.g., when circuit breaker state changes). */
+    invalidate() {
+        this.models = null;
+    }
+}

package/dist/orchestrator/circuit-breaker.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Circuit breaker — per-model failure tracking with automatic recovery.
+ *
+ * States:
+ *   closed    → normal operation, requests flow through
+ *   open      → model disabled after N consecutive failures, requests rejected
+ *   half-open → cooldown expired, allow one retry to test recovery
+ *
+ * On success → reset to closed.
+ * On failure in half-open → back to open with fresh cooldown.
+ */
+export type CircuitState = "closed" | "open" | "half-open";
+export interface CircuitBreakerConfig {
+    maxFailures: number;
+    cooldownMs: number;
+}
+export declare class CircuitBreaker {
+    private circuits;
+    private config;
+    constructor(config: CircuitBreakerConfig);
+    /** Check if the circuit is open (model should not be called). */
+    isOpen(model: string): boolean;
+    /** Record a successful query — reset circuit to closed. */
+    recordSuccess(model: string): void;
+    /** Record a failed query — increment failures, potentially open circuit. */
+    recordFailure(model: string): void;
+    /** Get status of all tracked models. */
+    getStatus(): Map<string, {
+        state: CircuitState;
+        failures: number;
+    }>;
+    /** Get list of models currently in open state. */
+    getOpenModels(): string[];
+}

package/dist/orchestrator/circuit-breaker.js

@@ -0,0 +1,90 @@
+/**
+ * Circuit breaker — per-model failure tracking with automatic recovery.
+ *
+ * States:
+ *   closed    → normal operation, requests flow through
+ *   open      → model disabled after N consecutive failures, requests rejected
+ *   half-open → cooldown expired, allow one retry to test recovery
+ *
+ * On success → reset to closed.
+ * On failure in half-open → back to open with fresh cooldown.
+ */
+import { logger } from "../utils/logger.js";
+export class CircuitBreaker {
+    circuits = new Map();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /** Check if the circuit is open (model should not be called). */
+    isOpen(model) {
+        const circuit = this.circuits.get(model);
+        if (!circuit || circuit.state === "closed")
+            return false;
+        if (circuit.state === "open") {
+            // Check if cooldown has expired → transition to half-open
+            if (Date.now() - circuit.lastFailureTime >= this.config.cooldownMs) {
+                circuit.state = "half-open";
+                logger.info(`circuit-breaker: ${model} → half-open (cooldown expired, allowing retry)`);
+                return false; // Allow one retry
+            }
+            return true; // Still in cooldown
+        }
+        // half-open: allow the retry
+        return false;
+    }
+    /** Record a successful query — reset circuit to closed. */
+    recordSuccess(model) {
+        const circuit = this.circuits.get(model);
+        if (!circuit)
+            return;
+        if (circuit.state !== "closed") {
+            logger.info(`circuit-breaker: ${model} → closed (recovered)`);
+        }
+        this.circuits.delete(model); // Clean state = no entry
+    }
+    /** Record a failed query — increment failures, potentially open circuit. */
+    recordFailure(model) {
+        const circuit = this.circuits.get(model) ?? {
+            state: "closed",
+            failures: 0,
+            lastFailureTime: 0,
+        };
+        circuit.failures++;
+        circuit.lastFailureTime = Date.now();
+        if (circuit.state === "half-open") {
+            // Retry failed — back to open
+            circuit.state = "open";
+            logger.warn(`circuit-breaker: ${model} → open (retry failed, ${circuit.failures} total failures)`);
+        }
+        else if (circuit.failures >= this.config.maxFailures) {
+            circuit.state = "open";
+            logger.warn(`circuit-breaker: ${model} → open (${circuit.failures} consecutive failures)`);
+        }
+        this.circuits.set(model, circuit);
+    }
+    /** Get status of all tracked models. */
+    getStatus() {
+        const status = new Map();
+        for (const [model, circuit] of this.circuits) {
+            status.set(model, {
+                state: circuit.state,
+                failures: circuit.failures,
+            });
+        }
+        return status;
+    }
+    /** Get list of models currently in open state. */
+    getOpenModels() {
+        const open = [];
+        for (const [model, circuit] of this.circuits) {
+            if (circuit.state === "open") {
+                // Check if still within cooldown
+                if (Date.now() - circuit.lastFailureTime < this.config.cooldownMs) {
+                    open.push(model);
+                }
+            }
+        }
+        return open;
+    }
+}

package/dist/orchestrator/config.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Orchestrator configuration — sensible defaults with env var overrides.
+ */
+export interface OrchestratorConfig {
+    maxFailures: number;
+    cooldownMs: number;
+    queryCacheTtlMs: number;
+    queryCacheMaxEntries: number;
+    modelListCacheTtlMs: number;
+    enableCache: boolean;
+    enableCircuitBreaker: boolean;
+}
+export declare const DEFAULT_CONFIG: OrchestratorConfig;
+/** Read config from env vars, falling back to defaults. */
+export declare function loadConfig(overrides?: Partial<OrchestratorConfig>): OrchestratorConfig;

package/dist/orchestrator/config.js

@@ -0,0 +1,50 @@
+/**
+ * Orchestrator configuration — sensible defaults with env var overrides.
+ */
+export const DEFAULT_CONFIG = {
+    maxFailures: 3,
+    cooldownMs: 60_000, // 1 minute
+    queryCacheTtlMs: 900_000, // 15 minutes
+    queryCacheMaxEntries: 100,
+    modelListCacheTtlMs: 30_000, // 30 seconds
+    enableCache: true,
+    enableCircuitBreaker: true,
+};
+/** Read config from env vars, falling back to defaults. */
+export function loadConfig(overrides) {
+    const env = process.env;
+    return {
+        maxFailures: overrides?.maxFailures ??
+            intEnv(env.HYDRA_CB_MAX_FAILURES) ??
+            DEFAULT_CONFIG.maxFailures,
+        cooldownMs: overrides?.cooldownMs ??
+            intEnv(env.HYDRA_CB_COOLDOWN_MS) ??
+            DEFAULT_CONFIG.cooldownMs,
+        queryCacheTtlMs: overrides?.queryCacheTtlMs ??
+            intEnv(env.HYDRA_CACHE_TTL_MS) ??
+            DEFAULT_CONFIG.queryCacheTtlMs,
+        queryCacheMaxEntries: overrides?.queryCacheMaxEntries ??
+            intEnv(env.HYDRA_CACHE_MAX_ENTRIES) ??
+            DEFAULT_CONFIG.queryCacheMaxEntries,
+        modelListCacheTtlMs: overrides?.modelListCacheTtlMs ??
+            intEnv(env.HYDRA_MODEL_CACHE_TTL_MS) ??
+            DEFAULT_CONFIG.modelListCacheTtlMs,
+        enableCache: overrides?.enableCache ??
+            boolEnv(env.HYDRA_CACHE_ENABLED) ??
+            DEFAULT_CONFIG.enableCache,
+        enableCircuitBreaker: overrides?.enableCircuitBreaker ??
+            boolEnv(env.HYDRA_CB_ENABLED) ??
+            DEFAULT_CONFIG.enableCircuitBreaker,
+    };
+}
+function intEnv(val) {
+    if (val === undefined)
+        return undefined;
+    const n = parseInt(val, 10);
+    return isNaN(n) ? undefined : n;
+}
+function boolEnv(val) {
+    if (val === undefined)
+        return undefined;
+    return val === "true" || val === "1";
+}