@fudrouter/fsrouter 0.6.64 → 0.6.65

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

@@ -0,0 +1,283 @@
+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

@@ -0,0 +1,184 @@
+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

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,32 @@
+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
+};