// open-sse/mcp-server/server.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

// open-sse/mcp-server/schemas/tools.ts
import { z } from "zod";
var getHealthInput = z.object({}).describe("No parameters required");
var getHealthOutput = z.object({
  uptime: z.string(),
  version: z.string(),
  memoryUsage: z.object({
    heapUsed: z.number(),
    heapTotal: z.number(),
  }),
  circuitBreakers: z.array(
    z.object({
      provider: z.string(),
      state: z.enum(["CLOSED", "OPEN", "HALF_OPEN"]),
      failureCount: z.number(),
      lastFailure: z.string().nullable(),
    })
  ),
  rateLimits: z.array(
    z.object({
      provider: z.string(),
      rpm: z.number(),
      currentUsage: z.number(),
      isLimited: z.boolean(),
    })
  ),
  cacheStats: z
    .object({
      hits: z.number(),
      misses: z.number(),
      hitRate: z.number(),
    })
    .optional(),
});
var getHealthTool = {
  name: "omniroute_get_health",
  description:
    "Returns the current health status of OmniRoute including uptime, memory usage, circuit breaker states for all providers, rate limit status, and cache statistics.",
  inputSchema: getHealthInput,
  outputSchema: getHealthOutput,
  scopes: ["read:health"],
  auditLevel: "basic",
  phase: 1,
  sourceEndpoints: ["/api/monitoring/health", "/api/resilience", "/api/rate-limits"],
};
var listCombosInput = z.object({
  includeMetrics: z
    .boolean()
    .optional()
    .describe("Include request count, success rate, latency, and cost metrics per combo"),
});
var listCombosOutput = z.object({
  combos: z.array(
    z.object({
      id: z.string(),
      name: z.string(),
      models: z.array(
        z.object({
          provider: z.string(),
          model: z.string(),
          priority: z.number(),
        })
      ),
      strategy: z.enum([
        "priority",
        "weighted",
        "round-robin",
        "strict-random",
        "random",
        "least-used",
        "cost-optimized",
        "auto",
      ]),
      enabled: z.boolean(),
      metrics: z
        .object({
          requestCount: z.number(),
          successRate: z.number(),
          avgLatencyMs: z.number(),
          totalCost: z.number(),
        })
        .optional(),
    })
  ),
});
var listCombosTool = {
  name: "omniroute_list_combos",
  description:
    "Lists all configured combos (model chains) with their strategies and optionally includes performance metrics. Combos define how requests are routed across multiple providers.",
  inputSchema: listCombosInput,
  outputSchema: listCombosOutput,
  scopes: ["read:combos"],
  auditLevel: "basic",
  phase: 1,
  sourceEndpoints: ["/api/combos", "/api/combos/metrics"],
};
var getComboMetricsInput = z.object({
  comboId: z.string().describe("ID of the combo to get metrics for"),
});
var getComboMetricsOutput = z.object({
  requests: z.number(),
  successRate: z.number(),
  avgLatency: z.number(),
  costTotal: z.number(),
  fallbackCount: z.number(),
  byProvider: z.array(
    z.object({
      provider: z.string(),
      requests: z.number(),
      successRate: z.number(),
      avgLatency: z.number(),
    })
  ),
});
var getComboMetricsTool = {
  name: "omniroute_get_combo_metrics",
  description:
    "Returns detailed performance metrics for a specific combo including request count, success rate, average latency, total cost, and per-provider breakdowns.",
  inputSchema: getComboMetricsInput,
  outputSchema: getComboMetricsOutput,
  scopes: ["read:combos"],
  auditLevel: "basic",
  phase: 1,
  sourceEndpoints: ["/api/combos/metrics"],
};
var switchComboInput = z.object({
  comboId: z.string().describe("ID of the combo to activate/deactivate"),
  active: z.boolean().describe("Whether to enable or disable the combo"),
});
var switchComboOutput = z.object({
  success: z.boolean(),
  combo: z.object({
    id: z.string(),
    name: z.string(),
    enabled: z.boolean(),
  }),
});
var switchComboTool = {
  name: "omniroute_switch_combo",
  description:
    "Activates or deactivates a combo. When deactivated, requests will not be routed through this combo. Use to toggle between different routing strategies.",
  inputSchema: switchComboInput,
  outputSchema: switchComboOutput,
  scopes: ["write:combos"],
  auditLevel: "full",
  phase: 1,
  sourceEndpoints: ["/api/combos"],
};
var checkQuotaInput = z.object({
  provider: z
    .string()
    .optional()
    .describe(
      "Filter by provider name (e.g., 'claude', 'gemini'). If omitted, returns all providers."
    ),
  connectionId: z.string().optional().describe("Filter by specific connection ID"),
});
var checkQuotaOutput = z.object({
  providers: z.array(
    z.object({
      name: z.string(),
      provider: z.string(),
      connectionId: z.string(),
      quotaUsed: z.number(),
      quotaTotal: z.number().nullable(),
      percentRemaining: z.number(),
      resetAt: z.string().nullable(),
      tokenStatus: z.enum(["valid", "expiring", "expired", "refreshing"]),
    })
  ),
  meta: z
    .object({
      generatedAt: z.string(),
      filters: z.object({
        provider: z.string().nullable(),
        connectionId: z.string().nullable(),
      }),
      totalProviders: z.number(),
    })
    .optional(),
});
var checkQuotaTool = {
  name: "omniroute_check_quota",
  description:
    "Checks the remaining API quota for one or all providers. Returns quota used/total, percentage remaining, reset time, and token health status.",
  inputSchema: checkQuotaInput,
  outputSchema: checkQuotaOutput,
  scopes: ["read:quota"],
  auditLevel: "basic",
  phase: 1,
  sourceEndpoints: ["/api/usage/quota", "/api/token-health", "/api/rate-limits"],
};
var routeRequestInput = z.object({
  model: z.string().describe("Model identifier (e.g., 'claude-sonnet-4', 'gpt-4o')"),
  messages: z
    .array(
      z.object({
        role: z.string(),
        content: z.string(),
      })
    )
    .describe("Chat messages in OpenAI format"),
  combo: z.string().optional().describe("Specific combo to route through"),
  budget: z.number().optional().describe("Maximum cost in USD for this request"),
  role: z
    .enum(["coding", "review", "planning", "analysis"])
    .optional()
    .describe("Task role hint for intelligent routing"),
  stream: z.boolean().optional().default(false).describe("Whether to stream the response"),
});
var routeRequestOutput = z.object({
  response: z.object({
    content: z.string(),
    model: z.string(),
    tokens: z.object({
      prompt: z.number(),
      completion: z.number(),
    }),
  }),
  routing: z.object({
    provider: z.string(),
    combo: z.string().nullable(),
    fallbacksTriggered: z.number(),
    cost: z.number(),
    latencyMs: z.number(),
    routingExplanation: z.string(),
  }),
});
var routeRequestTool = {
  name: "omniroute_route_request",
  description:
    "Sends a chat completion request through OmniRoute's intelligent routing pipeline. Supports combo selection, budget limits, and task role hints for optimal provider matching.",
  inputSchema: routeRequestInput,
  outputSchema: routeRequestOutput,
  scopes: ["execute:completions"],
  auditLevel: "full",
  phase: 1,
  sourceEndpoints: ["/v1/chat/completions", "/v1/responses"],
};
var costReportInput = z.object({
  period: z
    .enum(["session", "day", "week", "month"])
    .optional()
    .default("session")
    .describe("Time period for the cost report"),
});
var costReportOutput = z.object({
  period: z.string(),
  totalCost: z.number(),
  requestCount: z.number(),
  tokenCount: z.object({
    prompt: z.number(),
    completion: z.number(),
  }),
  byProvider: z.array(
    z.object({
      name: z.string(),
      cost: z.number(),
      requests: z.number(),
    })
  ),
  byModel: z.array(
    z.object({
      model: z.string(),
      cost: z.number(),
      requests: z.number(),
    })
  ),
  budget: z.object({
    limit: z.number().nullable(),
    remaining: z.number().nullable(),
  }),
});
var costReportTool = {
  name: "omniroute_cost_report",
  description:
    "Generates a cost report for the specified period showing total cost, request count, token usage, and breakdowns by provider and model. Also shows budget status if configured.",
  inputSchema: costReportInput,
  outputSchema: costReportOutput,
  scopes: ["read:usage"],
  auditLevel: "basic",
  phase: 1,
  sourceEndpoints: ["/api/usage/analytics", "/api/usage/budget"],
};
var listModelsCatalogInput = z.object({
  provider: z.string().optional().describe("Filter by provider name"),
  capability: z
    .enum(["chat", "embedding", "image", "audio", "video", "rerank", "moderation"])
    .optional()
    .describe("Filter by model capability"),
});
var listModelsCatalogOutput = z.object({
  models: z.array(
    z.object({
      id: z.string(),
      provider: z.string(),
      capabilities: z.array(z.string()),
      status: z.enum(["available", "degraded", "unavailable"]),
      pricing: z
        .object({
          inputPerMillion: z.number().nullable(),
          outputPerMillion: z.number().nullable(),
        })
        .optional(),
    })
  ),
});
var listModelsCatalogTool = {
  name: "omniroute_list_models_catalog",
  description:
    "Lists all available AI models across all providers with their capabilities, current status, and pricing information.",
  inputSchema: listModelsCatalogInput,
  outputSchema: listModelsCatalogOutput,
  scopes: ["read:models"],
  auditLevel: "none",
  phase: 1,
  sourceEndpoints: ["/api/models/catalog", "/v1/models"],
};
var webSearchInput = z.object({
  query: z
    .string()
    .min(1, "Query is required")
    .max(1e3, "Query must be 1000 characters or fewer")
    .describe("The search query string"),
  max_results: z
    .number()
    .int()
    .min(1)
    .max(20)
    .default(5)
    .describe("Maximum number of search results to return"),
  search_type: z.enum(["web", "news"]).default("web").describe("Type of search to perform"),
  provider: z
    .string()
    .optional()
    .describe("Specific search provider to use (serper, brave, perplexity, exa, tavily)"),
});
var webSearchOutput = z.object({
  id: z.string(),
  provider: z.string(),
  query: z.string(),
  results: z.array(
    z.object({
      title: z.string(),
      url: z.string(),
      display_url: z.string().optional(),
      snippet: z.string(),
      position: z.number().int().positive(),
    })
  ),
  cached: z.boolean(),
  usage: z.object({
    queries_used: z.number().int().min(0),
    search_cost_usd: z.number().min(0),
  }),
});
var webSearchTool = {
  name: "omniroute_web_search",
  description:
    "Performs a web search using OmniRoute's search gateway. Supports multiple providers (Serper, Brave, Perplexity, Exa, Tavily) with automatic failover. Returns search results with titles, URLs, snippets, and position data.",
  inputSchema: webSearchInput,
  outputSchema: webSearchOutput,
  scopes: ["execute:search"],
  auditLevel: "basic",
  phase: 1,
  sourceEndpoints: ["/v1/search"],
};
var simulateRouteInput = z.object({
  model: z.string().describe("Target model for simulation"),
  promptTokenEstimate: z.number().describe("Estimated prompt token count"),
  combo: z.string().optional().describe("Specific combo to simulate (default: active combo)"),
});
var simulateRouteOutput = z.object({
  simulatedPath: z.array(
    z.object({
      provider: z.string(),
      model: z.string(),
      probability: z.number(),
      estimatedCost: z.number(),
      healthStatus: z.enum(["CLOSED", "OPEN", "HALF_OPEN"]),
      quotaAvailable: z.number(),
    })
  ),
  fallbackTree: z.object({
    primary: z.string(),
    fallbacks: z.array(z.string()),
    worstCaseCost: z.number(),
    bestCaseCost: z.number(),
  }),
});
var simulateRouteTool = {
  name: "omniroute_simulate_route",
  description:
    "Simulates (dry-run) the routing path a request would take without actually executing it. Shows the fallback tree, provider probabilities, estimated costs, and health status.",
  inputSchema: simulateRouteInput,
  outputSchema: simulateRouteOutput,
  scopes: ["read:health", "read:combos"],
  auditLevel: "basic",
  phase: 2,
  sourceEndpoints: ["/api/combos", "/api/monitoring/health", "/api/resilience"],
};
var setBudgetGuardInput = z.object({
  maxCost: z.number().describe("Maximum cost in USD for this session"),
  action: z.enum(["degrade", "block", "alert"]).describe("Action when budget is exceeded"),
  degradeToTier: z
    .enum(["cheap", "free"])
    .optional()
    .describe("If action=degrade, which tier to fall back to"),
});
var setBudgetGuardOutput = z.object({
  sessionId: z.string(),
  budgetTotal: z.number(),
  budgetSpent: z.number(),
  budgetRemaining: z.number(),
  action: z.string(),
  status: z.enum(["active", "warning", "exceeded"]),
});
var setBudgetGuardTool = {
  name: "omniroute_set_budget_guard",
  description:
    "Sets a budget guard that limits spending for the current session. When the budget is reached, it can degrade to cheaper models, block requests, or send alerts.",
  inputSchema: setBudgetGuardInput,
  outputSchema: setBudgetGuardOutput,
  scopes: ["write:budget"],
  auditLevel: "full",
  phase: 2,
  sourceEndpoints: ["/api/usage/budget"],
};
var setRoutingStrategyInput = z.object({
  comboId: z.string().describe("Combo ID or name to update"),
  strategy: z
    .enum([
      "priority",
      "weighted",
      "round-robin",
      "strict-random",
      "random",
      "least-used",
      "cost-optimized",
      "auto",
    ])
    .describe("Routing strategy to apply"),
  autoRoutingStrategy: z
    .enum(["rules", "cost", "eco", "latency", "fast"])
    .optional()
    .describe("Optional strategy used by auto mode (only used when strategy='auto')"),
});
var setRoutingStrategyOutput = z.object({
  success: z.boolean(),
  combo: z.object({
    id: z.string(),
    name: z.string(),
    strategy: z.string(),
    autoRoutingStrategy: z.string().nullable(),
  }),
});
var setRoutingStrategyTool = {
  name: "omniroute_set_routing_strategy",
  description:
    "Updates a combo routing strategy (priority/weighted/auto/etc.) at runtime. Supports selecting the sub-strategy used by auto mode (rules/cost/latency).",
  inputSchema: setRoutingStrategyInput,
  outputSchema: setRoutingStrategyOutput,
  scopes: ["write:combos"],
  auditLevel: "full",
  phase: 2,
  sourceEndpoints: ["/api/combos", "/api/combos/{id}"],
};
var setResilienceProfileInput = z.object({
  profile: z
    .enum(["aggressive", "balanced", "conservative"])
    .describe("Resilience profile to apply"),
});
var setResilienceProfileOutput = z.object({
  applied: z.boolean(),
  settings: z.object({
    circuitBreakerThreshold: z.number(),
    retryCount: z.number(),
    timeoutMs: z.number(),
    fallbackDepth: z.number(),
  }),
});
var setResilienceProfileTool = {
  name: "omniroute_set_resilience_profile",
  description:
    "Applies a resilience profile that adjusts circuit breaker thresholds, retry counts, timeouts, and fallback depth. 'aggressive' = fast fail, 'conservative' = max retries.",
  inputSchema: setResilienceProfileInput,
  outputSchema: setResilienceProfileOutput,
  scopes: ["write:resilience"],
  auditLevel: "full",
  phase: 2,
  sourceEndpoints: ["/api/resilience"],
};
var testComboInput = z.object({
  comboId: z.string().describe("ID of the combo to test"),
  testPrompt: z.string().max(500).describe("Short test prompt (max 500 chars)"),
});
var testComboOutput = z.object({
  results: z.array(
    z.object({
      provider: z.string(),
      model: z.string(),
      success: z.boolean(),
      latencyMs: z.number(),
      cost: z.number(),
      tokenCount: z.number(),
      error: z.string().optional(),
    })
  ),
  summary: z.object({
    totalProviders: z.number(),
    successful: z.number(),
    fastestProvider: z.string(),
    cheapestProvider: z.string(),
  }),
});
var testComboTool = {
  name: "omniroute_test_combo",
  description:
    "Tests a combo by sending a short test prompt to each provider in the combo and reporting individual results including latency, cost, and success status.",
  inputSchema: testComboInput,
  outputSchema: testComboOutput,
  scopes: ["execute:completions", "read:combos"],
  auditLevel: "full",
  phase: 2,
  sourceEndpoints: ["/api/combos/test", "/v1/chat/completions"],
};
var getProviderMetricsInput = z.object({
  provider: z.string().describe("Provider name (e.g., 'claude', 'gemini-cli', 'codex')"),
});
var getProviderMetricsOutput = z.object({
  provider: z.string(),
  successRate: z.number(),
  requestCount: z.number(),
  avgLatencyMs: z.number(),
  p50LatencyMs: z.number(),
  p95LatencyMs: z.number(),
  p99LatencyMs: z.number(),
  errorRate: z.number(),
  lastError: z
    .object({
      message: z.string(),
      timestamp: z.string(),
    })
    .nullable(),
  circuitBreakerState: z.enum(["CLOSED", "OPEN", "HALF_OPEN"]),
  quotaInfo: z.object({
    used: z.number(),
    total: z.number().nullable(),
    resetAt: z.string().nullable(),
  }),
});
var getProviderMetricsTool = {
  name: "omniroute_get_provider_metrics",
  description:
    "Returns detailed performance metrics for a specific provider including success/error rates, latency percentiles (p50/p95/p99), circuit breaker state, and quota information.",
  inputSchema: getProviderMetricsInput,
  outputSchema: getProviderMetricsOutput,
  scopes: ["read:health"],
  auditLevel: "basic",
  phase: 2,
  sourceEndpoints: ["/api/provider-metrics", "/api/resilience"],
};
var bestComboForTaskInput = z.object({
  taskType: z
    .enum(["coding", "review", "planning", "analysis", "debugging", "documentation"])
    .describe("Type of task to find the best combo for"),
  budgetConstraint: z.number().optional().describe("Maximum cost in USD"),
  latencyConstraint: z.number().optional().describe("Maximum acceptable latency in ms"),
});
var bestComboForTaskOutput = z.object({
  recommendedCombo: z.object({
    id: z.string(),
    name: z.string(),
    reason: z.string(),
  }),
  alternatives: z.array(
    z.object({
      id: z.string(),
      name: z.string(),
      tradeoff: z.string(),
    })
  ),
  freeAlternative: z
    .object({
      id: z.string(),
      name: z.string(),
    })
    .nullable(),
});
var bestComboForTaskTool = {
  name: "omniroute_best_combo_for_task",
  description:
    "Recommends the best combo for a given task type (coding, review, planning, etc.) considering budget and latency constraints. Also suggests alternatives and free options.",
  inputSchema: bestComboForTaskInput,
  outputSchema: bestComboForTaskOutput,
  scopes: ["read:combos", "read:health"],
  auditLevel: "basic",
  phase: 2,
  sourceEndpoints: ["/api/combos", "/api/combos/metrics", "/api/monitoring/health"],
};
var explainRouteInput = z.object({
  requestId: z.string().describe("Request ID from the X-Request-Id header"),
});
var explainRouteOutput = z.object({
  requestId: z.string(),
  decision: z.object({
    comboUsed: z.string(),
    providerSelected: z.string(),
    modelUsed: z.string(),
    score: z.number(),
    factors: z.array(
      z.object({
        name: z.string(),
        value: z.number(),
        weight: z.number(),
        contribution: z.number(),
      })
    ),
    fallbacksTriggered: z.array(
      z.object({
        provider: z.string(),
        reason: z.string(),
      })
    ),
    costActual: z.number(),
    latencyActual: z.number(),
  }),
});
var explainRouteTool = {
  name: "omniroute_explain_route",
  description:
    "Explains why a specific request was routed to a particular provider. Shows the scoring factors, weights, fallbacks triggered, actual cost, and latency.",
  inputSchema: explainRouteInput,
  outputSchema: explainRouteOutput,
  scopes: ["read:health", "read:usage"],
  auditLevel: "basic",
  phase: 2,
  sourceEndpoints: [],
};
var getSessionSnapshotInput = z.object({}).describe("No parameters required");
var getSessionSnapshotOutput = z.object({
  sessionStart: z.string(),
  duration: z.string(),
  requestCount: z.number(),
  costTotal: z.number(),
  tokenCount: z.object({
    prompt: z.number(),
    completion: z.number(),
  }),
  topModels: z.array(
    z.object({
      model: z.string(),
      count: z.number(),
    })
  ),
  topProviders: z.array(
    z.object({
      provider: z.string(),
      count: z.number(),
    })
  ),
  errors: z.number(),
  fallbacks: z.number(),
  budgetGuard: z
    .object({
      active: z.boolean(),
      remaining: z.number(),
    })
    .nullable(),
});
var getSessionSnapshotTool = {
  name: "omniroute_get_session_snapshot",
  description:
    "Returns a snapshot of the current working session including duration, request count, total cost, top models/providers used, error count, and budget guard status.",
  inputSchema: getSessionSnapshotInput,
  outputSchema: getSessionSnapshotOutput,
  scopes: ["read:usage"],
  auditLevel: "none",
  phase: 2,
  sourceEndpoints: ["/api/usage/analytics", "/api/telemetry/summary"],
};
var syncPricingInput = z.object({
  sources: z
    .array(z.string())
    .optional()
    .describe("External pricing sources to sync from (default: ['litellm'])"),
  dryRun: z
    .boolean()
    .optional()
    .describe("If true, preview sync results without saving to database"),
});
var syncPricingOutput = z.object({
  success: z.boolean(),
  modelCount: z.number(),
  providerCount: z.number(),
  source: z.string(),
  dryRun: z.boolean(),
  error: z.string().optional(),
  warnings: z.array(z.string()).optional(),
  data: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
});
var syncPricingTool = {
  name: "omniroute_sync_pricing",
  description:
    "Syncs pricing data from external sources (LiteLLM) into OmniRoute. Synced pricing fills gaps not covered by hardcoded defaults without overwriting user-set prices. Use dryRun=true to preview.",
  inputSchema: syncPricingInput,
  outputSchema: syncPricingOutput,
  scopes: ["pricing:write"],
  auditLevel: "full",
  phase: 2,
  sourceEndpoints: ["/api/pricing/sync"],
};
var cacheStatsInput = z.object({}).describe("No parameters required");
var cacheStatsOutput = z.object({
  semanticCache: z.object({
    memoryEntries: z.number(),
    dbEntries: z.number(),
    hits: z.number(),
    misses: z.number(),
    hitRate: z.string(),
    tokensSaved: z.number(),
  }),
  promptCache: z
    .object({
      totalRequests: z.number(),
      requestsWithCacheControl: z.number(),
      totalCachedTokens: z.number(),
      totalCacheCreationTokens: z.number(),
      estimatedCostSaved: z.number(),
    })
    .nullable(),
  idempotency: z.object({
    activeKeys: z.number(),
    windowMs: z.number(),
  }),
});
var cacheStatsTool = {
  name: "omniroute_cache_stats",
  description:
    "Returns cache statistics including semantic cache hit rate, prompt cache metrics by provider, and idempotency layer stats.",
  inputSchema: cacheStatsInput,
  outputSchema: cacheStatsOutput,
  scopes: ["read:cache"],
  auditLevel: "basic",
  phase: 2,
  sourceEndpoints: ["/api/cache"],
};
var cacheFlushInput = z.object({
  signature: z.string().optional().describe("Specific cache signature to invalidate"),
  model: z.string().optional().describe("Invalidate all entries for a specific model"),
});
var cacheFlushOutput = z.object({
  ok: z.boolean(),
  invalidated: z.number().optional(),
  scope: z.string().optional(),
});
var cacheFlushTool = {
  name: "omniroute_cache_flush",
  description:
    "Flush cache entries. Provide signature to invalidate a single entry, model to invalidate all entries for a model, or omit both to clear all.",
  inputSchema: cacheFlushInput,
  outputSchema: cacheFlushOutput,
  scopes: ["write:cache"],
  auditLevel: "full",
  phase: 2,
  sourceEndpoints: ["/api/cache"],
};
var MCP_TOOLS = [
  getHealthTool,
  listCombosTool,
  getComboMetricsTool,
  switchComboTool,
  checkQuotaTool,
  routeRequestTool,
  costReportTool,
  listModelsCatalogTool,
  webSearchTool,
  simulateRouteTool,
  setBudgetGuardTool,
  setRoutingStrategyTool,
  setResilienceProfileTool,
  testComboTool,
  getProviderMetricsTool,
  bestComboForTaskTool,
  explainRouteTool,
  getSessionSnapshotTool,
  syncPricingTool,
  cacheStatsTool,
  cacheFlushTool,
];
var MCP_ESSENTIAL_TOOLS = MCP_TOOLS.filter((t) => t.phase === 1);
var MCP_ADVANCED_TOOLS = MCP_TOOLS.filter((t) => t.phase === 2);
var MCP_TOOL_MAP = Object.fromEntries(MCP_TOOLS.map((t) => [t.name, t]));

