@duckmind/dm-windows-x64 0.63.0 → 0.63.6

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

@@ -0,0 +1,476 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, hostname, tmpdir } from "node:os";
+import { join } from "node:path";
+let cachedWebSearchConfigDir;
+export function getWebSearchConfigDir() {
+  if (cachedWebSearchConfigDir)
+    return cachedWebSearchConfigDir;
+  const explicitDir = process.env.DM_CODING_AGENT_DIR;
+  if (explicitDir)
+    return cachedWebSearchConfigDir = explicitDir;
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  if (xdgConfigHome) {
+    const xdgDir = join(xdgConfigHome, "pi");
+    if (existsSync(join(xdgDir, "web-search.json")))
+      return cachedWebSearchConfigDir = xdgDir;
+    const legacyDir = join(homedir(), ".dm");
+    if (existsSync(join(legacyDir, "web-search.json")))
+      return cachedWebSearchConfigDir = legacyDir;
+    return cachedWebSearchConfigDir = xdgDir;
+  }
+  return cachedWebSearchConfigDir = join(homedir(), ".dm");
+}
+export function getWebSearchConfigPath() {
+  return join(getWebSearchConfigDir(), "web-search.json");
+}
+export function resolveApiBaseUrl(options) {
+  const fromEnvironment = options.environmentValue !== undefined;
+  const value = fromEnvironment ? options.environmentValue : options.configuredValue;
+  if (value === undefined)
+    return options.defaultValue;
+  const source = fromEnvironment ? options.environmentKey : `${options.configKey} in ${getWebSearchConfigPath()}`;
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${source} must be an absolute HTTP(S) URL`);
+  }
+  let url;
+  try {
+    url = new URL(value.trim());
+  } catch {
+    throw new Error(`${source} must be an absolute HTTP(S) URL`);
+  }
+  if (url.protocol !== "https:") {
+    throw new Error(`${source} must be an absolute HTTPS URL`);
+  }
+  if (url.username || url.password) {
+    throw new Error(`${source} must not include credentials`);
+  }
+  if (url.search || url.hash) {
+    throw new Error(`${source} must not include query parameters or fragments`);
+  }
+  url.search = "";
+  url.hash = "";
+  url.pathname = url.pathname.replace(/\/+$/, "");
+  return url.toString().replace(/\/+$/, "");
+}
+const API_REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+const API_REQUEST_BODY_HEADERS = ["Content-Encoding", "Content-Language", "Content-Location", "Content-Type"];
+const MAX_API_REDIRECTS = 5;
+export async function fetchWithCredentialRedirects(url, init, credentialHeaders) {
+  let current = new URL(url);
+  let requestInit = init;
+  for (let redirects = 0;; redirects++) {
+    const response = await fetch(current, { ...requestInit, redirect: "manual" });
+    if (!API_REDIRECT_STATUSES.has(response.status))
+      return response;
+    const location = response.headers.get("location");
+    if (!location)
+      return response;
+    if (redirects === MAX_API_REDIRECTS) {
+      throw new Error(`Too many API redirects from ${url}`);
+    }
+    const next = new URL(location, current);
+    if (next.protocol !== "http:" && next.protocol !== "https:") {
+      throw new Error(`API redirect from ${current.origin} must use HTTP(S)`);
+    }
+    const method = requestInit.method?.toUpperCase() ?? "GET";
+    if ((response.status === 301 || response.status === 302) && method === "POST" || response.status === 303 && method !== "GET" && method !== "HEAD") {
+      const headers = new Headers(requestInit.headers);
+      for (const name of API_REQUEST_BODY_HEADERS)
+        headers.delete(name);
+      const { body: _body, ...withoutBody } = requestInit;
+      requestInit = { ...withoutBody, method: "GET", headers };
+    }
+    if (next.origin !== current.origin) {
+      const headers = new Headers(requestInit.headers);
+      for (const name of credentialHeaders)
+        headers.delete(name);
+      requestInit = { ...requestInit, headers };
+    }
+    current = next;
+  }
+}
+const LOCAL_CURATOR_NETWORK_DEFAULTS = { enabled: false, host: "localhost", bind: "127.0.0.1" };
+function trimmedString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+export function resolveCuratorNetworkConfig() {
+  const configPath = getWebSearchConfigPath();
+  if (!existsSync(configPath))
+    return LOCAL_CURATOR_NETWORK_DEFAULTS;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return LOCAL_CURATOR_NETWORK_DEFAULTS;
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return LOCAL_CURATOR_NETWORK_DEFAULTS;
+  const curatorRemote = raw.curatorRemote;
+  if (curatorRemote === true)
+    return { enabled: true, host: hostname(), bind: "0.0.0.0" };
+  if (curatorRemote && typeof curatorRemote === "object" && !Array.isArray(curatorRemote)) {
+    const obj = curatorRemote;
+    return {
+      enabled: true,
+      host: trimmedString(obj.host) ?? hostname(),
+      bind: trimmedString(obj.bind) ?? "0.0.0.0"
+    };
+  }
+  return LOCAL_CURATOR_NETWORK_DEFAULTS;
+}
+export function formatSeconds(s) {
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const sec = s % 60;
+  if (h > 0)
+    return `${h}:${String(m).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
+  return `${m}:${String(sec).padStart(2, "0")}`;
+}
+export function readExecError(err) {
+  if (!err || typeof err !== "object") {
+    return { stderr: "", message: String(err) };
+  }
+  const code = err.code;
+  const message = err.message ?? "";
+  const stderrRaw = err.stderr;
+  const stderr = Buffer.isBuffer(stderrRaw) ? stderrRaw.toString("utf-8") : typeof stderrRaw === "string" ? stderrRaw : "";
+  return { code, stderr, message };
+}
+export function isTimeoutError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  if (err.killed)
+    return true;
+  const name = err.name;
+  const code = err.code;
+  const message = err.message ?? "";
+  return name === "AbortError" || code === "ETIMEDOUT" || message.toLowerCase().includes("timed out");
+}
+export function trimErrorText(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+export function mapFfmpegError(err) {
+  const { code, stderr, message } = readExecError(err);
+  if (code === "ENOENT")
+    return "ffmpeg is not installed. Install with: brew install ffmpeg";
+  if (isTimeoutError(err))
+    return "ffmpeg timed out extracting frame";
+  if (stderr.includes("403"))
+    return "Stream URL returned 403 — may have expired, try again";
+  const snippet = trimErrorText(stderr || message);
+  return snippet ? `ffmpeg failed: ${snippet}` : "ffmpeg failed";
+}
+const proxyStorage = new AsyncLocalStorage;
+export function normalizeProxyUrl(value, source) {
+  if (value === undefined || value === null)
+    return null;
+  if (typeof value !== "string")
+    throw new Error(`${source} must be an http(s) proxy URL string`);
+  const trimmed = value.trim();
+  if (!trimmed)
+    return null;
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error(`${source} must be a valid proxy URL: ${JSON.stringify(trimmed)}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`${source} must use the http:// or https:// scheme: ${trimmed}`);
+  }
+  if (!parsed.hostname)
+    throw new Error(`${source} must include a proxy host: ${trimmed}`);
+  parsed.hash = "";
+  parsed.search = "";
+  return parsed.toString();
+}
+function redactProxyUrl(value) {
+  const parsed = new URL(value);
+  if (parsed.username)
+    parsed.username = "redacted";
+  if (parsed.password)
+    parsed.password = "redacted";
+  return parsed.toString();
+}
+function loadConfiguredProxy() {
+  let configured;
+  const path = getWebSearchConfigPath();
+  if (existsSync(path)) {
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(path, "utf-8"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to load proxy config from ${path}: ${message}`);
+    }
+    if (raw && typeof raw === "object" && !Array.isArray(raw))
+      configured = raw.proxy;
+  }
+  if (configured === undefined)
+    return null;
+  return normalizeProxyUrl(configured, `proxy in ${getWebSearchConfigPath()}`);
+}
+export function runWithProxy(proxy, fn) {
+  if (proxy === undefined)
+    return fn();
+  const normalized = normalizeProxyUrl(proxy, "proxy");
+  return proxyStorage.run(normalized, fn);
+}
+export function getActiveProxy() {
+  const scoped = proxyStorage.getStore();
+  return scoped !== undefined ? scoped : loadConfiguredProxy();
+}
+export function hasScopedProxyDecision() {
+  return proxyStorage.getStore() !== undefined;
+}
+function noProxyEntryMatches(hostname, entry) {
+  if (!entry)
+    return false;
+  if (entry === "*")
+    return true;
+  let host = entry;
+  if (host.startsWith("[")) {
+    const close = host.indexOf("]");
+    if (close > 0)
+      host = host.slice(0, close + 1);
+  } else {
+    const colon = host.lastIndexOf(":");
+    if (colon > -1 && /^\d+$/.test(host.slice(colon + 1)))
+      host = host.slice(0, colon);
+  }
+  host = host.toLowerCase().replace(/^\[|\]$/g, "");
+  if (!host)
+    return false;
+  return hostname === host || hostname.endsWith(host.startsWith(".") ? host : `.${host}`);
+}
+export function isProxyBypassedUrl(url) {
+  const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "::1")
+    return true;
+  const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+  if (noProxy && noProxy.split(",").some((entry) => noProxyEntryMatches(hostname, entry.trim())))
+    return true;
+  return false;
+}
+export function installGlobalProxyFetch() {
+  const current = globalThis.fetch;
+  if (typeof current !== "function" || current.__piWebAccessProxyFetch === true)
+    return;
+  const nativeFetch = current;
+  const wrapped = (input, init) => {
+    const proxy = init?.__proxy ?? getActiveProxy();
+    if (!proxy)
+      return nativeFetch(input, init);
+    let url = null;
+    try {
+      url = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
+    } catch {
+      url = null;
+    }
+    if (!url || url.protocol !== "http:" && url.protocol !== "https:" || isProxyBypassedUrl(url)) {
+      return nativeFetch(input, init);
+    }
+    return fetchViaCurl(url, init ?? {}, proxy);
+  };
+  wrapped.__piWebAccessProxyFetch = true;
+  globalThis.fetch = wrapped;
+}
+function parseHeaderDump(dump) {
+  const blocks = dump.split(/\r?\n\r?\n/).filter((block) => /^HTTP\/[\d.]+\s+\d{3}/.test(block.trim()));
+  const block = (blocks.length > 0 ? blocks[blocks.length - 1] : "").trim();
+  const lines = block.split(/\r?\n/);
+  let status = 0;
+  let statusText = "";
+  const headers = [];
+  for (const line of lines) {
+    const match = /^HTTP\/[\d.]+\s+(\d{3})(?:\s+(.*))?$/.exec(line.trim());
+    if (match) {
+      status = Number(match[1]);
+      statusText = match[2] ?? "";
+      headers.length = 0;
+      continue;
+    }
+    const separator = line.indexOf(":");
+    if (separator > 0) {
+      const name = line.slice(0, separator).trim();
+      if (name.toLowerCase() === "content-encoding" || name.toLowerCase() === "content-length")
+        continue;
+      headers.push([name, line.slice(separator + 1).trim()]);
+    }
+  }
+  return { status, statusText, headers };
+}
+
+class CurlTransportError extends Error {
+}
+async function fetchViaCurl(url, init, proxyUrl) {
+  let current = url;
+  let currentInit = init;
+  for (let redirects = 0;; redirects++) {
+    const response = await fetchViaCurlOnce(current, currentInit, proxyUrl);
+    const location = response.headers.get("location");
+    if (!location || ![301, 302, 303, 307, 308].includes(response.status)) {
+      if (redirects > 0)
+        Object.defineProperty(response, "redirected", { value: true, configurable: true });
+      return response;
+    }
+    if (currentInit.redirect === "manual")
+      return response;
+    if (currentInit.redirect === "error")
+      throw new TypeError(`Proxy fetch redirect blocked from ${current.toString()}`);
+    if (redirects === 20)
+      throw new Error(`Too many proxy redirects from ${url.toString()}`);
+    const next = new URL(location, current);
+    if (next.protocol !== "http:" && next.protocol !== "https:")
+      throw new Error(`Proxy redirect from ${current.origin} must use HTTP(S)`);
+    let headers = new Headers(currentInit.headers);
+    let nextInit;
+    const method = currentInit.method?.toUpperCase() ?? "GET";
+    if ((response.status === 301 || response.status === 302) && method === "POST" || response.status === 303 && method !== "GET" && method !== "HEAD") {
+      for (const name of ["Content-Encoding", "Content-Language", "Content-Location", "Content-Type"])
+        headers.delete(name);
+      const { body: _body, ...withoutBody } = currentInit;
+      nextInit = { ...withoutBody, method: "GET", headers };
+    } else {
+      nextInit = { ...currentInit, headers };
+    }
+    if (next.origin !== current.origin) {
+      headers = new Headers;
+      nextInit = { ...nextInit, headers };
+    }
+    current = next;
+    currentInit = nextInit;
+  }
+}
+async function fetchViaCurlOnce(url, init, proxyUrl) {
+  const method = (init.method ?? "GET").toUpperCase();
+  const headers = new Headers(init.headers);
+  const dir = await mkdtemp(join(tmpdir(), "dm-web-access-proxy-"));
+  const headerFile = join(dir, "headers");
+  const bodyFile = join(dir, "body");
+  const requestBodyFile = join(dir, "request-body");
+  const args = [
+    "--silent",
+    "--show-error",
+    "--compressed",
+    "--connect-timeout",
+    "20",
+    "-x",
+    proxyUrl,
+    "-D",
+    headerFile,
+    "--output",
+    bodyFile,
+    "--write-out",
+    "%{json}"
+  ];
+  if (method !== "GET" && method !== "HEAD")
+    args.push("-X", method);
+  for (const [name, value] of headers.entries()) {
+    if (value === "")
+      continue;
+    args.push("-H", `${name}: ${value}`);
+  }
+  const body = init.body;
+  if (body !== undefined && body !== null) {
+    let buffer;
+    if (typeof body === "string")
+      buffer = Buffer.from(body, "utf-8");
+    else if (body instanceof URLSearchParams)
+      buffer = Buffer.from(body.toString(), "utf-8");
+    else if (body instanceof ArrayBuffer)
+      buffer = Buffer.from(body);
+    else if (ArrayBuffer.isView(body))
+      buffer = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    else
+      throw new Error(`Unsupported request body type for proxy fetch: ${typeof body}`);
+    await writeFile(requestBodyFile, buffer);
+    args.push("--data-binary", `@${requestBodyFile}`);
+    if (method === "GET")
+      args.unshift("-X", "GET");
+  }
+  args.push(url.toString());
+  const signal = init.signal ?? null;
+  let stdout;
+  try {
+    stdout = await new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new DOMException("The operation was aborted.", "AbortError"));
+        return;
+      }
+      const child = spawn("curl", args, { windowsHide: true });
+      let out = "";
+      let stderr = "";
+      const onAbort = () => {
+        try {
+          child.kill();
+        } catch {}
+      };
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      child.stdout?.on("data", (chunk) => {
+        out += chunk.toString("utf-8");
+      });
+      child.stderr?.on("data", (chunk) => {
+        if (stderr.length < 4096)
+          stderr += chunk.toString("utf-8");
+      });
+      child.once("error", (err) => {
+        signal?.removeEventListener("abort", onAbort);
+        reject(new CurlTransportError(err.code === "ENOENT" ? "curl executable not found on PATH; proxy transport requires curl" : `curl failed to start: ${err.message}`));
+      });
+      child.once("close", (code) => {
+        signal?.removeEventListener("abort", onAbort);
+        if (signal?.aborted)
+          return reject(new DOMException("The operation was aborted.", "AbortError"));
+        if (code !== 0 && !out.trim()) {
+          return reject(new CurlTransportError(`curl exited with code ${code ?? "unknown"} via ${redactProxyUrl(proxyUrl)}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+        }
+        resolve(out);
+      });
+    });
+  } catch (err) {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+    if (err instanceof CurlTransportError)
+      throw new Error(err.message);
+    throw err;
+  }
+  let bodyBuffer = Buffer.alloc(0);
+  let dump = "";
+  try {
+    [dump, bodyBuffer] = await Promise.all([readFile(headerFile, "utf-8"), readFile(bodyFile)]);
+  } catch {} finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+  const { status, statusText, headers: responseHeaders } = parseHeaderDump(dump);
+  if (status === 0) {
+    throw new Error(`Proxy fetch to ${url.toString()} via ${redactProxyUrl(proxyUrl)} returned no HTTP status`);
+  }
+  let finalUrl = url.toString();
+  let redirected = false;
+  try {
+    const trimmed = stdout.trim();
+    if (trimmed.startsWith("{")) {
+      const writeOut = JSON.parse(trimmed);
+      if (writeOut.url_effective)
+        finalUrl = writeOut.url_effective;
+      redirected = (writeOut.num_redirects ?? 0) > 0;
+    }
+  } catch {}
+  const nullBody = status === 204 || status === 205 || status === 304;
+  const response = new Response(nullBody ? null : new Uint8Array(bodyBuffer), {
+    status,
+    statusText: statusText || undefined,
+    headers: new Headers(responseHeaders)
+  });
+  Object.defineProperty(response, "url", { value: finalUrl, configurable: true });
+  Object.defineProperty(response, "redirected", { value: redirected, configurable: true });
+  return response;
+}

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

