open-research 0.1.26 → 1.0.0

package/dist/query-agent-LRUUJR4F.js

@@ -0,0 +1,193 @@
+import {
+  loadOntology
+} from "./chunk-3WM33M3O.js";
+import {
+  getConnections,
+  getNote,
+  searchNotes
+} from "./chunk-IOR7G25X.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/lib/ontology/query-agent.ts
+var SYSTEM_PROMPT = `You answer research questions by reading a project's ontology \u2014 a structured graph of sources, findings, claims, questions, methods, and insights connected by typed edges (supports, contradicts, derived-from, relates-to).
+
+# How to search
+
+Pick the right strategy based on the question type:
+
+| Question type | Search approach | Example |
+|---------------|----------------|---------|
+| Structural | Use filters only (no text) | "unsupported claims" \u2192 { kind: "claim", missingEdge: "supports" } |
+| Specific entity | Text query + kind filter | "Smith 2024 findings" \u2192 { queries: ["Smith 2024"], kind: "source" } then follow derived-from edges |
+| Broad topic | Multiple synonym phrases | "attention efficiency" \u2192 { queries: ["attention efficiency", "quadratic scaling", "computational cost"] } |
+| Evidence chain | Find the claim, then traverse | search for claim \u2192 get_connections depth 2 \u2192 follow supports/contradicts edges |
+
+After finding any node, ALWAYS call get_connections to explore its neighborhood. The most relevant notes are often one edge away from a search result.
+
+# Response rules
+
+- Write for a researcher: be precise, cite specific sources and page/table numbers when available
+- Always state the confidence level of claims and findings you reference
+- When reporting contradictions, present BOTH sides with their edge contexts \u2014 do not take a side
+- Explicitly say what's NOT in the ontology: "The ontology has no data on X" is a useful answer
+- Never include raw note IDs \u2014 use source names and natural language references
+- Aim for 100-300 words. Longer for complex evidence chains. Shorter for simple lookups.`;
+var QUERY_TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "get_note",
+      description: "Retrieve a single note by ID. Returns full content, kind, confidence, all edges with their contexts, and source metadata. Use when you have a note ID from search results or edge targets and need the complete details.",
+      parameters: {
+        type: "object",
+        properties: {
+          noteId: { type: "string", description: "UUID of the note" }
+        },
+        required: ["noteId"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "search_notes",
+      description: "Find notes by text and/or structural filters. Include 2-3 synonym phrases for broad queries. Combine text with kind filter for precision. Use structural filters for graph-shape queries (e.g. unsupported claims \u2192 { kind: 'claim', missingEdge: 'supports' }).",
+      parameters: {
+        type: "object",
+        properties: {
+          queries: { type: "array", items: { type: "string" }, description: "Text search phrases (OR logic). Include synonyms: ['attention efficiency', 'quadratic scaling', 'computational cost']" },
+          kind: { type: "string", enum: ["source", "finding", "claim", "question", "method", "insight"] },
+          confidence: { type: "string", enum: ["established", "supported", "hypothesized", "questioned", "refuted"] },
+          hasEdge: { type: "string", enum: ["supports", "contradicts", "derived-from", "relates-to"], description: "Note must have at least one edge of this type" },
+          missingEdge: { type: "string", enum: ["supports", "contradicts", "derived-from", "relates-to"], description: "Note must have NO edges of this type" },
+          limit: { type: "number", description: "Max results. Default: 10" }
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_connections",
+      description: "Explore a note's neighborhood by traversing edges. Returns the note and all connected notes within N hops. ALWAYS call after search_notes finds a relevant node \u2014 the most important information is often one edge away.",
+      parameters: {
+        type: "object",
+        properties: {
+          noteId: { type: "string", description: "Starting note ID" },
+          depth: { type: "number", description: "Hops to traverse. Default: 1 (immediate neighbors). Use 2 for evidence chains." }
+        },
+        required: ["noteId"],
+        additionalProperties: false
+      }
+    }
+  }
+];
+function executeQueryTool(name, args, ontology) {
+  switch (name) {
+    case "get_note": {
+      const note = getNote(ontology, String(args.noteId));
+      if (!note) return `Note not found: ${args.noteId}`;
+      return JSON.stringify(note, null, 2);
+    }
+    case "search_notes": {
+      const results = searchNotes(ontology, {
+        queries: args.queries,
+        kind: args.kind,
+        confidence: args.confidence,
+        hasEdge: args.hasEdge,
+        missingEdge: args.missingEdge,
+        limit: args.limit
+      });
+      if (results.length === 0) return "No matching notes found.";
+      return results.map(
+        (n) => `[${n.id}] (${n.kind}, ${n.confidence}) "${n.content}" \u2014 ${n.edges.length} edges`
+      ).join("\n");
+    }
+    case "get_connections": {
+      const { root, connected } = getConnections(
+        ontology,
+        String(args.noteId),
+        args.depth ?? 1
+      );
+      if (!root) return `Note not found: ${args.noteId}`;
+      const lines = [
+        `Root: [${root.id}] (${root.kind}, ${root.confidence}) "${root.content}"`,
+        `Edges: ${root.edges.map((e) => `${e.relation}(${e.strength}) \u2192 ${e.targetId} \u2014 "${e.context}"`).join("\n  ") || "none"}`,
+        `Connected (${connected.length}):`,
+        ...connected.map(
+          (c) => `  [${c.id}] (${c.kind}, ${c.confidence}) "${c.content}" \u2014 edges: ${c.edges.map((e) => `${e.relation} \u2192 ${e.targetId.slice(0, 8)}`).join(", ") || "none"}`
+        )
+      ];
+      return lines.join("\n");
+    }
+    default:
+      return `Unknown tool: ${name}`;
+  }
+}
+var MAX_ITERATIONS = 8;
+async function runQueryAgent(input) {
+  const ontology = await loadOntology(input.workspaceDir);
+  if (ontology.notes.length === 0) {
+    return "The ontology is empty \u2014 no notes have been captured yet. As you do research, the ontology will automatically populate with sources, findings, and claims.";
+  }
+  const userMessage = input.scope ? `${input.query}
+
+(Focus on: ${input.scope})` : input.query;
+  const messages = [
+    { role: "system", content: SYSTEM_PROMPT },
+    { role: "user", content: userMessage }
+  ];
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    let fullText = "";
+    let toolCalls = [];
+    for await (const chunk of input.provider.callLLMStreaming({
+      messages,
+      tools: QUERY_TOOLS,
+      model: "gpt-5.4-mini"
+    })) {
+      if (chunk.type === "text_delta") {
+        fullText += chunk.content;
+      } else if (chunk.type === "done") {
+        toolCalls = chunk.toolCalls;
+      }
+    }
+    if (toolCalls.length === 0) {
+      return fullText || "(Query agent returned empty response)";
+    }
+    messages.push({
+      role: "assistant",
+      content: fullText || null,
+      tool_calls: toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }))
+    });
+    for (const toolCall of toolCalls) {
+      const args = JSON.parse(toolCall.arguments || "{}");
+      const result = executeQueryTool(toolCall.name, args, ontology);
+      messages.push({
+        role: "tool",
+        tool_call_id: toolCall.id,
+        content: result
+      });
+    }
+  }
+  messages.push({
+    role: "user",
+    content: "Summarize what you've found so far. Be concise."
+  });
+  let finalText = "";
+  for await (const chunk of input.provider.callLLMStreaming({
+    messages,
+    model: "gpt-5.4-mini"
+  })) {
+    if (chunk.type === "text_delta") finalText += chunk.content;
+  }
+  return finalText || "(Query agent could not synthesize an answer)";
+}
+export {
+  runQueryAgent
+};