// open-sse/mcp-server/runtimeHeartbeat.ts
import { promises as fs } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";
var HEARTBEAT_FILE = "mcp-heartbeat.json";
var RUNTIME_DIR = "runtime";
var DEFAULT_INTERVAL_MS = 5e3;
function resolveDataDir() {
  const configured = process.env.DATA_DIR;
  if (typeof configured === "string" && configured.trim().length > 0) {
    return configured.trim();
  }
  return join(homedir(), ".omniroute");
}
function resolveMcpHeartbeatPath() {
  return join(resolveDataDir(), RUNTIME_DIR, HEARTBEAT_FILE);
}
async function writeHeartbeat(snapshot) {
  const heartbeatPath = resolveMcpHeartbeatPath();
  const runtimeDir = join(resolveDataDir(), RUNTIME_DIR);
  await fs.mkdir(runtimeDir, { recursive: true });
  await fs.writeFile(heartbeatPath, JSON.stringify(snapshot, null, 2), "utf-8");
}
function startMcpHeartbeat(config) {
  const startedAt = /* @__PURE__ */ new Date().toISOString();
  let timer = null;
  let stopped = false;
  const intervalMs =
    typeof config.intervalMs === "number" && config.intervalMs > 0
      ? config.intervalMs
      : DEFAULT_INTERVAL_MS;
  const tick = async () => {
    if (stopped) return;
    const snapshot = {
      pid: process.pid,
      startedAt,
      lastHeartbeatAt: /* @__PURE__ */ new Date().toISOString(),
      version: config.version,
      transport: "stdio",
      scopesEnforced: config.scopesEnforced,
      allowedScopes: [...config.allowedScopes],
      toolCount: config.toolCount,
    };
    try {
      await writeHeartbeat(snapshot);
    } catch (error) {
      const message = error instanceof Error ? error.message : String(error);
      console.error("[MCP Heartbeat] Failed to write heartbeat:", message);
    }
  };
  void tick();
  timer = setInterval(() => {
    void tick();
  }, intervalMs);
  return () => {
    if (stopped) return;
    stopped = true;
    if (timer) {
      clearInterval(timer);
      timer = null;
    }
    void tick();
  };
}

// open-sse/mcp-server/schemas/audit.ts
async function hashInput(input) {
  const data = JSON.stringify(input);
  const encoder = new TextEncoder();
  const hashBuffer = await crypto.subtle.digest("SHA-256", encoder.encode(data));
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
}
function summarizeOutput(output, maxLength = 200) {
  if (output === null || output === void 0) return "(null)";
  const str = typeof output === "string" ? output : JSON.stringify(output);
  if (str.length <= maxLength) return str;
  return str.slice(0, maxLength) + "\u2026";
}

// open-sse/mcp-server/audit.ts
var db = null;
async function getDb() {
  if (db) return db;
  try {
    const { homedir: homedir2 } = await import("node:os");
    const { join: join2 } = await import("node:path");
    const { existsSync } = await import("node:fs");
    const dbPath = process.env.DATA_DIR
      ? join2(process.env.DATA_DIR, "storage.sqlite")
      : join2(homedir2(), ".omniroute", "storage.sqlite");
    if (!existsSync(dbPath)) {
      console.error(`[MCP Audit] Database not found at ${dbPath} \u2014 audit logging disabled`);
      return null;
    }
    const Database2 = (await import("better-sqlite3")).default;
    db = new Database2(dbPath);
    return db;
  } catch (err) {
    const message = err instanceof Error ? err.message : String(err);
    console.error("[MCP Audit] Failed to connect to database:", message);
    return null;
  }
}
async function logToolCall(toolName, input, output, durationMs, success, errorCode) {
  try {
    const database = await getDb();
    if (!database) return;
    const inputHash = await hashInput(input);
    const outputSummary = summarizeOutput(output);
    const apiKeyId = process.env.OMNIROUTE_API_KEY_ID || null;
    database
      .prepare(
        `INSERT INTO mcp_tool_audit (tool_name, input_hash, output_summary, duration_ms, api_key_id, success, error_code)
         VALUES (?, ?, ?, ?, ?, ?, ?)`
      )
      .run(
        toolName,
        inputHash,
        outputSummary,
        durationMs,
        apiKeyId,
        success ? 1 : 0,
        errorCode || null
      );
  } catch (err) {
    const message = err instanceof Error ? err.message : String(err);
    console.error("[MCP Audit] Failed to log:", message);
  }
}

// open-sse/mcp-server/scopeEnforcement.ts
function normalizeScopeList(raw) {
  if (!Array.isArray(raw)) return [];
  const normalized = raw
    .filter((value) => typeof value === "string")
    .map((value) => value.trim())
    .filter(Boolean);
  return Array.from(new Set(normalized));
}
function extractMetaScopeList(meta) {
  if (!meta || typeof meta !== "object") return [];
  const metaRecord = meta;
  const direct = normalizeScopeList(metaRecord.scopes);
  if (direct.length > 0) return direct;
  const auth = metaRecord.auth;
  if (auth && typeof auth === "object") {
    const authScopes = normalizeScopeList(auth.scopes);
    if (authScopes.length > 0) return authScopes;
  }
  const omni = metaRecord.omniroute;
  if (omni && typeof omni === "object") {
    const omniScopes = normalizeScopeList(omni.scopes);
    if (omniScopes.length > 0) return omniScopes;
  }
  return [];
}
function scopeMatches(grantedScope, requiredScope) {
  if (grantedScope === "*" || grantedScope === requiredScope) {
    return true;
  }
  if (grantedScope.endsWith("*")) {
    const prefix = grantedScope.slice(0, -1);
    return requiredScope.startsWith(prefix);
  }
  return false;
}
function resolveCallerScopeContext(extra, fallbackScopes = []) {
  const callerId =
    (typeof extra?.authInfo?.clientId === "string" && extra.authInfo.clientId.trim()) ||
    (typeof extra?.sessionId === "string" && extra.sessionId.trim()) ||
    "anonymous";
  const authScopes = normalizeScopeList(extra?.authInfo?.scopes);
  if (authScopes.length > 0) {
    return { callerId, scopes: authScopes, source: "authInfo" };
  }
  const metaScopes = extractMetaScopeList(extra?._meta);
  if (metaScopes.length > 0) {
    return { callerId, scopes: metaScopes, source: "meta" };
  }
  const fallback = normalizeScopeList(fallbackScopes);
  if (fallback.length > 0) {
    return { callerId, scopes: fallback, source: "env" };
  }
  return { callerId, scopes: [], source: "none" };
}
function evaluateToolScopes(toolName, callerScopes, enforceScopes) {
  const toolDef = MCP_TOOL_MAP[toolName];
  if (!toolDef) {
    return {
      allowed: false,
      required: [],
      provided: Array.from(callerScopes),
      missing: [],
      reason: "tool_definition_missing",
    };
  }
  const required = Array.isArray(toolDef.scopes) ? Array.from(toolDef.scopes) : [];
  const provided = normalizeScopeList(callerScopes);
  if (!enforceScopes || required.length === 0) {
    return { allowed: true, required, provided, missing: [] };
  }
  const missing = required.filter(
    (requiredScope) => !provided.some((grantedScope) => scopeMatches(grantedScope, requiredScope))
  );
  return {
    allowed: missing.length === 0,
    required,
    provided,
    missing,
    reason: missing.length > 0 ? "missing_scopes" : void 0,
  };
}

