@mayank3238/keymux 1.0.0

package/dist/proxy/index.js

@@ -0,0 +1,2122 @@
+import fs from 'fs';
+import path from 'path';
+import http from 'http';
+import os2 from 'os';
+
+// keymux v1.0.0 — Smart API Key Multiplexer for LLM Providers
+
+
+// src/types/index.ts
+var KeyRouterError = class extends Error {
+  constructor(message, code, keyId) {
+    super(message);
+    this.code = code;
+    this.keyId = keyId;
+    this.name = "KeyRouterError";
+  }
+  code;
+  keyId;
+};
+var RateLimitError = class extends KeyRouterError {
+  constructor(keyId) {
+    super(`Rate limit exceeded for key ${keyId}`, "ALL_KEYS_EXHAUSTED", keyId);
+    this.name = "RateLimitError";
+  }
+};
+var PROVIDER_PRESETS = {
+  mistral: {
+    name: "Mistral AI",
+    baseURL: "https://api.mistral.ai/v1",
+    defaultRpmLimit: 30,
+    models: [
+      "codestral-2508",
+      "mistral-large-latest",
+      "open-mistral-nemo"
+    ]
+  },
+  nvidia: {
+    name: "NVIDIA",
+    baseURL: "https://integrate.api.nvidia.com/v1",
+    defaultRpmLimit: 40,
+    models: [
+      "nvidia/nemotron-3-ultra-550b-a55b",
+      "nvidia/nemotron-3-super-120b-a12b",
+      "stepfun-ai/step-3.7-flash"
+    ]
+  },
+  gemini: {
+    name: "Google Gemini",
+    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
+    defaultRpmLimit: 15,
+    models: [
+      "gemini-3.1-pro-preview",
+      "gemini-2.5-pro",
+      "gemini-2.5-flash",
+      "gemini-2.5-flash-thinking",
+      "gemini-3.5-flash"
+    ]
+  },
+  openrouter: {
+    name: "OpenRouter",
+    baseURL: "https://openrouter.ai/api/v1",
+    defaultRpmLimit: 20,
+    models: [
+      "nex-agi/nex-n2.5-mini:free",
+      "meta-llama/llama-3.3-70b-instruct:free",
+      "qwen/qwen3-235b-a22b:free"
+    ]
+  },
+  deepseek: {
+    name: "DeepSeek",
+    baseURL: "https://api.deepseek.com/v1",
+    defaultRpmLimit: 60,
+    models: ["deepseek-chat", "deepseek-reasoner"]
+  },
+  together: {
+    name: "Together AI",
+    baseURL: "https://api.together.xyz/v1",
+    defaultRpmLimit: 60,
+    models: [
+      "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+      "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo"
+    ]
+  },
+  sambanova: {
+    name: "SambaNova",
+    baseURL: "https://api.sambanova.ai/v1",
+    defaultRpmLimit: 30,
+    models: ["Meta-Llama-3.1-405B-Instruct", "Meta-Llama-3.1-70B-Instruct"]
+  },
+  openai: {
+    name: "OpenAI",
+    baseURL: "https://api.openai.com/v1",
+    defaultRpmLimit: 500,
+    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo"]
+  },
+  groq: {
+    name: "Groq",
+    baseURL: "https://api.groq.com/openai/v1",
+    defaultRpmLimit: 30,
+    models: ["qwen/qwen3.8-27b", "openai/gpt-oss-120b", "groq/compound"]
+  }
+};
+
+// src/tracking/keyTracker.ts
+var KeyTracker = class {
+  keys = /* @__PURE__ */ new Map();
+  options;
+  cleanupInterval;
+  constructor(options) {
+    this.options = options;
+    this.startCleanupLoop();
+  }
+  initialize(keyConfigs) {
+    const oldKeys = new Map(this.keys);
+    this.keys.clear();
+    for (const config2 of keyConfigs) {
+      const existing = oldKeys.get(config2.id);
+      if (existing) {
+        existing.config = {
+          ...config2,
+          rpmLimit: config2.rpmLimit ?? this.options.defaultRpmLimit,
+          weight: config2.weight ?? this.options.defaultWeight
+        };
+        this.keys.set(config2.id, existing);
+      } else {
+        const state = {
+          config: {
+            ...config2,
+            rpmLimit: config2.rpmLimit ?? this.options.defaultRpmLimit,
+            weight: config2.weight ?? this.options.defaultWeight
+          },
+          rpm: 0,
+          lastUsed: 0,
+          circuitState: "healthy" /* HEALTHY */,
+          failures: 0,
+          cooldownUntil: 0,
+          avgLatencyMs: 0,
+          latencyHistory: [],
+          totalRequests: 0,
+          totalErrors: 0,
+          requestTimestamps: []
+        };
+        this.keys.set(config2.id, state);
+      }
+    }
+  }
+  /**
+   * Get all key states - for debugging or stats
+   */
+  getAllStates() {
+    return Array.from(this.keys.values());
+  }
+  /**
+   * Get state of a specific key
+   */
+  getState(keyId) {
+    return this.keys.get(keyId);
+  }
+  /**
+   * Get only healthy and available keys
+   * Checks circuit breaker state and RPM limits
+   */
+  getAvailableKeys() {
+    const now = Date.now();
+    return Array.from(this.keys.values()).filter((state) => {
+      if (state.circuitState === "open" /* OPEN */) {
+        if (now >= state.cooldownUntil) {
+          this.transitionToHealthy(state);
+          return state.rpm < state.config.rpmLimit;
+        }
+        return false;
+      }
+      return state.rpm < state.config.rpmLimit;
+    });
+  }
+  /**
+   * Record a request attempt (reservation)
+   * Increments RPM count without touching failures or circuit state.
+   */
+  recordAttempt(keyId) {
+    const state = this.keys.get(keyId);
+    if (!state) return;
+    state.requestTimestamps.push(Date.now());
+    state.rpm = state.requestTimestamps.length;
+    state.lastUsed = Date.now();
+    state.totalRequests++;
+  }
+  /**
+   * Record a successful request completion
+   * Updates latency and resets failures (RPM already incremented by recordAttempt).
+   */
+  recordSuccess(keyId, latencyMs) {
+    const state = this.keys.get(keyId);
+    if (!state) return;
+    state.lastUsed = Date.now();
+    state.failures = 0;
+    if (this.options.trackLatency && latencyMs != null) {
+      state.latencyHistory.push(latencyMs);
+      if (state.latencyHistory.length > 25) {
+        state.latencyHistory.shift();
+      }
+      state.avgLatencyMs = Math.round(
+        state.latencyHistory.reduce((sum, v) => sum + v, 0) / state.latencyHistory.length
+      );
+    }
+    if (state.circuitState === "degraded" /* DEGRADED */ || state.circuitState === "open" /* OPEN */) {
+      this.transitionToHealthy(state);
+    }
+    this.emitDebug({
+      type: "key_selected",
+      keyId,
+      timestamp: Date.now(),
+      details: { rpm: state.rpm, latencyMs }
+    });
+  }
+  /**
+   * Record a failed request (rate limit, server error, etc.)
+   * Triggers circuit breaker logic (RPM already incremented by recordAttempt).
+   */
+  recordFailure(keyId, isRateLimit = false) {
+    const state = this.keys.get(keyId);
+    if (!state) return;
+    state.failures++;
+    state.totalErrors++;
+    state.lastUsed = Date.now();
+    this.emitDebug({
+      type: "key_failed",
+      keyId,
+      timestamp: Date.now(),
+      details: { failures: state.failures, isRateLimit }
+    });
+    if (state.failures >= this.options.failureThreshold) {
+      this.openCircuit(state);
+    } else if (state.failures >= Math.ceil(this.options.failureThreshold / 2)) {
+      if (state.circuitState === "healthy" /* HEALTHY */) {
+        state.circuitState = "degraded" /* DEGRADED */;
+        if (this.options.onStateChange) {
+          this.options.onStateChange(keyId, "degraded" /* DEGRADED */);
+        }
+        this.emitDebug({
+          type: "key_failed",
+          keyId,
+          timestamp: Date.now(),
+          details: { circuitState: "degraded" /* DEGRADED */ }
+        });
+      }
+    }
+  }
+  /**
+   * Manually report a key as recovered (for external health checks)
+   */
+  reportRecovery(keyId) {
+    const state = this.keys.get(keyId);
+    if (!state) return;
+    this.transitionToHealthy(state);
+    this.emitDebug({
+      type: "key_recovered",
+      keyId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Get statistics for all keys
+   */
+  getStats() {
+    return Array.from(this.keys.values()).map((state) => this.toStats(state));
+  }
+  /**
+   * Get overall router statistics
+   */
+  getOverallStats() {
+    const stats = this.getStats();
+    const totalRpm = stats.reduce((sum, s) => sum + s.rpm, 0);
+    const totalRpmLimit = stats.reduce((sum, s) => sum + s.rpmLimit, 0);
+    return {
+      totalKeys: stats.length,
+      healthyKeys: stats.filter((s) => s.isHealthy).length,
+      totalRpm,
+      totalRpmLimit,
+      overallUtilization: totalRpmLimit > 0 ? totalRpm / totalRpmLimit : 0,
+      keys: stats
+    };
+  }
+  /**
+   * Reset all tracking (useful for testing)
+   */
+  reset() {
+    for (const state of this.keys.values()) {
+      state.rpm = 0;
+      state.lastUsed = 0;
+      state.circuitState = "healthy" /* HEALTHY */;
+      state.failures = 0;
+      state.cooldownUntil = 0;
+      state.totalRequests = 0;
+      state.totalErrors = 0;
+      state.avgLatencyMs = 0;
+      state.latencyHistory = [];
+      state.requestTimestamps = [];
+    }
+  }
+  /**
+   * Shutdown cleanup
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = void 0;
+    }
+  }
+  // ==================== Private Methods ====================
+  transitionToHealthy(state) {
+    const wasUnhealthy = state.circuitState !== "healthy" /* HEALTHY */;
+    state.circuitState = "healthy" /* HEALTHY */;
+    state.failures = 0;
+    state.cooldownUntil = 0;
+    if (wasUnhealthy) {
+      if (this.options.onStateChange) {
+        this.options.onStateChange(state.config.id, "healthy" /* HEALTHY */);
+      }
+      this.emitDebug({
+        type: "key_recovered",
+        keyId: state.config.id,
+        timestamp: Date.now()
+      });
+    }
+  }
+  openCircuit(state) {
+    if (state.circuitState === "open" /* OPEN */) return;
+    state.circuitState = "open" /* OPEN */;
+    state.cooldownUntil = Date.now() + this.options.cooldownMs;
+    if (this.options.onStateChange) {
+      this.options.onStateChange(state.config.id, "open" /* OPEN */);
+    }
+    this.emitDebug({
+      type: "circuit_opened",
+      keyId: state.config.id,
+      timestamp: Date.now(),
+      details: { cooldownUntil: state.cooldownUntil, failures: state.failures }
+    });
+  }
+  toStats(state) {
+    const rpmLimit = state.config.rpmLimit ?? this.options.defaultRpmLimit;
+    const now = Date.now();
+    const cooldownRemainingMs = state.cooldownUntil > now ? state.cooldownUntil - now : 0;
+    return {
+      id: state.config.id,
+      key: this.maskKey(state.config.key),
+      rpm: state.rpm,
+      rpmLimit,
+      utilization: rpmLimit > 0 ? state.rpm / rpmLimit : 0,
+      circuitState: state.circuitState,
+      failures: state.failures,
+      avgLatencyMs: state.avgLatencyMs,
+      totalRequests: state.totalRequests,
+      totalErrors: state.totalErrors,
+      isHealthy: (state.circuitState !== "open" /* OPEN */ || cooldownRemainingMs === 0) && state.rpm < rpmLimit,
+      cooldownRemainingMs
+    };
+  }
+  maskKey(key) {
+    if (key.length <= 8) return "****";
+    return key.slice(0, 4) + "****" + key.slice(-4);
+  }
+  emitDebug(event) {
+    if (this.options.onDebug) {
+      this.options.onDebug(event);
+    }
+  }
+  startCleanupLoop() {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredWindows();
+      this.checkCircuitRecovery();
+    }, Math.min(this.options.windowMs / 10, 1e4));
+  }
+  cleanupExpiredWindows() {
+    const now = Date.now();
+    const windowStart = now - this.options.windowMs;
+    for (const state of this.keys.values()) {
+      state.requestTimestamps = state.requestTimestamps.filter((ts) => ts >= windowStart);
+      state.rpm = state.requestTimestamps.length;
+    }
+  }
+  checkCircuitRecovery() {
+    const now = Date.now();
+    for (const state of this.keys.values()) {
+      if (state.circuitState === "open" /* OPEN */ && now >= state.cooldownUntil) {
+        this.transitionToHealthy(state);
+      }
+    }
+  }
+};
+
+// src/strategies/selectionStrategies.ts
+var WeightedLeastUtilizationStrategy = class {
+  name = "weighted-least-utilization";
+  select(keys, options) {
+    if (keys.length === 0) return null;
+    let candidates = keys;
+    if (options?.maxUtilization != null) {
+      candidates = keys.filter((k) => {
+        const limit = k.config.rpmLimit ?? 40;
+        return k.rpm / limit <= options.maxUtilization;
+      });
+      if (candidates.length === 0) return null;
+    }
+    candidates.sort((a, b) => {
+      const limitA = a.config.rpmLimit ?? 40;
+      const limitB = b.config.rpmLimit ?? 40;
+      const weightA = a.config.weight ?? 1;
+      const weightB = b.config.weight ?? 1;
+      const utilA = a.rpm / limitA / weightA;
+      const utilB = b.rpm / limitB / weightB;
+      return utilA - utilB;
+    });
+    return candidates[0] ?? null;
+  }
+};
+var LeastRequestsStrategy = class {
+  name = "least-requests";
+  select(keys, options) {
+    if (keys.length === 0) return null;
+    let candidates = keys;
+    if (options?.maxUtilization != null) {
+      candidates = keys.filter((k) => {
+        const limit = k.config.rpmLimit ?? 40;
+        return k.rpm / limit <= options.maxUtilization;
+      });
+      if (candidates.length === 0) return null;
+    }
+    candidates.sort((a, b) => a.rpm - b.rpm);
+    return candidates[0] ?? null;
+  }
+};
+var SmartRoutingStrategy = class {
+  name = "smart";
+  select(keys, options) {
+    if (!keys || keys.length === 0) return null;
+    let candidates = keys;
+    if (options?.maxUtilization != null) {
+      candidates = keys.filter((k) => {
+        const limit = k.config.rpmLimit ?? 40;
+        return k.rpm / limit <= options.maxUtilization;
+      });
+      if (candidates.length === 0) return null;
+    }
+    const untestedKeys = candidates.filter((k) => (k.latencyHistory?.length ?? 0) === 0);
+    if (untestedKeys.length > 0) {
+      untestedKeys.sort((a, b) => (a.totalRequests ?? 0) - (b.totalRequests ?? 0));
+      return untestedKeys[0] ?? null;
+    }
+    const keysWithLatency = candidates.filter(
+      (k) => typeof k.avgLatencyMs === "number" && !isNaN(k.avgLatencyMs) && k.avgLatencyMs > 0
+    );
+    let pool = candidates;
+    if (keysWithLatency.length > 0) {
+      const fastest = Math.min(...keysWithLatency.map((k) => k.avgLatencyMs));
+      pool = keysWithLatency.filter((k) => k.avgLatencyMs <= fastest + 100);
+    }
+    if (pool.length === 0) {
+      pool = candidates;
+    }
+    pool.sort((a, b) => {
+      if (a.avgLatencyMs !== b.avgLatencyMs) return a.avgLatencyMs - b.avgLatencyMs;
+      const limitA = a.config.rpmLimit ?? 40;
+      const limitB = b.config.rpmLimit ?? 40;
+      return a.rpm / limitA - b.rpm / limitB;
+    });
+    return pool[0] ?? null;
+  }
+};
+var LeastLatencyStrategy = class {
+  name = "least-latency";
+  select(keys, options) {
+    if (keys.length === 0) return null;
+    let candidates = keys;
+    if (options?.maxUtilization != null) {
+      candidates = keys.filter((k) => {
+        const limit = k.config.rpmLimit ?? 40;
+        return k.rpm / limit <= options.maxUtilization;
+      });
+      if (candidates.length === 0) return null;
+    }
+    candidates = candidates.filter((k) => k.avgLatencyMs > 0);
+    if (candidates.length === 0) {
+      return new LeastRequestsStrategy().select(keys, options);
+    }
+    candidates.sort((a, b) => a.avgLatencyMs - b.avgLatencyMs);
+    return candidates[0] ?? null;
+  }
+};
+var PreferredKeysStrategy = class {
+  constructor(fallbackStrategy) {
+    this.fallbackStrategy = fallbackStrategy;
+  }
+  fallbackStrategy;
+  name = "preferred-keys";
+  select(keys, options) {
+    if (!options?.preferredKeys?.length) {
+      return this.fallbackStrategy.select(keys, options);
+    }
+    const preferredKeysSet = new Set(options.preferredKeys);
+    const preferredCandidates = keys.filter((k) => preferredKeysSet.has(k.config.id));
+    if (preferredCandidates.length > 0) {
+      const selected = this.fallbackStrategy.select(preferredCandidates, options);
+      if (selected) return selected;
+    }
+    return this.fallbackStrategy.select(keys, options);
+  }
+};
+var RandomStrategy = class {
+  name = "random";
+  select(keys, options) {
+    if (keys.length === 0) return null;
+    let candidates = keys;
+    if (options?.maxUtilization != null) {
+      candidates = keys.filter((k) => {
+        const limit = k.config.rpmLimit ?? 40;
+        return k.rpm / limit <= options.maxUtilization;
+      });
+      if (candidates.length === 0) return null;
+    }
+    const index = Math.floor(Math.random() * candidates.length);
+    return candidates[index] ?? null;
+  }
+};
+var RoundRobinStrategy = class {
+  name = "round-robin";
+  index = 0;
+  select(keys, options) {
+    if (keys.length === 0) return null;
+    let candidates = keys;
+    if (options?.maxUtilization != null) {
+      candidates = keys.filter((k) => {
+        const limit = k.config.rpmLimit ?? 40;
+        return limit > 0 ? k.rpm / limit <= options.maxUtilization : true;
+      });
+      if (candidates.length === 0) return null;
+    }
+    const selected = candidates[this.index % candidates.length];
+    this.index++;
+    return selected || null;
+  }
+};
+function createStrategy(name, fallback) {
+  switch (name) {
+    case "weighted-least-utilization":
+      return new WeightedLeastUtilizationStrategy();
+    case "least-requests":
+      return new LeastRequestsStrategy();
+    case "round-robin":
+      return new RoundRobinStrategy();
+    case "smart":
+      return new SmartRoutingStrategy();
+    case "least-latency":
+      return new LeastLatencyStrategy();
+    case "random":
+      return new RandomStrategy();
+    case "preferred-keys":
+      return new PreferredKeysStrategy(fallback ?? new WeightedLeastUtilizationStrategy());
+    default:
+      return new WeightedLeastUtilizationStrategy();
+  }
+}
+
+// src/core/multiProviderRouter.ts
+var MultiProviderRouter = class {
+  tracker;
+  strategy;
+  endpointMap = /* @__PURE__ */ new Map();
+  providerGroups = /* @__PURE__ */ new Map();
+  lastRoute = null;
+  keyConfigs = [];
+  providers;
+  config;
+  constructor(providers, config2) {
+    if (!providers.length) {
+      throw new KeyRouterError(
+        "At least one provider must be configured.",
+        "NO_KEYS_CONFIGURED"
+      );
+    }
+    this.providers = providers.map((p) => ({
+      ...p,
+      keys: [...p.keys],
+      models: p.models ? [...p.models] : void 0
+    }));
+    this.config = {
+      failureThreshold: config2?.failureThreshold ?? 3,
+      cooldownMs: config2?.cooldownMs ?? 3e4,
+      windowMs: config2?.windowMs ?? 6e4,
+      trackLatency: config2?.trackLatency ?? true,
+      strategy: config2?.strategy ?? "weighted-least-utilization",
+      onStateChange: config2?.onStateChange ?? (() => {
+      }),
+      onDebug: config2?.onDebug ?? (() => {
+      })
+    };
+    if (this.config.failureThreshold <= 0) throw new KeyRouterError("Invalid config: failureThreshold must be > 0", "INVALID_CONFIG");
+    if (this.config.cooldownMs <= 0) throw new KeyRouterError("Invalid config: cooldownMs must be > 0", "INVALID_CONFIG");
+    if (this.config.windowMs <= 0) throw new KeyRouterError("Invalid config: windowMs must be > 0", "INVALID_CONFIG");
+    for (const provider of this.providers) {
+      if (provider.rpmLimit !== void 0 && provider.rpmLimit <= 0) {
+        throw new KeyRouterError("Invalid config: rpmLimit must be > 0", "INVALID_CONFIG");
+      }
+      if (provider.weight !== void 0 && provider.weight <= 0) {
+        throw new KeyRouterError("Invalid config: weight must be > 0", "INVALID_CONFIG");
+      }
+    }
+    this.tracker = new KeyTracker({
+      defaultRpmLimit: 40,
+      defaultWeight: 1,
+      failureThreshold: this.config.failureThreshold,
+      cooldownMs: this.config.cooldownMs,
+      windowMs: this.config.windowMs,
+      trackLatency: this.config.trackLatency,
+      onStateChange: this.config.onStateChange,
+      onDebug: this.config.onDebug
+    });
+    this.strategy = createStrategy(this.config.strategy);
+    this.buildPool(providers);
+  }
+  // ==================== Core Methods ====================
+  /**
+   * Get the next best endpoint for making an API call
+   * Returns key + baseURL + model + provider — everything needed for a request
+   *
+   * Supports filtering:
+   * - preferProviders: try these first
+   * - excludeProviders: skip these entirely
+   * - model: pick a provider that has this model
+   * - maxUtilization: skip overloaded endpoints
+   */
+  async getEndpoint(options) {
+    let availableKeys = this.tracker.getAvailableKeys();
+    if (options?.excludeProviders?.length) {
+      availableKeys = availableKeys.filter((k) => {
+        const meta2 = this.endpointMap.get(k.config.id);
+        return meta2 ? !options.excludeProviders.includes(meta2.provider) : true;
+      });
+    }
+    if (options?.model) {
+      availableKeys = availableKeys.filter((k) => {
+        const meta2 = this.endpointMap.get(k.config.id);
+        return meta2 ? meta2.model === options.model : false;
+      });
+    }
+    if (options?.maxUtilization != null) {
+      availableKeys = availableKeys.filter((k) => {
+        const limit2 = k.config.rpmLimit ?? 40;
+        return k.rpm / limit2 <= options.maxUtilization;
+      });
+    }
+    if (availableKeys.length === 0) {
+      this.config.onDebug({
+        type: "all_exhausted",
+        timestamp: Date.now(),
+        details: { totalEndpoints: this.endpointMap.size }
+      });
+      throw new RateLimitError("all");
+    }
+    const preferredKeys = options?.preferProviders?.length ? options.preferProviders.flatMap(
+      (p) => this.providerGroups.get(p) ?? []
+    ) : void 0;
+    let activeStrategy = options?.strategy ? createStrategy(options.strategy, this.strategy) : this.strategy;
+    if (preferredKeys?.length) {
+      activeStrategy = new PreferredKeysStrategy(activeStrategy);
+    }
+    const selected = activeStrategy.select(availableKeys, { preferredKeys });
+    if (!selected) {
+      throw new RateLimitError("all");
+    }
+    this.tracker.recordAttempt(selected.config.id);
+    const m = this.endpointMap.get(selected.config.id);
+    if (m) {
+      this.lastRoute = {
+        provider: m.provider,
+        model: m.model,
+        key: selected.config.key,
+        time: Date.now()
+      };
+    }
+    const meta = this.endpointMap.get(selected.config.id);
+    if (!meta) {
+      throw new KeyRouterError(
+        `Endpoint metadata not found for ${selected.config.id}`,
+        "KEY_NOT_FOUND",
+        selected.config.id
+      );
+    }
+    const limit = selected.config.rpmLimit ?? 40;
+    return {
+      key: selected.config.key,
+      baseURL: meta.baseURL,
+      model: meta.model,
+      provider: meta.provider,
+      endpointId: selected.config.id,
+      utilization: limit > 0 ? selected.rpm / limit : 0
+    };
+  }
+  /**
+   * Report a successful request for an endpoint
+   * Resets failure count, updates latency (EMA), recovers degraded state
+   */
+  reportSuccess(endpointId, latencyMs) {
+    this.tracker.recordSuccess(endpointId, latencyMs);
+  }
+  /**
+   * Report a failed request for an endpoint
+   * Increments failure count, may open circuit breaker
+   * Next getEndpoint() call will automatically route to a different provider
+   */
+  reportFailure(endpointId, isRateLimit = false) {
+    this.tracker.recordFailure(endpointId, isRateLimit);
+  }
+  /**
+   * Manually recover an endpoint (e.g. after external health check)
+   */
+  reportRecovery(endpointId) {
+    this.tracker.reportRecovery(endpointId);
+  }
+  // ==================== Stats & Monitoring ====================
+  /**
+   * Get overall stats across all providers (same familiar format as KeyRouter)
+   */
+  getOverallStats() {
+    return this.tracker.getOverallStats();
+  }
+  /**
+   * Get stats for all endpoints
+   */
+  getStats() {
+    return this.tracker.getStats();
+  }
+  /**
+   * Get stats for a specific provider
+   */
+  getProviderStats(provider) {
+    const keyIds = this.providerGroups.get(provider) ?? [];
+    const allStats = this.tracker.getStats();
+    const providerKeyStats = allStats.filter((s) => keyIds.includes(s.id));
+    const totalRpm = providerKeyStats.reduce((sum, s) => sum + s.rpm, 0);
+    const totalRpmLimit = providerKeyStats.reduce(
+      (sum, s) => sum + s.rpmLimit,
+      0
+    );
+    return {
+      provider,
+      totalKeys: providerKeyStats.length,
+      healthyKeys: providerKeyStats.filter((s) => s.isHealthy).length,
+      totalRpm,
+      totalRpmLimit,
+      utilization: totalRpmLimit > 0 ? totalRpm / totalRpmLimit : 0,
+      keys: providerKeyStats
+    };
+  }
+  /**
+   * Get list of all configured provider names
+   */
+  getProviderNames() {
+    return Array.from(this.providerGroups.keys());
+  }
+  /**
+   * Get all available (healthy + under limit) endpoint IDs
+   */
+  getLastRoute() {
+    return this.lastRoute;
+  }
+  getAvailableEndpointIds() {
+    return this.tracker.getAvailableKeys().map((s) => s.config.id);
+  }
+  /**
+   * Check if a specific endpoint is healthy
+   */
+  isEndpointHealthy(endpointId) {
+    const state = this.tracker.getState(endpointId);
+    if (!state) return false;
+    const limit = state.config.rpmLimit ?? 40;
+    if (state.circuitState === "open" /* OPEN */) {
+      if (Date.now() >= state.cooldownUntil) {
+        return state.rpm < limit;
+      }
+      return false;
+    }
+    return state.rpm < limit;
+  }
+  /**
+   * Check if a provider has any healthy endpoints
+   */
+  isProviderHealthy(provider) {
+    const keyIds = this.providerGroups.get(provider) ?? [];
+    return keyIds.some((id) => this.isEndpointHealthy(id));
+  }
+  // ==================== Dynamic Management ====================
+  /**
+   * Add a new provider at runtime
+   */
+  addProvider(entry) {
+    if (!entry.keys.length) {
+      throw new KeyRouterError(
+        `Provider '${entry.provider}' must have at least one key.`,
+        "NO_KEYS_CONFIGURED"
+      );
+    }
+    const clonedEntry = JSON.parse(JSON.stringify(entry));
+    this.providers.push(clonedEntry);
+    this.rebuildPool();
+  }
+  /**
+   * Add a key to an existing provider at runtime
+   */
+  addKeyToProvider(provider, key) {
+    const entry = this.providers.find((p) => p.provider === provider);
+    if (!entry) {
+      throw new KeyRouterError(
+        `Provider '${provider}' not found. Use addProvider() to add a new provider.`,
+        "KEY_NOT_FOUND"
+      );
+    }
+    const clonedKey = JSON.parse(JSON.stringify(key));
+    entry.keys.push(clonedKey);
+    this.rebuildPool();
+  }
+  /**
+   * Remove a provider entirely at runtime
+   */
+  removeProvider(provider) {
+    const index = this.providers.findIndex((p) => p.provider === provider);
+    if (index === -1) return false;
+    this.providers.splice(index, 1);
+    this.rebuildPool();
+    return true;
+  }
+  /**
+   * Remove a specific key from a provider at runtime
+   */
+  removeKey(provider, key) {
+    const entry = this.providers.find((p) => p.provider === provider);
+    if (!entry) return false;
+    const keyIndex = entry.keys.indexOf(key);
+    if (keyIndex === -1) return false;
+    entry.keys.splice(keyIndex, 1);
+    if (entry.keys.length === 0) {
+      return this.removeProvider(provider);
+    }
+    this.rebuildPool();
+    return true;
+  }
+  // ==================== Strategy ====================
+  /**
+   * Set the selection strategy
+   */
+  setStrategy(strategy) {
+    if (typeof strategy === "string") {
+      this.strategy = createStrategy(strategy, this.strategy);
+    } else {
+      this.strategy = strategy;
+    }
+  }
+  // ==================== Lifecycle ====================
+  /**
+   * Reset all tracking data (useful for testing)
+   */
+  reset() {
+    this.tracker.reset();
+  }
+  /**
+   * Shutdown and cleanup (stops background cleanup timer)
+   */
+  destroy() {
+    this.tracker.destroy();
+  }
+  // ==================== Private Helpers ====================
+  /**
+   * Flatten all providers into a single key pool
+   * Each key gets a unique ID: `${provider}-${keyIndex}`
+   * Provider metadata (baseURL, model) is stored in endpointMap
+   */
+  buildPool(providers) {
+    this.keyConfigs = [];
+    this.endpointMap.clear();
+    this.providerGroups.clear();
+    for (const entry of providers) {
+      const preset = PROVIDER_PRESETS[entry.provider];
+      const baseURL = entry.baseURL ?? preset?.baseURL ?? "";
+      const rpmLimit = entry.rpmLimit ?? preset?.defaultRpmLimit ?? 40;
+      const models = entry.models ?? preset?.models ?? [];
+      const defaultModel = models[0] ?? "";
+      const weight = entry.weight ?? 1;
+      if (!baseURL) {
+        throw new KeyRouterError(
+          `Provider '${entry.provider}' has no baseURL. Provide one or use a known provider preset.`,
+          "NO_KEYS_CONFIGURED"
+        );
+      }
+      const groupIds = [];
+      for (let i = 0; i < entry.keys.length; i++) {
+        const key = entry.keys[i];
+        const id = `${entry.provider}-${i}`;
+        this.keyConfigs.push({
+          id,
+          key,
+          rpmLimit,
+          weight,
+          baseURL,
+          metadata: {
+            provider: entry.provider,
+            model: defaultModel,
+            ...entry.metadata
+          }
+        });
+        this.endpointMap.set(id, {
+          baseURL,
+          model: defaultModel,
+          provider: entry.provider
+        });
+        groupIds.push(id);
+      }
+      this.providerGroups.set(entry.provider, groupIds);
+    }
+    this.tracker.initialize(this.keyConfigs);
+  }
+  /**
+   * Rebuild the pool from current providers (used after dynamic changes)
+   */
+  rebuildPool() {
+    this.buildPool(this.providers);
+  }
+};
+
+// src/core/fetcher.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function fetchWithFailover(urlBuilder, fetchOptionsBuilder, config2) {
+  const router2 = config2.router;
+  const maxRetries = config2.maxRetries;
+  let attempts = 0;
+  let lastResponse = null;
+  let lastError = null;
+  const dynamicExcludeProviders = [...config2.excludeProviders || []];
+  while (attempts < maxRetries) {
+    attempts++;
+    let ep;
+    try {
+      ep = await router2.getEndpoint({
+        preferProviders: config2.preferProviders,
+        excludeProviders: dynamicExcludeProviders,
+        model: config2.model
+      });
+    } catch (error) {
+      if (attempts >= maxRetries) continue;
+      if (lastResponse) {
+        return lastResponse;
+      }
+      throw error;
+    }
+    const url = urlBuilder(ep);
+    const options = fetchOptionsBuilder(ep);
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e5);
+      const response = await fetch(url, { ...options, signal: controller.signal });
+      clearTimeout(timeoutId);
+      lastResponse = response;
+      if (!response.ok) {
+        let errorText = "";
+        try {
+          const clone = response.clone();
+          if (clone.body) {
+            const reader = clone.body.getReader();
+            const { value } = await reader.read();
+            if (value) {
+              errorText = new TextDecoder().decode(value).slice(0, 2048);
+            }
+            reader.cancel().catch(() => {
+            });
+          } else {
+            errorText = (await clone.text()).slice(0, 2048);
+          }
+        } catch (e) {
+        }
+        const lower = errorText.toLowerCase();
+        const isContextError = lower.includes("context length exceeded") || lower.includes("maximum context length");
+        const isModelError = lower.includes("decommissioned") || lower.includes("not a valid model") || lower.includes("model not found") || lower.includes("does not exist") || lower.includes("not supported");
+        const isAuthError = response.status === 401 || response.status === 403;
+        const isRateLimit = response.status === 429;
+        router2.reportFailure(ep.endpointId, isRateLimit);
+        if (isContextError || isModelError || isAuthError || response.status === 402 || response.status === 404) {
+          if (!dynamicExcludeProviders.includes(ep.provider)) {
+            dynamicExcludeProviders.push(ep.provider);
+          }
+        }
+        if (isRateLimit || response.status >= 500) {
+          await sleep(Math.min(1e3 * Math.pow(2, attempts - 1), 1e4));
+        }
+        continue;
+      }
+      return response;
+    } catch (error) {
+      lastError = error;
+      router2.reportFailure(ep.endpointId, false);
+    }
+  }
+  if (lastResponse) {
+    return lastResponse;
+  }
+  if (lastError && lastError.name === "AbortError") {
+    throw new Error("timeout");
+  }
+  throw new Error(`fetchWithFailover exhausted all retries. Last error: ${lastError?.message}`);
+}
+var UsageTracker = class {
+  data;
+  filePath;
+  saveTimeout = null;
+  sessionProviderUsage = {};
+  initialized = false;
+  constructor() {
+    const dir = path.join(os2.homedir(), ".keymux");
+    this.filePath = path.join(dir, "usage.json");
+    this.data = {
+      totalRequests: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheTokens: 0,
+      providerUsage: {},
+      daily: {},
+      sessions: 0,
+      firstUsed: Date.now()
+    };
+  }
+  ensureInitialized() {
+    if (this.initialized) return;
+    this.initialized = true;
+    const dir = path.dirname(this.filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.data = this.loadData();
+    this.data.sessions += 1;
+    this.saveData();
+  }
+  loadData() {
+    const defaultData = {
+      totalRequests: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheTokens: 0,
+      providerUsage: {},
+      daily: {},
+      sessions: 0,
+      firstUsed: Date.now()
+    };
+    if (fs.existsSync(this.filePath)) {
+      try {
+        const content = fs.readFileSync(this.filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (parsed && typeof parsed === "object") {
+          const providerUsage = {};
+          if (parsed.providerUsage) {
+            for (const [k, v] of Object.entries(parsed.providerUsage)) {
+              if (typeof v === "number") {
+                providerUsage[k] = { requests: v, tokens: 0 };
+              } else {
+                providerUsage[k] = v;
+              }
+            }
+          }
+          return { ...defaultData, ...parsed, providerUsage, daily: parsed.daily || {} };
+        }
+      } catch (e) {
+      }
+    }
+    return defaultData;
+  }
+  saveData() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        try {
+          const diskContent = fs.readFileSync(this.filePath, "utf-8");
+          const diskData = JSON.parse(diskContent);
+          if (diskData.totalRequests > this.data.totalRequests) {
+            this.data.totalRequests = diskData.totalRequests;
+          }
+        } catch (e) {
+        }
+      }
+      const tempPath = this.filePath + ".tmp";
+      fs.writeFileSync(tempPath, JSON.stringify(this.data, null, 2));
+      fs.renameSync(tempPath, this.filePath);
+    } catch (e) {
+    }
+  }
+  scheduleSave() {
+    if (!this.saveTimeout) {
+      this.saveTimeout = setTimeout(() => {
+        this.saveData();
+        this.saveTimeout = null;
+      }, 5e3);
+    }
+  }
+  recordRequest(provider, inputTokens, outputTokens, cacheTokens = 0) {
+    this.ensureInitialized();
+    const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    this.data.totalRequests += 1;
+    this.data.totalInputTokens += inputTokens;
+    this.data.totalOutputTokens += outputTokens;
+    this.data.totalCacheTokens += cacheTokens;
+    if (!this.data.providerUsage[provider]) {
+      this.data.providerUsage[provider] = { requests: 0, tokens: 0 };
+    } else if (typeof this.data.providerUsage[provider] === "number") {
+      this.data.providerUsage[provider] = { requests: this.data.providerUsage[provider], tokens: 0 };
+    }
+    const provUsage = this.data.providerUsage[provider];
+    provUsage.requests += 1;
+    provUsage.tokens += inputTokens + outputTokens;
+    if (!this.data.daily[dateStr]) {
+      this.data.daily[dateStr] = {
+        date: dateStr,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheTokens: 0,
+        requests: 0
+      };
+    }
+    this.data.daily[dateStr].inputTokens += inputTokens;
+    this.data.daily[dateStr].outputTokens += outputTokens;
+    this.data.daily[dateStr].cacheTokens += cacheTokens;
+    this.data.daily[dateStr].requests += 1;
+    if (!this.sessionProviderUsage[provider]) {
+      this.sessionProviderUsage[provider] = { requests: 0, tokens: 0 };
+    }
+    this.sessionProviderUsage[provider].requests += 1;
+    this.sessionProviderUsage[provider].tokens += inputTokens + outputTokens;
+    if (!this.data.daily[dateStr].providerUsage) {
+      this.data.daily[dateStr].providerUsage = {};
+    }
+    if (!this.data.daily[dateStr].providerUsage[provider]) {
+      this.data.daily[dateStr].providerUsage[provider] = { requests: 0, tokens: 0 };
+    }
+    this.data.daily[dateStr].providerUsage[provider].requests += 1;
+    this.data.daily[dateStr].providerUsage[provider].tokens += inputTokens + outputTokens;
+    this.scheduleSave();
+  }
+  getSessionUsage() {
+    this.ensureInitialized();
+    return this.sessionProviderUsage;
+  }
+  getTodayUsage() {
+    this.ensureInitialized();
+    const todayDateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    return this.data.daily[todayDateStr]?.providerUsage || {};
+  }
+  getData() {
+    this.ensureInitialized();
+    return this.data;
+  }
+};
+var _globalTracker = null;
+new Proxy({}, {
+  get: (target, prop) => {
+    if (!_globalTracker) _globalTracker = new UsageTracker();
+    return _globalTracker[prop];
+  }
+});
+
+// src/proxy/translators/requestTranslator.ts
+function translateMessages(anthropicMessages, systemPrompt) {
+  const openaiMessages = [];
+  if (systemPrompt) {
+    let sysContent = systemPrompt;
+    if (Array.isArray(systemPrompt)) {
+      sysContent = systemPrompt.map((b) => b.text || "").join("\n");
+    }
+    openaiMessages.push({ role: "system", content: sysContent });
+  }
+  for (const msg of anthropicMessages || []) {
+    const role = msg.role;
+    if (typeof msg.content === "string") {
+      openaiMessages.push({ role, content: msg.content });
+    } else if (Array.isArray(msg.content)) {
+      const contentParts = [];
+      const calls = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          contentParts.push({ type: "text", text: block.text });
+        } else if (block.type === "thinking") {
+          contentParts.push({ type: "text", text: `<thinking>${block.thinking}</thinking>` });
+        } else if (block.type === "image") {
+          contentParts.push({
+            type: "image_url",
+            image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+          });
+        } else if (block.type === "tool_use") {
+          const inputCopy = typeof block.input === "object" && block.input !== null ? { ...block.input } : {};
+          calls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(inputCopy)
+            }
+          });
+        } else if (block.type === "document") {
+          let title = block.title || "document";
+          if (typeof title === "string" && (title.includes("../") || title.includes("..\\") || title.includes("/etc/") || title.startsWith("/"))) {
+            title = "sanitized_document";
+          }
+          if (block.source && block.source.type === "base64" && block.source.data) {
+            let docText = `[Attached File: ${title}]
+`;
+            if (block.source.media_type === "application/pdf") {
+              docText += "[PDF extraction via proxy is limited. Try pasting text if it fails]";
+            } else if (block.source.media_type && !block.source.media_type.startsWith("text/")) {
+              docText += "[Binary content unsupported by translation layer]";
+            } else {
+              try {
+                docText += Buffer.from(block.source.data, "base64").toString("utf8");
+              } catch (e) {
+                docText += "[Binary file cannot be read]";
+              }
+            }
+            contentParts.push({ type: "text", text: docText });
+          } else if (block.source && block.source.type === "text") {
+            contentParts.push({ type: "text", text: `[Attached File: ${title}]
+${block.source.data}` });
+          }
+        } else if (block.type === "tool_result") {
+          let toolText = "";
+          if (typeof block.content === "string") {
+            toolText = block.content;
+          } else if (Array.isArray(block.content)) {
+            toolText = block.content.map((c) => {
+              if (c.type === "text") return c.text;
+              if (c.type === "image") return "[Tool output included an image]";
+              return typeof c === "string" ? c : JSON.stringify(c);
+            }).join("\n");
+          }
+          if (block.is_error) {
+            toolText = `[Error executing tool]
+${toolText}`;
+          }
+          openaiMessages.push({
+            role: "tool",
+            tool_call_id: block.tool_use_id,
+            content: toolText || "Executed successfully"
+          });
+        }
+      }
+      if (contentParts.length > 0 || calls.length > 0) {
+        const messageObj = { role };
+        if (contentParts.length > 0) {
+          messageObj.content = contentParts;
+        }
+        if (calls.length > 0) {
+          messageObj.tool_calls = calls;
+        }
+        openaiMessages.push(messageObj);
+      }
+    }
+  }
+  return openaiMessages;
+}
+function translateTools(anthropicTools) {
+  if (!anthropicTools) return void 0;
+  return anthropicTools.map((t) => {
+    const parameters = JSON.parse(JSON.stringify(t.input_schema || {}));
+    if (parameters && parameters.properties && parameters.properties.thought_signature) {
+      delete parameters.properties.thought_signature;
+      if (Array.isArray(parameters.required)) {
+        parameters.required = parameters.required.filter((r) => r !== "thought_signature");
+      }
+    }
+    return {
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters
+      }
+    };
+  });
+}
+function translateAnthropicToOpenAI(anthropicReq) {
+  if (anthropicReq.model) {
+    if (anthropicReq.model === "claude-3-5-sonnet-minimax-m3") {
+      anthropicReq.model = "minimax/minimax-m3:free";
+    } else if (anthropicReq.model === "claude-3-5-sonnet-minimax-m2.7") {
+      anthropicReq.model = "minimax/minimax-m2.7:free";
+    } else if (anthropicReq.model === "claude-3-5-sonnet-glm-5.2") {
+      anthropicReq.model = "z-ai/glm-5.2:free";
+    } else if (anthropicReq.model === "claude-3-5-sonnet-nemotron-3-super-120b-a12b") {
+      anthropicReq.model = "nvidia/nemotron-3-super-120b-a12b";
+    } else if (anthropicReq.model === "claude-3-5-sonnet-nemotron-3-ultra-550b-a55b") {
+      anthropicReq.model = "nvidia/nemotron-3-ultra-550b-a55b";
+    }
+  }
+  const openaiReq = {
+    messages: translateMessages(anthropicReq.messages, anthropicReq.system),
+    stream: anthropicReq.stream !== void 0 ? anthropicReq.stream : false
+  };
+  if (openaiReq.stream) {
+    openaiReq.stream_options = { include_usage: true };
+  }
+  const tools = translateTools(anthropicReq.tools);
+  if (tools) openaiReq.tools = tools;
+  if (anthropicReq.temperature !== void 0) {
+    openaiReq.temperature = anthropicReq.temperature;
+  }
+  if (anthropicReq.top_k !== void 0) {
+    openaiReq.top_k = anthropicReq.top_k;
+  }
+  if (anthropicReq.top_p !== void 0) {
+    openaiReq.top_p = anthropicReq.top_p;
+  }
+  if (anthropicReq.max_tokens !== void 0) {
+    openaiReq.max_tokens = anthropicReq.max_tokens;
+  }
+  if (anthropicReq.stop_sequences) {
+    openaiReq.stop = anthropicReq.stop_sequences;
+  }
+  if (anthropicReq.tool_choice) {
+    if (anthropicReq.tool_choice.type === "tool") {
+      openaiReq.tool_choice = { type: "function", function: { name: anthropicReq.tool_choice.name } };
+    } else if (anthropicReq.tool_choice.type === "auto") {
+      openaiReq.tool_choice = "auto";
+    }
+  }
+  return openaiReq;
+}
+
+// src/proxy/translators/streamTranslator.ts
+var OpenRouterStreamTranslator = class {
+  res;
+  requestedModel;
+  currentBlockType;
+  currentBlockIndex;
+  toolIndexMap;
+  state;
+  buffer;
+  _thinkTag;
+  hasSentMessageStart;
+  constructor(res, requestedModel) {
+    this.res = res;
+    this.requestedModel = requestedModel;
+    this.currentBlockType = null;
+    this.currentBlockIndex = 0;
+    this.toolIndexMap = {};
+    this.state = "NORMAL";
+    this.buffer = "";
+    this._thinkTag = "<thinking>";
+    this.hasSentMessageStart = false;
+  }
+  writeEvent(type, dataObj) {
+    this.res.write(`event: ${type}
+data: ${JSON.stringify(dataObj)}
+
+`);
+  }
+  startMessage() {
+    if (this.hasSentMessageStart) return;
+    this.writeEvent("message_start", {
+      type: "message_start",
+      message: {
+        id: "msg_" + Math.random().toString(36).slice(2, 11),
+        type: "message",
+        role: "assistant",
+        content: [],
+        model: this.requestedModel,
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 }
+      }
+    });
+    this.hasSentMessageStart = true;
+  }
+  stopCurrentBlock() {
+    if (this.currentBlockType !== null) {
+      this.writeEvent("content_block_stop", {
+        type: "content_block_stop",
+        index: this.currentBlockIndex
+      });
+      this.currentBlockIndex++;
+      this.currentBlockType = null;
+    }
+  }
+  startBlock(type, extra = {}) {
+    this.stopCurrentBlock();
+    const content_block = { type, ...extra };
+    if (type === "thinking") {
+      content_block.thinking = "";
+      content_block.signature = "dummy_sig";
+    } else if (type === "text") {
+      content_block.text = "";
+    }
+    this.writeEvent("content_block_start", {
+      type: "content_block_start",
+      index: this.currentBlockIndex,
+      content_block
+    });
+    this.currentBlockType = type;
+  }
+  handleChunk(chunkObj) {
+    this.startMessage();
+    const choice = chunkObj.choices && chunkObj.choices[0];
+    if (!choice) return;
+    const delta = choice.delta;
+    if (!delta) return;
+    const reasoning = delta.reasoning || delta.reasoning_content;
+    if (reasoning) {
+      if (this.currentBlockType !== "thinking") {
+        this.startBlock("thinking");
+      }
+      this.writeEvent("content_block_delta", {
+        type: "content_block_delta",
+        index: this.currentBlockIndex,
+        delta: {
+          type: "thinking_delta",
+          thinking: reasoning
+        }
+      });
+    }
+    if (typeof delta.content === "string" && delta.content.length > 0) {
+      let pendingText = "";
+      let pendingThinking = "";
+      const flushText = () => {
+        if (pendingText.length > 0) {
+          if (this.currentBlockType !== "text") this.startBlock("text");
+          this.writeEvent("content_block_delta", {
+            type: "content_block_delta",
+            index: this.currentBlockIndex,
+            delta: { type: "text_delta", text: pendingText }
+          });
+          pendingText = "";
+        }
+      };
+      const flushThinking = () => {
+        if (pendingThinking.length > 0) {
+          if (this.currentBlockType !== "thinking") this.startBlock("thinking");
+          this.writeEvent("content_block_delta", {
+            type: "content_block_delta",
+            index: this.currentBlockIndex,
+            delta: { type: "thinking_delta", thinking: pendingThinking }
+          });
+          pendingThinking = "";
+        }
+      };
+      for (const char of delta.content) {
+        if (this.state === "NORMAL") {
+          if (char === "<") {
+            this.state = "POTENTIAL_START";
+            this.buffer = char;
+          } else {
+            pendingText += char;
+          }
+        } else if (this.state === "POTENTIAL_START") {
+          this.buffer += char;
+          const targets = ["<thinking>", "<think>"];
+          const matchedTarget = targets.find((t) => t === this.buffer);
+          const partialMatch = targets.some((t) => t.startsWith(this.buffer));
+          if (matchedTarget) {
+            flushText();
+            this.state = "IN_THINKING";
+            this._thinkTag = matchedTarget;
+            this.buffer = "";
+            this.startBlock("thinking");
+          } else if (!partialMatch || this.buffer.length > 20) {
+            pendingText += this.buffer;
+            this.state = "NORMAL";
+            this.buffer = "";
+          }
+        } else if (this.state === "IN_THINKING") {
+          if (char === "<") {
+            this.state = "POTENTIAL_END";
+            this.buffer = char;
+          } else {
+            pendingThinking += char;
+          }
+        } else if (this.state === "POTENTIAL_END") {
+          this.buffer += char;
+          const closeTag = this._thinkTag === "<think>" ? "</think>" : "</thinking>";
+          if (this.buffer === closeTag) {
+            flushThinking();
+            this.state = "NORMAL";
+            this.buffer = "";
+            this.startBlock("text");
+          } else if (!closeTag.startsWith(this.buffer) || this.buffer.length > 20) {
+            pendingThinking += this.buffer;
+            this.state = "IN_THINKING";
+            this.buffer = "";
+          }
+        }
+      }
+      flushText();
+      flushThinking();
+    }
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        if (tc.id) {
+          let rawName = tc.function.name || "";
+          let safeName = rawName.split("<")[0].replace(/[^a-zA-Z0-9_-]/g, "");
+          this.startBlock("tool_use", { id: tc.id, name: safeName, input: {} });
+          this.toolIndexMap[tc.index] = this.currentBlockIndex;
+        }
+        if (tc.function && tc.function.arguments) {
+          const targetIndex = this.toolIndexMap[tc.index] !== void 0 ? this.toolIndexMap[tc.index] : this.currentBlockIndex;
+          this.writeEvent("content_block_delta", {
+            type: "content_block_delta",
+            index: targetIndex,
+            delta: {
+              type: "input_json_delta",
+              partial_json: tc.function.arguments
+            }
+          });
+        }
+      }
+    }
+  }
+  finish(streamUsage, finishReason) {
+    this.startMessage();
+    if (this.buffer && this.buffer.length > 0) {
+      if (this.state === "POTENTIAL_START") {
+        if (this.currentBlockType !== "text") this.startBlock("text");
+        this.writeEvent("content_block_delta", {
+          type: "content_block_delta",
+          index: this.currentBlockIndex,
+          delta: { type: "text_delta", text: this.buffer }
+        });
+      } else if (this.state === "POTENTIAL_END") {
+        if (this.currentBlockType !== "thinking") this.startBlock("thinking");
+        this.writeEvent("content_block_delta", {
+          type: "content_block_delta",
+          index: this.currentBlockIndex,
+          delta: { type: "thinking_delta", thinking: this.buffer }
+        });
+      }
+      this.buffer = "";
+    }
+    this.stopCurrentBlock();
+    const stop_reason = finishReason === "stop" || finishReason === null ? "end_turn" : finishReason === "tool_calls" || finishReason === "function_call" ? "tool_use" : finishReason === "length" ? "max_tokens" : finishReason === "content_filter" ? "end_turn" : finishReason || "end_turn";
+    const inputTokens = streamUsage?.prompt_tokens || 0;
+    const outputTokens = streamUsage?.completion_tokens || 0;
+    this.writeEvent("message_delta", {
+      type: "message_delta",
+      delta: { stop_reason, stop_sequence: null },
+      usage: { input_tokens: inputTokens, output_tokens: outputTokens }
+    });
+    this.writeEvent("message_stop", { type: "message_stop" });
+  }
+};
+var NvidiaStreamTranslator = class extends OpenRouterStreamTranslator {
+};
+
+// src/proxy/translators/responseTranslator.ts
+function translateOpenAIToAnthropic(openaiRes, requestedModel) {
+  const choice = openaiRes.choices && openaiRes.choices[0];
+  const message = choice && choice.message;
+  let stop_reason = choice?.finish_reason || "end_turn";
+  if (stop_reason === "stop") stop_reason = "end_turn";
+  if (stop_reason === "tool_calls" || stop_reason === "function_call") stop_reason = "tool_use";
+  if (stop_reason === "length") stop_reason = "max_tokens";
+  if (stop_reason === "content_filter") stop_reason = "end_turn";
+  const anthropicRes = {
+    id: "msg_" + Math.random().toString(36).slice(2, 11),
+    type: "message",
+    role: "assistant",
+    content: [],
+    model: requestedModel,
+    stop_reason,
+    stop_sequence: null,
+    usage: {
+      input_tokens: openaiRes.usage?.prompt_tokens || 0,
+      output_tokens: openaiRes.usage?.completion_tokens || 0
+    }
+  };
+  if (message) {
+    if (message.content) {
+      anthropicRes.content.push({
+        type: "text",
+        text: message.content
+      });
+    }
+    if (message.tool_calls) {
+      for (const tc of message.tool_calls) {
+        let parsedInput;
+        if (typeof tc.function.arguments === "string") {
+          try {
+            parsedInput = JSON.parse(tc.function.arguments);
+          } catch (e) {
+            parsedInput = { _error: "Malformed JSON from model", _raw: tc.function.arguments };
+          }
+        } else {
+          parsedInput = tc.function.arguments;
+        }
+        anthropicRes.content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: parsedInput
+        });
+      }
+    }
+  }
+  return anthropicRes;
+}
+
+// src/utils/helpers.ts
+function maskKey(key) {
+  if (!key || key.length <= 8) return "****";
+  return key.slice(0, 4) + "****" + key.slice(-4);
+}
+
+// src/proxy/server.ts
+var DEFAULT_PORT = 3002;
+var MODEL_NAME = process.env["ANTHROPIC_MODEL"] || "nvidia/nemotron-3-ultra-550b-a55b";
+var serverInstance = null;
+var router;
+var config;
+var globalUsageTracker2 = new UsageTracker();
+function parseKeyList(raw) {
+  return String(raw || "").split(",").map((part) => part.trim()).filter(Boolean);
+}
+function loadConfig(configPath) {
+  try {
+    if (fs.existsSync(configPath)) {
+      return JSON.parse(fs.readFileSync(configPath, "utf8"));
+    }
+  } catch (e) {
+    console.error("Failed to read config:", e);
+  }
+  return { defaultProvider: null, defaultModel: "", keys: { openrouter: [], nvidia: [] } };
+}
+function createRouterInstance(config2) {
+  const keysObj = config2?.keys || {};
+  let nvidiaKeys = Array.isArray(keysObj.nvidia) ? keysObj.nvidia : [];
+  let openRouterKeys = Array.isArray(keysObj.openrouter) ? keysObj.openrouter : [];
+  let mistralKeys = Array.isArray(keysObj.mistral) ? keysObj.mistral : [];
+  let geminiKeys = Array.isArray(keysObj.gemini) ? keysObj.gemini : [];
+  let groqKeys = Array.isArray(keysObj.groq) ? keysObj.groq : [];
+  if (nvidiaKeys.length === 0) {
+    nvidiaKeys = parseKeyList(process.env["NVIDIA_KEYS"]);
+  }
+  if (openRouterKeys.length === 0) {
+    openRouterKeys = parseKeyList(process.env["OPENROUTER_KEYS"]);
+  }
+  if (mistralKeys.length === 0) {
+    mistralKeys = parseKeyList(process.env["MISTRAL_KEYS"]);
+  }
+  if (geminiKeys.length === 0) {
+    geminiKeys = parseKeyList(process.env["GEMINI_KEYS"]);
+  }
+  if (groqKeys.length === 0) {
+    groqKeys = parseKeyList(process.env["GROQ_KEYS"]);
+  }
+  return new MultiProviderRouter([
+    {
+      provider: "openrouter",
+      keys: openRouterKeys,
+      models: config2.openrouterModels || ["minimax/minimax-m3:free", "minimax/minimax-m2.7:free", "z-ai/glm-5.2:free"]
+    },
+    {
+      provider: "nvidia",
+      keys: nvidiaKeys
+    },
+    {
+      provider: "mistral",
+      keys: mistralKeys
+    },
+    {
+      provider: "gemini",
+      keys: geminiKeys
+    },
+    {
+      provider: "groq",
+      keys: groqKeys,
+      models: config2.groqModels || ["qwen/qwen3.8-27b"]
+    }
+  ], {
+    strategy: config2.strategy || "smart",
+    trackLatency: config2.trackLatency !== void 0 ? config2.trackLatency : true,
+    failureThreshold: config2.failureThreshold || 2,
+    cooldownMs: config2.cooldownMs || 6e4,
+    windowMs: config2.windowMs || 6e4,
+    onDebug: (event) => {
+      if (event.type === "all_exhausted" || event.type === "circuit_opened" || event.type === "key_recovered") {
+        console.log(`[keymux] ${event.type}`, event.details || {});
+      }
+    }
+  });
+}
+function logUsage(provider, model, key, attempts, failoverReason, anthropicReq) {
+  if (process.env["KEYMUX_ENABLE_LOGGING"] !== "true") return;
+  try {
+    const maskedKeyStr = key ? maskKey(key) : "none";
+    let statusStr = attempts > 1 ? `[FAILOVER #${attempts} | Prev Reason: ${failoverReason}]` : `[PRIMARY TRY #1]`;
+    const logLine = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${statusStr.padEnd(50)} | Provider: ${provider.padEnd(10)} | Key: ${maskedKeyStr.padEnd(15)} | Model: ${model.padEnd(30)} | Query: <redacted for privacy>
+`;
+    const logDir = path.join(os2.homedir(), ".claude");
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    const logPath = path.join(logDir, "queries.log");
+    if (fs.existsSync(logPath) && fs.statSync(logPath).size > 5 * 1024 * 1024) {
+      fs.renameSync(logPath, logPath.replace("queries.log", "queries.old.log"));
+    }
+    fs.appendFileSync(logPath, logLine);
+  } catch (e) {
+    console.error("Failed to log usage", e);
+  }
+}
+function sendJson(res, statusCode, payload) {
+  res.writeHead(statusCode, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "*"
+  });
+  res.end(JSON.stringify(payload));
+}
+function startProxyServer(options) {
+  const port = options?.port || Number(process.env["NVIDIA_PROXY_PORT"]) || DEFAULT_PORT;
+  const configPath = options?.configPath || path.join(os2.homedir(), ".keymux", "config.json");
+  config = loadConfig(configPath);
+  router = createRouterInstance(config);
+  console.log("[keymux] Multi-Provider proxy initialized");
+  global.isConfigReloading = false;
+  serverInstance = http.createServer(async (req, res) => {
+    if (global.isConfigReloading) {
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    if (!req.url?.startsWith("/v1/keymux/")) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "*");
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.url === "/api/hello") {
+      res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+      res.end(JSON.stringify({ message: "hello" }));
+      return;
+    }
+    if (req.method === "GET" && (req.url === "/" || req.url === "/api" || req.url === "/api/")) {
+      return sendJson(res, 200, { status: "ok", service: "keymux-proxy" });
+    }
+    if (req.url?.startsWith("/v1/keymux/")) {
+      const adminToken = process.env["KEYMUX_ADMIN_TOKEN"];
+      if (adminToken) {
+        const authHeader = req.headers.authorization || "";
+        if (authHeader !== `Bearer ${adminToken}`) {
+          return sendJson(res, 401, { error: "Unauthorized" });
+        }
+      }
+      if (req.method === "POST" && req.url === "/v1/keymux/reload") {
+        try {
+          const newConfig = loadConfig(configPath);
+          const newRouter = createRouterInstance(newConfig);
+          global.isConfigReloading = true;
+          config = newConfig;
+          router = newRouter;
+          console.log("[keymux] Proxy settings reloaded");
+          return sendJson(res, 200, { status: "reloaded" });
+        } catch (err) {
+          console.error("[keymux] Proxy reload failed:", err);
+          return sendJson(res, 500, { error: "reload failed", details: err.message });
+        } finally {
+          global.isConfigReloading = false;
+        }
+      }
+      if (req.method === "GET" && req.url === "/v1/keymux/lastRoute") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        const lastRoute = typeof router.getLastRoute === "function" ? router.getLastRoute() : null;
+        if (lastRoute && global.lastActualTargetModel) {
+          lastRoute.model = global.lastActualTargetModel;
+        }
+        res.end(JSON.stringify(lastRoute || {}));
+        return;
+      }
+      if (req.method === "GET" && req.url === "/v1/keymux/activeModel") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          mode: config.strictMode ? "STRICT" : "AUTO",
+          model: config.defaultModel || "auto",
+          provider: config.defaultProvider || "auto"
+        }));
+        return;
+      }
+      if (req.method === "GET" && req.url === "/v1/keymux/stats") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(router.getStats()));
+        return;
+      }
+      if (req.method === "GET" && req.url === "/v1/keymux/usage") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          session: globalUsageTracker2.getSessionUsage(),
+          today: globalUsageTracker2.getTodayUsage()
+        }));
+        return;
+      }
+    }
+    if (req.method === "GET" && (req.url?.includes("/v1/models") || req.url?.includes("/models"))) {
+      return sendJson(res, 200, {
+        data: [
+          {
+            id: "claude-3-5-sonnet-minimax/minimax-m3",
+            type: "model",
+            created: 1715e6,
+            display_name: "MiniMax M3",
+            anthropic_family_tier: "sonnet"
+          },
+          {
+            id: "claude-3-5-sonnet-minimax/minimax-m2.7",
+            type: "model",
+            created: 1715e6,
+            display_name: "MiniMax M2.7",
+            anthropic_family_tier: "sonnet"
+          },
+          {
+            id: "claude-3-5-sonnet-nvidia/nemotron-3-super-120b-a12b",
+            type: "model",
+            created: 1715e6,
+            display_name: "Nemotron Super",
+            anthropic_family_tier: "sonnet"
+          },
+          {
+            id: "claude-3-5-sonnet-nvidia/nemotron-3-ultra-550b-a55b",
+            type: "model",
+            created: 1715e6,
+            display_name: "Nemotron Ultra",
+            anthropic_family_tier: "sonnet"
+          },
+          {
+            id: "claude-3-5-sonnet-codestral-2508",
+            type: "model",
+            created: 1715e6,
+            display_name: "Codestral",
+            anthropic_family_tier: "sonnet"
+          },
+          {
+            id: "claude-3-5-sonnet-gemini-1.5-flash",
+            type: "model",
+            created: 1715e6,
+            display_name: "Gemini 1.5 Flash",
+            anthropic_family_tier: "sonnet"
+          }
+        ]
+      });
+    }
+    if (req.method === "POST" && req.url?.includes("/count_tokens")) {
+      return sendJson(res, 200, { input_tokens: 10 });
+    }
+    if (req.method === "POST" && req.url?.includes("/v1/messages")) {
+      let bodyStr = "";
+      const MAX_BODY_SIZE = 25 * 1024 * 1024;
+      req.on("data", (chunk) => {
+        bodyStr += chunk;
+        if (bodyStr.length > MAX_BODY_SIZE) {
+          req.destroy();
+          res.writeHead(413, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Payload Too Large" }));
+        }
+      });
+      req.on("end", async () => {
+        try {
+          const anthropicReq = JSON.parse(bodyStr);
+          const isProbe = anthropicReq.messages && anthropicReq.messages.length === 1 && (anthropicReq.messages[0].content === "." || anthropicReq.messages[0].content === "ping" || anthropicReq.max_tokens <= 1);
+          if (isProbe) {
+            return sendJson(res, 200, {
+              id: "msg_probe_" + Math.random().toString(36).slice(2, 9),
+              type: "message",
+              role: "assistant",
+              content: [{ type: "text", text: "OK" }],
+              model: anthropicReq.model || MODEL_NAME,
+              stop_reason: "end_turn",
+              stop_sequence: null,
+              usage: { input_tokens: 1, output_tokens: 1 }
+            });
+          }
+          const openaiReq = translateAnthropicToOpenAI(anthropicReq);
+          openaiReq.model = anthropicReq.model || MODEL_NAME;
+          if (openaiReq.stream) {
+            openaiReq.stream_options = { include_usage: true };
+          }
+          const REQUEST_TIMEOUT_MS = Number(process.env["NVIDIA_PROXY_TIMEOUT"]) || 6e4;
+          let attempts = 0;
+          let lastErrorReason = "";
+          let finalEp = null;
+          let startedAt = 0;
+          const reqString = JSON.stringify(openaiReq);
+          const needsVision = reqString.includes('"type":"image_url"');
+          const needsComputerUse = reqString.includes('"name":"computer_20241022"');
+          const isComplexRequest = needsVision || needsComputerUse;
+          let preferProviders = config.defaultProvider ? [config.defaultProvider] : void 0;
+          let excludeProviders = config.strictMode && config.defaultProvider ? router.getProviderNames().filter((p) => p !== config.defaultProvider) : [];
+          if (isComplexRequest && !config.strictMode) {
+            console.log(`[PROXY] Detected ${needsVision ? "Vision" : "Computer Use"} request. Activating Smart Router...`);
+            preferProviders = ["openrouter", "gemini"];
+            const blindProviders = ["groq", "mistral", "nvidia"];
+            for (const p of blindProviders) {
+              if (!excludeProviders.includes(p)) excludeProviders.push(p);
+            }
+          }
+          try {
+            const fetchRes = await fetchWithFailover(
+              (ep2) => {
+                const url = new URL(ep2.baseURL + "/chat/completions");
+                return url.toString();
+              },
+              (ep2) => {
+                attempts++;
+                startedAt = Date.now();
+                console.log(`[PROXY] Attempt ${attempts}: Routing to ${ep2.provider} (${ep2.model})`);
+                logUsage(ep2.provider, ep2.model, ep2.key, attempts, lastErrorReason, anthropicReq);
+                let targetModel = config.defaultModel || anthropicReq.model || ep2.model || MODEL_NAME;
+                if (targetModel.startsWith("claude-3-5-sonnet-") && targetModel !== "claude-3-5-sonnet-20240620") {
+                  targetModel = targetModel.replace("claude-3-5-sonnet-", "");
+                }
+                if (!config.strictMode) {
+                  if (isComplexRequest && ep2.provider === "openrouter") {
+                    targetModel = "inclusionai/ling-3.0-flash-vl:free";
+                  } else if (isComplexRequest && ep2.provider === "gemini") {
+                    targetModel = "gemini-1.5-flash";
+                  } else if (ep2.provider === "nvidia" && !targetModel.startsWith("nvidia/") && !targetModel.startsWith("deepseek")) {
+                    targetModel = "nvidia/nemotron-3-super-120b-a12b";
+                  } else if (ep2.provider === "mistral" && !targetModel.startsWith("mistral") && !targetModel.startsWith("codestral") && !targetModel.startsWith("devstral")) {
+                    targetModel = "codestral-2508";
+                  } else if (ep2.provider === "gemini" && !targetModel.startsWith("gemini")) {
+                    targetModel = "gemini-3.5-flash-lite";
+                  } else if (ep2.provider === "groq" && !targetModel.startsWith("qwen/") && !targetModel.startsWith("groq/") && !targetModel.startsWith("openai/")) {
+                    targetModel = "qwen/qwen3.8-27b";
+                  } else if (ep2.provider === "openrouter") {
+                    if (targetModel.startsWith("nvidia/")) {
+                      targetModel = "qwen/qwen3.8-27b";
+                    } else if (targetModel === "codestral-2508") {
+                      targetModel = "mistralai/codestral-2501";
+                    } else if (!targetModel.includes("/")) {
+                      targetModel = "qwen/qwen3.8-27b";
+                    }
+                  }
+                }
+                openaiReq.model = targetModel;
+                global.lastActualTargetModel = targetModel;
+                if (ep2.provider === "openrouter" || targetModel.includes("deepseek")) {
+                  openaiReq.include_reasoning = true;
+                } else {
+                  delete openaiReq.include_reasoning;
+                }
+                const postData = JSON.stringify(openaiReq);
+                finalEp = ep2;
+                return {
+                  method: "POST",
+                  headers: {
+                    "Authorization": `Bearer ${ep2.key}`,
+                    "Content-Type": "application/json"
+                  },
+                  body: postData,
+                  signal: AbortSignal.timeout ? AbortSignal.timeout(REQUEST_TIMEOUT_MS) : void 0
+                };
+              },
+              {
+                router,
+                maxRetries: 10,
+                preferProviders,
+                excludeProviders
+              }
+            );
+            const ep = finalEp;
+            if (!fetchRes.ok) {
+              const errorData = await fetchRes.text();
+              if (globalUsageTracker2) {
+                globalUsageTracker2.recordRequest(ep.provider, 0, 0, 0);
+              }
+              lastErrorReason = `${ep.provider} HTTP ${fetchRes.status}`;
+              console.error(`[PROXY] Provider ${ep.provider} failed with ${fetchRes.status}: ${errorData}`);
+              let customMessage = `[Keymux Gateway] Provider error (${fetchRes.status}): ${errorData.substring(0, 150)}`;
+              const lowerErr = errorData.toLowerCase();
+              if (lowerErr.includes("tokens limit") || lowerErr.includes("context") || lowerErr.includes("too large")) {
+                customMessage = `[Keymux Gateway] Context window exceeded! Your prompt is too large for the current model. Please clear some history or switch to a larger model via 'keymux -d'. (Details: ${errorData.substring(0, 150)})`;
+              } else if (fetchRes.status === 402 || fetchRes.status === 429) {
+                customMessage = `[Keymux Gateway] All available APIs for this model are currently exhausted (rate-limited or out of credits). Please try again in a few minutes, or change your Provider/Model via 'keymux -d'.`;
+              }
+              res.writeHead(fetchRes.status, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({
+                type: "error",
+                error: {
+                  type: "api_error",
+                  message: customMessage
+                }
+              }));
+              return;
+            }
+            if (!openaiReq.stream) {
+              const responseData = await fetchRes.text();
+              try {
+                const openaiRes = JSON.parse(responseData);
+                const inputTokens = openaiRes.usage?.prompt_tokens || 0;
+                const outputTokens = openaiRes.usage?.completion_tokens || 0;
+                if (globalUsageTracker2 && openaiRes.usage) globalUsageTracker2.recordRequest(ep.provider, inputTokens, outputTokens, 0);
+                const anthropicRes = translateOpenAIToAnthropic(openaiRes, anthropicReq.model || MODEL_NAME);
+                router.reportSuccess(ep.endpointId, Date.now() - startedAt);
+                sendJson(res, 200, anthropicRes);
+              } catch (e) {
+                router.reportFailure(ep.endpointId, false);
+                sendJson(res, 500, { error: e.message });
+              }
+              return;
+            }
+            res.writeHead(fetchRes.status, {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive"
+            });
+            const TranslatorClass = ep.provider === "nvidia" ? NvidiaStreamTranslator : OpenRouterStreamTranslator;
+            const translator = new TranslatorClass(res, anthropicReq.model || MODEL_NAME);
+            let buffer = "";
+            let streamUsage = null;
+            let generatedText = "";
+            if (!fetchRes.body) {
+              res.end();
+              return;
+            }
+            const reader = fetchRes.body.getReader();
+            const decoder = new TextDecoder();
+            let ttftRecorded = false;
+            let ttftMs = Date.now() - startedAt;
+            let streamFailed = false;
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (!ttftRecorded) {
+                  ttftRecorded = true;
+                  ttftMs = Date.now() - startedAt;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                  const trimmed = line.trim();
+                  if (!trimmed) continue;
+                  if (trimmed === "data: [DONE]") continue;
+                  if (trimmed.startsWith("data: ")) {
+                    const jsonStr = trimmed.slice(6);
+                    try {
+                      const chunkObj = JSON.parse(jsonStr);
+                      if (chunkObj.usage) streamUsage = chunkObj.usage;
+                      if (chunkObj.choices?.[0]?.delta?.content) {
+                        generatedText += chunkObj.choices[0].delta.content;
+                      }
+                      translator.handleChunk(chunkObj);
+                    } catch (e) {
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+              console.error("[PROXY] Stream read error:", e);
+              router.reportFailure(ep.endpointId, false);
+              streamFailed = true;
+            }
+            if (!streamFailed) {
+              router.reportSuccess(ep.endpointId, ttftMs);
+              let inputTokens = streamUsage?.prompt_tokens || 0;
+              let outputTokens = streamUsage?.completion_tokens || 0;
+              if (inputTokens === 0 && outputTokens === 0) {
+                inputTokens = Math.ceil(JSON.stringify(anthropicReq.messages || []).length / 4);
+                outputTokens = Math.ceil(generatedText.length / 4);
+              }
+              if (globalUsageTracker2) {
+                globalUsageTracker2.recordRequest(ep.provider, inputTokens, outputTokens, 0);
+              }
+              translator.finish(streamUsage, streamUsage ? "stop" : null);
+            }
+            res.end();
+          } catch (error) {
+            console.error("[PROXY] fetchWithFailover Error:", error);
+            let customMessage = "[Keymux Gateway] API Error occurred.";
+            const targetProvider = config.defaultProvider;
+            const hasKeysForTarget = targetProvider && config.keys && config.keys[targetProvider] && config.keys[targetProvider].length > 0;
+            if (config.strictMode && !hasKeysForTarget) {
+              customMessage = `[Keymux Gateway] \u{1F6A8} No API keys found for '${targetProvider}'. Please open another terminal, run 'keymux -d', go to Settings and add your API key.`;
+            } else if (error.message?.includes("timeout") || error.name === "AbortError") {
+              customMessage = "[Keymux Gateway] The model provider is not responding (Timeout > 60s). The server might be down or overloaded. Please try changing your Default Model or Provider via 'keymux -d'.";
+            } else if (error.message?.includes("exhausted") || error.name === "RateLimitError") {
+              customMessage = "[Keymux Gateway] All available APIs for this model are currently exhausted (rate-limited or down). Please try again in a few minutes, or change your Provider/Model via 'keymux -d'.";
+            } else {
+              customMessage = `[Keymux Gateway] ${error.message}`;
+            }
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              type: "error",
+              error: {
+                type: "api_error",
+                message: customMessage
+              }
+            }));
+          }
+        } catch (err) {
+          sendJson(res, 400, { error: "Invalid JSON" });
+        }
+      });
+    } else {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    }
+  });
+  serverInstance.listen(port, "127.0.0.1", () => {
+    console.log(`[keymux] HTTP Proxy Server listening on 127.0.0.1:${port}`);
+  });
+  return serverInstance;
+}
+function stopProxyServer() {
+  if (serverInstance) {
+    serverInstance.close();
+    serverInstance = null;
+    console.log("[keymux] HTTP Proxy Server stopped");
+  }
+}
+
+export { NvidiaStreamTranslator, OpenRouterStreamTranslator, startProxyServer, stopProxyServer, translateAnthropicToOpenAI, translateMessages, translateOpenAIToAnthropic, translateTools };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map