@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/mcp-server/audit.js

@@ -1,283 +0,0 @@
-import { hashInput, summarizeOutput } from "./schemas/audit.ts";
-import { isNativeSqliteLoadError } from "../../lib/db/core.ts";
-function createNodeSqliteAuditAdapter(db) {
-  let _isOpen = true;
-  return {
-    driver: "node:sqlite",
-    get open() {
-      return _isOpen;
-    },
-    prepare(sql) {
-      const stmt = db.prepare(sql);
-      return {
-        get: (...params) => stmt.get(...params),
-        all: (...params) => stmt.all(...params),
-        run: (...params) => stmt.run(...params)
-      };
-    },
-    pragma(pragmaSql) {
-      try {
-        db.exec(`PRAGMA ${pragmaSql}`);
-        return null;
-      } catch (err) {
-        return err instanceof Error ? err.message : String(err);
-      }
-    },
-    close: () => {
-      if (!_isOpen) return;
-      try {
-        db.close();
-      } finally {
-        _isOpen = false;
-      }
-    }
-  };
-}
-function toNullableString(value) {
-  return typeof value === "string" ? value : null;
-}
-function toBoolean(value, fallback = false) {
-  if (typeof value === "boolean") return value;
-  if (value === 1 || value === "1") return true;
-  if (value === 0 || value === "0") return false;
-  return fallback;
-}
-function toPositiveInt(value, fallback) {
-  const parsed = toNumber(value, fallback);
-  if (!Number.isFinite(parsed)) return fallback;
-  return Math.max(0, Math.floor(parsed));
-}
-function mapAuditEntry(row) {
-  return {
-    id: toPositiveInt(row.id, 0),
-    toolName: toString(row.tool_name),
-    inputHash: toString(row.input_hash),
-    outputSummary: toString(row.output_summary),
-    durationMs: toNumber(row.duration_ms, 0),
-    apiKeyId: toNullableString(row.api_key_id),
-    success: toBoolean(row.success, false),
-    errorCode: toNullableString(row.error_code),
-    createdAt: toString(row.created_at)
-  };
-}
-function buildAuditFilterSql(filters) {
-  const clauses = [];
-  const params = [];
-  if (typeof filters.tool === "string" && filters.tool.trim().length > 0) {
-    clauses.push("tool_name = ?");
-    params.push(filters.tool.trim());
-  }
-  if (typeof filters.success === "boolean") {
-    clauses.push("success = ?");
-    params.push(filters.success ? 1 : 0);
-  }
-  if (typeof filters.apiKeyId === "string" && filters.apiKeyId.trim().length > 0) {
-    clauses.push("api_key_id = ?");
-    params.push(filters.apiKeyId.trim());
-  }
-  return {
-    whereSql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-}
-function getCachedAuditDb() {
-  return globalThis.__omnirouteMcpAuditDb ?? null;
-}
-function setCachedAuditDb(database) {
-  globalThis.__omnirouteMcpAuditDb = database;
-}
-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 toString(value) {
-  return typeof value === "string" ? value : "";
-}
-async function openBetterSqliteAuditDb(dbPath) {
-  const Database = (await import("better-sqlite3")).default;
-  return new Database(dbPath);
-}
-function nodeSqliteFallbackAvailable() {
-  const [maj, min] = (process.versions.node ?? "0.0").split(".").map(Number);
-  return maj > 22 || maj === 22 && (min ?? 0) >= 5;
-}
-async function openNodeSqliteAuditDb(dbPath) {
-  const { DatabaseSync } = await import("node:sqlite");
-  return createNodeSqliteAuditAdapter(new DatabaseSync(dbPath));
-}
-async function openFallbackAuditDb(dbPath, nativeMessage) {
-  if (!nodeSqliteFallbackAvailable()) {
-    console.error(
-      `[MCP Audit] better-sqlite3 native binding unavailable and Node ${process.version} has no built-in sqlite. Audit logging disabled. Fix: run \`npm rebuild better-sqlite3\` in the omniroute install root.`
-    );
-    return null;
-  }
-  try {
-    const adapter = await openNodeSqliteAuditDb(dbPath);
-    console.warn(
-      `[MCP Audit] better-sqlite3 binding unavailable \u2014 fell back to node:sqlite (${nativeMessage.split("\n")[0]})`
-    );
-    return adapter;
-  } catch (nodeErr) {
-    const nodeMessage = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
-    console.error("[MCP Audit] Failed to connect to database:", nodeMessage);
-    return null;
-  }
-}
-async function getDb() {
-  const cachedDb = getCachedAuditDb();
-  if (cachedDb) return cachedDb;
-  try {
-    const { homedir } = await import("node:os");
-    const { join } = await import("node:path");
-    const { existsSync } = await import("node:fs");
-    const dbPath = process.env.DATA_DIR ? join(process.env.DATA_DIR, "storage.sqlite") : join(homedir(), ".omniroute", "storage.sqlite");
-    if (!existsSync(dbPath)) {
-      console.error(`[MCP Audit] Database not found at ${dbPath} \u2014 audit logging disabled`);
-      return null;
-    }
-    try {
-      const database = await openBetterSqliteAuditDb(dbPath);
-      setCachedAuditDb(database);
-      return database;
-    } catch (nativeErr) {
-      const nativeMessage = nativeErr instanceof Error ? nativeErr.message : String(nativeErr);
-      if (!isNativeSqliteLoadError(nativeErr)) {
-        console.error("[MCP Audit] Failed to connect to database:", nativeMessage);
-        return null;
-      }
-      const fallbackDb = await openFallbackAuditDb(dbPath, nativeMessage);
-      setCachedAuditDb(fallbackDb);
-      return fallbackDb;
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error("[MCP Audit] Failed to connect to database:", message);
-    return null;
-  }
-}
-function closeAuditDb() {
-  const database = getCachedAuditDb();
-  if (!database) return false;
-  setCachedAuditDb(null);
-  try {
-    try {
-      if (database.open !== false) {
-        database.pragma("wal_checkpoint(TRUNCATE)");
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.warn("[MCP Audit] WAL checkpoint failed during close:", message);
-    }
-  } finally {
-    try {
-      database.close();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.warn("[MCP Audit] Failed to close database:", message);
-    }
-  }
-  return true;
-}
-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);
-  }
-}
-async function queryAuditEntries(filters = {}) {
-  try {
-    const database = await getDb();
-    const limit = Math.max(1, Math.min(500, toPositiveInt(filters.limit, 50)));
-    const offset = Math.max(0, toPositiveInt(filters.offset, 0));
-    if (!database) return { entries: [], total: 0, limit, offset };
-    const { whereSql, params } = buildAuditFilterSql(filters);
-    const totalRow = database.prepare(`SELECT COUNT(*) as total FROM mcp_tool_audit ${whereSql}`).get(...params);
-    const rows = database.prepare(
-      `SELECT
-           id,
-           tool_name,
-           input_hash,
-           output_summary,
-           duration_ms,
-           api_key_id,
-           success,
-           error_code,
-           created_at
-         FROM mcp_tool_audit
-         ${whereSql}
-         ORDER BY created_at DESC
-         LIMIT ? OFFSET ?`
-    ).all(...params, limit, offset);
-    return {
-      entries: rows.map(mapAuditEntry),
-      total: toPositiveInt(totalRow?.total, 0),
-      limit,
-      offset
-    };
-  } catch {
-    return { entries: [], total: 0, limit: 50, offset: 0 };
-  }
-}
-async function getRecentAuditEntries(limit = 50) {
-  const result = await queryAuditEntries({ limit, offset: 0 });
-  return result.entries;
-}
-async function getAuditStats() {
-  try {
-    const database = await getDb();
-    if (!database) return { totalCalls: 0, successRate: 0, avgDurationMs: 0, topTools: [] };
-    const stats = database.prepare(
-      `SELECT 
-           COUNT(*) as total,
-           AVG(CASE WHEN success = 1 THEN 1.0 ELSE 0.0 END) as successRate,
-           AVG(duration_ms) as avgDuration
-         FROM mcp_tool_audit
-         WHERE created_at > datetime('now', '-24 hours')`
-    ).get();
-    const topTools = database.prepare(
-      `SELECT tool_name as tool, COUNT(*) as count
-         FROM mcp_tool_audit
-         WHERE created_at > datetime('now', '-24 hours')
-         GROUP BY tool_name
-         ORDER BY count DESC
-         LIMIT 10`
-    ).all();
-    return {
-      totalCalls: toNumber(stats?.total, 0),
-      successRate: toNumber(stats?.successRate, 0),
-      avgDurationMs: toNumber(stats?.avgDuration, 0),
-      topTools: (topTools || []).map((entry) => ({
-        tool: toString(entry.tool),
-        count: toNumber(entry.count, 0)
-      }))
-    };
-  } catch {
-    return { totalCalls: 0, successRate: 0, avgDurationMs: 0, topTools: [] };
-  }
-}
-export {
-  closeAuditDb,
-  getAuditStats,
-  getRecentAuditEntries,
-  logToolCall,
-  queryAuditEntries
-};

