@certalis/agent-smith 0.0.0-stage → 0.1.1

package/dist/post-processor.worker.js

@@ -0,0 +1,4945 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// ../../packages/core/src/constants.ts
+var TIME_CONSTANTS, BUFFER_SIZES, NETWORK, CACHE, LIMITS, HTTP_STATUS;
+var init_constants = __esm(() => {
+  TIME_CONSTANTS = {
+    SECOND: 1000,
+    MINUTE: 60 * 1000,
+    HOUR: 60 * 60 * 1000,
+    DAY: 24 * 60 * 60 * 1000,
+    SESSION_DURATION_DEFAULT: 5 * 60 * 60 * 1000,
+    SESSION_DURATION_FALLBACK: 3600000,
+    STREAM_TIMEOUT_DEFAULT: 1000 * 60 * 1,
+    OAUTH_STATE_TTL: 10,
+    RETRY_DELAY_DEFAULT: 1000,
+    CACHE_YEAR: 31536000
+  };
+  BUFFER_SIZES = {
+    STREAM_USAGE_BUFFER_KB: 256,
+    STREAM_USAGE_BUFFER_BYTES: 256 * 1024,
+    STREAM_BODY_MAX_KB: 256,
+    STREAM_BODY_MAX_BYTES: 256 * 1024,
+    ANTHROPIC_STREAM_CAP_BYTES: 32768,
+    STREAM_TEE_MAX_BYTES: 1024 * 1024,
+    LOG_FILE_MAX_SIZE: 10 * 1024 * 1024
+  };
+  NETWORK = {
+    DEFAULT_PORT: 8080,
+    IDLE_TIMEOUT_MAX: 255
+  };
+  CACHE = {
+    STATIC_ASSETS_MAX_AGE: 31536000,
+    CACHE_CONTROL_IMMUTABLE: "public, max-age=31536000, immutable",
+    CACHE_CONTROL_STATIC: "public, max-age=31536000",
+    CACHE_CONTROL_NO_CACHE: "no-cache, no-store, must-revalidate"
+  };
+  LIMITS = {
+    REQUEST_HISTORY_DEFAULT: 50,
+    REQUEST_DETAILS_DEFAULT: 100,
+    REQUEST_HISTORY_MAX: 1000,
+    LOG_READ_DEFAULT: 1000,
+    ACCOUNT_NAME_MIN_LENGTH: 1,
+    ACCOUNT_NAME_MAX_LENGTH: 100,
+    CONSOLE_SEPARATOR_LENGTH: 100,
+    CONSOLE_COLUMN_PADDING: {
+      NAME: 20,
+      TYPE: 10,
+      TIER: 6,
+      REQUESTS: 12,
+      TOKEN: 10,
+      STATUS: 20
+    }
+  };
+  HTTP_STATUS = {
+    OK: 200,
+    NOT_FOUND: 404,
+    TOO_MANY_REQUESTS: 429,
+    INTERNAL_SERVER_ERROR: 500,
+    SERVICE_UNAVAILABLE: 503
+  };
+});
+
+// ../../packages/core/src/container.ts
+class Container {
+  services = new Map;
+  factories = new Map;
+  register(key, factory) {
+    this.factories.set(key, factory);
+  }
+  registerInstance(key, instance) {
+    this.services.set(key, instance);
+  }
+  resolve(key) {
+    if (this.services.has(key)) {
+      return this.services.get(key);
+    }
+    const factory = this.factories.get(key);
+    if (!factory) {
+      throw new Error(`Service '${String(key)}' not registered`);
+    }
+    const instance = factory();
+    this.services.set(key, instance);
+    return instance;
+  }
+  has(key) {
+    return this.factories.has(key) || this.services.has(key);
+  }
+  clear() {
+    this.services.clear();
+    this.factories.clear();
+  }
+}
+var container;
+var init_container = __esm(() => {
+  container = new Container;
+});
+
+// ../../packages/core/src/di.ts
+var SERVICE_KEYS;
+var init_di = __esm(() => {
+  init_container();
+  SERVICE_KEYS = {
+    Logger: Symbol("Logger"),
+    Config: Symbol("Config"),
+    Database: Symbol("Database"),
+    PricingLogger: Symbol("PricingLogger"),
+    AsyncWriter: Symbol("AsyncWriter")
+  };
+});
+
+// ../../packages/core/src/errors.ts
+function isAppError(error) {
+  return error instanceof AppError;
+}
+function logError(error, logger) {
+  if (isAppError(error)) {
+    const sanitizedContext = error.context ? sanitizeErrorContext(error.context) : undefined;
+    logger.error(`${error.name}: ${error.message}`, {
+      code: error.code,
+      statusCode: error.statusCode,
+      context: sanitizedContext
+    });
+  } else if (error instanceof Error) {
+    logger.error(`Error: ${error.message}`, {
+      name: error.name,
+      stack: error.stack
+    });
+  } else {
+    logger.error("Unknown error", error);
+  }
+}
+function sanitizeErrorContext(context) {
+  const sanitized = {};
+  const sensitiveKeys = ["token", "password", "secret", "key", "authorization"];
+  for (const [key, value] of Object.entries(context)) {
+    const lowerKey = key.toLowerCase();
+    if (sensitiveKeys.some((sensitive) => lowerKey.includes(sensitive))) {
+      sanitized[key] = "[REDACTED]";
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitizeErrorContext(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+var AppError, AuthError, TokenRefreshError, RateLimitError, ValidationError, ProviderError, OAuthError, ServiceUnavailableError;
+var init_errors = __esm(() => {
+  AppError = class AppError extends Error {
+    code;
+    statusCode;
+    timestamp;
+    context;
+    constructor(message, code, statusCode, context) {
+      super(message);
+      this.code = code;
+      this.statusCode = statusCode;
+      this.name = this.constructor.name;
+      this.timestamp = new Date;
+      this.context = context;
+      Error.captureStackTrace(this, this.constructor);
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        message: this.message,
+        code: this.code,
+        statusCode: this.statusCode,
+        timestamp: this.timestamp,
+        context: this.context
+      };
+    }
+  };
+  AuthError = class AuthError extends AppError {
+    constructor(message, context) {
+      super(message, "AUTH_ERROR", 401, context);
+    }
+  };
+  TokenRefreshError = class TokenRefreshError extends AuthError {
+    originalError;
+    constructor(accountId, originalError) {
+      super("Failed to refresh access token", {
+        accountId,
+        originalError: originalError?.message
+      });
+      this.originalError = originalError;
+    }
+  };
+  RateLimitError = class RateLimitError extends AppError {
+    accountId;
+    resetTime;
+    remaining;
+    constructor(accountId, resetTime, remaining) {
+      super("Rate limit exceeded", "RATE_LIMIT_ERROR", 429, {
+        accountId,
+        resetTime,
+        remaining
+      });
+      this.accountId = accountId;
+      this.resetTime = resetTime;
+      this.remaining = remaining;
+    }
+  };
+  ValidationError = class ValidationError extends AppError {
+    field;
+    value;
+    constructor(message, field, value) {
+      super(message, "VALIDATION_ERROR", 400, { field, value });
+      this.field = field;
+      this.value = value;
+    }
+  };
+  ProviderError = class ProviderError extends AppError {
+    provider;
+    constructor(message, provider, statusCode = 502, context) {
+      super(message, "PROVIDER_ERROR", statusCode, { provider, ...context });
+      this.provider = provider;
+    }
+  };
+  OAuthError = class OAuthError extends ProviderError {
+    oauthCode;
+    constructor(message, provider, oauthCode) {
+      super(message, provider, 400, { oauthCode });
+      this.oauthCode = oauthCode;
+    }
+  };
+  ServiceUnavailableError = class ServiceUnavailableError extends AppError {
+    service;
+    constructor(message, service) {
+      super(message, "SERVICE_UNAVAILABLE", 503, { service });
+      this.service = service;
+    }
+  };
+});
+
+// ../../packages/core/src/formatters.ts
+function formatCost(cost) {
+  if (!cost || cost === 0)
+    return "$0.0000";
+  return `$${cost.toFixed(4)}`;
+}
+
+// ../../packages/core/src/lifecycle.ts
+class LifecycleManager {
+  disposables = new Set;
+  isShuttingDown = false;
+  register(disposable) {
+    this.disposables.add(disposable);
+  }
+  unregister(disposable) {
+    this.disposables.delete(disposable);
+  }
+  async shutdown() {
+    if (this.isShuttingDown) {
+      return;
+    }
+    this.isShuttingDown = true;
+    const errors = [];
+    const disposableArray = Array.from(this.disposables).reverse();
+    for (const disposable of disposableArray) {
+      try {
+        await disposable.dispose();
+      } catch (error) {
+        errors.push(error instanceof Error ? error : new Error(`Disposal error: ${String(error)}`));
+      }
+    }
+    this.disposables.clear();
+    this.isShuttingDown = false;
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "Errors occurred during shutdown");
+    }
+  }
+}
+function registerDisposable(disposable) {
+  lifecycleManager.register(disposable);
+}
+function unregisterDisposable(disposable) {
+  lifecycleManager.unregister(disposable);
+}
+async function shutdown() {
+  await lifecycleManager.shutdown();
+}
+var lifecycleManager;
+var init_lifecycle = __esm(() => {
+  lifecycleManager = new LifecycleManager;
+});
+
+// ../../packages/core/src/models.ts
+function normalizeModelId(modelId) {
+  return modelId.trim().replace(PROVIDER_PREFIX_RE, "").replace(LATEST_SUFFIX_RE, "").replace(DATE_SUFFIX_RE, "");
+}
+function getModelShortName(modelId) {
+  const normalized = normalizeModelId(modelId);
+  return normalized || modelId;
+}
+var PROVIDER_PREFIX_RE, DATE_SUFFIX_RE, LATEST_SUFFIX_RE;
+var init_models = __esm(() => {
+  PROVIDER_PREFIX_RE = /^(anthropic|openai|codex|claude-code|google|xai|zai)\//;
+  DATE_SUFFIX_RE = /-\d{8}$/;
+  LATEST_SUFFIX_RE = /-latest$/;
+});
+
+// ../../packages/core/src/pricing.ts
+import { promises as fs } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+class PriceCatalogue {
+  static instance;
+  priceData = null;
+  lastFetch = 0;
+  warnedModels = new Set;
+  logger = null;
+  constructor() {}
+  setLogger(logger) {
+    this.logger = logger;
+  }
+  static get() {
+    if (!PriceCatalogue.instance) {
+      PriceCatalogue.instance = new PriceCatalogue;
+    }
+    return PriceCatalogue.instance;
+  }
+  getCacheDir() {
+    return join(tmpdir(), "ccflare");
+  }
+  getCachePath() {
+    return join(this.getCacheDir(), "models.dev.json");
+  }
+  getCacheDurationMs() {
+    const hours = Number(process.env.CF_PRICING_REFRESH_HOURS) || 24;
+    return hours * TIME_CONSTANTS.HOUR;
+  }
+  async ensureCacheDir() {
+    try {
+      await fs.mkdir(this.getCacheDir(), { recursive: true });
+    } catch (error) {
+      this.logger?.warn("Failed to create cache directory: %s", error);
+    }
+  }
+  async loadFromCache() {
+    try {
+      const cachePath = this.getCachePath();
+      const stats = await fs.stat(cachePath);
+      const age = Date.now() - stats.mtime.getTime();
+      if (age < this.getCacheDurationMs()) {
+        const content = await fs.readFile(cachePath, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {}
+    return null;
+  }
+  async saveToCache(data) {
+    try {
+      await this.ensureCacheDir();
+      const cachePath = this.getCachePath();
+      await fs.writeFile(cachePath, JSON.stringify(data, null, 2));
+    } catch (error) {
+      this.logger?.warn("Failed to save pricing cache: %s", error);
+    }
+  }
+  async fetchRemote() {
+    try {
+      const response = await fetch("https://models.dev/api.json");
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      await this.saveToCache(data);
+      return data;
+    } catch (error) {
+      this.logger?.warn("Failed to fetch pricing data: %s", error);
+      return null;
+    }
+  }
+  async getPricing() {
+    if (this.priceData && Date.now() - this.lastFetch < this.getCacheDurationMs()) {
+      return this.priceData;
+    }
+    let data = await this.fetchRemote();
+    if (!data) {
+      data = await this.loadFromCache();
+    }
+    if (!data) {
+      data = {};
+    }
+    this.priceData = data;
+    this.lastFetch = Date.now();
+    return data;
+  }
+  warnOnce(modelId) {
+    if (!this.warnedModels.has(modelId)) {
+      this.warnedModels.add(modelId);
+      this.logger?.warn("Price for model %s not found - cost set to 0", modelId);
+    }
+  }
+}
+function setPricingLogger(logger) {
+  PriceCatalogue.get().setLogger(logger);
+}
+function findModelCost(pricing, modelId) {
+  for (const provider of Object.values(pricing)) {
+    const model = provider.models?.[modelId];
+    if (model?.cost) {
+      return model.cost;
+    }
+  }
+  return null;
+}
+async function estimateCostUSD(modelId, tokens) {
+  const catalogue = PriceCatalogue.get();
+  try {
+    const pricing = await catalogue.getPricing();
+    const normalizedModelId = modelId.trim();
+    if (!normalizedModelId) {
+      throw new Error("Model id is empty");
+    }
+    const cost = findModelCost(pricing, normalizedModelId);
+    if (!cost) {
+      throw new Error(`Model ${normalizedModelId} not found in pricing catalogue`);
+    }
+    let totalCost = 0;
+    if (tokens.inputTokens && cost.input !== undefined) {
+      totalCost += tokens.inputTokens * (cost.input / 1e6);
+    }
+    if (tokens.outputTokens && cost.output !== undefined) {
+      totalCost += tokens.outputTokens * (cost.output / 1e6);
+    }
+    if (tokens.cacheReadInputTokens && cost.cache_read !== undefined) {
+      totalCost += tokens.cacheReadInputTokens * (cost.cache_read / 1e6);
+    }
+    if (tokens.cacheCreationInputTokens && cost.cache_write !== undefined) {
+      totalCost += tokens.cacheCreationInputTokens * (cost.cache_write / 1e6);
+    }
+    return totalCost;
+  } catch (_error) {
+    catalogue.warnOnce(modelId);
+    return 0;
+  }
+}
+var init_pricing = __esm(() => {
+  init_constants();
+});
+
+// ../../packages/core/src/request-events.ts
+import { EventEmitter } from "events";
+var RequestEventBus, requestEvents;
+var init_request_events = __esm(() => {
+  RequestEventBus = class RequestEventBus extends EventEmitter {
+  };
+  requestEvents = new RequestEventBus;
+});
+
+// ../../packages/types/src/account.ts
+function normalizeRateLimitCode(account, now) {
+  if (account.paused) {
+    return "paused";
+  }
+  if (account.rate_limit_status) {
+    return account.rate_limit_status;
+  }
+  if (account.rate_limited_until && account.rate_limited_until > now) {
+    return "rate_limited";
+  }
+  return "ok";
+}
+function getAccountRateLimitInfo(account, now = Date.now()) {
+  const limitedUntil = account.rate_limited_until && account.rate_limited_until > now ? account.rate_limited_until : null;
+  return {
+    code: normalizeRateLimitCode(account, now),
+    isLimited: account.paused ? false : limitedUntil !== null,
+    until: limitedUntil,
+    resetAt: account.rate_limit_reset ?? null,
+    remaining: account.rate_limit_remaining ?? null
+  };
+}
+function getAccountSessionInfo(account) {
+  return {
+    active: account.session_start !== null,
+    startedAt: account.session_start ?? null,
+    requestCount: account.session_request_count
+  };
+}
+function getAccountTokenStatus(account, now = Date.now()) {
+  if (account.expires_at !== null) {
+    return account.expires_at > now ? "valid" : "expired";
+  }
+  return account.access_token ? "valid" : "expired";
+}
+// ../../packages/types/src/conversation.ts
+var init_conversation = () => {};
+
+// ../../packages/types/src/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// ../../packages/types/src/conversation-links.ts
+function decodeBase64Utf8(value) {
+  if (!value || value === "[streamed]") {
+    return null;
+  }
+  try {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(value, "base64").toString("utf8");
+    }
+    if (typeof atob === "function") {
+      const binary = atob(value);
+      const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+      return new TextDecoder("utf-8").decode(bytes);
+    }
+  } catch {}
+  return null;
+}
+function extractResponseIdFromRecord(record) {
+  if (typeof record.id === "string") {
+    return record.id;
+  }
+  if (isRecord(record.response) && typeof record.response.id === "string") {
+    return record.response.id;
+  }
+  return null;
+}
+function extractPreviousResponseId(requestBody) {
+  if (!requestBody) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(requestBody);
+    if (!isRecord(parsed)) {
+      return null;
+    }
+    return typeof parsed.previous_response_id === "string" ? parsed.previous_response_id : null;
+  } catch {
+    return null;
+  }
+}
+function extractResponseId(responseBody) {
+  if (!responseBody) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(responseBody);
+    if (isRecord(parsed)) {
+      return extractResponseIdFromRecord(parsed);
+    }
+  } catch {}
+  for (const line of responseBody.split(`
+`)) {
+    if (!line.startsWith("data:")) {
+      continue;
+    }
+    const dataStr = line.slice(5).trim();
+    if (!dataStr || dataStr === "[DONE]") {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(dataStr);
+      if (isRecord(parsed)) {
+        const responseId = extractResponseIdFromRecord(parsed);
+        if (responseId) {
+          return responseId;
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+function extractClientSessionIdFromHeaders(headers) {
+  if (!headers) {
+    return null;
+  }
+  const value = headers[CLAUDE_CODE_SESSION_ID_HEADER];
+  return typeof value === "string" ? value : null;
+}
+function extractRequestLinkageFromPayload(payload) {
+  if (!isRecord(payload)) {
+    return {
+      previousResponseId: null,
+      responseId: null,
+      clientSessionId: null
+    };
+  }
+  const requestBody = isRecord(payload.request) ? decodeBase64Utf8(typeof payload.request.body === "string" ? payload.request.body : null) : null;
+  const responseBody = isRecord(payload.response) ? decodeBase64Utf8(typeof payload.response.body === "string" ? payload.response.body : null) : null;
+  const requestHeaders = isRecord(payload.request) && isRecord(payload.request.headers) ? payload.request.headers : null;
+  return {
+    previousResponseId: extractPreviousResponseId(requestBody),
+    responseId: extractResponseId(responseBody),
+    clientSessionId: extractClientSessionIdFromHeaders(requestHeaders)
+  };
+}
+var CLAUDE_CODE_SESSION_ID_HEADER = "x-claude-code-session-id";
+var init_conversation_links = () => {};
+
+// ../../packages/types/src/logging.ts
+function isLogLevel(value) {
+  return LOG_LEVELS.includes(value);
+}
+function isLogEvent(value) {
+  return isRecord(value) && isFiniteNumber(value.ts) && typeof value.level === "string" && isLogLevel(value.level) && typeof value.msg === "string";
+}
+var LOG_LEVELS;
+var init_logging = __esm(() => {
+  LOG_LEVELS = ["DEBUG", "INFO", "WARN", "ERROR"];
+});
+
+// ../../packages/types/src/provider-metadata.ts
+function isAccountProvider(value) {
+  return Object.hasOwn(PROVIDER_METADATA_MAP, value);
+}
+function isAuthMethod(value) {
+  return AUTH_METHODS.includes(value);
+}
+function isProviderWire(value) {
+  return PROVIDER_WIRES.includes(value);
+}
+function isApiKeyProvider(value) {
+  return isAccountProvider(value) && PROVIDER_METADATA_MAP[value].authMethod === "api_key";
+}
+function isOAuthProvider(value) {
+  return isAccountProvider(value) && PROVIDER_METADATA_MAP[value].authMethod === "oauth";
+}
+function getProviderDisplayLabel(provider) {
+  return isAccountProvider(provider) ? PROVIDER_METADATA_MAP[provider].displayLabel : provider;
+}
+function getProviderDefaultBaseUrl(provider) {
+  return PROVIDER_METADATA_MAP[provider].defaultBaseUrl;
+}
+var PROVIDER_WIRES, PROVIDER_METADATA_MAP, providerNames, authMethods, providerOptions, ACCOUNT_PROVIDERS, AUTH_METHODS, API_KEY_PROVIDERS, OAUTH_PROVIDERS;
+var init_provider_metadata = __esm(() => {
+  PROVIDER_WIRES = [
+    "anthropic-messages",
+    "openai-responses"
+  ];
+  PROVIDER_METADATA_MAP = {
+    anthropic: {
+      displayLabel: "Anthropic",
+      authMethod: "api_key",
+      supportsOAuth: false,
+      supportsWebSocket: false,
+      defaultBaseUrl: "https://api.anthropic.com",
+      specialRequirements: []
+    },
+    openai: {
+      displayLabel: "OpenAI",
+      authMethod: "api_key",
+      supportsOAuth: false,
+      supportsWebSocket: false,
+      defaultBaseUrl: "https://api.openai.com/v1",
+      specialRequirements: []
+    },
+    "claude-code": {
+      displayLabel: "Claude Code",
+      authMethod: "oauth",
+      supportsOAuth: true,
+      supportsWebSocket: false,
+      defaultBaseUrl: "https://api.anthropic.com",
+      specialRequirements: ["Requires Claude Code OAuth authentication"]
+    },
+    codex: {
+      displayLabel: "Codex",
+      authMethod: "oauth",
+      supportsOAuth: true,
+      supportsWebSocket: true,
+      defaultBaseUrl: "https://chatgpt.com/backend-api/codex",
+      specialRequirements: ["Requires Codex OAuth authentication"]
+    }
+  };
+  providerNames = Object.freeze(Object.keys(PROVIDER_METADATA_MAP));
+  authMethods = Object.freeze(Array.from(new Set(providerNames.map((provider) => PROVIDER_METADATA_MAP[provider].authMethod))));
+  providerOptions = Object.freeze(providerNames.map((provider) => ({
+    value: provider,
+    label: PROVIDER_METADATA_MAP[provider].displayLabel
+  })));
+  ACCOUNT_PROVIDERS = providerNames;
+  AUTH_METHODS = authMethods;
+  API_KEY_PROVIDERS = Object.freeze(ACCOUNT_PROVIDERS.filter((provider) => isApiKeyProvider(provider)));
+  OAUTH_PROVIDERS = Object.freeze(ACCOUNT_PROVIDERS.filter((provider) => isOAuthProvider(provider)));
+});
+
+// ../../packages/types/src/quota.ts
+function quotaThresholdFor(account, bucket, fleetThreshold) {
+  const threshold = account.switch_threshold;
+  if (typeof threshold === "number")
+    return threshold;
+  return threshold?.[bucket] ?? threshold?.default ?? fleetThreshold;
+}
+function isCurrentQuotaWindow(window, now) {
+  return (window.resetAt === null || window.resetAt > now) && now - window.seenAt <= QUOTA_STALE_MS;
+}
+var QUOTA_STALE_MS;
+var init_quota = __esm(() => {
+  QUOTA_STALE_MS = 30 * 60000;
+});
+
+// ../../packages/types/src/request.ts
+function isOptionalNullableNumber(value) {
+  return value === undefined || value === null || isFiniteNumber(value);
+}
+function isNullableNumber(value) {
+  return value === null || isFiniteNumber(value);
+}
+function isOptionalString(value) {
+  return value === undefined || typeof value === "string";
+}
+function isOptionalNullableString(value) {
+  return value === undefined || value === null || typeof value === "string";
+}
+function isNullableString(value) {
+  return value === null || typeof value === "string";
+}
+function isNullableBoolean(value) {
+  return value === null || typeof value === "boolean";
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function isTokenCurveSampleArray(value) {
+  return Array.isArray(value) && value.every((sample) => isRecord(sample) && isFiniteNumber(sample.chunkIndex) && isFiniteNumber(sample.tokenDelta) && isFiniteNumber(sample.timestamp));
+}
+function isHttpMethod(value) {
+  return HTTP_METHODS.includes(value);
+}
+function toRequestSummary(request) {
+  return {
+    id: request.id,
+    timestamp: new Date(request.timestamp).toISOString(),
+    method: request.method,
+    path: request.path,
+    provider: request.provider,
+    upstreamPath: request.upstreamPath,
+    accountUsed: request.accountUsed,
+    accountName: null,
+    statusCode: request.statusCode,
+    success: request.success,
+    errorMessage: request.errorMessage,
+    responseTimeMs: request.responseTimeMs,
+    failoverAttempts: request.failoverAttempts,
+    model: request.model ?? null,
+    promptTokens: request.promptTokens ?? null,
+    completionTokens: request.completionTokens ?? null,
+    totalTokens: request.totalTokens ?? null,
+    inputTokens: request.inputTokens ?? null,
+    cacheReadInputTokens: request.cacheReadInputTokens ?? null,
+    cacheCreationInputTokens: request.cacheCreationInputTokens ?? null,
+    outputTokens: request.outputTokens ?? null,
+    reasoningTokens: request.reasoningTokens ?? null,
+    costUsd: request.costUsd ?? null,
+    tokensPerSecond: request.tokensPerSecond ?? null,
+    ttftMs: request.ttftMs ?? null,
+    proxyOverheadMs: request.proxyOverheadMs ?? null,
+    upstreamTtfbMs: request.upstreamTtfbMs ?? null,
+    streamingDurationMs: request.streamingDurationMs ?? null,
+    responseId: request.responseId ?? null,
+    previousResponseId: request.previousResponseId ?? null,
+    responseChainId: request.responseChainId ?? null,
+    clientSessionId: request.clientSessionId ?? null
+  };
+}
+function isRequestSummary(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.timestamp === "string" && typeof value.method === "string" && isHttpMethod(value.method) && typeof value.path === "string" && typeof value.provider === "string" && value.provider.length > 0 && typeof value.upstreamPath === "string" && (value.accountUsed === null || typeof value.accountUsed === "string") && (value.accountName === null || typeof value.accountName === "string") && isOptionalNullableNumber(value.statusCode) && isNullableBoolean(value.success) && isOptionalNullableString(value.errorMessage) && isOptionalNullableNumber(value.responseTimeMs) && isFiniteNumber(value.failoverAttempts) && isNullableString(value.model) && isNullableNumber(value.promptTokens) && isNullableNumber(value.completionTokens) && isNullableNumber(value.totalTokens) && isNullableNumber(value.inputTokens) && isNullableNumber(value.cacheReadInputTokens) && isNullableNumber(value.cacheCreationInputTokens) && isNullableNumber(value.outputTokens) && isNullableNumber(value.reasoningTokens) && isNullableNumber(value.costUsd) && isNullableNumber(value.tokensPerSecond) && isNullableNumber(value.ttftMs) && isNullableNumber(value.proxyOverheadMs) && isNullableNumber(value.upstreamTtfbMs) && isNullableNumber(value.streamingDurationMs) && isNullableString(value.responseId) && isNullableString(value.previousResponseId) && isNullableString(value.responseChainId) && isNullableString(value.clientSessionId);
+}
+function isRequestPayload(value) {
+  if (!isRecord(value) || !isRecord(value.request) || !isRecord(value.meta) || !isRecord(value.meta.trace) || !isRecord(value.meta.account) || !isRecord(value.meta.transport)) {
+    return false;
+  }
+  const { request, response, meta } = value;
+  const trace = meta.trace;
+  const account = meta.account;
+  const transport = meta.transport;
+  if (!isStringRecord(request.headers) || isOptionalNullableString(request.body) === false) {
+    return false;
+  }
+  if (response !== null && (!isRecord(response) || !isFiniteNumber(response.status) || !isStringRecord(response.headers) || isOptionalNullableString(response.body) === false)) {
+    return false;
+  }
+  return typeof value.id === "string" && isOptionalString(value.error) && isFiniteNumber(trace.timestamp) && (trace.provider === undefined || typeof trace.provider === "string" && trace.provider.length > 0) && (trace.upstreamPath === undefined || typeof trace.upstreamPath === "string") && (trace.path === undefined || typeof trace.path === "string") && (trace.method === undefined || typeof trace.method === "string" && isHttpMethod(trace.method)) && isOptionalNullableString(trace.responseId) && isOptionalNullableString(trace.previousResponseId) && isOptionalNullableString(trace.responseChainId) && isOptionalNullableString(trace.clientSessionId) && (account.id === null || typeof account.id === "string") && (account.name === undefined || account.name === null || typeof account.name === "string") && (transport.success === undefined || typeof transport.success === "boolean") && (transport.rateLimited === undefined || typeof transport.rateLimited === "boolean") && (transport.accountsAttempted === undefined || isFiniteNumber(transport.accountsAttempted)) && (transport.pending === undefined || typeof transport.pending === "boolean") && (transport.retry === undefined || isFiniteNumber(transport.retry)) && (transport.isStream === undefined || typeof transport.isStream === "boolean") && isOptionalNullableNumber(transport.ttftMs) && isOptionalNullableNumber(transport.proxyOverheadMs) && isOptionalNullableNumber(transport.upstreamTtfbMs) && isOptionalNullableNumber(transport.streamingDurationMs) && (transport.tokenCurve === undefined || transport.tokenCurve === null || isTokenCurveSampleArray(transport.tokenCurve));
+}
+function parseRequestPayload(value) {
+  if (isRequestPayload(value)) {
+    return value;
+  }
+  return null;
+}
+var HTTP_METHODS, NO_ACCOUNT_ID = "no_account";
+var init_request = __esm(() => {
+  HTTP_METHODS = Object.freeze([
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "OPTIONS",
+    "HEAD",
+    "WS"
+  ]);
+});
+
+// ../../packages/types/src/request-events.ts
+function isRequestStreamEvent(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return false;
+  }
+  switch (value.type) {
+    case "ingress":
+      return typeof value.id === "string" && isFiniteNumber(value.timestamp) && typeof value.method === "string" && isHttpMethod(value.method) && typeof value.path === "string";
+    case "start":
+      return typeof value.id === "string" && isFiniteNumber(value.timestamp) && typeof value.method === "string" && isHttpMethod(value.method) && typeof value.path === "string" && (value.accountId === null || typeof value.accountId === "string") && isFiniteNumber(value.statusCode);
+    case "summary":
+      return isRequestSummary(value.payload);
+    case "payload":
+      return isRequestPayload(value.payload);
+    default:
+      return false;
+  }
+}
+var init_request_events2 = __esm(() => {
+  init_request();
+});
+
+// ../../packages/types/src/stats.ts
+function isTimeRange(value) {
+  return TIME_RANGES.includes(value);
+}
+function isAnalyticsMode(value) {
+  return ANALYTICS_MODES.includes(value);
+}
+function isAnalyticsStatusFilter(value) {
+  return ANALYTICS_STATUS_FILTERS.includes(value);
+}
+var TIME_RANGES, ANALYTICS_MODES, ANALYTICS_STATUS_FILTERS;
+var init_stats = __esm(() => {
+  TIME_RANGES = Object.freeze([
+    "1h",
+    "6h",
+    "24h",
+    "7d",
+    "30d"
+  ]);
+  ANALYTICS_MODES = Object.freeze([
+    "normal",
+    "cumulative"
+  ]);
+  ANALYTICS_STATUS_FILTERS = Object.freeze([
+    "all",
+    "success",
+    "error"
+  ]);
+});
+
+// ../../packages/types/src/strategy.ts
+function isLbStrategy(value) {
+  return LB_STRATEGIES.includes(value);
+}
+var StrategyName, LB_STRATEGIES;
+var init_strategy = __esm(() => {
+  StrategyName = {
+    Session: "session"
+  };
+  LB_STRATEGIES = Object.freeze(Object.values(StrategyName));
+});
+
+// ../../packages/types/src/index.ts
+var init_src = __esm(() => {
+  init_conversation();
+  init_conversation_links();
+  init_logging();
+  init_provider_metadata();
+  init_quota();
+  init_request();
+  init_request_events2();
+  init_stats();
+  init_strategy();
+});
+
+// ../../packages/core/src/strategy.ts
+function isValidStrategy(strategy2) {
+  return isLbStrategy(strategy2);
+}
+function isAccountAvailable(account2, now = Date.now()) {
+  return !account2.paused && (!account2.rate_limited_until || account2.rate_limited_until < now);
+}
+var DEFAULT_STRATEGY;
+var init_strategy2 = __esm(() => {
+  init_src();
+  DEFAULT_STRATEGY = StrategyName.Session;
+});
+
+// ../../packages/core/src/validation.ts
+function validateString(value, field, options = {}) {
+  if (value === undefined || value === null) {
+    if (options.required) {
+      throw new ValidationError(`${field} is required`, field);
+    }
+    return;
+  }
+  if (typeof value !== "string") {
+    throw new ValidationError(`${field} must be a string`, field, value);
+  }
+  const sanitized = options.transform ? options.transform(value) : value;
+  if (options.minLength !== undefined && sanitized.length < options.minLength) {
+    throw new ValidationError(`${field} must be at least ${options.minLength} characters long`, field, value);
+  }
+  if (options.maxLength !== undefined && sanitized.length > options.maxLength) {
+    throw new ValidationError(`${field} must be at most ${options.maxLength} characters long`, field, value);
+  }
+  if (options.pattern && !options.pattern.test(sanitized)) {
+    throw new ValidationError(`${field} has an invalid format`, field, value);
+  }
+  if (options.allowedValues && !options.allowedValues.includes(sanitized)) {
+    throw new ValidationError(`${field} must be one of: ${options.allowedValues.join(", ")}`, field, value);
+  }
+  return sanitized;
+}
+function validateNumber(value, field, options = {}) {
+  if (value === undefined || value === null) {
+    if (options.required) {
+      throw new ValidationError(`${field} is required`, field);
+    }
+    return;
+  }
+  let num;
+  if (typeof value === "string") {
+    num = Number(value);
+    if (Number.isNaN(num)) {
+      throw new ValidationError(`${field} must be a valid number`, field, value);
+    }
+  } else if (typeof value === "number") {
+    num = value;
+  } else {
+    throw new ValidationError(`${field} must be a number`, field, value);
+  }
+  if (options.integer && !Number.isInteger(num)) {
+    throw new ValidationError(`${field} must be an integer`, field, value);
+  }
+  if (options.min !== undefined && num < options.min) {
+    throw new ValidationError(`${field} must be at least ${options.min}`, field, value);
+  }
+  if (options.max !== undefined && num > options.max) {
+    throw new ValidationError(`${field} must be at most ${options.max}`, field, value);
+  }
+  if (options.allowedValues && !options.allowedValues.includes(num)) {
+    throw new ValidationError(`${field} must be one of: ${options.allowedValues.join(", ")}`, field, value);
+  }
+  return num;
+}
+var sanitizers, patterns;
+var init_validation = __esm(() => {
+  init_errors();
+  sanitizers = {
+    trim: (value) => value.trim(),
+    lowercase: (value) => value.toLowerCase(),
+    uppercase: (value) => value.toUpperCase(),
+    removeWhitespace: (value) => value.replace(/\s+/g, ""),
+    alphanumeric: (value) => value.replace(/[^a-zA-Z0-9]/g, ""),
+    alphanumericWithSpaces: (value) => value.replace(/[^a-zA-Z0-9\s]/g, ""),
+    email: (value) => value.trim().toLowerCase(),
+    url: (value) => {
+      try {
+        const parsed = new URL(value);
+        return parsed.toString();
+      } catch {
+        throw new ValidationError("Invalid URL format", "url", value);
+      }
+    }
+  };
+  patterns = {
+    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+    uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    alphanumeric: /^[a-zA-Z0-9]+$/,
+    alphanumericWithSpaces: /^[a-zA-Z0-9\s]+$/,
+    accountName: /^[a-zA-Z0-9\s\-_@.+]+$/,
+    apiPath: /^\/v1\/[a-zA-Z0-9\-_/]*$/
+  };
+});
+
+// ../../packages/core/src/index.ts
+var init_src2 = __esm(() => {
+  init_constants();
+  init_di();
+  init_errors();
+  init_models();
+  init_pricing();
+  init_validation();
+  init_lifecycle();
+  init_request_events();
+  init_strategy2();
+});
+
+// ../../packages/database/src/analytics-query.ts
+function buildAnalyticsQuery(input) {
+  const now = input.now ?? Date.now();
+  const config = ANALYTICS_RANGE_CONFIG[input.range];
+  return {
+    meta: {
+      range: input.range,
+      bucket: config.bucketLabel
+    },
+    options: {
+      startMs: now - config.durationMs,
+      bucketMs: config.bucketMs,
+      accounts: input.accounts,
+      models: input.models,
+      providers: input.providers,
+      status: input.status,
+      includeModelBreakdown: input.includeModelBreakdown
+    }
+  };
+}
+var HOUR_MS, DAY_MS, ANALYTICS_RANGE_CONFIG;
+var init_analytics_query = __esm(() => {
+  HOUR_MS = 60 * 60 * 1000;
+  DAY_MS = 24 * HOUR_MS;
+  ANALYTICS_RANGE_CONFIG = {
+    "1h": {
+      durationMs: HOUR_MS,
+      bucketMs: 60 * 1000,
+      bucketLabel: "1m"
+    },
+    "6h": {
+      durationMs: 6 * HOUR_MS,
+      bucketMs: 5 * 60 * 1000,
+      bucketLabel: "5m"
+    },
+    "24h": {
+      durationMs: DAY_MS,
+      bucketMs: HOUR_MS,
+      bucketLabel: "1h"
+    },
+    "7d": {
+      durationMs: 7 * DAY_MS,
+      bucketMs: HOUR_MS,
+      bucketLabel: "1h"
+    },
+    "30d": {
+      durationMs: 30 * DAY_MS,
+      bucketMs: DAY_MS,
+      bucketLabel: "1d"
+    }
+  };
+});
+
+// ../../packages/logger/src/file-writer.ts
+import {
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  statSync,
+  unlinkSync
+} from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+function writeToStderr(message, error) {
+  if (typeof process === "undefined") {
+    return;
+  }
+  const formattedError = error instanceof Error ? error.stack ?? error.message : String(error);
+  process.stderr?.write?.(`${message}: ${formattedError}
+`);
+}
+
+class LogFileWriter {
+  logDir;
+  logFile;
+  stream = null;
+  maxFileSize = BUFFER_SIZES.LOG_FILE_MAX_SIZE;
+  constructor() {
+    this.logDir = join2(tmpdir2(), "ccflare-logs");
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
+    }
+    this.logFile = join2(this.logDir, "app.log");
+    this.initStream();
+  }
+  initStream() {
+    if (existsSync(this.logFile)) {
+      const stats2 = statSync(this.logFile);
+      if (stats2.size > this.maxFileSize) {
+        this.rotateLog();
+      }
+    }
+    this.stream = createWriteStream(this.logFile, { flags: "a" });
+  }
+  rotateLog() {
+    if (this.stream) {
+      this.stream.end();
+    }
+    if (existsSync(this.logFile)) {
+      try {
+        unlinkSync(this.logFile);
+      } catch (_e) {
+        writeToStderr("Failed to rotate log", _e);
+      }
+    }
+  }
+  write(event) {
+    if (!this.stream || this.stream.destroyed) {
+      this.initStream();
+    }
+    const line = `${JSON.stringify(event)}
+`;
+    if (this.stream) {
+      this.stream.write(line);
+    }
+  }
+  async readLogs(limit = LIMITS.LOG_READ_DEFAULT) {
+    if (!existsSync(this.logFile)) {
+      return [];
+    }
+    try {
+      const content = await Bun.file(this.logFile).text();
+      const lines = content.trim().split(`
+`).filter(Boolean);
+      return lines.slice(-limit).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((log) => log !== null);
+    } catch (_e) {
+      writeToStderr("Failed to read logs", _e);
+      return [];
+    }
+  }
+  close() {
+    if (this.stream) {
+      this.stream.end();
+      this.stream = null;
+    }
+  }
+  dispose() {
+    this.close();
+  }
+}
+var logFileWriter;
+var init_file_writer = __esm(() => {
+  init_src2();
+  logFileWriter = new LogFileWriter;
+  registerDisposable(logFileWriter);
+});
+
+// ../../packages/logger/src/index.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+class Logger {
+  level;
+  prefix;
+  format;
+  silentConsole;
+  constructor(prefix = "", level = 1 /* INFO */, options = {}) {
+    this.prefix = prefix;
+    this.level = this.getLogLevelFromEnv() || level;
+    this.format = process.env.LOG_FORMAT || "pretty";
+    this.silentConsole = options.silentConsole ?? !(process.env.ccflare_DEBUG === "1" || this.level === 0 /* DEBUG */);
+  }
+  getLogLevelFromEnv() {
+    const envLevel = process.env.LOG_LEVEL?.toUpperCase();
+    if (envLevel && envLevel in LogLevel) {
+      return LogLevel[envLevel];
+    }
+    return null;
+  }
+  formatMessage(level, message, data) {
+    const timestamp = new Date().toISOString();
+    if (this.format === "json") {
+      const logEntry = {
+        ts: timestamp,
+        level,
+        prefix: this.prefix || undefined,
+        msg: message,
+        ...data && { data }
+      };
+      return JSON.stringify(logEntry);
+    } else {
+      const prefix = this.prefix ? `[${this.prefix}] ` : "";
+      const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+      return `[${timestamp}] ${level}: ${prefix}${message}${dataStr}`;
+    }
+  }
+  debug(message, data) {
+    if (this.level <= 0 /* DEBUG */) {
+      const msg = this.formatMessage("DEBUG", message, data);
+      const event = {
+        ts: Date.now(),
+        level: "DEBUG",
+        msg: message
+      };
+      logBus.emit("log", event);
+      logFileWriter.write(event);
+      this.writeToStream(0 /* DEBUG */, msg);
+    }
+  }
+  info(message, data) {
+    if (this.level <= 1 /* INFO */) {
+      const msg = this.formatMessage("INFO", message, data);
+      const event = {
+        ts: Date.now(),
+        level: "INFO",
+        msg: message
+      };
+      logBus.emit("log", event);
+      logFileWriter.write(event);
+      this.writeToStream(1 /* INFO */, msg);
+    }
+  }
+  warn(message, data) {
+    if (this.level <= 2 /* WARN */) {
+      const msg = this.formatMessage("WARN", message, data);
+      const event = {
+        ts: Date.now(),
+        level: "WARN",
+        msg: message
+      };
+      logBus.emit("log", event);
+      logFileWriter.write(event);
+      this.writeToStream(2 /* WARN */, msg);
+    }
+  }
+  error(message, error) {
+    if (this.level <= 3 /* ERROR */) {
+      const msg = this.formatMessage("ERROR", message, error);
+      const event = {
+        ts: Date.now(),
+        level: "ERROR",
+        msg: message
+      };
+      logBus.emit("log", event);
+      logFileWriter.write(event);
+      this.writeToStream(3 /* ERROR */, msg);
+    }
+  }
+  setLevel(level) {
+    this.level = level;
+    this.silentConsole = !(process.env.ccflare_DEBUG === "1" || this.level === 0 /* DEBUG */);
+  }
+  getLevel() {
+    return this.level;
+  }
+  writeToStream(level, message) {
+    if (this.silentConsole || typeof process === "undefined") {
+      return;
+    }
+    const stream = level >= 2 /* WARN */ ? process.stderr : process.stdout;
+    stream?.write?.(`${message}
+`);
+  }
+}
+var LogLevel, logBus, log;
+var init_src3 = __esm(() => {
+  init_file_writer();
+  init_file_writer();
+  ((LogLevel2) => {
+    LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+    LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+    LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+    LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  })(LogLevel ||= {});
+  logBus = new EventEmitter2;
+  log = new Logger;
+});
+
+// ../../packages/config/src/paths-common.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { platform } from "process";
+function getPlatformConfigDir() {
+  if (platform === "win32") {
+    const baseDir = process.env.LOCALAPPDATA ?? process.env.APPDATA ?? join3(homedir(), "AppData", "Local");
+    return join3(baseDir, "ccflare");
+  } else {
+    const xdgConfig = process.env.XDG_CONFIG_HOME;
+    const baseDir = xdgConfig ?? join3(homedir(), ".config");
+    return join3(baseDir, "ccflare");
+  }
+}
+var init_paths_common = () => {};
+
+// ../../packages/config/src/paths.ts
+import { join as join4 } from "path";
+function resolveConfigPath() {
+  const explicitPath = process.env.ccflare_CONFIG_PATH;
+  if (explicitPath) {
+    return explicitPath;
+  }
+  const configDir = getPlatformConfigDir();
+  return join4(configDir, "ccflare.json");
+}
+var init_paths = __esm(() => {
+  init_paths_common();
+});
+
+// ../../packages/config/src/index.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname } from "path";
+function parseNumber(value) {
+  if (value === undefined) {
+    return;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+function sanitizeConfigData(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "team_routing") {
+      const teamRouting = sanitizeTeamRouting(entry);
+      if (teamRouting)
+        sanitized.team_routing = teamRouting;
+      continue;
+    }
+    if (key === "providers") {
+      const providers = sanitizeProviderConfigs(entry);
+      if (providers)
+        sanitized.providers = providers;
+      continue;
+    }
+    if (key === "provider_pools") {
+      const providerPools = sanitizeProviderPools(entry);
+      if (providerPools)
+        sanitized.provider_pools = providerPools;
+      continue;
+    }
+    if (typeof entry === "string" || typeof entry === "boolean" || isFiniteNumber(entry)) {
+      sanitized[key] = entry;
+    }
+  }
+  if (!isLbStrategy(String(sanitized.lb_strategy ?? ""))) {
+    delete sanitized.lb_strategy;
+  }
+  const numericKeys = [
+    "retry_attempts",
+    "max_body_bytes",
+    "quota_threshold",
+    "retry_delay_ms",
+    "retry_backoff",
+    "request_scoped_429_retry_delay_ms",
+    "session_duration_ms",
+    "port",
+    "data_retention_days",
+    "request_retention_days"
+  ];
+  for (const key of numericKeys) {
+    const entry = sanitized[key];
+    if (entry !== undefined && !isFiniteNumber(entry)) {
+      delete sanitized[key];
+    }
+  }
+  if (sanitized.client_id !== undefined && typeof sanitized.client_id !== "string") {
+    delete sanitized.client_id;
+  }
+  return sanitized;
+}
+function isProviderStrategy(value) {
+  return typeof value === "string" && PROVIDER_STRATEGIES.includes(value);
+}
+function sanitizeProviderBaseUrl(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.protocol === "http:" ? url.toString().replace(/\/$/, "") : undefined;
+  } catch {
+    return;
+  }
+}
+function sanitizeProviderModels(value) {
+  if (!isRecord(value))
+    return;
+  const models = {};
+  for (const [pattern, target] of Object.entries(value)) {
+    const wildcardIndex = pattern.indexOf("*");
+    if (pattern.length === 0 || pattern.length > 200 || wildcardIndex !== -1 && wildcardIndex !== pattern.length - 1 || typeof target !== "string" || target.length === 0 || target.length > 200) {
+      continue;
+    }
+    models[pattern] = target;
+  }
+  return Object.keys(models).length > 0 ? models : undefined;
+}
+function sanitizeProviderConfigs(value) {
+  if (!isRecord(value))
+    return;
+  const providers = {};
+  for (const [name, entry] of Object.entries(value)) {
+    if (name === "pool" || !PROVIDER_NAME_PATTERN.test(name) || !isRecord(entry))
+      continue;
+    const builtin = BUILTIN_PROVIDER_CONFIG_BY_NAME.get(name);
+    const strategy3 = isProviderStrategy(entry.strategy) ? entry.strategy : builtin?.strategy;
+    if (!strategy3)
+      continue;
+    const provider = { strategy: strategy3 };
+    if (typeof entry.enabled === "boolean")
+      provider.enabled = entry.enabled;
+    const baseUrl = sanitizeProviderBaseUrl(entry.base_url);
+    if (baseUrl)
+      provider.base_url = baseUrl;
+    const models = sanitizeProviderModels(entry.models);
+    if (models)
+      provider.models = models;
+    providers[name] = provider;
+  }
+  return providers;
+}
+function sanitizeProviderPools(value) {
+  if (!isRecord(value))
+    return;
+  const pools = {};
+  for (const [wire, entries] of Object.entries(value)) {
+    if (!isProviderWire(wire) || !Array.isArray(entries))
+      continue;
+    const providers = [...new Set(entries)].filter((provider) => typeof provider === "string" && PROVIDER_NAME_PATTERN.test(provider));
+    if (providers.length > 0)
+      pools[wire] = providers;
+  }
+  return pools;
+}
+function wireForStrategy(strategy3) {
+  return strategy3 === "anthropic-api" || strategy3 === "claude-code" ? "anthropic-messages" : "openai-responses";
+}
+function isNonNegativeFiniteNumber(value) {
+  return isFiniteNumber(value) && value >= 0;
+}
+function sanitizeTeamRouting(value) {
+  if (!isRecord(value))
+    return;
+  const result = {};
+  if (typeof value.enabled === "boolean")
+    result.enabled = value.enabled;
+  if (typeof value.distribution_enabled === "boolean") {
+    result.distribution_enabled = value.distribution_enabled;
+  }
+  if (Array.isArray(value.allowlisted_account_uuids) && value.allowlisted_account_uuids.every((entry) => typeof entry === "string" && entry.length > 0 && entry.length <= 200)) {
+    result.allowlisted_account_uuids = [...value.allowlisted_account_uuids];
+  }
+  if (isFiniteNumber(value.max_usage) && value.max_usage > 0 && value.max_usage <= 0.9) {
+    result.max_usage = value.max_usage;
+  }
+  if (isNonNegativeFiniteNumber(value.admission_cap)) {
+    result.admission_cap = Math.floor(value.admission_cap);
+  }
+  if (isNonNegativeFiniteNumber(value.admission_queue_limit)) {
+    result.admission_queue_limit = Math.floor(value.admission_queue_limit);
+  }
+  if (isNonNegativeFiniteNumber(value.admission_wait_ms)) {
+    result.admission_wait_ms = Math.floor(value.admission_wait_ms);
+  }
+  if (isNonNegativeFiniteNumber(value.hold_seconds)) {
+    result.hold_seconds = Math.floor(value.hold_seconds);
+  }
+  if (isNonNegativeFiniteNumber(value.quota_probe_seconds)) {
+    result.quota_probe_seconds = Math.min(Math.floor(value.quota_probe_seconds), 7 * 24 * 60 * 60);
+  }
+  return result;
+}
+var log2, PROVIDER_STRATEGIES, BUILTIN_PROVIDER_CONFIGS, BUILTIN_PROVIDER_CONFIG_BY_NAME, PROVIDER_NAME_PATTERN, TEAM_ROUTING_DEFAULTS, Config;
+var init_src4 = __esm(() => {
+  init_src2();
+  init_src3();
+  init_src();
+  init_paths();
+  init_paths();
+  init_paths_common();
+  log2 = new Logger("Config");
+  PROVIDER_STRATEGIES = [
+    "anthropic-api",
+    "openai-api",
+    "claude-code",
+    "codex"
+  ];
+  BUILTIN_PROVIDER_CONFIGS = [
+    { name: "anthropic", enabled: true, strategy: "anthropic-api" },
+    { name: "openai", enabled: true, strategy: "openai-api" },
+    { name: "claude-code", enabled: false, strategy: "claude-code" },
+    { name: "codex", enabled: false, strategy: "codex" }
+  ];
+  BUILTIN_PROVIDER_CONFIG_BY_NAME = new Map(BUILTIN_PROVIDER_CONFIGS.map((provider) => [provider.name, provider]));
+  PROVIDER_NAME_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
+  TEAM_ROUTING_DEFAULTS = {
+    enabled: false,
+    distributionEnabled: true,
+    allowlistedAccountUuids: [],
+    maxUsage: 0.9,
+    admissionCap: 5,
+    admissionQueueLimit: 25,
+    admissionWaitMs: 30000,
+    holdSeconds: 0,
+    quotaProbeSeconds: 0
+  };
+  Config = class Config extends EventEmitter3 {
+    configPath;
+    data = {};
+    constructor(configPath) {
+      super();
+      this.configPath = configPath ?? resolveConfigPath();
+      this.loadConfig();
+    }
+    loadConfig() {
+      if (existsSync2(this.configPath)) {
+        try {
+          const content = readFileSync(this.configPath, "utf8");
+          this.data = sanitizeConfigData(JSON.parse(content));
+          if ("default_agent_model" in this.data) {
+            delete this.data.default_agent_model;
+            this.saveConfig();
+          }
+        } catch (error) {
+          log2.error(`Failed to parse config file: ${error}`);
+          this.data = {};
+        }
+      } else {
+        const dir = dirname(this.configPath);
+        mkdirSync2(dir, { recursive: true });
+        this.data = {
+          lb_strategy: DEFAULT_STRATEGY
+        };
+        this.saveConfig();
+      }
+    }
+    saveConfig() {
+      try {
+        const content = JSON.stringify(this.data, null, 2);
+        writeFileSync(this.configPath, content, "utf8");
+      } catch (error) {
+        log2.error(`Failed to save config file: ${error}`);
+      }
+    }
+    get(key, defaultValue) {
+      const value = this.data[key];
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+      }
+      if (defaultValue !== undefined) {
+        this.set(key, defaultValue);
+        return defaultValue;
+      }
+      return;
+    }
+    set(key, value) {
+      const oldValue = this.data[key];
+      this.data[key] = value;
+      this.saveConfig();
+      this.emit("change", { key, oldValue, newValue: value });
+    }
+    getStrategy() {
+      const envStrategy = process.env.LB_STRATEGY;
+      if (envStrategy && isValidStrategy(envStrategy)) {
+        return envStrategy;
+      }
+      const configStrategy = this.data.lb_strategy;
+      if (configStrategy && isValidStrategy(configStrategy)) {
+        return configStrategy;
+      }
+      return DEFAULT_STRATEGY;
+    }
+    setStrategy(strategy3) {
+      if (!isValidStrategy(strategy3)) {
+        throw new Error(`Invalid strategy: ${strategy3}`);
+      }
+      this.set("lb_strategy", strategy3);
+    }
+    clamp(n, min, max) {
+      return Math.max(min, Math.min(max, n));
+    }
+    getDataRetentionDays() {
+      const fromEnv = process.env.DATA_RETENTION_DAYS;
+      if (fromEnv) {
+        const n = parseInt(fromEnv, 10);
+        if (!Number.isNaN(n))
+          return this.clamp(n, 1, 365);
+      }
+      const fromFile = this.data.data_retention_days;
+      if (typeof fromFile === "number")
+        return this.clamp(fromFile, 1, 365);
+      return 7;
+    }
+    setDataRetentionDays(days) {
+      const clamped = this.clamp(days, 1, 365);
+      this.set("data_retention_days", clamped);
+    }
+    getRequestRetentionDays() {
+      const fromEnv = process.env.REQUEST_RETENTION_DAYS;
+      if (fromEnv) {
+        const n = parseInt(fromEnv, 10);
+        if (!Number.isNaN(n))
+          return this.clamp(n, 1, 3650);
+      }
+      const fromFile = this.data.request_retention_days;
+      if (typeof fromFile === "number")
+        return this.clamp(fromFile, 1, 3650);
+      return 365;
+    }
+    setRequestRetentionDays(days) {
+      const clamped = this.clamp(days, 1, 3650);
+      this.set("request_retention_days", clamped);
+    }
+    getAllSettings() {
+      const primitiveSettings = Object.fromEntries(Object.entries(this.data).filter(([, value]) => typeof value === "string" || typeof value === "number" || typeof value === "boolean"));
+      return {
+        ...primitiveSettings,
+        lb_strategy: this.getStrategy(),
+        data_retention_days: this.getDataRetentionDays(),
+        request_retention_days: this.getRequestRetentionDays()
+      };
+    }
+    getTeamRouting() {
+      const file = this.data.team_routing;
+      return {
+        enabled: file?.enabled ?? TEAM_ROUTING_DEFAULTS.enabled,
+        distributionEnabled: file?.distribution_enabled ?? TEAM_ROUTING_DEFAULTS.distributionEnabled,
+        allowlistedAccountUuids: [
+          ...file?.allowlisted_account_uuids ?? TEAM_ROUTING_DEFAULTS.allowlistedAccountUuids
+        ],
+        maxUsage: file?.max_usage ?? TEAM_ROUTING_DEFAULTS.maxUsage,
+        admissionCap: file?.admission_cap ?? TEAM_ROUTING_DEFAULTS.admissionCap,
+        admissionQueueLimit: file?.admission_queue_limit ?? TEAM_ROUTING_DEFAULTS.admissionQueueLimit,
+        admissionWaitMs: file?.admission_wait_ms ?? TEAM_ROUTING_DEFAULTS.admissionWaitMs,
+        holdSeconds: file?.hold_seconds ?? TEAM_ROUTING_DEFAULTS.holdSeconds,
+        quotaProbeSeconds: file?.quota_probe_seconds ?? TEAM_ROUTING_DEFAULTS.quotaProbeSeconds
+      };
+    }
+    getProviderConfig(name) {
+      const builtin = BUILTIN_PROVIDER_CONFIG_BY_NAME.get(name);
+      const configured = this.data.providers?.[name];
+      if (!builtin && !configured?.strategy)
+        return;
+      return {
+        name,
+        enabled: configured?.enabled ?? builtin?.enabled ?? true,
+        strategy: configured?.strategy ?? builtin?.strategy ?? "anthropic-api",
+        ...configured?.base_url && { baseUrl: configured.base_url },
+        ...configured?.models && { models: { ...configured.models } }
+      };
+    }
+    getProviderPool(wire) {
+      return (this.data.provider_pools?.[wire] ?? []).filter((name) => {
+        const provider = this.getProviderConfig(name);
+        return provider?.enabled === true && wireForStrategy(provider.strategy) === wire;
+      });
+    }
+    getProviderPools() {
+      return Object.fromEntries(PROVIDER_WIRES.map((wire) => [wire, this.getProviderPool(wire)]).filter(([, providers]) => providers.length > 0));
+    }
+    getProviderConfigs() {
+      const names = new Set(BUILTIN_PROVIDER_CONFIGS.map(({ name }) => name));
+      for (const name of Object.keys(this.data.providers ?? {})) {
+        names.add(name);
+      }
+      return [...names].map((name) => this.getProviderConfig(name)).filter((provider) => provider !== undefined);
+    }
+    setTeamRouting(value) {
+      if (!isRecord(value)) {
+        throw new Error("team routing configuration must be an object");
+      }
+      const allowed = new Set([
+        "enabled",
+        "distribution_enabled",
+        "allowlisted_account_uuids",
+        "max_usage",
+        "admission_cap",
+        "admission_queue_limit",
+        "admission_wait_ms",
+        "hold_seconds",
+        "quota_probe_seconds"
+      ]);
+      if (Object.keys(value).some((key) => !allowed.has(key))) {
+        throw new Error("team routing configuration contains an unknown field");
+      }
+      const sanitized = sanitizeTeamRouting(value);
+      if (!sanitized) {
+        throw new Error("team routing configuration must be an object");
+      }
+      for (const key of Object.keys(value)) {
+        if (!(key in sanitized)) {
+          throw new Error(`Invalid team routing field: ${key}`);
+        }
+      }
+      const oldValue = this.data.team_routing;
+      this.data.team_routing = sanitized;
+      this.saveConfig();
+      this.emit("change", {
+        key: "team_routing",
+        oldValue,
+        newValue: sanitized
+      });
+    }
+    allowAccountUuid(accountUuid) {
+      const current = this.getTeamRouting().allowlistedAccountUuids;
+      if (current.includes(accountUuid))
+        return;
+      this.persistAccountAllowlist([...current, accountUuid]);
+    }
+    removeAccountUuid(accountUuid) {
+      const current = this.getTeamRouting().allowlistedAccountUuids;
+      if (!current.includes(accountUuid))
+        return;
+      this.persistAccountAllowlist(current.filter((uuid) => uuid !== accountUuid));
+    }
+    persistAccountAllowlist(accountUuids) {
+      const teamRouting = {
+        ...this.data.team_routing,
+        allowlisted_account_uuids: accountUuids
+      };
+      const next = { ...this.data, team_routing: teamRouting };
+      const temporary = `${this.configPath}.${crypto.randomUUID()}.tmp`;
+      try {
+        writeFileSync(temporary, JSON.stringify(next, null, 2), {
+          mode: 384,
+          flag: "wx"
+        });
+        renameSync(temporary, this.configPath);
+      } finally {
+        rmSync(temporary, { force: true });
+      }
+      const oldValue = this.data.team_routing;
+      this.data = next;
+      this.emit("change", {
+        key: "team_routing",
+        oldValue,
+        newValue: teamRouting
+      });
+    }
+    getRuntime() {
+      const defaults = {
+        clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+        maxBodyBytes: 64 * 1024 * 1024,
+        quotaThreshold: 0.98,
+        requestScopedRetryDelayMs: 2000,
+        retry: {
+          attempts: 3,
+          delayMs: TIME_CONSTANTS.RETRY_DELAY_DEFAULT,
+          backoff: 2
+        },
+        sessionDurationMs: TIME_CONSTANTS.SESSION_DURATION_DEFAULT,
+        port: NETWORK.DEFAULT_PORT,
+        teamRouting: this.getTeamRouting()
+      };
+      if (process.env.CLIENT_ID) {
+        defaults.clientId = process.env.CLIENT_ID;
+      }
+      const retryAttempts = parseNumber(process.env.RETRY_ATTEMPTS);
+      if (retryAttempts !== undefined) {
+        defaults.retry.attempts = retryAttempts;
+      }
+      const maxBodyBytes = parseNumber(process.env.MAX_BODY_BYTES);
+      if (maxBodyBytes !== undefined) {
+        defaults.maxBodyBytes = maxBodyBytes;
+      }
+      const quotaThreshold = parseNumber(process.env.QUOTA_THRESHOLD);
+      if (quotaThreshold !== undefined && quotaThreshold > 0 && quotaThreshold <= 1) {
+        defaults.quotaThreshold = quotaThreshold;
+      }
+      const retryDelayMs = parseNumber(process.env.RETRY_DELAY_MS);
+      if (retryDelayMs !== undefined) {
+        defaults.retry.delayMs = retryDelayMs;
+      }
+      const retryBackoff = parseNumber(process.env.RETRY_BACKOFF);
+      if (retryBackoff !== undefined) {
+        defaults.retry.backoff = retryBackoff;
+      }
+      const requestScopedRetryDelayMs = parseNumber(process.env.REQUEST_SCOPED_429_RETRY_DELAY_MS);
+      if (requestScopedRetryDelayMs !== undefined) {
+        defaults.requestScopedRetryDelayMs = requestScopedRetryDelayMs;
+      }
+      const sessionDurationMs = parseNumber(process.env.SESSION_DURATION_MS);
+      if (sessionDurationMs !== undefined) {
+        defaults.sessionDurationMs = sessionDurationMs;
+      }
+      const port = parseNumber(process.env.PORT);
+      if (port !== undefined) {
+        defaults.port = port;
+      }
+      if (this.data.client_id) {
+        defaults.clientId = this.data.client_id;
+      }
+      if (typeof this.data.retry_attempts === "number") {
+        defaults.retry.attempts = this.data.retry_attempts;
+      }
+      if (typeof this.data.max_body_bytes === "number") {
+        defaults.maxBodyBytes = this.data.max_body_bytes;
+      }
+      if (typeof this.data.quota_threshold === "number" && this.data.quota_threshold > 0 && this.data.quota_threshold <= 1) {
+        defaults.quotaThreshold = this.data.quota_threshold;
+      }
+      if (typeof this.data.retry_delay_ms === "number") {
+        defaults.retry.delayMs = this.data.retry_delay_ms;
+      }
+      if (typeof this.data.retry_backoff === "number") {
+        defaults.retry.backoff = this.data.retry_backoff;
+      }
+      if (typeof this.data.request_scoped_429_retry_delay_ms === "number") {
+        defaults.requestScopedRetryDelayMs = this.data.request_scoped_429_retry_delay_ms;
+      }
+      if (typeof this.data.session_duration_ms === "number") {
+        defaults.sessionDurationMs = this.data.session_duration_ms;
+      }
+      if (typeof this.data.port === "number") {
+        defaults.port = this.data.port;
+      }
+      return defaults;
+    }
+  };
+});
+
+// ../../packages/database/src/paths.ts
+import { join as join5 } from "path";
+function resolveDbPath() {
+  const explicitPath = process.env.ccflare_DB_PATH;
+  if (explicitPath) {
+    return explicitPath;
+  }
+  const configDir = getPlatformConfigDir();
+  return join5(configDir, "ccflare.db");
+}
+var init_paths2 = __esm(() => {
+  init_src4();
+});
+
+// ../../packages/database/src/performance-indexes.ts
+function addPerformanceIndexes(db) {
+  log3.info("Adding performance indexes...");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_timestamp_account 
+		ON requests(timestamp DESC, account_used)
+	`);
+  log3.info("Added index: idx_requests_timestamp_account");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_model_timestamp 
+		ON requests(model, timestamp DESC) 
+		WHERE model IS NOT NULL
+	`);
+  log3.info("Added index: idx_requests_model_timestamp");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_success_timestamp 
+		ON requests(success, timestamp DESC)
+	`);
+  log3.info("Added index: idx_requests_success_timestamp");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_accounts_paused 
+		ON accounts(paused) 
+		WHERE paused = 0
+	`);
+  log3.info("Added index: idx_accounts_paused");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_account_timestamp 
+		ON requests(account_used, timestamp DESC)
+	`);
+  log3.info("Added index: idx_requests_account_timestamp");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_cost_model 
+		ON requests(cost_usd, model, timestamp DESC) 
+		WHERE cost_usd > 0 AND model IS NOT NULL
+	`);
+  log3.info("Added index: idx_requests_cost_model");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_response_time 
+		ON requests(model, response_time_ms) 
+		WHERE response_time_ms IS NOT NULL AND model IS NOT NULL
+	`);
+  log3.info("Added index: idx_requests_response_time");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_tokens 
+		ON requests(timestamp DESC, total_tokens) 
+		WHERE total_tokens > 0
+	`);
+  log3.info("Added index: idx_requests_tokens");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_accounts_name 
+		ON accounts(name)
+	`);
+  log3.info("Added index: idx_accounts_name");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_accounts_rate_limited 
+		ON accounts(rate_limited_until) 
+		WHERE rate_limited_until IS NOT NULL
+	`);
+  log3.info("Added index: idx_accounts_rate_limited");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_accounts_session 
+		ON accounts(session_start, session_request_count) 
+		WHERE session_start IS NOT NULL
+	`);
+  log3.info("Added index: idx_accounts_session");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_accounts_request_count 
+		ON accounts(request_count DESC, last_used)
+	`);
+  log3.info("Added index: idx_accounts_request_count");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_response_id
+		ON requests(response_id)
+		WHERE response_id IS NOT NULL
+	`);
+  log3.info("Added index: idx_requests_response_id");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_previous_response_id
+		ON requests(previous_response_id)
+		WHERE previous_response_id IS NOT NULL
+	`);
+  log3.info("Added index: idx_requests_previous_response_id");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_response_chain_timestamp
+		ON requests(response_chain_id, timestamp ASC)
+		WHERE response_chain_id IS NOT NULL
+	`);
+  log3.info("Added index: idx_requests_response_chain_timestamp");
+  db.run(`
+		CREATE INDEX IF NOT EXISTS idx_requests_client_session_timestamp
+		ON requests(client_session_id, timestamp DESC)
+		WHERE client_session_id IS NOT NULL
+	`);
+  log3.info("Added index: idx_requests_client_session_timestamp");
+  log3.info("Performance indexes added successfully");
+}
+function analyzeIndexUsage(db) {
+  log3.info(`
+Analyzing index usage...`);
+  const indexes = db.prepare(`SELECT name, tbl_name, sql 
+			FROM sqlite_master 
+			WHERE type = 'index' AND name NOT LIKE 'sqlite_%'
+			ORDER BY tbl_name, name`).all();
+  log3.info(`
+Total indexes: ${indexes.length}`);
+  for (const index of indexes) {
+    log3.info(`- ${index.name} on ${index.tbl_name}`);
+  }
+  const tables = ["accounts", "requests", "request_payloads"];
+  for (const table of tables) {
+    const count = db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+    log3.info(`
+${table} table: ${count.count} rows`);
+  }
+}
+var log3;
+var init_performance_indexes = __esm(() => {
+  init_src3();
+  log3 = new Logger("PerformanceIndexes");
+});
+
+// ../../packages/database/src/analyze-performance.ts
+function analyzeQueryPerformance(db) {
+  log4.info(`
+=== Query Performance Analysis ===
+`);
+  const testQueries = [
+    {
+      name: "Time-based account analytics",
+      query: `
+				SELECT COUNT(*), account_used 
+				FROM requests 
+				WHERE timestamp > ? AND account_used IS NOT NULL 
+				GROUP BY account_used
+			`,
+      params: [Date.now() - 24 * 60 * 60 * 1000]
+    },
+    {
+      name: "Model performance with timestamp filter",
+      query: `
+				SELECT model, COUNT(*), AVG(response_time_ms)
+				FROM requests 
+				WHERE timestamp > ? AND model IS NOT NULL 
+				GROUP BY model
+			`,
+      params: [Date.now() - 24 * 60 * 60 * 1000]
+    },
+    {
+      name: "Success rate calculation",
+      query: `
+				SELECT 
+					SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 100.0 / COUNT(*) as success_rate
+				FROM requests 
+				WHERE timestamp > ?
+			`,
+      params: [Date.now() - 24 * 60 * 60 * 1000]
+    },
+    {
+      name: "Active accounts lookup",
+      query: `
+				SELECT id, name, request_count 
+				FROM accounts 
+				WHERE paused = 0 
+				ORDER BY request_count DESC
+			`,
+      params: []
+    },
+    {
+      name: "Cost analysis by model",
+      query: `
+				SELECT model, SUM(cost_usd) as total_cost
+				FROM requests 
+				WHERE cost_usd > 0 AND model IS NOT NULL 
+				GROUP BY model 
+				ORDER BY total_cost DESC
+			`,
+      params: []
+    },
+    {
+      name: "P95 response time calculation",
+      query: `
+				WITH ordered_times AS (
+					SELECT 
+						response_time_ms,
+						ROW_NUMBER() OVER (ORDER BY response_time_ms) as row_num,
+						COUNT(*) OVER () as total_count
+					FROM requests 
+					WHERE model = ? AND response_time_ms IS NOT NULL
+				)
+				SELECT response_time_ms as p95_response_time
+				FROM ordered_times
+				WHERE row_num = CAST(CEIL(total_count * 0.95) AS INTEGER)
+				LIMIT 1
+			`,
+      params: ["claude-3-5-sonnet-20241022"]
+    }
+  ];
+  for (const test of testQueries) {
+    log4.info(`
+--- ${test.name} ---`);
+    try {
+      const planStmt = db.prepare(`EXPLAIN QUERY PLAN ${test.query}`);
+      const plan = planStmt.all(...test.params);
+      log4.info("Query Plan:");
+      for (const row of plan) {
+        log4.info(`  ${JSON.stringify(row)}`);
+      }
+      const start = performance.now();
+      const stmt = db.prepare(test.query);
+      const result = stmt.all(...test.params);
+      const duration = performance.now() - start;
+      log4.info(`Execution time: ${duration.toFixed(2)}ms`);
+      log4.info(`Rows returned: ${result.length}`);
+    } catch (error) {
+      log4.error(`Error: ${error}`);
+    }
+  }
+}
+function showIndexStats(db) {
+  log4.info(`
+=== Index Statistics ===
+`);
+  const indexes = db.prepare(`
+			SELECT 
+				m.name as index_name,
+				m.tbl_name as table_name,
+				m.sql as create_sql,
+				s.stat as stat_value
+			FROM sqlite_master m
+			LEFT JOIN sqlite_stat1 s ON m.name = s.idx
+			WHERE m.type = 'index' 
+				AND m.name NOT LIKE 'sqlite_%'
+				AND m.name LIKE 'idx_%'
+			ORDER BY m.tbl_name, m.name
+		`).all();
+  log4.info(`Total performance indexes: ${indexes.length}
+`);
+  let currentTable = "";
+  for (const index of indexes) {
+    if (index.table_name !== currentTable) {
+      currentTable = index.table_name;
+      log4.info(`
+${currentTable}:`);
+    }
+    log4.info(`  - ${index.index_name}`);
+    if (index.stat_value) {
+      log4.info(`    Stats: ${index.stat_value}`);
+    }
+  }
+  log4.info(`
+Running ANALYZE to update statistics...`);
+  db.exec("ANALYZE");
+  log4.info("Statistics updated.");
+}
+function analyzeDatabasePerformance(dbOps) {
+  const db = dbOps.getDatabase();
+  log4.info(`
+=== Database Performance Analysis ===
+`);
+  analyzeIndexUsage(db);
+  showIndexStats(db);
+  analyzeQueryPerformance(db);
+  log4.info(`
+=== Analysis Complete ===
+`);
+}
+var log4;
+var init_analyze_performance = __esm(() => {
+  init_src3();
+  init_paths2();
+  init_performance_indexes();
+  log4 = new Logger("PerformanceAnalysis");
+  if (false) {}
+});
+
+// ../../packages/database/src/async-writer.ts
+class AsyncDbWriter {
+  queue = [];
+  running = false;
+  intervalId = null;
+  failureCount = 0;
+  disposePromise = null;
+  currentRunPromise = null;
+  constructor() {
+    this.intervalId = setInterval(() => void this.processQueue(), 100);
+  }
+  enqueue(job) {
+    this.queue.push(job);
+    this.processQueue();
+  }
+  async processQueue() {
+    if (this.running) {
+      return this.currentRunPromise ?? Promise.resolve();
+    }
+    if (this.queue.length === 0) {
+      return;
+    }
+    this.running = true;
+    this.currentRunPromise = (async () => {
+      try {
+        while (this.queue.length > 0) {
+          const job = this.queue.shift();
+          if (!job)
+            continue;
+          try {
+            await job();
+          } catch (error) {
+            this.failureCount += 1;
+            logger.error("Failed to execute DB job", error);
+          }
+        }
+      } finally {
+        this.running = false;
+        this.currentRunPromise = null;
+      }
+    })();
+    return this.currentRunPromise;
+  }
+  isHealthy() {
+    return this.failureCount === 0;
+  }
+  getFailureCount() {
+    return this.failureCount;
+  }
+  getQueueSize() {
+    return this.queue.length;
+  }
+  async dispose() {
+    if (this.disposePromise) {
+      return this.disposePromise;
+    }
+    this.disposePromise = (async () => {
+      logger.info("Flushing async DB writer queue...");
+      if (this.intervalId) {
+        clearInterval(this.intervalId);
+        this.intervalId = null;
+      }
+      await this.processQueue();
+      logger.info("Async DB writer queue flushed", {
+        remainingJobs: this.queue.length,
+        failureCount: this.failureCount
+      });
+    })();
+    return this.disposePromise;
+  }
+}
+var logger;
+var init_async_writer = __esm(() => {
+  init_src3();
+  logger = new Logger("async-db-writer");
+});
+
+// ../../packages/database/src/migrations.ts
+function getTableInfo(db, tableName) {
+  return db.prepare(`PRAGMA table_info(${tableName})`).all();
+}
+function hasColumn(columns, columnName) {
+  return columns.some((column) => column.name === columnName);
+}
+function getColumn(columns, columnName) {
+  return columns.find((column) => column.name === columnName) ?? null;
+}
+function columnOr(columns, columnName, fallback) {
+  return hasColumn(columns, columnName) ? columnName : fallback;
+}
+function shouldMigrateAccountsTable(columns) {
+  const provider = getColumn(columns, "provider");
+  const refreshToken = getColumn(columns, "refresh_token");
+  const weight = getColumn(columns, "weight");
+  const authMethod = getColumn(columns, "auth_method");
+  const baseUrl = getColumn(columns, "base_url");
+  return !provider || provider.notnull !== 1 || provider.dflt_value !== null || !refreshToken || refreshToken.notnull !== 0 || !weight || weight.notnull !== 1 || weight.dflt_value !== "1" || !authMethod || authMethod.notnull !== 1 || !baseUrl || hasColumn(columns, "account_tier");
+}
+function shouldMigrateRequestsTable(columns) {
+  const provider = getColumn(columns, "provider");
+  const upstreamPath = getColumn(columns, "upstream_path");
+  const reasoningTokens = getColumn(columns, "reasoning_tokens");
+  const responseChainId = getColumn(columns, "response_chain_id");
+  const clientSessionId = getColumn(columns, "client_session_id");
+  const ttftMs = getColumn(columns, "ttft_ms");
+  const proxyOverheadMs = getColumn(columns, "proxy_overhead_ms");
+  const upstreamTtfbMs = getColumn(columns, "upstream_ttfb_ms");
+  const streamingDurationMs = getColumn(columns, "streaming_duration_ms");
+  return !provider || provider.notnull !== 1 || !upstreamPath || upstreamPath.notnull !== 1 || !reasoningTokens || !responseChainId || !clientSessionId || !ttftMs || !proxyOverheadMs || !upstreamTtfbMs || !streamingDurationMs || hasColumn(columns, "conversation_id") || hasColumn(columns, "agent_used");
+}
+function ensureRequestLinkageColumns(db) {
+  const columns = getTableInfo(db, "requests");
+  const requestColumns = [
+    ["response_id", "TEXT"],
+    ["previous_response_id", "TEXT"],
+    ["response_chain_id", "TEXT"],
+    ["client_session_id", "TEXT"],
+    ["ttft_ms", "INTEGER"],
+    ["proxy_overhead_ms", "INTEGER"],
+    ["upstream_ttfb_ms", "INTEGER"],
+    ["streaming_duration_ms", "INTEGER"]
+  ];
+  for (const [columnName, columnType] of requestColumns) {
+    if (!hasColumn(columns, columnName)) {
+      db.run(`ALTER TABLE requests ADD COLUMN ${columnName} ${columnType}`);
+    }
+  }
+}
+function ensureAccountExtensionColumns(db) {
+  const columns = getTableInfo(db, "accounts");
+  const identityColumns = [
+    ["account_uuid", "TEXT"],
+    ["organization_uuid", "TEXT"],
+    ["quota_state", "TEXT"],
+    ["priority", "INTEGER NOT NULL DEFAULT 0"],
+    ["switch_threshold", "TEXT"],
+    ["error_reason", "TEXT"]
+  ];
+  for (const [columnName, columnType] of identityColumns) {
+    if (!hasColumn(columns, columnName)) {
+      db.run(`ALTER TABLE accounts ADD COLUMN ${columnName} ${columnType}`);
+    }
+  }
+}
+function backfillRequestLinkageColumns(db) {
+  const missingCount = db.query(`
+				SELECT COUNT(*) AS count
+				FROM requests
+				WHERE response_chain_id IS NULL OR client_session_id IS NULL
+			`).get();
+  if (!missingCount || missingCount.count === 0) {
+    return;
+  }
+  const rows = db.query(`
+				SELECT
+					r.id,
+					r.timestamp,
+					r.response_id,
+					r.previous_response_id,
+					r.response_chain_id,
+					r.client_session_id,
+					rp.json
+				FROM requests r
+				LEFT JOIN request_payloads rp ON rp.id = r.id
+				ORDER BY r.timestamp ASC
+			`).all();
+  const responseToChain = new Map;
+  let updatedRows = 0;
+  const updateStmt = db.prepare(`
+		UPDATE requests
+		SET
+			previous_response_id = ?,
+			response_id = ?,
+			response_chain_id = ?,
+			client_session_id = ?
+		WHERE id = ?
+	`);
+  db.run("BEGIN");
+  try {
+    for (const row of rows) {
+      let payload = null;
+      if (typeof row.json === "string") {
+        try {
+          payload = JSON.parse(row.json);
+        } catch {
+          payload = null;
+        }
+      }
+      const extracted = extractRequestLinkageFromPayload(payload);
+      const previousResponseId = extracted.previousResponseId ?? row.previous_response_id ?? null;
+      const responseId = extracted.responseId ?? row.response_id ?? null;
+      let responseChainId = row.response_chain_id;
+      const clientSessionId = extracted.clientSessionId ?? row.client_session_id ?? null;
+      if (!responseChainId) {
+        if (previousResponseId) {
+          responseChainId = responseToChain.get(previousResponseId) ?? previousResponseId;
+        } else {
+          responseChainId = responseId ?? row.id;
+        }
+      }
+      if (responseId && responseChainId) {
+        responseToChain.set(responseId, responseChainId);
+      }
+      if (row.previous_response_id !== previousResponseId || row.response_id !== responseId || row.response_chain_id !== responseChainId || row.client_session_id !== clientSessionId) {
+        updateStmt.run(previousResponseId, responseId, responseChainId, clientSessionId, row.id);
+        updatedRows++;
+      }
+    }
+    db.run("COMMIT");
+  } catch (e) {
+    db.run("ROLLBACK");
+    throw e;
+  }
+  if (updatedRows > 0) {
+    log5.info(`Backfilled request linkage for ${updatedRows} requests`);
+  }
+}
+function migrateAccountsTable(db, columns) {
+  const weightExpression = hasColumn(columns, "weight") ? hasColumn(columns, "account_tier") ? "COALESCE(weight, account_tier, 1)" : "COALESCE(weight, 1)" : hasColumn(columns, "account_tier") ? "COALESCE(account_tier, 1)" : "1";
+  db.run(`
+		CREATE TABLE accounts_v2 (
+			id TEXT PRIMARY KEY,
+			name TEXT NOT NULL,
+			provider TEXT NOT NULL,
+			auth_method TEXT NOT NULL,
+			base_url TEXT,
+			api_key TEXT,
+			refresh_token TEXT,
+			access_token TEXT,
+			expires_at INTEGER,
+			created_at INTEGER NOT NULL,
+			last_used INTEGER,
+			request_count INTEGER DEFAULT 0,
+			total_requests INTEGER DEFAULT 0,
+			weight INTEGER NOT NULL DEFAULT 1,
+			priority INTEGER NOT NULL DEFAULT 0,
+			switch_threshold TEXT,
+			rate_limited_until INTEGER,
+			session_start INTEGER,
+			session_request_count INTEGER DEFAULT 0,
+			paused INTEGER DEFAULT 0,
+			error_reason TEXT,
+			rate_limit_reset INTEGER,
+			rate_limit_status TEXT,
+			rate_limit_remaining INTEGER,
+			account_uuid TEXT,
+			organization_uuid TEXT,
+			quota_state TEXT
+		)
+	`);
+  db.run(`
+		INSERT INTO accounts_v2 (
+			id, name, provider, auth_method, base_url, api_key, refresh_token,
+			access_token, expires_at, created_at, last_used, request_count,
+			total_requests, weight, priority, switch_threshold, rate_limited_until, session_start,
+			session_request_count, paused, error_reason, rate_limit_reset, rate_limit_status,
+			rate_limit_remaining, account_uuid, organization_uuid, quota_state
+		)
+		SELECT
+			id,
+			name,
+			${hasColumn(columns, "provider") ? "COALESCE(provider, 'anthropic')" : "'anthropic'"},
+			${hasColumn(columns, "auth_method") ? "COALESCE(auth_method, 'oauth')" : "'oauth'"},
+			${columnOr(columns, "base_url", "NULL")},
+			${columnOr(columns, "api_key", "NULL")},
+			${columnOr(columns, "refresh_token", "NULL")},
+			${columnOr(columns, "access_token", "NULL")},
+			${columnOr(columns, "expires_at", "NULL")},
+			${columnOr(columns, "created_at", "CAST(unixepoch('subsec') * 1000 AS INTEGER)")},
+			${columnOr(columns, "last_used", "NULL")},
+			COALESCE(${columnOr(columns, "request_count", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "total_requests", "NULL")}, 0),
+			${weightExpression},
+			COALESCE(${columnOr(columns, "priority", "NULL")}, 0),
+			${columnOr(columns, "switch_threshold", "NULL")},
+			${columnOr(columns, "rate_limited_until", "NULL")},
+			${columnOr(columns, "session_start", "NULL")},
+			COALESCE(${columnOr(columns, "session_request_count", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "paused", "NULL")}, 0),
+			${columnOr(columns, "error_reason", "NULL")},
+			${columnOr(columns, "rate_limit_reset", "NULL")},
+			${columnOr(columns, "rate_limit_status", "NULL")},
+			${columnOr(columns, "rate_limit_remaining", "NULL")},
+			${columnOr(columns, "account_uuid", "NULL")},
+			${columnOr(columns, "organization_uuid", "NULL")},
+			${columnOr(columns, "quota_state", "NULL")}
+		FROM accounts
+	`);
+  db.run("DROP TABLE accounts");
+  db.run("ALTER TABLE accounts_v2 RENAME TO accounts");
+  log5.info("Migrated accounts table to v2 schema");
+}
+function migrateRequestsTable(db, columns) {
+  db.run(`
+		CREATE TABLE requests_v2 (
+			id TEXT PRIMARY KEY,
+			timestamp INTEGER NOT NULL,
+			method TEXT NOT NULL,
+			path TEXT NOT NULL,
+			provider TEXT NOT NULL DEFAULT '',
+			upstream_path TEXT NOT NULL DEFAULT '',
+			account_used TEXT,
+			status_code INTEGER,
+			success BOOLEAN,
+			error_message TEXT,
+			response_time_ms INTEGER,
+			failover_attempts INTEGER DEFAULT 0,
+			model TEXT,
+			prompt_tokens INTEGER DEFAULT 0,
+			completion_tokens INTEGER DEFAULT 0,
+			total_tokens INTEGER DEFAULT 0,
+			cost_usd REAL DEFAULT 0,
+			output_tokens_per_second REAL,
+			input_tokens INTEGER DEFAULT 0,
+			cache_read_input_tokens INTEGER DEFAULT 0,
+			cache_creation_input_tokens INTEGER DEFAULT 0,
+			output_tokens INTEGER DEFAULT 0,
+			reasoning_tokens INTEGER DEFAULT 0,
+			response_id TEXT,
+			previous_response_id TEXT,
+			response_chain_id TEXT,
+			client_session_id TEXT,
+			ttft_ms INTEGER,
+			proxy_overhead_ms INTEGER,
+			upstream_ttfb_ms INTEGER,
+			streaming_duration_ms INTEGER
+		)
+	`);
+  db.run(`
+		INSERT INTO requests_v2 (
+			id, timestamp, method, path, provider, upstream_path, account_used,
+			status_code, success, error_message, response_time_ms,
+			failover_attempts, model, prompt_tokens, completion_tokens,
+			total_tokens, cost_usd, output_tokens_per_second, input_tokens,
+			cache_read_input_tokens, cache_creation_input_tokens, output_tokens,
+			reasoning_tokens, response_id, previous_response_id, response_chain_id,
+			client_session_id, ttft_ms, proxy_overhead_ms, upstream_ttfb_ms,
+			streaming_duration_ms
+		)
+		SELECT
+			id,
+			timestamp,
+			method,
+			path,
+			${hasColumn(columns, "provider") ? "COALESCE(provider, '')" : "''"},
+			${hasColumn(columns, "upstream_path") ? "COALESCE(upstream_path, '')" : "''"},
+			${columnOr(columns, "account_used", "NULL")},
+			${columnOr(columns, "status_code", "NULL")},
+			${columnOr(columns, "success", "0")},
+			${columnOr(columns, "error_message", "NULL")},
+			${columnOr(columns, "response_time_ms", "NULL")},
+			COALESCE(${columnOr(columns, "failover_attempts", "NULL")}, 0),
+			${columnOr(columns, "model", "NULL")},
+			COALESCE(${columnOr(columns, "prompt_tokens", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "completion_tokens", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "total_tokens", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "cost_usd", "NULL")}, 0),
+			${columnOr(columns, "output_tokens_per_second", "NULL")},
+			COALESCE(${columnOr(columns, "input_tokens", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "cache_read_input_tokens", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "cache_creation_input_tokens", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "output_tokens", "NULL")}, 0),
+			COALESCE(${columnOr(columns, "reasoning_tokens", "NULL")}, 0),
+			${columnOr(columns, "response_id", "NULL")},
+			${columnOr(columns, "previous_response_id", "NULL")},
+			${hasColumn(columns, "response_chain_id") ? "response_chain_id" : columnOr(columns, "conversation_id", "NULL")},
+			${columnOr(columns, "client_session_id", "NULL")},
+			${columnOr(columns, "ttft_ms", "NULL")},
+			${columnOr(columns, "proxy_overhead_ms", "NULL")},
+			${columnOr(columns, "upstream_ttfb_ms", "NULL")},
+			${columnOr(columns, "streaming_duration_ms", "NULL")}
+		FROM requests
+	`);
+  db.run("DROP TABLE requests");
+  db.run("ALTER TABLE requests_v2 RENAME TO requests");
+  log5.info("Migrated requests table to v2 schema");
+}
+function ensureAuthSessionsTable(db) {
+  db.run(`
+		CREATE TABLE IF NOT EXISTS auth_sessions (
+			id TEXT PRIMARY KEY,
+			provider TEXT NOT NULL,
+			auth_method TEXT NOT NULL,
+			account_name TEXT NOT NULL,
+			state_json TEXT NOT NULL,
+			created_at TEXT NOT NULL,
+			expires_at TEXT NOT NULL
+		)
+	`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_auth_sessions_expires ON auth_sessions(expires_at)`);
+}
+function ensureConversationPinsTable(db) {
+  db.run(`
+		CREATE TABLE IF NOT EXISTS conversation_pins (
+			pin_key TEXT PRIMARY KEY,
+			account_id TEXT NOT NULL,
+			last_seen_at INTEGER NOT NULL
+		)
+	`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_conversation_pins_account ON conversation_pins(account_id)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_conversation_pins_last_seen ON conversation_pins(last_seen_at)`);
+}
+function remediateDuplicateAccountNames(db) {
+  const accounts = db.query(`
+				SELECT id, name, created_at
+				FROM accounts
+				ORDER BY name ASC, created_at ASC, id ASC
+			`).all();
+  if (accounts.length < 2) {
+    return;
+  }
+  const duplicateGroups = new Map;
+  const usedNames = new Set(accounts.map((account2) => account2.name));
+  for (const account2 of accounts) {
+    const group = duplicateGroups.get(account2.name);
+    if (group) {
+      group.push(account2);
+      continue;
+    }
+    duplicateGroups.set(account2.name, [account2]);
+  }
+  let renamedCount = 0;
+  for (const [name, group] of duplicateGroups) {
+    if (group.length < 2) {
+      continue;
+    }
+    for (const account2 of group.slice(1)) {
+      let suffix = 2;
+      let candidate = `${name}-${suffix}`;
+      while (usedNames.has(candidate)) {
+        suffix += 1;
+        candidate = `${name}-${suffix}`;
+      }
+      db.run(`UPDATE accounts SET name = ? WHERE id = ?`, [
+        candidate,
+        account2.id
+      ]);
+      usedNames.add(candidate);
+      renamedCount += 1;
+    }
+  }
+  if (renamedCount > 0) {
+    log5.warn(`Renamed ${renamedCount} duplicate account name${renamedCount === 1 ? "" : "s"} before creating the accounts.name unique index`);
+  }
+}
+function ensureAccountsNameUniqueness(db) {
+  remediateDuplicateAccountNames(db);
+  db.run(`CREATE UNIQUE INDEX IF NOT EXISTS idx_accounts_name_unique ON accounts(name)`);
+}
+function ensureSchema(db) {
+  db.run(`
+		CREATE TABLE IF NOT EXISTS accounts (
+			id TEXT PRIMARY KEY,
+			name TEXT NOT NULL,
+			provider TEXT NOT NULL,
+			auth_method TEXT NOT NULL,
+			base_url TEXT,
+			api_key TEXT,
+			refresh_token TEXT,
+			access_token TEXT,
+			expires_at INTEGER,
+			created_at INTEGER NOT NULL,
+			last_used INTEGER,
+			request_count INTEGER DEFAULT 0,
+			total_requests INTEGER DEFAULT 0,
+			weight INTEGER NOT NULL DEFAULT 1,
+			priority INTEGER NOT NULL DEFAULT 0,
+			switch_threshold TEXT,
+			rate_limited_until INTEGER,
+			session_start INTEGER,
+			session_request_count INTEGER DEFAULT 0,
+			paused INTEGER DEFAULT 0,
+			error_reason TEXT,
+			rate_limit_reset INTEGER,
+			rate_limit_status TEXT,
+			rate_limit_remaining INTEGER,
+			account_uuid TEXT,
+			organization_uuid TEXT,
+			quota_state TEXT
+		)
+	`);
+  ensureAccountsNameUniqueness(db);
+  db.run(`
+		CREATE TABLE IF NOT EXISTS requests (
+			id TEXT PRIMARY KEY,
+			timestamp INTEGER NOT NULL,
+			method TEXT NOT NULL,
+			path TEXT NOT NULL,
+			provider TEXT NOT NULL DEFAULT '',
+			upstream_path TEXT NOT NULL DEFAULT '',
+			account_used TEXT,
+			status_code INTEGER,
+			success BOOLEAN,
+			error_message TEXT,
+			response_time_ms INTEGER,
+			failover_attempts INTEGER DEFAULT 0,
+			model TEXT,
+			prompt_tokens INTEGER DEFAULT 0,
+			completion_tokens INTEGER DEFAULT 0,
+			total_tokens INTEGER DEFAULT 0,
+			cost_usd REAL DEFAULT 0,
+			output_tokens_per_second REAL,
+			input_tokens INTEGER DEFAULT 0,
+				cache_read_input_tokens INTEGER DEFAULT 0,
+			cache_creation_input_tokens INTEGER DEFAULT 0,
+			output_tokens INTEGER DEFAULT 0,
+			reasoning_tokens INTEGER DEFAULT 0,
+			response_id TEXT,
+			previous_response_id TEXT,
+			response_chain_id TEXT,
+			client_session_id TEXT,
+			ttft_ms INTEGER,
+			proxy_overhead_ms INTEGER,
+			upstream_ttfb_ms INTEGER,
+			streaming_duration_ms INTEGER
+		)
+	`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_requests_timestamp ON requests(timestamp DESC)`);
+  db.run(`
+		CREATE TABLE IF NOT EXISTS request_payloads (
+			id TEXT PRIMARY KEY,
+			json TEXT NOT NULL,
+			FOREIGN KEY (id) REFERENCES requests(id) ON DELETE CASCADE
+		)
+	`);
+  ensureAuthSessionsTable(db);
+  ensureConversationPinsTable(db);
+}
+function runMigrations(db) {
+  ensureSchema(db);
+  const accountsInfo = getTableInfo(db, "accounts");
+  if (shouldMigrateAccountsTable(accountsInfo)) {
+    migrateAccountsTable(db, accountsInfo);
+  }
+  ensureAccountExtensionColumns(db);
+  const requestsInfo = getTableInfo(db, "requests");
+  if (shouldMigrateRequestsTable(requestsInfo)) {
+    migrateRequestsTable(db, requestsInfo);
+  }
+  ensureRequestLinkageColumns(db);
+  backfillRequestLinkageColumns(db);
+  db.run("DROP TABLE IF EXISTS agent_preferences");
+  db.run("DROP TABLE IF EXISTS oauth_sessions");
+  db.run("DROP INDEX IF EXISTS idx_oauth_sessions_expires");
+  ensureAuthSessionsTable(db);
+  ensureConversationPinsTable(db);
+  ensureAccountsNameUniqueness(db);
+  db.run(`CREATE TABLE IF NOT EXISTS enrollment_contacts (
+		account_id TEXT PRIMARY KEY REFERENCES accounts(id) ON DELETE CASCADE,
+		email TEXT, slack_user_id TEXT
+	)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_requests_timestamp ON requests(timestamp DESC)`);
+  addPerformanceIndexes(db);
+}
+var log5;
+var init_migrations = __esm(() => {
+  init_src3();
+  init_src();
+  init_performance_indexes();
+  log5 = new Logger("DatabaseMigrations");
+});
+
+// ../../packages/database/src/models/account-row.ts
+function parseQuotaState(value) {
+  if (!value)
+    return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && typeof parsed.windows === "object") {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+function parseSwitchThreshold(value) {
+  if (!value)
+    return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "number") {
+      return Number.isFinite(parsed) && parsed > 0 && parsed <= 1 ? parsed : null;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return null;
+    }
+    const entries = Object.entries(parsed).filter(([, entry]) => typeof entry === "number" && Number.isFinite(entry) && entry > 0 && entry <= 1);
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+  } catch {
+    return null;
+  }
+}
+function toAccount(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    provider: row.provider,
+    auth_method: row.auth_method,
+    base_url: row.base_url,
+    api_key: row.api_key,
+    refresh_token: row.refresh_token,
+    access_token: row.access_token,
+    expires_at: row.expires_at,
+    created_at: row.created_at,
+    last_used: row.last_used,
+    request_count: row.request_count,
+    total_requests: row.total_requests,
+    rate_limited_until: row.rate_limited_until ?? null,
+    session_start: row.session_start ?? null,
+    session_request_count: row.session_request_count ?? 0,
+    weight: row.weight || 1,
+    priority: row.priority ?? 0,
+    switch_threshold: parseSwitchThreshold(row.switch_threshold),
+    error_reason: row.error_reason ?? null,
+    paused: row.paused === 1,
+    rate_limit_reset: row.rate_limit_reset ?? null,
+    rate_limit_status: row.rate_limit_status ?? null,
+    rate_limit_remaining: row.rate_limit_remaining ?? null,
+    account_uuid: row.account_uuid ?? null,
+    organization_uuid: row.organization_uuid ?? null,
+    quota_state: parseQuotaState(row.quota_state)
+  };
+}
+
+// ../../packages/database/src/repositories/base.repository.ts
+class BaseRepository {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  query(sql, params = []) {
+    return this.db.query(sql).all(...params);
+  }
+  get(sql, params = []) {
+    const result = this.db.query(sql).get(...params);
+    return result;
+  }
+  run(sql, params = []) {
+    this.db.run(sql, params);
+  }
+  runWithChanges(sql, params = []) {
+    const result = this.db.run(sql, params);
+    return result.changes;
+  }
+}
+
+// ../../packages/database/src/repositories/account.repository.ts
+var accountSelectFields = `
+	id, name, provider, auth_method, base_url, api_key, refresh_token, access_token,
+	expires_at, created_at, last_used, request_count, total_requests,
+	rate_limited_until, session_start, session_request_count,
+	COALESCE(weight, 1) as weight, COALESCE(priority, 0) as priority, switch_threshold,
+	error_reason,
+	COALESCE(paused, 0) as paused,
+	rate_limit_reset, rate_limit_status, rate_limit_remaining,
+	account_uuid, organization_uuid, quota_state
+`, AccountRepository;
+var init_account_repository = __esm(() => {
+  AccountRepository = class AccountRepository extends BaseRepository {
+    setEnrollmentContact(accountId, contact) {
+      this.run("INSERT INTO enrollment_contacts (account_id, email, slack_user_id) VALUES (?, ?, ?)", [accountId, contact.email ?? null, contact.slackUserId ?? null]);
+    }
+    getEnrollmentContact(accountId) {
+      return this.get("SELECT email, slack_user_id AS slackUserId FROM enrollment_contacts WHERE account_id = ?", [accountId]) ?? null;
+    }
+    findAll() {
+      const rows = this.query(`
+			SELECT ${accountSelectFields}
+			FROM accounts
+		`);
+      return rows.map(toAccount);
+    }
+    create(data) {
+      const id = crypto.randomUUID();
+      const createdAt = Date.now();
+      this.run(`
+			INSERT INTO accounts (
+				id, name, provider, auth_method, base_url, api_key, refresh_token,
+				access_token, expires_at, account_uuid, organization_uuid, quota_state, switch_threshold,
+				created_at, request_count, total_requests, weight, priority
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?)
+		`, [
+        id,
+        data.name,
+        data.provider,
+        data.auth_method,
+        data.base_url ?? null,
+        data.api_key ?? null,
+        data.refresh_token ?? null,
+        data.access_token ?? null,
+        data.expires_at ?? null,
+        data.account_uuid ?? null,
+        data.organization_uuid ?? null,
+        data.quota_state ? JSON.stringify(data.quota_state) : null,
+        data.switch_threshold ? JSON.stringify(data.switch_threshold) : null,
+        createdAt,
+        data.weight ?? 1,
+        data.priority ?? 0
+      ]);
+      return this.findById(id);
+    }
+    createApiKeyAccount(opts) {
+      if (this.findByName(opts.name)) {
+        throw new Error(`Account '${opts.name}' already exists`);
+      }
+      return this.create({
+        name: opts.name,
+        provider: opts.provider,
+        auth_method: "api_key",
+        api_key: opts.apiKey,
+        base_url: opts.baseUrl,
+        weight: opts.weight
+      });
+    }
+    createOAuthAccount(opts) {
+      if (this.findByName(opts.name)) {
+        throw new Error(`Account '${opts.name}' already exists`);
+      }
+      return this.create({
+        name: opts.name,
+        provider: opts.provider,
+        auth_method: "oauth",
+        access_token: opts.accessToken,
+        refresh_token: opts.refreshToken,
+        expires_at: opts.expiresAt,
+        account_uuid: opts.accountUuid,
+        organization_uuid: opts.organizationUuid,
+        quota_state: opts.quotaState,
+        base_url: opts.baseUrl,
+        priority: opts.priority,
+        switch_threshold: opts.switchThreshold,
+        weight: opts.weight
+      });
+    }
+    findById(accountId) {
+      const row = this.get(`
+			SELECT
+				${accountSelectFields}
+			FROM accounts
+			WHERE id = ?
+		`, [accountId]);
+      return row ? toAccount(row) : null;
+    }
+    findByName(name) {
+      const row = this.get(`
+			SELECT
+				${accountSelectFields}
+			FROM accounts
+			WHERE name = ?
+		`, [name]);
+      return row ? toAccount(row) : null;
+    }
+    findByProvider(provider) {
+      const rows = this.query(`
+			SELECT
+				${accountSelectFields}
+			FROM accounts
+			WHERE provider = ?
+		`, [provider]);
+      return rows.map(toAccount);
+    }
+    findAvailableForProvider(provider) {
+      const now = Date.now();
+      const rows = this.query(`
+			SELECT
+				${accountSelectFields}
+			FROM accounts
+			WHERE provider = ?
+				AND COALESCE(paused, 0) = 0
+				AND (rate_limited_until IS NULL OR rate_limited_until < ?)
+		`, [provider, now]);
+      return rows.map(toAccount);
+    }
+    update(accountId, data) {
+      const updates = [];
+      const params = [];
+      if (data.name !== undefined) {
+        updates.push("name = ?");
+        params.push(data.name);
+      }
+      if ("base_url" in data) {
+        updates.push("base_url = ?");
+        params.push(data.base_url ?? null);
+      }
+      if (data.priority !== undefined) {
+        updates.push("priority = ?");
+        params.push(data.priority);
+      }
+      if ("switch_threshold" in data) {
+        updates.push("switch_threshold = ?");
+        params.push(data.switch_threshold ? JSON.stringify(data.switch_threshold) : null);
+      }
+      if (updates.length === 0) {
+        return this.findById(accountId);
+      }
+      params.push(accountId);
+      const changes = this.runWithChanges(`UPDATE accounts SET ${updates.join(", ")} WHERE id = ?`, params);
+      return changes > 0 ? this.findById(accountId) : null;
+    }
+    delete(accountId) {
+      return this.runWithChanges(`DELETE FROM accounts WHERE id = ?`, [accountId]) > 0;
+    }
+    count() {
+      const result = this.get("SELECT COUNT(*) as count FROM accounts");
+      return result?.count ?? 0;
+    }
+    updateTokens(accountId, accessToken, expiresAt, refreshToken) {
+      if (refreshToken) {
+        this.run(`UPDATE accounts SET access_token = ?, expires_at = ?, refresh_token = ? WHERE id = ?`, [accessToken, expiresAt, refreshToken, accountId]);
+      } else {
+        this.run(`UPDATE accounts SET access_token = ?, expires_at = ? WHERE id = ?`, [accessToken, expiresAt, accountId]);
+      }
+    }
+    updateQuotaState(accountId, quotaState) {
+      this.run(`UPDATE accounts SET quota_state = ? WHERE id = ?`, [
+        JSON.stringify(quotaState),
+        accountId
+      ]);
+    }
+    incrementUsage(accountId, sessionDurationMs) {
+      const now = Date.now();
+      this.run(`
+			UPDATE accounts 
+			SET 
+				last_used = ?,
+				request_count = request_count + 1,
+				total_requests = total_requests + 1,
+				session_start = CASE
+					WHEN session_start IS NULL OR ? - session_start >= ? THEN ?
+					ELSE session_start
+				END,
+				session_request_count = CASE
+					WHEN session_start IS NULL OR ? - session_start >= ? THEN 1
+					ELSE session_request_count + 1
+				END
+			WHERE id = ?
+		`, [now, now, sessionDurationMs, now, now, sessionDurationMs, accountId]);
+    }
+    setRateLimited(accountId, until) {
+      this.run(`UPDATE accounts SET rate_limited_until = ? WHERE id = ?`, [
+        until,
+        accountId
+      ]);
+    }
+    updateRateLimitMeta(accountId, status, reset, remaining) {
+      this.run(`UPDATE accounts SET rate_limit_status = ?, rate_limit_reset = ?, rate_limit_remaining = ? WHERE id = ?`, [status, reset, remaining ?? null, accountId]);
+    }
+    pause(accountId) {
+      this.run(`UPDATE accounts SET paused = 1, error_reason = NULL WHERE id = ?`, [accountId]);
+    }
+    markError(accountId, reason) {
+      this.run(`UPDATE accounts SET paused = 1, error_reason = ? WHERE id = ?`, [
+        reason,
+        accountId
+      ]);
+    }
+    resume(accountId) {
+      this.run(`UPDATE accounts SET paused = 0, error_reason = NULL WHERE id = ?`, [accountId]);
+    }
+    resetSession(accountId, timestamp) {
+      this.run(`UPDATE accounts SET session_start = ?, session_request_count = 0 WHERE id = ?`, [timestamp, accountId]);
+    }
+    updateRequestCount(accountId, count) {
+      this.run(`UPDATE accounts SET session_request_count = ? WHERE id = ?`, [
+        count,
+        accountId
+      ]);
+    }
+    resetStatistics(resetSessionStart = false) {
+      if (resetSessionStart) {
+        this.run(`UPDATE accounts SET request_count = 0, session_start = NULL, session_request_count = 0`);
+        return;
+      }
+      this.run(`UPDATE accounts SET request_count = 0, session_request_count = 0`);
+    }
+  };
+});
+
+// ../../packages/database/src/repositories/analytics.repository.ts
+var AnalyticsRepository;
+var init_analytics_repository = __esm(() => {
+  init_src();
+  AnalyticsRepository = class AnalyticsRepository extends BaseRepository {
+    getAnalytics(options) {
+      const includeModelBreakdown = options.includeModelBreakdown === true;
+      const { whereClause, queryParams } = this.buildFilters(options);
+      const combined = this.get(`
+				SELECT
+					COUNT(*) as total_requests,
+					SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 100.0 /
+						NULLIF(SUM(CASE WHEN success IS NOT NULL THEN 1 ELSE 0 END), 0) as success_rate,
+					AVG(response_time_ms) as avg_response_time,
+					SUM(COALESCE(total_tokens, 0)) as total_tokens,
+					SUM(COALESCE(cost_usd, 0)) as total_cost_usd,
+					AVG(output_tokens_per_second) as avg_tokens_per_second,
+					COUNT(DISTINCT COALESCE(account_used, ?)) as active_accounts,
+					SUM(COALESCE(input_tokens, 0)) as input_tokens,
+					SUM(COALESCE(cache_read_input_tokens, 0)) as cache_read_input_tokens,
+					SUM(COALESCE(cache_creation_input_tokens, 0)) as cache_creation_input_tokens,
+					SUM(COALESCE(output_tokens, 0)) as output_tokens
+				FROM requests r
+				WHERE ${whereClause}
+			`, [NO_ACCOUNT_ID, ...queryParams]);
+      const timeSeries = this.query(`
+				SELECT
+					(timestamp / ?) * ? as ts,
+					${includeModelBreakdown ? "model," : ""}
+					COUNT(*) as requests,
+					SUM(COALESCE(total_tokens, 0)) as tokens,
+					SUM(COALESCE(cost_usd, 0)) as cost_usd,
+					SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 100.0 /
+						NULLIF(SUM(CASE WHEN success IS NOT NULL THEN 1 ELSE 0 END), 0) as success_rate,
+					SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) * 100.0 /
+						NULLIF(SUM(CASE WHEN success IS NOT NULL THEN 1 ELSE 0 END), 0) as error_rate,
+					SUM(COALESCE(cache_read_input_tokens, 0)) * 100.0 /
+						NULLIF(SUM(COALESCE(input_tokens, 0) + COALESCE(cache_read_input_tokens, 0) + COALESCE(cache_creation_input_tokens, 0)), 0) as cache_hit_rate,
+					AVG(response_time_ms) as avg_response_time,
+					AVG(output_tokens_per_second) as avg_tokens_per_second
+				FROM requests r
+				WHERE ${whereClause} ${includeModelBreakdown ? "AND model IS NOT NULL" : ""}
+				GROUP BY ts${includeModelBreakdown ? ", model" : ""}
+				ORDER BY ts${includeModelBreakdown ? ", model" : ""}
+			`, [options.bucketMs, options.bucketMs, ...queryParams]);
+      const modelDistribution = this.query(`
+				SELECT
+					model,
+					COUNT(*) as count
+				FROM requests r
+				WHERE ${whereClause} AND model IS NOT NULL
+				GROUP BY model
+				ORDER BY count DESC
+				LIMIT 10
+			`, queryParams);
+      const accountPerformance = this.query(`
+				SELECT
+					COALESCE(a.name, ?) as name,
+					COUNT(r.id) as requests,
+					SUM(CASE WHEN r.success = 1 THEN 1 ELSE 0 END) * 100.0 /
+						NULLIF(SUM(CASE WHEN r.success IS NOT NULL THEN 1 ELSE 0 END), 0) as success_rate
+				FROM requests r
+				LEFT JOIN accounts a ON a.id = r.account_used
+				WHERE ${whereClause}
+				GROUP BY name
+				HAVING requests > 0
+				ORDER BY requests DESC
+			`, [NO_ACCOUNT_ID, ...queryParams]);
+      const providerBreakdown = this.query(`
+				SELECT
+					r.provider as provider,
+					COUNT(*) as requests,
+					SUM(CASE WHEN r.success = 1 THEN 1 ELSE 0 END) * 100.0 /
+						NULLIF(SUM(CASE WHEN r.success IS NOT NULL THEN 1 ELSE 0 END), 0) as success_rate,
+					SUM(COALESCE(r.total_tokens, 0)) as total_tokens,
+					SUM(COALESCE(r.cost_usd, 0)) as total_cost_usd
+				FROM requests r
+				WHERE ${whereClause}
+				GROUP BY r.provider
+				ORDER BY requests DESC
+			`, queryParams).map((row) => ({
+        provider: row.provider,
+        requests: row.requests,
+        successRate: row.success_rate ?? 0,
+        totalTokens: row.total_tokens ?? 0,
+        totalCostUsd: row.total_cost_usd ?? 0
+      }));
+      const modelPerformance = this.query(`
+				WITH model_stats AS (
+					SELECT
+						model,
+						AVG(response_time_ms) as avg_response_time,
+						COUNT(*) as total_requests,
+						SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) * 100.0 /
+							NULLIF(SUM(CASE WHEN success IS NOT NULL THEN 1 ELSE 0 END), 0) as error_rate,
+						AVG(output_tokens_per_second) as avg_tokens_per_second,
+						MIN(CASE WHEN output_tokens_per_second > 0 THEN output_tokens_per_second ELSE NULL END) as min_tokens_per_second,
+						MAX(output_tokens_per_second) as max_tokens_per_second
+					FROM requests r
+					WHERE ${whereClause} AND model IS NOT NULL
+					GROUP BY model
+					ORDER BY total_requests DESC
+					LIMIT 10
+				),
+				ranked_times AS (
+					SELECT
+						r.model,
+						r.response_time_ms,
+						ROW_NUMBER() OVER (PARTITION BY r.model ORDER BY r.response_time_ms) as row_num,
+						COUNT(*) OVER (PARTITION BY r.model) as total_count
+					FROM requests r
+					INNER JOIN model_stats ms ON ms.model = r.model
+					WHERE ${whereClause} AND r.response_time_ms IS NOT NULL
+				)
+				SELECT
+					ms.*,
+					rt.response_time_ms as p95_response_time
+				FROM model_stats ms
+				LEFT JOIN ranked_times rt
+					ON rt.model = ms.model
+					AND rt.row_num = CAST(CEIL(rt.total_count * 0.95) AS INTEGER)
+				ORDER BY ms.total_requests DESC
+			`, [...queryParams, ...queryParams]).map((row) => ({
+        model: row.model,
+        avgResponseTime: row.avg_response_time ?? 0,
+        p95ResponseTime: row.p95_response_time ?? row.avg_response_time ?? 0,
+        errorRate: row.error_rate ?? 0,
+        avgTokensPerSecond: row.avg_tokens_per_second ?? null,
+        minTokensPerSecond: row.min_tokens_per_second ?? null,
+        maxTokensPerSecond: row.max_tokens_per_second ?? null
+      }));
+      const costByModel = this.query(`
+				SELECT
+					model,
+					SUM(COALESCE(cost_usd, 0)) as cost_usd,
+					COUNT(*) as requests,
+					SUM(COALESCE(total_tokens, 0)) as total_tokens
+				FROM requests r
+				WHERE ${whereClause} AND COALESCE(cost_usd, 0) > 0 AND model IS NOT NULL
+				GROUP BY model
+				ORDER BY cost_usd DESC
+				LIMIT 10
+			`, queryParams).map((row) => ({
+        model: row.model,
+        costUsd: row.cost_usd ?? 0,
+        requests: row.requests,
+        totalTokens: row.total_tokens ?? 0
+      }));
+      return {
+        totals: {
+          requests: combined?.total_requests ?? 0,
+          successRate: combined?.success_rate ?? 0,
+          activeAccounts: combined?.active_accounts ?? 0,
+          avgResponseTime: combined?.avg_response_time ?? 0,
+          totalTokens: combined?.total_tokens ?? 0,
+          totalCostUsd: combined?.total_cost_usd ?? 0,
+          avgTokensPerSecond: combined?.avg_tokens_per_second ?? null
+        },
+        timeSeries: timeSeries.map((point) => ({
+          ts: point.ts,
+          ...point.model ? { model: point.model } : {},
+          requests: point.requests,
+          tokens: point.tokens ?? 0,
+          costUsd: point.cost_usd ?? 0,
+          successRate: point.success_rate ?? 0,
+          errorRate: point.error_rate ?? 0,
+          cacheHitRate: point.cache_hit_rate ?? 0,
+          avgResponseTime: point.avg_response_time ?? 0,
+          avgTokensPerSecond: point.avg_tokens_per_second ?? null
+        })),
+        tokenBreakdown: {
+          inputTokens: combined?.input_tokens ?? 0,
+          cacheReadInputTokens: combined?.cache_read_input_tokens ?? 0,
+          cacheCreationInputTokens: combined?.cache_creation_input_tokens ?? 0,
+          outputTokens: combined?.output_tokens ?? 0
+        },
+        modelDistribution,
+        accountPerformance: accountPerformance.map((account2) => ({
+          name: account2.name,
+          requests: account2.requests,
+          successRate: account2.success_rate ?? 0
+        })),
+        providerBreakdown,
+        costByModel,
+        modelPerformance
+      };
+    }
+    buildFilters(options) {
+      const conditions = ["timestamp > ?"];
+      const queryParams = [options.startMs];
+      const accounts = options.accounts ?? [];
+      const models = options.models ?? [];
+      const providers = options.providers ?? [];
+      const status = options.status ?? "all";
+      if (accounts.length > 0) {
+        const placeholders = accounts.map(() => "?").join(",");
+        conditions.push(`(
+				r.account_used IN (SELECT id FROM accounts WHERE name IN (${placeholders}))
+				OR (r.account_used = ? AND ? IN (${placeholders}))
+			)`);
+        queryParams.push(...accounts, NO_ACCOUNT_ID, NO_ACCOUNT_ID, ...accounts);
+      }
+      if (models.length > 0) {
+        const placeholders = models.map(() => "?").join(",");
+        conditions.push(`model IN (${placeholders})`);
+        queryParams.push(...models);
+      }
+      if (providers.length > 0) {
+        const placeholders = providers.map(() => "?").join(",");
+        conditions.push(`r.provider IN (${placeholders})`);
+        queryParams.push(...providers);
+      }
+      if (status === "success") {
+        conditions.push("success = 1");
+      } else if (status === "error") {
+        conditions.push("success = 0");
+      }
+      return {
+        whereClause: conditions.join(" AND "),
+        queryParams
+      };
+    }
+  };
+});
+
+// ../../packages/database/src/repositories/auth-session.repository.ts
+var AuthSessionRepository;
+var init_auth_session_repository = __esm(() => {
+  AuthSessionRepository = class AuthSessionRepository extends BaseRepository {
+    getActiveRowById(id) {
+      return this.get(`
+			SELECT
+				id,
+				provider,
+				auth_method,
+				account_name,
+				state_json,
+				created_at,
+				expires_at
+			FROM auth_sessions
+			WHERE id = ? AND expires_at > ?
+		`, [id, new Date().toISOString()]);
+    }
+    getActiveRowByState(state) {
+      return this.get(`
+			SELECT
+				id,
+				provider,
+				auth_method,
+				account_name,
+				state_json,
+				created_at,
+				expires_at
+			FROM auth_sessions
+			WHERE expires_at > ?
+				AND json_valid(state_json) = 1
+				AND json_extract(state_json, '$.state') = ?
+		`, [new Date().toISOString(), state]);
+    }
+    toAuthSession(row) {
+      return {
+        id: row.id,
+        provider: row.provider,
+        authMethod: row.auth_method,
+        accountName: row.account_name,
+        stateJson: row.state_json,
+        createdAt: row.created_at,
+        expiresAt: row.expires_at
+      };
+    }
+    createSession(provider, authMethod, accountName, stateJson, expiresAt) {
+      const id = crypto.randomUUID();
+      const createdAt = new Date().toISOString();
+      const expiresAtIso = new Date(expiresAt).toISOString();
+      this.run(`
+			INSERT INTO auth_sessions (
+				id,
+				provider,
+				auth_method,
+				account_name,
+				state_json,
+				created_at,
+				expires_at
+			)
+			VALUES (?, ?, ?, ?, ?, ?, ?)
+		`, [
+        id,
+        provider,
+        authMethod,
+        accountName,
+        stateJson,
+        createdAt,
+        expiresAtIso
+      ]);
+      return id;
+    }
+    getSession(id) {
+      const row = this.getActiveRowById(id);
+      if (!row) {
+        return null;
+      }
+      return this.toAuthSession(row);
+    }
+    getSessionByState(state) {
+      const row = this.getActiveRowByState(state);
+      if (!row) {
+        return null;
+      }
+      return this.toAuthSession(row);
+    }
+    updateSessionState(id, stateJson, expiresAt) {
+      if (typeof expiresAt === "number") {
+        this.run("UPDATE auth_sessions SET state_json = ?, expires_at = ? WHERE id = ?", [stateJson, new Date(expiresAt).toISOString(), id]);
+        return;
+      }
+      this.run("UPDATE auth_sessions SET state_json = ? WHERE id = ?", [
+        stateJson,
+        id
+      ]);
+    }
+    deleteSession(id) {
+      this.run("DELETE FROM auth_sessions WHERE id = ?", [id]);
+    }
+    deleteExpiredSessions() {
+      return this.runWithChanges("DELETE FROM auth_sessions WHERE expires_at <= ?", [new Date().toISOString()]);
+    }
+  };
+});
+
+// ../../packages/database/src/repositories/conversation-pin.repository.ts
+var ConversationPinRepository;
+var init_conversation_pin_repository = __esm(() => {
+  ConversationPinRepository = class ConversationPinRepository extends BaseRepository {
+    find(pinKey) {
+      const row = this.get(`SELECT account_id, last_seen_at FROM conversation_pins WHERE pin_key = ?`, [pinKey]);
+      return row ? { accountId: row.account_id, lastSeenAt: row.last_seen_at } : null;
+    }
+    upsert(pinKey, accountId, lastSeenAt) {
+      this.run(`
+				INSERT INTO conversation_pins (pin_key, account_id, last_seen_at)
+				VALUES (?, ?, ?)
+				ON CONFLICT(pin_key) DO UPDATE SET
+					account_id = excluded.account_id,
+					last_seen_at = excluded.last_seen_at
+			`, [pinKey, accountId, lastSeenAt]);
+    }
+    countByAccount(activeSince) {
+      const rows = this.query(`
+				SELECT account_id, COUNT(*) AS count
+				FROM conversation_pins
+				WHERE last_seen_at >= ?
+				GROUP BY account_id
+			`, [activeSince]);
+      return new Map(rows.map((row) => [row.account_id, row.count]));
+    }
+    deleteExpired(before) {
+      this.run(`DELETE FROM conversation_pins WHERE last_seen_at < ?`, [before]);
+    }
+    deleteForAccount(accountId) {
+      this.run(`DELETE FROM conversation_pins WHERE account_id = ?`, [accountId]);
+    }
+  };
+});
+
+// ../../packages/database/src/models/request-row.ts
+function toRequest(row) {
+  return {
+    id: row.id,
+    timestamp: row.timestamp,
+    method: row.method,
+    path: row.path,
+    provider: row.provider,
+    upstreamPath: row.upstream_path,
+    accountUsed: row.account_used,
+    statusCode: row.status_code,
+    success: row.success === null ? null : row.success === 1,
+    errorMessage: row.error_message,
+    responseTimeMs: row.response_time_ms,
+    failoverAttempts: row.failover_attempts,
+    model: row.model ?? null,
+    promptTokens: row.prompt_tokens ?? null,
+    completionTokens: row.completion_tokens ?? null,
+    totalTokens: row.total_tokens ?? null,
+    costUsd: row.cost_usd ?? null,
+    inputTokens: row.input_tokens ?? null,
+    cacheReadInputTokens: row.cache_read_input_tokens ?? null,
+    cacheCreationInputTokens: row.cache_creation_input_tokens ?? null,
+    outputTokens: row.output_tokens ?? null,
+    reasoningTokens: row.reasoning_tokens ?? null,
+    tokensPerSecond: row.output_tokens_per_second ?? null,
+    ttftMs: row.ttft_ms ?? null,
+    proxyOverheadMs: row.proxy_overhead_ms ?? null,
+    upstreamTtfbMs: row.upstream_ttfb_ms ?? null,
+    streamingDurationMs: row.streaming_duration_ms ?? null,
+    responseId: row.response_id ?? null,
+    previousResponseId: row.previous_response_id ?? null,
+    responseChainId: row.response_chain_id ?? null,
+    clientSessionId: row.client_session_id ?? null
+  };
+}
+function toRequestWithAccountName(row) {
+  return {
+    ...toRequest(row),
+    accountName: row.account_name ?? null
+  };
+}
+
+// ../../packages/database/src/repositories/request.repository.ts
+function requestLinkageFromPayload(payload) {
+  const fromBodies = extractRequestLinkageFromPayload(payload);
+  const trace = isRecord(payload) && isRecord(payload.meta) ? payload.meta.trace : null;
+  if (!isRecord(trace)) {
+    return fromBodies;
+  }
+  return {
+    previousResponseId: typeof trace.previousResponseId === "string" ? trace.previousResponseId : fromBodies.previousResponseId,
+    responseId: typeof trace.responseId === "string" ? trace.responseId : fromBodies.responseId,
+    clientSessionId: typeof trace.clientSessionId === "string" ? trace.clientSessionId : fromBodies.clientSessionId
+  };
+}
+var log6, RequestRepository;
+var init_request_repository = __esm(() => {
+  init_src3();
+  init_src();
+  log6 = new Logger("RequestRepository");
+  RequestRepository = class RequestRepository extends BaseRepository {
+    saveMeta(id, method, path, provider, upstreamPath, accountUsed, statusCode, timestamp) {
+      this.run(`
+			INSERT INTO requests (
+				id, timestamp, method, path, provider, upstream_path, account_used, 
+				status_code, success, error_message, response_time_ms, failover_attempts
+			)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, 0)
+		`, [
+        id,
+        timestamp ?? Date.now(),
+        method,
+        path,
+        provider,
+        upstreamPath,
+        accountUsed,
+        statusCode
+      ]);
+    }
+    save(data) {
+      const { usage, timings } = data;
+      const payloadJson = data.payload === undefined ? undefined : JSON.stringify(data.payload);
+      const linkage = requestLinkageFromPayload(data.payload);
+      const responseChainId = this.resolveResponseChainId(linkage.previousResponseId, linkage.responseId, data.id);
+      this.db.run("BEGIN");
+      try {
+        this.run(`
+				INSERT OR IGNORE INTO requests (
+					id, timestamp, method, path, provider, upstream_path, account_used,
+					status_code, success, error_message, response_time_ms, failover_attempts
+				)
+				VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, 0)
+			`, [
+          data.id,
+          data.timestamp ?? Date.now(),
+          data.method,
+          data.path,
+          data.provider,
+          data.upstreamPath,
+          data.accountUsed,
+          data.statusCode
+        ]);
+        this.run(`
+				UPDATE requests
+				SET
+					method = ?,
+					path = ?,
+					provider = ?,
+					upstream_path = ?,
+					account_used = ?,
+					status_code = ?,
+					success = ?,
+					error_message = ?,
+					response_time_ms = ?,
+					failover_attempts = ?,
+					model = ?,
+					prompt_tokens = ?,
+					completion_tokens = ?,
+					total_tokens = ?,
+					cost_usd = ?,
+					input_tokens = ?,
+					cache_read_input_tokens = ?,
+					cache_creation_input_tokens = ?,
+					output_tokens = ?,
+					reasoning_tokens = ?,
+					output_tokens_per_second = ?,
+					ttft_ms = ?,
+					proxy_overhead_ms = ?,
+					upstream_ttfb_ms = ?,
+					streaming_duration_ms = ?,
+					response_id = ?,
+					previous_response_id = ?,
+					response_chain_id = ?,
+					client_session_id = ?
+				WHERE id = ?
+			`, [
+          data.method,
+          data.path,
+          data.provider,
+          data.upstreamPath,
+          data.accountUsed,
+          data.statusCode,
+          data.success ? 1 : 0,
+          data.errorMessage,
+          data.responseTime,
+          data.failoverAttempts,
+          usage?.model ?? null,
+          usage?.promptTokens ?? null,
+          usage?.completionTokens ?? null,
+          usage?.totalTokens ?? null,
+          usage?.costUsd ?? null,
+          usage?.inputTokens ?? null,
+          usage?.cacheReadInputTokens ?? null,
+          usage?.cacheCreationInputTokens ?? null,
+          usage?.outputTokens ?? null,
+          usage?.reasoningTokens ?? null,
+          usage?.tokensPerSecond ?? null,
+          timings?.ttftMs ?? null,
+          timings?.proxyOverheadMs ?? null,
+          timings?.upstreamTtfbMs ?? null,
+          timings?.streamingDurationMs ?? null,
+          linkage.responseId,
+          linkage.previousResponseId,
+          responseChainId,
+          linkage.clientSessionId,
+          data.id
+        ]);
+        if (payloadJson !== undefined) {
+          this.run(`
+					INSERT INTO request_payloads (id, json)
+					VALUES (?, ?)
+					ON CONFLICT(id) DO UPDATE SET json = excluded.json
+				`, [data.id, payloadJson]);
+        }
+        this.db.run("COMMIT");
+      } catch (error) {
+        this.db.run("ROLLBACK");
+        throw error;
+      }
+    }
+    resolveResponseChainId(previousResponseId, responseId, requestId) {
+      if (previousResponseId) {
+        const parentRow = this.get(`
+					SELECT response_chain_id
+					FROM requests
+					WHERE response_id = ?
+					LIMIT 1
+				`, [previousResponseId]);
+        return parentRow?.response_chain_id ?? previousResponseId;
+      }
+      return responseId ?? requestId;
+    }
+    updateUsage(requestId, usage) {
+      if (!usage)
+        return;
+      this.run(`
+			UPDATE requests
+			SET 
+				model = COALESCE(?, model),
+				prompt_tokens = COALESCE(?, prompt_tokens),
+				completion_tokens = COALESCE(?, completion_tokens),
+				total_tokens = COALESCE(?, total_tokens),
+				cost_usd = COALESCE(?, cost_usd),
+				input_tokens = COALESCE(?, input_tokens),
+				cache_read_input_tokens = COALESCE(?, cache_read_input_tokens),
+				cache_creation_input_tokens = COALESCE(?, cache_creation_input_tokens),
+				output_tokens = COALESCE(?, output_tokens),
+				reasoning_tokens = COALESCE(?, reasoning_tokens),
+				output_tokens_per_second = COALESCE(?, output_tokens_per_second)
+			WHERE id = ?
+		`, [
+        usage.model ?? null,
+        usage.promptTokens ?? null,
+        usage.completionTokens ?? null,
+        usage.totalTokens ?? null,
+        usage.costUsd ?? null,
+        usage.inputTokens ?? null,
+        usage.cacheReadInputTokens ?? null,
+        usage.cacheCreationInputTokens ?? null,
+        usage.outputTokens ?? null,
+        usage.reasoningTokens ?? null,
+        usage.tokensPerSecond ?? null,
+        requestId
+      ]);
+    }
+    savePayload(id, data) {
+      const json = JSON.stringify(data);
+      this.run(`
+			INSERT INTO request_payloads (id, json)
+			VALUES (?, ?)
+			ON CONFLICT(id) DO UPDATE SET json = excluded.json
+		`, [id, json]);
+    }
+    getPayload(id) {
+      const row = this.get(`SELECT json FROM request_payloads WHERE id = ?`, [id]);
+      if (!row)
+        return null;
+      try {
+        return JSON.parse(row.json);
+      } catch (error) {
+        log6.warn(`Failed to parse request payload for ${id}`, error);
+        return null;
+      }
+    }
+    listPayloads(limit = 50) {
+      return this.query(`
+			SELECT rp.id, rp.json 
+			FROM request_payloads rp
+			JOIN requests r ON rp.id = r.id
+			ORDER BY r.timestamp DESC
+			LIMIT ?
+		`, [limit]);
+    }
+    listPayloadsWithAccountNames(limit = 50) {
+      return this.query(`
+			SELECT rp.id, rp.json, a.name as account_name
+			FROM request_payloads rp
+			JOIN requests r ON rp.id = r.id
+			LEFT JOIN accounts a ON r.account_used = a.id
+			ORDER BY r.timestamp DESC
+			LIMIT ?
+		`, [limit]);
+    }
+    listResponseChainPayloadsWithAccountNames(requestId) {
+      return this.query(`
+				WITH RECURSIVE chain AS (
+					SELECT
+						r.id,
+						r.previous_response_id,
+						0 AS depth,
+						(',' || r.id || ',') AS visited
+					FROM requests r
+					WHERE r.id = ?
+					UNION ALL
+					SELECT
+						parent.id,
+						parent.previous_response_id,
+						chain.depth + 1 AS depth,
+						(chain.visited || parent.id || ',') AS visited
+					FROM chain
+					JOIN requests parent
+						ON parent.response_id = chain.previous_response_id
+					WHERE
+						chain.previous_response_id IS NOT NULL
+						AND instr(chain.visited, ',' || parent.id || ',') = 0
+				)
+				SELECT rp.id, rp.json, a.name AS account_name
+				FROM chain
+				JOIN requests r ON r.id = chain.id
+				JOIN request_payloads rp ON rp.id = r.id
+				LEFT JOIN accounts a ON r.account_used = a.id
+				ORDER BY chain.depth DESC, r.timestamp ASC
+			`, [requestId]);
+    }
+    getRecentRequests(limit = 100) {
+      return this.query(`
+				SELECT *
+				FROM requests
+				ORDER BY timestamp DESC
+				LIMIT ?
+			`, [limit]).flatMap((row) => {
+        if (!isHttpMethod(row.method) || row.provider.length === 0) {
+          return [];
+        }
+        return [toRequest(row)];
+      });
+    }
+    listSummaries(limit = 100) {
+      return this.query(`
+				SELECT r.*, a.name as account_name
+				FROM requests r
+				LEFT JOIN accounts a ON r.account_used = a.id
+				ORDER BY r.timestamp DESC
+				LIMIT ?
+			`, [limit]).flatMap((row) => {
+        if (!isHttpMethod(row.method) || row.provider.length === 0) {
+          return [];
+        }
+        return [
+          {
+            ...toRequestSummary(toRequest(row)),
+            accountName: row.account_name ?? null
+          }
+        ];
+      });
+    }
+    listWithAccountNames(limit = 100) {
+      return this.query(`
+				SELECT r.*, a.name as account_name
+				FROM requests r
+				LEFT JOIN accounts a ON r.account_used = a.id
+				ORDER BY r.timestamp DESC
+				LIMIT ?
+			`, [limit]).flatMap((row) => {
+        if (!isHttpMethod(row.method) || row.provider.length === 0) {
+          return [];
+        }
+        return [toRequestWithAccountName(row)];
+      });
+    }
+    getRequestStats(since) {
+      const whereClause = since ? "WHERE timestamp > ?" : "";
+      const params = since ? [since] : [];
+      const result = this.get(`
+			SELECT 
+				COUNT(*) as total_requests,
+				SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as successful_requests,
+				SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failed_requests,
+				AVG(response_time_ms) as avg_response_time
+			FROM requests
+			${whereClause}
+		`, params);
+      return {
+        totalRequests: result?.total_requests ?? 0,
+        successfulRequests: result?.successful_requests ?? 0,
+        failedRequests: result?.failed_requests ?? 0,
+        avgResponseTime: result?.avg_response_time ?? null
+      };
+    }
+    aggregateStats(rangeMs) {
+      const whereClause = rangeMs ? "WHERE timestamp > ?" : "";
+      const params = rangeMs ? [Date.now() - rangeMs] : [];
+      const result = this.get(`
+			SELECT 
+				COUNT(*) as total_requests,
+				SUM(CASE WHEN success IS NOT NULL THEN 1 ELSE 0 END) as completed_requests,
+				SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as successful_requests,
+				AVG(response_time_ms) as avg_response_time,
+				SUM(
+					COALESCE(
+						total_tokens,
+						COALESCE(input_tokens, 0) +
+							COALESCE(output_tokens, 0) +
+							COALESCE(cache_read_input_tokens, 0) +
+							COALESCE(cache_creation_input_tokens, 0)
+					)
+				) as total_tokens,
+				SUM(cost_usd) as total_cost_usd,
+				SUM(input_tokens) as input_tokens,
+				SUM(output_tokens) as output_tokens,
+				SUM(cache_read_input_tokens) as cache_read_input_tokens,
+				SUM(cache_creation_input_tokens) as cache_creation_input_tokens,
+				AVG(output_tokens_per_second) as avg_tokens_per_second
+			FROM requests
+			${whereClause}
+		`, params);
+      return {
+        totalRequests: result?.total_requests ?? 0,
+        completedRequests: result?.completed_requests ?? 0,
+        successfulRequests: result?.successful_requests ?? 0,
+        avgResponseTime: result?.avg_response_time ?? null,
+        totalTokens: result?.total_tokens ?? 0,
+        totalCostUsd: result?.total_cost_usd ?? 0,
+        inputTokens: result?.input_tokens ?? 0,
+        outputTokens: result?.output_tokens ?? 0,
+        cacheReadInputTokens: result?.cache_read_input_tokens ?? 0,
+        cacheCreationInputTokens: result?.cache_creation_input_tokens ?? 0,
+        avgTokensPerSecond: result?.avg_tokens_per_second ?? null
+      };
+    }
+    getTopModels(limit = 10) {
+      return this.query(`
+			SELECT model, COUNT(*) as count
+			FROM requests
+			WHERE model IS NOT NULL
+			GROUP BY model
+			ORDER BY count DESC
+			LIMIT ?
+		`, [limit]);
+    }
+    getRecentErrors(limit = 10) {
+      const errors = this.query(`
+			SELECT error_message
+			FROM (
+				SELECT
+					error_message,
+					MAX(timestamp) as latest_timestamp
+				FROM requests
+				WHERE error_message IS NOT NULL
+					AND error_message != ''
+				GROUP BY error_message
+			)
+			ORDER BY latest_timestamp DESC
+			LIMIT ?
+		`, [limit]);
+      return errors.map((e) => e.error_message);
+    }
+    getRequestsByAccount(since) {
+      const whereClause = since ? "WHERE r.timestamp > ?" : "";
+      const params = since ? [since] : [];
+      return this.query(`
+			SELECT 
+				r.account_used as account_id,
+				a.name as account_name,
+				COUNT(*) as request_count,
+				SUM(CASE WHEN r.success = 1 THEN 1 ELSE 0 END) * 100.0 /
+					NULLIF(SUM(CASE WHEN r.success IS NOT NULL THEN 1 ELSE 0 END), 0) as success_rate
+			FROM requests r
+			LEFT JOIN accounts a ON r.account_used = a.id
+			${whereClause}
+			GROUP BY r.account_used
+			ORDER BY request_count DESC
+		`, params).map((row) => ({
+        accountId: row.account_id,
+        accountName: row.account_name,
+        requestCount: row.request_count,
+        successRate: row.success_rate
+      }));
+    }
+    deleteOlderThan(cutoffTs) {
+      return this.runWithChanges(`DELETE FROM requests WHERE timestamp < ?`, [
+        cutoffTs
+      ]);
+    }
+    clear() {
+      return this.runWithChanges(`DELETE FROM requests`);
+    }
+    deleteOrphanedPayloads() {
+      return this.runWithChanges(`DELETE FROM request_payloads WHERE id NOT IN (SELECT id FROM requests)`);
+    }
+    deletePayloadsOlderThan(cutoffTs) {
+      return this.runWithChanges(`DELETE FROM request_payloads WHERE id IN (SELECT id FROM requests WHERE timestamp < ?)`, [cutoffTs]);
+    }
+  };
+});
+
+// ../../packages/database/src/repositories/stats.repository.ts
+class StatsRepository {
+  db;
+  requests;
+  constructor(db) {
+    this.db = db;
+    this.requests = new RequestRepository(db);
+  }
+  getAggregatedStats() {
+    const stats2 = this.requests.aggregateStats();
+    const successRate = stats2.completedRequests > 0 ? Math.round(stats2.successfulRequests / stats2.completedRequests * 100) : 0;
+    return {
+      totalRequests: stats2.totalRequests,
+      completedRequests: stats2.completedRequests,
+      successfulRequests: stats2.successfulRequests,
+      successRate,
+      avgResponseTime: stats2.avgResponseTime ?? 0,
+      totalTokens: stats2.totalTokens,
+      totalCostUsd: stats2.totalCostUsd,
+      inputTokens: stats2.inputTokens,
+      outputTokens: stats2.outputTokens,
+      cacheReadInputTokens: stats2.cacheReadInputTokens,
+      cacheCreationInputTokens: stats2.cacheCreationInputTokens,
+      avgTokensPerSecond: stats2.avgTokensPerSecond
+    };
+  }
+  getAccountStats(limit = 10, includeUnauthenticated = true) {
+    const query = includeUnauthenticated ? `
+				SELECT
+					COALESCE(a.name, ?) as name,
+					COUNT(r.id) as requestCount,
+					COALESCE(a.total_requests, 0) as totalRequests,
+					CASE
+						WHEN SUM(CASE WHEN r.success IS NOT NULL THEN 1 ELSE 0 END) > 0
+						THEN CAST(ROUND(SUM(CASE WHEN r.success = 1 THEN 1 ELSE 0 END) * 100.0 /
+							SUM(CASE WHEN r.success IS NOT NULL THEN 1 ELSE 0 END)) AS INTEGER)
+						ELSE 0
+					END as successRate
+				FROM requests r
+				LEFT JOIN accounts a ON a.id = r.account_used
+				GROUP BY COALESCE(a.id, ?), COALESCE(a.name, ?)
+				HAVING requestCount > 0
+				ORDER BY requestCount DESC
+				LIMIT ?
+			` : `
+				SELECT
+					a.name,
+					COUNT(r.id) as requestCount,
+					a.total_requests as totalRequests,
+					CASE
+						WHEN SUM(CASE WHEN r.success IS NOT NULL THEN 1 ELSE 0 END) > 0
+						THEN CAST(ROUND(SUM(CASE WHEN r.success = 1 THEN 1 ELSE 0 END) * 100.0 /
+							SUM(CASE WHEN r.success IS NOT NULL THEN 1 ELSE 0 END)) AS INTEGER)
+						ELSE 0
+					END as successRate
+				FROM accounts a
+				INNER JOIN requests r ON r.account_used = a.id
+				GROUP BY a.id
+				HAVING requestCount > 0
+				ORDER BY requestCount DESC
+				LIMIT ?
+			`;
+    const params = includeUnauthenticated ? [NO_ACCOUNT_ID, NO_ACCOUNT_ID, NO_ACCOUNT_ID, limit] : [limit];
+    return this.db.query(query).all(...params);
+  }
+  getActiveAccountCount() {
+    const result = this.db.query("SELECT COUNT(*) as count FROM accounts WHERE request_count > 0").get();
+    return result.count;
+  }
+  getRecentErrors(limit = 10) {
+    return this.requests.getRecentErrors(limit);
+  }
+  getTopModels(limit = 5) {
+    const models = this.requests.getTopModels(limit);
+    const total = this.db.query(`SELECT COUNT(*) as total FROM requests WHERE model IS NOT NULL`).get()?.total ?? 0;
+    return models.map((model) => ({
+      ...model,
+      percentage: total > 0 ? Math.round(model.count / total * 1e4) / 100 : 0
+    }));
+  }
+}
+var init_stats_repository = __esm(() => {
+  init_src();
+  init_request_repository();
+});
+
+// ../../packages/database/src/repositories/strategy.repository.ts
+var StrategyRepository;
+var init_strategy_repository = __esm(() => {
+  StrategyRepository = class StrategyRepository extends BaseRepository {
+    getStrategy(name) {
+      const row = super.get(`SELECT name, config, updated_at FROM strategies WHERE name = ?`, [name]);
+      if (!row)
+        return null;
+      return {
+        name: row.name,
+        config: JSON.parse(row.config),
+        updatedAt: row.updated_at
+      };
+    }
+    set(name, config) {
+      const now = Date.now();
+      const configJson = JSON.stringify(config);
+      this.run(`INSERT OR REPLACE INTO strategies (name, config, updated_at) VALUES (?, ?, ?)`, [name, configJson, now]);
+    }
+    list() {
+      const rows = this.query(`SELECT name, config, updated_at FROM strategies ORDER BY name`);
+      return rows.map((row) => ({
+        name: row.name,
+        config: JSON.parse(row.config),
+        updatedAt: row.updated_at
+      }));
+    }
+    delete(name) {
+      const changes = this.runWithChanges(`DELETE FROM strategies WHERE name = ?`, [name]);
+      return changes > 0;
+    }
+  };
+});
+
+// ../../packages/database/src/database-operations.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+
+class DatabaseOperations {
+  db;
+  runtime;
+  closed = false;
+  accounts;
+  analytics;
+  requests;
+  authSessions;
+  conversationPins;
+  strategy;
+  stats;
+  constructor(dbPath) {
+    const resolvedPath = dbPath ?? resolveDbPath();
+    const dir = dirname2(resolvedPath);
+    mkdirSync3(dir, { recursive: true });
+    this.db = new Database(resolvedPath, { create: true });
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA busy_timeout = 5000");
+    this.db.exec("PRAGMA synchronous = NORMAL");
+    ensureSchema(this.db);
+    runMigrations(this.db);
+    this.accounts = new AccountRepository(this.db);
+    this.analytics = new AnalyticsRepository(this.db);
+    this.requests = new RequestRepository(this.db);
+    this.authSessions = new AuthSessionRepository(this.db);
+    this.conversationPins = new ConversationPinRepository(this.db);
+    this.strategy = new StrategyRepository(this.db);
+    this.stats = new StatsRepository(this.db);
+  }
+  setRuntimeConfig(runtime) {
+    this.runtime = runtime;
+  }
+  getDatabase() {
+    return this.db;
+  }
+  getAllAccounts() {
+    return this.accounts.findAll();
+  }
+  getAccount(accountId) {
+    return this.accounts.findById(accountId);
+  }
+  getAccountByName(name) {
+    return this.accounts.findByName(name);
+  }
+  setEnrollmentContact(accountId, contact) {
+    this.accounts.setEnrollmentContact(accountId, contact);
+  }
+  getEnrollmentContact(accountId) {
+    return this.accounts.getEnrollmentContact(accountId);
+  }
+  getAccountsByProvider(provider) {
+    return this.accounts.findByProvider(provider);
+  }
+  getAvailableAccountsByProvider(provider) {
+    return this.accounts.findAvailableForProvider(provider);
+  }
+  createAccount(data) {
+    return this.accounts.create(data);
+  }
+  createApiKeyAccount(opts) {
+    return this.accounts.createApiKeyAccount(opts);
+  }
+  createOAuthAccount(opts) {
+    return this.accounts.createOAuthAccount(opts);
+  }
+  updateAccount(accountId, data) {
+    return this.accounts.update(accountId, data);
+  }
+  deleteAccount(accountId) {
+    this.conversationPins.deleteForAccount(accountId);
+    return this.accounts.delete(accountId);
+  }
+  getConversationPin(pinKey) {
+    return this.conversationPins.find(pinKey);
+  }
+  upsertConversationPin(pinKey, accountId, lastSeenAt) {
+    this.conversationPins.upsert(pinKey, accountId, lastSeenAt);
+  }
+  countConversationPinsByAccount(activeSince) {
+    return this.conversationPins.countByAccount(activeSince);
+  }
+  deleteExpiredConversationPins(before) {
+    this.conversationPins.deleteExpired(before);
+  }
+  countAccounts() {
+    return this.accounts.count();
+  }
+  updateAccountTokens(accountId, accessToken, expiresAt, refreshToken) {
+    this.accounts.updateTokens(accountId, accessToken, expiresAt, refreshToken);
+  }
+  updateAccountUsage(accountId) {
+    const sessionDuration = this.runtime?.sessionDurationMs || 5 * 60 * 60 * 1000;
+    this.accounts.incrementUsage(accountId, sessionDuration);
+  }
+  markAccountRateLimited(accountId, until) {
+    this.accounts.setRateLimited(accountId, until);
+  }
+  updateAccountRateLimitMeta(accountId, status, reset, remaining) {
+    this.accounts.updateRateLimitMeta(accountId, status, reset, remaining);
+  }
+  updateAccountQuotaState(accountId, quotaState) {
+    this.accounts.updateQuotaState(accountId, quotaState);
+  }
+  pauseAccount(accountId) {
+    this.accounts.pause(accountId);
+  }
+  markAccountError(accountId, reason) {
+    this.accounts.markError(accountId, reason);
+  }
+  resumeAccount(accountId) {
+    this.accounts.resume(accountId);
+  }
+  resetAccountSession(accountId, timestamp) {
+    this.accounts.resetSession(accountId, timestamp);
+  }
+  updateAccountRequestCount(accountId, count) {
+    this.accounts.updateRequestCount(accountId, count);
+  }
+  resetAccountStats(options) {
+    this.accounts.resetStatistics(options?.resetSessionStart === true);
+  }
+  resetStats() {
+    this.clearRequestHistory();
+    this.resetAccountStats({ resetSessionStart: true });
+  }
+  saveRequestMeta(id, method, path, provider, upstreamPath, accountUsed, statusCode, timestamp) {
+    this.requests.saveMeta(id, method, path, provider, upstreamPath, accountUsed, statusCode, timestamp);
+  }
+  saveRequest(id, method, path, provider, upstreamPath, accountUsed, statusCode, success, errorMessage, responseTime, failoverAttempts, usage, options) {
+    this.requests.save({
+      id,
+      method,
+      path,
+      provider,
+      upstreamPath,
+      accountUsed,
+      statusCode,
+      success,
+      errorMessage,
+      responseTime,
+      failoverAttempts,
+      usage,
+      timestamp: options?.timestamp,
+      payload: options?.payload,
+      timings: options?.timings
+    });
+  }
+  updateRequestUsage(requestId, usage) {
+    this.requests.updateUsage(requestId, usage);
+  }
+  saveRequestPayload(id, data) {
+    this.requests.savePayload(id, data);
+  }
+  getRequestPayload(id) {
+    return this.requests.getPayload(id);
+  }
+  listRequestSummaries(limit = 50) {
+    return this.requests.listSummaries(limit);
+  }
+  listRequestsWithAccountNames(limit = 50) {
+    return this.requests.listWithAccountNames(limit);
+  }
+  listRequestPayloads(limit = 50) {
+    return this.requests.listPayloads(limit);
+  }
+  listRequestPayloadsWithAccountNames(limit = 50) {
+    return this.requests.listPayloadsWithAccountNames(limit);
+  }
+  listResponseChainPayloadsWithAccountNames(requestId) {
+    return this.requests.listResponseChainPayloadsWithAccountNames(requestId);
+  }
+  createAuthSession(provider, authMethod, accountName, stateJson, expiresAt) {
+    return this.authSessions.createSession(provider, authMethod, accountName, stateJson, expiresAt);
+  }
+  getAuthSession(sessionId) {
+    return this.authSessions.getSession(sessionId);
+  }
+  getAuthSessionByState(state) {
+    return this.authSessions.getSessionByState(state);
+  }
+  updateAuthSessionState(sessionId, stateJson, expiresAt) {
+    this.authSessions.updateSessionState(sessionId, stateJson, expiresAt);
+  }
+  deleteAuthSession(sessionId) {
+    this.authSessions.deleteSession(sessionId);
+  }
+  deleteExpiredAuthSessions() {
+    return this.authSessions.deleteExpiredSessions();
+  }
+  getStrategy(name) {
+    return this.strategy.getStrategy(name);
+  }
+  setStrategy(name, config) {
+    this.strategy.set(name, config);
+  }
+  listStrategies() {
+    return this.strategy.list();
+  }
+  deleteStrategy(name) {
+    return this.strategy.delete(name);
+  }
+  getRecentRequests(limit = 100) {
+    return this.requests.getRecentRequests(limit);
+  }
+  clearRequestHistory() {
+    return this.requests.clear();
+  }
+  getAnalytics(options) {
+    return this.analytics.getAnalytics(options);
+  }
+  cleanupOldRequests(payloadRetentionMs, requestRetentionMs) {
+    const now = Date.now();
+    const payloadCutoff = now - payloadRetentionMs;
+    let removedRequests = 0;
+    if (typeof requestRetentionMs === "number" && Number.isFinite(requestRetentionMs)) {
+      const requestCutoff = now - requestRetentionMs;
+      removedRequests = this.requests.deleteOlderThan(requestCutoff);
+    }
+    const removedPayloadsByAge = this.requests.deletePayloadsOlderThan(payloadCutoff);
+    const removedOrphans = this.requests.deleteOrphanedPayloads();
+    const removedPayloads = removedPayloadsByAge + removedOrphans;
+    return { removedRequests, removedPayloads };
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    this.db.close();
+  }
+  dispose() {
+    this.close();
+  }
+  optimize() {
+    this.db.exec("PRAGMA optimize");
+    this.db.exec("PRAGMA wal_checkpoint(PASSIVE)");
+  }
+  compact() {
+    this.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    this.db.exec("VACUUM");
+  }
+  getStatsRepository() {
+    return this.stats;
+  }
+}
+var init_database_operations = __esm(() => {
+  init_migrations();
+  init_paths2();
+  init_account_repository();
+  init_analytics_repository();
+  init_auth_session_repository();
+  init_conversation_pin_repository();
+  init_request_repository();
+  init_stats_repository();
+  init_strategy_repository();
+});
+
+// ../../packages/database/src/factory.ts
+function initialize(dbPathParam, runtimeConfigParam) {
+  dbPath = dbPathParam;
+  runtimeConfig = runtimeConfigParam;
+}
+function getInstance() {
+  if (!instance) {
+    instance = new DatabaseOperations(dbPath);
+    if (runtimeConfig) {
+      instance.setRuntimeConfig(runtimeConfig);
+    }
+    registerDisposable(instance);
+  }
+  return instance;
+}
+function closeAll() {
+  if (instance) {
+    unregisterDisposable(instance);
+    instance.close();
+    instance = null;
+  }
+}
+function reset() {
+  closeAll();
+}
+var instance = null, dbPath, runtimeConfig, DatabaseFactory;
+var init_factory = __esm(() => {
+  init_src2();
+  init_database_operations();
+  DatabaseFactory = {
+    initialize,
+    getInstance,
+    closeAll,
+    reset
+  };
+});
+
+// ../../packages/database/src/index.ts
+var init_src5 = __esm(() => {
+  init_analytics_query();
+  init_analyze_performance();
+  init_async_writer();
+  init_database_operations();
+  init_factory();
+  init_migrations();
+  init_paths2();
+  init_performance_indexes();
+});
+
+// ../../packages/proxy/src/openai-usage.ts
+function getFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseUsageDetails(value) {
+  if (value === null) {
+    return null;
+  }
+  if (!isRecord(value)) {
+    return;
+  }
+  const cachedTokens = getFiniteNumber(value.cached_tokens);
+  const reasoningTokens = getFiniteNumber(value.reasoning_tokens);
+  return {
+    ...cachedTokens !== undefined && { cached_tokens: cachedTokens },
+    ...reasoningTokens !== undefined && {
+      reasoning_tokens: reasoningTokens
+    }
+  };
+}
+function parseOpenAIUsagePayload(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const parsed = {};
+  const numericFields = [
+    "prompt_tokens",
+    "completion_tokens",
+    "total_tokens",
+    "input_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens",
+    "output_tokens",
+    "reasoning_tokens"
+  ];
+  for (const field of numericFields) {
+    const numericValue = getFiniteNumber(value[field]);
+    if (numericValue !== undefined) {
+      parsed[field] = numericValue;
+    }
+  }
+  const inputTokenDetails = parseUsageDetails(value.input_tokens_details);
+  if (inputTokenDetails !== undefined) {
+    parsed.input_tokens_details = inputTokenDetails;
+  }
+  const promptTokenDetails = parseUsageDetails(value.prompt_tokens_details);
+  if (promptTokenDetails !== undefined) {
+    parsed.prompt_tokens_details = promptTokenDetails;
+  }
+  const outputTokenDetails = parseUsageDetails(value.output_tokens_details);
+  if (outputTokenDetails !== undefined) {
+    parsed.output_tokens_details = outputTokenDetails;
+  }
+  return parsed;
+}
+function normalizeOpenAIUsage(usage) {
+  if (!usage) {
+    return {};
+  }
+  const normalized = {};
+  const numericFields = [
+    "prompt_tokens",
+    "completion_tokens",
+    "total_tokens",
+    "input_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens",
+    "output_tokens",
+    "reasoning_tokens"
+  ];
+  for (const field of numericFields) {
+    const value = getFiniteNumber(usage[field]);
+    if (value !== undefined) {
+      normalized[field] = value;
+    }
+  }
+  const rawCachedTokens = getFiniteNumber(usage.input_tokens_details?.cached_tokens) ?? getFiniteNumber(usage.prompt_tokens_details?.cached_tokens);
+  if (rawCachedTokens !== undefined) {
+    const inputTokens = getFiniteNumber(usage.input_tokens) ?? getFiniteNumber(normalized.input_tokens);
+    const promptTokens = getFiniteNumber(usage.prompt_tokens) ?? getFiniteNumber(normalized.prompt_tokens);
+    const maxCachedTokens = Math.max(0, inputTokens ?? promptTokens ?? rawCachedTokens);
+    const cachedTokens = Math.max(0, Math.min(rawCachedTokens, maxCachedTokens));
+    normalized.cache_read_input_tokens = cachedTokens;
+    if (inputTokens !== undefined) {
+      normalized.input_tokens = Math.max(0, inputTokens - cachedTokens);
+    }
+    if (promptTokens !== undefined) {
+      normalized.prompt_tokens = Math.max(0, promptTokens - cachedTokens);
+    }
+  }
+  const reasoningTokens = getFiniteNumber(usage.output_tokens_details?.reasoning_tokens);
+  if (reasoningTokens !== undefined) {
+    normalized.reasoning_tokens = reasoningTokens;
+  }
+  return normalized;
+}
+var init_openai_usage = __esm(() => {
+  init_src();
+});
+
+// ../../packages/proxy/src/post-processor.worker.ts
+init_src2();
+init_src5();
+init_src3();
+init_src();
+init_openai_usage();
+import { get_encoding } from "@dqbd/tiktoken";
+
+// ../../packages/proxy/src/stream-tee.ts
+init_src2();
+function combineChunks(chunks) {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const combined = Buffer.allocUnsafe(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return combined;
+}
+
+// ../../packages/proxy/src/tracked-model.ts
+function normalizeTrackedModel(model) {
+  if (typeof model !== "string") {
+    return;
+  }
+  const trimmed = model.trim();
+  return trimmed || undefined;
+}
+var MODEL_FIELD_RE = /"model"\s*:\s*"([^"]+)"/;
+function extractTrackedModelFromRequestBody(encodedBody) {
+  if (!encodedBody) {
+    return;
+  }
+  try {
+    const slice = encodedBody.slice(0, 700);
+    const decoded = Buffer.from(slice, "base64").toString("utf-8");
+    const match = decoded.match(MODEL_FIELD_RE);
+    return match ? normalizeTrackedModel(match[1]) : undefined;
+  } catch {
+    return;
+  }
+}
+
+// ../../packages/proxy/src/post-processor.worker.ts
+var log7 = new Logger("PostProcessor");
+var requests = new Map;
+var tokenEncoder = get_encoding("cl100k_base");
+var streamDecoder = new TextDecoder("utf-8", { fatal: false });
+var dbOps = new DatabaseOperations;
+var asyncWriter = new AsyncDbWriter;
+var MAX_BUFFER_SIZE = Number(process.env.CF_STREAM_USAGE_BUFFER_KB || BUFFER_SIZES.STREAM_USAGE_BUFFER_KB) * 1024;
+var TIMEOUT_MS = Number(process.env.CF_STREAM_TIMEOUT_MS || TIME_CONSTANTS.STREAM_TIMEOUT_DEFAULT);
+var MAX_PAYLOAD_BYTES = Number(process.env.CF_MAX_PAYLOAD_BYTES || 0) || 2 * 1024 * 1024;
+var MAX_TRACKED_REQUESTS = Number(process.env.CF_MAX_TRACKED_REQUESTS || 0) || 100;
+var TOKEN_CURVE_SAMPLE_EVERY = Math.max(1, Number(process.env.CF_TOKEN_CURVE_SAMPLE_EVERY || 10) || 10);
+var TOKEN_CURVE_MAX_SAMPLES = Math.max(1, Number(process.env.CF_TOKEN_CURVE_MAX_SAMPLES || 200) || 200);
+var RESPONSES_TERMINAL_EVENTS = new Set([
+  "response.completed",
+  "response.failed",
+  "response.incomplete"
+]);
+var cleanupIntervalId = null;
+var messageProcessingQueue = Promise.resolve();
+function shouldLogRequest(path, status) {
+  if (path.startsWith("/.well-known/") && status === 404) {
+    return false;
+  }
+  return true;
+}
+function parseSSELine(line) {
+  if (line.startsWith("event: ")) {
+    return { event: line.slice(7).trim() };
+  }
+  if (line.startsWith("data: ")) {
+    return { data: line.slice(6).trim() };
+  }
+  return {};
+}
+function extractUsageFromJson(json, state) {
+  if (!json)
+    return;
+  const usageObj = json.response?.usage ?? json.usage;
+  if (!usageObj)
+    return;
+  applyUsageData(state, normalizeOpenAIUsage(usageObj), json.response?.model ?? json.model ?? state.usage.model);
+}
+function setUsageModel(state, model) {
+  const normalizedModel = normalizeTrackedModel(model);
+  if (normalizedModel) {
+    state.usage.model = normalizedModel;
+  }
+}
+function applyUsageData(state, usageObj, model) {
+  setUsageModel(state, model);
+  state.usage.inputTokens = usageObj.prompt_tokens ?? usageObj.input_tokens ?? 0;
+  state.usage.cacheReadInputTokens = usageObj.cache_read_input_tokens ?? 0;
+  state.usage.cacheCreationInputTokens = usageObj.cache_creation_input_tokens ?? 0;
+  state.usage.outputTokens = usageObj.completion_tokens ?? usageObj.output_tokens ?? 0;
+  state.usage.reasoningTokens = usageObj.reasoning_tokens ?? 0;
+  const prompt = (state.usage.inputTokens ?? 0) + (state.usage.cacheReadInputTokens ?? 0) + (state.usage.cacheCreationInputTokens ?? 0);
+  const completion = state.usage.outputTokens ?? 0;
+  state.usage.totalTokens = usageObj.total_tokens ?? prompt + completion;
+}
+function computeTokenCount(text) {
+  try {
+    return tokenEncoder.encode(text).length;
+  } catch (err) {
+    log7.debug("Failed to count tokens:", err);
+    return null;
+  }
+}
+function recordTokenEvent(state, text, timestamp = Date.now()) {
+  if (!text) {
+    return;
+  }
+  const tokenDelta = computeTokenCount(text);
+  if (!tokenDelta || tokenDelta <= 0) {
+    return;
+  }
+  if (!state.firstTokenTimestamp) {
+    state.firstTokenTimestamp = timestamp;
+  }
+  state.lastTokenTimestamp = timestamp;
+  if (state.providerFinalOutputTokens === undefined) {
+    state.usage.outputTokensComputed = (state.usage.outputTokensComputed || 0) + tokenDelta;
+  }
+  state.tokenChunkCount += 1;
+  if (state.tokenChunkCount % TOKEN_CURVE_SAMPLE_EVERY === 0 && state.tokenCurve.length < TOKEN_CURVE_MAX_SAMPLES) {
+    state.tokenCurve.push({
+      chunkIndex: state.tokenChunkCount,
+      tokenDelta,
+      timestamp
+    });
+  }
+}
+function durationBetween(start, end) {
+  if (start === undefined || end === undefined) {
+    return null;
+  }
+  return Math.max(0, end - start);
+}
+function isRelevantSseData(data) {
+  return data.includes('"usage"') || data.includes('"message_start"') || data.includes('"message_delta"') || data.includes('"response.created"') || data.includes('"response.completed"') || data.includes('"chat.completion.chunk"') || data.includes('"content_block_start"') || data.includes('"content_block_delta"') || data.includes('"response.output_text.delta"');
+}
+function extractUsageFromData(data, state) {
+  if (!isRelevantSseData(data))
+    return;
+  try {
+    const parsed = JSON.parse(data);
+    if (isRecord(parsed) && parsed.type === "response.created" && (typeof parsed.model === "string" || isRecord(parsed.response) && typeof parsed.response.model === "string")) {
+      setUsageModel(state, (isRecord(parsed.response) && typeof parsed.response.model === "string" ? parsed.response.model : undefined) ?? (typeof parsed.model === "string" ? parsed.model : undefined));
+    }
+    if (isRecord(parsed) && parsed.type === "message_start" && isRecord(parsed.message) && isRecord(parsed.message.usage)) {
+      const usage = parsed.message.usage;
+      state.usage.inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+      state.usage.cacheReadInputTokens = typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0;
+      state.usage.cacheCreationInputTokens = typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : 0;
+      state.usage.outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+      if (typeof parsed.message.model === "string") {
+        setUsageModel(state, parsed.message.model);
+      }
+    }
+    if (isRecord(parsed) && typeof parsed.type === "string" && RESPONSES_TERMINAL_EVENTS.has(parsed.type) && isRecord(parsed.response)) {
+      const usage = parseOpenAIUsagePayload(parsed.response.usage);
+      applyUsageData(state, normalizeOpenAIUsage(usage), typeof parsed.response.model === "string" ? parsed.response.model : state.usage.model);
+    }
+    if (isRecord(parsed) && parsed.type === "response.output_text.delta" && typeof parsed.delta === "string") {
+      recordTokenEvent(state, parsed.delta);
+    }
+    if (isRecord(parsed) && parsed.object === "chat.completion.chunk" && Array.isArray(parsed.choices)) {
+      if (typeof parsed.model === "string") {
+        setUsageModel(state, parsed.model);
+      }
+      const firstChoice = isRecord(parsed.choices[0]) ? parsed.choices[0] : null;
+      const delta = firstChoice && isRecord(firstChoice.delta) ? firstChoice.delta : null;
+      if (delta) {
+        if (typeof delta.content === "string") {
+          recordTokenEvent(state, delta.content);
+        }
+        if (typeof delta.reasoning_content === "string") {
+          recordTokenEvent(state, delta.reasoning_content);
+        }
+        if (Array.isArray(delta.tool_calls)) {
+          for (const toolCall of delta.tool_calls) {
+            if (!isRecord(toolCall) || !isRecord(toolCall.function))
+              continue;
+            if (typeof toolCall.function.arguments === "string") {
+              recordTokenEvent(state, toolCall.function.arguments);
+            }
+          }
+        }
+      }
+      if (isRecord(parsed.usage)) {
+        applyUsageData(state, normalizeOpenAIUsage(parseOpenAIUsagePayload(parsed.usage)), typeof parsed.model === "string" ? parsed.model : state.usage.model);
+      }
+    }
+    if (isRecord(parsed) && parsed.type === "message_delta") {
+      if (isRecord(parsed.usage) && typeof parsed.usage.output_tokens === "number") {
+        state.providerFinalOutputTokens = parsed.usage.output_tokens;
+        state.usage.outputTokens = parsed.usage.output_tokens;
+        if (parsed.usage.output_tokens > 0 && state.lastTokenTimestamp === undefined) {
+          state.lastTokenTimestamp = Date.now();
+        }
+        return;
+      }
+    }
+    if (isRecord(parsed) && parsed.type === "content_block_delta" && isRecord(parsed.delta)) {
+      let textToCount;
+      if (parsed.delta.type === "text_delta" && typeof parsed.delta.text === "string") {
+        textToCount = parsed.delta.text;
+      } else if (parsed.delta.type === "thinking_delta" && typeof parsed.delta.thinking === "string") {
+        textToCount = parsed.delta.thinking;
+      }
+      if (textToCount) {
+        recordTokenEvent(state, textToCount);
+      }
+    }
+    if (isRecord(parsed) && parsed.usage) {
+      applyUsageData(state, normalizeOpenAIUsage(parseOpenAIUsagePayload(parsed.usage)), state.usage.model);
+    }
+  } catch {}
+}
+function processStreamChunk(chunk, state) {
+  const text = streamDecoder.decode(chunk, { stream: true });
+  state.buffer += text;
+  state.lastActivity = Date.now();
+  if (state.buffer.length > MAX_BUFFER_SIZE) {
+    state.buffer = state.buffer.slice(-MAX_BUFFER_SIZE);
+  }
+  let currentEvent = state.currentSseEvent;
+  let nlIndex = state.buffer.indexOf(`
+`);
+  while (nlIndex !== -1) {
+    const line = state.buffer.slice(0, nlIndex).trim();
+    state.buffer = state.buffer.slice(nlIndex + 1);
+    if (!line) {
+      currentEvent = "";
+    } else {
+      const parsed = parseSSELine(line);
+      if (parsed.event) {
+        currentEvent = parsed.event;
+      } else if (parsed.data) {
+        extractUsageFromData(parsed.data, state);
+      }
+    }
+    nlIndex = state.buffer.indexOf(`
+`);
+  }
+  state.currentSseEvent = currentEvent;
+}
+function createRequestState(startMessage, overrides = {}) {
+  return {
+    startMessage,
+    buffer: "",
+    chunks: [],
+    chunksBytes: 0,
+    payloadCapped: false,
+    currentSseEvent: "",
+    usage: {},
+    lastActivity: Date.now(),
+    clientSessionId: extractClientSessionIdFromHeaders(startMessage.requestHeaders),
+    tokenChunkCount: 0,
+    tokenCurve: [],
+    ...overrides
+  };
+}
+function hasTrackedUsageData(state) {
+  return state.usage.inputTokens !== undefined || state.usage.cacheReadInputTokens !== undefined || state.usage.cacheCreationInputTokens !== undefined || state.usage.outputTokens !== undefined || state.usage.reasoningTokens !== undefined || state.usage.outputTokensComputed !== undefined || state.usage.totalTokens !== undefined || state.providerFinalOutputTokens !== undefined;
+}
+async function handleStart(msg) {
+  if (requests.size >= MAX_TRACKED_REQUESTS) {
+    log7.warn(`Tracked request cap reached (${MAX_TRACKED_REQUESTS}), skipping tracking for ${msg.requestId}`);
+    return;
+  }
+  const shouldSkip = !shouldLogRequest(msg.path, msg.responseStatus);
+  const state = createRequestState(msg, {
+    shouldSkipLogging: shouldSkip
+  });
+  requests.set(msg.requestId, state);
+  if (shouldSkip) {
+    log7.debug(`Skipping logging for ${msg.path} (${msg.responseStatus})`);
+    return;
+  }
+  asyncWriter.enqueue(() => dbOps.saveRequestMeta(msg.requestId, msg.method, msg.path, msg.providerName, msg.upstreamPath, msg.accountId, msg.responseStatus, msg.timestamp));
+  if (msg.accountId) {
+    const accountId = msg.accountId;
+    asyncWriter.enqueue(() => dbOps.updateAccountUsage(accountId));
+  }
+}
+function handleChunk(msg) {
+  const state = requests.get(msg.requestId);
+  if (!state) {
+    log7.warn(`No state found for request ${msg.requestId}`);
+    return;
+  }
+  if (!state.payloadCapped) {
+    if (state.chunksBytes + msg.data.length <= MAX_PAYLOAD_BYTES) {
+      state.chunks.push(msg.data);
+      state.chunksBytes += msg.data.length;
+    } else {
+      const remaining = MAX_PAYLOAD_BYTES - state.chunksBytes;
+      if (remaining > 0) {
+        state.chunks.push(msg.data.slice(0, remaining));
+        state.chunksBytes = MAX_PAYLOAD_BYTES;
+      }
+      state.payloadCapped = true;
+      log7.debug(`Payload cap reached for request ${msg.requestId} (${MAX_PAYLOAD_BYTES} bytes)`);
+    }
+  }
+  processStreamChunk(msg.data, state);
+}
+function buildRequestEndPayload(input) {
+  const { startMessage, state, success, responseBody, timings } = input;
+  const payload = {
+    id: startMessage.requestId,
+    request: {
+      headers: startMessage.requestHeaders,
+      body: startMessage.requestBody
+    },
+    response: {
+      status: startMessage.responseStatus,
+      headers: startMessage.responseHeaders,
+      body: responseBody
+    },
+    meta: {
+      trace: {
+        timestamp: startMessage.timestamp,
+        provider: startMessage.providerName,
+        upstreamPath: startMessage.upstreamPath,
+        path: startMessage.path,
+        method: startMessage.method
+      },
+      account: {
+        id: startMessage.accountId
+      },
+      transport: {
+        success,
+        isStream: startMessage.isStream,
+        retry: startMessage.retryAttempt,
+        ttftMs: timings.ttftMs,
+        proxyOverheadMs: timings.proxyOverheadMs,
+        upstreamTtfbMs: timings.upstreamTtfbMs,
+        streamingDurationMs: timings.streamingDurationMs,
+        tokenCurve: state.tokenCurve.length > 0 ? state.tokenCurve : null
+      }
+    }
+  };
+  const linkage = extractRequestLinkageFromPayload(payload);
+  payload.meta.trace.responseId = linkage.responseId;
+  payload.meta.trace.previousResponseId = linkage.previousResponseId;
+  payload.meta.trace.clientSessionId = linkage.clientSessionId ?? state.clientSessionId ?? null;
+  payload.request.body = null;
+  if (payload.response) {
+    payload.response.body = null;
+  }
+  return payload;
+}
+async function handleEnd(msg) {
+  const state = requests.get(msg.requestId);
+  if (!state) {
+    log7.warn(`No state found for request ${msg.requestId}`);
+    return;
+  }
+  const { startMessage } = state;
+  const responseTime = Date.now() - startMessage.timestamp;
+  if (state.shouldSkipLogging) {
+    requests.delete(msg.requestId);
+    return;
+  }
+  if (msg.preExtractedUsage) {
+    applyUsageData(state, msg.preExtractedUsage, msg.preExtractedModel);
+  } else if (!state.usage.model && msg.responseBody) {
+    try {
+      const decoded = Buffer.from(msg.responseBody, "base64").toString("utf-8");
+      const json = JSON.parse(decoded);
+      extractUsageFromJson(json, state);
+    } catch {}
+  }
+  if (msg.preExtractedModel && !state.usage.model) {
+    setUsageModel(state, msg.preExtractedModel);
+  }
+  if (!state.usage.model) {
+    setUsageModel(state, extractTrackedModelFromRequestBody(startMessage.requestBody));
+  }
+  const usageModel = state.usage.model || (hasTrackedUsageData(state) ? "unknown" : undefined);
+  if (usageModel) {
+    if (!state.usage.model) {
+      log7.debug(`Usage model missing for request ${msg.requestId}, using fallback`, {
+        provider: startMessage.providerName,
+        path: startMessage.path
+      });
+    }
+    state.usage.model = usageModel;
+    const finalOutputTokens = state.providerFinalOutputTokens ?? state.usage.outputTokens ?? state.usage.outputTokensComputed ?? 0;
+    state.usage.outputTokens = finalOutputTokens;
+    state.usage.outputTokensComputed = undefined;
+    state.usage.totalTokens = (state.usage.inputTokens || 0) + finalOutputTokens + (state.usage.cacheReadInputTokens || 0) + (state.usage.cacheCreationInputTokens || 0);
+    state.usage.costUsd = usageModel === "unknown" ? 0 : await estimateCostUSD(usageModel, {
+      inputTokens: state.usage.inputTokens,
+      outputTokens: finalOutputTokens,
+      cacheReadInputTokens: state.usage.cacheReadInputTokens,
+      cacheCreationInputTokens: state.usage.cacheCreationInputTokens
+    });
+    if (finalOutputTokens > 0) {
+      const durationMs = durationBetween(state.firstTokenTimestamp, state.lastTokenTimestamp);
+      if (durationMs !== null && durationMs > 0) {
+        state.usage.tokensPerSecond = finalOutputTokens / (durationMs / 1000);
+      } else if (durationMs !== null) {
+        state.usage.tokensPerSecond = finalOutputTokens / 0.001;
+      }
+    }
+  }
+  let responseBody = null;
+  if (msg.responseBody) {
+    responseBody = msg.responseBody;
+  } else if (state.chunks.length > 0) {
+    const combined = combineChunks(state.chunks);
+    if (combined.length > 0) {
+      responseBody = combined.toString("base64");
+    }
+  }
+  const timings = {
+    ttftMs: durationBetween(startMessage.timestamp, state.firstTokenTimestamp),
+    proxyOverheadMs: durationBetween(startMessage.timestamp, startMessage.upstreamRequestStartedAt),
+    upstreamTtfbMs: durationBetween(startMessage.upstreamRequestStartedAt, startMessage.responseHeadersReceivedAt),
+    streamingDurationMs: durationBetween(state.firstTokenTimestamp, state.lastTokenTimestamp)
+  };
+  const payload = buildRequestEndPayload({
+    startMessage,
+    state,
+    success: msg.success,
+    responseBody,
+    timings
+  });
+  asyncWriter.enqueue(() => dbOps.saveRequest(startMessage.requestId, startMessage.method, startMessage.path, startMessage.providerName, startMessage.upstreamPath, startMessage.accountId, startMessage.responseStatus, msg.success, msg.error || null, responseTime, startMessage.failoverAttempts, state.usage.model ? {
+    model: state.usage.model,
+    promptTokens: (state.usage.inputTokens || 0) + (state.usage.cacheReadInputTokens || 0) + (state.usage.cacheCreationInputTokens || 0),
+    completionTokens: state.usage.outputTokens,
+    totalTokens: state.usage.totalTokens,
+    costUsd: state.usage.costUsd,
+    inputTokens: state.usage.inputTokens,
+    outputTokens: state.usage.outputTokens,
+    cacheReadInputTokens: state.usage.cacheReadInputTokens,
+    cacheCreationInputTokens: state.usage.cacheCreationInputTokens,
+    reasoningTokens: state.usage.reasoningTokens,
+    tokensPerSecond: state.usage.tokensPerSecond
+  } : undefined, {
+    timestamp: startMessage.timestamp,
+    payload,
+    timings
+  }));
+  if (state.usage.model && startMessage.accountId !== null) {
+    log7.info(`Usage for request ${startMessage.requestId}: Model: ${state.usage.model}, ` + `Tokens: ${state.usage.totalTokens || 0}, Cost: ${formatCost(state.usage.costUsd)}`);
+  }
+  const summary = {
+    id: startMessage.requestId,
+    timestamp: new Date(startMessage.timestamp).toISOString(),
+    method: startMessage.method,
+    path: startMessage.path,
+    provider: startMessage.providerName,
+    upstreamPath: startMessage.upstreamPath,
+    accountUsed: startMessage.accountId,
+    accountName: null,
+    statusCode: startMessage.responseStatus,
+    success: msg.success,
+    errorMessage: msg.error || null,
+    responseTimeMs: responseTime,
+    failoverAttempts: startMessage.failoverAttempts,
+    model: state.usage.model ?? null,
+    promptTokens: state.usage.inputTokens ?? null,
+    completionTokens: state.usage.outputTokens ?? null,
+    totalTokens: state.usage.totalTokens ?? null,
+    inputTokens: state.usage.inputTokens ?? null,
+    cacheReadInputTokens: state.usage.cacheReadInputTokens ?? null,
+    cacheCreationInputTokens: state.usage.cacheCreationInputTokens ?? null,
+    reasoningTokens: state.usage.reasoningTokens ?? null,
+    outputTokens: state.usage.outputTokens ?? null,
+    costUsd: state.usage.costUsd ?? null,
+    tokensPerSecond: state.usage.tokensPerSecond ?? null,
+    ttftMs: timings.ttftMs,
+    proxyOverheadMs: timings.proxyOverheadMs,
+    upstreamTtfbMs: timings.upstreamTtfbMs,
+    streamingDurationMs: timings.streamingDurationMs,
+    responseId: payload.meta.trace.responseId ?? null,
+    previousResponseId: payload.meta.trace.previousResponseId ?? null,
+    responseChainId: null,
+    clientSessionId: payload.meta.trace.clientSessionId ?? null
+  };
+  self.postMessage({
+    type: "summary",
+    summary
+  });
+  self.postMessage({
+    type: "payload",
+    payload: { ...payload, error: msg.error }
+  });
+  requests.delete(msg.requestId);
+}
+async function handleShutdown() {
+  log7.info("Worker shutting down, flushing async writer...");
+  if (cleanupIntervalId) {
+    clearInterval(cleanupIntervalId);
+    cleanupIntervalId = null;
+  }
+  for (const requestId of Array.from(requests.keys())) {
+    await handleEnd({
+      type: "end",
+      requestId,
+      success: false,
+      error: "Request interrupted by shutdown"
+    });
+  }
+  await asyncWriter.dispose();
+  dbOps.close();
+  self.postMessage({
+    type: "shutdown-complete",
+    asyncWriter: {
+      healthy: asyncWriter.isHealthy(),
+      failureCount: asyncWriter.getFailureCount(),
+      queuedJobs: asyncWriter.getQueueSize()
+    }
+  });
+}
+function acknowledgeMessage(message) {
+  if (!message.messageId) {
+    return;
+  }
+  self.postMessage({
+    type: "ack",
+    messageId: message.messageId,
+    requestId: "requestId" in message ? message.requestId : undefined,
+    acknowledgedType: message.type
+  });
+}
+function cleanupStaleRequests() {
+  const now = Date.now();
+  for (const [id, state] of requests) {
+    if (now - state.lastActivity > TIMEOUT_MS) {
+      log7.warn(`Request ${id} appears orphaned (no activity for ${TIMEOUT_MS}ms), cleaning up...`);
+      handleEnd({
+        type: "end",
+        requestId: id,
+        success: false,
+        error: "Request orphaned - no activity"
+      });
+    }
+  }
+}
+if (typeof self !== "undefined" && typeof self.postMessage === "function") {
+  cleanupIntervalId = setInterval(cleanupStaleRequests, TIMEOUT_MS);
+  self.onmessage = (event) => {
+    const msg = event.data;
+    acknowledgeMessage(msg);
+    messageProcessingQueue = messageProcessingQueue.then(async () => {
+      switch (msg.type) {
+        case "start":
+          await handleStart(msg);
+          break;
+        case "chunk":
+          handleChunk(msg);
+          break;
+        case "end":
+          await handleEnd(msg);
+          break;
+        case "shutdown":
+          await handleShutdown();
+          break;
+      }
+    }).catch((error) => {
+      log7.error("Failed to process usage worker message", error);
+    });
+  };
+  self.postMessage({
+    type: "ready"
+  });
+}
+export {
+  processStreamChunk,
+  createRequestState,
+  buildRequestEndPayload
+};