@duckmind/dm-windows-x64 0.63.0 → 0.63.6

package/extensions/dm-web-access/declared-web-links.js

@@ -0,0 +1,167 @@
+const MAX_DECLARED_LINKS = 20;
+const MAX_DECLARED_URL_LENGTH = 4096;
+const DECLARATION_RELATIONS = new Set([
+  "api-catalog",
+  "describedby",
+  "service-desc",
+  "service-doc",
+  "service-meta"
+]);
+const RELATION_LABELS = {
+  "api-catalog": "API catalog",
+  describedby: "Description",
+  "service-desc": "Service description",
+  "service-doc": "Service documentation",
+  "service-meta": "Service metadata"
+};
+export function discoverDeclaredWebLinks(document, linkHeader, responseUrl) {
+  const links = new Map;
+  for (const value of splitLinkHeader(linkHeader ?? "")) {
+    const target = /^\s*<([^>]*)>/.exec(value);
+    if (!target)
+      continue;
+    const parameters = parseLinkParameters(value.slice(target[0].length));
+    if (!parameters || parameters.has("anchor"))
+      continue;
+    addDeclaredLink(links, {
+      url: resolveHttpUrl(target[1], responseUrl),
+      relations: declaredRelations(parameters.get("rel")),
+      type: parameters.get("type")
+    });
+    if (links.size >= MAX_DECLARED_LINKS)
+      break;
+  }
+  if (links.size < MAX_DECLARED_LINKS) {
+    const declaredBase = document.querySelector("base[href]")?.getAttribute("href");
+    const documentBase = resolveHttpUrl(declaredBase, responseUrl) ?? responseUrl;
+    for (const element of document.querySelectorAll("link[rel][href], a[rel][href]")) {
+      addDeclaredLink(links, {
+        url: resolveHttpUrl(element.getAttribute("href"), documentBase),
+        relations: declaredRelations(element.getAttribute("rel")),
+        type: element.getAttribute("type")
+      });
+      if (links.size >= MAX_DECLARED_LINKS)
+        break;
+    }
+  }
+  return [...links.values()];
+}
+export function appendDeclaredWebLinks(content, links) {
+  if (links.length === 0)
+    return content;
+  const section = [
+    "## Declared links",
+    "",
+    ...links.map(formatDeclaredLink)
+  ].join(`
+`);
+  return content.trim() ? `${content.trim()}
+
+${section}` : section;
+}
+function addDeclaredLink(links, candidate) {
+  if (!candidate.url || candidate.relations.length === 0)
+    return;
+  const existing = links.get(candidate.url);
+  if (existing) {
+    for (const relation of candidate.relations) {
+      if (!existing.relations.includes(relation))
+        existing.relations.push(relation);
+    }
+    if (!existing.type)
+      existing.type = normalizeMetadata(candidate.type);
+    return;
+  }
+  if (links.size >= MAX_DECLARED_LINKS)
+    return;
+  const type = normalizeMetadata(candidate.type);
+  links.set(candidate.url, {
+    url: candidate.url,
+    relations: candidate.relations,
+    ...type ? { type } : {}
+  });
+}
+function declaredRelations(value) {
+  if (!value)
+    return [];
+  return [...new Set(value.trim().toLowerCase().split(/\s+/).filter((relation) => DECLARATION_RELATIONS.has(relation)))];
+}
+function resolveHttpUrl(value, baseUrl) {
+  if (!value || value.length > MAX_DECLARED_URL_LENGTH)
+    return null;
+  try {
+    const url = new URL(value, baseUrl);
+    if (url.href.length > MAX_DECLARED_URL_LENGTH)
+      return null;
+    return url.protocol === "http:" || url.protocol === "https:" ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+function splitOutsideSyntax(input, separator, protectTargets) {
+  const parts = [];
+  let start = 0;
+  let inTarget = false;
+  let inQuotes = false;
+  let escaped = false;
+  for (let index = 0;index < input.length; index++) {
+    const character = input[index];
+    if (inQuotes) {
+      if (escaped)
+        escaped = false;
+      else if (character === "\\")
+        escaped = true;
+      else if (character === '"')
+        inQuotes = false;
+      continue;
+    }
+    if (character === '"' && !inTarget)
+      inQuotes = true;
+    else if (protectTargets && character === "<")
+      inTarget = true;
+    else if (protectTargets && character === ">")
+      inTarget = false;
+    else if (character === separator && !inTarget) {
+      parts.push(input.slice(start, index));
+      start = index + 1;
+    }
+  }
+  if (inQuotes || inTarget)
+    return null;
+  parts.push(input.slice(start));
+  return parts;
+}
+function splitLinkHeader(header) {
+  return (splitOutsideSyntax(header, ",", true) ?? []).map((value) => value.trim()).filter(Boolean);
+}
+function parseLinkParameters(input) {
+  const parts = splitOutsideSyntax(input, ";", false);
+  if (!parts || parts.shift()?.trim())
+    return null;
+  const parameters = new Map;
+  for (const part of parts) {
+    const match = /^\s*([!#$%&'*+\-.^_`|~A-Za-z0-9]+)(?:\s*=\s*(?:"((?:\\.|[^"])*)"|(\S+)))?\s*$/.exec(part);
+    if (!match)
+      return null;
+    const name = match[1].toLowerCase();
+    const value = match[2] === undefined ? match[3] ?? "" : match[2].replace(/\\(.)/g, "$1");
+    if (!parameters.has(name))
+      parameters.set(name, value);
+  }
+  return parameters;
+}
+function normalizeMetadata(value) {
+  if (!value)
+    return;
+  const normalized = value.replace(/\s+/g, " ").trim().slice(0, 160);
+  return normalized || undefined;
+}
+function formatDeclaredLink(link) {
+  const relation = link.relations.map(inlineCode).join(", ");
+  const type = link.type ? `; ${inlineCode(link.type)}` : "";
+  const label = RELATION_LABELS[link.relations[0]] ?? "Declared link";
+  return `- ${label} (${relation}${type}): <${link.url}>`;
+}
+function inlineCode(value) {
+  return `\`${value.replace(/`/g, "'")}\``;
+}

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

@@ -0,0 +1,118 @@
+import { parseHTML } from "linkedom";
+import { activityMonitor } from "./activity.js";
+const SEARCH_URL = "https://html.duckduckgo.com/html/";
+const SEARCH_TIMEOUT_MS = 30000;
+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 hostMatchesDomain(hostname, domain) {
+  return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function matchesDomainFilters(url, filters) {
+  if (filters.allowed.length === 0 && filters.blocked.length === 0)
+    return true;
+  const hostname = new URL(url).hostname.toLowerCase();
+  if (filters.allowed.length > 0 && !filters.allowed.some((domain) => hostMatchesDomain(hostname, domain)))
+    return false;
+  return !filters.blocked.some((domain) => hostMatchesDomain(hostname, domain));
+}
+function decodeResultUrl(href) {
+  try {
+    const link = new URL(href, SEARCH_URL);
+    const destination = link.searchParams.get("uddg") ?? link.href;
+    const url = new URL(destination);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+export function isDuckDuckGoAvailable() {
+  return true;
+}
+export async function searchWithDuckDuckGo(query, options = {}) {
+  const url = new URL(SEARCH_URL);
+  url.searchParams.set("q", query);
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "text/html",
+        "User-Agent": "Mozilla/5.0 (compatible; dm-web-access/1.0; +https://github.com/nicobailon/dm-web-access)"
+      },
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`DuckDuckGo search error ${response.status}: ${body.slice(0, 300)}`);
+    }
+    const { document } = parseHTML(await response.text());
+    const filters = normalizeDomainFilters(options.domainFilter);
+    const results = [];
+    let parseableResults = 0;
+    for (const container of document.querySelectorAll(".result")) {
+      if (container.classList.contains("result--ad"))
+        continue;
+      const anchor = container.querySelector(".result__a");
+      const title = anchor?.textContent?.trim() ?? "";
+      const href = anchor?.getAttribute("href")?.trim() ?? "";
+      const resultUrl = href ? decodeResultUrl(href) : null;
+      if (!title || !resultUrl)
+        continue;
+      parseableResults++;
+      if (!matchesDomainFilters(resultUrl, filters))
+        continue;
+      const snippet = container.querySelector(".result__snippet")?.textContent?.trim() ?? "";
+      results.push({ title, url: resultUrl, snippet });
+      if (results.length >= normalizeCount(options.numResults))
+        break;
+    }
+    if (parseableResults === 0) {
+      throw new Error("DuckDuckGo returned no parseable results (invalid response)");
+    }
+    activityMonitor.logComplete(activityId, response.status);
+    const answer = results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`);
+    return { answer, 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/exa.js

@@ -0,0 +1,401 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { fetchWithCredentialRedirects, getWebSearchConfigPath, resolveApiBaseUrl } from "./utils.js";
+const EXA_API_BASE_URL = "https://api.exa.ai";
+const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
+const CONFIG_PATH = getWebSearchConfigPath();
+const EXA_MCP_ADVANCED_TOOL = "web_search_advanced_exa";
+const EXA_MCP_BASIC_TOOL = "web_search_exa";
+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}`);
+  }
+}
+async function getApiKey(signal) {
+  return resolveCredential({
+    provider: "Exa",
+    configuredValue: loadConfig().exaApiKey,
+    environmentValue: process.env.EXA_API_KEY,
+    signal
+  });
+}
+function getApiBaseUrl() {
+  return resolveApiBaseUrl({
+    configKey: "exaBaseUrl",
+    configuredValue: loadConfig().exaBaseUrl,
+    defaultValue: EXA_API_BASE_URL,
+    environmentKey: "EXA_BASE_URL",
+    environmentValue: process.env.EXA_BASE_URL
+  });
+}
+function exaApiHeaders(apiKey) {
+  return {
+    "x-api-key": apiKey,
+    "Content-Type": "application/json",
+    "x-exa-integration": "dm-web-access"
+  };
+}
+function requestSignal(signal) {
+  const timeout = AbortSignal.timeout(60000);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function recencyToStartDate(filter) {
+  const now = new Date;
+  const offsets = {
+    day: 1,
+    week: 7,
+    month: 30,
+    year: 365
+  };
+  const days = offsets[filter] ?? 0;
+  return new Date(now.getTime() - days * 86400000).toISOString();
+}
+function mapDomainFilter(domainFilter) {
+  if (!domainFilter?.length)
+    return {};
+  const includeDomains = domainFilter.filter((d) => !d.startsWith("-") && d.trim().length > 0).map((d) => d.trim());
+  const excludeDomains = domainFilter.filter((d) => d.startsWith("-")).map((d) => d.slice(1).trim()).filter(Boolean);
+  return {
+    ...includeDomains.length ? { includeDomains } : {},
+    ...excludeDomains.length ? { excludeDomains } : {}
+  };
+}
+function exaSearchArgs(query, options) {
+  const startDate = options.recencyFilter ? recencyToStartDate(options.recencyFilter) : null;
+  return {
+    query,
+    type: "auto",
+    numResults: options.numResults ?? 5,
+    ...mapDomainFilter(options.domainFilter),
+    ...startDate ? { startPublishedDate: startDate } : {}
+  };
+}
+function normalizeHighlights(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function buildAnswerFromSearchResults(results) {
+  if (!results?.length)
+    return "";
+  const parts = [];
+  for (let i = 0;i < results.length; i++) {
+    const item = results[i];
+    if (!item?.url)
+      continue;
+    const highlights = normalizeHighlights(item.highlights);
+    const content = highlights.length > 0 ? highlights.join(" ") : typeof item.text === "string" ? item.text.trim().slice(0, 1000) : "";
+    if (!content)
+      continue;
+    const sourceTitle = item.title || `Source ${i + 1}`;
+    parts.push(`${content}
+Source: ${sourceTitle} (${item.url})`);
+  }
+  return parts.join(`
+
+`);
+}
+function mapResults(results) {
+  if (!Array.isArray(results))
+    return [];
+  const mapped = [];
+  for (let i = 0;i < results.length; i++) {
+    const item = results[i];
+    if (!item?.url)
+      continue;
+    mapped.push({
+      title: item.title || `Source ${i + 1}`,
+      url: item.url,
+      snippet: ""
+    });
+  }
+  return mapped;
+}
+function mapInlineContent(results) {
+  if (!results?.length)
+    return [];
+  return results.filter((r) => !!r?.url && typeof r.text === "string" && r.text.length > 0).map((r) => ({
+    url: r.url,
+    title: r.title || "",
+    content: r.text,
+    error: null
+  }));
+}
+function toSearchResponse(answer, results, inlineContent) {
+  const response = { answer, results };
+  if (inlineContent?.length)
+    response.inlineContent = inlineContent;
+  return response;
+}
+export async function callExaMcp(toolName, args, signal) {
+  const response = await fetch(`${EXA_MCP_URL}?tools=${toolName}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      "x-exa-source": "dm-web-access"
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: {
+        name: toolName,
+        arguments: args
+      }
+    }),
+    signal: requestSignal(signal)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    if (response.status === 429) {
+      throw new Error(`Exa MCP rate limit reached (429). Add "exaApiKey" to ${CONFIG_PATH} for unthrottled Exa search: ${errorText.slice(0, 200)}`);
+    }
+    throw new Error(`Exa MCP error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  const body = await response.text();
+  const dataLines = body.split(`
+`).filter((line) => line.startsWith("data:"));
+  let parsed = null;
+  for (const line of dataLines) {
+    const payload = line.slice(5).trim();
+    if (!payload)
+      continue;
+    try {
+      const candidate = JSON.parse(payload);
+      if (candidate?.result || candidate?.error) {
+        parsed = candidate;
+        break;
+      }
+    } catch {}
+  }
+  if (!parsed) {
+    try {
+      const candidate = JSON.parse(body);
+      if (candidate?.result || candidate?.error) {
+        parsed = candidate;
+      }
+    } catch {}
+  }
+  if (!parsed) {
+    throw new Error("Exa MCP returned an empty response");
+  }
+  if (parsed.error) {
+    const code = typeof parsed.error.code === "number" ? ` ${parsed.error.code}` : "";
+    const message = parsed.error.message || "Unknown error";
+    throw new Error(`Exa MCP error${code}: ${message}`);
+  }
+  if (parsed.result?.isError) {
+    const message = parsed.result.content?.find((item) => item.type === "text" && typeof item.text === "string")?.text?.trim();
+    throw new Error(message || "Exa MCP returned an error");
+  }
+  const text = parsed.result?.content?.find((item) => item.type === "text" && typeof item.text === "string" && item.text.trim().length > 0)?.text;
+  if (!text) {
+    throw new Error("Exa MCP returned empty content");
+  }
+  return text;
+}
+function parseMcpResults(text) {
+  const blocks = text.split(/(?=^Title: )/m).filter((block) => block.trim().length > 0);
+  const parsed = blocks.map((block) => {
+    const title = block.match(/^Title: (.+)/m)?.[1]?.trim() ?? "";
+    const url = block.match(/^URL: (.+)/m)?.[1]?.trim() ?? "";
+    let content = "";
+    const textStart = block.indexOf(`
+Text: `);
+    if (textStart >= 0) {
+      content = block.slice(textStart + 7).trim();
+    } else {
+      const hlMatch = block.match(/\nHighlights:\s*\n/);
+      if (hlMatch?.index != null) {
+        content = block.slice(hlMatch.index + hlMatch[0].length).trim();
+      }
+    }
+    content = content.replace(/\n---\s*$/, "").trim();
+    return { title, url, content };
+  }).filter((result) => result.url.length > 0);
+  return parsed.length > 0 ? parsed : null;
+}
+function buildAnswerFromMcpResults(results) {
+  if (results.length === 0)
+    return "";
+  const parts = [];
+  for (let i = 0;i < results.length; i++) {
+    const result = results[i];
+    const snippet = result.content.replace(/\s+/g, " ").trim().slice(0, 500);
+    if (!snippet)
+      continue;
+    const sourceTitle = result.title || `Source ${i + 1}`;
+    parts.push(`${snippet}
+Source: ${sourceTitle} (${result.url})`);
+  }
+  return parts.join(`
+
+`);
+}
+function mapMcpInlineContent(results) {
+  return results.filter((result) => result.content.length > 0).map((result) => ({
+    url: result.url,
+    title: result.title,
+    content: result.content,
+    error: null
+  }));
+}
+function buildMcpQuery(query, options) {
+  const parts = [query];
+  if (options.domainFilter?.length) {
+    for (const d of options.domainFilter) {
+      parts.push(d.startsWith("-") ? `-site:${d.slice(1)}` : `site:${d}`);
+    }
+  }
+  if (options.recencyFilter) {
+    const now = new Date;
+    switch (options.recencyFilter) {
+      case "day":
+        parts.push("past 24 hours");
+        break;
+      case "week":
+        parts.push("past week");
+        break;
+      case "month":
+        parts.push(`${now.toLocaleString("en", { month: "long" })} ${now.getFullYear()}`);
+        break;
+      case "year":
+        parts.push(String(now.getFullYear()));
+        break;
+    }
+  }
+  return parts.join(" ");
+}
+function isAbortMessage(message) {
+  return message.toLowerCase().includes("abort");
+}
+function parseJsonMcpResults(text) {
+  try {
+    const results = JSON.parse(text).results;
+    return Array.isArray(results) && results.length > 0 ? results : null;
+  } catch {
+    return null;
+  }
+}
+async function searchWithExaMcpTool(tool, args, options) {
+  const text = await callExaMcp(tool, args, options.signal);
+  const jsonResults = parseJsonMcpResults(text);
+  if (jsonResults) {
+    return toSearchResponse(buildAnswerFromSearchResults(jsonResults), mapResults(jsonResults), options.includeContent ? mapInlineContent(jsonResults) : null);
+  }
+  const textResults = parseMcpResults(text);
+  if (!textResults)
+    return null;
+  return toSearchResponse(buildAnswerFromMcpResults(textResults), mapResults(textResults), options.includeContent ? mapMcpInlineContent(textResults) : null);
+}
+async function searchWithFilteredExaMcp(query, options, basicArgs) {
+  try {
+    return await searchWithExaMcpTool(EXA_MCP_ADVANCED_TOOL, {
+      ...exaSearchArgs(query, options),
+      enableHighlights: true,
+      textMaxCharacters: options.includeContent ? 50000 : 3000
+    }, options);
+  } catch (err) {
+    if (isAbortMessage(err instanceof Error ? err.message : String(err)))
+      throw err;
+    return searchWithExaMcpTool(EXA_MCP_BASIC_TOOL, basicArgs, options);
+  }
+}
+async function searchWithExaMcp(query, options = {}) {
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  const basicArgs = { query: buildMcpQuery(query, options), numResults: options.numResults ?? 5 };
+  const filtered = !!options.includeContent || !!options.recencyFilter || !!options.domainFilter?.length;
+  try {
+    const response = filtered ? await searchWithFilteredExaMcp(query, options, basicArgs) : await searchWithExaMcpTool(EXA_MCP_BASIC_TOOL, basicArgs, options);
+    activityMonitor.logComplete(activityId, 200);
+    return response;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (isAbortMessage(message)) {
+      activityMonitor.logComplete(activityId, 0);
+    } else {
+      activityMonitor.logError(activityId, message);
+    }
+    throw err;
+  }
+}
+export function isExaAvailable() {
+  return true;
+}
+export function hasExaApiKey() {
+  return hasCredentialSource({
+    provider: "Exa",
+    configuredValue: loadConfig().exaApiKey,
+    environmentValue: process.env.EXA_API_KEY
+  });
+}
+export async function searchWithExa(query, options = {}) {
+  const apiKey = await getApiKey(options.signal);
+  if (!apiKey) {
+    return searchWithExaMcp(query, options);
+  }
+  const apiBaseUrl = getApiBaseUrl();
+  const useSearch = options.includeContent || !!options.recencyFilter || !!options.domainFilter?.length || !!(options.numResults && options.numResults !== 5);
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  try {
+    if (!useSearch) {
+      const response = await fetchWithCredentialRedirects(`${apiBaseUrl}/answer`, {
+        method: "POST",
+        headers: exaApiHeaders(apiKey),
+        body: JSON.stringify({ query }),
+        signal: requestSignal(options.signal)
+      }, ["x-api-key"]);
+      if (!response.ok) {
+        const errorText = redactCredential(await response.text(), apiKey);
+        throw new Error(`Exa API error ${response.status}: ${errorText.slice(0, 300)}`);
+      }
+      const data = await response.json();
+      activityMonitor.logComplete(activityId, response.status);
+      return {
+        answer: data.answer || "",
+        results: mapResults(data.citations)
+      };
+    }
+    const response = await fetchWithCredentialRedirects(`${apiBaseUrl}/search`, {
+      method: "POST",
+      headers: exaApiHeaders(apiKey),
+      body: JSON.stringify({
+        ...exaSearchArgs(query, options),
+        contents: options.includeContent ? { text: true, highlights: true } : { highlights: true }
+      }),
+      signal: requestSignal(options.signal)
+    }, ["x-api-key"]);
+    if (!response.ok) {
+      const errorText = redactCredential(await response.text(), apiKey);
+      throw new Error(`Exa API error ${response.status}: ${errorText.slice(0, 300)}`);
+    }
+    const data = await response.json();
+    activityMonitor.logComplete(activityId, response.status);
+    return toSearchResponse(buildAnswerFromSearchResults(data.results), mapResults(data.results), options.includeContent ? mapInlineContent(data.results) : null);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (isAbortMessage(redactedMessage)) {
+      activityMonitor.logComplete(activityId, 0);
+    } else {
+      activityMonitor.logError(activityId, redactedMessage);
+    }
+    if (redactedMessage === message)
+      throw err;
+    throw new Error(redactedMessage);
+  }
+}