package/open-sse/mcp-server/catalog.js

@@ -1,184 +0,0 @@
-import { getCodexRequestDefaults } from "../../lib/providers/requestDefaults.ts";
-import { getProviderConnections } from "../../lib/db/providers.ts";
-import { AI_PROVIDERS, NOAUTH_PROVIDERS } from '../../dist/shared/constants/providers.ts.js';
-function toRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function toString(value, fallback = "") {
-  return typeof value === "string" ? value : fallback;
-}
-function toStringArray(value, fallback = []) {
-  return Array.isArray(value) ? value.map((item) => String(item)) : fallback;
-}
-function buildProviderAliasMap() {
-  const aliasMap = {};
-  for (const provider of Object.values(AI_PROVIDERS)) {
-    if (!provider?.id) continue;
-    aliasMap[provider.id] = provider.id;
-    if (typeof provider.alias === "string" && provider.alias.length > 0) {
-      aliasMap[provider.alias] = provider.id;
-    }
-  }
-  for (const provider of Object.values(NOAUTH_PROVIDERS)) {
-    if (!provider?.id) continue;
-    aliasMap[provider.id] = provider.id;
-    if ("alias" in provider && typeof provider.alias === "string" && provider.alias.length > 0) {
-      aliasMap[provider.alias] = provider.id;
-    }
-  }
-  return aliasMap;
-}
-function normalizeCapability(value) {
-  switch (value) {
-    case "embeddings":
-      return "embedding";
-    case "images":
-      return "image";
-    case "videos":
-      return "video";
-    case "moderations":
-      return "moderation";
-    case "chat-completions":
-      return "chat";
-    default:
-      return value;
-  }
-}
-function getCatalogModelCapabilities(model) {
-  if (Array.isArray(model.capabilities) && model.capabilities.length > 0) {
-    return toStringArray(model.capabilities, ["chat"]).map(normalizeCapability);
-  }
-  if (Array.isArray(model.supportedEndpoints) && model.supportedEndpoints.length > 0) {
-    return toStringArray(model.supportedEndpoints, ["chat"]).map(normalizeCapability);
-  }
-  const type = toString(model.type);
-  if (type) return [normalizeCapability(type)];
-  return ["chat"];
-}
-function normalizeCatalogStatus(model, source, warning) {
-  const explicitStatus = toString(model.status);
-  if (explicitStatus === "available" || explicitStatus === "degraded" || explicitStatus === "unavailable") {
-    return explicitStatus;
-  }
-  if (warning || source === "local_catalog") return "degraded";
-  return "available";
-}
-function getConnectionThinkingEffort(connection) {
-  const provider = typeof connection.provider === "string" ? connection.provider : null;
-  const providerSpecificData = toRecord(connection.providerSpecificData);
-  if (provider === "codex") {
-    return getCodexRequestDefaults(providerSpecificData).reasoningEffort || "medium";
-  }
-  const rawThinkingEffort = toString(providerSpecificData.thinkingEffort);
-  return rawThinkingEffort || void 0;
-}
-function normalizeProviderModelRecord(rawModel, fallbackProvider, source, warning, thinkingEffort) {
-  const model = toRecord(rawModel);
-  const id = toString(model.id, "");
-  return {
-    id,
-    provider: toString(model.owned_by, toString(model.provider, fallbackProvider)),
-    capabilities: getCatalogModelCapabilities(model),
-    status: normalizeCatalogStatus(model, source, warning),
-    ...thinkingEffort ? { thinkingEffort } : {},
-    pricing: model.pricing
-  };
-}
-function activeProviderConnections(connections, normalizeProviderId, requestedProvider) {
-  return connections.filter((connection) => {
-    const provider = typeof connection?.provider === "string" ? normalizeProviderId(connection.provider) : null;
-    return !!provider && !!connection?.id && connection.isActive !== false && (!requestedProvider || provider === requestedProvider);
-  });
-}
-function providerModelRequestSpecs(connections, normalizeProviderId) {
-  return connections.map((connection) => ({
-    provider: normalizeProviderId(String(connection.provider)),
-    path: `/api/providers/${encodeURIComponent(String(connection.id))}/models?excludeHidden=true`,
-    thinkingEffort: getConnectionThinkingEffort(connection)
-  }));
-}
-function noAuthProviderSpec(requestedProvider) {
-  return {
-    provider: requestedProvider,
-    path: `/api/v1/providers/${encodeURIComponent(requestedProvider)}/models`,
-    thinkingEffort: void 0
-  };
-}
-function emptyCatalogForProvider(requestedProvider) {
-  return {
-    models: [],
-    source: "provider_connections",
-    warning: `No active connections found for provider '${requestedProvider}'.`
-  };
-}
-function rawModelsFromCatalog(raw) {
-  if (Array.isArray(raw.models)) return raw.models;
-  if (Array.isArray(raw.data)) return raw.data;
-  return [];
-}
-function maybeCatalogModel(rawModel, spec, source, warning, requestedCapability) {
-  const normalized = normalizeProviderModelRecord(rawModel, spec.provider, source, warning);
-  if (spec.thinkingEffort && !normalized.thinkingEffort) normalized.thinkingEffort = spec.thinkingEffort;
-  if (!normalized.id) return null;
-  if (requestedCapability && !normalized.capabilities.includes(requestedCapability)) return null;
-  return normalized;
-}
-function addCatalogModels(raw, spec, source, warning, requestedCapability, collectedModels) {
-  for (const rawModel of rawModelsFromCatalog(raw)) {
-    const normalized = maybeCatalogModel(rawModel, spec, source, warning, requestedCapability);
-    if (normalized) collectedModels.set(`${normalized.provider}:${normalized.id}`, normalized);
-  }
-}
-async function collectCatalogModels(requestSpecs, fetchJson, requestedCapability) {
-  const collectedModels = /* @__PURE__ */ new Map();
-  const warnings = /* @__PURE__ */ new Set();
-  const sources = /* @__PURE__ */ new Set();
-  for (const spec of requestSpecs) {
-    const raw = toRecord(await fetchJson(spec.path));
-    const source = toString(raw.source, spec.path.startsWith("/api/providers/") ? "api" : "v1_catalog");
-    const warning = raw.warning ? String(raw.warning) : void 0;
-    if (warning) warnings.add(warning);
-    sources.add(source);
-    addCatalogModels(raw, spec, source, warning, requestedCapability, collectedModels);
-  }
-  return { collectedModels, warnings, sources };
-}
-async function getMcpModelsCatalog(args, deps = {}) {
-  const fetchJson = deps.fetchJson ?? ((path) => import("./server.ts").then((m) => m.omniRouteFetch(path)));
-  const listProviderConnections = deps.listProviderConnections ?? getProviderConnections;
-  const aliasMap = buildProviderAliasMap();
-  const normalizeProviderId = (value) => aliasMap[value] || value;
-  const requestedProvider = args.provider ? normalizeProviderId(args.provider) : null;
-  const requestedCapability = args.capability ? normalizeCapability(args.capability) : null;
-  let connections = await listProviderConnections();
-  connections = Array.isArray(connections) ? connections : [];
-  const activeConnections = activeProviderConnections(
-    connections,
-    normalizeProviderId,
-    requestedProvider
-  );
-  const requestSpecs = providerModelRequestSpecs(activeConnections, normalizeProviderId);
-  if (requestedProvider && requestSpecs.length === 0) {
-    const isNoAuthProvider = Object.values(NOAUTH_PROVIDERS).some(
-      (provider) => provider.id === requestedProvider
-    );
-    if (isNoAuthProvider) {
-      requestSpecs.push(noAuthProviderSpec(requestedProvider));
-    } else {
-      return emptyCatalogForProvider(requestedProvider);
-    }
-  }
-  const { collectedModels, warnings, sources } = await collectCatalogModels(
-    requestSpecs,
-    fetchJson,
-    requestedCapability
-  );
-  return {
-    models: [...collectedModels.values()],
-    source: sources.size === 1 ? [...sources][0] : "aggregated_provider_models",
-    ...warnings.size > 0 ? { warning: [...warnings].join(" | ") } : {}
-  };
-}
-export {
-  getMcpModelsCatalog
-};