package/dist/read-tools-GHBKBZFE.js

@@ -0,0 +1,13 @@
+import {
+  findExistingSource,
+  getConnections,
+  getNote,
+  searchNotes
+} from "./chunk-IOR7G25X.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  findExistingSource,
+  getConnections,
+  getNote,
+  searchNotes
+};

package/dist/relevance-agent-CCN7JGTM.js

@@ -0,0 +1,74 @@
+import "./chunk-3RG5ZIWI.js";
+
+// src/lib/ontology/relevance-agent.ts
+function shouldRunRelevanceAgent(message, ontology) {
+  if (ontology.notes.length === 0) return false;
+  if (message.startsWith("/")) return false;
+  if (message.length < 15) return false;
+  if (/^(hi|hello|hey|thanks|thank you|ok|yes|no|sure|got it)\b/i.test(message)) return false;
+  return true;
+}
+var SYSTEM_PROMPT = `You select which notes from a research ontology are relevant to the user's current message.
+
+Return a JSON array of note IDs. Nothing else \u2014 no markdown, no explanation, no text outside the array.
+
+# Selection criteria
+
+Include a note if ANY of these apply:
+- It is about the same topic or concept (even using different terminology)
+- It provides evidence for or against what the user is discussing
+- It is a source, finding, or method referenced directly or indirectly
+- It contains a contradiction or open question the user should be aware of
+
+Prioritize: claims with contradictions > claims the user is building on > directly relevant findings > contextual sources > tangential notes.
+
+# Output
+
+- Return 5-15 IDs (fewer if few are relevant, more if the topic is well-covered)
+- Return [] if nothing is relevant
+- Output ONLY a JSON array: ["id1", "id2", ...]`;
+function buildNoteList(notes) {
+  return notes.map((n) => `[${n.id}] "${n.content}" (${n.kind})`).join("\n");
+}
+async function runRelevanceAgent(input) {
+  const { userMessage, ontology, provider } = input;
+  if (!shouldRunRelevanceAgent(userMessage, ontology)) {
+    return [];
+  }
+  let candidates = ontology.notes;
+  if (candidates.length > 100) {
+    candidates = [...candidates].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, 100);
+  }
+  const noteList = buildNoteList(candidates);
+  try {
+    const response = await provider.callLLM({
+      messages: [
+        { role: "system", content: SYSTEM_PROMPT },
+        {
+          role: "user",
+          content: `## User's message
+${userMessage}
+
+## Notes in ontology
+${noteList}`
+        }
+      ],
+      model: "gpt-5.4-mini",
+      maxTokens: 500,
+      temperature: 0
+    });
+    const raw = response.content.trim();
+    const jsonStr = raw.startsWith("[") ? raw : raw.match(/\[[\s\S]*\]/)?.[0];
+    if (!jsonStr) return [];
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed)) return [];
+    const noteIds = new Set(ontology.notes.map((n) => n.id));
+    return parsed.filter((id) => typeof id === "string" && noteIds.has(id)).slice(0, 15);
+  } catch {
+    return [];
+  }
+}
+export {
+  runRelevanceAgent,
+  shouldRunRelevanceAgent
+};

