@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/config/rerankRegistry.js

@@ -0,0 +1,177 @@
+/**
+ * Rerank Provider Registry
+ *
+ * Defines providers that support the /v1/rerank endpoint.
+ * Follows the Cohere rerank API request/response format (industry standard).
+ */
+
+export const RERANK_PROVIDERS = {
+  cohere: {
+    id: "cohere",
+    baseUrl: "https://api.cohere.com/v2/rerank",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [
+      { id: "rerank-v4.0-pro", name: "Rerank v4.0 Pro" },
+      { id: "rerank-v4.0-fast", name: "Rerank v4.0 Fast" },
+      { id: "rerank-v3.5", name: "Rerank v3.5" },
+      { id: "rerank-multilingual-v3.0", name: "Rerank Multilingual v3.0" },
+    ],
+  },
+  together: {
+    id: "together",
+    baseUrl: "https://api.together.xyz/v1/rerank",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [{ id: "Salesforce/Llama-Rank-V2", name: "Llama Rank V2" }],
+  },
+  nvidia: {
+    id: "nvidia",
+    baseUrl: "https://integrate.api.nvidia.com/v1/ranking",
+    authType: "apikey",
+    authHeader: "bearer",
+    format: "nvidia",
+    models: [{ id: "nvidia/nv-rerankqa-mistral-4b-v3", name: "NV RerankQA Mistral 4B v3" }],
+  },
+  fireworks: {
+    id: "fireworks",
+    baseUrl: "https://api.fireworks.ai/inference/v1/rerank",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [
+      { id: "accounts/fireworks/models/nomic-rerank-v1", name: "Nomic Rerank v1" },
+      { id: "accounts/fireworks/models/qwen3-reranker-8b", name: "Qwen3 Reranker 8B" },
+    ],
+  },
+  "voyage-ai": {
+    id: "voyage-ai",
+    baseUrl: "https://api.voyageai.com/v1/rerank",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [
+      { id: "rerank-2.5", name: "Rerank 2.5" },
+      { id: "rerank-2.5-lite", name: "Rerank 2.5 Lite" },
+    ],
+  },
+  "jina-ai": {
+    id: "jina-ai",
+    baseUrl: "https://api.jina.ai/v1/rerank",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [
+      { id: "jina-reranker-v3", name: "Jina Reranker v3" },
+      { id: "jina-reranker-m0", name: "Jina Reranker m0" },
+    ],
+  },
+  siliconflow: {
+    id: "siliconflow",
+    baseUrl: "https://api.siliconflow.com/v1/rerank",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [
+      { id: "Qwen/Qwen3-Reranker-8B", name: "Qwen3 Reranker 8B" },
+      { id: "Qwen/Qwen3-Reranker-4B", name: "Qwen3 Reranker 4B" },
+      { id: "Qwen/Qwen3-Reranker-0.6B", name: "Qwen3 Reranker 0.6B" },
+      { id: "BAAI/bge-reranker-v2-m3", name: "BGE Reranker v2 m3" },
+    ],
+  },
+  deepinfra: {
+    id: "deepinfra",
+    baseUrl: "https://api.deepinfra.com/v1/inference",
+    authType: "apikey",
+    authHeader: "bearer",
+    format: "deepinfra",
+    models: [
+      { id: "Qwen/Qwen3-Reranker-8B", name: "Qwen3 Reranker 8B" },
+      { id: "Qwen/Qwen3-Reranker-4B", name: "Qwen3 Reranker 4B" },
+      { id: "Qwen/Qwen3-Reranker-0.6B", name: "Qwen3 Reranker 0.6B" },
+    ],
+  },
+};
+
+const RERANK_PROVIDER_ALIASES = {
+  jina: "jina-ai",
+  voyage: "voyage-ai",
+};
+
+function resolveRerankProviderId(providerId) {
+  return RERANK_PROVIDER_ALIASES[providerId] || providerId;
+}
+
+function normalizeProviderScopedModelId(providerId, modelId) {
+  const resolvedProvider = resolveRerankProviderId(providerId);
+  const provider = RERANK_PROVIDERS[resolvedProvider];
+  if (provider?.models.some((model) => model.id === modelId)) return modelId;
+
+  const providerScopedModelId = `${resolvedProvider}/${modelId}`;
+  if (provider?.models.some((model) => model.id === providerScopedModelId)) {
+    return providerScopedModelId;
+  }
+
+  return modelId.startsWith(`${providerId}/`) ? modelId.slice(providerId.length + 1) : modelId;
+}
+
+function toProviderScopedModelId(providerId, modelId) {
+  return modelId.startsWith(`${providerId}/`) ? modelId : `${providerId}/${modelId}`;
+}
+
+/**
+ * Get rerank provider config by ID
+ */
+export function getRerankProvider(providerId) {
+  return RERANK_PROVIDERS[resolveRerankProviderId(providerId)] || null;
+}
+
+/**
+ * Parse rerank model string (format: "provider/model" or just "model")
+ * Returns { provider, model }
+ */
+export function parseRerankModel(modelStr) {
+  if (!modelStr) return { provider: null, model: null };
+
+  const slashIdx = modelStr.indexOf("/");
+  if (slashIdx > 0) {
+    const rawProvider = modelStr.slice(0, slashIdx);
+    const resolvedProvider = resolveRerankProviderId(rawProvider);
+    if (RERANK_PROVIDERS[resolvedProvider]) {
+      return {
+        provider: resolvedProvider,
+        model: normalizeProviderScopedModelId(resolvedProvider, modelStr.slice(slashIdx + 1)),
+      };
+    }
+  }
+
+  for (const [providerId, config] of Object.entries(RERANK_PROVIDERS)) {
+    if (modelStr.startsWith(providerId + "/")) {
+      return {
+        provider: providerId,
+        model: normalizeProviderScopedModelId(providerId, modelStr.slice(providerId.length + 1)),
+      };
+    }
+  }
+
+  for (const [providerId, config] of Object.entries(RERANK_PROVIDERS)) {
+    if (config.models.some((m) => m.id === modelStr)) {
+      return { provider: providerId, model: modelStr };
+    }
+  }
+
+  return { provider: null, model: modelStr };
+}
+
+/**
+ * Get all rerank models as a flat list
+ */
+export function getAllRerankModels() {
+  const models = [];
+  for (const [providerId, config] of Object.entries(RERANK_PROVIDERS)) {
+    for (const model of config.models) {
+      models.push({
+        id: toProviderScopedModelId(providerId, model.id),
+        name: model.name,
+        provider: providerId,
+      });
+    }
+  }
+  return models;
+}