// src/shared/contracts/quota.ts
var TOKEN_STATUS_VALUES = ["valid", "expiring", "expired", "refreshing"];
function toNumber(value) {
  if (typeof value === "number" && Number.isFinite(value)) return value;
  if (typeof value === "string" && value.trim() !== "") {
    const parsed = Number(value);
    if (Number.isFinite(parsed)) return parsed;
  }
  return null;
}
function clamp(value, min, max) {
  return Math.min(max, Math.max(min, value));
}
function normalizeTokenStatus(value) {
  if (typeof value === "string" && TOKEN_STATUS_VALUES.includes(value)) {
    return value;
  }
  return "valid";
}
function sanitizeQuotaProvider(input) {
  const source = input && typeof input === "object" ? input : {};
  const provider = typeof source.provider === "string" ? source.provider : "unknown";
  const name = typeof source.name === "string" && source.name.trim() ? source.name : provider;
  const connectionId =
    typeof source.connectionId === "string" && source.connectionId.trim()
      ? source.connectionId
      : "unknown";
  const quotaTotalRaw = toNumber(source.quotaTotal);
  const quotaTotal = quotaTotalRaw !== null && quotaTotalRaw >= 0 ? quotaTotalRaw : null;
  const quotaUsedRaw = toNumber(source.quotaUsed) ?? 0;
  const quotaUsed =
    quotaTotal !== null ? clamp(quotaUsedRaw, 0, quotaTotal) : Math.max(0, quotaUsedRaw);
  let percentRemainingRaw = toNumber(source.percentRemaining);
  if (percentRemainingRaw === null) {
    if (quotaTotal && quotaTotal > 0) {
      percentRemainingRaw = ((quotaTotal - quotaUsed) / quotaTotal) * 100;
    } else {
      percentRemainingRaw = 100;
    }
  }
  const percentRemaining = clamp(percentRemainingRaw, 0, 100);
  const resetAt =
    typeof source.resetAt === "string" && source.resetAt.trim() ? source.resetAt : null;
  return {
    name,
    provider,
    connectionId,
    quotaUsed,
    quotaTotal,
    percentRemaining,
    resetAt,
    tokenStatus: normalizeTokenStatus(source.tokenStatus),
  };
}
function normalizeQuotaResponse(raw, filters = {}) {
  const source = raw && typeof raw === "object" ? raw : {};
  const providersRaw = Array.isArray(source.providers)
    ? source.providers
    : Array.isArray(raw)
      ? raw
      : [];
  const providers = providersRaw.map((entry) => sanitizeQuotaProvider(entry));
  const sourceMeta = source.meta && typeof source.meta === "object" ? source.meta : {};
  const sourceFilters =
    sourceMeta.filters && typeof sourceMeta.filters === "object" ? sourceMeta.filters : {};
  const providerFilter =
    filters.provider ??
    (typeof sourceFilters.provider === "string" && sourceFilters.provider.trim()
      ? sourceFilters.provider
      : null);
  const connectionFilter =
    filters.connectionId ??
    (typeof sourceFilters.connectionId === "string" && sourceFilters.connectionId.trim()
      ? sourceFilters.connectionId
      : null);
  const generatedAt =
    typeof sourceMeta.generatedAt === "string" && sourceMeta.generatedAt.trim()
      ? sourceMeta.generatedAt
      : /* @__PURE__ */ new Date().toISOString();
  return {
    providers,
    meta: {
      generatedAt,
      filters: {
        provider: providerFilter || null,
        connectionId: connectionFilter || null,
      },
      totalProviders: providers.length,
    },
  };
}