@@ -0,0 +1,189 @@
+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 VALYU_SEARCH_URL = "https://api.valyu.ai/v1/search";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 60000;
+const MAX_SNIPPET_CHARS = 2500;
+const MAX_CONTENT_CHARS = 4000;
+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: "Valyu",
+    configuredValue: loadConfig().valyuApiKey,
+    environmentValue: process.env.VALYU_API_KEY,
+    signal
+  });
+}
+async function requireApiKey(signal) {
+  const apiKey = await getApiKey(signal);
+  if (!apiKey) {
+    throw new Error(`Valyu API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "valyuApiKey": "your-key" }
+` + `  2. Set VALYU_API_KEY environment variable
+` + "Get a key at https://platform.valyu.ai");
+  }
+  return apiKey;
+}
+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 mapDomainFilter(domainFilter) {
+  if (!domainFilter?.length)
+    return {};
+  const included_sources = [];
+  const excluded_sources = [];
+  for (const raw of domainFilter) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? excluded_sources : included_sources;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return {
+    ...included_sources.length > 0 ? { included_sources } : {},
+    ...excluded_sources.length > 0 ? { excluded_sources } : {}
+  };
+}
+function recencyToStartDate(filter) {
+  if (!filter)
+    return;
+  const days = { day: 1, week: 7, month: 30, year: 365 }[filter];
+  return days ? new Date(Date.now() - days * 86400000).toISOString().slice(0, 10) : undefined;
+}
+function text(value, limit) {
+  return typeof value === "string" ? value.replace(/\s+/g, " ").trim().slice(0, limit) : "";
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function invalidResponse(message) {
+  return new Error(`Valyu 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 (envelope.success !== true)
+    throw invalidResponse("expected success true");
+  if (!Array.isArray(envelope.results))
+    throw invalidResponse("expected results array");
+  return envelope.results;
+}
+function buildAnswer(results) {
+  return results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`);
+}
+export function isValyuAvailable() {
+  return hasCredentialSource({ provider: "Valyu", configuredValue: loadConfig().valyuApiKey, environmentValue: process.env.VALYU_API_KEY });
+}
+export async function searchWithValyu(query, options = {}) {
+  const apiKey = await requireApiKey(options.signal);
+  const numResults = normalizeCount(options.numResults);
+  const startDate = recencyToStartDate(options.recencyFilter);
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  let response;
+  try {
+    response = await fetch(VALYU_SEARCH_URL, {
+      method: "POST",
+      headers: { "x-api-key": apiKey, "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({ query, max_num_results: numResults, ...mapDomainFilter(options.domainFilter), ...startDate ? { start_date: startDate } : {} }),
+      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(`Valyu 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(`Valyu API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  let entries;
+  try {
+    entries = parseResponse(rawData);
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw err;
+  }
+  activityMonitor.logComplete(activityId, response.status);
+  const results = [];
+  const inlineContent = [];
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const url = text(entry.url, Number.MAX_SAFE_INTEGER);
+    if (!url)
+      continue;
+    const title = text(entry.title, Number.MAX_SAFE_INTEGER) || `Source ${results.length + 1}`;
+    const content = text(entry.content, MAX_CONTENT_CHARS);
+    const description = text(entry.description, MAX_SNIPPET_CHARS);
+    results.push({ title, url, snippet: (content || description).slice(0, MAX_SNIPPET_CHARS) });
+    if (options.includeContent && content)
+      inlineContent.push({ url, title, content, error: null });
+    if (results.length >= numResults)
+      break;
+  }
+  return { answer: buildAnswer(results), results, ...inlineContent.length > 0 ? { inlineContent } : {} };
+}