package/open-sse/config/runtimeConfig.js

@@ -0,0 +1,96 @@
+// HTTP status codes
+export const HTTP_STATUS = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  NOT_ACCEPTABLE: 406,
+  REQUEST_TIMEOUT: 408,
+  RATE_LIMITED: 429,
+  SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+
+// Re-export error config (backward compat)
+export { ERROR_TYPES, DEFAULT_ERROR_MESSAGES, BACKOFF_CONFIG, COOLDOWN_MS } from "./errorConfig.js";
+
+// Cache TTLs (seconds)
+export const CACHE_TTL = {
+  userInfo: 300,    // 5 minutes
+  modelAlias: 3600  // 1 hour
+};
+
+// Memory management config
+export const MEMORY_CONFIG = {
+  sessionTtlMs: 2 * 60 * 60 * 1000,
+  sessionCleanupIntervalMs: 30 * 60 * 1000,
+  dnsCacheTtlMs: 5 * 60 * 1000,
+  proxyDispatchersMaxSize: 20,
+};
+
+// Parse a positive integer env override, falling back to a default.
+function envMs(name, def) {
+  const raw = process.env[name];
+  if (raw == null || raw === "") return def;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : def;
+}
+
+function envUrl(name, def) {
+  const raw = process.env[name]?.trim();
+  return raw || def;
+}
+
+// SearXNG endpoint used by the unauthenticated web-search provider.
+// Configure this for a separate Docker service or remote SearXNG instance.
+export const SEARXNG_URL = envUrl("SEARXNG_URL", "http://localhost:8888/search");
+
+// Inter-chunk stall timeout (once tokens are flowing). Generous headroom so
+// slow reasoning models aren't aborted mid-stream. Env: STREAM_STALL_TIMEOUT_MS.
+export const STREAM_STALL_TIMEOUT_MS = envMs("STREAM_STALL_TIMEOUT_MS", 360 * 1000);
+
+// Time-to-first-token timeout (prompt prefill). Env: STREAM_FIRST_CHUNK_TIMEOUT_MS.
+export const STREAM_FIRST_CHUNK_TIMEOUT_MS = envMs("STREAM_FIRST_CHUNK_TIMEOUT_MS", 200 * 1000);
+
+// Fetch connect timeout: abort if upstream doesn't return response headers within this duration
+export const FETCH_CONNECT_TIMEOUT_MS = envMs("FETCH_CONNECT_TIMEOUT_MS", 60 * 1000);
+
+// Gemini native TTS fetch timeout: abort if Google does not return response headers in time.
+export const GEMINI_NATIVE_TTS_FETCH_TIMEOUT_MS = envMs("GEMINI_NATIVE_TTS_FETCH_TIMEOUT_MS", 45 * 1000);
+
+// Default token limits
+export const DEFAULT_MAX_TOKENS = 64000;
+export const DEFAULT_MIN_TOKENS = 32000;
+
+// Retry config for 429 responses (legacy - kept for backward compatibility)
+export const RETRY_CONFIG = {
+  maxAttempts: 2,
+  delayMs: 2000
+};
+
+// Default retry config by status code: { attempts, delayMs }
+// Backward compat: if value is a number, treated as attempts with RETRY_CONFIG.delayMs
+export const DEFAULT_RETRY_CONFIG = {
+  429: { attempts: 0, delayMs: 0 },
+  502: { attempts: 3, delayMs: 3000 },
+  503: { attempts: 3, delayMs: 2000 },
+  504: { attempts: 2, delayMs: 3000 }
+};
+
+// Normalize a retry entry to { attempts, delayMs }
+export function resolveRetryEntry(entry) {
+  if (entry == null) return { attempts: 0, delayMs: RETRY_CONFIG.delayMs };
+  if (typeof entry === "number") return { attempts: entry, delayMs: RETRY_CONFIG.delayMs };
+  return {
+    attempts: entry.attempts || 0,
+    delayMs: entry.delayMs != null ? entry.delayMs : RETRY_CONFIG.delayMs
+  };
+}
+
+// Requests containing these texts will bypass provider
+export const SKIP_PATTERNS = [
+  "Please write a 5-10 word title for the following conversation:"
+];