// open-sse/mcp-server/tools/advancedTools.ts
var OMNIROUTE_BASE_URL = process.env.OMNIROUTE_BASE_URL || "http://localhost:20128";
var OMNIROUTE_API_KEY = process.env.OMNIROUTE_API_KEY || "";
async function apiFetch(path4, options = {}) {
  const url = `${OMNIROUTE_BASE_URL}${path4}`;
  const headers = {
    "Content-Type": "application/json",
    ...(OMNIROUTE_API_KEY ? { Authorization: `Bearer ${OMNIROUTE_API_KEY}` } : {}),
    ...(options.headers || {}),
  };
  const response = await fetch(url, { ...options, headers, signal: AbortSignal.timeout(3e4) });
  if (!response.ok) {
    const text = await response.text().catch(() => "Unknown error");
    throw new Error(`API [${response.status}]: ${text}`);
  }
  return response.json();
}
function isRecord(value) {
  return !!value && typeof value === "object" && !Array.isArray(value);
}
function toRecord(value) {
  return isRecord(value) ? value : {};
}
function toArrayOfRecords(value) {
  return Array.isArray(value) ? value.filter(isRecord) : [];
}
function toString(value, fallback = "") {
  return typeof value === "string" ? value : fallback;
}
function toNumber2(value, fallback = 0) {
  const parsed =
    typeof value === "number"
      ? value
      : typeof value === "string" && value.trim().length > 0
        ? Number(value)
        : Number.NaN;
  return Number.isFinite(parsed) ? parsed : fallback;
}
function getComboModels(combo) {
  const directModels = toArrayOfRecords(combo.models);
  const nestedModels = toArrayOfRecords(toRecord(combo.data).models);
  const sourceModels = directModels.length > 0 ? directModels : nestedModels;
  return sourceModels.map((model) => ({
    provider: toString(model.provider, "unknown"),
    model: toString(model.model, ""),
    inputCostPer1M: toNumber2(model.inputCostPer1M, 3),
  }));
}
function normalizeCombosResponse(raw) {
  if (Array.isArray(raw)) return raw.filter(isRecord);
  const source = toRecord(raw);
  return Array.isArray(source.combos) ? source.combos.filter(isRecord) : [];
}
var activeBudgetGuard = null;
var RESILIENCE_PROFILES = {
  aggressive: {
    profiles: {
      oauth: {
        transientCooldown: 3e3,
        rateLimitCooldown: 3e4,
        maxBackoffLevel: 4,
        circuitBreakerThreshold: 2,
        circuitBreakerReset: 3e4,
      },
      apikey: {
        transientCooldown: 2e3,
        rateLimitCooldown: 0,
        maxBackoffLevel: 3,
        circuitBreakerThreshold: 3,
        circuitBreakerReset: 15e3,
      },
    },
    defaults: {
      requestsPerMinute: 180,
      minTimeBetweenRequests: 100,
      concurrentRequests: 16,
    },
  },
  balanced: {
    profiles: {
      oauth: {
        transientCooldown: 5e3,
        rateLimitCooldown: 6e4,
        maxBackoffLevel: 8,
        circuitBreakerThreshold: 3,
        circuitBreakerReset: 6e4,
      },
      apikey: {
        transientCooldown: 3e3,
        rateLimitCooldown: 0,
        maxBackoffLevel: 5,
        circuitBreakerThreshold: 5,
        circuitBreakerReset: 3e4,
      },
    },
    defaults: {
      requestsPerMinute: 100,
      minTimeBetweenRequests: 200,
      concurrentRequests: 10,
    },
  },
  conservative: {
    profiles: {
      oauth: {
        transientCooldown: 8e3,
        rateLimitCooldown: 12e4,
        maxBackoffLevel: 10,
        circuitBreakerThreshold: 8,
        circuitBreakerReset: 12e4,
      },
      apikey: {
        transientCooldown: 5e3,
        rateLimitCooldown: 3e4,
        maxBackoffLevel: 8,
        circuitBreakerThreshold: 8,
        circuitBreakerReset: 6e4,
      },
    },
    defaults: {
      requestsPerMinute: 60,
      minTimeBetweenRequests: 350,
      concurrentRequests: 6,
    },
  },
};
var TASK_FITNESS = {
  coding: { preferred: ["claude", "deepseek", "codex"], traits: ["fast", "code-optimized"] },
  review: { preferred: ["claude", "gemini", "openai"], traits: ["analytical", "thorough"] },
  planning: { preferred: ["gemini", "claude", "openai"], traits: ["reasoning", "structured"] },
  analysis: { preferred: ["gemini", "claude"], traits: ["deep-reasoning", "large-context"] },
  debugging: { preferred: ["claude", "deepseek", "codex"], traits: ["code-aware", "fast"] },
  documentation: { preferred: ["gemini", "claude", "openai"], traits: ["clear", "structured"] },
};
async function handleSimulateRoute(args) {
  const start = Date.now();
  try {
    const [combosRaw, healthRaw, quotaRaw] = await Promise.allSettled([
      apiFetch("/api/combos"),
      apiFetch("/api/monitoring/health"),
      apiFetch("/api/usage/quota"),
    ]);
    const combos = combosRaw.status === "fulfilled" ? normalizeCombosResponse(combosRaw.value) : [];
    const health = healthRaw.status === "fulfilled" ? toRecord(healthRaw.value) : {};
    const quota =
      quotaRaw.status === "fulfilled"
        ? normalizeQuotaResponse(quotaRaw.value)
        : normalizeQuotaResponse({});
    const targetCombo = args.combo
      ? combos.find(
          (combo) => toString(combo.id) === args.combo || toString(combo.name) === args.combo
        )
      : combos.find((combo) => combo.enabled !== false);
    if (!targetCombo) {
      return {
        content: [{ type: "text", text: JSON.stringify({ error: "No matching combo found" }) }],
        isError: true,
      };
    }
    const models = getComboModels(targetCombo);
    const breakers = toArrayOfRecords(health.circuitBreakers);
    const providers = quota.providers;
    const simulatedPath = models.map((model, idx) => {
      const cb = breakers.find((breaker) => toString(breaker.provider) === model.provider);
      const q = providers.find((providerEntry) => providerEntry.provider === model.provider);
      const estimatedCost = (args.promptTokenEstimate / 1e6) * model.inputCostPer1M;
      return {
        provider: model.provider,
        model: model.model || args.model,
        probability: idx === 0 ? 0.85 : 0.15 / Math.max(models.length - 1, 1),
        estimatedCost: Math.round(estimatedCost * 1e4) / 1e4,
        healthStatus: toString(cb?.state, "CLOSED"),
        quotaAvailable: q?.percentRemaining ?? 100,
      };
    });
    const costs = simulatedPath.map((pathEntry) => pathEntry.estimatedCost);
    const result = {
      simulatedPath,
      fallbackTree: {
        primary: simulatedPath[0]?.provider || "unknown",
        fallbacks: simulatedPath.slice(1).map((pathEntry) => pathEntry.provider),
        worstCaseCost: Math.max(...costs, 0),
        bestCaseCost: Math.min(...costs, 0),
      },
    };
    await logToolCall("omniroute_simulate_route", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_simulate_route", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleSetBudgetGuard(args) {
  const start = Date.now();
  try {
    let spent = 0;
    try {
      const analytics = toRecord(await apiFetch("/api/usage/analytics?period=session"));
      spent = toNumber2(analytics.totalCost, 0);
    } catch {}
    activeBudgetGuard = {
      sessionId: `budget_${Date.now()}`,
      maxCost: args.maxCost,
      action: args.action,
      degradeToTier: args.degradeToTier,
      spent,
      createdAt: /* @__PURE__ */ new Date().toISOString(),
    };
    const remaining = Math.max(0, args.maxCost - spent);
    const result = {
      sessionId: activeBudgetGuard.sessionId,
      budgetTotal: args.maxCost,
      budgetSpent: Math.round(spent * 1e4) / 1e4,
      budgetRemaining: Math.round(remaining * 1e4) / 1e4,
      action: args.action,
      status: remaining <= 0 ? "exceeded" : remaining < args.maxCost * 0.2 ? "warning" : "active",
    };
    await logToolCall(
      "omniroute_set_budget_guard",
      { maxCost: args.maxCost, action: args.action },
      result,
      Date.now() - start,
      true
    );
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_set_budget_guard", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleSetRoutingStrategy(args) {
  const start = Date.now();
  try {
    const combos = normalizeCombosResponse(await apiFetch("/api/combos"));
    const combo = combos.find(
      (comboEntry) =>
        toString(comboEntry.id) === args.comboId || toString(comboEntry.name) === args.comboId
    );
    if (!combo) {
      const msg = `Combo '${args.comboId}' not found`;
      await logToolCall(
        "omniroute_set_routing_strategy",
        args,
        null,
        Date.now() - start,
        false,
        msg
      );
      return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
    }
    const comboId = toString(combo.id);
    if (!comboId) {
      const msg = "Matched combo has no id";
      await logToolCall(
        "omniroute_set_routing_strategy",
        args,
        null,
        Date.now() - start,
        false,
        msg
      );
      return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
    }
    const comboData = toRecord(combo.data);
    const currentConfig = toRecord(
      Object.keys(toRecord(combo.config)).length > 0 ? combo.config : comboData.config
    );
    let nextConfig = void 0;
    if (args.strategy === "auto" && args.autoRoutingStrategy) {
      const currentAutoConfig = toRecord(currentConfig.auto);
      nextConfig = {
        ...currentConfig,
        auto: {
          ...currentAutoConfig,
          routingStrategy: args.autoRoutingStrategy,
        },
      };
    }
    const payload = { strategy: args.strategy };
    if (nextConfig && Object.keys(nextConfig).length > 0) {
      payload.config = nextConfig;
    }
    const updatedCombo = toRecord(
      await apiFetch(`/api/combos/${encodeURIComponent(comboId)}`, {
        method: "PUT",
        body: JSON.stringify(payload),
      })
    );
    const updatedConfig = toRecord(updatedCombo.config);
    const resolvedAutoStrategy =
      toString(toRecord(updatedConfig.auto).routingStrategy) ||
      (args.strategy === "auto" ? (args.autoRoutingStrategy ?? "rules") : "");
    const result = {
      success: true,
      combo: {
        id: toString(updatedCombo.id, comboId),
        name: toString(updatedCombo.name, toString(combo.name, comboId)),
        strategy: toString(updatedCombo.strategy, args.strategy),
        autoRoutingStrategy:
          toString(updatedCombo.strategy, args.strategy) === "auto" ? resolvedAutoStrategy : null,
      },
    };
    await logToolCall("omniroute_set_routing_strategy", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_set_routing_strategy", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleSetResilienceProfile(args) {
  const start = Date.now();
  try {
    const settings = RESILIENCE_PROFILES[args.profile];
    if (!settings) {
      return {
        content: [{ type: "text", text: `Error: Invalid profile "${args.profile}"` }],
        isError: true,
      };
    }
    await apiFetch("/api/resilience", {
      method: "PATCH",
      body: JSON.stringify({
        profiles: settings.profiles,
        defaults: settings.defaults,
      }),
    });
    const result = { applied: true, profile: args.profile, settings };
    await logToolCall("omniroute_set_resilience_profile", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall(
      "omniroute_set_resilience_profile",
      args,
      null,
      Date.now() - start,
      false,
      msg
    );
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleTestCombo(args) {
  const start = Date.now();
  try {
    const combos = normalizeCombosResponse(await apiFetch("/api/combos"));
    const combo = combos.find(
      (comboEntry) =>
        toString(comboEntry.id) === args.comboId || toString(comboEntry.name) === args.comboId
    );
    if (!combo) {
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify({ error: `Combo "${args.comboId}" not found` }),
          },
        ],
        isError: true,
      };
    }
    const models = getComboModels(combo);
    const prompt = (args.testPrompt || "Say hello").slice(0, 200);
    const results = await Promise.allSettled(
      models.map(async (model) => {
        const providerStart = Date.now();
        try {
          const resp = toRecord(
            await apiFetch("/v1/chat/completions", {
              method: "POST",
              body: JSON.stringify({
                model: model.model || "auto",
                messages: [{ role: "user", content: prompt }],
                max_tokens: 50,
                stream: false,
                "x-provider": model.provider,
              }),
            })
          );
          const usage = toRecord(resp.usage);
          return {
            provider: model.provider,
            model: model.model || toString(resp.model, "unknown"),
            success: true,
            latencyMs: Date.now() - providerStart,
            cost: toNumber2(resp.cost, 0),
            tokenCount: toNumber2(usage.prompt_tokens, 0) + toNumber2(usage.completion_tokens, 0),
          };
        } catch (err) {
          return {
            provider: model.provider,
            model: model.model || "unknown",
            success: false,
            latencyMs: Date.now() - providerStart,
            cost: 0,
            tokenCount: 0,
            error: err instanceof Error ? err.message : String(err),
          };
        }
      })
    );
    const providerResults = results.map((r) =>
      r.status === "fulfilled"
        ? r.value
        : {
            provider: "unknown",
            model: "unknown",
            success: false,
            latencyMs: 0,
            cost: 0,
            tokenCount: 0,
            error: "Promise rejected",
          }
    );
    const successful = providerResults.filter((r) => r.success);
    const fastest = successful.sort((a, b) => a.latencyMs - b.latencyMs)[0];
    const cheapest = successful.sort((a, b) => a.cost - b.cost)[0];
    const result = {
      results: providerResults,
      summary: {
        totalProviders: providerResults.length,
        successful: successful.length,
        fastestProvider: fastest?.provider || "none",
        cheapestProvider: cheapest?.provider || "none",
      },
    };
    await logToolCall(
      "omniroute_test_combo",
      { comboId: args.comboId },
      result.summary,
      Date.now() - start,
      true
    );
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_test_combo", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleGetProviderMetrics(args) {
  const start = Date.now();
  try {
    const [healthRaw, quotaRaw, analyticsRaw] = await Promise.allSettled([
      apiFetch("/api/monitoring/health"),
      apiFetch(`/api/usage/quota?provider=${encodeURIComponent(args.provider)}`),
      apiFetch(`/api/usage/analytics?period=session&provider=${encodeURIComponent(args.provider)}`),
    ]);
    const health = healthRaw.status === "fulfilled" ? toRecord(healthRaw.value) : {};
    const quota =
      quotaRaw.status === "fulfilled"
        ? normalizeQuotaResponse(quotaRaw.value, { provider: args.provider })
        : normalizeQuotaResponse({});
    const analytics = analyticsRaw.status === "fulfilled" ? toRecord(analyticsRaw.value) : {};
    const cb = toArrayOfRecords(health.circuitBreakers).find(
      (breaker) => toString(breaker.provider) === args.provider
    );
    const providerQuota = quota.providers.find((p) => p.provider === args.provider) || null;
    const result = {
      provider: args.provider,
      successRate: toNumber2(analytics.successRate, 1),
      requestCount: toNumber2(analytics.requestCount, 0),
      avgLatencyMs: toNumber2(analytics.avgLatencyMs, 0),
      p50LatencyMs: toNumber2(analytics.p50LatencyMs, 0),
      p95LatencyMs: toNumber2(analytics.p95LatencyMs, 0),
      p99LatencyMs: toNumber2(analytics.p99LatencyMs, 0),
      errorRate: toNumber2(analytics.errorRate, 0),
      lastError: toString(analytics.lastError) || null,
      circuitBreakerState: toString(cb?.state, "CLOSED"),
      quotaInfo: providerQuota
        ? {
            used: providerQuota.quotaUsed,
            total: providerQuota.quotaTotal,
            resetAt: providerQuota.resetAt,
          }
        : { used: 0, total: null, resetAt: null },
    };
    await logToolCall("omniroute_get_provider_metrics", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_get_provider_metrics", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleBestComboForTask(args) {
  const start = Date.now();
  try {
    const fitness = TASK_FITNESS[args.taskType] || TASK_FITNESS.coding;
    const combos = normalizeCombosResponse(await apiFetch("/api/combos"));
    const enabledCombos = combos.filter((combo) => combo.enabled !== false);
    if (enabledCombos.length === 0) {
      return {
        content: [{ type: "text", text: JSON.stringify({ error: "No enabled combos available" }) }],
        isError: true,
      };
    }
    const scored = enabledCombos.map((combo) => {
      const models = getComboModels(combo);
      let score = 0;
      for (const model of models) {
        const prefIdx = fitness.preferred.indexOf(model.provider);
        if (prefIdx >= 0) score += (fitness.preferred.length - prefIdx) * 10;
      }
      const name = toString(combo.name).toLowerCase();
      for (const trait of fitness.traits) {
        if (name.includes(trait)) score += 5;
      }
      const isFree =
        name.includes("free") ||
        models.every((model) => model.provider.toLowerCase().includes("free"));
      return { combo, score, isFree };
    });
    scored.sort((a, b) => b.score - a.score);
    const best = scored[0];
    const alternatives = scored.slice(1, 4).map((s) => ({
      id: s.combo.id,
      name: s.combo.name,
      tradeoff: s.isFree
        ? "free but may have limits"
        : s.score < best.score * 0.5
          ? "cheaper but slower"
          : "similar quality, different providers",
    }));
    const freeAlt = scored.find((s) => s.isFree && s !== best);
    const result = {
      recommendedCombo: {
        id: best.combo.id,
        name: best.combo.name,
        reason: `Best match for "${args.taskType}": preferred providers (${fitness.preferred.slice(0, 3).join(", ")})`,
      },
      alternatives,
      freeAlternative: freeAlt ? { id: freeAlt.combo.id, name: freeAlt.combo.name } : null,
    };
    await logToolCall(
      "omniroute_best_combo_for_task",
      args,
      result.recommendedCombo,
      Date.now() - start,
      true
    );
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_best_combo_for_task", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleExplainRoute(args) {
  const start = Date.now();
  try {
    let decision = null;
    try {
      decision = toRecord(
        await apiFetch(`/api/routing/decisions/${encodeURIComponent(args.requestId)}`)
      );
    } catch {}
    const result = decision
      ? {
          requestId: args.requestId,
          decision: {
            comboUsed: decision.comboUsed || "default",
            providerSelected: decision.providerSelected || "unknown",
            modelUsed: decision.modelUsed || "unknown",
            score: decision.score || 0,
            factors: decision.factors || [
              { name: "health", value: 1, weight: 0.3, contribution: 0.3 },
              { name: "quota", value: 1, weight: 0.25, contribution: 0.25 },
              { name: "cost", value: 0.8, weight: 0.2, contribution: 0.16 },
              { name: "latency", value: 0.9, weight: 0.15, contribution: 0.135 },
              { name: "task_fit", value: 0.7, weight: 0.1, contribution: 0.07 },
            ],
            fallbacksTriggered: decision.fallbacksTriggered || [],
            costActual: decision.costActual || 0,
            latencyActual: decision.latencyActual || 0,
          },
        }
      : {
          requestId: args.requestId,
          decision: {
            comboUsed: "unknown",
            providerSelected: "unknown",
            modelUsed: "unknown",
            score: 0,
            factors: [],
            fallbacksTriggered: [],
            costActual: 0,
            latencyActual: 0,
          },
          note: "Routing decision not found. The /api/routing/decisions endpoint may not be implemented yet, or the requestId is invalid.",
        };
    await logToolCall(
      "omniroute_explain_route",
      args,
      { requestId: args.requestId },
      Date.now() - start,
      true
    );
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_explain_route", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleSyncPricing(args) {
  const start = Date.now();
  try {
    const result = toRecord(
      await apiFetch("/api/pricing/sync", {
        method: "POST",
        body: JSON.stringify({
          sources: args.sources,
          dryRun: args.dryRun ?? false,
        }),
      })
    );
    await logToolCall("omniroute_sync_pricing", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_sync_pricing", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleGetSessionSnapshot() {
  const start = Date.now();
  try {
    const analytics = toRecord(
      await apiFetch("/api/usage/analytics?period=session").catch(() => ({}))
    );
    const tokenCount = toRecord(analytics.tokenCount);
    const byModel = toArrayOfRecords(analytics.byModel);
    const byProvider = toArrayOfRecords(analytics.byProvider);
    const result = {
      sessionStart: toString(analytics.sessionStart, /* @__PURE__ */ new Date().toISOString()),
      duration: toString(analytics.duration, "unknown"),
      requestCount: toNumber2(analytics.requestCount, 0),
      costTotal: toNumber2(analytics.totalCost, 0),
      tokenCount: {
        prompt: toNumber2(tokenCount.prompt, 0),
        completion: toNumber2(tokenCount.completion, 0),
      },
      topModels: byModel.slice(0, 5).map((model) => ({
        model: toString(model.model, "unknown"),
        count: toNumber2(model.requests, 0),
      })),
      topProviders: byProvider.slice(0, 5).map((provider) => ({
        provider: toString(provider.name, "unknown"),
        count: toNumber2(provider.requests, 0),
      })),
      errors: toNumber2(analytics.errorCount, 0),
      fallbacks: toNumber2(analytics.fallbackCount, 0),
      budgetGuard: activeBudgetGuard
        ? {
            active: true,
            remaining: Math.max(0, activeBudgetGuard.maxCost - activeBudgetGuard.spent),
            action: activeBudgetGuard.action,
          }
        : null,
    };
    await logToolCall(
      "omniroute_get_session_snapshot",
      {},
      { requestCount: result.requestCount },
      Date.now() - start,
      true
    );
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_get_session_snapshot", {}, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}

// open-sse/mcp-server/tools/memoryTools.ts
import { z as z3 } from "zod";

// src/lib/db/core.ts
import Database from "better-sqlite3";
import path3 from "path";
import fs3 from "fs";

// src/lib/dataPaths.ts
import path from "path";
import os from "os";
var APP_NAME = "omniroute";
function safeHomeDir() {
  try {
    return os.homedir();
  } catch {
    return process.cwd();
  }
}
function normalizeConfiguredPath(dir) {
  if (typeof dir !== "string") return null;
  const trimmed = dir.trim();
  if (!trimmed) return null;
  return path.resolve(trimmed);
}
function getLegacyDotDataDir() {
  return path.join(safeHomeDir(), `.${APP_NAME}`);
}
function getDefaultDataDir() {
  const homeDir = safeHomeDir();
  if (process.platform === "win32") {
    const appData = process.env.APPDATA || path.join(homeDir, "AppData", "Roaming");
    return path.join(appData, APP_NAME);
  }
  const xdgConfigHome = normalizeConfiguredPath(process.env.XDG_CONFIG_HOME);
  if (xdgConfigHome) {
    return path.join(xdgConfigHome, APP_NAME);
  }
  return getLegacyDotDataDir();
}
function resolveDataDir2({ isCloud: isCloud2 = false } = {}) {
  if (isCloud2) return "/tmp";
  const configured = normalizeConfiguredPath(process.env.DATA_DIR);
  if (configured) return configured;
  return getDefaultDataDir();
}

// src/lib/db/migrationRunner.ts
import fs2 from "fs";
import path2 from "path";
import { fileURLToPath } from "url";
function resolveMigrationsDir() {
  try {
    const metaUrl = import.meta.url;
    if (metaUrl && metaUrl.startsWith("file://")) {
      const __filename = fileURLToPath(metaUrl);
      return path2.join(path2.dirname(__filename), "migrations");
    }
  } catch {}
  return path2.join(process.cwd(), "src", "lib", "db", "migrations");
}
var MIGRATIONS_DIR = resolveMigrationsDir();
function ensureMigrationsTable(db2) {
  db2.exec(`
    CREATE TABLE IF NOT EXISTS _omniroute_migrations (
      version TEXT PRIMARY KEY,
      name TEXT NOT NULL,
      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
    );
  `);
}
function getMigrationFiles() {
  if (!fs2.existsSync(MIGRATIONS_DIR)) return [];
  return fs2
    .readdirSync(MIGRATIONS_DIR)
    .filter((f) => f.endsWith(".sql"))
    .sort()
    .map((filename) => {
      const match = filename.match(/^(\d+)_(.+)\.sql$/);
      if (!match) return null;
      return {
        version: match[1],
        name: match[2],
        path: path2.join(MIGRATIONS_DIR, filename),
      };
    })
    .filter(Boolean);
}
function getAppliedVersions(db2) {
  const rows = db2.prepare("SELECT version FROM _omniroute_migrations").all();
  return new Set(rows.map((r) => r.version));
}
function runMigrations(db2) {
  ensureMigrationsTable(db2);
  const files = getMigrationFiles();
  const applied = getAppliedVersions(db2);
  let count = 0;
  for (const migration of files) {
    if (applied.has(migration.version)) continue;
    const sql = fs2.readFileSync(migration.path, "utf-8");
    const applyMigration = db2.transaction(() => {
      db2.exec(sql);
      db2
        .prepare("INSERT INTO _omniroute_migrations (version, name) VALUES (?, ?)")
        .run(migration.version, migration.name);
    });
    try {
      applyMigration();
      count++;
      console.log(`[Migration] Applied: ${migration.version}_${migration.name}`);
    } catch (err) {
      const message = err instanceof Error ? err.message : String(err);
      console.error(`[Migration] FAILED: ${migration.version}_${migration.name} \u2014 ${message}`);
      throw err;
    }
  }
  if (count > 0) {
    console.log(`[Migration] ${count} migration(s) applied successfully.`);
  }
  return count;
}

// src/lib/db/core.ts
var isCloud = typeof globalThis.caches === "object" && globalThis.caches !== null;
var isBuildPhase = process.env.NEXT_PHASE === "phase-production-build";
var DATA_DIR = resolveDataDir2({ isCloud });
var LEGACY_DATA_DIR = isCloud ? null : getLegacyDotDataDir();
var SQLITE_FILE = isCloud ? null : path3.join(DATA_DIR, "storage.sqlite");
var JSON_DB_FILE = isCloud ? null : path3.join(DATA_DIR, "db.json");
var DB_BACKUPS_DIR = isCloud ? null : path3.join(DATA_DIR, "db_backups");
if (!isCloud && !fs3.existsSync(DATA_DIR)) {
  try {
    fs3.mkdirSync(DATA_DIR, { recursive: true });
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    console.warn(
      `[DB] Cannot create data directory '${DATA_DIR}': ${msg}
[DB] Set the DATA_DIR environment variable to a writable path, e.g.:
[DB]   DATA_DIR=/path/to/writable/dir omniroute`
    );
  }
}
var SCHEMA_SQL = `
  CREATE TABLE IF NOT EXISTS provider_connections (
    id TEXT PRIMARY KEY,
    provider TEXT NOT NULL,
    auth_type TEXT,
    name TEXT,
    email TEXT,
    priority INTEGER DEFAULT 0,
    is_active INTEGER DEFAULT 1,
    access_token TEXT,
    refresh_token TEXT,
    expires_at TEXT,
    token_expires_at TEXT,
    scope TEXT,
    project_id TEXT,
    test_status TEXT,
    error_code TEXT,
    last_error TEXT,
    last_error_at TEXT,
    last_error_type TEXT,
    last_error_source TEXT,
    backoff_level INTEGER DEFAULT 0,
    rate_limited_until TEXT,
    health_check_interval INTEGER,
    last_health_check_at TEXT,
    last_tested TEXT,
    api_key TEXT,
    id_token TEXT,
    provider_specific_data TEXT,
    expires_in INTEGER,
    display_name TEXT,
    global_priority INTEGER,
    default_model TEXT,
    token_type TEXT,
    consecutive_use_count INTEGER DEFAULT 0,
    rate_limit_protection INTEGER DEFAULT 0,
    last_used_at TEXT,
    "group" TEXT,
    created_at TEXT NOT NULL,
    updated_at TEXT NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_pc_provider ON provider_connections(provider);
  CREATE INDEX IF NOT EXISTS idx_pc_active ON provider_connections(is_active);
  CREATE INDEX IF NOT EXISTS idx_pc_priority ON provider_connections(provider, priority);

  CREATE TABLE IF NOT EXISTS provider_nodes (
    id TEXT PRIMARY KEY,
    type TEXT NOT NULL,
    name TEXT NOT NULL,
    prefix TEXT,
    api_type TEXT,
    base_url TEXT,
    created_at TEXT NOT NULL,
    updated_at TEXT NOT NULL
  );

  CREATE TABLE IF NOT EXISTS key_value (
    namespace TEXT NOT NULL,
    key TEXT NOT NULL,
    value TEXT NOT NULL,
    PRIMARY KEY (namespace, key)
  );

  CREATE TABLE IF NOT EXISTS combos (
    id TEXT PRIMARY KEY,
    name TEXT NOT NULL UNIQUE,
    data TEXT NOT NULL,
    created_at TEXT NOT NULL,
    updated_at TEXT NOT NULL
  );

  CREATE TABLE IF NOT EXISTS api_keys (
    id TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    key TEXT NOT NULL UNIQUE,
    machine_id TEXT,
    allowed_models TEXT DEFAULT '[]',
    no_log INTEGER NOT NULL DEFAULT 0,
    created_at TEXT NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_ak_key ON api_keys(key);

  CREATE TABLE IF NOT EXISTS db_meta (
    key TEXT PRIMARY KEY,
    value TEXT
  );

  CREATE TABLE IF NOT EXISTS usage_history (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    provider TEXT,
    model TEXT,
    connection_id TEXT,
    api_key_id TEXT,
    api_key_name TEXT,
    tokens_input INTEGER DEFAULT 0,
    tokens_output INTEGER DEFAULT 0,
    tokens_cache_read INTEGER DEFAULT 0,
    tokens_cache_creation INTEGER DEFAULT 0,
    tokens_reasoning INTEGER DEFAULT 0,
    status TEXT,
    success INTEGER DEFAULT 1,
    latency_ms INTEGER DEFAULT 0,
    ttft_ms INTEGER DEFAULT 0,
    error_code TEXT,
    timestamp TEXT NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_uh_timestamp ON usage_history(timestamp);
  CREATE INDEX IF NOT EXISTS idx_uh_provider ON usage_history(provider);
  CREATE INDEX IF NOT EXISTS idx_uh_model ON usage_history(model);

  CREATE TABLE IF NOT EXISTS call_logs (
    id TEXT PRIMARY KEY,
    timestamp TEXT NOT NULL,
    method TEXT,
    path TEXT,
    status INTEGER,
    model TEXT,
    provider TEXT,
    account TEXT,
    connection_id TEXT,
    duration INTEGER DEFAULT 0,
    tokens_in INTEGER DEFAULT 0,
    tokens_out INTEGER DEFAULT 0,
    source_format TEXT,
    target_format TEXT,
    api_key_id TEXT,
    api_key_name TEXT,
    combo_name TEXT,
    request_body TEXT,
    response_body TEXT,
    error TEXT,
    artifact_relpath TEXT,
    has_pipeline_details INTEGER DEFAULT 0
  );
  CREATE INDEX IF NOT EXISTS idx_cl_timestamp ON call_logs(timestamp);
  CREATE INDEX IF NOT EXISTS idx_cl_status ON call_logs(status);

  CREATE TABLE IF NOT EXISTS proxy_logs (
    id TEXT PRIMARY KEY,
    timestamp TEXT NOT NULL,
    status TEXT,
    proxy_type TEXT,
    proxy_host TEXT,
    proxy_port INTEGER,
    level TEXT,
    level_id TEXT,
    provider TEXT,
    target_url TEXT,
    public_ip TEXT,
    latency_ms INTEGER DEFAULT 0,
    error TEXT,
    connection_id TEXT,
    combo_id TEXT,
    account TEXT,
    tls_fingerprint INTEGER DEFAULT 0
  );
  CREATE INDEX IF NOT EXISTS idx_pl_timestamp ON proxy_logs(timestamp);
  CREATE INDEX IF NOT EXISTS idx_pl_status ON proxy_logs(status);
  CREATE INDEX IF NOT EXISTS idx_pl_provider ON proxy_logs(provider);

  -- Domain State Persistence (Phase 5)
  CREATE TABLE IF NOT EXISTS domain_fallback_chains (
    model TEXT PRIMARY KEY,
    chain TEXT NOT NULL
  );

  CREATE TABLE IF NOT EXISTS domain_budgets (
    api_key_id TEXT PRIMARY KEY,
    daily_limit_usd REAL NOT NULL,
    monthly_limit_usd REAL DEFAULT 0,
    warning_threshold REAL DEFAULT 0.8
  );

  CREATE TABLE IF NOT EXISTS domain_cost_history (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    api_key_id TEXT NOT NULL,
    cost REAL NOT NULL,
    timestamp INTEGER NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_dch_key ON domain_cost_history(api_key_id);
  CREATE INDEX IF NOT EXISTS idx_dch_ts ON domain_cost_history(timestamp);

  CREATE TABLE IF NOT EXISTS domain_lockout_state (
    identifier TEXT PRIMARY KEY,
    attempts TEXT NOT NULL,
    locked_until INTEGER
  );

  CREATE TABLE IF NOT EXISTS domain_circuit_breakers (
    name TEXT PRIMARY KEY,
    state TEXT NOT NULL DEFAULT 'CLOSED',
    failure_count INTEGER DEFAULT 0,
    last_failure_time INTEGER,
    options TEXT
  );

  CREATE TABLE IF NOT EXISTS semantic_cache (
    id TEXT PRIMARY KEY,
    signature TEXT NOT NULL UNIQUE,
    model TEXT NOT NULL,
    prompt_hash TEXT NOT NULL,
    response TEXT NOT NULL,
    tokens_saved INTEGER DEFAULT 0,
    hit_count INTEGER DEFAULT 0,
    created_at TEXT NOT NULL,
    expires_at TEXT NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_sc_sig ON semantic_cache(signature);
  CREATE INDEX IF NOT EXISTS idx_sc_model ON semantic_cache(model);
`;
function getDb2() {
  return globalThis.__omnirouteDb ?? null;
}
function setDb(db2) {
  if (db2) {
    globalThis.__omnirouteDb = db2;
  } else {
    delete globalThis.__omnirouteDb;
  }
}
function ensureProviderConnectionsColumns(db2) {
  try {
    const columns = db2.prepare("PRAGMA table_info(provider_connections)").all();
    const columnNames = new Set(columns.map((column) => String(column.name ?? "")));
    if (!columnNames.has("rate_limit_protection")) {
      db2.exec(
        "ALTER TABLE provider_connections ADD COLUMN rate_limit_protection INTEGER DEFAULT 0"
      );
      console.log("[DB] Added provider_connections.rate_limit_protection column");
    }
    if (!columnNames.has("last_used_at")) {
      db2.exec("ALTER TABLE provider_connections ADD COLUMN last_used_at TEXT");
      console.log("[DB] Added provider_connections.last_used_at column");
    }
    if (!columnNames.has("group")) {
      db2.exec('ALTER TABLE provider_connections ADD COLUMN "group" TEXT');
      console.log('[DB] Added provider_connections."group" column');
    }
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    console.warn("[DB] Failed to verify provider_connections schema:", message);
  }
}
function ensureUsageHistoryColumns(db2) {
  try {
    const columns = db2.prepare("PRAGMA table_info(usage_history)").all();
    const columnNames = new Set(columns.map((column) => String(column.name ?? "")));
    if (!columnNames.has("success")) {
      db2.exec("ALTER TABLE usage_history ADD COLUMN success INTEGER DEFAULT 1");
      console.log("[DB] Added usage_history.success column");
    }
    if (!columnNames.has("latency_ms")) {
      db2.exec("ALTER TABLE usage_history ADD COLUMN latency_ms INTEGER DEFAULT 0");
      console.log("[DB] Added usage_history.latency_ms column");
    }
    if (!columnNames.has("ttft_ms")) {
      db2.exec("ALTER TABLE usage_history ADD COLUMN ttft_ms INTEGER DEFAULT 0");
      console.log("[DB] Added usage_history.ttft_ms column");
    }
    if (!columnNames.has("error_code")) {
      db2.exec("ALTER TABLE usage_history ADD COLUMN error_code TEXT");
      console.log("[DB] Added usage_history.error_code column");
    }
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    console.warn("[DB] Failed to verify usage_history schema:", message);
  }
}
function ensureCallLogsColumns(db2) {
  try {
    const columns = db2.prepare("PRAGMA table_info(call_logs)").all();
    const columnNames = new Set(columns.map((column) => String(column.name ?? "")));
    if (!columnNames.has("artifact_relpath")) {
      db2.exec("ALTER TABLE call_logs ADD COLUMN artifact_relpath TEXT");
      console.log("[DB] Added call_logs.artifact_relpath column");
    }
    if (!columnNames.has("has_pipeline_details")) {
      db2.exec("ALTER TABLE call_logs ADD COLUMN has_pipeline_details INTEGER DEFAULT 0");
      console.log("[DB] Added call_logs.has_pipeline_details column");
    }
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    console.warn("[DB] Failed to verify call_logs schema:", message);
  }
}
function getDbInstance() {
  const existing = getDb2();
  if (existing) return existing;
  if (isCloud || isBuildPhase) {
    if (isBuildPhase) {
      console.log("[DB] Build phase detected \u2014 using in-memory SQLite (read-only)");
    }
    const memoryDb = new Database(":memory:");
    memoryDb.pragma("journal_mode = WAL");
    memoryDb.exec(SCHEMA_SQL);
    ensureUsageHistoryColumns(memoryDb);
    setDb(memoryDb);
    return memoryDb;
  }
  const sqliteFile = SQLITE_FILE;
  if (!sqliteFile) {
    throw new Error("SQLITE_FILE is unavailable for local mode");
  }
  const jsonDbFile = JSON_DB_FILE;
  if (fs3.existsSync(sqliteFile)) {
    try {
      const probe = new Database(sqliteFile, { readonly: true });
      const hasOldSchema = probe
        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_migrations'")
        .get();
      if (hasOldSchema) {
        let hasData = false;
        try {
          const count = probe.prepare("SELECT COUNT(*) as c FROM provider_connections").get();
          hasData = Boolean(count && count.c > 0);
        } catch {}
        probe.close();
        if (hasData) {
          console.log(
            `[DB] Old schema_migrations table found but data exists \u2014 preserving data (#146)`
          );
          const fixDb = new Database(sqliteFile);
          try {
            fixDb.exec("DROP TABLE IF EXISTS schema_migrations");
            fixDb.pragma("wal_checkpoint(TRUNCATE)");
          } catch (e) {
            const message = e instanceof Error ? e.message : String(e);
            console.warn("[DB] Could not clean up old schema table:", message);
          } finally {
            fixDb.close();
          }
        } else {
          const oldPath = sqliteFile + ".old-schema";
          console.log(
            `[DB] Old incompatible schema detected (empty) \u2014 renaming to ${path3.basename(oldPath)}`
          );
          fs3.renameSync(sqliteFile, oldPath);
          for (const ext of ["-wal", "-shm"]) {
            try {
              if (fs3.existsSync(sqliteFile + ext)) fs3.unlinkSync(sqliteFile + ext);
            } catch {}
          }
        }
      } else {
        probe.close();
      }
    } catch (e) {
      const message = e instanceof Error ? e.message : String(e);
      console.warn("[DB] Could not probe existing DB, will create fresh:", message);
      try {
        fs3.unlinkSync(sqliteFile);
      } catch {}
    }
  }
  const db2 = new Database(sqliteFile);
  db2.pragma("journal_mode = WAL");
  db2.pragma("busy_timeout = 5000");
  db2.pragma("synchronous = NORMAL");
  db2.exec(SCHEMA_SQL);
  ensureProviderConnectionsColumns(db2);
  ensureUsageHistoryColumns(db2);
  ensureCallLogsColumns(db2);
  db2.exec(`
    CREATE TABLE IF NOT EXISTS _omniroute_migrations (
      version TEXT PRIMARY KEY,
      name TEXT NOT NULL,
      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
    );
    INSERT OR IGNORE INTO _omniroute_migrations (version, name)
    VALUES ('001', 'initial_schema');
  `);
  runMigrations(db2);
  if (jsonDbFile && fs3.existsSync(jsonDbFile)) {
    migrateFromJson(db2, jsonDbFile);
  }
  const versionStmt = db2.prepare(
    "INSERT OR REPLACE INTO db_meta (key, value) VALUES ('schema_version', '1')"
  );
  versionStmt.run();
  setDb(db2);
  console.log(`[DB] SQLite database ready: ${sqliteFile}`);
  return db2;
}
function migrateFromJson(db2, jsonPath) {
  try {
    const raw = fs3.readFileSync(jsonPath, "utf-8");
    const data = JSON.parse(raw);
    const connCount = (data.providerConnections || []).length;
    const nodeCount = (data.providerNodes || []).length;
    const keyCount = (data.apiKeys || []).length;
    if (connCount === 0 && nodeCount === 0 && keyCount === 0) {
      console.log("[DB] db.json has no data to migrate, skipping");
      fs3.renameSync(jsonPath, jsonPath + ".empty");
      return;
    }
    console.log(
      `[DB] Migrating db.json \u2192 SQLite (${connCount} connections, ${nodeCount} nodes, ${keyCount} keys)...`
    );
    const migrate = db2.transaction(() => {
      const insertConn = db2.prepare(`
        INSERT OR REPLACE INTO provider_connections (
          id, provider, auth_type, name, email, priority, is_active,
          access_token, refresh_token, expires_at, token_expires_at,
          scope, project_id, test_status, error_code, last_error,
          last_error_at, last_error_type, last_error_source, backoff_level,
          rate_limited_until, health_check_interval, last_health_check_at,
          last_tested, api_key, id_token, provider_specific_data,
          expires_in, display_name, global_priority, default_model,
          token_type, consecutive_use_count, rate_limit_protection, last_used_at, created_at, updated_at
        ) VALUES (
          @id, @provider, @authType, @name, @email, @priority, @isActive,
          @accessToken, @refreshToken, @expiresAt, @tokenExpiresAt,
          @scope, @projectId, @testStatus, @errorCode, @lastError,
          @lastErrorAt, @lastErrorType, @lastErrorSource, @backoffLevel,
          @rateLimitedUntil, @healthCheckInterval, @lastHealthCheckAt,
          @lastTested, @apiKey, @idToken, @providerSpecificData,
          @expiresIn, @displayName, @globalPriority, @defaultModel,
          @tokenType, @consecutiveUseCount, @rateLimitProtection, @lastUsedAt, @createdAt, @updatedAt
        )
      `);
      for (const conn of data.providerConnections || []) {
        insertConn.run({
          id: conn.id,
          provider: conn.provider,
          authType: conn.authType || "oauth",
          name: conn.name || null,
          email: conn.email || null,
          priority: conn.priority || 0,
          isActive: conn.isActive === false ? 0 : 1,
          accessToken: conn.accessToken || null,
          refreshToken: conn.refreshToken || null,
          expiresAt: conn.expiresAt || null,
          tokenExpiresAt: conn.tokenExpiresAt || null,
          scope: conn.scope || null,
          projectId: conn.projectId || null,
          testStatus: conn.testStatus || null,
          errorCode: conn.errorCode || null,
          lastError: conn.lastError || null,
          lastErrorAt: conn.lastErrorAt || null,
          lastErrorType: conn.lastErrorType || null,
          lastErrorSource: conn.lastErrorSource || null,
          backoffLevel: conn.backoffLevel || 0,
          rateLimitedUntil: conn.rateLimitedUntil || null,
          healthCheckInterval: conn.healthCheckInterval || null,
          lastHealthCheckAt: conn.lastHealthCheckAt || null,
          lastTested: conn.lastTested || null,
          apiKey: conn.apiKey || null,
          idToken: conn.idToken || null,
          providerSpecificData: conn.providerSpecificData
            ? JSON.stringify(conn.providerSpecificData)
            : null,
          expiresIn: conn.expiresIn || null,
          displayName: conn.displayName || null,
          globalPriority: conn.globalPriority || null,
          defaultModel: conn.defaultModel || null,
          tokenType: conn.tokenType || null,
          consecutiveUseCount: conn.consecutiveUseCount || 0,
          lastUsedAt: conn.lastUsedAt || null,
          rateLimitProtection:
            conn.rateLimitProtection === true || conn.rateLimitProtection === 1 ? 1 : 0,
          createdAt: conn.createdAt || /* @__PURE__ */ new Date().toISOString(),
          updatedAt: conn.updatedAt || /* @__PURE__ */ new Date().toISOString(),
        });
      }
      const insertNode = db2.prepare(`
        INSERT OR REPLACE INTO provider_nodes (id, type, name, prefix, api_type, base_url, created_at, updated_at)
        VALUES (@id, @type, @name, @prefix, @apiType, @baseUrl, @createdAt, @updatedAt)
      `);
      for (const node of data.providerNodes || []) {
        insertNode.run({
          id: node.id,
          type: node.type,
          name: node.name,
          prefix: node.prefix || null,
          apiType: node.apiType || null,
          baseUrl: node.baseUrl || null,
          createdAt: node.createdAt || /* @__PURE__ */ new Date().toISOString(),
          updatedAt: node.updatedAt || /* @__PURE__ */ new Date().toISOString(),
        });
      }
      const insertKv = db2.prepare(
        "INSERT OR REPLACE INTO key_value (namespace, key, value) VALUES (?, ?, ?)"
      );
      for (const [alias, model] of Object.entries(data.modelAliases || {})) {
        insertKv.run("modelAliases", alias, JSON.stringify(model));
      }
      for (const [toolName, mappings] of Object.entries(data.mitmAlias || {})) {
        insertKv.run("mitmAlias", toolName, JSON.stringify(mappings));
      }
      for (const [key, value] of Object.entries(data.settings || {})) {
        insertKv.run("settings", key, JSON.stringify(value));
      }
      for (const [provider, models] of Object.entries(data.pricing || {})) {
        insertKv.run("pricing", provider, JSON.stringify(models));
      }
      for (const [providerId, models] of Object.entries(data.customModels || {})) {
        insertKv.run("customModels", providerId, JSON.stringify(models));
      }
      if (data.proxyConfig) {
        insertKv.run("proxyConfig", "global", JSON.stringify(data.proxyConfig.global || null));
        insertKv.run("proxyConfig", "providers", JSON.stringify(data.proxyConfig.providers || {}));
        insertKv.run("proxyConfig", "combos", JSON.stringify(data.proxyConfig.combos || {}));
        insertKv.run("proxyConfig", "keys", JSON.stringify(data.proxyConfig.keys || {}));
      }
      const insertCombo = db2.prepare(`
        INSERT OR REPLACE INTO combos (id, name, data, created_at, updated_at)
        VALUES (@id, @name, @data, @createdAt, @updatedAt)
      `);
      for (const combo of data.combos || []) {
        insertCombo.run({
          id: combo.id,
          name: combo.name,
          data: JSON.stringify(combo),
          createdAt: combo.createdAt || /* @__PURE__ */ new Date().toISOString(),
          updatedAt: combo.updatedAt || /* @__PURE__ */ new Date().toISOString(),
        });
      }
      const insertKey = db2.prepare(`
        INSERT OR REPLACE INTO api_keys (id, name, key, machine_id, allowed_models, no_log, created_at)
        VALUES (@id, @name, @key, @machineId, @allowedModels, @noLog, @createdAt)
      `);
      for (const apiKey of data.apiKeys || []) {
        insertKey.run({
          id: apiKey.id,
          name: apiKey.name,
          key: apiKey.key,
          machineId: apiKey.machineId || null,
          allowedModels: JSON.stringify(apiKey.allowedModels || []),
          noLog: apiKey.noLog ? 1 : 0,
          createdAt: apiKey.createdAt || /* @__PURE__ */ new Date().toISOString(),
        });
      }
    });
    migrate();
    const migratedPath = jsonPath + ".migrated";
    fs3.renameSync(jsonPath, migratedPath);
    console.log(`[DB] \u2713 Migration complete. Original saved as ${migratedPath}`);
    const legacyBackupDir = path3.join(DATA_DIR, "db_backups");
    if (fs3.existsSync(legacyBackupDir)) {
      const jsonBackups = fs3.readdirSync(legacyBackupDir).filter((f) => f.endsWith(".json"));
      if (jsonBackups.length > 0) {
        console.log(
          `[DB] Note: ${jsonBackups.length} legacy .json backups remain in ${legacyBackupDir}`
        );
      }
    }
  } catch (err) {
    console.error("[DB] Migration from db.json failed:", err.message);
  }
}

// src/lib/memory/schemas.ts
import { z as z2 } from "zod";

// src/lib/memory/types.ts
var MemoryType = /* @__PURE__ */ ((MemoryType2) => {
  MemoryType2["FACTUAL"] = "factual";
  MemoryType2["EPISODIC"] = "episodic";
  MemoryType2["PROCEDURAL"] = "procedural";
  MemoryType2["SEMANTIC"] = "semantic";
  return MemoryType2;
})(MemoryType || {});

// src/lib/memory/schemas.ts
var MemoryConfigSchema = z2.object({
  enabled: z2.boolean(),
  maxTokens: z2.number().int().positive(),
  retrievalStrategy: z2.enum(["exact", "semantic", "hybrid"]).optional(),
  autoSummarize: z2.boolean(),
  persistAcrossModels: z2.boolean(),
  retentionDays: z2.number().int().positive(),
  scope: z2.enum(["session", "apiKey", "global"]).optional(),
});
var MemoryCreateInputSchema = z2
  .object({
    type: z2.nativeEnum(MemoryType),
    key: z2.string().min(1),
    content: z2.string().min(1),
    metadata: z2.record(z2.string(), z2.unknown()).optional(),
  })
  .strict();
var MemoryUpdateInputSchema = z2
  .object({
    type: z2.nativeEnum(MemoryType).optional(),
    key: z2.string().min(1).optional(),
    content: z2.string().min(1).optional(),
    metadata: z2.record(z2.string(), z2.unknown()).optional(),
  })
  .strict();

// src/lib/memory/retrieval.ts
function estimateTokens(text) {
  if (!text || typeof text !== "string") return 0;
  return Math.ceil(text.length / 4);
}
async function retrieveMemories(apiKeyId, config = {}) {
  const normalizedConfig = MemoryConfigSchema.parse({
    enabled: true,
    maxTokens: 2e3,
    retrievalStrategy: "recent",
    autoSummarize: false,
    persistAcrossModels: false,
    retentionDays: 30,
    scope: "apiKey",
    ...config,
  });
  const maxTokens = Math.min(Math.max(normalizedConfig.maxTokens, 100), 8e3);
  const strategy = normalizedConfig.retrievalStrategy;
  const db2 = getDbInstance();
  const memories = [];
  let totalTokens = 0;
  let query = "SELECT * FROM memory WHERE apiKeyId = ?";
  const params = [apiKeyId];
  switch (strategy) {
    case "semantic":
      query += " ORDER BY createdAt DESC";
      break;
    case "hybrid":
      query += " ORDER BY createdAt DESC";
      break;
    case "exact":
    default:
      query += " ORDER BY createdAt DESC";
  }
  query += " LIMIT 100";
  const stmt = db2.prepare(query);
  const rows = stmt.all(...params);
  for (const row of rows) {
    const memory = {
      id: String(row.id),
      apiKeyId: String(row.apiKeyId),
      sessionId: String(row.sessionId),
      type: row.type,
      key: String(row.key),
      content: String(row.content),
      metadata: JSON.parse(String(row.metadata)),
      createdAt: new Date(String(row.createdAt)),
      updatedAt: new Date(String(row.updatedAt)),
      expiresAt: row.expiresAt ? new Date(String(row.expiresAt)) : null,
    };
    const memoryTokens = estimateTokens(memory.content);
    if (totalTokens + memoryTokens > maxTokens) {
      if (memories.length === 0) {
        memories.push(memory);
        totalTokens += memoryTokens;
      }
      break;
    }
    memories.push(memory);
    totalTokens += memoryTokens;
  }
  return memories;
}

// src/lib/memory/store.ts
var MEMORY_MAX_CACHE_SIZE = 1e4;
var _memoryCache = /* @__PURE__ */ new Map();
function parseJSON(value) {
  if (!value || typeof value !== "string" || value.trim() === "") {
    return {};
  }
  try {
    const parsed = JSON.parse(value);
    return typeof parsed === "object" && parsed !== null ? parsed : {};
  } catch {
    return {};
  }
}
function invalidateMemoryCache(key) {
  _memoryCache.delete(key);
}
function evictIfNeeded(cache) {
  if (cache.size > MEMORY_MAX_CACHE_SIZE) {
    const keysArray = Array.from(cache.keys());
    const entriesToRemove = Math.floor(cache.size * 0.2);
    for (let i = 0; i < entriesToRemove; i++) {
      cache.delete(keysArray[i]);
    }
  }
}
var MEMORY_VALIDATION_CACHE_TTL = 60 * 1e3;
async function createMemory(memory) {
  const db2 = getDbInstance();
  const id = crypto.randomUUID();
  const now = /* @__PURE__ */ new Date().toISOString();
  const stmt = db2.prepare(
    "INSERT INTO memory (id, apiKeyId, sessionId, type, key, content, metadata, createdAt, updatedAt, expiresAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
  );
  stmt.run(
    id,
    memory.apiKeyId,
    memory.sessionId,
    memory.type,
    memory.key,
    memory.content,
    JSON.stringify(memory.metadata),
    now,
    now,
    memory.expiresAt?.toISOString() ?? null
  );
  const createdMemory = {
    id,
    apiKeyId: memory.apiKeyId,
    sessionId: memory.sessionId,
    type: memory.type,
    key: memory.key,
    content: memory.content,
    metadata: memory.metadata,
    createdAt: new Date(now),
    updatedAt: new Date(now),
    expiresAt: memory.expiresAt ?? null,
  };
  invalidateMemoryCache(id);
  evictIfNeeded(_memoryCache);
  _memoryCache.set(id, { value: createdMemory, timestamp: Date.now() });
  return createdMemory;
}
async function deleteMemory(id) {
  if (!id || typeof id !== "string") return false;
  const db2 = getDbInstance();
  const stmt = db2.prepare("DELETE FROM memory WHERE id = ?");
  const result = stmt.run(id);
  if (result.changes === 0) {
    return false;
  }
  invalidateMemoryCache(id);
  return true;
}
async function listMemories(filters) {
  const db2 = getDbInstance();
  let query = "SELECT * FROM memory";
  const params = [];
  const whereClauses = [];
  if (filters.apiKeyId) {
    whereClauses.push("apiKeyId = ?");
    params.push(filters.apiKeyId);
  }
  if (filters.type) {
    whereClauses.push("type = ?");
    params.push(filters.type);
  }
  if (filters.sessionId) {
    whereClauses.push("sessionId = ?");
    params.push(filters.sessionId);
  }
  if (whereClauses.length > 0) {
    query += " WHERE " + whereClauses.join(" AND ");
  }
  query += " ORDER BY createdAt DESC";
  if (filters.limit !== void 0) {
    query += " LIMIT ?";
    params.push(filters.limit);
  }
  if (filters.offset !== void 0) {
    query += " OFFSET ?";
    params.push(filters.offset);
  }
  const stmt = db2.prepare(query);
  const rows = stmt.all(...params);
  return rows.map((row) => ({
    id: String(row.id),
    apiKeyId: String(row.apiKeyId),
    sessionId: String(row.sessionId),
    type: row.type,
    key: String(row.key),
    content: String(row.content),
    metadata: parseJSON(row.metadata),
    createdAt: new Date(String(row.createdAt)),
    updatedAt: new Date(String(row.updatedAt)),
    expiresAt: row.expiresAt ? new Date(String(row.expiresAt)) : null,
  }));
}

// open-sse/mcp-server/tools/memoryTools.ts
var MemorySearchSchema = z3.object({
  apiKeyId: z3.string(),
  query: z3.string().optional(),
  type: z3.enum(["factual", "episodic", "procedural", "semantic"]).optional(),
  maxTokens: z3.number().int().positive().max(8e3).optional(),
  limit: z3.number().int().positive().max(100).optional(),
});
var MemoryAddSchema = z3.object({
  apiKeyId: z3.string(),
  sessionId: z3.string().optional(),
  type: z3.enum(["factual", "episodic", "procedural", "semantic"]),
  key: z3.string().min(1),
  content: z3.string().min(1),
  metadata: z3.record(z3.string(), z3.unknown()).optional(),
});
var MemoryClearSchema = z3.object({
  apiKeyId: z3.string(),
  type: z3.enum(["factual", "episodic", "procedural", "semantic"]).optional(),
  olderThan: z3.string().optional(),
});
var memoryTools = {
  omniroute_memory_search: {
    name: "omniroute_memory_search",
    description: "Search memories by query, type, or API key with token budget enforcement",
    inputSchema: MemorySearchSchema,
    handler: async (args) => {
      const config = {
        enabled: true,
        maxTokens: args.maxTokens || 2e3,
        retrievalStrategy: "exact",
        autoSummarize: false,
        persistAcrossModels: false,
        retentionDays: 30,
        scope: "apiKey",
      };
      const memories = await retrieveMemories(args.apiKeyId, config);
      const filtered = args.type ? memories.filter((m) => m.type === args.type) : memories;
      const limited = args.limit ? filtered.slice(0, args.limit) : filtered;
      return {
        success: true,
        data: {
          memories: limited,
          count: limited.length,
          totalTokens: limited.reduce((sum, m) => sum + Math.ceil(m.content.length / 4), 0),
        },
      };
    },
  },
  omniroute_memory_add: {
    name: "omniroute_memory_add",
    description: "Add a new memory entry",
    inputSchema: MemoryAddSchema,
    handler: async (args) => {
      const memory = await createMemory({
        apiKeyId: args.apiKeyId,
        sessionId: args.sessionId || "",
        type: args.type,
        key: args.key,
        content: args.content,
        metadata: args.metadata || {},
        expiresAt: null,
      });
      return {
        success: true,
        data: {
          memory,
          message: "Memory created successfully",
        },
      };
    },
  },
  omniroute_memory_clear: {
    name: "omniroute_memory_clear",
    description: "Clear memories for an API key, optionally filtered by type or age",
    inputSchema: MemoryClearSchema,
    handler: async (args) => {
      const memories = await listMemories({
        apiKeyId: args.apiKeyId,
        type: args.type,
      });
      let toDelete = memories;
      if (args.olderThan) {
        const cutoff = new Date(args.olderThan);
        toDelete = memories.filter((m) => new Date(m.createdAt) < cutoff);
      }
      let deletedCount = 0;
      for (const memory of toDelete) {
        await deleteMemory(memory.id);
        deletedCount++;
      }
      return {
        success: true,
        data: {
          deletedCount,
          message: `Cleared ${deletedCount} memories`,
        },
      };
    },
  },
};

// open-sse/mcp-server/tools/skillTools.ts
import { z as z5 } from "zod";

// src/lib/skills/schemas.ts
import { z as z4 } from "zod";

// src/lib/skills/types.ts
var SkillMode = /* @__PURE__ */ ((SkillMode2) => {
  SkillMode2["AUTO"] = "auto";
  SkillMode2["MANUAL"] = "manual";
  SkillMode2["HYBRID"] = "hybrid";
  return SkillMode2;
})(SkillMode || {});

// src/lib/skills/schemas.ts
var SkillSchema = z4.object({
  input: z4.record(z4.string(), z4.unknown()),
  output: z4.record(z4.string(), z4.unknown()),
});
var SkillCreateInputSchema = z4
  .object({
    name: z4.string().min(1).max(100),
    version: z4
      .string()
      .regex(/^\d+\.\d+\.\d+$/)
      .default("1.0.0"),
    description: z4.string().max(500).optional(),
    schema: SkillSchema,
    handler: z4.string().min(1),
    enabled: z4.boolean().default(true),
  })
  .strict();
var SkillUpdateInputSchema = z4
  .object({
    name: z4.string().min(1).max(100).optional(),
    version: z4
      .string()
      .regex(/^\d+\.\d+\.\d+$/)
      .optional(),
    description: z4.string().max(500).optional(),
    schema: SkillSchema.optional(),
    handler: z4.string().min(1).optional(),
    enabled: z4.boolean().optional(),
  })
  .strict();
var SkillConfigSchema = z4.object({
  enabled: z4.boolean(),
  mode: z4.nativeEnum(SkillMode),
  allowedSkills: z4.array(z4.string()),
  timeout: z4.number().int().positive().default(3e4),
  maxRetries: z4.number().int().min(0).default(3),
});

// src/lib/skills/registry.ts
import { randomUUID } from "crypto";
var SkillRegistry = class _SkillRegistry {
  static instance;
  registeredSkills = /* @__PURE__ */ new Map();
  versionCache = /* @__PURE__ */ new Map();
  constructor() {}
  static getInstance() {
    if (!_SkillRegistry.instance) {
      _SkillRegistry.instance = new _SkillRegistry();
    }
    return _SkillRegistry.instance;
  }
  async register(skillData) {
    const parsed = SkillCreateInputSchema.parse(skillData);
    const db2 = getDbInstance();
    const id = randomUUID();
    const now = /* @__PURE__ */ new Date();
    db2
      .prepare(
        `INSERT INTO skills (id, api_key_id, name, version, description, schema, handler, enabled, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
      )
      .run(
        id,
        skillData.apiKeyId,
        parsed.name,
        parsed.version,
        parsed.description || null,
        JSON.stringify(parsed.schema),
        parsed.handler,
        parsed.enabled ? 1 : 0,
        now.toISOString(),
        now.toISOString()
      );
    const skill = {
      id,
      apiKeyId: skillData.apiKeyId,
      name: parsed.name,
      version: parsed.version,
      description: parsed.description || "",
      schema: parsed.schema,
      handler: parsed.handler,
      enabled: parsed.enabled,
      createdAt: now,
      updatedAt: now,
    };
    this.registeredSkills.set(`${parsed.name}@${parsed.version}`, skill);
    this.updateVersionCache(skill);
    return skill;
  }
  async unregister(name, version, apiKeyId) {
    const db2 = getDbInstance();
    if (version) {
      const key = `${name}@${version}`;
      const skill = this.registeredSkills.get(key);
      if (skill && (!apiKeyId || skill.apiKeyId === apiKeyId)) {
        db2.prepare("DELETE FROM skills WHERE id = ?").run(skill.id);
        this.registeredSkills.delete(key);
        this.clearVersionCache(name);
        return true;
      }
    } else {
      const deleted = db2
        .prepare("DELETE FROM skills WHERE name = ? AND (? IS NULL OR api_key_id = ?)")
        .run(name, apiKeyId || null, apiKeyId || null);
      if (deleted.changes > 0) {
        const keysToDelete = Array.from(this.registeredSkills.keys()).filter((k) =>
          k.startsWith(`${name}@`)
        );
        keysToDelete.forEach((k) => this.registeredSkills.delete(k));
        this.clearVersionCache(name);
        return true;
      }
    }
    return false;
  }
  list(apiKeyId) {
    if (apiKeyId) {
      return Array.from(this.registeredSkills.values()).filter((s) => s.apiKeyId === apiKeyId);
    }
    return Array.from(this.registeredSkills.values());
  }
  getSkill(name, apiKeyId) {
    return this.registeredSkills.get(name);
  }
  getSkillVersions(name) {
    const cached = this.versionCache.get(name);
    if (!cached) return [];
    return Array.from(cached.values()).sort((a, b) => this.compareVersions(b.version, a.version));
  }
  resolveVersion(name, constraint, apiKeyId) {
    const versions = this.getSkillVersions(name);
    if (versions.length === 0) return void 0;
    const operator = constraint.charAt(0);
    const version = constraint.slice(1);
    switch (operator) {
      case "^":
        return versions.find((s) => this.satisfies(s.version, version, "^"));
      case "~":
        return versions.find((s) => this.satisfies(s.version, version, "~"));
      case ">":
      case ">=":
      case "<":
      case "<=":
      case "==":
        return versions.find((s) => this.satisfies(s.version, version, operator));
      default:
        return versions.find((s) => s.version === constraint);
    }
  }
  satisfies(version, base, operator) {
    const [baseMajor, baseMinor, basePatch] = base.split(".").map(Number);
    const [verMajor, verMinor, verPatch] = version.split(".").map(Number);
    switch (operator) {
      case "^":
        return (
          verMajor === baseMajor &&
          (verMinor > baseMinor || (verMinor === baseMinor && verPatch >= basePatch))
        );
      case "~":
        return verMajor === baseMajor && verMinor === baseMinor && verPatch >= basePatch;
      case ">":
        return this.compareVersions(version, base) > 0;
      case ">=":
        return this.compareVersions(version, base) >= 0;
      case "<":
        return this.compareVersions(version, base) < 0;
      case "<=":
        return this.compareVersions(version, base) <= 0;
      case "==":
        return version === base;
      default:
        return version === base;
    }
  }
  compareVersions(a, b) {
    const [aMajor, aMinor, aPatch] = a.split(".").map(Number);
    const [bMajor, bMinor, bPatch] = b.split(".").map(Number);
    if (aMajor !== bMajor) return aMajor - bMajor;
    if (aMinor !== bMinor) return aMinor - bMinor;
    return aPatch - bPatch;
  }
  updateVersionCache(skill) {
    if (!this.versionCache.has(skill.name)) {
      this.versionCache.set(skill.name, /* @__PURE__ */ new Map());
    }
    this.versionCache.get(skill.name).set(skill.version, skill);
  }
  clearVersionCache(name) {
    this.versionCache.delete(name);
  }
  async loadFromDatabase(apiKeyId) {
    const db2 = getDbInstance();
    const rows = apiKeyId
      ? db2.prepare("SELECT * FROM skills WHERE api_key_id = ?").all(apiKeyId)
      : db2.prepare("SELECT * FROM skills").all();
    for (const row of rows) {
      const skill = {
        id: row.id,
        apiKeyId: row.api_key_id,
        name: row.name,
        version: row.version,
        description: row.description || "",
        schema: JSON.parse(row.schema),
        handler: row.handler,
        enabled: row.enabled === 1,
        createdAt: new Date(row.created_at),
        updatedAt: new Date(row.updated_at),
      };
      this.registeredSkills.set(`${skill.name}@${skill.version}`, skill);
      this.updateVersionCache(skill);
    }
  }
};
var skillRegistry = SkillRegistry.getInstance();

// src/lib/skills/executor.ts
import { randomUUID as randomUUID2 } from "crypto";
var SkillExecutor = class _SkillExecutor {
  static instance;
  handlers = /* @__PURE__ */ new Map();
  timeout = 3e4;
  maxRetries = 3;
  constructor() {}
  static getInstance() {
    if (!_SkillExecutor.instance) {
      _SkillExecutor.instance = new _SkillExecutor();
    }
    return _SkillExecutor.instance;
  }
  registerHandler(name, handler) {
    this.handlers.set(name, handler);
  }
  setTimeout(ms) {
    this.timeout = ms;
  }
  setMaxRetries(count) {
    this.maxRetries = count;
  }
  async execute(skillName, input, context) {
    const skill = skillRegistry.getSkill(skillName, context.apiKeyId);
    if (!skill) {
      throw new Error(`Skill not found: ${skillName}`);
    }
    if (!skill.enabled) {
      throw new Error(`Skill is disabled: ${skillName}`);
    }
    const db2 = getDbInstance();
    const executionId = randomUUID2();
    const startTime = Date.now();
    try {
      db2
        .prepare(
          `INSERT INTO skill_executions (id, skill_id, api_key_id, session_id, input, status, created_at)
         VALUES (?, ?, ?, ?, ?, ?, ?)`
        )
        .run(
          executionId,
          skill.id,
          context.apiKeyId,
          context.sessionId || null,
          JSON.stringify(input),
          "running" /* RUNNING */,
          /* @__PURE__ */ new Date().toISOString()
        );
      const handler = this.handlers.get(skill.handler);
      if (!handler) {
        throw new Error(`Handler not found: ${skill.handler}`);
      }
      let output = null;
      let errorMessage = null;
      let status = "success"; /* SUCCESS */
      try {
        const result = await this.executeWithTimeout(
          handler(input, { apiKeyId: context.apiKeyId, sessionId: context.sessionId || "" })
        );
        output = result;
      } catch (err) {
        errorMessage = err instanceof Error ? err.message : String(err);
        status = "error" /* ERROR */;
      }
      const durationMs = Date.now() - startTime;
      db2
        .prepare(
          `UPDATE skill_executions SET output = ?, status = ?, error_message = ?, duration_ms = ? WHERE id = ?`
        )
        .run(output ? JSON.stringify(output) : null, status, errorMessage, durationMs, executionId);
      return {
        id: executionId,
        skillId: skill.id,
        apiKeyId: context.apiKeyId,
        sessionId: context.sessionId || "",
        input,
        output,
        status,
        errorMessage,
        durationMs,
        createdAt: /* @__PURE__ */ new Date(),
      };
    } catch (err) {
      const durationMs = Date.now() - startTime;
      const errorMessage = err instanceof Error ? err.message : String(err);
      db2
        .prepare(
          `UPDATE skill_executions SET status = ?, error_message = ?, duration_ms = ? WHERE id = ?`
        )
        .run("error" /* ERROR */, errorMessage, durationMs, executionId);
      throw err;
    }
  }
  async executeWithTimeout(promise) {
    return Promise.race([
      promise,
      new Promise((_, reject) =>
        setTimeout(() => reject(new Error("Skill execution timed out")), this.timeout)
      ),
    ]);
  }
  getExecution(executionId) {
    const db2 = getDbInstance();
    const row = db2.prepare("SELECT * FROM skill_executions WHERE id = ?").get(executionId);
    if (!row) return void 0;
    return {
      id: row.id,
      skillId: row.skill_id,
      apiKeyId: row.api_key_id,
      sessionId: row.session_id || "",
      input: JSON.parse(row.input),
      output: row.output ? JSON.parse(row.output) : null,
      status: row.status,
      errorMessage: row.error_message,
      durationMs: row.duration_ms,
      createdAt: new Date(row.created_at),
    };
  }
  listExecutions(apiKeyId, limit = 50) {
    const db2 = getDbInstance();
    const rows = apiKeyId
      ? db2
          .prepare(
            "SELECT * FROM skill_executions WHERE api_key_id = ? ORDER BY created_at DESC LIMIT ?"
          )
          .all(apiKeyId, limit)
      : db2.prepare("SELECT * FROM skill_executions ORDER BY created_at DESC LIMIT ?").all(limit);
    return rows.map((row) => ({
      id: row.id,
      skillId: row.skill_id,
      apiKeyId: row.api_key_id,
      sessionId: row.session_id || "",
      input: JSON.parse(row.input),
      output: row.output ? JSON.parse(row.output) : null,
      status: row.status,
      errorMessage: row.error_message,
      durationMs: row.duration_ms,
      createdAt: new Date(row.created_at),
    }));
  }
};
var skillExecutor = SkillExecutor.getInstance();

// open-sse/mcp-server/tools/skillTools.ts
var SkillListSchema = z5.object({
  apiKeyId: z5.string().optional(),
  name: z5.string().optional(),
  enabled: z5.boolean().optional(),
});
var SkillEnableSchema = z5.object({
  apiKeyId: z5.string(),
  skillId: z5.string(),
  enabled: z5.boolean(),
});
var SkillExecuteSchema = z5.object({
  apiKeyId: z5.string(),
  skillName: z5.string(),
  input: z5.record(z5.string(), z5.unknown()),
  sessionId: z5.string().optional(),
});
var skillTools = {
  omniroute_skills_list: {
    name: "omniroute_skills_list",
    description: "List all registered skills with optional filtering by API key or name",
    inputSchema: SkillListSchema,
    handler: async (args) => {
      await skillRegistry.loadFromDatabase(args.apiKeyId);
      const skills = skillRegistry.list(args.apiKeyId);
      let filtered = skills;
      if (args.name) {
        filtered = filtered.filter((s) => s.name.includes(args.name));
      }
      if (args.enabled !== void 0) {
        filtered = filtered.filter((s) => s.enabled === args.enabled);
      }
      return {
        skills: filtered.map((s) => ({
          id: s.id,
          name: s.name,
          version: s.version,
          description: s.description,
          enabled: s.enabled,
          createdAt: s.createdAt.toISOString(),
        })),
        count: filtered.length,
      };
    },
  },
  omniroute_skills_enable: {
    name: "omniroute_skills_enable",
    description: "Enable or disable a specific skill by ID",
    inputSchema: SkillEnableSchema,
    handler: async (args) => {
      const skill = skillRegistry.getSkill(args.skillId, args.apiKeyId);
      if (!skill) {
        throw new Error(`Skill not found: ${args.skillId}`);
      }
      await skillRegistry.register({
        ...skill,
        enabled: args.enabled,
        apiKeyId: args.apiKeyId,
      });
      return { success: true, skillId: args.skillId, enabled: args.enabled };
    },
  },
  omniroute_skills_execute: {
    name: "omniroute_skills_execute",
    description: "Execute a skill with provided input and return the result",
    inputSchema: SkillExecuteSchema,
    handler: async (args) => {
      const execution = await skillExecutor.execute(args.skillName, args.input, {
        apiKeyId: args.apiKeyId,
        sessionId: args.sessionId,
      });
      return {
        id: execution.id,
        skillId: execution.skillId,
        status: execution.status,
        output: execution.output,
        error: execution.errorMessage,
        duration: execution.durationMs,
        createdAt: execution.createdAt.toISOString(),
      };
    },
  },
  omniroute_skills_executions: {
    name: "omniroute_skills_executions",
    description: "List recent skill execution history",
    inputSchema: z5.object({
      apiKeyId: z5.string().optional(),
      limit: z5.number().int().positive().max(100).optional(),
    }),
    handler: async (args) => {
      const executions = skillExecutor.listExecutions(args.apiKeyId, args.limit || 50);
      return {
        executions: executions.map((e) => ({
          id: e.id,
          skillId: e.skillId,
          status: e.status,
          duration: e.durationMs,
          error: e.errorMessage,
          createdAt: e.createdAt.toISOString(),
        })),
        count: executions.length,
      };
    },
  },
};

// open-sse/mcp-server/server.ts
var OMNIROUTE_BASE_URL2 = process.env.OMNIROUTE_BASE_URL || "http://localhost:20128";
var OMNIROUTE_API_KEY2 = process.env.OMNIROUTE_API_KEY || "";
var MCP_ENFORCE_SCOPES = process.env.OMNIROUTE_MCP_ENFORCE_SCOPES === "true";
var MCP_ALLOWED_SCOPES = new Set(
  (process.env.OMNIROUTE_MCP_SCOPES || "")
    .split(",")
    .map((s) => s.trim())
    .filter(Boolean)
);
function toRecord2(value) {
  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
}
function toArray(value) {
  return Array.isArray(value) ? value : [];
}
function toString2(value, fallback = "") {
  return typeof value === "string" ? value : fallback;
}
function toNumber3(value, fallback = 0) {
  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
}
function toStringArray(value, fallback = []) {
  const values = toArray(value).filter((entry) => typeof entry === "string");
  return values.length > 0 ? values : fallback;
}
function normalizeComboModels(rawModels) {
  return toArray(rawModels).map((rawModel, index) => {
    const model = toRecord2(rawModel);
    return {
      provider: toString2(model.provider, "unknown"),
      model: toString2(model.model, "unknown"),
      priority: toNumber3(model.priority, index + 1),
    };
  });
}
async function omniRouteFetch(path4, options = {}) {
  const url = `${OMNIROUTE_BASE_URL2}${path4}`;
  const headers = {
    "Content-Type": "application/json",
    ...(OMNIROUTE_API_KEY2 ? { Authorization: `Bearer ${OMNIROUTE_API_KEY2}` } : {}),
    ...(options.headers || {}),
  };
  const response = await fetch(url, { ...options, headers, signal: AbortSignal.timeout(1e4) });
  if (!response.ok) {
    const errorText = await response.text().catch(() => "Unknown error");
    throw new Error(`OmniRoute API error [${response.status}]: ${errorText}`);
  }
  return response.json();
}
function withScopeEnforcement(toolName, handler) {
  return async (args, extra) => {
    const scopeContext = resolveCallerScopeContext(extra, Array.from(MCP_ALLOWED_SCOPES));
    const scopeCheck = evaluateToolScopes(toolName, scopeContext.scopes, MCP_ENFORCE_SCOPES);
    if (!scopeCheck.allowed) {
      const missingScopes =
        scopeCheck.missing.length > 0 ? scopeCheck.missing.join(", ") : "unavailable";
      const reason = scopeCheck.reason || "scope_check_failed";
      const msg = `Insufficient MCP scopes for ${toolName}. Missing: ${missingScopes}. Caller=${scopeContext.callerId}, source=${scopeContext.source}.`;
      const safeArgs = args && typeof args === "object" ? toRecord2(args) : { rawArgs: args };
      await logToolCall(
        toolName,
        {
          ...safeArgs,
          _scopeCheck: {
            callerId: scopeContext.callerId,
            source: scopeContext.source,
            required: scopeCheck.required,
            provided: scopeCheck.provided,
            missing: scopeCheck.missing,
          },
        },
        null,
        0,
        false,
        `scope_denied:${reason}`
      );
      return {
        content: [{ type: "text", text: `Error: ${msg}` }],
        isError: true,
      };
    }
    return handler(args, extra);
  };
}
async function handleGetHealth() {
  const start = Date.now();
  try {
    const [healthRaw, resilienceRaw, rateLimitsRaw] = await Promise.allSettled([
      omniRouteFetch("/api/monitoring/health"),
      omniRouteFetch("/api/resilience"),
      omniRouteFetch("/api/rate-limits"),
    ]);
    const health = healthRaw.status === "fulfilled" ? toRecord2(healthRaw.value) : {};
    const resilience = resilienceRaw.status === "fulfilled" ? toRecord2(resilienceRaw.value) : {};
    const rateLimits = rateLimitsRaw.status === "fulfilled" ? toRecord2(rateLimitsRaw.value) : {};
    const memoryUsageRaw = toRecord2(health.memoryUsage);
    const cacheStatsRaw = toRecord2(health.cacheStats);
    const resilienceCircuitBreakers = toArray(resilience.circuitBreakers);
    const rateLimitEntries = toArray(rateLimits.limits);
    const result = {
      uptime: toString2(health.uptime, "unknown"),
      version: toString2(health.version, "unknown"),
      memoryUsage: {
        heapUsed: toNumber3(memoryUsageRaw.heapUsed, 0),
        heapTotal: toNumber3(memoryUsageRaw.heapTotal, 0),
      },
      circuitBreakers: resilienceCircuitBreakers,
      rateLimits: rateLimitEntries,
      cacheStats:
        Object.keys(cacheStatsRaw).length > 0
          ? {
              hits: toNumber3(cacheStatsRaw.hits, 0),
              misses: toNumber3(cacheStatsRaw.misses, 0),
              hitRate: toNumber3(cacheStatsRaw.hitRate, 0),
            }
          : void 0,
    };
    await logToolCall("omniroute_get_health", {}, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_get_health", {}, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleListCombos(args) {
  const start = Date.now();
  try {
    const combosRaw = await omniRouteFetch("/api/combos");
    const combosRecord = toRecord2(combosRaw);
    const combos = Array.isArray(combosRecord.combos)
      ? combosRecord.combos
      : Array.isArray(combosRaw)
        ? combosRaw
        : [];
    let metrics = {};
    if (args.includeMetrics) {
      metrics = toRecord2(await omniRouteFetch("/api/combos/metrics").catch(() => ({})));
    }
    const result = {
      combos: toArray(combos).map((rawCombo) => {
        const combo = toRecord2(rawCombo);
        const comboData = toRecord2(combo.data);
        const comboId = toString2(combo.id, "");
        const modelsSource =
          Array.isArray(combo.models) && combo.models.length > 0 ? combo.models : comboData.models;
        return {
          id: comboId,
          name: toString2(combo.name, comboId || "unnamed"),
          models: normalizeComboModels(modelsSource),
          strategy: toString2(combo.strategy, toString2(comboData.strategy, "priority")),
          enabled: combo.enabled !== false,
          ...(args.includeMetrics ? { metrics: metrics[comboId] ?? null } : {}),
        };
      }),
    };
    await logToolCall("omniroute_list_combos", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_list_combos", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleGetComboMetrics(args) {
  const start = Date.now();
  try {
    const result = await omniRouteFetch(
      `/api/combos/metrics?comboId=${encodeURIComponent(args.comboId)}`
    );
    await logToolCall("omniroute_get_combo_metrics", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_get_combo_metrics", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleSwitchCombo(args) {
  const start = Date.now();
  try {
    const result = await omniRouteFetch(`/api/combos/${encodeURIComponent(args.comboId)}`, {
      method: "PUT",
      body: JSON.stringify({ isActive: args.active }),
    });
    await logToolCall("omniroute_switch_combo", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_switch_combo", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleCheckQuota(args) {
  const start = Date.now();
  try {
    let path4 = "/api/usage/quota";
    if (args.connectionId) path4 += `?connectionId=${encodeURIComponent(args.connectionId)}`;
    else if (args.provider) path4 += `?provider=${encodeURIComponent(args.provider)}`;
    const result = normalizeQuotaResponse(await omniRouteFetch(path4), {
      provider: args.provider || null,
      connectionId: args.connectionId || null,
    });
    await logToolCall("omniroute_check_quota", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_check_quota", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleRouteRequest(args) {
  const start = Date.now();
  try {
    const body = {
      model: args.model,
      messages: args.messages,
      stream: false,
      // MCP tool always returns non-streaming
    };
    if (args.combo) {
      body["x-combo"] = args.combo;
    }
    const raw = await omniRouteFetch("/v1/chat/completions", {
      method: "POST",
      body: JSON.stringify(body),
    });
    const choices = toArray(raw.choices);
    const firstChoice = toRecord2(choices[0]);
    const firstMessage = toRecord2(firstChoice.message);
    const usage = toRecord2(raw.usage);
    const result = {
      response: {
        content: toString2(firstMessage.content, ""),
        model: toString2(raw.model, args.model),
        tokens: {
          prompt: toNumber3(usage.prompt_tokens, 0),
          completion: toNumber3(usage.completion_tokens, 0),
        },
      },
      routing: {
        provider: toString2(raw.provider, "unknown"),
        combo: raw.combo ?? null,
        fallbacksTriggered: toNumber3(raw.fallbacksTriggered, 0),
        cost: toNumber3(raw.cost, 0),
        latencyMs: Date.now() - start,
        routingExplanation: toString2(
          raw.routingExplanation,
          "Request routed through primary provider"
        ),
      },
    };
    await logToolCall(
      "omniroute_route_request",
      { model: args.model, messageCount: args.messages.length },
      result.routing,
      Date.now() - start,
      true
    );
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall(
      "omniroute_route_request",
      { model: args.model },
      null,
      Date.now() - start,
      false,
      msg
    );
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleCostReport(args) {
  const start = Date.now();
  try {
    const period = args.period || "session";
    const rangeMap = {
      session: "1d",
      day: "1d",
      week: "7d",
      month: "30d",
    };
    const range = rangeMap[period] || "30d";
    const raw = toRecord2(
      await omniRouteFetch(`/api/usage/analytics?range=${encodeURIComponent(range)}`)
    );
    const tokenCount = toRecord2(raw.tokenCount);
    const budget = toRecord2(raw.budget);
    const result = {
      period,
      totalCost: toNumber3(raw.totalCost, 0),
      requestCount: toNumber3(raw.requestCount, 0),
      tokenCount: {
        prompt: toNumber3(tokenCount.prompt, 0),
        completion: toNumber3(tokenCount.completion, 0),
      },
      byProvider: toArray(raw.byProvider),
      byModel: toArray(raw.byModel),
      budget: {
        limit: budget.limit ?? null,
        remaining: budget.remaining ?? null,
      },
    };
    await logToolCall("omniroute_cost_report", args, result, Date.now() - start, true);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_cost_report", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
async function handleListModelsCatalog(args) {
  const start = Date.now();
  try {
    let path4 = "/v1/models";
    let isProviderSpecific = false;
    let source = "local_catalog";
    let warning;
    if (args.provider && !args.capability) {
      path4 = `/api/providers/${encodeURIComponent(args.provider)}/models?excludeHidden=true`;
      isProviderSpecific = true;
    } else {
      const params = new URLSearchParams();
      if (args.provider) params.set("provider", args.provider);
      if (args.capability) params.set("capability", args.capability);
      if (params.toString()) path4 += `?${params.toString()}`;
    }
    const raw = toRecord2(await omniRouteFetch(path4));
    let rawModels = [];
    if (isProviderSpecific) {
      rawModels = Array.isArray(raw.models) ? raw.models : [];
      source = typeof raw.source === "string" ? raw.source : "api";
      if (raw.warning) warning = String(raw.warning);
    } else {
      rawModels = Array.isArray(raw.data) ? raw.data : [];
      source = "local_catalog";
    }
    const result = {
      models: rawModels.map((rawModel) => {
        const model = toRecord2(rawModel);
        return {
          id: toString2(model.id, ""),
          provider: toString2(
            model.owned_by,
            toString2(model.provider, args.provider || "unknown")
          ),
          capabilities: toStringArray(model.capabilities, ["chat"]),
          status: toString2(model.status, "available"),
          pricing: model.pricing,
        };
      }),
      source,
      ...(warning ? { warning } : {}),
    };
    await logToolCall(
      "omniroute_list_models_catalog",
      args,
      { modelCount: result.models.length },
      Date.now() - start,
      true
    );
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    await logToolCall("omniroute_list_models_catalog", args, null, Date.now() - start, false, msg);
    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
  }
}
function createMcpServer() {
  const server = new McpServer({
    name: "omniroute",
    version: process.env.npm_package_version || "1.8.1",
  });
  server.registerTool(
    "omniroute_get_health",
    {
      description:
        "Returns OmniRoute health status including uptime, memory, circuit breakers, rate limits, and cache stats",
      inputSchema: getHealthInput,
    },
    withScopeEnforcement("omniroute_get_health", async (args) => {
      getHealthInput.parse(args ?? {});
      return handleGetHealth();
    })
  );
  server.registerTool(
    "omniroute_list_combos",
    {
      description:
        "Lists all configured combos (model chains) with strategies and optional metrics",
      inputSchema: listCombosInput,
    },
    withScopeEnforcement("omniroute_list_combos", (args) =>
      handleListCombos(listCombosInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_get_combo_metrics",
    {
      description: "Returns detailed performance metrics for a specific combo",
      inputSchema: getComboMetricsInput,
    },
    withScopeEnforcement("omniroute_get_combo_metrics", (args) =>
      handleGetComboMetrics(getComboMetricsInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_switch_combo",
    {
      description: "Activates or deactivates a combo for routing",
      inputSchema: switchComboInput,
    },
    withScopeEnforcement("omniroute_switch_combo", (args) =>
      handleSwitchCombo(switchComboInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_check_quota",
    {
      description: "Checks remaining API quota for one or all providers",
      inputSchema: checkQuotaInput,
    },
    withScopeEnforcement("omniroute_check_quota", (args) =>
      handleCheckQuota(checkQuotaInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_route_request",
    {
      description: "Sends a chat completion request through OmniRoute intelligent routing",
      inputSchema: routeRequestInput,
    },
    withScopeEnforcement("omniroute_route_request", (args) =>
      handleRouteRequest(routeRequestInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_cost_report",
    {
      description: "Generates a cost report for the specified period",
      inputSchema: costReportInput,
    },
    withScopeEnforcement("omniroute_cost_report", (args) =>
      handleCostReport(costReportInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_list_models_catalog",
    {
      description: "Lists all available AI models across providers with capabilities and pricing",
      inputSchema: listModelsCatalogInput,
    },
    withScopeEnforcement("omniroute_list_models_catalog", (args) =>
      handleListModelsCatalog(listModelsCatalogInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_simulate_route",
    {
      description: "Simulates the routing path a request would take without executing it (dry-run)",
      inputSchema: simulateRouteInput,
    },
    withScopeEnforcement("omniroute_simulate_route", (args) =>
      handleSimulateRoute(simulateRouteInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_set_budget_guard",
    {
      description:
        "Sets a session budget limit with configurable action when exceeded (degrade/block/alert)",
      inputSchema: setBudgetGuardInput,
    },
    withScopeEnforcement("omniroute_set_budget_guard", (args) =>
      handleSetBudgetGuard(setBudgetGuardInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_set_routing_strategy",
    {
      description:
        "Updates combo routing strategy at runtime (priority/weighted/round-robin/auto/etc.)",
      inputSchema: setRoutingStrategyInput,
    },
    withScopeEnforcement("omniroute_set_routing_strategy", (args) =>
      handleSetRoutingStrategy(setRoutingStrategyInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_set_resilience_profile",
    {
      description:
        "Applies a resilience profile controlling circuit breakers, retries, timeouts, and fallback depth",
      inputSchema: setResilienceProfileInput,
    },
    withScopeEnforcement("omniroute_set_resilience_profile", (args) =>
      handleSetResilienceProfile(setResilienceProfileInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_test_combo",
    {
      description:
        "Tests each provider in a combo with a real prompt, reporting latency, cost, and success per provider",
      inputSchema: testComboInput,
    },
    withScopeEnforcement("omniroute_test_combo", (args) =>
      handleTestCombo(testComboInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_get_provider_metrics",
    {
      description:
        "Returns detailed metrics for a specific provider including latency percentiles and circuit breaker state",
      inputSchema: getProviderMetricsInput,
    },
    withScopeEnforcement("omniroute_get_provider_metrics", (args) =>
      handleGetProviderMetrics(getProviderMetricsInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_best_combo_for_task",
    {
      description:
        "Recommends the best combo for a task type based on provider fitness and constraints",
      inputSchema: bestComboForTaskInput,
    },
    withScopeEnforcement("omniroute_best_combo_for_task", (args) =>
      handleBestComboForTask(bestComboForTaskInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_explain_route",
    {
      description:
        "Explains why a request was routed to a specific provider, showing scoring factors and fallbacks",
      inputSchema: explainRouteInput,
    },
    withScopeEnforcement("omniroute_explain_route", (args) =>
      handleExplainRoute(explainRouteInput.parse(args))
    )
  );
  server.registerTool(
    "omniroute_get_session_snapshot",
    {
      description:
        "Returns a full snapshot of the current working session: cost, tokens, top models, errors, budget status",
      inputSchema: getSessionSnapshotInput,
    },
    withScopeEnforcement("omniroute_get_session_snapshot", async (args) => {
      getSessionSnapshotInput.parse(args ?? {});
      return handleGetSessionSnapshot();
    })
  );
  server.registerTool(
    "omniroute_sync_pricing",
    {
      description:
        "Syncs pricing data from external sources (LiteLLM) into OmniRoute without overwriting user-set prices",
      inputSchema: syncPricingInput,
    },
    withScopeEnforcement("omniroute_sync_pricing", (args) =>
      handleSyncPricing(syncPricingInput.parse(args))
    )
  );
  Object.values(memoryTools).forEach((toolDef) => {
    server.registerTool(
      toolDef.name,
      {
        description: toolDef.description,
        // @ts-ignore: dynamic zod access
        inputSchema: toolDef.inputSchema,
      },
      withScopeEnforcement(toolDef.name, async (args) => {
        try {
          const parsedArgs = toolDef.inputSchema.parse(args ?? {});
          const result = await toolDef.handler(parsedArgs);
          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
        } catch (err) {
          const msg = err instanceof Error ? err.message : String(err);
          return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
        }
      })
    );
  });
  Object.values(skillTools).forEach((toolDef) => {
    server.registerTool(
      toolDef.name,
      {
        description: toolDef.description,
        // @ts-ignore: dynamic zod access
        inputSchema: toolDef.inputSchema,
      },
      withScopeEnforcement(toolDef.name, async (args) => {
        try {
          const parsedArgs = toolDef.inputSchema.parse(args ?? {});
          const result = await toolDef.handler(parsedArgs);
          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
        } catch (err) {
          const msg = err instanceof Error ? err.message : String(err);
          return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
        }
      })
    );
  });
  return server;
}
async function startMcpStdio() {
  const server = createMcpServer();
  const transport = new StdioServerTransport();
  const version = process.env.npm_package_version || "1.8.1";
  const stopHeartbeat = startMcpHeartbeat({
    version,
    scopesEnforced: MCP_ENFORCE_SCOPES,
    allowedScopes: Array.from(MCP_ALLOWED_SCOPES),
    toolCount: MCP_TOOLS.length,
  });
  const stopHeartbeatOnce = () => {
    stopHeartbeat();
  };
  process.once("exit", stopHeartbeatOnce);
  process.once("SIGINT", stopHeartbeatOnce);
  process.once("SIGTERM", stopHeartbeatOnce);
  console.error("[MCP] OmniRoute MCP Server starting (stdio transport)...");
  try {
    await server.connect(transport);
    console.error("[MCP] OmniRoute MCP Server connected and ready.");
  } finally {
    stopHeartbeatOnce();
    process.off("exit", stopHeartbeatOnce);
    process.off("SIGINT", stopHeartbeatOnce);
    process.off("SIGTERM", stopHeartbeatOnce);
  }
}
if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/\\/g, "/"))) {
  startMcpStdio().catch((err) => {
    console.error("[MCP] Fatal error:", err);
    process.exit(1);
  });
}
export { createMcpServer, startMcpStdio };