package/dist/scaffolding-MSAICMWV.js

@@ -0,0 +1,90 @@
+import {
+  getNote
+} from "./chunk-IOR7G25X.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/lib/ontology/scaffolding.ts
+function buildScaffoldingContext(ontology, relevantIds) {
+  if (relevantIds.length === 0) return null;
+  const notes = relevantIds.map((id) => getNote(ontology, id)).filter((n) => n !== null);
+  if (notes.length === 0) return null;
+  const byKind = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    const group = byKind.get(note.kind) ?? [];
+    group.push(note);
+    byKind.set(note.kind, group);
+  }
+  const supportCount = /* @__PURE__ */ new Map();
+  const contradictCount = /* @__PURE__ */ new Map();
+  for (const note of ontology.notes) {
+    for (const edge of note.edges) {
+      if (edge.relation === "supports") {
+        supportCount.set(edge.targetId, (supportCount.get(edge.targetId) ?? 0) + 1);
+      }
+      if (edge.relation === "contradicts") {
+        contradictCount.set(edge.targetId, (contradictCount.get(edge.targetId) ?? 0) + 1);
+      }
+    }
+  }
+  const lines = ["## Ontology Context", ""];
+  lines.push("Your project ontology contains the following related to this topic:");
+  lines.push("");
+  const claims = byKind.get("claim") ?? [];
+  for (const claim of claims) {
+    const s = supportCount.get(claim.id) ?? 0;
+    const c = contradictCount.get(claim.id) ?? 0;
+    const evidence = [];
+    if (s > 0) evidence.push(`${s} supporting`);
+    if (c > 0) evidence.push(`${c} contradicting`);
+    const evidenceStr = evidence.length > 0 ? `, ${evidence.join(", ")}` : "";
+    lines.push(`- CLAIM: "${truncate(claim.content, 120)}" (${claim.confidence}${evidenceStr})`);
+  }
+  const findings = byKind.get("finding") ?? [];
+  if (findings.length > 0) {
+    const sourceNames = /* @__PURE__ */ new Set();
+    for (const f of findings) {
+      for (const edge of f.edges) {
+        if (edge.relation === "derived-from") {
+          const source = getNote(ontology, edge.targetId);
+          if (source) sourceNames.add(truncate(source.content, 40));
+        }
+      }
+    }
+    const from = sourceNames.size > 0 ? ` from ${[...sourceNames].join(", ")}` : "";
+    lines.push(`- ${findings.length} finding${findings.length !== 1 ? "s" : ""}${from}`);
+  }
+  const sources = byKind.get("source") ?? [];
+  if (sources.length > 0) {
+    lines.push(`- ${sources.length} source${sources.length !== 1 ? "s" : ""}: ${sources.map((s) => truncate(s.content, 40)).join(", ")}`);
+  }
+  const questions = byKind.get("question") ?? [];
+  for (const q of questions) {
+    lines.push(`- QUESTION: "${truncate(q.content, 100)}"`);
+  }
+  const methods = byKind.get("method") ?? [];
+  if (methods.length > 0) {
+    lines.push(`- ${methods.length} method${methods.length !== 1 ? "s" : ""}`);
+  }
+  const insights = byKind.get("insight") ?? [];
+  for (const ins of insights) {
+    lines.push(`- INSIGHT: "${truncate(ins.content, 100)}"`);
+  }
+  const hasContradictions = claims.some((c) => (contradictCount.get(c.id) ?? 0) > 0);
+  if (hasContradictions) {
+    lines.push("");
+    lines.push("\u26A0 There is contradicting evidence on one or more claims.");
+  }
+  const unsupported = claims.filter((c) => (supportCount.get(c.id) ?? 0) === 0);
+  if (unsupported.length > 0) {
+    lines.push(`\u26A0 ${unsupported.length} claim${unsupported.length !== 1 ? "s have" : " has"} no supporting evidence yet.`);
+  }
+  lines.push("");
+  lines.push("Use query_ontology to get full details on any of the above.");
+  return lines.join("\n");
+}
+function truncate(text, max) {
+  return text.length > max ? text.slice(0, max) + "\u2026" : text;
+}
+export {
+  buildScaffoldingContext
+};