package/open-sse/mcp-server/descriptionCompressor.js

@@ -1,175 +0,0 @@
-import { applyRulesToText } from "../services/compression/caveman.ts";
-import { getRulesForContext } from "../services/compression/cavemanRules.ts";
-import {
-  extractPreservedBlocks,
-  restorePreservedBlocks
-} from "../services/compression/preservation.ts";
-const descriptionCompressionStats = {
-  descriptionsCompressed: 0,
-  charsBefore: 0,
-  charsAfter: 0,
-  charsSaved: 0,
-  estimatedTokensSaved: 0
-};
-const persistedDescriptionCompressionStats = {
-  descriptionsCompressed: 0,
-  charsBefore: 0,
-  charsAfter: 0,
-  charsSaved: 0,
-  estimatedTokensSaved: 0
-};
-const MCP_LIST_CONTAINER_KEYS = /* @__PURE__ */ new Set(["tools", "prompts", "resources", "resourceTemplates"]);
-const MCP_METADATA_DESCRIPTION_FIELDS = ["description"];
-function isDisabledEnvValue(value) {
-  return !!value && ["0", "false", "off", "no"].includes(value.trim().toLowerCase());
-}
-function isMcpDescriptionCompressionEnabled(options = {}) {
-  if (isDisabledEnvValue(process.env.OMNIROUTE_MCP_COMPRESS_DESCRIPTIONS)) return false;
-  if (isDisabledEnvValue(process.env.OMNIROUTE_MCP_DESCRIPTION_COMPRESSION)) return false;
-  return options.enabled !== false;
-}
-function compressMcpDescription(description) {
-  if (!description) {
-    return { compressed: description, before: 0, after: 0, changed: false };
-  }
-  const { text, blocks } = extractPreservedBlocks(description);
-  const rules = getRulesForContext("all", "full");
-  const applied = applyRulesToText(text, rules).text;
-  const normalized = applied.replace(/[ \t]{2,}/g, " ").replace(/[ \t]([,.;:!?])/g, "$1").replace(/\n{3,}/g, "\n\n").replace(/(^|[.!?][ \t]|\n[ \t]*)([a-z])/g, (_match, prefix, char) => {
-    return `${prefix}${char.toUpperCase()}`;
-  }).trim();
-  const compressed = restorePreservedBlocks(normalized, blocks);
-  return {
-    compressed,
-    before: description.length,
-    after: compressed.length,
-    changed: compressed !== description
-  };
-}
-function maybeCompressMcpDescription(description, options = {}) {
-  if (!isMcpDescriptionCompressionEnabled(options)) return description;
-  const result = compressMcpDescription(description);
-  if (result.changed && result.after < result.before) {
-    descriptionCompressionStats.descriptionsCompressed += 1;
-    descriptionCompressionStats.charsBefore += result.before;
-    descriptionCompressionStats.charsAfter += result.after;
-    descriptionCompressionStats.charsSaved += result.before - result.after;
-    descriptionCompressionStats.estimatedTokensSaved += Math.ceil(
-      (result.before - result.after) / 4
-    );
-    return result.compressed;
-  }
-  return description;
-}
-function compressDescriptionsInPlace(value, fieldNames = ["description"], options = {}) {
-  if (!value || typeof value !== "object") return;
-  const fields = new Set(fieldNames);
-  if (Array.isArray(value)) {
-    for (const item of value) compressDescriptionsInPlace(item, fieldNames, options);
-    return;
-  }
-  for (const [key, nested] of Object.entries(value)) {
-    if (fields.has(key) && typeof nested === "string") {
-      value[key] = maybeCompressMcpDescription(nested, options);
-    } else if (nested && typeof nested === "object") {
-      compressDescriptionsInPlace(nested, fieldNames, options);
-    }
-  }
-}
-function clonePlainMetadata(value) {
-  if (!value || typeof value !== "object") return value;
-  return JSON.parse(JSON.stringify(value));
-}
-function compressMcpListContainersInPlace(value, options = {}) {
-  if (!value || typeof value !== "object") return;
-  if (Array.isArray(value)) {
-    for (const item of value) compressMcpListContainersInPlace(item, options);
-    return;
-  }
-  for (const [key, nested] of Object.entries(value)) {
-    if (MCP_LIST_CONTAINER_KEYS.has(key) && Array.isArray(nested)) {
-      compressDescriptionsInPlace(nested, MCP_METADATA_DESCRIPTION_FIELDS, options);
-    } else if (nested && typeof nested === "object") {
-      compressMcpListContainersInPlace(nested, options);
-    }
-  }
-}
-function compressMcpListMetadata(value, options = {}) {
-  if (!isMcpDescriptionCompressionEnabled(options)) return value;
-  const clone = clonePlainMetadata(value);
-  compressMcpListContainersInPlace(clone, options);
-  return clone;
-}
-function compressMcpRegistryMetadata(metadata, options = {}) {
-  if (!isMcpDescriptionCompressionEnabled(options)) return metadata;
-  const clone = { ...metadata };
-  if (typeof clone.description === "string") {
-    clone.description = maybeCompressMcpDescription(clone.description, options);
-  }
-  return clone;
-}
-function getMcpDescriptionCompressionStats() {
-  return { ...descriptionCompressionStats };
-}
-function getUnpersistedMcpDescriptionCompressionStats() {
-  return {
-    descriptionsCompressed: descriptionCompressionStats.descriptionsCompressed - persistedDescriptionCompressionStats.descriptionsCompressed,
-    charsBefore: descriptionCompressionStats.charsBefore - persistedDescriptionCompressionStats.charsBefore,
-    charsAfter: descriptionCompressionStats.charsAfter - persistedDescriptionCompressionStats.charsAfter,
-    charsSaved: descriptionCompressionStats.charsSaved - persistedDescriptionCompressionStats.charsSaved,
-    estimatedTokensSaved: descriptionCompressionStats.estimatedTokensSaved - persistedDescriptionCompressionStats.estimatedTokensSaved
-  };
-}
-async function snapshotMcpDescriptionCompressionStats() {
-  const delta = getUnpersistedMcpDescriptionCompressionStats();
-  if (delta.descriptionsCompressed <= 0 || delta.charsSaved <= 0 || delta.estimatedTokensSaved <= 0) {
-    return {
-      descriptionsCompressed: 0,
-      charsBefore: 0,
-      charsAfter: 0,
-      charsSaved: 0,
-      estimatedTokensSaved: 0
-    };
-  }
-  const originalTokens = Math.max(delta.estimatedTokensSaved, Math.ceil(delta.charsBefore / 4));
-  const compressedTokens = Math.max(0, originalTokens - delta.estimatedTokensSaved);
-  const { insertCompressionAnalyticsRow } = await import("../../lib/db/compressionAnalytics.ts");
-  insertCompressionAnalyticsRow({
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    mode: "mcp-description",
-    engine: "mcp-description",
-    original_tokens: originalTokens,
-    compressed_tokens: compressedTokens,
-    tokens_saved: delta.estimatedTokensSaved,
-    mcp_description_tokens_saved: delta.estimatedTokensSaved
-  });
-  persistedDescriptionCompressionStats.descriptionsCompressed = descriptionCompressionStats.descriptionsCompressed;
-  persistedDescriptionCompressionStats.charsBefore = descriptionCompressionStats.charsBefore;
-  persistedDescriptionCompressionStats.charsAfter = descriptionCompressionStats.charsAfter;
-  persistedDescriptionCompressionStats.charsSaved = descriptionCompressionStats.charsSaved;
-  persistedDescriptionCompressionStats.estimatedTokensSaved = descriptionCompressionStats.estimatedTokensSaved;
-  return delta;
-}
-function resetMcpDescriptionCompressionStats() {
-  descriptionCompressionStats.descriptionsCompressed = 0;
-  descriptionCompressionStats.charsBefore = 0;
-  descriptionCompressionStats.charsAfter = 0;
-  descriptionCompressionStats.charsSaved = 0;
-  descriptionCompressionStats.estimatedTokensSaved = 0;
-  persistedDescriptionCompressionStats.descriptionsCompressed = 0;
-  persistedDescriptionCompressionStats.charsBefore = 0;
-  persistedDescriptionCompressionStats.charsAfter = 0;
-  persistedDescriptionCompressionStats.charsSaved = 0;
-  persistedDescriptionCompressionStats.estimatedTokensSaved = 0;
-}
-export {
-  compressDescriptionsInPlace,
-  compressMcpDescription,
-  compressMcpListMetadata,
-  compressMcpRegistryMetadata,
-  getMcpDescriptionCompressionStats,
-  isMcpDescriptionCompressionEnabled,
-  maybeCompressMcpDescription,
-  resetMcpDescriptionCompressionStats,
-  snapshotMcpDescriptionCompressionStats
-};

package/open-sse/mcp-server/httpAuthContext.js

@@ -1,32 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-const mcpHttpAuthContext = new AsyncLocalStorage();
-function headerValue(request, name) {
-  const value = request.headers.get(name);
-  return value && value.trim().length > 0 ? value : void 0;
-}
-function getMcpHttpAuthHeadersForInternalFetch() {
-  const context = mcpHttpAuthContext.getStore();
-  const headers = {};
-  if (context?.authorization) headers.Authorization = context.authorization;
-  if (context?.cookie) headers.Cookie = context.cookie;
-  if (context?.xApiKey && context?.anthropicVersion) {
-    headers["x-api-key"] = context.xApiKey;
-    headers["anthropic-version"] = context.anthropicVersion;
-  }
-  return headers;
-}
-async function withMcpHttpAuthContext(request, callback) {
-  return mcpHttpAuthContext.run(
-    {
-      authorization: headerValue(request, "authorization"),
-      cookie: headerValue(request, "cookie"),
-      xApiKey: headerValue(request, "x-api-key"),
-      anthropicVersion: headerValue(request, "anthropic-version")
-    },
-    callback
-  );
-}
-export {
-  getMcpHttpAuthHeadersForInternalFetch,
-  withMcpHttpAuthContext
-};