@duckmind/dm-windows-x64 0.63.0 → 0.63.4

package/extensions/dm-web-access/searchinfinity.js

@@ -0,0 +1,221 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const SEARCHINFINITY_SEARCH_URL = "https://torchlight.byteintlapi.com/search_api/web_search";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 30000;
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config in ${CONFIG_PATH}: expected a JSON object`);
+  }
+  cachedConfig = parsed;
+  return cachedConfig;
+}
+async function getApiKey(signal) {
+  const key = await resolveCredential({
+    provider: "Searchinfinity",
+    configuredValue: loadConfig().searchinfinityApiKey,
+    environmentValue: process.env.SEARCHINFINITY_API_KEY,
+    signal
+  });
+  if (!key) {
+    throw new Error(`Searchinfinity API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "searchinfinityApiKey": "your-key" }
+` + `  2. Set SEARCHINFINITY_API_KEY environment variable
+` + "Create a key at https://console.byteplus.com/search-infinity/api-key");
+  }
+  return key;
+}
+export function isSearchinfinityAvailable() {
+  return hasCredentialSource({
+    provider: "Searchinfinity",
+    configuredValue: loadConfig().searchinfinityApiKey,
+    environmentValue: process.env.SEARCHINFINITY_API_KEY
+  });
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function requestSignal(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function normalizeNumResults(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 5;
+  return Math.max(1, Math.min(Math.floor(value), 20));
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input)
+    return null;
+  if (input.startsWith("-"))
+    input = input.slice(1).trim();
+  if (!input)
+    return null;
+  try {
+    const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
+    input = parsed.hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  input = input.replace(/^\.+|\.+$/g, "");
+  return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function mapRecencyFilter(recency) {
+  if (recency === "day")
+    return "OneDay";
+  if (recency === "week")
+    return "OneWeek";
+  if (recency === "month")
+    return "OneMonth";
+  if (recency === "year")
+    return "OneYear";
+  return;
+}
+function buildSearchBody(query, options) {
+  const includeSites = [];
+  const blockHosts = [];
+  for (const raw of options.domainFilter ?? []) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? blockHosts : includeSites;
+    if (target.length < 5 && !target.includes(domain))
+      target.push(domain);
+  }
+  const filter = {};
+  if (includeSites.length > 0)
+    filter.Sites = includeSites.join("|");
+  if (blockHosts.length > 0)
+    filter.BlockHosts = blockHosts.join("|");
+  const timeRange = mapRecencyFilter(options.recencyFilter);
+  return {
+    Query: query,
+    Count: normalizeNumResults(options.numResults),
+    ...Object.keys(filter).length > 0 ? { Filter: filter } : {},
+    ...timeRange ? { TimeRange: timeRange } : {}
+  };
+}
+function businessErrorStatus(codeN, code, message) {
+  if (codeN === 700901 || code === "invalid_api_key")
+    return 401;
+  if (codeN === 700429 || code === "700429")
+    return 429;
+  if (codeN === 10400 || code === "10400")
+    return 400;
+  if (codeN === 10500 || code === "10500")
+    return 500;
+  if (codeN === 10403 || code === "10403")
+    return /quota|exhaust/i.test(message) ? 429 : 403;
+  return;
+}
+async function searchinfinityJsonRequest(apiKey, body, signal) {
+  let response;
+  try {
+    response = await fetch(SEARCHINFINITY_SEARCH_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: requestSignal(signal, SEARCH_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  const raw = await response.text();
+  if (!response.ok) {
+    throw new Error(`Searchinfinity Search API error ${response.status}: ${redactCredential(raw, apiKey).slice(0, 300)}`);
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Searchinfinity Search API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  const businessError = data.ResponseMetadata?.Error;
+  if (businessError && (businessError.Code || businessError.Message)) {
+    const code = typeof businessError.Code === "string" && businessError.Code ? businessError.Code : "unknown";
+    const message = typeof businessError.Message === "string" && businessError.Message ? businessError.Message : "unknown error";
+    const status = businessErrorStatus(businessError.CodeN, code, message);
+    const codeLabel = typeof businessError.CodeN === "number" ? `${businessError.CodeN} ${code}` : code;
+    throw new Error(`Searchinfinity Search API error ${status ?? "unknown"}: ${message} (code ${codeLabel})`);
+  }
+  return data;
+}
+function mapSearchResults(results) {
+  if (!Array.isArray(results)) {
+    throw new Error("Searchinfinity Search API returned an unexpected response shape");
+  }
+  return results.flatMap((item) => {
+    if (!item || typeof item.Url !== "string" || item.Url.trim().length === 0)
+      return [];
+    const url = item.Url.trim();
+    const summary = typeof item.Summary === "string" ? item.Summary.replace(/\s+/g, " ").trim() : "";
+    const snippet = typeof item.Snippet === "string" ? item.Snippet.replace(/\s+/g, " ").trim() : "";
+    return [{
+      title: typeof item.Title === "string" && item.Title.trim() ? item.Title.trim() : url,
+      url,
+      snippet: summary || snippet
+    }];
+  });
+}
+function buildAnswer(results) {
+  return results.map((result) => {
+    if (result.snippet)
+      return `${result.snippet}
+Source: ${result.title} (${result.url})`;
+    return `Source: ${result.title} (${result.url})`;
+  }).join(`
+
+`);
+}
+export async function searchWithSearchinfinity(query, options = {}) {
+  const apiKey = await getApiKey(options.signal);
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  try {
+    const data = await searchinfinityJsonRequest(apiKey, buildSearchBody(query, options), options.signal);
+    const results = mapSearchResults(data.Result?.WebResults);
+    const response = { answer: buildAnswer(results), results };
+    activityMonitor.logComplete(activityId, 200);
+    return response;
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, redactedMessage);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+}

package/extensions/dm-web-access/searxng.js

@@ -0,0 +1,223 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { fetchRemoteUrl, loadSsrfConfig } from "./ssrf-protection.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 30000;
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    cachedConfig = JSON.parse(raw);
+    return cachedConfig;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+function normalizeBaseUrl(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return null;
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return null;
+    if (url.username || url.password)
+      return null;
+    url.pathname = url.pathname.replace(/\/+$/, "");
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+function getBaseUrl() {
+  const configured = process.env.SEARXNG_BASE_URL;
+  return configured !== undefined ? normalizeBaseUrl(configured) : normalizeBaseUrl(loadConfig().searxngBaseUrl);
+}
+function isValidHeaderValue(value) {
+  try {
+    new Headers({ "x-dm-web-access-validation": value });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeHeaders(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return {};
+  const headers = {};
+  for (const [key, headerValue] of Object.entries(value)) {
+    if (typeof headerValue !== "string")
+      continue;
+    const name = key.trim();
+    if (!name || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name))
+      continue;
+    if (!isValidHeaderValue(headerValue))
+      continue;
+    headers[name] = headerValue;
+  }
+  return headers;
+}
+function getConfiguredHeaders() {
+  return normalizeHeaders(loadConfig().searxngHeaders);
+}
+function mergeDefaultHeaders(configured) {
+  const headers = { Accept: "application/json" };
+  for (const [name, value] of Object.entries(configured)) {
+    for (const existing of Object.keys(headers)) {
+      if (existing.toLowerCase() === name.toLowerCase())
+        delete headers[existing];
+    }
+    headers[name] = value;
+  }
+  return headers;
+}
+function requireBaseUrl() {
+  const baseUrl = getBaseUrl();
+  if (!baseUrl) {
+    throw new Error(`SearXNG base URL is invalid or missing. Either:
+` + `  1. Create ${CONFIG_PATH} with { "searxngBaseUrl": "https://search.example.com" }
+` + "  2. Set SEARXNG_BASE_URL to an HTTP(S) URL");
+  }
+  return baseUrl;
+}
+function normalizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 5;
+  return Math.max(1, Math.min(Math.floor(value), 20));
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input)
+    return null;
+  if (input.startsWith("-"))
+    input = input.slice(1).trim();
+  if (!input)
+    return null;
+  try {
+    const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
+    input = parsed.hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  input = input.replace(/^\.+|\.+$/g, "");
+  return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function normalizeDomainFilters(domainFilter) {
+  const filters = { allowed: [], blocked: [] };
+  for (const raw of domainFilter ?? []) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? filters.blocked : filters.allowed;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return filters;
+}
+function buildSearXNGQuery(query, filters) {
+  const parts = [query];
+  if (filters.allowed.length === 1) {
+    parts.push(`site:${filters.allowed[0]}`);
+  } else if (filters.allowed.length > 1) {
+    parts.push(filters.allowed.map((domain) => `site:${domain}`).join(" OR "));
+  }
+  for (const domain of filters.blocked)
+    parts.push(`-site:${domain}`);
+  return parts.join(" ");
+}
+function hostMatchesDomain(hostname, domain) {
+  return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function matchesDomainFilters(url, filters) {
+  if (filters.allowed.length === 0 && filters.blocked.length === 0)
+    return true;
+  let hostname;
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (filters.allowed.length > 0 && !filters.allowed.some((domain) => hostMatchesDomain(hostname, domain)))
+    return false;
+  return !filters.blocked.some((domain) => hostMatchesDomain(hostname, domain));
+}
+function mapTimeRange(recencyFilter) {
+  return recencyFilter === "day" || recencyFilter === "week" || recencyFilter === "month" || recencyFilter === "year" ? recencyFilter : null;
+}
+export function isSearXNGAvailable() {
+  const baseUrl = getBaseUrl();
+  if (baseUrl === null)
+    return false;
+  loadSsrfConfig();
+  return true;
+}
+export async function searchWithSearXNG(query, options = {}) {
+  const baseUrl = requireBaseUrl();
+  const numResults = normalizeCount(options.numResults);
+  const filters = normalizeDomainFilters(options.domainFilter);
+  const searchQuery = buildSearXNGQuery(query, filters);
+  const url = new URL(`${baseUrl}/search`);
+  url.searchParams.set("q", searchQuery);
+  url.searchParams.set("format", "json");
+  const timeRange = mapTimeRange(options.recencyFilter);
+  if (timeRange)
+    url.searchParams.set("time_range", timeRange);
+  const activityId = activityMonitor.logStart({ type: "api", query: searchQuery });
+  try {
+    const headers = mergeDefaultHeaders(getConfiguredHeaders());
+    const response = await fetchRemoteUrl(url, {
+      method: "GET",
+      headers,
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    }, {
+      ...loadSsrfConfig(),
+      onRedirect: ({ from, to, init }) => from.origin === to.origin ? init : { ...init, headers: { Accept: "application/json" } }
+    });
+    if (!response.ok) {
+      activityMonitor.logError(activityId, `HTTP ${response.status}`);
+      const errorText = await response.text();
+      throw new Error(`SearXNG search error ${response.status}: ${errorText.slice(0, 300)}`);
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`SearXNG returned invalid JSON: ${message}`);
+    }
+    activityMonitor.logComplete(activityId, response.status);
+    const results = [];
+    for (const item of data.results ?? []) {
+      if (!item.url || !matchesDomainFilters(item.url, filters))
+        continue;
+      results.push({ title: item.title || item.url, url: item.url, snippet: item.content || "" });
+      if (results.length >= numResults)
+        break;
+    }
+    const answerParts = (data.answers ?? []).filter((answer) => typeof answer === "string" && answer.trim().length > 0).map((answer) => answer.trim());
+    answerParts.push(...results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`));
+    return { answer: answerParts.join(`
+
+`), results };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, message);
+    throw err;
+  }
+}

