fast-web-search-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2540 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import * as cheerio from 'cheerio';
+import { URL as URL$1 } from 'url';
+
+// src/config/defaults.ts
+var DEFAULTS = {
+  // Server
+  logLevel: "warn",
+  logFormat: "text",
+  redactQueries: true,
+  // Search defaults
+  defaultRegion: "us-en",
+  defaultLanguage: "en",
+  safeSearch: "moderate",
+  // Providers
+  providers: ["duckduckgo", "bing", "wikipedia"],
+  providerStrategy: "fallback",
+  // Timeouts (ms)
+  searchTimeoutMs: 2e4,
+  providerTimeoutMs: 1e4,
+  fetchTimeoutMs: 15e3,
+  researchTimeoutMs: 45e3,
+  // Limits
+  maxSearchResults: 25,
+  maxFetchCharacters: 1e5,
+  maxSearchBodyBytes: 3145728,
+  // 3 MB
+  maxPageBodyBytes: 8388608,
+  // 8 MB
+  // Concurrency
+  maxConcurrentSearches: 2,
+  maxConcurrentFetches: 3,
+  maxOutboundRequests: 4,
+  // Cache
+  cacheEnabled: true,
+  searchCacheTtlMs: 12e4,
+  // 2 minutes
+  newsCacheTtlMs: 6e4,
+  // 1 minute
+  pageCacheTtlMs: 18e5,
+  // 30 minutes
+  cacheMaxEntries: 250,
+  // Privacy
+  globalExcludeDomains: [],
+  // Optional
+  searxngUrl: "",
+  diagnosticsEnabled: false
+};
+
+// src/config/environment.ts
+function parseBool(value, fallback) {
+  if (value === void 0) return fallback;
+  return value === "true" || value === "1";
+}
+function parseIntSafe(value, fallback) {
+  if (value === void 0) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed) || parsed < 0) return fallback;
+  return parsed;
+}
+function parseStringList(value) {
+  if (!value) return void 0;
+  const items = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+function parseEnvironment(env = process.env) {
+  return {
+    logLevel: env.FWSMCP_LOG_LEVEL || DEFAULTS.logLevel,
+    logFormat: env.FWSMCP_LOG_FORMAT || DEFAULTS.logFormat,
+    redactQueries: parseBool(env.FWSMCP_REDACT_QUERIES, DEFAULTS.redactQueries),
+    defaultRegion: env.FWSMCP_DEFAULT_REGION || DEFAULTS.defaultRegion,
+    defaultLanguage: env.FWSMCP_DEFAULT_LANGUAGE || DEFAULTS.defaultLanguage,
+    safeSearch: env.FWSMCP_SAFE_SEARCH || DEFAULTS.safeSearch,
+    providers: parseStringList(env.FWSMCP_PROVIDERS) || [...DEFAULTS.providers],
+    providerStrategy: env.FWSMCP_PROVIDER_STRATEGY || DEFAULTS.providerStrategy,
+    searchTimeoutMs: parseIntSafe(env.FWSMCP_SEARCH_TIMEOUT_MS, DEFAULTS.searchTimeoutMs),
+    providerTimeoutMs: parseIntSafe(env.FWSMCP_PROVIDER_TIMEOUT_MS, DEFAULTS.providerTimeoutMs),
+    fetchTimeoutMs: parseIntSafe(env.FWSMCP_FETCH_TIMEOUT_MS, DEFAULTS.fetchTimeoutMs),
+    researchTimeoutMs: parseIntSafe(env.FWSMCP_RESEARCH_TIMEOUT_MS, DEFAULTS.researchTimeoutMs),
+    maxSearchResults: parseIntSafe(env.FWSMCP_MAX_SEARCH_RESULTS, DEFAULTS.maxSearchResults),
+    maxFetchCharacters: parseIntSafe(env.FWSMCP_MAX_FETCH_CHARACTERS, DEFAULTS.maxFetchCharacters),
+    maxSearchBodyBytes: parseIntSafe(env.FWSMCP_MAX_SEARCH_BODY_BYTES, DEFAULTS.maxSearchBodyBytes),
+    maxPageBodyBytes: parseIntSafe(env.FWSMCP_MAX_PAGE_BODY_BYTES, DEFAULTS.maxPageBodyBytes),
+    maxConcurrentSearches: parseIntSafe(env.FWSMCP_MAX_CONCURRENT_SEARCHES, DEFAULTS.maxConcurrentSearches),
+    maxConcurrentFetches: parseIntSafe(env.FWSMCP_MAX_CONCURRENT_FETCHES, DEFAULTS.maxConcurrentFetches),
+    maxOutboundRequests: parseIntSafe(env.FWSMCP_MAX_OUTBOUND_REQUESTS, DEFAULTS.maxOutboundRequests),
+    cacheEnabled: parseBool(env.FWSMCP_CACHE_ENABLED, DEFAULTS.cacheEnabled),
+    searchCacheTtlMs: parseIntSafe(env.FWSMCP_SEARCH_CACHE_TTL_MS, DEFAULTS.searchCacheTtlMs),
+    newsCacheTtlMs: parseIntSafe(env.FWSMCP_NEWS_CACHE_TTL_MS, DEFAULTS.newsCacheTtlMs),
+    pageCacheTtlMs: parseIntSafe(env.FWSMCP_PAGE_CACHE_TTL_MS, DEFAULTS.pageCacheTtlMs),
+    cacheMaxEntries: parseIntSafe(env.FWSMCP_CACHE_MAX_ENTRIES, DEFAULTS.cacheMaxEntries),
+    globalExcludeDomains: parseStringList(env.FWSMCP_GLOBAL_EXCLUDE_DOMAINS) ?? [],
+    searxngUrl: env.FWSMCP_SEARXNG_URL || DEFAULTS.searxngUrl,
+    diagnosticsEnabled: parseBool(env.FWSMCP_DIAGNOSTICS_ENABLED, DEFAULTS.diagnosticsEnabled)
+  };
+}
+
+// src/observability/logger.ts
+var LOG_LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  minLevel;
+  format;
+  redact;
+  constructor(options = {}) {
+    this.minLevel = LOG_LEVEL_ORDER[options.level ?? "warn"];
+    this.format = options.format ?? "text";
+    this.redact = options.redact ?? true;
+  }
+  shouldLog(level) {
+    return LOG_LEVEL_ORDER[level] >= this.minLevel;
+  }
+  redactValue(value) {
+    if (!this.redact) return value;
+    if (typeof value === "string" && value.length > 0) {
+      if (value.length > 30 && !value.includes("://")) {
+        return "[REDACTED]";
+      }
+    }
+    return value;
+  }
+  formatText(entry) {
+    const parts = [`${entry.timestamp} [${entry.level.toUpperCase()}]`, entry.message];
+    for (const [key, value] of Object.entries(entry)) {
+      if (key === "level" || key === "message" || key === "timestamp") continue;
+      parts.push(`${key}=${JSON.stringify(this.redactValue(value))}`);
+    }
+    return parts.join(" ");
+  }
+  formatJson(entry) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(entry)) {
+      cleaned[key] = key === "message" || key === "timestamp" || key === "level" ? value : this.redactValue(value);
+    }
+    return JSON.stringify(cleaned);
+  }
+  log(level, message, data) {
+    if (!this.shouldLog(level)) return;
+    const entry = {
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...data
+    };
+    const formatted = this.format === "json" ? this.formatJson(entry) : this.formatText(entry);
+    process.stderr.write(formatted + "\n");
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+};
+var loggerInstance = null;
+function getLogger(options) {
+  if (!loggerInstance) {
+    loggerInstance = new Logger(options);
+  }
+  return loggerInstance;
+}
+function resetLogger() {
+  loggerInstance = null;
+}
+
+// src/config/load-config.ts
+async function loadConfig() {
+  const envConfig = parseEnvironment();
+  let fileConfig = {};
+  const configPath = process.env.FWSMCP_CONFIG_FILE;
+  if (configPath) {
+    try {
+      const { readFile } = await import('fs/promises');
+      const raw = await readFile(configPath, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch (err) {
+      const logger2 = getLogger();
+      logger2.warn("Failed to load config file, using environment defaults", {
+        path: configPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const defaults = DEFAULTS;
+  const envConfigRaw = envConfig;
+  const merged = { ...defaults, ...fileConfig, ...envConfigRaw };
+  const config = merged;
+  const logger = getLogger({ level: config.logLevel });
+  logger.info("Configuration loaded", {
+    providers: config.providers,
+    strategy: config.providerStrategy,
+    cacheEnabled: config.cacheEnabled,
+    diagnosticsEnabled: config.diagnosticsEnabled
+  });
+  return config;
+}
+function createServer(_config) {
+  const logger = getLogger();
+  const server = new McpServer({
+    name: "fast-web-search-mcp",
+    version: "0.1.0"
+  });
+  logger.info("MCP server created", {
+    name: "fast-web-search-mcp",
+    version: "0.1.0"
+  });
+  return server;
+}
+z.enum(["debug", "info", "warn", "error"]);
+z.enum(["text", "json"]);
+var SafeSearchSchema = z.enum(["off", "moderate", "strict"]);
+var ProviderStrategySchema = z.enum(["fallback", "merge"]);
+var TimeRangeSchema = z.enum(["day", "week", "month", "year", "any"]);
+var OutputFormatSchema = z.enum(["markdown", "text"]);
+var SearchInputSchema = z.object({
+  query: z.string().min(1).max(500),
+  max_results: z.number().int().min(1).max(25).default(10),
+  providers: z.array(z.string()).optional(),
+  strategy: ProviderStrategySchema.default("fallback"),
+  region: z.string().default("us-en"),
+  language: z.string().default("en"),
+  time_range: TimeRangeSchema.default("any"),
+  safe_search: SafeSearchSchema.default("moderate"),
+  include_domains: z.array(z.string()).max(20).optional(),
+  exclude_domains: z.array(z.string()).max(50).optional(),
+  deduplicate: z.boolean().default(true),
+  timeout_ms: z.number().int().min(1e3).max(6e4).optional()
+});
+var NewsSearchInputSchema = z.object({
+  query: z.string().min(1).max(500),
+  max_results: z.number().int().min(1).max(25).default(10),
+  providers: z.array(z.string()).optional(),
+  region: z.string().default("us-en"),
+  language: z.string().default("en"),
+  time_range: z.enum(["day", "week", "month"]).default("week"),
+  include_domains: z.array(z.string()).max(20).optional(),
+  exclude_domains: z.array(z.string()).max(50).optional(),
+  timeout_ms: z.number().int().min(1e3).max(6e4).optional()
+});
+var FetchUrlInputSchema = z.object({
+  url: z.string().refine(
+    (val) => {
+      try {
+        const url = new URL(val);
+        return url.protocol === "http:" || url.protocol === "https:";
+      } catch {
+        return false;
+      }
+    },
+    { message: "Must be a valid HTTP or HTTPS URL" }
+  ),
+  output: OutputFormatSchema.default("markdown"),
+  max_characters: z.number().int().min(100).max(1e5).default(2e4),
+  include_metadata: z.boolean().default(true),
+  include_links: z.boolean().default(false),
+  timeout_ms: z.number().int().min(1e3).max(6e4).optional()
+});
+var SearchAndFetchInputSchema = z.object({
+  query: z.string().min(1).max(500),
+  search_results: z.number().int().min(1).max(20).default(8),
+  fetch_results: z.number().int().min(1).max(5).default(3),
+  providers: z.array(z.string()).optional(),
+  strategy: ProviderStrategySchema.default("fallback"),
+  region: z.string().default("us-en"),
+  language: z.string().default("en"),
+  time_range: TimeRangeSchema.default("any"),
+  include_domains: z.array(z.string()).max(20).optional(),
+  exclude_domains: z.array(z.string()).max(50).optional(),
+  max_characters_per_page: z.number().int().min(1e3).max(1e5).default(2e4),
+  total_character_budget: z.number().int().min(1e3).max(5e5).default(1e5),
+  timeout_ms: z.number().int().min(1e3).max(12e4).optional()
+});
+z.object({});
+var SearchResultSchema = z.object({
+  position: z.number(),
+  title: z.string(),
+  url: z.string(),
+  display_url: z.string().optional(),
+  snippet: z.string().optional(),
+  provider: z.string(),
+  source_type: z.enum(["web", "news", "reference"]),
+  published_at: z.string().optional(),
+  crawled_at: z.string().optional(),
+  language: z.string().optional(),
+  domain: z.string(),
+  score: z.number().optional()
+});
+var ProviderAttemptSchema = z.object({
+  provider: z.string(),
+  success: z.boolean(),
+  duration_ms: z.number(),
+  result_count: z.number(),
+  error: z.string().optional(),
+  warnings: z.array(z.string()).optional()
+});
+z.object({
+  query: z.string(),
+  results: z.array(SearchResultSchema),
+  provider_attempts: z.array(ProviderAttemptSchema),
+  cached: z.boolean(),
+  partial: z.boolean(),
+  warnings: z.array(z.string()),
+  duration_ms: z.number()
+});
+var FetchedPageSchema = z.object({
+  url: z.string(),
+  title: z.string().optional(),
+  content_type: z.string(),
+  content: z.string(),
+  character_count: z.number(),
+  fetched_at: z.string(),
+  warnings: z.array(z.string())
+});
+var FetchFailureSchema = z.object({
+  url: z.string(),
+  error: z.string(),
+  code: z.string()
+});
+z.object({
+  query: z.string(),
+  search_results: z.array(SearchResultSchema),
+  pages: z.array(FetchedPageSchema),
+  failures: z.array(FetchFailureSchema),
+  partial: z.boolean(),
+  duration_ms: z.number()
+});
+
+// src/http/headers.ts
+var DEFAULT_HEADERS = {
+  Accept: "text/html,application/xhtml+xml,application/json;q=0.9,text/plain;q=0.8",
+  "Accept-Language": "en-US,en;q=0.8",
+  "Cache-Control": "no-cache"
+};
+var USER_AGENT = "fast-web-search-mcp/0.1 (+local-personal-mcp)";
+function getHeaders(customHeaders) {
+  return {
+    ...DEFAULT_HEADERS,
+    "User-Agent": USER_AGENT,
+    ...customHeaders
+  };
+}
+
+// src/http/errors.ts
+var HttpError = class extends Error {
+  constructor(message, statusCode, url, retryable = false) {
+    super(message);
+    this.statusCode = statusCode;
+    this.url = url;
+    this.retryable = retryable;
+    this.name = "HttpError";
+  }
+  statusCode;
+  url;
+  retryable;
+};
+var HttpTimeoutError = class extends Error {
+  constructor(message, url, timeoutMs) {
+    super(message);
+    this.url = url;
+    this.timeoutMs = timeoutMs;
+    this.name = "HttpTimeoutError";
+  }
+  url;
+  timeoutMs;
+};
+var HttpBodyLimitError = class extends Error {
+  constructor(message, url, limitBytes) {
+    super(message);
+    this.url = url;
+    this.limitBytes = limitBytes;
+    this.name = "HttpBodyLimitError";
+  }
+  url;
+  limitBytes;
+};
+var HttpRedirectError = class extends Error {
+  constructor(message, url, redirectCount) {
+    super(message);
+    this.url = url;
+    this.redirectCount = redirectCount;
+    this.name = "HttpRedirectError";
+  }
+  url;
+  redirectCount;
+};
+
+// src/http/client.ts
+async function httpFetch(options) {
+  const logger = getLogger();
+  const {
+    url,
+    method = "GET",
+    timeoutMs = 15e3,
+    maxBodyBytes = 8388608,
+    // 8 MB
+    maxRedirects = 5
+  } = options;
+  const headers = getHeaders(options.headers);
+  logger.debug("HTTP request", { url: new URL(url).hostname, method });
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    let currentUrl = url;
+    let redirectCount = 0;
+    while (true) {
+      const response = await fetch(currentUrl, {
+        method,
+        headers,
+        signal: controller.signal,
+        redirect: "manual"
+        // We handle redirects manually for validation
+      });
+      if (response.status >= 300 && response.status < 400) {
+        redirectCount++;
+        if (redirectCount > maxRedirects) {
+          throw new HttpRedirectError(
+            `Too many redirects (${redirectCount})`,
+            url,
+            redirectCount
+          );
+        }
+        const location = response.headers.get("location");
+        if (!location) {
+          throw new HttpError("Redirect without Location header", response.status, url);
+        }
+        try {
+          const redirectUrl = new URL(location, currentUrl);
+          currentUrl = redirectUrl.toString();
+        } catch {
+          throw new HttpError("Invalid redirect URL", response.status, url);
+        }
+        logger.debug("HTTP redirect", { from: new URL(url).hostname, to: new URL(currentUrl).hostname });
+        continue;
+      }
+      if (!response.ok) {
+        const retryable = response.status === 429 || response.status >= 500;
+        throw new HttpError(
+          `HTTP ${response.status}: ${response.statusText}`,
+          response.status,
+          url,
+          retryable
+        );
+      }
+      const contentLength = response.headers.get("content-length");
+      if (contentLength && Number.parseInt(contentLength, 10) > maxBodyBytes) {
+        throw new HttpBodyLimitError(
+          `Response body exceeds ${maxBodyBytes} bytes`,
+          url,
+          maxBodyBytes
+        );
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        return {
+          status: response.status,
+          headers: response.headers,
+          body: "",
+          finalUrl: currentUrl
+        };
+      }
+      const chunks = [];
+      let totalBytes = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        totalBytes += value.length;
+        if (totalBytes > maxBodyBytes) {
+          reader.cancel();
+          throw new HttpBodyLimitError(
+            `Response body exceeds ${maxBodyBytes} bytes`,
+            url,
+            maxBodyBytes
+          );
+        }
+        chunks.push(value);
+      }
+      const body = new TextDecoder().decode(Buffer.concat(chunks));
+      return {
+        status: response.status,
+        headers: response.headers,
+        body,
+        finalUrl: currentUrl
+      };
+    }
+    throw new HttpError("Unexpected end of redirect chain", 0, url);
+  } catch (err) {
+    if (err instanceof HttpError || err instanceof HttpTimeoutError || err instanceof HttpBodyLimitError || err instanceof HttpRedirectError) {
+      throw err;
+    }
+    if (err instanceof DOMException && err.name === "AbortError") {
+      throw new HttpTimeoutError(`Request timed out after ${timeoutMs}ms`, url, timeoutMs);
+    }
+    throw new HttpError(
+      `Network error: ${err instanceof Error ? err.message : String(err)}`,
+      0,
+      url,
+      true
+    );
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+function detectChallenge($) {
+  const challengeSelectors = [
+    "#challenge-form",
+    ".challenge-form",
+    '[id*="captcha"]',
+    '[class*="captcha"]',
+    "#botchallenge",
+    ".bot-detect"
+  ];
+  for (const selector of challengeSelectors) {
+    if ($(selector).length > 0) return true;
+  }
+  const bodyText = $("body").text().toLowerCase();
+  const challengePhrases = [
+    "please confirm you are human",
+    "bot detected",
+    "access denied",
+    "please verify",
+    "unusual traffic",
+    "automated queries"
+  ];
+  for (const phrase of challengePhrases) {
+    if (bodyText.includes(phrase)) return true;
+  }
+  return false;
+}
+function detectRateLimited($) {
+  const bodyText = $("body").text().toLowerCase();
+  return bodyText.includes("too many requests") || bodyText.includes("rate limit");
+}
+function parseDuckDuckGoHtml(html) {
+  const $ = cheerio.load(html);
+  const warnings = [];
+  if (detectChallenge($)) {
+    return {
+      results: [],
+      hasChallenge: true,
+      isRateLimited: false,
+      isEmpty: false,
+      warnings: ["DuckDuckGo challenge/captcha detected"]
+    };
+  }
+  if (detectRateLimited($)) {
+    return {
+      results: [],
+      hasChallenge: false,
+      isRateLimited: true,
+      isEmpty: false,
+      warnings: ["DuckDuckGo rate limit detected"]
+    };
+  }
+  const results = [];
+  const resultSelectors = [".result", ".web-result", ".nrn-react-div"];
+  let $results = $([]);
+  for (const selector of resultSelectors) {
+    $results = $(selector);
+    if ($results.length > 0) break;
+  }
+  $results.each((_index, element) => {
+    const $el = $(element);
+    const $link = $el.find("a[href]").first();
+    const href = $link.attr("href");
+    const title = $el.find("a.result__a, a.result-link, h2 a, .result__title a").first().text().trim();
+    if (!title || !href) return;
+    let url = href;
+    if (href.includes("//duckduckgo.com/l/")) {
+      try {
+        const ddgUrl = new URL(href, "https://duckduckgo.com");
+        const actualUrl = ddgUrl.searchParams.get("uddg");
+        if (actualUrl) {
+          url = decodeURIComponent(actualUrl);
+        }
+      } catch {
+      }
+    }
+    const snippet = $el.find(".result__snippet, .result__body, .snippet").first().text().trim();
+    const displayUrl = $el.find(".result__url, .result__display-url").first().text().trim();
+    results.push({
+      title,
+      url,
+      snippet: snippet || void 0,
+      displayUrl: displayUrl || void 0
+    });
+  });
+  if (results.length === 0) {
+    const $main = $("body");
+    $main.find("a[href]").each((_index, element) => {
+      const $a = $(element);
+      const href = $a.attr("href");
+      const text = $a.text().trim();
+      if (!href || !text || text.length < 5) return;
+      if (href.startsWith("/") || href.includes("duckduckgo.com")) return;
+      if (href.includes("javascript:")) return;
+      if (text.length < 10) return;
+      try {
+        const urlObj = new URL(href);
+        if (urlObj.protocol === "http:" || urlObj.protocol === "https:") {
+          results.push({
+            title: text,
+            url: href
+          });
+        }
+      } catch {
+      }
+    });
+    if (results.length === 0) {
+      warnings.push("No results found \u2014 page structure may have changed");
+    }
+  }
+  return {
+    results: results.slice(0, 25),
+    // Cap at 25
+    hasChallenge: false,
+    isRateLimited: false,
+    isEmpty: results.length === 0,
+    warnings
+  };
+}
+
+// src/providers/duckduckgo/duckduckgo.provider.ts
+var DuckDuckGoProvider = class {
+  id = "duckduckgo";
+  displayName = "DuckDuckGo";
+  capabilities = {
+    web: true,
+    news: false,
+    images: false,
+    timeRange: true,
+    region: true,
+    language: true,
+    safeSearch: true,
+    siteFilter: false
+    // DDG uses !bang syntax, not site: operator in HTML
+  };
+  isConfigured() {
+    return true;
+  }
+  buildSearchUrl(request, context) {
+    const params = new URLSearchParams();
+    params.set("q", request.query);
+    const region = request.region || context.region;
+    if (region) {
+      params.set("kl", region);
+    }
+    const safeSearch = request.safeSearch || context.safeSearch;
+    if (safeSearch === "strict") {
+      params.set("kp", "1");
+    } else if (safeSearch === "moderate") {
+      params.set("kp", "-2");
+    }
+    if (request.timeRange && request.timeRange !== "any") {
+      const dfMap = {
+        day: "d",
+        week: "w",
+        month: "m",
+        year: "y"
+      };
+      const df = dfMap[request.timeRange];
+      if (df) {
+        params.set("df", df);
+      }
+    }
+    return `https://html.duckduckgo.com/html/?${params.toString()}`;
+  }
+  async search(request, context) {
+    const logger = getLogger();
+    const startTime = Date.now();
+    const warnings = [];
+    const url = this.buildSearchUrl(request, context);
+    logger.debug("DuckDuckGo request", { url: new URL(url).hostname, query: "[REDACTED]" });
+    try {
+      const response = await httpFetch({
+        url,
+        timeoutMs: context.timeoutMs,
+        maxBodyBytes: 3145728,
+        // 3 MB
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        }
+      });
+      const parseResult = parseDuckDuckGoHtml(response.body);
+      if (parseResult.hasChallenge) {
+        logger.warn("DuckDuckGo challenge detected");
+        return {
+          provider: this.id,
+          results: [],
+          durationMs: Date.now() - startTime,
+          warnings: ["DuckDuckGo returned a challenge/captcha page"],
+          metadata: { challenge: true }
+        };
+      }
+      if (parseResult.isRateLimited) {
+        logger.warn("DuckDuckGo rate limit detected");
+        return {
+          provider: this.id,
+          results: [],
+          durationMs: Date.now() - startTime,
+          warnings: ["DuckDuckGo rate limit reached"],
+          metadata: { rateLimited: true }
+        };
+      }
+      warnings.push(...parseResult.warnings);
+      let filteredResults = parseResult.results;
+      if (request.includeDomains && request.includeDomains.length > 0) {
+        filteredResults = filteredResults.filter((r) => {
+          try {
+            const hostname = new URL(r.url).hostname.toLowerCase();
+            return request.includeDomains.some(
+              (d) => hostname === d.toLowerCase() || hostname.endsWith("." + d.toLowerCase())
+            );
+          } catch {
+            return false;
+          }
+        });
+      }
+      if (request.excludeDomains && request.excludeDomains.length > 0) {
+        filteredResults = filteredResults.filter((r) => {
+          try {
+            const hostname = new URL(r.url).hostname.toLowerCase();
+            return !request.excludeDomains.some(
+              (d) => hostname === d.toLowerCase() || hostname.endsWith("." + d.toLowerCase())
+            );
+          } catch {
+            return true;
+          }
+        });
+      }
+      const limitedResults = filteredResults.slice(0, request.maxResults);
+      logger.info("DuckDuckGo search completed", {
+        resultCount: limitedResults.length,
+        durationMs: Date.now() - startTime
+      });
+      return {
+        provider: this.id,
+        results: limitedResults,
+        durationMs: Date.now() - startTime,
+        warnings
+      };
+    } catch (err) {
+      const durationMs = Date.now() - startTime;
+      logger.error("DuckDuckGo search failed", {
+        error: err instanceof Error ? err.message : String(err),
+        durationMs
+      });
+      return {
+        provider: this.id,
+        results: [],
+        durationMs,
+        warnings: [`DuckDuckGo request failed: ${err instanceof Error ? err.message : String(err)}`],
+        metadata: { error: true }
+      };
+    }
+  }
+};
+function detectChallenge2($) {
+  const bodyText = $("body").text().toLowerCase();
+  const challengePhrases = [
+    "please complete the security check",
+    "are you a human",
+    "verify you are human",
+    "unusual traffic",
+    "bot detection"
+  ];
+  for (const phrase of challengePhrases) {
+    if (bodyText.includes(phrase)) return true;
+  }
+  return false;
+}
+function detectRateLimited2($) {
+  const bodyText = $("body").text().toLowerCase();
+  return bodyText.includes("too many requests") || bodyText.includes("rate limit");
+}
+function parseBingHtml(html) {
+  const $ = cheerio.load(html);
+  const warnings = [];
+  if (detectChallenge2($)) {
+    return {
+      results: [],
+      hasChallenge: true,
+      isRateLimited: false,
+      isEmpty: false,
+      warnings: ["Bing challenge/captcha detected"]
+    };
+  }
+  if (detectRateLimited2($)) {
+    return {
+      results: [],
+      hasChallenge: false,
+      isRateLimited: true,
+      isEmpty: false,
+      warnings: ["Bing rate limit detected"]
+    };
+  }
+  const results = [];
+  const selectors = ["li.b_algo", ".b_algo", "li.b_algo h2 a"];
+  let $items = $([]);
+  for (const selector of selectors) {
+    if (selector.includes(" a")) {
+      $items = $(selector.replace(/ a$/, "")).filter("li.b_algo, .b_algo");
+    } else {
+      $items = $(selector);
+    }
+    if ($items.length > 0) break;
+  }
+  if ($items.length === 0) {
+    $items = $(".b_algo");
+  }
+  $items.each((_index, element) => {
+    const $el = $(element);
+    const $link = $el.find("h2 a").first();
+    const href = $link.attr("href");
+    const title = $link.text().trim();
+    if (!title || !href) return;
+    let url = href;
+    try {
+      const urlObj = new URL(href);
+      if (urlObj.protocol !== "http:" && urlObj.protocol !== "https:") {
+        return;
+      }
+      url = urlObj.toString();
+    } catch {
+      return;
+    }
+    const snippet = $el.find(".b_caption p, .b_lineclamp2, .b_algoSlug").first().text().trim();
+    const displayUrl = $el.find(".b_attribution cite, .tptt").first().text().trim();
+    results.push({
+      title,
+      url,
+      snippet: snippet || void 0,
+      displayUrl: displayUrl || void 0
+    });
+  });
+  if (results.length === 0) {
+    warnings.push("No results found \u2014 Bing page structure may have changed");
+  }
+  return {
+    results: results.slice(0, 25),
+    hasChallenge: false,
+    isRateLimited: false,
+    isEmpty: results.length === 0,
+    warnings
+  };
+}
+
+// src/providers/bing/bing.provider.ts
+var BingProvider = class {
+  id = "bing";
+  displayName = "Bing";
+  capabilities = {
+    web: true,
+    news: false,
+    images: false,
+    timeRange: true,
+    region: false,
+    language: false,
+    safeSearch: true,
+    siteFilter: true
+    // Bing supports site: operator
+  };
+  isConfigured() {
+    return true;
+  }
+  buildSearchUrl(request, context) {
+    const params = new URLSearchParams();
+    let query = request.query;
+    if (request.includeDomains && request.includeDomains.length > 0) {
+      const siteFilter = request.includeDomains.map((d) => `site:${d}`).join(" OR ");
+      query = `(${siteFilter}) ${query}`;
+    }
+    params.set("q", query);
+    const safeSearch = request.safeSearch || context.safeSearch;
+    if (safeSearch === "strict") {
+      params.set("adlt", "strict");
+    } else if (safeSearch === "off") {
+      params.set("adlt", "off");
+    }
+    params.set("count", String(Math.min(request.maxResults, 20)));
+    return `https://www.bing.com/search?${params.toString()}`;
+  }
+  async search(request, context) {
+    const logger = getLogger();
+    const startTime = Date.now();
+    const warnings = [];
+    const url = this.buildSearchUrl(request, context);
+    logger.debug("Bing request", { url: new URL(url).hostname, query: "[REDACTED]" });
+    try {
+      const response = await httpFetch({
+        url,
+        timeoutMs: context.timeoutMs,
+        maxBodyBytes: 3145728
+        // 3 MB
+      });
+      const parseResult = parseBingHtml(response.body);
+      if (parseResult.hasChallenge) {
+        logger.warn("Bing challenge detected");
+        return {
+          provider: this.id,
+          results: [],
+          durationMs: Date.now() - startTime,
+          warnings: ["Bing returned a challenge/captcha page"],
+          metadata: { challenge: true }
+        };
+      }
+      if (parseResult.isRateLimited) {
+        logger.warn("Bing rate limit detected");
+        return {
+          provider: this.id,
+          results: [],
+          durationMs: Date.now() - startTime,
+          warnings: ["Bing rate limit reached"],
+          metadata: { rateLimited: true }
+        };
+      }
+      warnings.push(...parseResult.warnings);
+      let filteredResults = parseResult.results;
+      if (request.excludeDomains && request.excludeDomains.length > 0) {
+        filteredResults = filteredResults.filter((r) => {
+          try {
+            const hostname = new URL(r.url).hostname.toLowerCase();
+            return !request.excludeDomains.some(
+              (d) => hostname === d.toLowerCase() || hostname.endsWith("." + d.toLowerCase())
+            );
+          } catch {
+            return true;
+          }
+        });
+      }
+      const limitedResults = filteredResults.slice(0, request.maxResults);
+      logger.info("Bing search completed", {
+        resultCount: limitedResults.length,
+        durationMs: Date.now() - startTime
+      });
+      return {
+        provider: this.id,
+        results: limitedResults,
+        durationMs: Date.now() - startTime,
+        warnings
+      };
+    } catch (err) {
+      const durationMs = Date.now() - startTime;
+      logger.error("Bing search failed", {
+        error: err instanceof Error ? err.message : String(err),
+        durationMs
+      });
+      return {
+        provider: this.id,
+        results: [],
+        durationMs,
+        warnings: [`Bing request failed: ${err instanceof Error ? err.message : String(err)}`],
+        metadata: { error: true }
+      };
+    }
+  }
+};
+
+// src/cache/memory-cache.ts
+var MemoryCache = class {
+  map = /* @__PURE__ */ new Map();
+  head = null;
+  tail = null;
+  _maxEntries;
+  constructor(maxEntries = 250) {
+    this._maxEntries = maxEntries;
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    if (Date.now() > node.entry.expiresAt) {
+      this.removeNode(node);
+      this.map.delete(key);
+      return void 0;
+    }
+    this.moveToFront(node);
+    return {
+      hit: true,
+      value: node.entry.value,
+      age: Date.now() - node.entry.createdAt
+    };
+  }
+  set(key, value, ttlMs) {
+    const existingNode = this.map.get(key);
+    if (existingNode) {
+      existingNode.entry = {
+        value,
+        expiresAt: Date.now() + ttlMs,
+        createdAt: Date.now()
+      };
+      this.moveToFront(existingNode);
+      return;
+    }
+    const node = {
+      key,
+      entry: {
+        value,
+        expiresAt: Date.now() + ttlMs,
+        createdAt: Date.now()
+      },
+      prev: null,
+      next: null
+    };
+    this.map.set(key, node);
+    this.addToFront(node);
+    while (this.map.size > this._maxEntries && this.tail) {
+      const tailKey = this.tail.key;
+      this.removeNode(this.tail);
+      this.map.delete(tailKey);
+    }
+  }
+  delete(key) {
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.removeNode(node);
+    this.map.delete(key);
+    return true;
+  }
+  has(key) {
+    const node = this.map.get(key);
+    if (!node) return false;
+    if (Date.now() > node.entry.expiresAt) {
+      this.removeNode(node);
+      this.map.delete(key);
+      return false;
+    }
+    return true;
+  }
+  clear() {
+    this.map.clear();
+    this.head = null;
+    this.tail = null;
+  }
+  addToFront(node) {
+    node.prev = null;
+    node.next = this.head;
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    if (!this.tail) {
+      this.tail = node;
+    }
+  }
+  removeNode(node) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+    node.prev = null;
+    node.next = null;
+  }
+  moveToFront(node) {
+    if (node === this.head) return;
+    this.removeNode(node);
+    this.addToFront(node);
+  }
+};
+
+// src/cache/cache-key.ts
+function generateSearchCacheKey(params) {
+  const parts = [
+    params.toolKind,
+    params.query.toLowerCase().replace(/\s+/g, " ").trim(),
+    `n${params.maxResults}`,
+    `s${params.strategy}`,
+    `r${params.region}`,
+    `l${params.language}`,
+    `t${params.timeRange}`,
+    `ss${params.safeSearch}`
+  ];
+  if (params.providers && params.providers.length > 0) {
+    parts.push(`p${params.providers.sort().join(",")}`);
+  }
+  if (params.includeDomains && params.includeDomains.length > 0) {
+    parts.push(`inc${params.includeDomains.sort().join(",")}`);
+  }
+  if (params.excludeDomains && params.excludeDomains.length > 0) {
+    parts.push(`exc${params.excludeDomains.sort().join(",")}`);
+  }
+  return parts.join(":");
+}
+function extractDomain(urlString) {
+  try {
+    const url = new URL$1(urlString);
+    return url.hostname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+var TRACKING_PARAMS = /* @__PURE__ */ new Set([
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content",
+  "utm_id",
+  "utm_cid",
+  "gclid",
+  "fbclid",
+  "mc_cid",
+  "mc_eid",
+  "msclkid",
+  "twclid",
+  "li_fat_id",
+  "igshid",
+  "yclid"
+]);
+function removeTrackingParams(urlString) {
+  try {
+    const url = new URL$1(urlString);
+    const paramsToDelete = [];
+    url.searchParams.forEach((_value, key) => {
+      if (TRACKING_PARAMS.has(key.toLowerCase())) {
+        paramsToDelete.push(key);
+      }
+    });
+    for (const key of paramsToDelete) {
+      url.searchParams.delete(key);
+    }
+    return url.toString();
+  } catch {
+    return urlString;
+  }
+}
+function canonicalizeUrl(urlString) {
+  try {
+    const url = new URL$1(urlString);
+    url.hostname = url.hostname.toLowerCase();
+    url.hash = "";
+    if (url.protocol === "http:" && url.port === "80" || url.protocol === "https:" && url.port === "443") {
+      url.port = "";
+    }
+    if (url.pathname !== "/" && url.pathname.endsWith("/")) {
+      url.pathname = url.pathname.slice(0, -1);
+    }
+    const cleaned = removeTrackingParams(url.toString());
+    return cleaned;
+  } catch {
+    return urlString;
+  }
+}
+var PRIVATE_IP_PATTERNS = [
+  /^127\./,
+  // Loopback
+  /^10\./,
+  // Class A private
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  // Class B private
+  /^192\.168\./,
+  // Class C private
+  /^169\.254\./,
+  // Link-local
+  /^0\./,
+  // Current network
+  /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./,
+  // Carrier-grade NAT
+  /^192\.0\.0\./,
+  // IETF protocol assignments
+  /^192\.0\.2\./,
+  // Documentation (TEST-NET-1)
+  /^198\.51\.100\./,
+  // Documentation (TEST-NET-2)
+  /^203\.0\.113\./,
+  // Documentation (TEST-NET-3)
+  /^224\./,
+  // Multicast
+  /^240\./
+  // Reserved
+];
+var PRIVATE_HOSTS = /* @__PURE__ */ new Set(["localhost", "localhost.", "*.localhost"]);
+function isPrivateHost(hostname) {
+  const lower = hostname.toLowerCase();
+  if (PRIVATE_HOSTS.has(lower) || lower.endsWith(".localhost")) {
+    return true;
+  }
+  if (lower === "::1" || lower === "[::1]") {
+    return true;
+  }
+  for (const pattern of PRIVATE_IP_PATTERNS) {
+    if (pattern.test(lower)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/search/normalize.ts
+function normalizeResults(rawResults, options) {
+  const { provider, sourceType, startIndex = 0 } = options;
+  return rawResults.map((raw, index) => {
+    const url = canonicalizeUrl(raw.url);
+    const domain = extractDomain(url);
+    return {
+      position: startIndex + index + 1,
+      title: raw.title.trim(),
+      url,
+      display_url: raw.displayUrl,
+      snippet: raw.snippet,
+      provider,
+      source_type: sourceType,
+      published_at: raw.publishedAt,
+      language: raw.language,
+      domain
+    };
+  });
+}
+
+// src/search/deduplicate.ts
+function deduplicateResults(results, options = { enabled: true }) {
+  if (!options.enabled || results.length === 0) return results;
+  const seen = /* @__PURE__ */ new Map();
+  const domainPath = /* @__PURE__ */ new Map();
+  const titleDomain = /* @__PURE__ */ new Map();
+  const unique = [];
+  for (const result of results) {
+    const canonical = canonicalizeUrl(result.url);
+    if (seen.has(canonical)) {
+      mergeProviders(unique, seen.get(canonical), result);
+      continue;
+    }
+    const dpKey = `${result.domain}:${getNormalPath(canonical)}`;
+    if (domainPath.has(dpKey)) {
+      mergeProviders(unique, domainPath.get(dpKey), result);
+      continue;
+    }
+    const titleKey = `${result.domain}:${result.title.toLowerCase().replace(/\s+/g, " ").trim()}`;
+    if (titleDomain.has(titleKey)) {
+      mergeProviders(unique, titleDomain.get(titleKey), result);
+      continue;
+    }
+    const idx = unique.length;
+    unique.push(result);
+    seen.set(canonical, idx);
+    domainPath.set(dpKey, idx);
+    titleDomain.set(titleKey, idx);
+  }
+  return unique;
+}
+function getNormalPath(urlString) {
+  try {
+    const url = new URL(urlString);
+    return url.pathname.replace(/\/$/, "") || "/";
+  } catch {
+    return urlString;
+  }
+}
+function mergeProviders(results, existingIndex, newResult) {
+  const existing = results[existingIndex];
+  const existingScore = scoreMetadata(existing);
+  const newScore = scoreMetadata(newResult);
+  if (newScore > existingScore) {
+    results[existingIndex] = newResult;
+  }
+}
+function scoreMetadata(result) {
+  let score = 0;
+  if (result.snippet) score += 1;
+  if (result.published_at) score += 1;
+  if (result.display_url) score += 0.5;
+  if (result.language) score += 0.5;
+  return score;
+}
+
+// src/search/rank.ts
+var DEFAULT_PROVIDER_WEIGHT = 1;
+var SCORE_WEIGHTS = {
+  upstreamRank: 10,
+  // Higher rank = lower position number = higher score
+  providerWeight: 2,
+  domainMatch: 10,
+  freshness: 3,
+  metadataQuality: 2,
+  urlQualityPenalty: -2
+};
+function rankResults(results, options = {}) {
+  const { includeDomains = [], providerWeights = {} } = options;
+  const scored = results.map((result, index) => {
+    let score = 0;
+    const maxPosition = results.length || 1;
+    score += SCORE_WEIGHTS.upstreamRank * ((maxPosition - index) / maxPosition);
+    const providerWeight = providerWeights[result.provider] ?? DEFAULT_PROVIDER_WEIGHT;
+    score += SCORE_WEIGHTS.providerWeight * providerWeight;
+    if (includeDomains.length > 0) {
+      const isMatch = includeDomains.some(
+        (d) => result.domain === d.toLowerCase() || result.domain.endsWith("." + d.toLowerCase())
+      );
+      if (isMatch) {
+        score += SCORE_WEIGHTS.domainMatch;
+      }
+    }
+    if (result.published_at) {
+      try {
+        const pubDate = new Date(result.published_at);
+        const daysSincePublication = (Date.now() - pubDate.getTime()) / (1e3 * 60 * 60 * 24);
+        if (daysSincePublication <= 7) {
+          score += SCORE_WEIGHTS.freshness;
+        } else if (daysSincePublication <= 30) {
+          score += SCORE_WEIGHTS.freshness * 0.5;
+        }
+      } catch {
+      }
+    }
+    if (result.snippet) score += SCORE_WEIGHTS.metadataQuality * 0.5;
+    if (result.display_url) score += SCORE_WEIGHTS.metadataQuality * 0.3;
+    if (result.language) score += SCORE_WEIGHTS.metadataQuality * 0.2;
+    const url = result.url;
+    if (url.includes("tracking") || url.includes("click") || url.includes("redirect")) {
+      score += SCORE_WEIGHTS.urlQualityPenalty;
+    }
+    if (url.length > 200) {
+      score += SCORE_WEIGHTS.urlQualityPenalty * 0.5;
+    }
+    return { result, score };
+  });
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.result.position - b.result.position;
+  });
+  return scored.map((item, index) => ({
+    ...item.result,
+    position: index + 1,
+    score: Math.round(item.score * 100) / 100
+  }));
+}
+
+// src/search/filters.ts
+function applyDomainFilters(results, options) {
+  const { includeDomains = [], excludeDomains = [], globalExcludeDomains = [] } = options;
+  const warnings = [];
+  let filtered = [...results];
+  let totalFiltered = 0;
+  if (includeDomains.length > 0) {
+    const before = filtered.length;
+    filtered = filtered.filter((result) => {
+      return domainMatchesAny(result.domain, includeDomains);
+    });
+    totalFiltered += before - filtered.length;
+  }
+  const allExcludes = [...excludeDomains, ...globalExcludeDomains];
+  if (allExcludes.length > 0) {
+    const before = filtered.length;
+    filtered = filtered.filter((result) => {
+      return !domainMatchesAny(result.domain, allExcludes);
+    });
+    totalFiltered += before - filtered.length;
+  }
+  if (filtered.length === 0 && results.length > 0 && totalFiltered > 0) {
+    warnings.push("Domain filtering removed all results \u2014 returning unfiltered results");
+    filtered = results;
+    totalFiltered = 0;
+  }
+  return {
+    results: filtered,
+    filteredCount: totalFiltered,
+    warnings
+  };
+}
+function domainMatchesAny(domain, domains) {
+  const lowerDomain = domain.toLowerCase();
+  return domains.some((filterDomain) => {
+    const lowerFilter = filterDomain.toLowerCase();
+    return lowerDomain === lowerFilter || lowerDomain.endsWith("." + lowerFilter);
+  });
+}
+
+// src/search/coalescer.ts
+var RequestCoalescer = class {
+  inflight = /* @__PURE__ */ new Map();
+  /**
+   * Get or create a coalesced request.
+   * If an identical request is already in-flight, returns its promise.
+   * Otherwise, executes the factory and stores the promise.
+   */
+  async acquire(key, factory) {
+    const existing = this.inflight.get(key);
+    if (existing) {
+      existing.refCount++;
+      try {
+        return await existing.promise;
+      } finally {
+        existing.refCount--;
+        if (existing.refCount <= 0) {
+          this.inflight.delete(key);
+        }
+      }
+    }
+    const entry = {
+      promise: factory(),
+      refCount: 1
+    };
+    this.inflight.set(key, entry);
+    try {
+      const result = await entry.promise;
+      return result;
+    } finally {
+      entry.refCount--;
+      if (entry.refCount <= 0) {
+        this.inflight.delete(key);
+      }
+    }
+  }
+  /**
+   * Check if a request is currently in-flight.
+   */
+  has(key) {
+    return this.inflight.has(key);
+  }
+  /**
+   * Get the number of in-flight requests.
+   */
+  get size() {
+    return this.inflight.size;
+  }
+  /**
+   * Clear all in-flight requests (does not cancel them).
+   */
+  clear() {
+    this.inflight.clear();
+  }
+};
+
+// src/search/rate-limiter.ts
+var RateLimiter = class {
+  states = /* @__PURE__ */ new Map();
+  defaultIntervalMs;
+  constructor(defaultIntervalMs = 1500) {
+    this.defaultIntervalMs = defaultIntervalMs;
+  }
+  /**
+   * Wait until the provider is available, respecting rate limits.
+   */
+  async acquire(providerId, signal) {
+    const state = this.getState(providerId);
+    const now = Date.now();
+    if (state.nextAvailableAt > now) {
+      const waitMs = state.nextAvailableAt - now;
+      if (signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, waitMs);
+        signal?.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(timer);
+            reject(new DOMException("Aborted", "AbortError"));
+          },
+          { once: true }
+        );
+      });
+    }
+    const state2 = this.getState(providerId);
+    state2.nextAvailableAt = Date.now() + this.defaultIntervalMs;
+  }
+  /**
+   * Report a rate-limited response — increases cooldown.
+   */
+  reportRateLimited(providerId, retryAfterMs) {
+    const state = this.getState(providerId);
+    state.consecutiveFailures++;
+    state.lastFailureAt = Date.now();
+    const base = retryAfterMs ?? this.defaultIntervalMs;
+    const backoff = Math.min(base * Math.pow(2, state.consecutiveFailures - 1), 6e5);
+    state.cooldownMs = backoff;
+    state.nextAvailableAt = Date.now() + backoff;
+  }
+  /**
+   * Report a success — resets failure state.
+   */
+  reportSuccess(providerId) {
+    const state = this.getState(providerId);
+    state.consecutiveFailures = 0;
+    state.cooldownMs = this.defaultIntervalMs;
+    state.lastFailureAt = void 0;
+    state.nextAvailableAt = 0;
+  }
+  /**
+   * Get the current state for a provider.
+   */
+  getState(providerId) {
+    let state = this.states.get(providerId);
+    if (!state) {
+      state = {
+        consecutiveFailures: 0,
+        cooldownMs: this.defaultIntervalMs,
+        nextAvailableAt: 0
+      };
+      this.states.set(providerId, state);
+    }
+    return state;
+  }
+  /**
+   * Check if a provider is currently available.
+   */
+  isAvailable(providerId) {
+    const state = this.states.get(providerId);
+    if (!state) return true;
+    return Date.now() >= state.nextAvailableAt;
+  }
+  /**
+   * Reset all state.
+   */
+  reset() {
+    this.states.clear();
+  }
+};
+
+// src/search/orchestrator.ts
+var coalescer = new RequestCoalescer();
+var rateLimiter = new RateLimiter(1500);
+async function orchestrateSearch(request, options) {
+  const logger = getLogger();
+  const startTime = Date.now();
+  const { providers: providers4, strategy, cache: cache4, config } = options;
+  const cacheKey = generateSearchCacheKey({
+    toolKind: "web_search",
+    query: request.query,
+    maxResults: request.maxResults,
+    providers: providers4.map((p) => p.id),
+    strategy,
+    region: request.region,
+    language: request.language,
+    timeRange: request.timeRange ?? "any",
+    safeSearch: request.safeSearch,
+    includeDomains: request.includeDomains,
+    excludeDomains: request.excludeDomains
+  });
+  const cached = cache4.get(cacheKey);
+  if (cached && cached.hit) {
+    logger.debug("Cache hit", { key: cacheKey });
+    const result = cached.value;
+    return { ...result, cached: true };
+  }
+  logger.debug("Cache miss", { key: cacheKey });
+  return coalescer.acquire(cacheKey, async () => {
+    const providerContext = {
+      timeoutMs: request.timeoutMs ?? config.providerTimeoutMs,
+      safeSearch: request.safeSearch,
+      region: request.region,
+      language: request.language
+    };
+    const allResults = [];
+    const providerAttempts = [];
+    const warnings = [];
+    let partial = false;
+    if (strategy === "fallback") {
+      for (const provider of providers4) {
+        if (allResults.length >= request.maxResults) break;
+        const { attempt, results: providerResults } = await executeProvider(provider, {
+          query: request.query,
+          maxResults: request.maxResults - allResults.length,
+          timeRange: request.timeRange,
+          region: request.region,
+          language: request.language,
+          safeSearch: request.safeSearch,
+          includeDomains: request.includeDomains,
+          excludeDomains: request.excludeDomains
+        }, providerContext);
+        allResults.push(...providerResults);
+        providerAttempts.push(attempt);
+        if (attempt.success) {
+          rateLimiter.reportSuccess(provider.id);
+        } else {
+          rateLimiter.reportRateLimited(provider.id);
+          partial = true;
+          warnings.push(...attempt.warnings ?? []);
+        }
+        if (allResults.length >= request.maxResults) break;
+      }
+    } else {
+      const topProviders = providers4.slice(0, 2);
+      const settled = await Promise.allSettled(
+        topProviders.map(
+          (provider) => executeProvider(provider, {
+            query: request.query,
+            maxResults: request.maxResults,
+            timeRange: request.timeRange,
+            region: request.region,
+            language: request.language,
+            safeSearch: request.safeSearch,
+            includeDomains: request.includeDomains,
+            excludeDomains: request.excludeDomains
+          }, providerContext)
+        )
+      );
+      for (const result2 of settled) {
+        if (result2.status === "fulfilled") {
+          allResults.push(...result2.value.results);
+          providerAttempts.push(result2.value.attempt);
+          if (result2.value.attempt.success) {
+            rateLimiter.reportSuccess(result2.value.attempt.provider);
+          } else {
+            partial = true;
+            warnings.push(...result2.value.attempt.warnings ?? []);
+          }
+        } else {
+          partial = true;
+          warnings.push(`Provider call failed: ${result2.reason}`);
+        }
+      }
+    }
+    const filtered = applyDomainFilters(allResults, {
+      includeDomains: request.includeDomains,
+      excludeDomains: request.excludeDomains,
+      globalExcludeDomains: config.globalExcludeDomains
+    });
+    warnings.push(...filtered.warnings);
+    const deduplicated = deduplicateResults(filtered.results, { enabled: request.deduplicate });
+    const ranked = rankResults(deduplicated);
+    const capped = ranked.slice(0, request.maxResults);
+    const durationMs = Date.now() - startTime;
+    const result = {
+      query: request.query,
+      results: capped,
+      providerAttempts,
+      cached: false,
+      partial: partial || capped.length < request.maxResults,
+      warnings,
+      durationMs
+    };
+    if (capped.length > 0) {
+      const cacheTtl = config.searchCacheTtlMs;
+      cache4.set(cacheKey, result, cacheTtl);
+    }
+    return result;
+  });
+}
+async function executeProvider(provider, request, context) {
+  const logger = getLogger();
+  const startTime = Date.now();
+  try {
+    await rateLimiter.acquire(provider.id);
+    logger.debug("Provider attempt started", { provider: provider.id });
+    const response = await provider.search(request, context);
+    const normalized = normalizeResults(response.results, {
+      provider: response.provider,
+      sourceType: "web"
+    });
+    const durationMs = Date.now() - startTime;
+    logger.debug("Provider attempt completed", {
+      provider: provider.id,
+      resultCount: normalized.length,
+      durationMs
+    });
+    return {
+      attempt: {
+        provider: provider.id,
+        success: normalized.length > 0,
+        duration_ms: durationMs,
+        result_count: normalized.length,
+        error: response.warnings.length > 0 ? response.warnings.join("; ") : void 0,
+        warnings: response.warnings
+      },
+      results: normalized
+    };
+  } catch (err) {
+    const durationMs = Date.now() - startTime;
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error("Provider attempt failed", {
+      provider: provider.id,
+      error: message,
+      durationMs
+    });
+    return {
+      attempt: {
+        provider: provider.id,
+        success: false,
+        duration_ms: durationMs,
+        result_count: 0,
+        error: message
+      },
+      results: []
+    };
+  }
+}
+var providers = [new DuckDuckGoProvider(), new BingProvider()];
+var cache = new MemoryCache(250);
+function registerWebSearchTool(server, config) {
+  server.tool(
+    "web_search",
+    "Search the general web and return normalized results.",
+    {
+      query: z.string().min(1).max(500).describe("Search query, 1-500 characters"),
+      max_results: z.number().int().min(1).max(25).default(10).describe("Maximum number of results (1-25)"),
+      providers: z.array(z.string()).optional().describe("Preferred providers in priority order"),
+      strategy: z.enum(["fallback", "merge"]).default("fallback").describe("Provider strategy: fallback tries providers in order, merge combines top 2"),
+      region: z.string().default("us-en").describe("Region code"),
+      language: z.string().default("en").describe("Language code"),
+      time_range: z.enum(["day", "week", "month", "year", "any"]).default("any").describe("Time range filter"),
+      safe_search: z.enum(["off", "moderate", "strict"]).default("moderate").describe("Safe search level"),
+      include_domains: z.array(z.string()).max(20).optional().describe("Only include results from these domains"),
+      exclude_domains: z.array(z.string()).max(50).optional().describe("Exclude results from these domains"),
+      deduplicate: z.boolean().default(true).describe("Deduplicate results by URL"),
+      timeout_ms: z.number().int().min(1e3).max(6e4).optional().describe("Operation timeout in milliseconds")
+    },
+    async (args) => {
+      const logger = getLogger();
+      logger.info("web_search called", {
+        query: config.redactQueries ? "[REDACTED]" : args.query,
+        maxResults: args.max_results
+      });
+      const parseResult = SearchInputSchema.safeParse(args);
+      if (!parseResult.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: {
+                  code: "INVALID_INPUT",
+                  message: "Invalid search parameters",
+                  details: parseResult.error.flatten()
+                }
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const input = parseResult.data;
+      let activeProviders = providers;
+      if (input.providers && input.providers.length > 0) {
+        activeProviders = providers.filter((p) => input.providers.includes(p.id));
+        if (activeProviders.length === 0) activeProviders = providers;
+      }
+      const orchestrationResult = await orchestrateSearch(
+        {
+          query: input.query,
+          maxResults: input.max_results,
+          timeRange: input.time_range,
+          region: input.region,
+          language: input.language,
+          safeSearch: input.safe_search,
+          includeDomains: input.include_domains,
+          excludeDomains: input.exclude_domains,
+          deduplicate: input.deduplicate,
+          timeoutMs: input.timeout_ms
+        },
+        {
+          providers: activeProviders,
+          strategy: input.strategy,
+          cache,
+          config
+        }
+      );
+      const output = {
+        query: orchestrationResult.query,
+        results: orchestrationResult.results,
+        provider_attempts: orchestrationResult.providerAttempts,
+        cached: orchestrationResult.cached,
+        partial: orchestrationResult.partial,
+        warnings: orchestrationResult.warnings,
+        duration_ms: orchestrationResult.durationMs
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/fetch/validate-url.ts
+var ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+function validateUrl(urlString) {
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch {
+    return {
+      valid: false,
+      error: "Invalid URL format",
+      code: "INVALID_URL"
+    };
+  }
+  if (!ALLOWED_SCHEMES.has(url.protocol)) {
+    return {
+      valid: false,
+      error: `Unsupported scheme: ${url.protocol}`,
+      code: "UNSUPPORTED_SCHEME"
+    };
+  }
+  if (url.username || url.password) {
+    return {
+      valid: false,
+      error: "URLs with credentials are not allowed",
+      code: "INVALID_URL"
+    };
+  }
+  if (isPrivateHost(url.hostname)) {
+    return {
+      valid: false,
+      error: "Private/reserved network addresses are not allowed",
+      code: "PRIVATE_NETWORK_BLOCKED"
+    };
+  }
+  return { valid: true };
+}
+
+// src/fetch/content-types.ts
+var SUPPORTED_TEXT_TYPES = /* @__PURE__ */ new Set([
+  "text/html",
+  "text/plain",
+  "text/css",
+  "text/xml",
+  "application/json",
+  "application/xml",
+  "application/xhtml+xml"
+]);
+var REJECTED_TYPES = /* @__PURE__ */ new Set([
+  "application/pdf",
+  "image/",
+  "audio/",
+  "video/",
+  "application/zip",
+  "application/x-tar",
+  "application/gzip",
+  "application/octet-stream",
+  "application/x-executable",
+  "application/x-msdownload"
+]);
+function classifyContentType(contentType) {
+  if (!contentType) {
+    return { isSupported: true, isText: true, isHtml: false };
+  }
+  const normalized = contentType.split(";")[0].trim().toLowerCase();
+  for (const rejected of REJECTED_TYPES) {
+    if (normalized.startsWith(rejected)) {
+      return {
+        isSupported: false,
+        isText: false,
+        isHtml: false,
+        rejectionReason: `Unsupported content type: ${normalized}`
+      };
+    }
+  }
+  const isHtml = normalized.includes("html");
+  const isText = normalized.startsWith("text/") || SUPPORTED_TEXT_TYPES.has(normalized);
+  return {
+    isSupported: true,
+    isText,
+    isHtml
+  };
+}
+async function extractMainContent(html, url) {
+  const $ = cheerio.load(html);
+  const meta = extractMetadata($, url);
+  try {
+    const { parseHTML } = await import('linkedom');
+    const { Readability } = await import('@mozilla/readability');
+    const { document } = parseHTML(html);
+    const reader = new Readability(document);
+    const article = reader.parse();
+    if (article && article.textContent && article.textContent.trim().length > 50) {
+      return {
+        title: article.title || meta.title,
+        byline: article.byline || meta.byline,
+        siteName: meta.siteName,
+        publishedAt: meta.publishedAt,
+        content: article.content || "",
+        textContent: article.textContent || ""
+      };
+    }
+  } catch {
+  }
+  const mainContent = extractBySelector($, "main");
+  if (mainContent) {
+    return {
+      ...meta,
+      content: mainContent,
+      textContent: stripTags($, mainContent)
+    };
+  }
+  const articleContent = extractBySelector($, "article");
+  if (articleContent) {
+    return {
+      ...meta,
+      content: articleContent,
+      textContent: stripTags($, articleContent)
+    };
+  }
+  const bodyContent = $("body").html() || "";
+  return {
+    ...meta,
+    content: bodyContent,
+    textContent: stripTags($, bodyContent)
+  };
+}
+function extractMetadata($, url) {
+  const title = $("meta[property='og:title']").attr("content") || $("title").text().trim() || void 0;
+  const byline = $("meta[name='author']").attr("content") || void 0;
+  let siteName = $("meta[property='og:site_name']").attr("content") || void 0;
+  if (!siteName) {
+    try {
+      siteName = new URL(url).hostname;
+    } catch {
+    }
+  }
+  const publishedAt = $("meta[property='article:published_time']").attr("content") || $("meta[name='date']").attr("content") || $("meta[name='pubdate']").attr("content") || void 0;
+  return {
+    title,
+    byline,
+    siteName,
+    publishedAt
+  };
+}
+function extractBySelector($, selector) {
+  const $el = $(selector).first();
+  if ($el.length === 0) return null;
+  $el.find("script, style, nav, footer, aside, form, iframe").remove();
+  const htmlStr = $el.html();
+  return htmlStr && htmlStr.trim().length > 50 ? htmlStr : null;
+}
+function stripTags($, htmlStr) {
+  return $(htmlStr).text().replace(/\s+/g, " ").trim();
+}
+
+// src/fetch/html-to-markdown.ts
+var turndownInstance = null;
+async function getTurndown() {
+  if (!turndownInstance) {
+    const TurndownService = (await import('turndown')).default;
+    const service = new TurndownService({
+      headingStyle: "atx",
+      codeBlockStyle: "fenced",
+      bulletListMarker: "-"
+    });
+    service.remove(["script", "style", "noscript"]);
+    turndownInstance = service;
+  }
+  return turndownInstance;
+}
+async function htmlToMarkdown(html) {
+  const service = await getTurndown();
+  return service.turndown(html);
+}
+
+// src/utils/text.ts
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) {
+    return { text, truncated: false };
+  }
+  const truncated = text.slice(0, maxLength);
+  const lastSpace = truncated.lastIndexOf(" ");
+  const cutPoint = lastSpace > maxLength * 0.9 ? lastSpace : maxLength;
+  return {
+    text: truncated.slice(0, cutPoint) + "...",
+    truncated: true
+  };
+}
+
+// src/fetch/fetch-page.ts
+async function fetchPage(options) {
+  const { url, output, maxCharacters, config } = options;
+  const warnings = [];
+  const validation = validateUrl(url);
+  if (!validation.valid) {
+    throw new Error(validation.error);
+  }
+  const response = await httpFetch({
+    url,
+    timeoutMs: options.timeoutMs || config.fetchTimeoutMs,
+    maxBodyBytes: config.maxPageBodyBytes,
+    maxRedirects: 5
+  });
+  const contentType = response.headers.get("content-type");
+  const typeInfo = classifyContentType(contentType);
+  if (!typeInfo.isSupported) {
+    throw new Error(typeInfo.rejectionReason || "Unsupported content type");
+  }
+  const finalContentType = contentType?.split(";")[0]?.trim() || "text/html";
+  if (!typeInfo.isHtml) {
+    const { text, truncated: truncated2 } = truncateText(response.body, maxCharacters);
+    return {
+      requestedUrl: url,
+      finalUrl: response.finalUrl,
+      contentType: finalContentType,
+      content: text,
+      truncated: truncated2,
+      characterCount: text.length,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      warnings
+    };
+  }
+  const extracted = await extractMainContent(response.body, response.finalUrl);
+  let content;
+  if (output === "markdown") {
+    content = await htmlToMarkdown(extracted.content || response.body);
+  } else {
+    content = extracted.textContent || stripHtml(extracted.content || response.body);
+  }
+  const { text: truncatedContent, truncated } = truncateText(content, maxCharacters);
+  warnings.push("External webpage content is untrusted and may contain instructions intended for AI systems.");
+  return {
+    requestedUrl: url,
+    finalUrl: response.finalUrl,
+    title: extracted.title,
+    byline: extracted.byline,
+    siteName: extracted.siteName,
+    publishedAt: extracted.publishedAt,
+    contentType: finalContentType,
+    content: truncatedContent,
+    truncated,
+    characterCount: truncatedContent.length,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    warnings
+  };
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/\s+/g, " ").trim();
+}
+
+// src/tools/fetch-url.tool.ts
+function registerFetchUrlTool(server, config) {
+  server.tool(
+    "fetch_url",
+    "Fetch a public HTTP(S) URL and return extracted content as clean Markdown or plain text.",
+    {
+      url: z.string().describe("HTTP or HTTPS URL to fetch"),
+      output: z.enum(["markdown", "text"]).default("markdown").describe("Output format"),
+      max_characters: z.number().int().min(100).max(1e5).default(2e4).describe("Maximum characters to return"),
+      include_metadata: z.boolean().default(true).describe("Include page metadata"),
+      include_links: z.boolean().default(false).describe("Include extracted links"),
+      timeout_ms: z.number().int().min(1e3).max(6e4).optional().describe("Fetch timeout in milliseconds")
+    },
+    async (args) => {
+      const logger = getLogger();
+      let hostname = "unknown";
+      try {
+        hostname = new URL(args.url).hostname;
+      } catch {
+      }
+      logger.info("fetch_url called", { url: hostname });
+      const parseResult = FetchUrlInputSchema.safeParse(args);
+      if (!parseResult.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: {
+                  code: "INVALID_INPUT",
+                  message: "Invalid fetch parameters",
+                  details: parseResult.error.flatten()
+                }
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const input = parseResult.data;
+      try {
+        const result = await fetchPage({
+          url: input.url,
+          output: input.output,
+          maxCharacters: input.max_characters,
+          includeMetadata: input.include_metadata,
+          timeoutMs: input.timeout_ms || config.fetchTimeoutMs,
+          config
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.error("fetch_url failed", { error: message, url: hostname });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: {
+                  code: "FETCH_FAILED",
+                  message
+                }
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+var providers2 = [new DuckDuckGoProvider(), new BingProvider()];
+var cache2 = new MemoryCache(250);
+function registerSearchAndFetchTool(server, config) {
+  server.tool(
+    "search_and_fetch",
+    "Search the web and fetch the best results. One call for research: search, rank, and fetch the best few pages.",
+    {
+      query: z.string().min(1).max(500).describe("Search query"),
+      search_results: z.number().int().min(1).max(20).default(8).describe("Number of search results to consider"),
+      fetch_results: z.number().int().min(1).max(5).default(3).describe("Number of pages to fetch"),
+      providers: z.array(z.string()).optional().describe("Preferred providers"),
+      strategy: z.enum(["fallback", "merge"]).default("fallback"),
+      region: z.string().default("us-en"),
+      language: z.string().default("en"),
+      time_range: z.enum(["day", "week", "month", "year", "any"]).default("any"),
+      include_domains: z.array(z.string()).max(20).optional(),
+      exclude_domains: z.array(z.string()).max(50).optional(),
+      max_characters_per_page: z.number().int().min(1e3).max(1e5).default(2e4),
+      total_character_budget: z.number().int().min(1e3).max(5e5).default(1e5),
+      timeout_ms: z.number().int().min(5e3).max(12e4).optional()
+    },
+    async (args) => {
+      const logger = getLogger();
+      const startTime = Date.now();
+      const totalTimeout = args.timeout_ms || config.researchTimeoutMs;
+      logger.info("search_and_fetch called", {
+        query: config.redactQueries ? "[REDACTED]" : args.query,
+        fetchResults: args.fetch_results
+      });
+      const parseResult = SearchAndFetchInputSchema.safeParse(args);
+      if (!parseResult.success) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: {
+                code: "INVALID_INPUT",
+                message: "Invalid parameters",
+                details: parseResult.error.flatten()
+              }
+            })
+          }],
+          isError: true
+        };
+      }
+      const input = parseResult.data;
+      try {
+        let activeProviders = providers2;
+        if (input.providers && input.providers.length > 0) {
+          activeProviders = providers2.filter((p) => input.providers.includes(p.id));
+          if (activeProviders.length === 0) activeProviders = providers2;
+        }
+        const searchResult = await orchestrateSearch(
+          {
+            query: input.query,
+            maxResults: input.search_results,
+            timeRange: input.time_range,
+            region: input.region,
+            language: input.language,
+            safeSearch: "moderate",
+            includeDomains: input.include_domains,
+            excludeDomains: input.exclude_domains,
+            deduplicate: true,
+            timeoutMs: Math.min(totalTimeout, 2e4)
+          },
+          {
+            providers: activeProviders,
+            strategy: input.strategy,
+            cache: cache2,
+            config
+          }
+        );
+        const candidates = searchResult.results.filter((r) => {
+          try {
+            const url = new URL(r.url);
+            if (url.protocol !== "https:" && url.protocol !== "http:") return false;
+            if (isPrivateHost(url.hostname)) return false;
+            return true;
+          } catch {
+            return false;
+          }
+        }).slice(0, input.fetch_results);
+        const pages = [];
+        const failures = [];
+        let totalCharacters = 0;
+        const maxPerPage = Math.min(
+          input.max_characters_per_page,
+          input.total_character_budget - totalCharacters
+        );
+        for (const candidate of candidates) {
+          if (totalCharacters >= input.total_character_budget) break;
+          if (Date.now() - startTime > totalTimeout) {
+            failures.push({
+              url: candidate.url,
+              error: "Operation timeout",
+              code: "OPERATION_CANCELLED"
+            });
+            continue;
+          }
+          const remainingBudget = input.total_character_budget - totalCharacters;
+          const charLimit = Math.min(maxPerPage, remainingBudget);
+          try {
+            const fetched = await fetchPage({
+              url: candidate.url,
+              output: "markdown",
+              maxCharacters: charLimit,
+              includeMetadata: true,
+              timeoutMs: Math.min(config.fetchTimeoutMs, totalTimeout - (Date.now() - startTime)),
+              config
+            });
+            pages.push({
+              url: fetched.finalUrl,
+              title: fetched.title || candidate.title,
+              content_type: fetched.contentType,
+              content: fetched.content,
+              character_count: fetched.characterCount,
+              fetched_at: fetched.fetchedAt,
+              warnings: fetched.warnings
+            });
+            totalCharacters += fetched.characterCount;
+          } catch (err) {
+            failures.push({
+              url: candidate.url,
+              error: err instanceof Error ? err.message : String(err),
+              code: "FETCH_FAILED"
+            });
+          }
+        }
+        const durationMs = Date.now() - startTime;
+        const partial = searchResult.partial || failures.length > 0 || pages.length < input.fetch_results;
+        const warnings = [...searchResult.warnings];
+        if (failures.length > 0) {
+          warnings.push(`${failures.length} page fetch(es) failed`);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              query: input.query,
+              search_results: searchResult.results,
+              pages,
+              failures,
+              partial,
+              duration_ms: durationMs
+            })
+          }]
+        };
+      } catch (err) {
+        logger.error("search_and_fetch failed", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: {
+                code: "INTERNAL_ERROR",
+                message: err instanceof Error ? err.message : String(err)
+              }
+            })
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+var providers3 = [new DuckDuckGoProvider(), new BingProvider()];
+var cache3 = new MemoryCache(250);
+function registerNewsSearchTool(server, config) {
+  server.tool(
+    "news_search",
+    "Search for recent news articles. Returns date-sensitive results with publisher and publication time.",
+    {
+      query: z.string().min(1).max(500).describe("News search query"),
+      max_results: z.number().int().min(1).max(25).default(10).describe("Maximum number of results"),
+      providers: z.array(z.string()).optional().describe("Preferred providers"),
+      region: z.string().default("us-en").describe("Region code"),
+      language: z.string().default("en").describe("Language code"),
+      time_range: z.enum(["day", "week", "month"]).default("week").describe("Time range filter"),
+      include_domains: z.array(z.string()).max(20).optional().describe("Only include these domains"),
+      exclude_domains: z.array(z.string()).max(50).optional().describe("Exclude these domains"),
+      timeout_ms: z.number().int().min(1e3).max(6e4).optional().describe("Timeout in ms")
+    },
+    async (args) => {
+      const logger = getLogger();
+      logger.info("news_search called", {
+        query: config.redactQueries ? "[REDACTED]" : args.query,
+        maxResults: args.max_results
+      });
+      const parseResult = NewsSearchInputSchema.safeParse(args);
+      if (!parseResult.success) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: {
+                code: "INVALID_INPUT",
+                message: "Invalid news search parameters",
+                details: parseResult.error.flatten()
+              }
+            })
+          }],
+          isError: true
+        };
+      }
+      const input = parseResult.data;
+      let activeProviders = providers3.filter((p) => p.capabilities.news || p.capabilities.web);
+      if (input.providers && input.providers.length > 0) {
+        activeProviders = providers3.filter((p) => input.providers.includes(p.id));
+        if (activeProviders.length === 0) activeProviders = providers3;
+      }
+      const result = await orchestrateSearch(
+        {
+          query: input.query,
+          maxResults: input.max_results,
+          timeRange: input.time_range,
+          region: input.region,
+          language: input.language,
+          safeSearch: "moderate",
+          includeDomains: input.include_domains,
+          excludeDomains: input.exclude_domains,
+          deduplicate: true,
+          timeoutMs: input.timeout_ms
+        },
+        {
+          providers: activeProviders,
+          strategy: "fallback",
+          cache: cache3,
+          config
+        }
+      );
+      const output = {
+        query: result.query,
+        results: result.results.map((r) => ({
+          ...r,
+          source_type: "news"
+        })),
+        provider_attempts: result.providerAttempts,
+        cached: result.cached,
+        partial: result.partial,
+        warnings: [
+          ...result.warnings,
+          "Publication dates are only included when provided by the source. Dates may be missing or approximate."
+        ],
+        duration_ms: result.durationMs
+      };
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(output)
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/diagnostics.tool.ts
+function registerDiagnosticsTool(server, config) {
+  server.tool(
+    "diagnostics",
+    "Return non-sensitive server diagnostics for troubleshooting.",
+    {},
+    async () => {
+      const logger = getLogger();
+      logger.debug("diagnostics called");
+      const output = {
+        version: "0.1.0",
+        nodeVersion: process.version,
+        platform: process.platform,
+        arch: process.arch,
+        enabledProviders: ["duckduckgo", "bing", "wikipedia"],
+        cacheEnabled: config.cacheEnabled,
+        diagnosticsEnabled: config.diagnosticsEnabled,
+        limits: {
+          maxSearchResults: config.maxSearchResults,
+          maxFetchCharacters: config.maxFetchCharacters,
+          searchTimeoutMs: config.searchTimeoutMs,
+          providerTimeoutMs: config.providerTimeoutMs,
+          fetchTimeoutMs: config.fetchTimeoutMs
+        },
+        concurrency: {
+          maxConcurrentSearches: config.maxConcurrentSearches,
+          maxConcurrentFetches: config.maxConcurrentFetches
+        },
+        cache: {
+          maxEntries: config.cacheMaxEntries,
+          searchTtlMs: config.searchCacheTtlMs,
+          newsTtlMs: config.newsCacheTtlMs,
+          pageTtlMs: config.pageCacheTtlMs
+        },
+        uptime: Math.floor(process.uptime()),
+        memoryUsage: {
+          rss: Math.round(process.memoryUsage().rss / 1024 / 1024),
+          heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024)
+        }
+      };
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(output)
+        }]
+      };
+    }
+  );
+}
+
+// src/server/register-tools.ts
+function registerTools(server, config) {
+  const logger = getLogger();
+  registerWebSearchTool(server, config);
+  registerFetchUrlTool(server, config);
+  registerSearchAndFetchTool(server, config);
+  registerNewsSearchTool(server, config);
+  if (config.diagnosticsEnabled) {
+    registerDiagnosticsTool(server, config);
+  }
+  const tools = ["web_search", "fetch_url", "search_and_fetch", "news_search"];
+  if (config.diagnosticsEnabled) tools.push("diagnostics");
+  logger.info("Tools registered", { tools });
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+function handleCliArgs() {
+  const args = process.argv.slice(2);
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+fast-web-search-mcp v${VERSION}
+
+A fast, lightweight, local MCP server for free web search and webpage extraction.
+
+USAGE
+  fast-web-search-mcp              Start the MCP server (stdio transport)
+  fast-web-search-mcp --version    Print version and exit
+  fast-web-search-mcp --help       Show this help message
+
+ENVIRONMENT VARIABLES
+  FWSMCP_LOG_LEVEL                 Log level: debug, info, warn, error (default: warn)
+  FWSMCP_DEFAULT_REGION            Default region code (default: us-en)
+  FWSMCP_DEFAULT_LANGUAGE          Default language code (default: en)
+  FWSMCP_PROVIDERS                 Comma-separated providers (default: duckduckgo,bing,wikipedia)
+  FWSMCP_PROVIDER_STRATEGY         Strategy: fallback or merge (default: fallback)
+  FWSMCP_CACHE_ENABLED             Enable cache: true or false (default: true)
+  FWSMCP_SEARXNG_URL               Optional SearXNG instance URL
+  FWSMCP_DIAGNOSTICS_ENABLED       Enable diagnostics tool (default: false)
+
+See https://github.com/iPraBhu/fast-web-search-mcp for full documentation.
+`);
+    process.exit(0);
+  }
+}
+async function main() {
+  handleCliArgs();
+  const config = await loadConfig();
+  const logger = getLogger({
+    level: config.logLevel,
+    format: config.logFormat,
+    redact: config.redactQueries
+  });
+  logger.info("Starting fast-web-search-mcp");
+  const server = createServer();
+  registerTools(server, config);
+  const transport = new StdioServerTransport();
+  let isShuttingDown = false;
+  const shutdown = async (reason, exitCode = 0) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    logger.info("Shutdown initiated", { reason });
+    try {
+      await transport.close();
+    } catch (err) {
+      logger.error("Error closing transport", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    logger.info("Shutdown complete");
+    resetLogger();
+    process.exit(exitCode);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT", 0));
+  process.on("SIGTERM", () => shutdown("SIGTERM", 0));
+  process.on("uncaughtException", (error) => {
+    logger.error("Uncaught exception", {
+      error: error.message,
+      stack: error.stack
+    });
+    shutdown("uncaughtException", 1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger.error("Unhandled rejection", {
+      reason: reason instanceof Error ? reason.message : String(reason)
+    });
+    shutdown("unhandledRejection", 1);
+  });
+  process.stdin.on("end", () => {
+    shutdown("stdin closed", 0);
+  });
+  process.stdin.on("error", () => {
+    shutdown("stdin error", 0);
+  });
+  await server.connect(transport);
+  logger.info("MCP server connected via stdio", {
+    pid: process.pid,
+    nodeVersion: process.version
+  });
+}
+main().catch((error) => {
+  process.stderr.write(
+    JSON.stringify({
+      level: "error",
+      message: "Fatal startup error",
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    }) + "\n"
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map