package/dist/{sessions-FMB5GHSR.js → sessions-GRES2MUV.js}

@@ -2,7 +2,9 @@ import {
   appendSessionEvent,
   listSessions,
   loadSessionHistory
-} from "./chunk-AYB7CAO5.js";
+} from "./chunk-ZUSIRA5S.js";
+import "./chunk-I5NVYKG7.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   appendSessionEvent,
   listSessions,

package/dist/status-GEEAGLPF.js

@@ -0,0 +1,120 @@
+import {
+  NOTE_KINDS
+} from "./chunk-KJHM7ZW2.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/lib/ontology/status.ts
+function getOntologyStatus(ontology) {
+  const { notes } = ontology;
+  if (notes.length === 0) {
+    return "Ontology: empty \u2014 no notes yet.";
+  }
+  const kindCounts = {
+    source: 0,
+    finding: 0,
+    claim: 0,
+    question: 0,
+    method: 0,
+    insight: 0
+  };
+  for (const note of notes) {
+    kindCounts[note.kind]++;
+  }
+  const contradictionPairs = /* @__PURE__ */ new Set();
+  for (const note of notes) {
+    for (const edge of note.edges) {
+      if (edge.relation === "contradicts") {
+        const pair = [note.id, edge.targetId].sort().join(":");
+        contradictionPairs.add(pair);
+      }
+    }
+  }
+  const supportedClaimIds = /* @__PURE__ */ new Set();
+  for (const note of notes) {
+    for (const edge of note.edges) {
+      if (edge.relation === "supports") {
+        supportedClaimIds.add(edge.targetId);
+      }
+    }
+  }
+  const unsupportedClaims = notes.filter(
+    (n) => n.kind === "claim" && !supportedClaimIds.has(n.id)
+  );
+  const openQuestions = notes.filter((n) => n.kind === "question");
+  const lines = [`Ontology: ${notes.length} notes`];
+  for (const kind of NOTE_KINDS) {
+    const count = kindCounts[kind];
+    if (count === 0) continue;
+    let suffix = "";
+    if (kind === "claim") {
+      const parts = [];
+      if (unsupportedClaims.length > 0) parts.push(`${unsupportedClaims.length} unsupported`);
+      const refuted = notes.filter((n) => n.kind === "claim" && n.confidence === "refuted").length;
+      if (refuted > 0) parts.push(`${refuted} refuted`);
+      if (parts.length > 0) suffix = ` (${parts.join(", ")})`;
+    }
+    const label = kind.charAt(0).toUpperCase() + kind.slice(1) + "s";
+    lines.push(`  ${label}: ${count}${suffix}`);
+  }
+  if (contradictionPairs.size > 0 || unsupportedClaims.length > 0 || openQuestions.length > 0) {
+    lines.push("");
+    if (contradictionPairs.size > 0) lines.push(`Contradictions: ${contradictionPairs.size}`);
+    if (unsupportedClaims.length > 0) lines.push(`Unsupported claims: ${unsupportedClaims.length}`);
+    if (openQuestions.length > 0) lines.push(`Open questions: ${openQuestions.length}`);
+  }
+  return lines.join("\n");
+}
+function formatClaims(ontology) {
+  const claims = ontology.notes.filter((n) => n.kind === "claim");
+  if (claims.length === 0) return "No claims in ontology.";
+  const supportCount = /* @__PURE__ */ new Map();
+  const contradictCount = /* @__PURE__ */ new Map();
+  for (const note of ontology.notes) {
+    for (const edge of note.edges) {
+      if (edge.relation === "supports") {
+        supportCount.set(edge.targetId, (supportCount.get(edge.targetId) ?? 0) + 1);
+      }
+      if (edge.relation === "contradicts") {
+        contradictCount.set(edge.targetId, (contradictCount.get(edge.targetId) ?? 0) + 1);
+      }
+    }
+  }
+  return claims.map((c) => {
+    const s = supportCount.get(c.id) ?? 0;
+    const ct = contradictCount.get(c.id) ?? 0;
+    return `[${c.id.slice(0, 8)}] "${c.content}" (${c.confidence})
+  Supports: ${s}  Contradicts: ${ct}`;
+  }).join("\n\n");
+}
+function formatConflicts(ontology) {
+  const pairs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const note of ontology.notes) {
+    for (const edge of note.edges) {
+      if (edge.relation !== "contradicts") continue;
+      const pairKey = [note.id, edge.targetId].sort().join(":");
+      if (seen.has(pairKey)) continue;
+      seen.add(pairKey);
+      const target = ontology.notes.find((n) => n.id === edge.targetId);
+      if (!target) continue;
+      pairs.push({
+        a: note.content,
+        b: target.content,
+        context: edge.context
+      });
+    }
+  }
+  if (pairs.length === 0) return "No contradictions found.";
+  return pairs.map(
+    (p, i) => `CONTRADICTION ${i + 1}:
+  "${p.a}"
+  vs.
+  "${p.b}"
+  Context: ${p.context}`
+  ).join("\n\n");
+}
+export {
+  formatClaims,
+  formatConflicts,
+  getOntologyStatus
+};

