@lov3kaizen/agentsea-gateway 0.5.1

package/dist/index.js

@@ -0,0 +1,3592 @@
+'use strict';
+
+var events = require('events');
+var tiktoken = require('tiktoken');
+var murmurhash = require('murmurhash');
+var lruCache = require('lru-cache');
+var pino = require('pino');
+var hono = require('hono');
+var cors = require('hono/cors');
+var logger = require('hono/logger');
+var streaming = require('hono/streaming');
+var nodeServer = require('@hono/node-server');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var murmurhash__default = /*#__PURE__*/_interopDefault(murmurhash);
+var pino__default = /*#__PURE__*/_interopDefault(pino);
+
+// src/core/Gateway.ts
+
+// src/core/types.ts
+var GatewayError = class extends Error {
+  constructor(message, code, statusCode = 500, provider, retryable = false) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.provider = provider;
+    this.retryable = retryable;
+    this.name = "GatewayError";
+  }
+};
+var ProviderError = class extends GatewayError {
+  constructor(message, provider, originalError, retryable = true) {
+    super(message, "PROVIDER_ERROR", 502, provider, retryable);
+    this.originalError = originalError;
+    this.name = "ProviderError";
+  }
+};
+var RateLimitError = class extends GatewayError {
+  constructor(message, retryAfter, provider) {
+    super(message, "RATE_LIMIT_EXCEEDED", 429, provider, true);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+var AuthenticationError = class extends GatewayError {
+  constructor(message) {
+    super(message, "AUTHENTICATION_FAILED", 401, void 0, false);
+    this.name = "AuthenticationError";
+  }
+};
+var ValidationError = class extends GatewayError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR", 400, void 0, false);
+    this.name = "ValidationError";
+  }
+};
+
+// src/providers/ProviderRegistry.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  modelToProvider = /* @__PURE__ */ new Map();
+  healthCheckInterval = null;
+  constructor(providers = []) {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+  }
+  /**
+   * Register a provider
+   */
+  register(provider) {
+    this.providers.set(provider.name, provider);
+    for (const model of provider.getModels()) {
+      const existing = this.modelToProvider.get(model) || [];
+      if (!existing.includes(provider.name)) {
+        existing.push(provider.name);
+        this.modelToProvider.set(model, existing);
+      }
+    }
+  }
+  /**
+   * Unregister a provider
+   */
+  unregister(name) {
+    const provider = this.providers.get(name);
+    if (!provider) {
+      return false;
+    }
+    for (const model of provider.getModels()) {
+      const providers = this.modelToProvider.get(model);
+      if (providers) {
+        const filtered = providers.filter((p) => p !== name);
+        if (filtered.length > 0) {
+          this.modelToProvider.set(model, filtered);
+        } else {
+          this.modelToProvider.delete(model);
+        }
+      }
+    }
+    this.providers.delete(name);
+    return true;
+  }
+  /**
+   * Get a provider by name
+   */
+  get(name) {
+    return this.providers.get(name);
+  }
+  /**
+   * Get all registered providers
+   */
+  getAll() {
+    return Array.from(this.providers.values());
+  }
+  /**
+   * Get all provider names
+   */
+  getNames() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+   * Get providers that support a specific model
+   */
+  getProvidersForModel(model) {
+    const names = this.modelToProvider.get(model) || [];
+    return names.map((name) => this.providers.get(name)).filter((p) => p !== void 0);
+  }
+  /**
+   * Get the first available provider for a model
+   */
+  getProviderForModel(model) {
+    const providers = this.getProvidersForModel(model);
+    return providers.find((p) => p.isAvailable());
+  }
+  /**
+   * Check if any provider supports a model
+   */
+  hasModel(model) {
+    return this.modelToProvider.has(model);
+  }
+  /**
+   * Get all available models across all providers
+   */
+  getAllModels() {
+    return Array.from(this.modelToProvider.keys());
+  }
+  /**
+   * Get model info from the appropriate provider
+   */
+  getModelInfo(model) {
+    const provider = this.getProviderForModel(model);
+    return provider?.getModelInfo(model) ?? null;
+  }
+  /**
+   * Get health status for all providers
+   */
+  getHealthStatus() {
+    const status = {};
+    for (const [name, provider] of this.providers) {
+      status[name] = provider.getHealth();
+    }
+    return status;
+  }
+  /**
+   * Get healthy providers
+   */
+  getHealthyProviders() {
+    return this.getAll().filter((p) => p.isHealthy());
+  }
+  /**
+   * Get available providers (healthy or degraded)
+   */
+  getAvailableProviders() {
+    return this.getAll().filter((p) => p.isAvailable());
+  }
+  /**
+   * Run health checks on all providers
+   */
+  async checkHealth() {
+    const results = {};
+    await Promise.all(
+      this.getAll().map(async (provider) => {
+        results[provider.name] = await provider.healthCheck();
+      })
+    );
+    return results;
+  }
+  /**
+   * Start periodic health checks
+   */
+  startHealthChecks(intervalMs = 6e4) {
+    if (this.healthCheckInterval) {
+      return;
+    }
+    this.healthCheckInterval = setInterval(() => {
+      this.checkHealth().catch(console.error);
+    }, intervalMs);
+  }
+  /**
+   * Stop periodic health checks
+   */
+  stopHealthChecks() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+  }
+  /**
+   * Get the number of registered providers
+   */
+  get size() {
+    return this.providers.size;
+  }
+};
+var CircuitBreaker = class {
+  constructor(providerName, config) {
+    this.providerName = providerName;
+    this.config = config;
+  }
+  state = "closed";
+  failures = 0;
+  successes = 0;
+  lastFailure = null;
+  nextAttempt = null;
+  /**
+   * Check if requests are allowed
+   */
+  isAllowed() {
+    if (this.state === "closed") {
+      return true;
+    }
+    if (this.state === "open") {
+      if (this.nextAttempt && /* @__PURE__ */ new Date() >= this.nextAttempt) {
+        this.state = "half-open";
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Record a successful request
+   */
+  recordSuccess() {
+    if (this.state === "half-open") {
+      this.successes++;
+      if (this.successes >= this.config.successThreshold) {
+        this.reset();
+      }
+    } else if (this.state === "closed") {
+      this.failures = Math.max(0, this.failures - 1);
+    }
+  }
+  /**
+   * Record a failed request
+   */
+  recordFailure() {
+    this.failures++;
+    this.lastFailure = /* @__PURE__ */ new Date();
+    if (this.state === "half-open") {
+      this.trip();
+    } else if (this.state === "closed" && this.failures >= this.config.failureThreshold) {
+      this.trip();
+    }
+  }
+  /**
+   * Trip the circuit breaker (open it)
+   */
+  trip() {
+    this.state = "open";
+    this.nextAttempt = new Date(Date.now() + this.config.timeout);
+    this.successes = 0;
+  }
+  /**
+   * Reset the circuit breaker
+   */
+  reset() {
+    this.state = "closed";
+    this.failures = 0;
+    this.successes = 0;
+    this.nextAttempt = null;
+  }
+  /**
+   * Get the current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get circuit status
+   */
+  getStatus() {
+    return {
+      providerName: this.providerName,
+      state: this.state,
+      failures: this.failures,
+      nextAttempt: this.nextAttempt,
+      lastFailure: this.lastFailure
+    };
+  }
+};
+var HealthMonitor = class extends events.EventEmitter {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  healthHistory = /* @__PURE__ */ new Map();
+  circuitBreakers = /* @__PURE__ */ new Map();
+  maxHistorySize = 100;
+  /**
+   * Record a health check result
+   */
+  recordHealth(providerName, health) {
+    const history = this.healthHistory.get(providerName) || [];
+    history.push(health);
+    if (history.length > this.maxHistorySize) {
+      history.shift();
+    }
+    this.healthHistory.set(providerName, history);
+    if (health.status === "unhealthy") {
+      this.emit("unhealthy", providerName, health);
+    } else if (health.status === "degraded") {
+      this.emit("degraded", providerName, health);
+    }
+  }
+  /**
+   * Record a request result
+   */
+  recordRequest(providerName, success, _latencyMs) {
+    const breaker = this.getOrCreateCircuitBreaker(providerName);
+    if (success) {
+      breaker.recordSuccess();
+    } else {
+      breaker.recordFailure();
+      if (breaker.getState() === "open") {
+        this.emit("circuit-open", providerName);
+      }
+    }
+  }
+  /**
+   * Check if requests are allowed for a provider
+   */
+  isRequestAllowed(providerName) {
+    const breaker = this.circuitBreakers.get(providerName);
+    return breaker ? breaker.isAllowed() : true;
+  }
+  /**
+   * Get or create a circuit breaker for a provider
+   */
+  getOrCreateCircuitBreaker(providerName) {
+    let breaker = this.circuitBreakers.get(providerName);
+    if (!breaker && this.config.circuitBreaker) {
+      breaker = new CircuitBreaker(providerName, this.config.circuitBreaker);
+      this.circuitBreakers.set(providerName, breaker);
+    }
+    return breaker || new CircuitBreaker(providerName, {
+      failureThreshold: 5,
+      successThreshold: 3,
+      timeout: 3e4
+    });
+  }
+  /**
+   * Get health history for a provider
+   */
+  getHistory(providerName) {
+    return this.healthHistory.get(providerName) || [];
+  }
+  /**
+   * Get average latency for a provider
+   */
+  getAverageLatency(providerName) {
+    const history = this.healthHistory.get(providerName) || [];
+    if (history.length === 0) return 0;
+    const sum = history.reduce((acc, h) => acc + h.latencyMs, 0);
+    return sum / history.length;
+  }
+  /**
+   * Get error rate for a provider
+   */
+  getErrorRate(providerName) {
+    const history = this.healthHistory.get(providerName) || [];
+    if (history.length === 0) return 0;
+    const lastHealth = history[history.length - 1];
+    return lastHealth.errorRate;
+  }
+  /**
+   * Get circuit breaker status for a provider
+   */
+  getCircuitStatus(providerName) {
+    const breaker = this.circuitBreakers.get(providerName);
+    return breaker ? breaker.getStatus() : null;
+  }
+  /**
+   * Get all circuit breaker statuses
+   */
+  getAllCircuitStatuses() {
+    const statuses = {};
+    for (const [name, breaker] of this.circuitBreakers) {
+      statuses[name] = breaker.getStatus();
+    }
+    return statuses;
+  }
+  /**
+   * Reset circuit breaker for a provider
+   */
+  resetCircuit(providerName) {
+    const breaker = this.circuitBreakers.get(providerName);
+    if (breaker) {
+      breaker.reset();
+      this.emit("circuit-reset", providerName);
+    }
+  }
+  /**
+   * Clear all history
+   */
+  clear() {
+    this.healthHistory.clear();
+    this.circuitBreakers.clear();
+  }
+};
+
+// src/routing/Router.ts
+var DEFAULT_MODEL_MAPPINGS = {
+  // GPT-4 class
+  "gpt-4o": [
+    { provider: "anthropic", model: "claude-3-5-sonnet-20241022" },
+    { provider: "google", model: "gemini-1.5-pro" }
+  ],
+  "claude-3-5-sonnet-20241022": [
+    { provider: "openai", model: "gpt-4o" },
+    { provider: "google", model: "gemini-1.5-pro" }
+  ],
+  "gemini-1.5-pro": [
+    { provider: "openai", model: "gpt-4o" },
+    { provider: "anthropic", model: "claude-3-5-sonnet-20241022" }
+  ],
+  // GPT-4 mini class
+  "gpt-4o-mini": [
+    { provider: "anthropic", model: "claude-3-5-haiku-20241022" },
+    { provider: "google", model: "gemini-1.5-flash" }
+  ],
+  "claude-3-5-haiku-20241022": [
+    { provider: "openai", model: "gpt-4o-mini" },
+    { provider: "google", model: "gemini-1.5-flash" }
+  ],
+  "gemini-1.5-flash": [
+    { provider: "openai", model: "gpt-4o-mini" },
+    { provider: "anthropic", model: "claude-3-5-haiku-20241022" }
+  ]
+};
+var VIRTUAL_MODELS = ["best", "cheapest", "fastest"];
+var Router = class {
+  strategy;
+  modelMappings;
+  fallbackChain;
+  constructor(strategy, config) {
+    this.strategy = strategy;
+    this.modelMappings = {
+      ...DEFAULT_MODEL_MAPPINGS,
+      ...config?.modelMappings
+    };
+    this.fallbackChain = config?.fallbackChain || [
+      "openai",
+      "anthropic",
+      "google"
+    ];
+  }
+  /**
+   * Route a request to a provider
+   */
+  route(request, registry, context) {
+    if (this.isVirtualModel(request.model)) {
+      return this.routeVirtualModel(request.model, request, registry, context);
+    }
+    return this.strategy.route(request, registry, context);
+  }
+  /**
+   * Check if a model is a virtual model
+   */
+  isVirtualModel(model) {
+    return VIRTUAL_MODELS.includes(model);
+  }
+  /**
+   * Route virtual model to actual provider/model
+   */
+  routeVirtualModel(virtualModel, _request, registry, context) {
+    const availableProviders = registry.getAvailableProviders().filter((p) => !context?.excludeProviders?.includes(p.name));
+    if (availableProviders.length === 0) {
+      throw new Error("No available providers");
+    }
+    switch (virtualModel) {
+      case "best":
+        return this.routeBest(availableProviders, context);
+      case "cheapest":
+        return this.routeCheapest(availableProviders, context);
+      case "fastest":
+        return this.routeFastest(availableProviders, context);
+      default:
+        throw new Error(`Unknown virtual model: ${String(virtualModel)}`);
+    }
+  }
+  /**
+   * Route to best quality model
+   */
+  routeBest(providers, context) {
+    const qualityRanking = {
+      "claude-3-5-sonnet-20241022": 95,
+      "claude-sonnet-4-20250514": 96,
+      "gpt-4o": 94,
+      "gemini-1.5-pro": 92,
+      "claude-3-opus-20240229": 93,
+      "gpt-4-turbo": 91,
+      o1: 97,
+      "o1-preview": 96
+    };
+    const candidates = [];
+    for (const provider of providers) {
+      for (const model of provider.getModels()) {
+        const score = qualityRanking[model] || 50;
+        candidates.push({
+          provider: provider.name,
+          model,
+          score
+        });
+      }
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    if (context?.preferredProvider) {
+      const preferred = candidates.find(
+        (c) => c.provider === context.preferredProvider
+      );
+      if (preferred) {
+        return {
+          provider: preferred.provider,
+          model: preferred.model,
+          reason: `Best quality model from preferred provider`,
+          alternatives: candidates.slice(0, 3),
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+    }
+    const best = candidates[0];
+    return {
+      provider: best.provider,
+      model: best.model,
+      reason: `Highest quality model available`,
+      alternatives: candidates.slice(1, 4),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Route to cheapest model
+   */
+  routeCheapest(providers, context) {
+    const candidates = [];
+    for (const provider of providers) {
+      for (const model of provider.getModels()) {
+        const modelInfo = provider.getModelInfo(model);
+        const avgCost = modelInfo ? (modelInfo.inputPricePerMillion + modelInfo.outputPricePerMillion) / 2 : Infinity;
+        candidates.push({
+          provider: provider.name,
+          model,
+          score: avgCost === 0 ? 0 : 1 / avgCost
+          // Higher score = cheaper
+        });
+      }
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    if (context?.maxCost !== void 0) {
+      const filtered = candidates.filter((c) => {
+        const provider = providers.find((p) => p.name === c.provider);
+        const modelInfo = provider?.getModelInfo(c.model);
+        if (!modelInfo) return true;
+        const estimatedCost = 1e3 / 1e6 * modelInfo.inputPricePerMillion + 500 / 1e6 * modelInfo.outputPricePerMillion;
+        return estimatedCost <= context.maxCost;
+      });
+      if (filtered.length > 0) {
+        const cheapest2 = filtered[0];
+        return {
+          provider: cheapest2.provider,
+          model: cheapest2.model,
+          reason: `Cheapest model within budget`,
+          alternatives: filtered.slice(1, 4),
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+    }
+    const cheapest = candidates[0];
+    return {
+      provider: cheapest.provider,
+      model: cheapest.model,
+      reason: `Cheapest available model`,
+      alternatives: candidates.slice(1, 4),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Route to fastest model (based on latency)
+   */
+  routeFastest(providers, context) {
+    const candidates = [];
+    for (const provider of providers) {
+      const health = provider.getHealth();
+      const latency = health.latencyMs || 1e3;
+      for (const model of provider.getModels()) {
+        candidates.push({
+          provider: provider.name,
+          model,
+          score: 1 / latency
+          // Higher score = lower latency
+        });
+      }
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    if (context?.maxLatency !== void 0) {
+      const filtered = candidates.filter((c) => {
+        const provider = providers.find((p) => p.name === c.provider);
+        const health = provider?.getHealth();
+        return (health?.latencyMs || 1e3) <= context.maxLatency;
+      });
+      if (filtered.length > 0) {
+        const fastest2 = filtered[0];
+        return {
+          provider: fastest2.provider,
+          model: fastest2.model,
+          reason: `Fastest model within latency limit`,
+          alternatives: filtered.slice(1, 4),
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+    }
+    const fastest = candidates[0];
+    return {
+      provider: fastest.provider,
+      model: fastest.model,
+      reason: `Fastest available provider`,
+      alternatives: candidates.slice(1, 4),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Get equivalent models across providers
+   */
+  getEquivalentModels(model) {
+    return this.modelMappings[model] || [];
+  }
+  /**
+   * Set the routing strategy
+   */
+  setStrategy(strategy) {
+    this.strategy = strategy;
+  }
+  /**
+   * Get the current strategy name
+   */
+  getStrategyName() {
+    return this.strategy.name;
+  }
+  /**
+   * Get the fallback chain
+   */
+  getFallbackChain() {
+    return [...this.fallbackChain];
+  }
+};
+function createRouterConfig(options) {
+  return {
+    strategy: options.strategy || "round-robin",
+    fallbackChain: options.fallbackChain,
+    weights: options.weights,
+    rules: options.rules
+  };
+}
+
+// src/routing/strategies/RoundRobin.ts
+var RoundRobinStrategy = class {
+  name = "round-robin";
+  currentIndex = 0;
+  weights;
+  constructor(config = {}) {
+    this.weights = config.weights || {};
+  }
+  route(request, registry, context) {
+    let providers = registry.getProvidersForModel(request.model);
+    if (providers.length === 0) {
+      providers = registry.getAvailableProviders();
+    }
+    if (context?.excludeProviders) {
+      providers = providers.filter(
+        (p) => !context.excludeProviders.includes(p.name)
+      );
+    }
+    providers = providers.filter((p) => p.isAvailable());
+    if (providers.length === 0) {
+      throw new Error(`No available providers for model: ${request.model}`);
+    }
+    if (context?.preferredProvider) {
+      const preferred = providers.find(
+        (p) => p.name === context.preferredProvider
+      );
+      if (preferred) {
+        const model2 = preferred.supportsModel(request.model) ? request.model : preferred.getModels()[0];
+        return {
+          provider: preferred.name,
+          model: model2,
+          reason: "Preferred provider selected",
+          alternatives: providers.filter((p) => p.name !== preferred.name).slice(0, 3).map((p) => ({
+            provider: p.name,
+            model: p.supportsModel(request.model) ? request.model : p.getModels()[0],
+            score: 1
+          })),
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+    }
+    const weightedProviders = [];
+    for (const provider of providers) {
+      const weight = this.weights[provider.name] || 1;
+      for (let i = 0; i < weight; i++) {
+        weightedProviders.push({ provider, weight });
+      }
+    }
+    this.currentIndex = this.currentIndex % weightedProviders.length;
+    const selected = weightedProviders[this.currentIndex];
+    this.currentIndex++;
+    const model = selected.provider.supportsModel(request.model) ? request.model : selected.provider.getModels()[0];
+    return {
+      provider: selected.provider.name,
+      model,
+      reason: `Round-robin selection (index: ${this.currentIndex - 1})`,
+      alternatives: providers.filter((p) => p.name !== selected.provider.name).slice(0, 3).map((p) => ({
+        provider: p.name,
+        model: p.supportsModel(request.model) ? request.model : p.getModels()[0],
+        score: 1
+      })),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Reset the rotation index
+   */
+  reset() {
+    this.currentIndex = 0;
+  }
+};
+
+// src/routing/strategies/Failover.ts
+var FailoverStrategy = class {
+  name = "failover";
+  chain;
+  modelMappings;
+  constructor(config) {
+    this.chain = config.chain;
+    this.modelMappings = config.modelMappings || {};
+  }
+  route(request, registry, context) {
+    const previousProviders = new Set(
+      context?.previousAttempts?.map((a) => a.provider) || []
+    );
+    if (context?.excludeProviders) {
+      for (const p of context.excludeProviders) {
+        previousProviders.add(p);
+      }
+    }
+    const alternatives = [];
+    for (const providerName of this.chain) {
+      const provider = registry.get(providerName);
+      if (!provider) continue;
+      if (!provider.isAvailable()) continue;
+      if (previousProviders.has(providerName)) continue;
+      let model = request.model;
+      if (!provider.supportsModel(model)) {
+        const mappedModel = this.modelMappings[model]?.[providerName];
+        if (mappedModel && provider.supportsModel(mappedModel)) {
+          model = mappedModel;
+        } else {
+          model = provider.getModels()[0];
+        }
+      }
+      for (const altName of this.chain) {
+        if (altName === providerName) continue;
+        if (previousProviders.has(altName)) continue;
+        const altProvider = registry.get(altName);
+        if (!altProvider?.isAvailable()) continue;
+        let altModel = request.model;
+        if (!altProvider.supportsModel(altModel)) {
+          altModel = this.modelMappings[request.model]?.[altName] || altProvider.getModels()[0];
+        }
+        alternatives.push({
+          provider: altName,
+          model: altModel,
+          score: 1 - alternatives.length * 0.1
+        });
+        if (alternatives.length >= 3) break;
+      }
+      return {
+        provider: providerName,
+        model,
+        reason: previousProviders.size > 0 ? `Failover to ${providerName} after ${previousProviders.size} failures` : `Primary provider in failover chain`,
+        alternatives,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    }
+    throw new Error(
+      `All providers in failover chain exhausted: ${this.chain.join(", ")}`
+    );
+  }
+  /**
+   * Get the next provider in chain after the given one
+   */
+  getNextProvider(currentProvider) {
+    const index = this.chain.indexOf(currentProvider);
+    if (index === -1 || index >= this.chain.length - 1) {
+      return null;
+    }
+    return this.chain[index + 1];
+  }
+  /**
+   * Get the current failover chain
+   */
+  getChain() {
+    return [...this.chain];
+  }
+  /**
+   * Update the failover chain
+   */
+  setChain(chain) {
+    this.chain = [...chain];
+  }
+};
+var encoder = null;
+function getEncoder() {
+  if (!encoder) {
+    encoder = tiktoken.get_encoding("cl100k_base");
+  }
+  return encoder;
+}
+function countTokens(text) {
+  try {
+    const enc = getEncoder();
+    return enc.encode(text).length;
+  } catch {
+    return Math.ceil(text.length / 4);
+  }
+}
+function countMessageTokens(messages) {
+  let total = 0;
+  for (const message of messages) {
+    total += 4;
+    if (message.content) {
+      total += countTokens(
+        typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+      );
+    }
+  }
+  total += 2;
+  return total;
+}
+function estimateRequestTokens(messages, tools) {
+  let total = countMessageTokens(messages);
+  if (tools && tools.length > 0) {
+    for (const tool of tools) {
+      total += countTokens(tool.function.name);
+      if (tool.function.description) {
+        total += countTokens(tool.function.description);
+      }
+      if (tool.function.parameters) {
+        total += countTokens(JSON.stringify(tool.function.parameters));
+      }
+      total += 10;
+    }
+  }
+  return total;
+}
+function truncateToTokenLimit(text, maxTokens) {
+  const enc = getEncoder();
+  const tokens = enc.encode(text);
+  if (tokens.length <= maxTokens) {
+    return text;
+  }
+  const truncatedTokens = tokens.slice(0, maxTokens);
+  const decoded = enc.decode(truncatedTokens);
+  return new TextDecoder().decode(decoded);
+}
+function freeEncoder() {
+  if (encoder) {
+    encoder.free();
+    encoder = null;
+  }
+}
+
+// src/routing/strategies/CostOptimized.ts
+var MODEL_QUALITY_SCORES = {
+  // Top tier
+  o1: 98,
+  "o1-preview": 96,
+  "claude-3-opus-20240229": 95,
+  "claude-3-5-sonnet-20241022": 94,
+  "claude-sonnet-4-20250514": 95,
+  "gpt-4o": 93,
+  "gemini-1.5-pro": 91,
+  // Mid tier
+  "gpt-4-turbo": 88,
+  "gpt-4": 87,
+  "claude-3-sonnet-20240229": 85,
+  "o1-mini": 84,
+  // Fast/cheap tier
+  "gpt-4o-mini": 80,
+  "claude-3-5-haiku-20241022": 79,
+  "claude-3-haiku-20240307": 75,
+  "gemini-1.5-flash": 78,
+  "gpt-3.5-turbo": 70,
+  // Local models
+  llama3: 65,
+  "llama3.1": 67,
+  "llama3.2": 68,
+  mistral: 62
+};
+var CostOptimizedStrategy = class {
+  name = "cost-optimized";
+  config;
+  constructor(config = {}) {
+    this.config = {
+      preferLocal: false,
+      qualityThreshold: 0.6,
+      fallbackOnBudget: "cheapest",
+      ...config
+    };
+  }
+  route(request, registry, context) {
+    let providers = registry.getAvailableProviders();
+    if (context?.excludeProviders) {
+      providers = providers.filter(
+        (p) => !context.excludeProviders.includes(p.name)
+      );
+    }
+    if (providers.length === 0) {
+      throw new Error("No available providers");
+    }
+    const estimatedInputTokens = estimateRequestTokens(
+      request.messages,
+      request.tools
+    );
+    const estimatedOutputTokens = request.max_tokens || 1e3;
+    const candidates = [];
+    for (const provider of providers) {
+      const isLocal = provider.name === "ollama" || provider.name === "lmstudio";
+      for (const model of provider.getModels()) {
+        const modelInfo = provider.getModelInfo(model);
+        if (!modelInfo) continue;
+        const inputCost = estimatedInputTokens / 1e6 * modelInfo.inputPricePerMillion;
+        const outputCost = estimatedOutputTokens / 1e6 * modelInfo.outputPricePerMillion;
+        const totalCost = inputCost + outputCost;
+        const quality = (MODEL_QUALITY_SCORES[model] || 50) / 100;
+        candidates.push({
+          provider: provider.name,
+          model,
+          cost: totalCost,
+          quality,
+          isLocal
+        });
+      }
+    }
+    const minQuality = this.config.qualityThreshold || 0;
+    let filtered = candidates.filter((c) => c.quality >= minQuality);
+    if (filtered.length === 0) {
+      filtered = candidates;
+    }
+    const maxCost = context?.maxCost ?? this.config.maxCostPerRequest;
+    if (maxCost !== void 0) {
+      const withinBudget = filtered.filter((c) => c.cost <= maxCost);
+      if (withinBudget.length > 0) {
+        filtered = withinBudget;
+      } else if (this.config.fallbackOnBudget === "error") {
+        throw new Error(`No models within budget of $${maxCost.toFixed(4)}`);
+      }
+    }
+    filtered.sort((a, b) => {
+      if (this.config.preferLocal) {
+        if (a.isLocal && !b.isLocal) return -1;
+        if (!a.isLocal && b.isLocal) return 1;
+      }
+      return a.cost - b.cost;
+    });
+    const selected = filtered[0];
+    return {
+      provider: selected.provider,
+      model: selected.model,
+      reason: `Cheapest model meeting quality threshold (${(selected.quality * 100).toFixed(0)}% quality, $${selected.cost.toFixed(6)}/req)`,
+      alternatives: filtered.slice(1, 4).map((c) => ({
+        provider: c.provider,
+        model: c.model,
+        score: 1 / (c.cost + 1e-4)
+        // Higher score = cheaper
+      })),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/routing/strategies/LatencyOptimized.ts
+var LatencyOptimizedStrategy = class {
+  name = "latency-optimized";
+  config;
+  latencyStats = /* @__PURE__ */ new Map();
+  maxSamples = 100;
+  constructor(config = {}) {
+    this.config = {
+      warmupRequests: 10,
+      adaptiveRouting: true,
+      ...config
+    };
+  }
+  route(request, registry, context) {
+    let providers = registry.getAvailableProviders();
+    if (context?.excludeProviders) {
+      providers = providers.filter(
+        (p) => !context.excludeProviders.includes(p.name)
+      );
+    }
+    if (providers.length === 0) {
+      throw new Error("No available providers");
+    }
+    const totalRequests = Array.from(this.latencyStats.values()).reduce(
+      (sum, stats) => sum + stats.count,
+      0
+    );
+    const warmupThreshold = this.config.warmupRequests ?? 10;
+    const isWarmup = warmupThreshold > 0 && totalRequests < warmupThreshold;
+    const candidates = [];
+    for (const provider of providers) {
+      const stats = this.latencyStats.get(provider.name);
+      const health = provider.getHealth();
+      let latency;
+      let confidence;
+      if (stats && stats.count >= 5 && this.config.adaptiveRouting) {
+        latency = stats.avg;
+        confidence = Math.min(stats.count / 50, 1);
+      } else {
+        latency = health.latencyMs || 1e3;
+        confidence = 0.3;
+      }
+      for (const model of provider.getModels()) {
+        if (request.model !== "fastest" && !provider.supportsModel(request.model) && model !== request.model) {
+          continue;
+        }
+        candidates.push({
+          provider: provider.name,
+          model: request.model !== "fastest" && provider.supportsModel(request.model) ? request.model : model,
+          latency,
+          confidence
+        });
+        break;
+      }
+    }
+    const maxLatency = context?.maxLatency ?? this.config.maxLatencyMs;
+    let filtered = candidates;
+    if (maxLatency !== void 0) {
+      const withinLimit = candidates.filter((c) => c.latency <= maxLatency);
+      if (withinLimit.length > 0) {
+        filtered = withinLimit;
+      }
+    }
+    filtered.sort((a, b) => a.latency - b.latency);
+    const shouldExplore = isWarmup && Math.random() < 0.3 && filtered.length > 1;
+    if (shouldExplore) {
+      const randomIndex = Math.floor(
+        Math.random() * Math.min(3, filtered.length)
+      );
+      const selected2 = filtered[randomIndex];
+      return {
+        provider: selected2.provider,
+        model: selected2.model,
+        reason: `Warmup exploration (${totalRequests}/${warmupThreshold} requests)`,
+        alternatives: filtered.filter((c) => c.provider !== selected2.provider).slice(0, 3).map((c) => ({
+          provider: c.provider,
+          model: c.model,
+          score: 1 / c.latency
+        })),
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    }
+    const selected = filtered[0];
+    return {
+      provider: selected.provider,
+      model: selected.model,
+      reason: `Fastest provider (${selected.latency.toFixed(0)}ms avg, ${(selected.confidence * 100).toFixed(0)}% confidence)`,
+      alternatives: filtered.slice(1, 4).map((c) => ({
+        provider: c.provider,
+        model: c.model,
+        score: 1 / c.latency
+      })),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Record a latency observation
+   */
+  recordLatency(provider, latencyMs) {
+    let stats = this.latencyStats.get(provider);
+    if (!stats) {
+      stats = {
+        count: 0,
+        total: 0,
+        min: Infinity,
+        max: 0,
+        avg: 0,
+        p95: 0,
+        samples: []
+      };
+      this.latencyStats.set(provider, stats);
+    }
+    stats.count++;
+    stats.total += latencyMs;
+    stats.min = Math.min(stats.min, latencyMs);
+    stats.max = Math.max(stats.max, latencyMs);
+    stats.samples.push(latencyMs);
+    if (stats.samples.length > this.maxSamples) {
+      stats.samples.shift();
+    }
+    const alpha = 0.2;
+    if (stats.count === 1) {
+      stats.avg = latencyMs;
+    } else {
+      stats.avg = alpha * latencyMs + (1 - alpha) * stats.avg;
+    }
+    if (stats.samples.length >= 20) {
+      const sorted = [...stats.samples].sort((a, b) => a - b);
+      const p95Index = Math.floor(sorted.length * 0.95);
+      stats.p95 = sorted[p95Index];
+    }
+  }
+  /**
+   * Get latency statistics for a provider
+   */
+  getStats(provider) {
+    return this.latencyStats.get(provider);
+  }
+  /**
+   * Get all latency statistics
+   */
+  getAllStats() {
+    const result = {};
+    for (const [provider, stats] of this.latencyStats) {
+      result[provider] = { ...stats, samples: [...stats.samples] };
+    }
+    return result;
+  }
+  /**
+   * Clear latency statistics
+   */
+  clearStats() {
+    this.latencyStats.clear();
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+
+// src/utils/pricing.ts
+var MODEL_PRICING = {
+  // OpenAI Models
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-2024-11-20": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4o-mini-2024-07-18": { input: 0.15, output: 0.6 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4-turbo-preview": { input: 10, output: 30 },
+  "gpt-4": { input: 30, output: 60 },
+  "gpt-4-32k": { input: 60, output: 120 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  "gpt-3.5-turbo-0125": { input: 0.5, output: 1.5 },
+  o1: { input: 15, output: 60 },
+  "o1-preview": { input: 15, output: 60 },
+  "o1-mini": { input: 3, output: 12 },
+  // Anthropic Models
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-3-5-sonnet-latest": { input: 3, output: 15 },
+  "claude-sonnet-4-20250514": { input: 3, output: 15 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+  "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  "claude-3-sonnet-20240229": { input: 3, output: 15 },
+  // Google Gemini Models
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  "gemini-1.5-pro-latest": { input: 1.25, output: 5 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  "gemini-1.5-flash-latest": { input: 0.075, output: 0.3 },
+  "gemini-2.0-flash-exp": { input: 0.1, output: 0.4 },
+  "gemini-pro": { input: 0.5, output: 1.5 },
+  // Mistral Models
+  "mistral-large-latest": { input: 2, output: 6 },
+  "mistral-medium-latest": { input: 2.7, output: 8.1 },
+  "mistral-small-latest": { input: 0.2, output: 0.6 },
+  "open-mistral-7b": { input: 0.25, output: 0.25 },
+  "open-mixtral-8x7b": { input: 0.7, output: 0.7 },
+  "open-mixtral-8x22b": { input: 2, output: 6 },
+  // Cohere Models
+  "command-r-plus": { input: 2.5, output: 10 },
+  "command-r": { input: 0.5, output: 1.5 },
+  command: { input: 1, output: 2 },
+  // Groq Models (significantly cheaper)
+  "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
+  "llama-3.1-70b-versatile": { input: 0.59, output: 0.79 },
+  "llama-3.1-8b-instant": { input: 0.05, output: 0.08 },
+  "mixtral-8x7b-32768": { input: 0.24, output: 0.24 },
+  // Together AI Models
+  "meta-llama/Llama-3.3-70B-Instruct-Turbo": { input: 0.88, output: 0.88 },
+  "meta-llama/Llama-3.1-70B-Instruct-Turbo": { input: 0.88, output: 0.88 },
+  "meta-llama/Llama-3.1-8B-Instruct-Turbo": { input: 0.18, output: 0.18 },
+  "mistralai/Mixtral-8x7B-Instruct-v0.1": { input: 0.6, output: 0.6 },
+  // Local models (free)
+  llama3: { input: 0, output: 0 },
+  "llama3.1": { input: 0, output: 0 },
+  "llama3.2": { input: 0, output: 0 },
+  mistral: { input: 0, output: 0 },
+  codellama: { input: 0, output: 0 },
+  phi3: { input: 0, output: 0 },
+  "qwen2.5": { input: 0, output: 0 }
+};
+var MODEL_CONTEXT_WINDOWS = {
+  // OpenAI
+  "gpt-4o": 128e3,
+  "gpt-4o-mini": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gpt-4": 8192,
+  "gpt-4-32k": 32768,
+  "gpt-3.5-turbo": 16385,
+  o1: 2e5,
+  "o1-preview": 128e3,
+  "o1-mini": 128e3,
+  // Anthropic
+  "claude-3-5-sonnet-20241022": 2e5,
+  "claude-sonnet-4-20250514": 2e5,
+  "claude-3-5-haiku-20241022": 2e5,
+  "claude-3-opus-20240229": 2e5,
+  "claude-3-sonnet-20240229": 2e5,
+  "claude-3-haiku-20240307": 2e5,
+  // Google
+  "gemini-1.5-pro": 2e6,
+  "gemini-1.5-flash": 1e6,
+  "gemini-2.0-flash-exp": 1e6,
+  "gemini-pro": 32e3,
+  // Mistral
+  "mistral-large-latest": 128e3,
+  "mistral-medium-latest": 32e3,
+  "mistral-small-latest": 32e3,
+  // Groq
+  "llama-3.3-70b-versatile": 128e3,
+  "llama-3.1-70b-versatile": 131072,
+  "llama-3.1-8b-instant": 131072,
+  "mixtral-8x7b-32768": 32768
+};
+var MODEL_MAX_OUTPUT = {
+  // OpenAI
+  "gpt-4o": 16384,
+  "gpt-4o-mini": 16384,
+  "gpt-4-turbo": 4096,
+  "gpt-4": 8192,
+  "gpt-3.5-turbo": 4096,
+  o1: 1e5,
+  "o1-preview": 32768,
+  "o1-mini": 65536,
+  // Anthropic
+  "claude-3-5-sonnet-20241022": 8192,
+  "claude-sonnet-4-20250514": 16384,
+  "claude-3-opus-20240229": 4096,
+  // Google
+  "gemini-1.5-pro": 8192,
+  "gemini-1.5-flash": 8192
+};
+function calculateCost(model, usage) {
+  const pricing = MODEL_PRICING[model];
+  if (!pricing) {
+    return 0;
+  }
+  const inputCost = usage.prompt_tokens / 1e6 * pricing.input;
+  const outputCost = usage.completion_tokens / 1e6 * pricing.output;
+  return inputCost + outputCost;
+}
+function estimateCost(model, estimatedInputTokens, estimatedOutputTokens) {
+  const pricing = MODEL_PRICING[model];
+  if (!pricing) {
+    return 0;
+  }
+  const inputCost = estimatedInputTokens / 1e6 * pricing.input;
+  const outputCost = estimatedOutputTokens / 1e6 * pricing.output;
+  return inputCost + outputCost;
+}
+function getModelPricing(model) {
+  return MODEL_PRICING[model] || null;
+}
+function getModelInfo(model, provider) {
+  const pricing = MODEL_PRICING[model] || { input: 0, output: 0 };
+  const contextWindow = MODEL_CONTEXT_WINDOWS[model] || 4096;
+  const maxOutput = MODEL_MAX_OUTPUT[model] || 4096;
+  return {
+    id: model,
+    provider,
+    contextWindow,
+    maxOutputTokens: maxOutput,
+    inputPricePerMillion: pricing.input,
+    outputPricePerMillion: pricing.output,
+    capabilities: getModelCapabilities(model, provider)
+  };
+}
+function getModelCapabilities(model, provider) {
+  const defaults = {
+    streaming: true,
+    tools: true,
+    vision: false,
+    json_mode: true,
+    system_prompts: true
+  };
+  if (model.includes("gpt-4o") || model.includes("gpt-4-turbo")) {
+    return { ...defaults, vision: true };
+  }
+  if (model.includes("o1")) {
+    return {
+      streaming: false,
+      // o1 doesn't support streaming
+      tools: false,
+      vision: false,
+      json_mode: false,
+      system_prompts: false
+      // o1 uses developer messages
+    };
+  }
+  if (model.includes("claude-3")) {
+    return { ...defaults, vision: true };
+  }
+  if (model.includes("gemini")) {
+    return { ...defaults, vision: true };
+  }
+  if (provider === "ollama") {
+    return {
+      streaming: true,
+      tools: false,
+      // Most Ollama models don't support tools natively
+      vision: model.includes("llava") || model.includes("bakllava"),
+      json_mode: true,
+      system_prompts: true
+    };
+  }
+  return defaults;
+}
+function findCheapestModel(models, _requiredCapabilities) {
+  let cheapest = null;
+  for (const model of models) {
+    const pricing = MODEL_PRICING[model];
+    if (!pricing) continue;
+    const avgCost = (pricing.input + pricing.output) / 2;
+    if (!cheapest || avgCost < cheapest.cost) {
+      cheapest = { model, cost: avgCost };
+    }
+  }
+  return cheapest?.model || null;
+}
+function sortModelsByCost(models, direction = "asc") {
+  return [...models].sort((a, b) => {
+    const pricingA = MODEL_PRICING[a] || { input: 0, output: 0 };
+    const pricingB = MODEL_PRICING[b] || { input: 0, output: 0 };
+    const costA = (pricingA.input + pricingA.output) / 2;
+    const costB = (pricingB.input + pricingB.output) / 2;
+    return direction === "asc" ? costA - costB : costB - costA;
+  });
+}
+function hashRequest(request) {
+  const normalized = {
+    model: request.model,
+    messages: request.messages.map((m) => ({
+      role: m.role,
+      content: normalizeContent(m.content)
+    })),
+    temperature: request.temperature ?? 1,
+    max_tokens: request.max_tokens,
+    tools: request.tools ? JSON.stringify(request.tools) : void 0,
+    tool_choice: request.tool_choice ? JSON.stringify(request.tool_choice) : void 0
+  };
+  const str = JSON.stringify(normalized);
+  return murmurhash__default.default.v3(str).toString(16);
+}
+function normalizeContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content === null || content === void 0) {
+    return "";
+  }
+  return JSON.stringify(content);
+}
+function generateId(prefix = "gw") {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${prefix}-${timestamp}${random}`;
+}
+function generateRequestId() {
+  return `chatcmpl-${generateId("")}`;
+}
+function generateCacheKey(provider, model, requestHash) {
+  return `gw:cache:${provider}:${model}:${requestHash}`;
+}
+function hash(str) {
+  return murmurhash__default.default.v3(str).toString(16);
+}
+function createSystemFingerprint(config) {
+  const str = JSON.stringify(config);
+  return `fp_${murmurhash__default.default.v3(str).toString(16)}`;
+}
+
+// src/providers/Provider.ts
+var Provider = class {
+  name;
+  config;
+  health;
+  constructor(config) {
+    this.name = config.name;
+    this.config = config;
+    this.health = {
+      status: "healthy",
+      latencyMs: 0,
+      lastCheck: /* @__PURE__ */ new Date(),
+      errorRate: 0,
+      consecutiveFailures: 0
+    };
+  }
+  /**
+   * Check if the provider supports a specific model
+   */
+  supportsModel(model) {
+    return this.config.models.includes(model);
+  }
+  /**
+   * Get all supported models
+   */
+  getModels() {
+    return [...this.config.models];
+  }
+  /**
+   * Get the current health status
+   */
+  getHealth() {
+    return { ...this.health };
+  }
+  /**
+   * Perform a health check
+   */
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      await this.chat({
+        model: this.config.models[0],
+        messages: [{ role: "user", content: "hi" }],
+        max_tokens: 1
+      });
+      const latencyMs = Date.now() - start;
+      this.health = {
+        status: "healthy",
+        latencyMs,
+        lastCheck: /* @__PURE__ */ new Date(),
+        errorRate: Math.max(0, this.health.errorRate - 0.1),
+        consecutiveFailures: 0
+      };
+    } catch (error) {
+      const latencyMs = Date.now() - start;
+      this.health = {
+        status: this.health.consecutiveFailures >= 2 ? "unhealthy" : "degraded",
+        latencyMs,
+        lastCheck: /* @__PURE__ */ new Date(),
+        errorRate: Math.min(1, this.health.errorRate + 0.2),
+        consecutiveFailures: this.health.consecutiveFailures + 1
+      };
+    }
+    return this.health;
+  }
+  /**
+   * Update health status after a request
+   */
+  updateHealth(success, latencyMs) {
+    if (success) {
+      this.health = {
+        status: "healthy",
+        latencyMs: this.health.latencyMs > 0 ? (this.health.latencyMs + latencyMs) / 2 : latencyMs,
+        lastCheck: /* @__PURE__ */ new Date(),
+        errorRate: Math.max(0, this.health.errorRate - 0.05),
+        consecutiveFailures: 0
+      };
+    } else {
+      this.health = {
+        ...this.health,
+        status: this.health.consecutiveFailures >= 2 ? "unhealthy" : "degraded",
+        lastCheck: /* @__PURE__ */ new Date(),
+        errorRate: Math.min(1, this.health.errorRate + 0.1),
+        consecutiveFailures: this.health.consecutiveFailures + 1
+      };
+    }
+  }
+  /**
+   * Check if the provider is currently healthy
+   */
+  isHealthy() {
+    return this.health.status === "healthy";
+  }
+  /**
+   * Check if the provider is available (healthy or degraded)
+   */
+  isAvailable() {
+    return this.health.status !== "unhealthy";
+  }
+};
+
+// src/providers/registry/OpenAIProvider.ts
+var DEFAULT_OPENAI_MODELS = [
+  "gpt-4o",
+  "gpt-4o-mini",
+  "gpt-4-turbo",
+  "gpt-4",
+  "gpt-3.5-turbo",
+  "o1",
+  "o1-mini",
+  "o1-preview"
+];
+var OpenAIProvider = class extends Provider {
+  apiKey;
+  baseUrl;
+  organization;
+  project;
+  timeout;
+  constructor(options = {}) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("OpenAI API key is required");
+    }
+    const config = {
+      name: "openai",
+      apiKey,
+      baseUrl: options.baseUrl || "https://api.openai.com/v1",
+      models: options.models || DEFAULT_OPENAI_MODELS,
+      timeout: options.timeout || 6e4,
+      maxRetries: options.maxRetries || 3,
+      headers: options.headers
+    };
+    super(config);
+    this.apiKey = apiKey;
+    this.baseUrl = config.baseUrl;
+    this.organization = options.organization;
+    this.project = options.project;
+    this.timeout = config.timeout;
+  }
+  /**
+   * Execute a chat completion request
+   */
+  async chat(request) {
+    const start = Date.now();
+    try {
+      const response = await this.makeRequest("/chat/completions", {
+        method: "POST",
+        body: JSON.stringify(this.transformRequest(request))
+      });
+      if (!response.ok) {
+        const error = await this.parseError(response);
+        throw error;
+      }
+      const data = await response.json();
+      const result = this.transformResponse(data, request.model);
+      this.updateHealth(true, Date.now() - start);
+      return result;
+    } catch (error) {
+      this.updateHealth(false, Date.now() - start);
+      throw this.wrapError(error);
+    }
+  }
+  /**
+   * Execute a streaming chat completion request
+   */
+  async *chatStream(request) {
+    const start = Date.now();
+    try {
+      const response = await this.makeRequest("/chat/completions", {
+        method: "POST",
+        body: JSON.stringify({
+          ...this.transformRequest(request),
+          stream: true,
+          stream_options: { include_usage: true }
+        })
+      });
+      if (!response.ok) {
+        const error = await this.parseError(response);
+        throw error;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new ProviderError("No response body", "openai");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        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 || trimmed === "data: [DONE]") continue;
+          if (!trimmed.startsWith("data: ")) continue;
+          try {
+            const json = JSON.parse(trimmed.slice(6));
+            yield this.transformChunk(json, request.model);
+          } catch {
+          }
+        }
+      }
+      this.updateHealth(true, Date.now() - start);
+    } catch (error) {
+      this.updateHealth(false, Date.now() - start);
+      throw this.wrapError(error);
+    }
+  }
+  /**
+   * Get model information
+   */
+  getModelInfo(model) {
+    if (!this.supportsModel(model)) {
+      return null;
+    }
+    return getModelInfo(model, "openai");
+  }
+  /**
+   * Make an HTTP request to the OpenAI API
+   */
+  async makeRequest(path, options) {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...this.config.headers
+    };
+    if (this.organization) {
+      headers["OpenAI-Organization"] = this.organization;
+    }
+    if (this.project) {
+      headers["OpenAI-Project"] = this.project;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(`${this.baseUrl}${path}`, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Transform gateway request to OpenAI format
+   */
+  transformRequest(request) {
+    const transformed = {
+      model: request.model,
+      messages: request.messages
+    };
+    if (request.temperature !== void 0) {
+      transformed.temperature = request.temperature;
+    }
+    if (request.max_tokens !== void 0) {
+      transformed.max_tokens = request.max_tokens;
+    }
+    if (request.top_p !== void 0) {
+      transformed.top_p = request.top_p;
+    }
+    if (request.frequency_penalty !== void 0) {
+      transformed.frequency_penalty = request.frequency_penalty;
+    }
+    if (request.presence_penalty !== void 0) {
+      transformed.presence_penalty = request.presence_penalty;
+    }
+    if (request.stop !== void 0) {
+      transformed.stop = request.stop;
+    }
+    if (request.tools !== void 0) {
+      transformed.tools = request.tools;
+    }
+    if (request.tool_choice !== void 0) {
+      transformed.tool_choice = request.tool_choice;
+    }
+    if (request.response_format !== void 0) {
+      transformed.response_format = request.response_format;
+    }
+    if (request.seed !== void 0) {
+      transformed.seed = request.seed;
+    }
+    if (request.user !== void 0) {
+      transformed.user = request.user;
+    }
+    return transformed;
+  }
+  /**
+   * Transform OpenAI response to gateway format
+   */
+  transformResponse(data, model) {
+    return {
+      id: data.id || generateRequestId(),
+      object: "chat.completion",
+      created: data.created || Math.floor(Date.now() / 1e3),
+      model: data.model || model,
+      choices: data.choices,
+      usage: data.usage,
+      system_fingerprint: data.system_fingerprint
+    };
+  }
+  /**
+   * Transform OpenAI stream chunk to gateway format
+   */
+  transformChunk(data, model) {
+    return {
+      id: data.id || generateRequestId(),
+      object: "chat.completion.chunk",
+      created: data.created || Math.floor(Date.now() / 1e3),
+      model: data.model || model,
+      choices: data.choices,
+      system_fingerprint: data.system_fingerprint,
+      usage: data.usage
+    };
+  }
+  /**
+   * Parse error response from OpenAI
+   */
+  async parseError(response) {
+    let message = `OpenAI API error: ${response.status}`;
+    const retryable = response.status >= 500 || response.status === 429;
+    try {
+      const data = await response.json();
+      if (data.error?.message) {
+        message = data.error.message;
+      }
+    } catch {
+    }
+    return new ProviderError(message, "openai", void 0, retryable);
+  }
+  /**
+   * Wrap unknown errors
+   */
+  wrapError(error) {
+    if (error instanceof ProviderError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const isTimeout = error.name === "AbortError" || error.message.includes("timeout");
+      return new ProviderError(
+        error.message,
+        "openai",
+        error,
+        isTimeout
+        // Timeouts are retryable
+      );
+    }
+    return new ProviderError("Unknown error", "openai", void 0, true);
+  }
+};
+
+// src/providers/registry/AnthropicProvider.ts
+var DEFAULT_ANTHROPIC_MODELS = [
+  "claude-3-5-sonnet-20241022",
+  "claude-3-5-sonnet-latest",
+  "claude-sonnet-4-20250514",
+  "claude-3-5-haiku-20241022",
+  "claude-3-opus-20240229",
+  "claude-3-sonnet-20240229",
+  "claude-3-haiku-20240307"
+];
+var ANTHROPIC_API_VERSION = "2023-06-01";
+var AnthropicProvider = class extends Provider {
+  apiKey;
+  baseUrl;
+  timeout;
+  anthropicBeta;
+  constructor(options = {}) {
+    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error("Anthropic API key is required");
+    }
+    const config = {
+      name: "anthropic",
+      apiKey,
+      baseUrl: options.baseUrl || "https://api.anthropic.com",
+      models: options.models || DEFAULT_ANTHROPIC_MODELS,
+      timeout: options.timeout || 6e4,
+      maxRetries: options.maxRetries || 3,
+      headers: options.headers
+    };
+    super(config);
+    this.apiKey = apiKey;
+    this.baseUrl = config.baseUrl;
+    this.timeout = config.timeout;
+    this.anthropicBeta = options.anthropicBeta;
+  }
+  /**
+   * Execute a chat completion request
+   */
+  async chat(request) {
+    const start = Date.now();
+    try {
+      const anthropicRequest = this.transformToAnthropic(request);
+      const response = await this.makeRequest("/v1/messages", {
+        method: "POST",
+        body: JSON.stringify(anthropicRequest)
+      });
+      if (!response.ok) {
+        const error = await this.parseError(response);
+        throw error;
+      }
+      const data = await response.json();
+      const result = this.transformFromAnthropic(data, request.model);
+      this.updateHealth(true, Date.now() - start);
+      return result;
+    } catch (error) {
+      this.updateHealth(false, Date.now() - start);
+      throw this.wrapError(error);
+    }
+  }
+  /**
+   * Execute a streaming chat completion request
+   */
+  async *chatStream(request) {
+    const start = Date.now();
+    try {
+      const anthropicRequest = this.transformToAnthropic(request);
+      const response = await this.makeRequest("/v1/messages", {
+        method: "POST",
+        body: JSON.stringify({
+          ...anthropicRequest,
+          stream: true
+        })
+      });
+      if (!response.ok) {
+        const error = await this.parseError(response);
+        throw error;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new ProviderError("No response body", "anthropic");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const requestId = generateRequestId();
+      let inputTokens = 0;
+      let outputTokens = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        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 || !trimmed.startsWith("data: ")) continue;
+          try {
+            const event = JSON.parse(trimmed.slice(6));
+            const chunk = this.transformStreamEvent(
+              event,
+              request.model,
+              requestId
+            );
+            if (event.type === "message_start" && event.message?.usage) {
+              inputTokens = event.message.usage.input_tokens || 0;
+            }
+            if (event.type === "message_delta" && event.usage) {
+              outputTokens = event.usage.output_tokens || 0;
+            }
+            if (chunk) {
+              if (event.type === "message_stop") {
+                chunk.usage = {
+                  prompt_tokens: inputTokens,
+                  completion_tokens: outputTokens,
+                  total_tokens: inputTokens + outputTokens
+                };
+              }
+              yield chunk;
+            }
+          } catch {
+          }
+        }
+      }
+      this.updateHealth(true, Date.now() - start);
+    } catch (error) {
+      this.updateHealth(false, Date.now() - start);
+      throw this.wrapError(error);
+    }
+  }
+  /**
+   * Get model information
+   */
+  getModelInfo(model) {
+    if (!this.supportsModel(model)) {
+      return null;
+    }
+    return getModelInfo(model, "anthropic");
+  }
+  /**
+   * Make an HTTP request to the Anthropic API
+   */
+  async makeRequest(path, options) {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey,
+      "anthropic-version": ANTHROPIC_API_VERSION,
+      ...this.config.headers
+    };
+    if (this.anthropicBeta && this.anthropicBeta.length > 0) {
+      headers["anthropic-beta"] = this.anthropicBeta.join(",");
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(`${this.baseUrl}${path}`, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Transform OpenAI-compatible request to Anthropic format
+   */
+  transformToAnthropic(request) {
+    const { messages, systemPrompt } = this.extractSystemPrompt(
+      request.messages
+    );
+    const transformed = {
+      model: request.model,
+      messages: messages.map((m) => this.transformMessage(m)),
+      max_tokens: request.max_tokens || 4096
+    };
+    if (systemPrompt) {
+      transformed.system = systemPrompt;
+    }
+    if (request.temperature !== void 0) {
+      transformed.temperature = request.temperature;
+    }
+    if (request.top_p !== void 0) {
+      transformed.top_p = request.top_p;
+    }
+    if (request.stop !== void 0) {
+      transformed.stop_sequences = Array.isArray(request.stop) ? request.stop : [request.stop];
+    }
+    if (request.tools && request.tools.length > 0) {
+      transformed.tools = request.tools.map((tool) => ({
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: tool.function.parameters || { type: "object" }
+      }));
+      if (request.tool_choice) {
+        if (request.tool_choice === "auto") {
+          transformed.tool_choice = { type: "auto" };
+        } else if (request.tool_choice === "required") {
+          transformed.tool_choice = { type: "any" };
+        } else if (request.tool_choice === "none") {
+          delete transformed.tools;
+        } else if (typeof request.tool_choice === "object" && request.tool_choice.function) {
+          transformed.tool_choice = {
+            type: "tool",
+            name: request.tool_choice.function.name
+          };
+        }
+      }
+    }
+    return transformed;
+  }
+  /**
+   * Extract system prompt from messages
+   */
+  extractSystemPrompt(messages) {
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const otherMessages = messages.filter((m) => m.role !== "system");
+    const systemPrompt = systemMessages.length > 0 ? systemMessages.map(
+      (m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+    ).join("\n") : null;
+    return { messages: otherMessages, systemPrompt };
+  }
+  /**
+   * Transform a single message to Anthropic format
+   */
+  transformMessage(message) {
+    if (message.role === "tool") {
+      return {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: message.tool_call_id,
+            content: typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+          }
+        ]
+      };
+    }
+    if (message.role === "assistant" && message.tool_calls) {
+      const content = [];
+      if (message.content) {
+        content.push({
+          type: "text",
+          text: typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+        });
+      }
+      for (const toolCall of message.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: toolCall.id,
+          name: toolCall.function.name,
+          input: JSON.parse(toolCall.function.arguments)
+        });
+      }
+      return { role: "assistant", content };
+    }
+    return {
+      role: message.role,
+      content: typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+    };
+  }
+  /**
+   * Transform Anthropic response to OpenAI-compatible format
+   */
+  transformFromAnthropic(data, model) {
+    const content = data.content;
+    let textContent = "";
+    const toolCalls = [];
+    for (const block of content) {
+      if (block.type === "text") {
+        textContent += block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          }
+        });
+      }
+    }
+    const message = {
+      role: "assistant",
+      content: textContent || null
+    };
+    if (toolCalls.length > 0) {
+      message.tool_calls = toolCalls;
+    }
+    const stopReason = data.stop_reason;
+    let finishReason = null;
+    if (stopReason === "end_turn") {
+      finishReason = "stop";
+    } else if (stopReason === "max_tokens") {
+      finishReason = "length";
+    } else if (stopReason === "tool_use") {
+      finishReason = "tool_calls";
+    }
+    const usage = data.usage;
+    return {
+      id: data.id || generateRequestId(),
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1e3),
+      model: data.model || model,
+      choices: [
+        {
+          index: 0,
+          message,
+          finish_reason: finishReason
+        }
+      ],
+      usage: {
+        prompt_tokens: usage.input_tokens,
+        completion_tokens: usage.output_tokens,
+        total_tokens: usage.input_tokens + usage.output_tokens
+      }
+    };
+  }
+  /**
+   * Transform Anthropic stream event to OpenAI-compatible chunk
+   */
+  transformStreamEvent(event, model, requestId) {
+    const eventType = event.type;
+    if (eventType === "content_block_delta") {
+      const delta = event.delta;
+      if (delta.type === "text_delta") {
+        return {
+          id: requestId,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1e3),
+          model,
+          choices: [
+            {
+              index: 0,
+              delta: {
+                content: delta.text
+              },
+              finish_reason: null
+            }
+          ]
+        };
+      }
+      if (delta.type === "input_json_delta") {
+        return {
+          id: requestId,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1e3),
+          model,
+          choices: [
+            {
+              index: 0,
+              delta: {},
+              finish_reason: null
+            }
+          ]
+        };
+      }
+    }
+    if (eventType === "content_block_start") {
+      const contentBlock = event.content_block;
+      if (contentBlock?.type === "tool_use") {
+        return {
+          id: requestId,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1e3),
+          model,
+          choices: [
+            {
+              index: 0,
+              delta: {
+                tool_calls: [
+                  {
+                    id: contentBlock.id,
+                    type: "function",
+                    function: {
+                      name: contentBlock.name,
+                      arguments: ""
+                    }
+                  }
+                ]
+              },
+              finish_reason: null
+            }
+          ]
+        };
+      }
+    }
+    if (eventType === "message_stop") {
+      return {
+        id: requestId,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1e3),
+        model,
+        choices: [
+          {
+            index: 0,
+            delta: {},
+            finish_reason: "stop"
+          }
+        ]
+      };
+    }
+    return null;
+  }
+  /**
+   * Parse error response from Anthropic
+   */
+  async parseError(response) {
+    let message = `Anthropic API error: ${response.status}`;
+    const retryable = response.status >= 500 || response.status === 429;
+    try {
+      const data = await response.json();
+      if (data.error?.message) {
+        message = data.error.message;
+      }
+    } catch {
+    }
+    return new ProviderError(message, "anthropic", void 0, retryable);
+  }
+  /**
+   * Wrap unknown errors
+   */
+  wrapError(error) {
+    if (error instanceof ProviderError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const isTimeout = error.name === "AbortError" || error.message.includes("timeout");
+      return new ProviderError(error.message, "anthropic", error, isTimeout);
+    }
+    return new ProviderError("Unknown error", "anthropic", void 0, true);
+  }
+};
+
+// src/providers/registry/GoogleProvider.ts
+var DEFAULT_GEMINI_MODELS = [
+  "gemini-1.5-pro",
+  "gemini-1.5-pro-latest",
+  "gemini-1.5-flash",
+  "gemini-1.5-flash-latest",
+  "gemini-2.0-flash-exp",
+  "gemini-pro"
+];
+var GoogleProvider = class extends Provider {
+  apiKey;
+  baseUrl;
+  timeout;
+  constructor(options = {}) {
+    const apiKey = options.apiKey || process.env.GOOGLE_API_KEY;
+    if (!apiKey) {
+      throw new Error("Google API key is required");
+    }
+    const config = {
+      name: "google",
+      apiKey,
+      baseUrl: options.baseUrl || "https://generativelanguage.googleapis.com/v1beta",
+      models: options.models || DEFAULT_GEMINI_MODELS,
+      timeout: options.timeout || 6e4,
+      maxRetries: options.maxRetries || 3,
+      headers: options.headers
+    };
+    super(config);
+    this.apiKey = apiKey;
+    this.baseUrl = config.baseUrl;
+    this.timeout = config.timeout;
+  }
+  /**
+   * Execute a chat completion request
+   */
+  async chat(request) {
+    const start = Date.now();
+    try {
+      const geminiRequest = this.transformToGemini(request);
+      const endpoint = `/models/${request.model}:generateContent`;
+      const response = await this.makeRequest(endpoint, {
+        method: "POST",
+        body: JSON.stringify(geminiRequest)
+      });
+      if (!response.ok) {
+        const error = await this.parseError(response);
+        throw error;
+      }
+      const data = await response.json();
+      const result = this.transformFromGemini(data, request.model);
+      this.updateHealth(true, Date.now() - start);
+      return result;
+    } catch (error) {
+      this.updateHealth(false, Date.now() - start);
+      throw this.wrapError(error);
+    }
+  }
+  /**
+   * Execute a streaming chat completion request
+   */
+  async *chatStream(request) {
+    const start = Date.now();
+    try {
+      const geminiRequest = this.transformToGemini(request);
+      const endpoint = `/models/${request.model}:streamGenerateContent`;
+      const response = await this.makeRequest(endpoint, {
+        method: "POST",
+        body: JSON.stringify(geminiRequest)
+      });
+      if (!response.ok) {
+        const error = await this.parseError(response);
+        throw error;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new ProviderError("No response body", "google");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const requestId = generateRequestId();
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        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 || trimmed === "[" || trimmed === "]" || trimmed === ",")
+            continue;
+          let jsonStr = trimmed;
+          if (jsonStr.startsWith(",")) jsonStr = jsonStr.slice(1);
+          if (jsonStr.endsWith(",")) jsonStr = jsonStr.slice(0, -1);
+          if (!jsonStr.startsWith("{")) continue;
+          try {
+            const data = JSON.parse(jsonStr);
+            const chunk = this.transformStreamChunk(
+              data,
+              request.model,
+              requestId
+            );
+            if (data.usageMetadata) {
+              totalInputTokens = data.usageMetadata.promptTokenCount || 0;
+              totalOutputTokens = data.usageMetadata.candidatesTokenCount || 0;
+            }
+            if (chunk) {
+              yield chunk;
+            }
+          } catch {
+          }
+        }
+      }
+      yield {
+        id: requestId,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1e3),
+        model: request.model,
+        choices: [
+          {
+            index: 0,
+            delta: {},
+            finish_reason: "stop"
+          }
+        ],
+        usage: {
+          prompt_tokens: totalInputTokens,
+          completion_tokens: totalOutputTokens,
+          total_tokens: totalInputTokens + totalOutputTokens
+        }
+      };
+      this.updateHealth(true, Date.now() - start);
+    } catch (error) {
+      this.updateHealth(false, Date.now() - start);
+      throw this.wrapError(error);
+    }
+  }
+  /**
+   * Get model information
+   */
+  getModelInfo(model) {
+    if (!this.supportsModel(model)) {
+      return null;
+    }
+    return getModelInfo(model, "google");
+  }
+  /**
+   * Make an HTTP request to the Google API
+   */
+  async makeRequest(path, options) {
+    const url = `${this.baseUrl}${path}?key=${this.apiKey}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Transform OpenAI-compatible request to Gemini format
+   */
+  transformToGemini(request) {
+    const contents = this.transformMessages(request.messages);
+    const transformed = {
+      contents
+    };
+    const generationConfig = {};
+    if (request.temperature !== void 0) {
+      generationConfig.temperature = request.temperature;
+    }
+    if (request.max_tokens !== void 0) {
+      generationConfig.maxOutputTokens = request.max_tokens;
+    }
+    if (request.top_p !== void 0) {
+      generationConfig.topP = request.top_p;
+    }
+    if (request.stop !== void 0) {
+      generationConfig.stopSequences = Array.isArray(request.stop) ? request.stop : [request.stop];
+    }
+    if (Object.keys(generationConfig).length > 0) {
+      transformed.generationConfig = generationConfig;
+    }
+    const systemMessages = request.messages.filter((m) => m.role === "system");
+    if (systemMessages.length > 0) {
+      const systemText = systemMessages.map(
+        (m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+      ).join("\n");
+      transformed.systemInstruction = { parts: [{ text: systemText }] };
+    }
+    if (request.tools && request.tools.length > 0) {
+      transformed.tools = [
+        {
+          functionDeclarations: request.tools.map((tool) => ({
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters || { type: "object" }
+          }))
+        }
+      ];
+    }
+    return transformed;
+  }
+  /**
+   * Transform messages to Gemini format
+   */
+  transformMessages(messages) {
+    const contents = [];
+    for (const message of messages) {
+      if (message.role === "system") continue;
+      const role = message.role === "assistant" ? "model" : "user";
+      const parts = [];
+      if (message.content) {
+        parts.push({
+          text: typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+        });
+      }
+      if (message.tool_calls) {
+        for (const toolCall of message.tool_calls) {
+          parts.push({
+            functionCall: {
+              name: toolCall.function.name,
+              args: JSON.parse(toolCall.function.arguments)
+            }
+          });
+        }
+      }
+      if (message.role === "tool" && message.tool_call_id) {
+        parts.push({
+          functionResponse: {
+            name: message.name || "tool_result",
+            response: {
+              result: typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+            }
+          }
+        });
+      }
+      if (parts.length > 0) {
+        contents.push({ role, parts });
+      }
+    }
+    return contents;
+  }
+  /**
+   * Transform Gemini response to OpenAI-compatible format
+   */
+  transformFromGemini(data, model) {
+    const candidates = data.candidates;
+    const candidate = candidates?.[0];
+    if (!candidate) {
+      throw new ProviderError("No response candidates", "google");
+    }
+    const content = candidate.content;
+    const parts = content?.parts || [];
+    let textContent = "";
+    const toolCalls = [];
+    for (const part of parts) {
+      if (part.text) {
+        textContent += part.text;
+      }
+      if (part.functionCall) {
+        const fc = part.functionCall;
+        toolCalls.push({
+          id: `call_${Math.random().toString(36).substring(2, 11)}`,
+          type: "function",
+          function: {
+            name: fc.name,
+            arguments: JSON.stringify(fc.args)
+          }
+        });
+      }
+    }
+    const message = {
+      role: "assistant",
+      content: textContent || null
+    };
+    if (toolCalls.length > 0) {
+      message.tool_calls = toolCalls;
+    }
+    const finishReason = candidate.finishReason;
+    let mappedReason = null;
+    if (finishReason === "STOP") {
+      mappedReason = "stop";
+    } else if (finishReason === "MAX_TOKENS") {
+      mappedReason = "length";
+    } else if (toolCalls.length > 0) {
+      mappedReason = "tool_calls";
+    }
+    const usageMetadata = data.usageMetadata;
+    const usage = {
+      prompt_tokens: usageMetadata?.promptTokenCount || 0,
+      completion_tokens: usageMetadata?.candidatesTokenCount || 0,
+      total_tokens: usageMetadata?.totalTokenCount || 0
+    };
+    return {
+      id: generateRequestId(),
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1e3),
+      model,
+      choices: [
+        {
+          index: 0,
+          message,
+          finish_reason: mappedReason
+        }
+      ],
+      usage
+    };
+  }
+  /**
+   * Transform Gemini stream chunk to OpenAI-compatible format
+   */
+  transformStreamChunk(data, model, requestId) {
+    const candidates = data.candidates;
+    const candidate = candidates?.[0];
+    if (!candidate) {
+      return null;
+    }
+    const content = candidate.content;
+    const parts = content?.parts || [];
+    let textContent = "";
+    for (const part of parts) {
+      if (part.text) {
+        textContent += part.text;
+      }
+    }
+    if (!textContent) {
+      return null;
+    }
+    return {
+      id: requestId,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1e3),
+      model,
+      choices: [
+        {
+          index: 0,
+          delta: {
+            content: textContent
+          },
+          finish_reason: null
+        }
+      ]
+    };
+  }
+  /**
+   * Parse error response from Google
+   */
+  async parseError(response) {
+    let message = `Google API error: ${response.status}`;
+    const retryable = response.status >= 500 || response.status === 429;
+    try {
+      const data = await response.json();
+      if (data.error?.message) {
+        message = data.error.message;
+      }
+    } catch {
+    }
+    return new ProviderError(message, "google", void 0, retryable);
+  }
+  /**
+   * Wrap unknown errors
+   */
+  wrapError(error) {
+    if (error instanceof ProviderError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const isTimeout = error.name === "AbortError" || error.message.includes("timeout");
+      return new ProviderError(error.message, "google", error, isTimeout);
+    }
+    return new ProviderError("Unknown error", "google", void 0, true);
+  }
+};
+var Gateway = class extends events.EventEmitter {
+  _config;
+  registry;
+  router;
+  healthMonitor;
+  cache;
+  logger;
+  metrics;
+  /**
+   * Chat completions API interface (OpenAI-compatible)
+   */
+  chat = {
+    completions: {
+      create: this.createCompletion.bind(this)
+    }
+  };
+  constructor(config) {
+    super();
+    this._config = config;
+    this.logger = pino__default.default({
+      level: config.telemetry?.logging?.level || "info",
+      transport: process.env.NODE_ENV !== "production" ? { target: "pino-pretty" } : void 0
+    });
+    this.registry = new ProviderRegistry();
+    for (const providerConfig of config.providers) {
+      const provider = this.createProvider(providerConfig);
+      if (provider) {
+        this.registry.register(provider);
+      }
+    }
+    this.router = this.createRouter(config);
+    this.healthMonitor = new HealthMonitor({
+      checkInterval: 6e4,
+      unhealthyThreshold: 3,
+      degradedThreshold: 1,
+      circuitBreaker: {
+        failureThreshold: 5,
+        successThreshold: 3,
+        timeout: 3e4
+      }
+    });
+    if (config.cache?.enabled) {
+      this.cache = new lruCache.LRUCache({
+        max: config.cache.maxEntries || 1e3,
+        ttl: (config.cache.ttl || 3600) * 1e3
+      });
+    } else {
+      this.cache = null;
+    }
+    this.metrics = this.createInitialMetrics();
+    this.healthMonitor.on("unhealthy", (provider) => {
+      this.logger.warn({ provider }, "Provider marked unhealthy");
+      this.emit("provider:unhealthy", provider);
+    });
+    this.healthMonitor.on("circuit-open", (provider) => {
+      this.logger.warn({ provider }, "Circuit breaker opened");
+    });
+  }
+  /**
+   * Create a chat completion (main API)
+   */
+  async createCompletion(request) {
+    this.validateRequest(request);
+    if (request.stream) {
+      return this.createStreamingCompletion(request);
+    }
+    return this.createNonStreamingCompletion(request);
+  }
+  /**
+   * Non-streaming completion
+   */
+  async createNonStreamingCompletion(request) {
+    const requestId = request._gateway?.requestId || generateRequestId();
+    const start = Date.now();
+    this.emit("request:start", {
+      requestId,
+      model: request.model
+    });
+    try {
+      if (this.cache && request._gateway?.cachePolicy !== "no-cache") {
+        const cacheKey = hashRequest(request);
+        const cached = this.cache.get(cacheKey);
+        if (cached) {
+          this.metrics.cache.hits++;
+          this.updateCacheHitRate();
+          this.logger.debug({ requestId, cacheKey }, "Cache hit");
+          const response = {
+            ...cached,
+            _gateway: {
+              ...cached._gateway,
+              cached: true,
+              cacheKey,
+              latencyMs: Date.now() - start
+            }
+          };
+          this.emit("request:complete", {
+            requestId,
+            provider: cached._gateway?.provider || "cache",
+            model: cached.model,
+            latencyMs: Date.now() - start,
+            cost: 0,
+            cached: true,
+            tokens: { input: 0, output: 0 }
+          });
+          return response;
+        }
+        this.metrics.cache.misses++;
+      }
+      const routingContext = {
+        excludeProviders: request._gateway?.excludeProviders,
+        preferredProvider: request._gateway?.preferredProvider,
+        maxCost: request._gateway?.maxCost,
+        maxLatency: request._gateway?.maxLatency
+      };
+      let lastError = null;
+      let attempts = 0;
+      const maxAttempts = 3;
+      while (attempts < maxAttempts) {
+        attempts++;
+        const decision = this.router.route(request, this.registry, {
+          ...routingContext,
+          previousAttempts: attempts > 1 ? [{ provider: "", model: "", error: lastError?.message }] : void 0
+        });
+        const provider = this.registry.get(decision.provider);
+        if (!provider) {
+          lastError = new GatewayError(
+            `Provider not found: ${decision.provider}`,
+            "PROVIDER_NOT_FOUND",
+            500
+          );
+          continue;
+        }
+        if (!this.healthMonitor.isRequestAllowed(decision.provider)) {
+          this.logger.debug(
+            { provider: decision.provider },
+            "Circuit breaker open, skipping"
+          );
+          routingContext.excludeProviders = [
+            ...routingContext.excludeProviders || [],
+            decision.provider
+          ];
+          continue;
+        }
+        try {
+          const providerRequest = {
+            ...request,
+            model: decision.model
+          };
+          const providerStart = Date.now();
+          const response = await provider.chat(providerRequest);
+          const latencyMs = Date.now() - providerStart;
+          this.healthMonitor.recordRequest(decision.provider, true, latencyMs);
+          const cost = calculateCost(decision.model, response.usage);
+          this.updateMetrics(decision, response, latencyMs, cost);
+          const gatewayResponse = {
+            ...response,
+            _gateway: {
+              provider: decision.provider,
+              originalModel: request.model,
+              latencyMs,
+              cost,
+              cached: false,
+              retries: attempts - 1,
+              routingDecision: decision
+            }
+          };
+          if (this.cache && request._gateway?.cachePolicy !== "no-cache") {
+            const cacheKey = hashRequest(request);
+            this.cache.set(cacheKey, gatewayResponse);
+          }
+          this.emit("request:complete", {
+            requestId,
+            provider: decision.provider,
+            model: decision.model,
+            latencyMs: Date.now() - start,
+            cost,
+            cached: false,
+            tokens: {
+              input: response.usage.prompt_tokens,
+              output: response.usage.completion_tokens
+            }
+          });
+          return gatewayResponse;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          this.healthMonitor.recordRequest(
+            decision.provider,
+            false,
+            Date.now() - start
+          );
+          if (error instanceof ProviderError && !error.retryable) {
+            throw error;
+          }
+          this.logger.warn(
+            {
+              provider: decision.provider,
+              error: lastError.message,
+              attempt: attempts
+            },
+            "Request failed, retrying"
+          );
+          routingContext.excludeProviders = [
+            ...routingContext.excludeProviders || [],
+            decision.provider
+          ];
+        }
+      }
+      this.metrics.requests.failed++;
+      this.emit("request:error", { requestId, error: lastError });
+      throw lastError || new GatewayError("All attempts failed", "ALL_ATTEMPTS_FAILED", 502);
+    } catch (error) {
+      this.metrics.requests.failed++;
+      this.emit("request:error", {
+        requestId,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      throw error;
+    }
+  }
+  /**
+   * Streaming completion
+   */
+  async *createStreamingCompletion(request) {
+    const requestId = request._gateway?.requestId || generateRequestId();
+    const start = Date.now();
+    this.emit("request:start", { requestId, model: request.model });
+    const decision = this.router.route(request, this.registry, {
+      excludeProviders: request._gateway?.excludeProviders,
+      preferredProvider: request._gateway?.preferredProvider
+    });
+    const provider = this.registry.get(decision.provider);
+    if (!provider) {
+      throw new GatewayError(
+        `Provider not found: ${decision.provider}`,
+        "PROVIDER_NOT_FOUND",
+        500
+      );
+    }
+    const providerRequest = { ...request, model: decision.model };
+    try {
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      for await (const chunk of provider.chatStream(providerRequest)) {
+        if (chunk.usage) {
+          totalInputTokens = chunk.usage.prompt_tokens;
+          totalOutputTokens = chunk.usage.completion_tokens;
+        }
+        yield chunk;
+      }
+      const latencyMs = Date.now() - start;
+      const cost = calculateCost(decision.model, {
+        prompt_tokens: totalInputTokens,
+        completion_tokens: totalOutputTokens,
+        total_tokens: totalInputTokens + totalOutputTokens
+      });
+      this.healthMonitor.recordRequest(decision.provider, true, latencyMs);
+      this.emit("request:complete", {
+        requestId,
+        provider: decision.provider,
+        model: decision.model,
+        latencyMs,
+        cost,
+        cached: false,
+        tokens: { input: totalInputTokens, output: totalOutputTokens }
+      });
+    } catch (error) {
+      this.healthMonitor.recordRequest(
+        decision.provider,
+        false,
+        Date.now() - start
+      );
+      this.emit("request:error", {
+        requestId,
+        provider: decision.provider,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      throw error;
+    }
+  }
+  /**
+   * Validate a request
+   */
+  validateRequest(request) {
+    if (!request.model) {
+      throw new ValidationError("Model is required");
+    }
+    if (!request.messages || request.messages.length === 0) {
+      throw new ValidationError(
+        "Messages array is required and cannot be empty"
+      );
+    }
+    for (const message of request.messages) {
+      if (!message.role) {
+        throw new ValidationError("Message role is required");
+      }
+      if (!["system", "user", "assistant", "tool"].includes(message.role)) {
+        throw new ValidationError(`Invalid message role: ${message.role}`);
+      }
+    }
+  }
+  /**
+   * Create a provider instance from config
+   */
+  createProvider(config) {
+    switch (config.name) {
+      case "openai":
+        return new OpenAIProvider({
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          models: config.models,
+          timeout: config.timeout
+        });
+      case "anthropic":
+        return new AnthropicProvider({
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          models: config.models,
+          timeout: config.timeout
+        });
+      case "google":
+        return new GoogleProvider({
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          models: config.models,
+          timeout: config.timeout
+        });
+      default:
+        this.logger.warn({ provider: config.name }, "Unknown provider type");
+        return null;
+    }
+  }
+  /**
+   * Create router from config
+   */
+  createRouter(config) {
+    const strategyName = config.routing?.strategy || "round-robin";
+    let strategy;
+    switch (strategyName) {
+      case "failover":
+        strategy = new FailoverStrategy({
+          chain: config.routing?.fallbackChain || [
+            "openai",
+            "anthropic",
+            "google"
+          ]
+        });
+        break;
+      case "cost-optimized":
+        strategy = new CostOptimizedStrategy();
+        break;
+      case "latency-optimized":
+        strategy = new LatencyOptimizedStrategy();
+        break;
+      case "round-robin":
+      default:
+        strategy = new RoundRobinStrategy({
+          weights: config.routing?.weights
+        });
+        break;
+    }
+    return new Router(strategy, {
+      fallbackChain: config.routing?.fallbackChain
+    });
+  }
+  /**
+   * Create initial metrics object
+   */
+  createInitialMetrics() {
+    return {
+      requests: { total: 0, successful: 0, failed: 0, cached: 0 },
+      latency: { avg: 0, p50: 0, p95: 0, p99: 0 },
+      tokens: { input: 0, output: 0, total: 0 },
+      cost: { total: 0, byProvider: {}, byModel: {} },
+      cache: { hits: 0, misses: 0, hitRate: 0 },
+      providers: {}
+    };
+  }
+  /**
+   * Update metrics after a request
+   */
+  updateMetrics(decision, response, latencyMs, cost) {
+    this.metrics.requests.total++;
+    this.metrics.requests.successful++;
+    this.metrics.latency.avg = (this.metrics.latency.avg * (this.metrics.requests.successful - 1) + latencyMs) / this.metrics.requests.successful;
+    this.metrics.tokens.input += response.usage.prompt_tokens;
+    this.metrics.tokens.output += response.usage.completion_tokens;
+    this.metrics.tokens.total += response.usage.total_tokens;
+    this.metrics.cost.total += cost;
+    this.metrics.cost.byProvider[decision.provider] = (this.metrics.cost.byProvider[decision.provider] || 0) + cost;
+    this.metrics.cost.byModel[decision.model] = (this.metrics.cost.byModel[decision.model] || 0) + cost;
+    this.updateCacheHitRate();
+    this.metrics.providers = this.registry.getHealthStatus();
+  }
+  /**
+   * Update cache hit rate metric
+   */
+  updateCacheHitRate() {
+    const totalCacheOps = this.metrics.cache.hits + this.metrics.cache.misses;
+    this.metrics.cache.hitRate = totalCacheOps > 0 ? this.metrics.cache.hits / totalCacheOps : 0;
+  }
+  /**
+   * Get current metrics
+   */
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  /**
+   * Get gateway configuration
+   */
+  getConfig() {
+    return { ...this._config };
+  }
+  /**
+   * Get provider registry
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Get router
+   */
+  getRouter() {
+    return this.router;
+  }
+  /**
+   * Check health of all providers
+   */
+  async checkHealth() {
+    const healthStatus = await this.registry.checkHealth();
+    const result = {};
+    for (const [name, health] of Object.entries(healthStatus)) {
+      result[name] = health.status === "healthy";
+    }
+    return result;
+  }
+  /**
+   * Shut down the gateway
+   */
+  shutdown() {
+    this.registry.stopHealthChecks();
+    this.cache?.clear();
+    this.logger.info("Gateway shut down");
+  }
+};
+function createHTTPServer(options) {
+  const { gateway, basePath = "" } = options;
+  const app = new hono.Hono();
+  app.use("*", logger.logger());
+  if (options.cors) {
+    app.use(
+      "*",
+      cors.cors({
+        origin: options.cors.origin || "*",
+        allowMethods: options.cors.methods || ["GET", "POST", "OPTIONS"],
+        allowHeaders: options.cors.headers || [
+          "Content-Type",
+          "Authorization",
+          "X-Request-Id"
+        ]
+      })
+    );
+  }
+  app.get(`${basePath}/health`, async (c) => {
+    const health = await gateway.checkHealth();
+    const allHealthy = Object.values(health).every((h) => h);
+    return c.json(
+      {
+        status: allHealthy ? "healthy" : "degraded",
+        providers: health,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      allHealthy ? 200 : 503
+    );
+  });
+  app.get(`${basePath}/metrics`, (c) => {
+    const metrics = gateway.getMetrics();
+    return c.json(metrics);
+  });
+  app.get(`${basePath}/v1/models`, (c) => {
+    const registry = gateway.getRegistry();
+    const models = registry.getAllModels();
+    const data = models.map((model) => {
+      const modelInfo = registry.getModelInfo(model);
+      return {
+        id: model,
+        object: "model",
+        created: Math.floor(Date.now() / 1e3),
+        owned_by: modelInfo?.provider || "unknown"
+      };
+    });
+    return c.json({
+      object: "list",
+      data
+    });
+  });
+  app.post(`${basePath}/v1/chat/completions`, async (c) => {
+    try {
+      const body = await c.req.json();
+      const requestId = c.req.header("X-Request-Id");
+      if (requestId) {
+        body._gateway = { ...body._gateway, requestId };
+      }
+      if (body.stream) {
+        return streaming.streamSSE(c, async (stream) => {
+          try {
+            const generator = await gateway.chat.completions.create(
+              body
+            );
+            for await (const chunk of generator) {
+              await stream.writeSSE({
+                data: JSON.stringify(chunk)
+              });
+            }
+            await stream.writeSSE({ data: "[DONE]" });
+          } catch (error) {
+            const errorResponse = formatError(error);
+            await stream.writeSSE({
+              data: JSON.stringify({ error: errorResponse })
+            });
+          }
+        });
+      }
+      const response = await gateway.chat.completions.create(
+        body
+      );
+      return c.json(response);
+    } catch (error) {
+      const { status, body } = formatError(error);
+      return c.json(body, status);
+    }
+  });
+  app.post(`${basePath}/v1/completions`, (c) => {
+    return c.json(
+      {
+        error: {
+          message: "The completions endpoint is deprecated. Please use /v1/chat/completions instead.",
+          type: "invalid_request_error",
+          code: "deprecated_endpoint"
+        }
+      },
+      400
+    );
+  });
+  app.all("*", (c) => {
+    return c.json(
+      {
+        error: {
+          message: `Unknown endpoint: ${c.req.method} ${c.req.path}`,
+          type: "invalid_request_error",
+          code: "unknown_endpoint"
+        }
+      },
+      404
+    );
+  });
+  return app;
+}
+function startServer(app, options) {
+  const port = options.port || 3e3;
+  const host = options.host || "0.0.0.0";
+  const server = nodeServer.serve({
+    fetch: app.fetch,
+    port,
+    hostname: host
+  });
+  console.log(`Gateway server running on http://${host}:${port}`);
+  return server;
+}
+function formatError(error) {
+  if (error instanceof ValidationError) {
+    return {
+      status: 400,
+      body: {
+        error: {
+          message: error.message,
+          type: "invalid_request_error",
+          code: error.code
+        }
+      }
+    };
+  }
+  if (error instanceof GatewayError) {
+    return {
+      status: error.statusCode,
+      body: {
+        error: {
+          message: error.message,
+          type: "gateway_error",
+          code: error.code
+        }
+      }
+    };
+  }
+  if (error instanceof Error) {
+    if ("name" in error && error.name === "ValidationError" && "code" in error) {
+      return {
+        status: 400,
+        body: {
+          error: {
+            message: error.message,
+            type: "invalid_request_error",
+            code: error.code
+          }
+        }
+      };
+    }
+    if ("name" in error && error.name === "GatewayError" && "statusCode" in error && "code" in error) {
+      return {
+        status: error.statusCode,
+        body: {
+          error: {
+            message: error.message,
+            type: "gateway_error",
+            code: error.code
+          }
+        }
+      };
+    }
+    return {
+      status: 500,
+      body: {
+        error: {
+          message: error.message,
+          type: "internal_error",
+          code: "internal_error"
+        }
+      }
+    };
+  }
+  return {
+    status: 500,
+    body: {
+      error: {
+        message: "An unknown error occurred",
+        type: "internal_error",
+        code: "unknown_error"
+      }
+    }
+  };
+}
+
+// src/telemetry/Metrics.ts
+var MetricsCollector = class {
+  prefix;
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  latencyBuckets;
+  tokenBuckets;
+  constructor(config = {}) {
+    this.prefix = config.prefix || "agentsea_gateway";
+    this.latencyBuckets = config.histogramBuckets?.latency || [
+      50,
+      100,
+      250,
+      500,
+      1e3,
+      2500,
+      5e3,
+      1e4
+    ];
+    this.tokenBuckets = config.histogramBuckets?.tokens || [
+      100,
+      500,
+      1e3,
+      2e3,
+      5e3,
+      1e4,
+      5e4
+    ];
+  }
+  /**
+   * Get token histogram buckets
+   */
+  getTokenBuckets() {
+    return [...this.tokenBuckets];
+  }
+  /**
+   * Increment a counter
+   */
+  incrementCounter(name, value = 1, labels) {
+    const key = this.formatKey(name, labels);
+    const current = this.counters.get(key) || 0;
+    this.counters.set(key, current + value);
+  }
+  /**
+   * Set a gauge value
+   */
+  setGauge(name, value, labels) {
+    const key = this.formatKey(name, labels);
+    this.gauges.set(key, value);
+  }
+  /**
+   * Record a histogram observation
+   */
+  recordHistogram(name, value, labels, buckets) {
+    const key = this.formatKey(name, labels);
+    let histogram = this.histograms.get(key);
+    if (!histogram) {
+      histogram = {
+        count: 0,
+        sum: 0,
+        buckets: /* @__PURE__ */ new Map()
+      };
+      const bucketsToUse = buckets || this.latencyBuckets;
+      for (const bucket of bucketsToUse) {
+        histogram.buckets.set(bucket, 0);
+      }
+      histogram.buckets.set(Infinity, 0);
+      this.histograms.set(key, histogram);
+    }
+    histogram.count++;
+    histogram.sum += value;
+    for (const [bucket, count] of histogram.buckets) {
+      if (value <= bucket) {
+        histogram.buckets.set(bucket, count + 1);
+      }
+    }
+  }
+  /**
+   * Record request metrics
+   */
+  recordRequest(data) {
+    const labels = { provider: data.provider, model: data.model };
+    this.incrementCounter("requests_total", 1, {
+      ...labels,
+      status: data.status,
+      cached: String(data.cached)
+    });
+    this.recordHistogram("request_latency_ms", data.latencyMs, labels);
+    this.incrementCounter("tokens_input_total", data.inputTokens, labels);
+    this.incrementCounter("tokens_output_total", data.outputTokens, labels);
+    this.incrementCounter(
+      "cost_microdollars_total",
+      Math.round(data.cost * 1e6),
+      labels
+    );
+    if (data.cached) {
+      this.incrementCounter("cache_hits_total", 1);
+    }
+  }
+  /**
+   * Get counter value
+   */
+  getCounter(name, labels) {
+    const key = this.formatKey(name, labels);
+    return this.counters.get(key) || 0;
+  }
+  /**
+   * Get gauge value
+   */
+  getGauge(name, labels) {
+    const key = this.formatKey(name, labels);
+    return this.gauges.get(key) || 0;
+  }
+  /**
+   * Get histogram data
+   */
+  getHistogram(name, labels) {
+    const key = this.formatKey(name, labels);
+    return this.histograms.get(key);
+  }
+  /**
+   * Get all metrics as a summary object
+   */
+  getSummary() {
+    const requestsTotal = this.sumAllCounters("requests_total");
+    const requestsSuccess = this.sumCountersByLabel(
+      "requests_total",
+      "status",
+      "success"
+    );
+    const requestsError = this.sumCountersByLabel(
+      "requests_total",
+      "status",
+      "error"
+    );
+    const requestsCached = this.sumCountersByLabel(
+      "requests_total",
+      "cached",
+      "true"
+    );
+    const latencyHistogram = this.aggregateHistograms("request_latency_ms");
+    const avgLatency = latencyHistogram.count > 0 ? latencyHistogram.sum / latencyHistogram.count : 0;
+    const inputTokens = this.sumAllCounters("tokens_input_total");
+    const outputTokens = this.sumAllCounters("tokens_output_total");
+    const totalCostMicro = this.sumAllCounters("cost_microdollars_total");
+    const cacheHits = this.getCounter("cache_hits_total");
+    const cacheMisses = requestsTotal - cacheHits;
+    return {
+      requests: {
+        total: requestsTotal,
+        successful: requestsSuccess,
+        failed: requestsError,
+        cached: requestsCached
+      },
+      latency: {
+        avg: avgLatency,
+        p50: this.calculatePercentile("request_latency_ms", 0.5),
+        p95: this.calculatePercentile("request_latency_ms", 0.95),
+        p99: this.calculatePercentile("request_latency_ms", 0.99)
+      },
+      tokens: {
+        input: inputTokens,
+        output: outputTokens,
+        total: inputTokens + outputTokens
+      },
+      cost: {
+        total: totalCostMicro / 1e6,
+        byProvider: this.getCostByLabel("provider"),
+        byModel: this.getCostByLabel("model")
+      },
+      cache: {
+        hits: cacheHits,
+        misses: cacheMisses,
+        hitRate: requestsTotal > 0 ? cacheHits / requestsTotal : 0
+      },
+      providers: {}
+    };
+  }
+  /**
+   * Export metrics in Prometheus format
+   */
+  toPrometheusFormat() {
+    const lines = [];
+    for (const [key, value] of this.counters) {
+      lines.push(`${this.prefix}_${key} ${value}`);
+    }
+    for (const [key, value] of this.gauges) {
+      lines.push(`${this.prefix}_${key} ${value}`);
+    }
+    for (const [key, histogram] of this.histograms) {
+      for (const [bucket, count] of histogram.buckets) {
+        const le = bucket === Infinity ? "+Inf" : bucket;
+        lines.push(`${this.prefix}_${key}_bucket{le="${le}"} ${count}`);
+      }
+      lines.push(`${this.prefix}_${key}_sum ${histogram.sum}`);
+      lines.push(`${this.prefix}_${key}_count ${histogram.count}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Reset all metrics
+   */
+  reset() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+  }
+  /**
+   * Format metric key with labels
+   */
+  formatKey(name, labels) {
+    if (!labels || Object.keys(labels).length === 0) {
+      return name;
+    }
+    const labelStr = Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}="${v}"`).join(",");
+    return `${name}{${labelStr}}`;
+  }
+  /**
+   * Sum counters by a specific label value
+   */
+  sumCountersByLabel(name, labelKey, labelValue) {
+    let sum = 0;
+    for (const [key, value] of this.counters) {
+      if (key.startsWith(name) && key.includes(`${labelKey}="${labelValue}"`)) {
+        sum += value;
+      }
+    }
+    return sum;
+  }
+  /**
+   * Sum all counters with a given name prefix
+   */
+  sumAllCounters(namePrefix) {
+    let sum = 0;
+    for (const [key, value] of this.counters) {
+      if (key.startsWith(namePrefix)) {
+        sum += value;
+      }
+    }
+    return sum;
+  }
+  /**
+   * Get cost breakdown by label
+   */
+  getCostByLabel(labelKey) {
+    const result = {};
+    const prefix = "cost_microdollars_total";
+    for (const [key, value] of this.counters) {
+      if (key.startsWith(prefix)) {
+        const match = key.match(new RegExp(`${labelKey}="([^"]+)"`));
+        if (match) {
+          const labelValue = match[1];
+          result[labelValue] = (result[labelValue] || 0) + value / 1e6;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Aggregate histograms for a metric name
+   */
+  aggregateHistograms(name) {
+    const result = {
+      count: 0,
+      sum: 0,
+      buckets: /* @__PURE__ */ new Map()
+    };
+    for (const [key, histogram] of this.histograms) {
+      if (key.startsWith(name)) {
+        result.count += histogram.count;
+        result.sum += histogram.sum;
+        for (const [bucket, count] of histogram.buckets) {
+          const existing = result.buckets.get(bucket) || 0;
+          result.buckets.set(bucket, existing + count);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Calculate percentile from histogram (approximate)
+   */
+  calculatePercentile(name, percentile) {
+    const histogram = this.aggregateHistograms(name);
+    if (histogram.count === 0) return 0;
+    const sortedBuckets = Array.from(histogram.buckets.entries()).sort(
+      ([a], [b]) => a - b
+    );
+    const targetCount = histogram.count * percentile;
+    let prevBucket = 0;
+    let prevCount = 0;
+    for (const [bucket, count] of sortedBuckets) {
+      if (count >= targetCount) {
+        const bucketRange = bucket - prevBucket;
+        const bucketCount = count - prevCount;
+        if (bucketCount === 0) {
+          return prevBucket;
+        }
+        const positionInBucket = targetCount - prevCount;
+        const fraction = positionInBucket / bucketCount;
+        return prevBucket + bucketRange * Math.max(0, Math.min(1, fraction));
+      }
+      prevBucket = bucket;
+      prevCount = count;
+    }
+    return prevBucket;
+  }
+};
+
+exports.AnthropicProvider = AnthropicProvider;
+exports.AuthenticationError = AuthenticationError;
+exports.CircuitBreaker = CircuitBreaker;
+exports.CostOptimizedStrategy = CostOptimizedStrategy;
+exports.DEFAULT_MODEL_MAPPINGS = DEFAULT_MODEL_MAPPINGS;
+exports.FailoverStrategy = FailoverStrategy;
+exports.Gateway = Gateway;
+exports.GatewayError = GatewayError;
+exports.GoogleProvider = GoogleProvider;
+exports.HealthMonitor = HealthMonitor;
+exports.LatencyOptimizedStrategy = LatencyOptimizedStrategy;
+exports.MODEL_CONTEXT_WINDOWS = MODEL_CONTEXT_WINDOWS;
+exports.MODEL_MAX_OUTPUT = MODEL_MAX_OUTPUT;
+exports.MODEL_PRICING = MODEL_PRICING;
+exports.MetricsCollector = MetricsCollector;
+exports.OpenAIProvider = OpenAIProvider;
+exports.Provider = Provider;
+exports.ProviderError = ProviderError;
+exports.ProviderRegistry = ProviderRegistry;
+exports.RateLimitError = RateLimitError;
+exports.RoundRobinStrategy = RoundRobinStrategy;
+exports.Router = Router;
+exports.VIRTUAL_MODELS = VIRTUAL_MODELS;
+exports.ValidationError = ValidationError;
+exports.calculateCost = calculateCost;
+exports.countMessageTokens = countMessageTokens;
+exports.countTokens = countTokens;
+exports.createHTTPServer = createHTTPServer;
+exports.createRouterConfig = createRouterConfig;
+exports.createSystemFingerprint = createSystemFingerprint;
+exports.estimateCost = estimateCost;
+exports.estimateRequestTokens = estimateRequestTokens;
+exports.findCheapestModel = findCheapestModel;
+exports.freeEncoder = freeEncoder;
+exports.generateCacheKey = generateCacheKey;
+exports.generateId = generateId;
+exports.generateRequestId = generateRequestId;
+exports.getModelCapabilities = getModelCapabilities;
+exports.getModelInfo = getModelInfo;
+exports.getModelPricing = getModelPricing;
+exports.hash = hash;
+exports.hashRequest = hashRequest;
+exports.sortModelsByCost = sortModelsByCost;
+exports.startServer = startServer;
+exports.truncateToTokenLimit = truncateToTokenLimit;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map