@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/mcp-server/tools/advancedTools.js

@@ -0,0 +1,893 @@
+import { logToolCall } from "../audit.ts";
+import { getMcpHttpAuthHeadersForInternalFetch } from "../httpAuthContext.ts";
+import { normalizeQuotaResponse } from "../../../shared/contracts/quota.ts";
+import { resolveOmniRouteBaseUrl } from "../../../shared/utils/resolveOmniRouteBaseUrl.ts";
+import {
+  getComboModelProvider,
+  getComboModelString,
+  getComboStepTarget
+} from '../../../dist/lib/combos/steps.ts.js';
+import { normalizeRoutingStrategy } from "../../../shared/constants/routingStrategies.ts";
+const OMNIROUTE_BASE_URL = resolveOmniRouteBaseUrl();
+const OMNIROUTE_API_KEY = process.env.OMNIROUTE_API_KEY || "";
+async function apiFetch(path, options = {}) {
+  const url = `${OMNIROUTE_BASE_URL}${path}`;
+  const headers = {
+    "Content-Type": "application/json",
+    // Static env key is only a fallback; the per-caller MCP identity forwarded via
+    // withMcpHttpAuthContext must win over it (#5819).
+    ...OMNIROUTE_API_KEY ? { Authorization: `Bearer ${OMNIROUTE_API_KEY}` } : {},
+    ...getMcpHttpAuthHeadersForInternalFetch(),
+    ...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 toNumber(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 toBoolean(value, fallback = false) {
+  return typeof value === "boolean" ? value : 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: getComboModelProvider(model) || (getComboModelString(model) ? "unknown" : "combo"),
+    model: getComboModelString(model) || getComboStepTarget(model) || "",
+    inputCostPer1M: toNumber(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) : [];
+}
+let activeBudgetGuard = null;
+const RESILIENCE_PROFILES = {
+  aggressive: {
+    requestQueue: {
+      requestsPerMinute: 180,
+      minTimeBetweenRequestsMs: 100,
+      concurrentRequests: 16
+    },
+    connectionCooldown: {
+      oauth: {
+        baseCooldownMs: 3e4,
+        useUpstreamRetryHints: false,
+        maxBackoffSteps: 4
+      },
+      apikey: {
+        baseCooldownMs: 2e3,
+        useUpstreamRetryHints: true,
+        maxBackoffSteps: 3
+      }
+    },
+    providerBreaker: {
+      oauth: {
+        failureThreshold: 2,
+        resetTimeoutMs: 3e4
+      },
+      apikey: {
+        failureThreshold: 3,
+        resetTimeoutMs: 15e3
+      }
+    }
+  },
+  balanced: {
+    requestQueue: {
+      requestsPerMinute: 100,
+      minTimeBetweenRequestsMs: 200,
+      concurrentRequests: 10
+    },
+    connectionCooldown: {
+      oauth: {
+        baseCooldownMs: 6e4,
+        useUpstreamRetryHints: false,
+        maxBackoffSteps: 8
+      },
+      apikey: {
+        baseCooldownMs: 3e3,
+        useUpstreamRetryHints: true,
+        maxBackoffSteps: 5
+      }
+    },
+    providerBreaker: {
+      oauth: {
+        failureThreshold: 3,
+        resetTimeoutMs: 6e4
+      },
+      apikey: {
+        failureThreshold: 5,
+        resetTimeoutMs: 3e4
+      }
+    }
+  },
+  conservative: {
+    requestQueue: {
+      requestsPerMinute: 60,
+      minTimeBetweenRequestsMs: 350,
+      concurrentRequests: 6
+    },
+    connectionCooldown: {
+      oauth: {
+        baseCooldownMs: 12e4,
+        useUpstreamRetryHints: false,
+        maxBackoffSteps: 10
+      },
+      apikey: {
+        baseCooldownMs: 3e4,
+        useUpstreamRetryHints: false,
+        maxBackoffSteps: 8
+      }
+    },
+    providerBreaker: {
+      oauth: {
+        failureThreshold: 8,
+        resetTimeoutMs: 12e4
+      },
+      apikey: {
+        failureThreshold: 8,
+        resetTimeoutMs: 6e4
+      }
+    }
+  }
+};
+const 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 = toNumber(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
+    );
+    const normalizedStrategy = normalizeRoutingStrategy(args.strategy);
+    let nextConfig = void 0;
+    if (normalizedStrategy === "auto" && args.autoRoutingStrategy) {
+      const currentAutoConfig = toRecord(currentConfig.auto);
+      nextConfig = {
+        ...currentConfig,
+        auto: {
+          ...currentAutoConfig,
+          routerStrategy: args.autoRoutingStrategy
+        }
+      };
+    }
+    const payload = { strategy: normalizedStrategy };
+    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).routerStrategy) || (normalizedStrategy === "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, normalizedStrategy),
+        autoRoutingStrategy: toString(updatedCombo.strategy, normalizedStrategy) === "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(settings)
+    });
+    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: toNumber(resp.cost, 0),
+            tokenCount: toNumber(usage.prompt_tokens, 0) + toNumber(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: toNumber(analytics.successRate, 1),
+      requestCount: toNumber(analytics.requestCount, 0),
+      avgLatencyMs: toNumber(analytics.avgLatencyMs, 0),
+      p50LatencyMs: toNumber(analytics.p50LatencyMs, 0),
+      p95LatencyMs: toNumber(analytics.p95LatencyMs, 0),
+      p99LatencyMs: toNumber(analytics.p99LatencyMs, 0),
+      errorRate: toNumber(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: toNumber(analytics.requestCount, 0),
+      costTotal: toNumber(analytics.totalCost, 0),
+      tokenCount: {
+        prompt: toNumber(tokenCount.prompt, 0),
+        completion: toNumber(tokenCount.completion, 0)
+      },
+      topModels: byModel.slice(0, 5).map((model) => ({
+        model: toString(model.model, "unknown"),
+        count: toNumber(model.requests, 0)
+      })),
+      topProviders: byProvider.slice(0, 5).map((provider) => ({
+        provider: toString(provider.name, "unknown"),
+        count: toNumber(provider.requests, 0)
+      })),
+      errors: toNumber(analytics.errorCount, 0),
+      fallbacks: toNumber(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 };
+  }
+}
+async function handleDbHealthCheck(args) {
+  const start = Date.now();
+  const autoRepair = args.autoRepair === true;
+  try {
+    const { runManagedDbHealthCheck } = await import('../../../dist/lib/db/core.ts.js');
+    const result = runManagedDbHealthCheck({ autoRepair });
+    await logToolCall(
+      "omniroute_db_health_check",
+      args,
+      {
+        isHealthy: toBoolean(result.isHealthy, false),
+        repairedCount: toNumber(result.repairedCount, 0)
+      },
+      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_db_health_check", args, null, Date.now() - start, false, msg);
+    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+  }
+}
+async function handleCacheStats() {
+  const start = Date.now();
+  try {
+    const raw = toRecord(await apiFetch("/api/cache"));
+    const semanticCache = toRecord(raw.semanticCache);
+    const promptCache = raw.promptCache ? toRecord(raw.promptCache) : null;
+    const idempotency = toRecord(raw.idempotency);
+    const config = raw.config ? toRecord(raw.config) : null;
+    const result = {
+      semanticCache: {
+        memoryEntries: toNumber(semanticCache.memoryEntries, 0),
+        dbEntries: toNumber(semanticCache.dbEntries, 0),
+        hits: toNumber(semanticCache.hits, 0),
+        misses: toNumber(semanticCache.misses, 0),
+        hitRate: toString(semanticCache.hitRate, "0%"),
+        tokensSaved: toNumber(semanticCache.tokensSaved, 0)
+      },
+      promptCache: promptCache ? {
+        totalRequests: toNumber(promptCache.totalRequests, 0),
+        requestsWithCacheControl: toNumber(promptCache.requestsWithCacheControl, 0),
+        totalInputTokens: toNumber(promptCache.totalInputTokens, 0),
+        totalCachedTokens: toNumber(promptCache.totalCachedTokens, 0),
+        totalCacheCreationTokens: toNumber(promptCache.totalCacheCreationTokens, 0),
+        tokensSaved: toNumber(promptCache.tokensSaved, 0),
+        estimatedCostSaved: toNumber(promptCache.estimatedCostSaved, 0)
+      } : null,
+      idempotency: {
+        activeKeys: toNumber(idempotency.activeKeys, 0),
+        windowMs: toNumber(idempotency.windowMs, 0)
+      },
+      config: config ? {
+        semanticCacheEnabled: toBoolean(config.semanticCacheEnabled, true)
+      } : void 0
+    };
+    await logToolCall("omniroute_cache_stats", {}, 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_cache_stats", {}, null, Date.now() - start, false, msg);
+    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+  }
+}
+async function handleCacheFlush(args) {
+  const start = Date.now();
+  try {
+    const params = new URLSearchParams();
+    let scope = "all";
+    if (args.signature) {
+      params.set("signature", args.signature);
+      scope = "signature";
+    } else if (args.model) {
+      params.set("model", args.model);
+      scope = "model";
+    }
+    const query = params.toString();
+    const path = query ? `/api/cache?${query}` : "/api/cache";
+    const raw = toRecord(
+      await apiFetch(path, {
+        method: "DELETE"
+      })
+    );
+    const result = {
+      ok: toBoolean(raw.ok, true),
+      invalidated: toNumber(raw.invalidated ?? raw.cleared, 0),
+      scope
+    };
+    await logToolCall("omniroute_cache_flush", 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_cache_flush", args, null, Date.now() - start, false, msg);
+    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+  }
+}
+async function handleOneproxyFetch(args = {}) {
+  const start = Date.now();
+  try {
+    const params = new URLSearchParams();
+    if (args.protocol) params.set("protocol", args.protocol);
+    if (args.countryCode) params.set("countryCode", args.countryCode);
+    if (args.minQuality) params.set("minQuality", String(args.minQuality));
+    if (args.limit) params.set("limit", String(args.limit));
+    const query = params.toString();
+    const path = query ? `/api/settings/oneproxy?${query}` : "/api/settings/oneproxy";
+    const raw = toRecord(await apiFetch(path));
+    const items = toArrayOfRecords(raw.items).map((r) => ({
+      id: toString(r.id, ""),
+      host: toString(r.host, ""),
+      port: toNumber(r.port, 0),
+      type: toString(r.type, "http"),
+      countryCode: typeof r.country_code === "string" ? r.country_code : null,
+      qualityScore: r.quality_score != null ? toNumber(r.quality_score) : null,
+      latencyMs: r.latency_ms != null ? toNumber(r.latency_ms) : null,
+      anonymity: typeof r.anonymity === "string" ? r.anonymity : null,
+      googleAccess: r.google_access === 1 || r.google_access === true,
+      status: toString(r.status, "active")
+    }));
+    const result = { items, total: toNumber(raw.total, items.length) };
+    await logToolCall("omniroute_oneproxy_fetch", 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_oneproxy_fetch", args, null, Date.now() - start, false, msg);
+    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+  }
+}
+async function handleOneproxyRotate(args = {}) {
+  const start = Date.now();
+  try {
+    const body = {};
+    if (args.strategy) body.strategy = args.strategy;
+    const raw = toRecord(
+      await apiFetch("/api/settings/oneproxy/rotate", {
+        method: "POST",
+        body: JSON.stringify(body)
+      })
+    );
+    const result = {
+      id: toString(raw.id, ""),
+      host: toString(raw.host, ""),
+      port: toNumber(raw.port, 0),
+      type: toString(raw.type, "http"),
+      countryCode: typeof raw.country_code === "string" ? raw.country_code : null,
+      qualityScore: raw.quality_score != null ? toNumber(raw.quality_score) : null,
+      latencyMs: raw.latency_ms != null ? toNumber(raw.latency_ms) : null
+    };
+    await logToolCall("omniroute_oneproxy_rotate", 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_oneproxy_rotate", args, null, Date.now() - start, false, msg);
+    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+  }
+}
+async function handleOneproxyStats(args = {}) {
+  const start = Date.now();
+  try {
+    const raw = toRecord(await apiFetch("/api/settings/oneproxy?action=stats"));
+    const statsRaw = toRecord(raw.stats);
+    const statusRaw = toRecord(raw.status);
+    const stats = {
+      total: toNumber(statsRaw.total, 0),
+      active: toNumber(statsRaw.active, 0),
+      avgQuality: statsRaw.avg_quality != null ? toNumber(statsRaw.avg_quality) : null,
+      lastValidated: typeof statsRaw.last_validated === "string" ? statsRaw.last_validated : null,
+      byProtocol: toArrayOfRecords(statsRaw.by_protocol || statsRaw.byProtocol).map((r) => ({
+        protocol: toString(r.protocol, ""),
+        count: toNumber(r.count, 0)
+      })),
+      byCountry: toArrayOfRecords(statsRaw.by_country || statsRaw.byCountry).map((r) => ({
+        countryCode: toString(r.countryCode || r.country_code, ""),
+        count: toNumber(r.count, 0)
+      }))
+    };
+    const status = {
+      lastSyncSuccess: toBoolean(statusRaw.last_sync_success, false),
+      lastSyncError: typeof statusRaw.last_sync_error === "string" ? statusRaw.last_sync_error : null,
+      lastSyncAt: typeof statusRaw.last_sync_at === "string" ? statusRaw.last_sync_at : null,
+      lastSyncCount: toNumber(statusRaw.last_sync_count, 0),
+      consecutiveFailures: toNumber(statusRaw.consecutive_failures, 0)
+    };
+    const result = { stats, status };
+    await logToolCall("omniroute_oneproxy_stats", 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_oneproxy_stats", args, null, Date.now() - start, false, msg);
+    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+  }
+}
+export {
+  handleBestComboForTask,
+  handleCacheFlush,
+  handleCacheStats,
+  handleDbHealthCheck,
+  handleExplainRoute,
+  handleGetProviderMetrics,
+  handleGetSessionSnapshot,
+  handleOneproxyFetch,
+  handleOneproxyRotate,
+  handleOneproxyStats,
+  handleSetBudgetGuard,
+  handleSetResilienceProfile,
+  handleSetRoutingStrategy,
+  handleSimulateRoute,
+  handleSyncPricing,
+  handleTestCombo
+};