package/dist/store-LT5EGDOI.js

@@ -0,0 +1,13 @@
+import {
+  cleanupStaleTmp,
+  getOntologyPath,
+  loadOntology,
+  saveOntology
+} from "./chunk-3WM33M3O.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  cleanupStaleTmp,
+  getOntologyPath,
+  loadOntology,
+  saveOntology
+};

package/dist/web-search-B7D5WMHU.js

@@ -0,0 +1,177 @@
+import {
+  USER_AGENT,
+  extractBatch,
+  fetchAndParseContent,
+  formatExtractionResults,
+  loadOpenResearchConfig
+} from "./chunk-TQSQRNX6.js";
+import "./chunk-I5NVYKG7.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/lib/search/duckduckgo.ts
+import { load as loadCheerio } from "cheerio";
+var DDG_URL = "https://html.duckduckgo.com/html/";
+var TIMEOUT_MS = 1e4;
+async function searchDuckDuckGo(query, numResults = 10) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  try {
+    const response = await fetch(DDG_URL, {
+      method: "POST",
+      headers: {
+        "User-Agent": USER_AGENT,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: `q=${encodeURIComponent(query)}`,
+      redirect: "follow",
+      signal: controller.signal
+    });
+    if (!response.ok) return [];
+    const html = await response.text();
+    const $ = loadCheerio(html);
+    const results = [];
+    $(".result").each((_, el) => {
+      if (results.length >= numResults) return false;
+      const $el = $(el);
+      const titleEl = $el.find(".result__a").first();
+      const snippetEl = $el.find(".result__snippet").first();
+      const title = titleEl.text().trim();
+      let url = titleEl.attr("href") ?? "";
+      if (url.includes("uddg=")) {
+        try {
+          const parsed = new URL(url, "https://duckduckgo.com");
+          url = decodeURIComponent(parsed.searchParams.get("uddg") ?? url);
+        } catch {
+        }
+      }
+      const snippet = snippetEl.text().trim();
+      if (title && url && url.startsWith("http")) {
+        results.push({ title, url, snippet });
+      }
+    });
+    return results;
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/lib/search/brave.ts
+var BRAVE_API_URL = "https://api.search.brave.com/res/v1/web/search";
+var TIMEOUT_MS2 = 1e4;
+async function searchBrave(query, apiKey, numResults = 10) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS2);
+  try {
+    const params = new URLSearchParams({
+      q: query,
+      count: String(Math.min(numResults, 20)),
+      text_decorations: "false"
+    });
+    const response = await fetch(`${BRAVE_API_URL}?${params}`, {
+      headers: {
+        Accept: "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": apiKey
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    const results = data.web?.results ?? [];
+    return results.map((r) => ({
+      title: r.title,
+      url: r.url,
+      description: r.description,
+      age: r.age,
+      pageAge: r.page_age,
+      hostname: r.meta_url?.hostname
+    }));
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/lib/agent/tools/web-search.ts
+async function discoverWebResults(query, numResults) {
+  const config = await loadOpenResearchConfig().catch(() => null);
+  const braveKey = config?.apiKeys?.brave;
+  if (braveKey) {
+    const results2 = await searchBrave(query, braveKey, numResults + 3);
+    if (results2.length > 0) {
+      return {
+        results: results2.map((r) => ({ title: r.title, url: r.url, snippet: r.description })),
+        backend: "brave"
+      };
+    }
+  }
+  const results = await searchDuckDuckGo(query, numResults + 3);
+  return {
+    results: results.map((r) => ({ title: r.title, url: r.url, snippet: r.snippet })),
+    backend: "duckduckgo"
+  };
+}
+async function executeWebSearch(args, provider) {
+  if (!args.target || !args.query) {
+    return { result: "Error: both target and query are required." };
+  }
+  const numResults = Math.min(args.num_results ?? 5, 8);
+  const { results: searchResults, backend } = await discoverWebResults(args.query, numResults);
+  if (searchResults.length === 0) {
+    return { result: "No web results found. Try a different query." };
+  }
+  if (!provider) {
+    const summary = searchResults.slice(0, numResults).map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}
+   ${r.snippet}`).join("\n\n");
+    return { result: `[${backend}] ${summary}` };
+  }
+  const toFetch = searchResults.slice(0, numResults);
+  const contentResults = await Promise.allSettled(
+    toFetch.map(async (hit) => {
+      const content = await fetchAndParseContent(hit.url);
+      if (content) return { hit, text: content.text };
+      return null;
+    })
+  );
+  const extractionInputs = [];
+  const titleMap = /* @__PURE__ */ new Map();
+  for (const result of contentResults) {
+    if (result.status === "fulfilled" && result.value) {
+      const { hit, text } = result.value;
+      extractionInputs.push({
+        title: hit.title,
+        content: text,
+        url: hit.url,
+        target: args.target
+      });
+      titleMap.set(hit.url, hit.title);
+    }
+  }
+  if (extractionInputs.length === 0) {
+    const summary = toFetch.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}
+   ${r.snippet}`).join("\n\n");
+    return { result: `Could not fetch page content. Search snippets:
+
+${summary}` };
+  }
+  const extractions = await extractBatch(extractionInputs, provider);
+  const extracted = [];
+  for (const [url, extraction] of extractions) {
+    if (extraction.relevanceScore >= 2) {
+      extracted.push({
+        title: titleMap.get(url) ?? url,
+        url,
+        extraction
+      });
+    }
+  }
+  return { result: formatExtractionResults(extracted) };
+}
+export {
+  executeWebSearch
+};