package/open-sse/config/runway.js

@@ -0,0 +1,39 @@
+export const RUNWAYML_DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1";
+export const RUNWAYML_API_VERSION = "2024-11-06";
+
+export const RUNWAYML_SUPPORTED_VIDEO_MODELS = [
+  { id: "gen4.5", name: "Gen-4.5" },
+  { id: "gen4_turbo", name: "Gen-4 Turbo" },
+  { id: "gen3a_turbo", name: "Gen-3 Alpha Turbo" },
+  { id: "veo3.1", name: "Veo 3.1" },
+  { id: "veo3.1_fast", name: "Veo 3.1 Fast" },
+];
+
+export const RUNWAYML_IMAGE_REQUIRED_MODELS = new Set(["gen4_turbo"]);
+
+export function normalizeRunwayBaseUrl(baseUrl) {
+  const normalized = String(baseUrl || "")
+    .trim()
+    .replace(/\/$/, "");
+  if (!normalized) return RUNWAYML_DEFAULT_BASE_URL;
+
+  const stripped = normalized
+    .replace(/\/organization$/i, "")
+    .replace(/\/tasks\/[^/]+$/i, "")
+    .replace(/\/(?:image_to_video|text_to_video)$/i, "");
+
+  return stripped.endsWith("/v1") ? stripped : `${stripped}/v1`;
+}
+
+export function buildRunwayApiUrl(path, baseUrl) {
+  const normalizedBaseUrl = normalizeRunwayBaseUrl(baseUrl);
+  return `${normalizedBaseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+}
+
+export function buildRunwayHeaders(apiKey) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    "X-Runway-Version": RUNWAYML_API_VERSION,
+  };
+}

package/open-sse/config/searchRegistry.js

@@ -0,0 +1,153 @@
+/**
+ * Search Provider Registry
+ *
+ * Defines providers that support the /v1/search endpoint.
+ */
+
+export const SEARCH_PROVIDERS = {
+  "serper-search": {
+    id: "serper-search", name: "Serper Search",
+    baseUrl: "https://google.serper.dev", method: "POST",
+    authType: "apikey", authHeader: "x-api-key",
+    costPerQuery: 0.001, freeMonthlyQuota: 2500,
+    searchTypes: ["web", "news"], defaultMaxResults: 5, maxMaxResults: 100,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "brave-search": {
+    id: "brave-search", name: "Brave Search",
+    baseUrl: "https://api.search.brave.com/res/v1", method: "GET",
+    authType: "apikey", authHeader: "x-subscription-token",
+    costPerQuery: 0.005, freeMonthlyQuota: 1000,
+    searchTypes: ["web", "news"], defaultMaxResults: 5, maxMaxResults: 20,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "perplexity-search": {
+    id: "perplexity-search", name: "Perplexity Search",
+    baseUrl: "https://api.perplexity.ai/search", method: "POST",
+    authType: "apikey", authHeader: "bearer",
+    costPerQuery: 0.005, freeMonthlyQuota: 0,
+    searchTypes: ["web"], defaultMaxResults: 5, maxMaxResults: 20,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "exa-search": {
+    id: "exa-search", name: "Exa Search",
+    baseUrl: "https://api.exa.ai/search", method: "POST",
+    authType: "apikey", authHeader: "x-api-key",
+    costPerQuery: 0.007, freeMonthlyQuota: 1000,
+    searchTypes: ["web", "news"], defaultMaxResults: 5, maxMaxResults: 100,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "tavily-search": {
+    id: "tavily-search", name: "Tavily Search",
+    baseUrl: "https://api.tavily.com/search", method: "POST",
+    authType: "apikey", authHeader: "bearer",
+    costPerQuery: 0.008, freeMonthlyQuota: 1000,
+    searchTypes: ["web", "news"], defaultMaxResults: 5, maxMaxResults: 20,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "google-pse-search": {
+    id: "google-pse-search", name: "Google Programmable Search",
+    baseUrl: "https://www.googleapis.com/customsearch/v1", method: "GET",
+    authType: "apikey", authHeader: "key",
+    costPerQuery: 0.005, freeMonthlyQuota: 3000,
+    searchTypes: ["web", "news"], defaultMaxResults: 5, maxMaxResults: 10,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "linkup-search": {
+    id: "linkup-search", name: "Linkup Search",
+    baseUrl: "https://api.linkup.so/v1/search", method: "POST",
+    authType: "apikey", authHeader: "bearer",
+    costPerQuery: 0.005, freeMonthlyQuota: 1000,
+    searchTypes: ["web"], defaultMaxResults: 5, maxMaxResults: 50,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "searchapi-search": {
+    id: "searchapi-search", name: "SearchAPI",
+    baseUrl: "https://www.searchapi.io/api/v1/search", method: "GET",
+    authType: "apikey", authHeader: "api_key",
+    costPerQuery: 0.004, freeMonthlyQuota: 100,
+    searchTypes: ["web", "news"], defaultMaxResults: 5, maxMaxResults: 100,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "youcom-search": {
+    id: "youcom-search", name: "You.com Search",
+    baseUrl: "https://ydc-index.io/v1/search", method: "GET",
+    authType: "apikey", authHeader: "x-api-key",
+    costPerQuery: 0.005, freeMonthlyQuota: 0,
+    searchTypes: ["web", "news"], defaultMaxResults: 5, maxMaxResults: 100,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "searxng-search": {
+    id: "searxng-search", name: "SearXNG Search",
+    baseUrl: "http://localhost:8888/search", method: "GET",
+    authType: "none", authHeader: "none",
+    costPerQuery: 0, freeMonthlyQuota: 999999,
+    searchTypes: ["web", "news"], defaultMaxResults: 5, maxMaxResults: 50,
+    timeoutMs: 10_000, cacheTTLMs: 3 * 60 * 1000,
+  },
+  "ollama-search": {
+    id: "ollama-search", name: "Ollama Search",
+    baseUrl: "https://ollama.com/api/web_search", method: "POST",
+    authType: "apikey", authHeader: "bearer",
+    costPerQuery: 0, freeMonthlyQuota: 1000,
+    searchTypes: ["web"], defaultMaxResults: 5, maxMaxResults: 10,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "zai-search": {
+    id: "zai-search", name: "Z.AI Coding Plan Search",
+    baseUrl: "https://api.z.ai/api/mcp/web_search_prime/mcp", method: "POST",
+    authType: "apikey", authHeader: "bearer",
+    costPerQuery: 0, freeMonthlyQuota: 0,
+    searchTypes: ["web"], defaultMaxResults: 5, maxMaxResults: 50,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+  },
+  "duckduckgo-free": {
+    id: "duckduckgo-free", name: "DuckDuckGo (free)",
+    baseUrl: "https://lite.duckduckgo.com/lite/", method: "POST",
+    authType: "none", authHeader: "none",
+    costPerQuery: 0, freeMonthlyQuota: 999999,
+    searchTypes: ["web"], defaultMaxResults: 5, maxMaxResults: 25,
+    timeoutMs: 10_000, cacheTTLMs: 5 * 60 * 1000,
+    fallbackOnly: true,
+  },
+};
+
+export const SEARCH_CREDENTIAL_FALLBACKS = {
+  "perplexity-search": "perplexity",
+  "ollama-search": "ollama-cloud",
+  "zai-search": "zai",
+};
+
+export function getSearchProvider(providerId) {
+  return SEARCH_PROVIDERS[providerId] || null;
+}
+
+export function supportsSearchType(providerOrId, searchType) {
+  const provider =
+    typeof providerOrId === "string" ? getSearchProvider(providerOrId) : providerOrId || null;
+  if (!provider) return false;
+  return provider.searchTypes.includes(searchType);
+}
+
+export function getAllSearchProviders() {
+  return Object.values(SEARCH_PROVIDERS).map((p) => ({
+    id: p.id, name: p.name, searchTypes: p.searchTypes,
+  }));
+}
+
+export function selectProvider(explicitProvider, searchType) {
+  if (explicitProvider) {
+    const provider = SEARCH_PROVIDERS[explicitProvider] || null;
+    if (!provider) return null;
+    if (searchType && !supportsSearchType(provider, searchType)) return null;
+    return provider;
+  }
+
+  const providers = Object.values(SEARCH_PROVIDERS).filter(
+    (provider) =>
+      !provider.fallbackOnly && (searchType ? supportsSearchType(provider, searchType) : true)
+  );
+  if (providers.length === 0) return null;
+
+  return providers.reduce((cheapest, p) => (p.costPerQuery < cheapest.costPerQuery ? p : cheapest));
+}

package/open-sse/config/toolCloaking.js

@@ -0,0 +1,199 @@
+const AG_TOOL_SUFFIX = "_ide";
+const AG_DEFAULT_TOOL_NAMES = [
+  "browser_subagent",
+  "command_status",
+  "find_by_name",
+  "generate_image",
+  "grep_search",
+  "list_dir",
+  "list_resources",
+  "multi_replace_file_content",
+  "notify_user",
+  "read_resource",
+  "read_terminal",
+  "read_url_content",
+  "replace_file_content",
+  "run_command",
+  "search_web",
+  "send_command_input",
+  "task_boundary",
+  "view_content_chunk",
+  "view_file",
+  "write_to_file"
+];
+const AG_DECOY_TOOL_NAMES = [
+  ...AG_DEFAULT_TOOL_NAMES,
+  "mcp_sequential_thinking_sequentialthinking"
+];
+const AG_DEFAULT_TOOLS = new Set(AG_DEFAULT_TOOL_NAMES);
+const AG_DECOY_TOOLS = AG_DECOY_TOOL_NAMES.map(
+  (name) => Object.freeze({
+    name,
+    description: "This tool is currently unavailable.",
+    parameters: {
+      type: "OBJECT",
+      properties: {},
+      required: []
+    }
+  })
+);
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function toToolName(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function stripEnumDescriptions(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) {
+    return schema.map((entry) => stripEnumDescriptions(entry));
+  }
+  const result = { ...schema };
+  delete result.enumDescriptions;
+  const properties = asRecord(result.properties);
+  if (properties) {
+    const nextProperties = {};
+    for (const key of Object.keys(properties)) {
+      nextProperties[key] = stripEnumDescriptions(properties[key]);
+    }
+    result.properties = nextProperties;
+  }
+  if (result.items !== void 0) {
+    result.items = stripEnumDescriptions(result.items);
+  }
+  return result;
+}
+function shouldCloakAntigravityTool(toolName) {
+  return toolName.length > 0 && !AG_DEFAULT_TOOLS.has(toolName) && !toolName.endsWith(AG_TOOL_SUFFIX);
+}
+function getCloakedAntigravityToolName(toolName) {
+  return shouldCloakAntigravityTool(toolName) ? `${toolName}${AG_TOOL_SUFFIX}` : toolName;
+}
+function cloakAntigravityToolPayload(body) {
+  const request = asRecord(body.request);
+  if (!request) {
+    return { body, toolNameMap: null };
+  }
+  const existingToolNameMap = body._toolNameMap instanceof Map ? body._toolNameMap : null;
+  const toolNameMap = existingToolNameMap ? new Map(existingToolNameMap) : /* @__PURE__ */ new Map();
+  let changed = false;
+  const nextRequest = {
+    ...request
+  };
+  if (Array.isArray(request.tools)) {
+    const preservedTools = [];
+    const cloakedDeclarations = [];
+    for (const toolValue of request.tools) {
+      const tool = asRecord(toolValue);
+      if (!tool || !Array.isArray(tool.functionDeclarations)) {
+        preservedTools.push(toolValue);
+        continue;
+      }
+      for (const declarationValue of tool.functionDeclarations) {
+        const declaration = asRecord(declarationValue);
+        if (!declaration) continue;
+        const stripped = declaration.parameters !== void 0 ? { ...declaration, parameters: stripEnumDescriptions(declaration.parameters) } : declaration;
+        if (stripped !== declaration) {
+          changed = true;
+        }
+        const rawName = toToolName(stripped.name);
+        if (!rawName) {
+          cloakedDeclarations.push({ ...stripped });
+          continue;
+        }
+        const cloakedName = getCloakedAntigravityToolName(rawName);
+        if (cloakedName !== rawName) {
+          changed = true;
+          toolNameMap.set(cloakedName, toolNameMap.get(rawName) ?? rawName);
+        }
+        cloakedDeclarations.push({
+          ...stripped,
+          name: cloakedName
+        });
+      }
+    }
+    if (cloakedDeclarations.length > 0) {
+      const declaredNames = new Set(
+        cloakedDeclarations.map((declaration) => toToolName(declaration.name)).filter((name) => name.length > 0)
+      );
+      const decoys = AG_DECOY_TOOLS.filter((declaration) => !declaredNames.has(declaration.name));
+      nextRequest.tools = [
+        ...preservedTools,
+        { functionDeclarations: [...cloakedDeclarations, ...decoys] }
+      ];
+      changed = true;
+    }
+  }
+  if (Array.isArray(request.contents)) {
+    let contentsChanged = false;
+    const nextContents = request.contents.map((contentValue) => {
+      const content = asRecord(contentValue);
+      if (!content || !Array.isArray(content.parts)) return contentValue;
+      let partChanged = false;
+      const nextParts = content.parts.map((partValue) => {
+        const part = asRecord(partValue);
+        if (!part) return partValue;
+        const nextPart = { ...part };
+        const functionCall = asRecord(part.functionCall);
+        if (functionCall) {
+          const rawName = toToolName(functionCall.name);
+          const cloakedName = getCloakedAntigravityToolName(rawName);
+          if (cloakedName !== rawName) {
+            nextPart.functionCall = {
+              ...functionCall,
+              name: cloakedName
+            };
+            toolNameMap.set(cloakedName, toolNameMap.get(rawName) ?? rawName);
+            partChanged = true;
+          }
+        }
+        const functionResponse = asRecord(part.functionResponse);
+        if (functionResponse) {
+          const rawName = toToolName(functionResponse.name);
+          const cloakedName = getCloakedAntigravityToolName(rawName);
+          if (cloakedName !== rawName) {
+            nextPart.functionResponse = {
+              ...functionResponse,
+              name: cloakedName
+            };
+            toolNameMap.set(cloakedName, toolNameMap.get(rawName) ?? rawName);
+            partChanged = true;
+          }
+        }
+        return partChanged ? nextPart : partValue;
+      });
+      if (!partChanged) return contentValue;
+      contentsChanged = true;
+      return {
+        ...content,
+        parts: nextParts
+      };
+    });
+    if (contentsChanged) {
+      nextRequest.contents = nextContents;
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return {
+      body,
+      toolNameMap: toolNameMap.size > 0 ? toolNameMap : null
+    };
+  }
+  return {
+    body: {
+      ...body,
+      request: nextRequest
+    },
+    toolNameMap: toolNameMap.size > 0 ? toolNameMap : null
+  };
+}
+export {
+  AG_DECOY_TOOLS,
+  AG_DEFAULT_TOOLS,
+  AG_TOOL_SUFFIX,
+  cloakAntigravityToolPayload,
+  getCloakedAntigravityToolName,
+  shouldCloakAntigravityTool,
+  stripEnumDescriptions
+};