package/extensions/dm-web-access/serpbase.js

@@ -0,0 +1,205 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const SERPBASE_API_URL = "https://api.serpbase.dev/google/search";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 60000;
+const RECENCY_TBS = {
+  day: "qdr:d",
+  week: "qdr:w",
+  month: "qdr:m",
+  year: "qdr:y"
+};
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config in ${CONFIG_PATH}: expected a JSON object`);
+  }
+  cachedConfig = parsed;
+  return cachedConfig;
+}
+async function getApiKey(signal) {
+  return resolveCredential({
+    provider: "SerpBase",
+    configuredValue: loadConfig().serpbaseApiKey,
+    environmentValue: process.env.SERPBASE_API_KEY,
+    signal
+  });
+}
+async function requireApiKey(signal) {
+  const apiKey = await getApiKey(signal);
+  if (!apiKey) {
+    throw new Error(`SerpBase API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "serpbaseApiKey": "your-key" }
+` + `  2. Set SERPBASE_API_KEY environment variable
+` + "Get a key at https://serpbase.dev");
+  }
+  return apiKey;
+}
+function normalizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 10;
+  return Math.max(1, Math.min(Math.floor(value), 20));
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input)
+    return null;
+  if (input.startsWith("-"))
+    input = input.slice(1).trim();
+  if (!input)
+    return null;
+  try {
+    const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
+    input = parsed.hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  input = input.replace(/^\.+|\.+$/g, "");
+  return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function parseDomainFilter(domainFilter) {
+  const filters = { include: [], exclude: [] };
+  if (!domainFilter?.length)
+    return filters;
+  for (const raw of domainFilter) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? filters.exclude : filters.include;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return filters;
+}
+function domainMatches(hostname, domain) {
+  return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function passesDomainFilters(url, filters) {
+  if (filters.include.length === 0 && filters.exclude.length === 0)
+    return true;
+  let hostname;
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (filters.exclude.some((domain) => domainMatches(hostname, domain)))
+    return false;
+  if (filters.include.length === 0)
+    return true;
+  return filters.include.some((domain) => domainMatches(hostname, domain));
+}
+function buildQuery(query, filters) {
+  const parts = [query];
+  if (filters.include.length === 1)
+    parts.push(`site:${filters.include[0]}`);
+  if (filters.include.length > 1)
+    parts.push(`(${filters.include.map((domain) => `site:${domain}`).join(" OR ")})`);
+  for (const domain of filters.exclude)
+    parts.push(`-site:${domain}`);
+  return parts.join(" ");
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function invalidResponse(message) {
+  return new Error(`SerpBase API returned invalid response: ${message}`);
+}
+function parseResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw invalidResponse("expected an object envelope");
+  const envelope = value;
+  if (typeof envelope.error === "string" && envelope.error.trim()) {
+    const suffix = typeof envelope.status === "number" || typeof envelope.status === "string" ? ` (status ${envelope.status})` : "";
+    throw invalidResponse(`${envelope.error}${suffix}`);
+  }
+  const organic = envelope.organic_results ?? envelope.organic ?? envelope.results;
+  if (!Array.isArray(organic))
+    throw invalidResponse("expected organic_results array");
+  return { ...envelope, organic_results: organic };
+}
+function buildAnswer(results) {
+  return results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`);
+}
+export function isSerpBaseAvailable() {
+  return hasCredentialSource({ provider: "SerpBase", configuredValue: loadConfig().serpbaseApiKey, environmentValue: process.env.SERPBASE_API_KEY });
+}
+export async function searchWithSerpBase(query, options = {}) {
+  const apiKey = await requireApiKey(options.signal);
+  const numResults = normalizeCount(options.numResults);
+  const filters = parseDomainFilter(options.domainFilter);
+  const url = new URL(SERPBASE_API_URL);
+  url.searchParams.set("q", buildQuery(query, filters));
+  url.searchParams.set("api_key", apiKey);
+  url.searchParams.set("num", String(numResults));
+  if (options.recencyFilter && RECENCY_TBS[options.recencyFilter])
+    url.searchParams.set("tbs", RECENCY_TBS[options.recencyFilter]);
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, redactedMessage);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    const errorText = redactCredential(await response.text(), apiKey);
+    throw new Error(`SerpBase API error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let rawData;
+  try {
+    rawData = await response.json();
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw new Error(`SerpBase API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  const data = parseResponse(rawData);
+  activityMonitor.logComplete(activityId, response.status);
+  const results = [];
+  for (const item of data.organic_results ?? []) {
+    const url = typeof item.link === "string" ? item.link : typeof item.url === "string" ? item.url : "";
+    if (!url || !passesDomainFilters(url, filters))
+      continue;
+    results.push({
+      title: typeof item.title === "string" && item.title.trim() ? item.title : `Source ${results.length + 1}`,
+      url,
+      snippet: typeof item.snippet === "string" ? item.snippet : typeof item.description === "string" ? item.description : ""
+    });
+    if (results.length >= numResults)
+      break;
+  }
+  return { answer: buildAnswer(results), results };
+}