swayrouter 1.0.0

package/src/routes/api/chat/tools/router/route.js

@@ -0,0 +1,215 @@
+import { NextResponse } from "@/next/server";
+import {
+  countProviderConnections,
+  getApiKeys,
+  getCombos,
+  getCustomModels,
+  getProviderConnectionsPaged,
+  getProviderNodes,
+  getProxyPools,
+  getSettings,
+} from "@/lib/localDb.js";
+import { buildModelsList } from "@/routes/api/v1/models/route.js";
+import { routerAdmission } from "@/transport/routerAdmission";
+import { AI_PROVIDERS } from "@/shared/constants/providers";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const MAX_RESULT_ITEMS = 100;
+const MODEL_CACHE_TTL_MS = 5_000;
+let modelCache = { at: 0, data: [] };
+
+class RouterToolInputError extends Error {}
+
+function limitValue(value, fallback = 25) {
+  if (value === undefined || value === null || value === "") return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_RESULT_ITEMS) {
+    throw new RouterToolInputError(`limit must be an integer from 1 to ${MAX_RESULT_ITEMS}`);
+  }
+  return parsed;
+}
+
+function stringValue(value, max = 120) {
+  return typeof value === "string" ? value.trim().slice(0, max) : "";
+}
+
+function providerIdentity(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+function safeConnection(connection) {
+  return {
+    id: connection.id,
+    provider: connection.provider,
+    name: connection.name || connection.email || connection.id,
+    authType: connection.authType || null,
+    isActive: connection.isActive === true,
+    testStatus: connection.testStatus || "unknown",
+    lastTested: connection.lastTested || null,
+    defaultModel: connection.defaultModel || null,
+    priority: connection.priority ?? null,
+  };
+}
+
+function safeApiKey(key) {
+  return {
+    id: key.id,
+    name: key.name || key.id,
+    isActive: key.isActive !== false,
+    isDefault: key.isDefault === true,
+    createdAt: key.createdAt || null,
+  };
+}
+
+function safeModel(model) {
+  const caps = model?.capabilities;
+  return {
+    id: model.id,
+    owned_by: model.owned_by || null,
+    capabilities: caps && typeof caps === "object"
+      ? {
+          vision: caps.vision === true,
+          imageOutput: caps.imageOutput === true,
+          search: caps.search === true,
+          tools: caps.tools !== false,
+          reasoning: caps.reasoning === true,
+          contextWindow: Number.isFinite(Number(caps.contextWindow)) ? Number(caps.contextWindow) : undefined,
+          maxOutput: Number.isFinite(Number(caps.maxOutput)) ? Number(caps.maxOutput) : undefined,
+        }
+      : undefined,
+  };
+}
+
+async function getModelsSnapshot() {
+  if (Date.now() - modelCache.at < MODEL_CACHE_TTL_MS) return modelCache.data;
+  const data = await buildModelsList(["llm"]);
+  modelCache = { at: Date.now(), data: Array.isArray(data) ? data : [] };
+  return modelCache.data;
+}
+
+async function overview() {
+  const [counts, nodes, pools, combos, customModels, keys, settings, models] = await Promise.all([
+    countProviderConnections(),
+    getProviderNodes(),
+    getProxyPools(),
+    getCombos(),
+    getCustomModels(),
+    getApiKeys(),
+    getSettings(),
+    getModelsSnapshot(),
+  ]);
+  const providerCounts = counts.map((row) => ({
+    provider: row.provider,
+    total: Number(row.total) || 0,
+    active: Number(row.active) || 0,
+    inactive: Number(row.inactive) || 0,
+  }));
+  const registeredProviderTypes = Object.keys(AI_PROVIDERS).length;
+  const registeredProviderIds = Object.keys(AI_PROVIDERS).map(providerIdentity).filter(Boolean);
+  const customProviderIds = nodes.map((node) => providerIdentity(node.id)).filter(Boolean);
+  const configuredProviderIds = providerCounts.map((row) => providerIdentity(row.provider)).filter(Boolean);
+  const allProviderIds = new Set([
+    ...registeredProviderIds,
+    ...customProviderIds,
+    ...configuredProviderIds,
+  ]);
+  const configuredProviders = new Set(configuredProviderIds).size;
+  const activeProviders = new Set(
+    providerCounts.filter((row) => row.active > 0).map((row) => providerIdentity(row.provider)).filter(Boolean)
+  ).size;
+  const inactiveOnlyProviders = new Set(
+    providerCounts.filter((row) => row.active === 0).map((row) => providerIdentity(row.provider)).filter(Boolean)
+  ).size;
+  const providersWithInactiveConnections = new Set(
+    providerCounts.filter((row) => row.inactive > 0).map((row) => providerIdentity(row.provider)).filter(Boolean)
+  ).size;
+
+  return {
+    ok: true,
+    kind: "router_overview",
+    summary: {
+      totalModels: models.length,
+      totalConnections: providerCounts.reduce((sum, row) => sum + row.total, 0),
+      activeConnections: providerCounts.reduce((sum, row) => sum + row.active, 0),
+      inactiveConnections: providerCounts.reduce((sum, row) => sum + row.inactive, 0),
+
+      totalProviders: allProviderIds.size,
+      registeredProviderTypes,
+      configuredProviders,
+      activeProviders,
+      inactiveOnlyProviders,
+      providersWithInactiveConnections,
+      connectedProviders: activeProviders,
+      providerNodes: nodes.length,
+      proxyPools: pools.length,
+      combos: combos.length,
+      customModels: customModels.length,
+      totalApiKeys: keys.length,
+      activeApiKeys: keys.filter((key) => key.isActive !== false).length,
+    },
+    providerCounts,
+    admission: routerAdmission.snapshot(),
+    settings: {
+      requireApiKey: settings.requireApiKey === true,
+      requireLogin: settings.requireLogin !== false,
+      tunnelDashboardAccess: settings.tunnelDashboardAccess === true,
+      mediaProviders: Array.isArray(settings.mediaProviders) ? settings.mediaProviders : [],
+    },
+  };
+}
+
+async function runRouterTool(body = {}) {
+  const action = stringValue(body.action, 40).toLowerCase() || "overview";
+  if (action === "overview" || action === "status") return overview();
+
+  if (action === "models") {
+    const query = stringValue(body.query, 120).toLowerCase();
+    const limit = limitValue(body.limit, 50);
+    const models = (await getModelsSnapshot()).map(safeModel).filter((model) => {
+      if (!query) return true;
+      return `${model.id} ${model.owned_by || ""}`.toLowerCase().includes(query);
+    });
+    return { ok: true, kind: "router_models", total: models.length, models: models.slice(0, limit), truncated: models.length > limit };
+  }
+
+  if (action === "connections") {
+    const provider = stringValue(body.provider, 80).toLowerCase();
+    const activeOnly = body.active_only === true;
+    const limit = limitValue(body.limit, 50);
+    const page = await getProviderConnectionsPaged({
+      ...(provider ? { provider } : {}),
+      ...(activeOnly ? { isActive: true } : {}),
+      page: 1,
+      pageSize: limit,
+    });
+    return {
+      ok: true,
+      kind: "router_connections",
+      total: page.total,
+      connections: page.connections.map(safeConnection),
+      truncated: page.total > limit,
+    };
+  }
+
+  if (action === "api_keys") {
+    const includeRevoked = body.include_revoked === true;
+    const limit = limitValue(body.limit, 50);
+    const all = await getApiKeys();
+    const filtered = includeRevoked ? all : all.filter((key) => key.isActive !== false);
+    return { ok: true, kind: "router_api_keys", total: filtered.length, keys: filtered.slice(0, limit).map(safeApiKey), truncated: filtered.length > limit };
+  }
+
+  throw new RouterToolInputError("Unknown router action. Use overview, models, connections, or api_keys");
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    return NextResponse.json(await runRouterTool(body));
+  } catch (error) {
+    const status = error instanceof RouterToolInputError ? 400 : 500;
+    return NextResponse.json({ ok: false, error: error instanceof Error ? error.message : "Router tool failed" }, { status });
+  }
+}

package/src/routes/api/chat/tools/search/route.js

@@ -0,0 +1,362 @@
+import { NextResponse } from "@/next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const MAX_QUERY_LENGTH = 300;
+const DEFAULT_RESULT_COUNT = 5;
+const MAX_RESULT_COUNT = 8;
+const MAX_RESPONSE_BYTES = 1_500_000;
+const MAX_TITLE_LENGTH = 180;
+const MAX_URL_LENGTH = 2_000;
+const MAX_SNIPPET_LENGTH = 700;
+const SEARCH_TIMEOUT_MS = 10_000;
+const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
+
+class SearchInputError extends Error {}
+class SearchProviderError extends Error {}
+
+function text(value, maxLength) {
+  if (typeof value !== "string") return "";
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}…` : normalized;
+}
+
+function decodeHtml(value) {
+  return String(value || "")
+    .replaceAll("&", "&")
+    .replaceAll(""", '"')
+    .replaceAll("'", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
+    .replace(/&#x([\da-f]+);/gi, (_, code) => String.fromCodePoint(Number.parseInt(code, 16)));
+}
+
+function queryInput(value) {
+  if (typeof value !== "string" || !value.trim()) throw new SearchInputError("Search query is required");
+  const query = value.trim();
+  if (query.length > MAX_QUERY_LENGTH) throw new SearchInputError(`Search query must be ${MAX_QUERY_LENGTH} characters or fewer`);
+  return query;
+}
+
+function resultCount(value) {
+  if (value === undefined || value === null || value === "") return DEFAULT_RESULT_COUNT;
+  const count = Number(value);
+  if (!Number.isInteger(count) || count < 1 || count > MAX_RESULT_COUNT) {
+    throw new SearchInputError(`max_results must be an integer from 1 to ${MAX_RESULT_COUNT}`);
+  }
+  return count;
+}
+
+function safeUrl(value) {
+  if (typeof value !== "string" || !value.trim()) return "";
+  try {
+    const parsed = new URL(decodeHtml(value.trim()));
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return "";
+    parsed.hash = "";
+    return parsed.toString().slice(0, MAX_URL_LENGTH);
+  } catch {
+    return "";
+  }
+}
+
+function normalizeResult(item) {
+  if (!item || typeof item !== "object") return null;
+  const fallbackTitle = typeof item.Text === "string" ? item.Text.split(" - ")[0] : "";
+  const title = text(item.title ?? item.name ?? item.Heading ?? fallbackTitle, MAX_TITLE_LENGTH);
+  const url = safeUrl(item.url ?? item.link ?? item.FirstURL ?? item.AbstractURL);
+  const snippet = text(item.snippet ?? item.description ?? item.content ?? item.Text ?? item.AbstractText, MAX_SNIPPET_LENGTH);
+  if (!url || (!title && !snippet)) return null;
+  return { title: title || url, url, snippet };
+}
+
+function unwrapBingUrl(value) {
+  try {
+    const parsed = new URL(decodeHtml(value));
+    if (parsed.hostname !== "www.bing.com" || !parsed.pathname.startsWith("/ck/")) return value;
+    const encoded = parsed.searchParams.get("u") || "";
+    const payload = encoded.startsWith("a1") ? encoded.slice(2) : encoded;
+    const decoded = Buffer.from(payload, "base64url").toString("utf8");
+    return /^https?:\/\//i.test(decoded) ? decoded : value;
+  } catch {
+    return value;
+  }
+}
+
+function uniqueResults(items, limit) {
+  const seen = new Set();
+  const results = [];
+  for (const item of items) {
+    const result = normalizeResult(item);
+    if (!result || seen.has(result.url)) continue;
+    seen.add(result.url);
+    results.push(result);
+    if (results.length >= limit) break;
+  }
+  return results;
+}
+
+async function requestJson(url, options = {}) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      cache: "no-store",
+      signal: controller.signal,
+    });
+    const raw = await response.text();
+    if (raw.length > MAX_RESPONSE_BYTES) throw new SearchProviderError("Search provider response was too large");
+    let payload = null;
+    try { payload = raw ? JSON.parse(raw) : null; } catch { throw new SearchProviderError("Search provider returned invalid data"); }
+    if (!response.ok) throw new SearchProviderError(`Search provider returned HTTP ${response.status}`);
+    return payload;
+  } catch (error) {
+    if (error instanceof SearchProviderError) throw error;
+    if (error?.name === "AbortError") throw new SearchProviderError("Search provider timed out");
+    throw new SearchProviderError("Search provider could not be reached");
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function requestText(url, options = {}) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      cache: "no-store",
+      signal: controller.signal,
+    });
+    const raw = await response.text();
+    if (raw.length > MAX_RESPONSE_BYTES) throw new SearchProviderError("Search provider response was too large");
+    if (!response.ok) throw new SearchProviderError(`Search provider returned HTTP ${response.status}`);
+    return raw;
+  } catch (error) {
+    if (error instanceof SearchProviderError) throw error;
+    if (error?.name === "AbortError") throw new SearchProviderError("Search provider timed out");
+    throw new SearchProviderError("Search provider could not be reached");
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function parseMcpMessage(raw) {
+  for (const block of String(raw || "").split(/\n\s*\n/)) {
+    const dataLine = block.split(/\r?\n/).find((line) => line.startsWith("data:"));
+    if (!dataLine) continue;
+    try {
+      const payload = JSON.parse(dataLine.slice(5).trim());
+      if (payload?.error) throw new SearchProviderError("Search provider returned an MCP error");
+      if (payload?.result) return payload.result;
+    } catch (error) {
+      if (error instanceof SearchProviderError) throw error;
+    }
+  }
+  throw new SearchProviderError("Search provider returned no results");
+}
+
+async function searchTavily(query, limit, apiKey) {
+  const payload = await requestJson("https://api.tavily.com/search", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Accept: "application/json" },
+    body: JSON.stringify({
+      api_key: apiKey,
+      query,
+      search_depth: "basic",
+      topic: "general",
+      max_results: limit,
+      include_answer: false,
+      include_raw_content: false,
+    }),
+  });
+  const results = uniqueResults(Array.isArray(payload?.results) ? payload.results : [], limit);
+  return { provider: "tavily", results };
+}
+
+async function searchExa(query, limit) {
+  const raw = await requestText(EXA_MCP_URL, {
+    method: "POST",
+    headers: { Accept: "application/json, text/event-stream", "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name: "web_search_exa", arguments: { query, numResults: limit } },
+    }),
+  });
+  const result = parseMcpMessage(raw);
+  const content = Array.isArray(result?.content)
+    ? result.content.filter((item) => item?.type === "text").map((item) => item.text).join("\n")
+    : "";
+  const candidates = content
+    .split(/\n(?=Title:\s)/)
+    .map((entry) => {
+      const title = entry.match(/^Title:\s*(.+)$/m)?.[1] || "";
+      const url = entry.match(/^URL:\s*(.+)$/m)?.[1] || "";
+      const highlights = entry.match(/^Highlights:\s*([\s\S]*)$/m)?.[1] || entry;
+      return { title, url, snippet: highlights.replace(/\n---\s*$/g, "") };
+    });
+  return { provider: "exa", results: uniqueResults(candidates, limit) };
+}
+
+async function searchBrave(query, limit, apiKey) {
+  const url = new URL("https://api.search.brave.com/res/v1/web/search");
+  url.searchParams.set("q", query);
+  url.searchParams.set("count", String(limit));
+  url.searchParams.set("safesearch", "moderate");
+  const payload = await requestJson(url, {
+    headers: {
+      Accept: "application/json",
+      "Accept-Encoding": "gzip",
+      "X-Subscription-Token": apiKey,
+    },
+  });
+  const results = uniqueResults(Array.isArray(payload?.web?.results) ? payload.web.results : [], limit);
+  return { provider: "brave", results };
+}
+
+function collectDuckDuckGoTopics(topics, output) {
+  if (!Array.isArray(topics)) return;
+  for (const topic of topics) {
+    if (Array.isArray(topic?.Topics)) collectDuckDuckGoTopics(topic.Topics, output);
+    else output.push(topic);
+  }
+}
+
+function stripMarkup(value) {
+  return text(String(value || "").replace(/<[^>]*>/g, "")
+    .replaceAll("&amp;", "&")
+    .replaceAll("&quot;", '"')
+    .replaceAll("&#39;", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">"), MAX_SNIPPET_LENGTH);
+}
+
+async function searchDuckDuckGo(query, limit) {
+  const url = new URL("https://api.duckduckgo.com/");
+  url.searchParams.set("q", query);
+  url.searchParams.set("format", "json");
+  url.searchParams.set("no_html", "1");
+  url.searchParams.set("no_redirect", "1");
+  url.searchParams.set("skip_disambig", "1");
+  const payload = await requestJson(url, {
+    headers: { Accept: "application/json", "User-Agent": "SwayRouter SwayChat/1.0" },
+  });
+  const candidates = [];
+  if (payload?.AbstractURL || payload?.AbstractText) {
+    candidates.push({
+      title: payload.Heading || query,
+      url: payload.AbstractURL,
+      snippet: payload.AbstractText,
+    });
+  }
+  if (payload?.DefinitionURL || payload?.Definition) {
+    candidates.push({
+      title: `${query} definition`,
+      url: payload.DefinitionURL,
+      snippet: payload.Definition,
+    });
+  }
+  if (Array.isArray(payload?.Results)) candidates.push(...payload.Results);
+  const topics = [];
+  collectDuckDuckGoTopics(payload?.RelatedTopics, topics);
+  candidates.push(...topics);
+  return {
+    provider: "duckduckgo",
+    results: uniqueResults(candidates, limit),
+    ...(text(payload?.AbstractText, MAX_SNIPPET_LENGTH) ? { answer: text(payload.AbstractText, MAX_SNIPPET_LENGTH) } : {}),
+  };
+}
+
+async function searchBing(query, limit) {
+  const url = new URL("https://www.bing.com/search");
+  url.searchParams.set("q", query);
+  url.searchParams.set("count", String(limit));
+  url.searchParams.set("setlang", "en-US");
+  const html = await requestText(url, {
+    headers: {
+      Accept: "text/html,application/xhtml+xml",
+      "Accept-Language": "en-US,en;q=0.8",
+      "User-Agent": "SwayRouter SwayChat/1.0",
+    },
+  });
+  const items = html.match(/<li\b[^>]*class=(['"])[^'"]*\bb_algo\b[^'"]*\1[^>]*>[\s\S]*?<\/li>/gi) || [];
+  const candidates = items.map((item) => {
+    const link = item.match(/<h2\b[\s\S]*?<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/i);
+    const snippet = item.match(/<p\b[^>]*>([\s\S]*?)<\/p>/i);
+    return {
+      title: link ? decodeHtml(link[2].replace(/<[^>]*>/g, "")) : "",
+      url: link ? unwrapBingUrl(link[1]) : "",
+      snippet: snippet ? decodeHtml(snippet[1].replace(/<[^>]*>/g, "")) : "",
+    };
+  });
+  return { provider: "bing", results: uniqueResults(candidates, limit) };
+}
+
+async function searchWikipedia(query, limit) {
+  const url = new URL("https://en.wikipedia.org/w/api.php");
+  url.searchParams.set("action", "query");
+  url.searchParams.set("list", "search");
+  url.searchParams.set("srsearch", query);
+  url.searchParams.set("srlimit", String(limit));
+  url.searchParams.set("format", "json");
+  url.searchParams.set("formatversion", "2");
+  const payload = await requestJson(url, {
+    headers: { Accept: "application/json", "User-Agent": "SwayRouter SwayChat/1.0" },
+  });
+  const results = uniqueResults(
+    (Array.isArray(payload?.query?.search) ? payload.query.search : [])
+      .map((item) => ({
+        title: item?.title,
+        url: Number.isInteger(item?.pageid) ? `https://en.wikipedia.org/?curid=${item.pageid}` : "",
+        snippet: stripMarkup(item?.snippet),
+      })),
+    limit,
+  );
+  return { provider: "wikipedia", results };
+}
+
+async function searchWeb(query, limit) {
+  const tavilyKey = typeof process.env.TAVILY_API_KEY === "string" ? process.env.TAVILY_API_KEY.trim() : "";
+  const braveKey = typeof process.env.BRAVE_SEARCH_API_KEY === "string" ? process.env.BRAVE_SEARCH_API_KEY.trim() : "";
+
+  if (tavilyKey) {
+    try { return await searchTavily(query, limit, tavilyKey); } catch {                      }
+  }
+  if (braveKey) {
+    try { return await searchBrave(query, limit, braveKey); } catch {                      }
+  }
+
+  try {
+    const exa = await searchExa(query, limit);
+    if (exa.results.length) return exa;
+  } catch {                                  }
+  try {
+    const bing = await searchBing(query, limit);
+    if (bing.results.length) return bing;
+  } catch {                                  }
+  try {
+    const duckDuckGo = await searchDuckDuckGo(query, limit);
+    if (duckDuckGo.results.length || duckDuckGo.answer) return duckDuckGo;
+  } catch {                                     }
+  return await searchWikipedia(query, limit);
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const query = queryInput(body?.query);
+    const limit = resultCount(body?.max_results);
+    const result = await searchWeb(query, limit);
+    return NextResponse.json({ ok: true, query, ...result });
+  } catch (error) {
+    const status = error instanceof SearchInputError ? 400 : 502;
+    return NextResponse.json({
+      ok: false,
+      error: error instanceof Error ? error.message : "Web search failed",
+    }, { status });
+  }
+}