@blackdrome/open-deepresearch 0.1.0

package/dist/index.js

@@ -0,0 +1,889 @@
+// src/constraints.ts
+var FORUM_DOMAIN_MAP = [
+  { pattern: /\breddit\b|\br\/[a-z0-9_]+/i, domain: "reddit.com", hint: "reddit" },
+  { pattern: /\bstack\s*overflow\b/i, domain: "stackoverflow.com", hint: "stackoverflow" },
+  { pattern: /\bstack\s*exchange\b|\bstackexchange\b/i, domain: "stackexchange.com", hint: "stackexchange" },
+  { pattern: /\bhacker\s*news\b|\bhn\b/i, domain: "news.ycombinator.com", hint: "hackernews" },
+  { pattern: /\bquora\b/i, domain: "quora.com", hint: "quora" },
+  { pattern: /\bgithub\s+issues\b/i, domain: "github.com", hint: "github" }
+];
+var STRICT_FORUM_PATTERN = /\b(?:only|just|strictly|specifically)\b.*\b(reddit|stack\s*overflow|stack\s*exchange|stackexchange|hacker\s*news|quora|github)\b/i;
+var FORUM_PREPOSITION_PATTERN = /\b(?:from|on|in)\s+(reddit|stack\s*overflow|stack\s*exchange|stackexchange|hacker\s*news|quora|github)\b/i;
+var normalizeDomain = (value) => value.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/^www\./, "");
+var unique = (items) => Array.from(new Set(items.filter(Boolean).map(normalizeDomain)));
+var extractSiteTokens = (query) => {
+  const matches = Array.from(query.matchAll(/site:([a-z0-9.-]+)/gi));
+  return unique(matches.map((entry) => entry[1]));
+};
+var extractSearchConstraints = (query) => {
+  const q = query || "";
+  const explicitSites = extractSiteTokens(q);
+  const preferredDomains = [];
+  const forumHints = [];
+  for (const forum of FORUM_DOMAIN_MAP) {
+    if (!forum.pattern.test(q)) continue;
+    preferredDomains.push(forum.domain);
+    forumHints.push(forum.hint);
+  }
+  const enforceByLanguage = STRICT_FORUM_PATTERN.test(q) || FORUM_PREPOSITION_PATTERN.test(q);
+  const enforceRequiredDomains = explicitSites.length > 0 || preferredDomains.length > 0 && enforceByLanguage;
+  const requiredDomains = enforceRequiredDomains ? explicitSites.length > 0 ? explicitSites : preferredDomains : explicitSites;
+  return {
+    requiredDomains: unique(requiredDomains),
+    preferredDomains: unique(preferredDomains),
+    enforceRequiredDomains,
+    forumHints: Array.from(new Set(forumHints))
+  };
+};
+var domainMatches = (urlOrDomain, targetDomains) => {
+  if (!targetDomains.length) return true;
+  let host = normalizeDomain(urlOrDomain);
+  try {
+    host = normalizeDomain(new URL(urlOrDomain).hostname);
+  } catch {
+    host = normalizeDomain(urlOrDomain);
+  }
+  return targetDomains.some((targetRaw) => {
+    const target = normalizeDomain(targetRaw);
+    return host === target || host.endsWith(`.${target}`);
+  });
+};
+var mergeConstraints = (base, incoming) => {
+  const requiredDomains = unique([...base.requiredDomains || [], ...incoming?.requiredDomains || []]);
+  const preferredDomains = unique([...base.preferredDomains || [], ...incoming?.preferredDomains || []]);
+  const forumHints = Array.from(/* @__PURE__ */ new Set([...base.forumHints || [], ...incoming?.forumHints || []]));
+  const enforceRequiredDomains = Boolean(
+    incoming?.enforceRequiredDomains ?? (base.enforceRequiredDomains || requiredDomains.length > 0)
+  );
+  return {
+    requiredDomains,
+    preferredDomains,
+    forumHints,
+    enforceRequiredDomains
+  };
+};
+
+// src/validators/truth-contract.ts
+var buildTruthContractInstruction = (strictness) => {
+  const strictLine = strictness === "strict" ? "Do not present uncertain claims as facts. If uncertain, explicitly state uncertainty." : "Prefer high-confidence claims and note uncertainty briefly when needed.";
+  return [
+    "TRUTH CONTRACT:",
+    "- Lead with the direct answer in 1-2 sentences.",
+    "- Do not invent sources or facts.",
+    "- If web or dossier sources are provided, cite claims as [1], [2], etc.",
+    "- Include a short 'What is uncertain' note when confidence is limited.",
+    strictLine
+  ].join("\n");
+};
+var evaluateTruthContract = (response, options) => {
+  const text = (response || "").trim();
+  const violations = [];
+  if (!text) {
+    return {
+      passed: false,
+      violations: ["Empty response"]
+    };
+  }
+  const hasCitation = /\[\d+\]/.test(text);
+  if (options?.requiresCitations && !hasCitation) {
+    violations.push("Missing source citations in bracket format like [1]");
+  }
+  const hasUncertaintySection = /what is uncertain/i.test(text) || /uncertain|not enough evidence|insufficient data/i.test(text);
+  if (options?.strictness === "strict" && !hasUncertaintySection) {
+    violations.push("No explicit uncertainty note found in strict mode");
+  }
+  const hasOverconfidentPhrases = /guaranteed|always true|definitely 100%|undeniably/i.test(text);
+  if (hasOverconfidentPhrases) {
+    violations.push("Contains overconfident phrasing");
+  }
+  return {
+    passed: violations.length === 0,
+    violations
+  };
+};
+
+// src/utils/text.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "to",
+  "for",
+  "of",
+  "in",
+  "on",
+  "with",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "as",
+  "at",
+  "from",
+  "by",
+  "that",
+  "this",
+  "it",
+  "about",
+  "into",
+  "what",
+  "which",
+  "who",
+  "when",
+  "where",
+  "how"
+]);
+var NEGATION_TERMS = ["not", "never", "no", "without", "cannot", "can't", "didn't"];
+var normalizeUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    parsed.hash = "";
+    ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"].forEach((key) => {
+      parsed.searchParams.delete(key);
+    });
+    return parsed.toString();
+  } catch {
+    return url.trim();
+  }
+};
+var domainOf = (url) => {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return url.trim().toLowerCase();
+  }
+};
+var toTokens = (text) => text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 2 && !STOPWORDS.has(token));
+var lexicalScore = (query, text) => {
+  const queryTokens = toTokens(query);
+  if (!queryTokens.length) return 0;
+  const textTokens = new Set(toTokens(text));
+  let hits = 0;
+  for (const token of queryTokens) {
+    if (textTokens.has(token)) hits += 1;
+  }
+  return hits / queryTokens.length;
+};
+var jaccardSimilarity = (a, b) => {
+  const aTokens = new Set(toTokens(a));
+  const bTokens = new Set(toTokens(b));
+  if (!aTokens.size || !bTokens.size) return 0;
+  let intersection = 0;
+  for (const token of aTokens) {
+    if (bTokens.has(token)) intersection += 1;
+  }
+  const union = aTokens.size + bTokens.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+};
+var sentenceCandidates = (snippet) => snippet.split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter((sentence) => sentence.length >= 35).slice(0, 2);
+var hasNegation = (text) => {
+  const lower = text.toLowerCase();
+  return NEGATION_TERMS.some((term) => lower.includes(term));
+};
+var extractNumericTokens = (text) => Array.from(text.matchAll(/\b\d+(?:\.\d+)?%?\b/g)).map((m) => m[0]);
+var authorityScore = (domain) => {
+  if (domain.endsWith(".gov") || domain.endsWith(".edu")) return 1;
+  if (domain.includes("wikipedia.org")) return 0.9;
+  if (domain.includes("stackoverflow.com") || domain.includes("stackexchange.com")) return 0.85;
+  if (domain.includes("github.com")) return 0.8;
+  if (domain.includes("reddit.com")) return 0.72;
+  return 0.56;
+};
+var recencyScore = (text, url) => {
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  const bag = `${text} ${url}`;
+  if (bag.includes(String(year))) return 1;
+  if (bag.includes(String(year - 1))) return 0.82;
+  if (bag.includes(String(year - 2))) return 0.65;
+  return 0.48;
+};
+
+// src/core/engine.ts
+var DEPTH_CONFIG = {
+  standard: {
+    initialQueries: 5,
+    refinementQueries: 2,
+    sourceLimit: 12,
+    maxPerDomain: 3,
+    minDomainDiversity: 3
+  },
+  deep: {
+    initialQueries: 8,
+    refinementQueries: 4,
+    sourceLimit: 20,
+    maxPerDomain: 4,
+    minDomainDiversity: 4
+  },
+  extreme: {
+    initialQueries: 12,
+    refinementQueries: 6,
+    sourceLimit: 30,
+    maxPerDomain: 5,
+    minDomainDiversity: 5
+  }
+};
+var confidenceFromSupport = (citations, domains) => {
+  if (citations >= 3 && domains >= 2) return "high";
+  if (citations >= 2) return "medium";
+  return "low";
+};
+var OpenDeepResearchEngine = class {
+  constructor(config) {
+    this.config = config;
+  }
+  resultCache = /* @__PURE__ */ new Map();
+  emit(onProgress, stage, message, completed, total) {
+    onProgress?.({ stage, message, completed, total });
+  }
+  buildPlan(query, depth, constraints) {
+    const cfg = DEPTH_CONFIG[depth];
+    const seed = [
+      { query, intent: "Core answer" },
+      { query: `${query} latest updates facts`, intent: "Fresh context" },
+      { query: `${query} benchmark comparison`, intent: "Comparative evidence" },
+      { query: `${query} data statistics report`, intent: "Quantitative evidence" },
+      { query: `${query} criticism limitations`, intent: "Counter evidence" },
+      { query: `${query} implementation guide`, intent: "Practical implementation" },
+      { query: `${query} official documentation`, intent: "Primary source" },
+      { query: `${query} common mistakes pitfalls`, intent: "Failure patterns" },
+      { query: `${query} timeline history`, intent: "Historical context" },
+      { query: `${query} expert analysis`, intent: "Expert opinion" }
+    ];
+    for (const domain of constraints.requiredDomains.slice(0, 4)) {
+      seed.unshift({
+        query: `${query} site:${domain}`,
+        intent: `Required domain evidence (${domain})`,
+        constrainedToDomain: domain
+      });
+    }
+    for (const domain of constraints.preferredDomains.slice(0, 3)) {
+      seed.unshift({
+        query: `${query} discussion site:${domain}`,
+        intent: `Preferred domain signal (${domain})`,
+        constrainedToDomain: domain
+      });
+    }
+    const unique2 = /* @__PURE__ */ new Map();
+    for (const row of seed) {
+      const key = row.query.toLowerCase().trim();
+      if (!unique2.has(key)) unique2.set(key, row);
+    }
+    return Array.from(unique2.values()).slice(0, cfg.initialQueries);
+  }
+  buildRefinementQueries(query, rankedSources, constraints, depth) {
+    const cfg = DEPTH_CONFIG[depth];
+    const diversity = new Set(rankedSources.map((source) => source.domain)).size;
+    const lowDiversity = diversity < cfg.minDomainDiversity;
+    const candidates = [
+      { query: `${query} contradictory findings`, intent: "Conflict checks" },
+      { query: `${query} independent validation`, intent: "Independent corroboration" },
+      { query: `${query} known caveats`, intent: "Known caveats" },
+      { query: `${query} recent updates this year`, intent: "Recency refresh" },
+      { query: `${query} real world case study`, intent: "Case studies" }
+    ];
+    if (lowDiversity) {
+      candidates.push({ query: `${query} alternative sources analysis`, intent: "Diversity expansion" });
+    }
+    for (const domain of constraints.requiredDomains.slice(0, 3)) {
+      candidates.push({
+        query: `${query} site:${domain}`,
+        intent: `Required domain refinement (${domain})`,
+        constrainedToDomain: domain
+      });
+    }
+    const unique2 = /* @__PURE__ */ new Map();
+    for (const row of candidates) {
+      const key = row.query.toLowerCase().trim();
+      if (!unique2.has(key)) unique2.set(key, row);
+    }
+    return Array.from(unique2.values()).slice(0, cfg.refinementQueries);
+  }
+  async retrieveWithCache(query, constraints) {
+    const cacheKey = [
+      query.toLowerCase().trim(),
+      constraints.requiredDomains.join(","),
+      constraints.preferredDomains.join(","),
+      String(constraints.enforceRequiredDomains)
+    ].join("|");
+    const cached = this.resultCache.get(cacheKey);
+    if (cached) return cached;
+    const results = await this.config.searchAdapter.search(query, {
+      sites: constraints.requiredDomains,
+      preferredSites: constraints.preferredDomains,
+      enforceSites: constraints.enforceRequiredDomains,
+      forumHints: constraints.forumHints
+    });
+    const filtered = results.filter((result) => result.url && result.url !== "#" && result.title !== "Search Error");
+    this.resultCache.set(cacheKey, filtered);
+    return filtered;
+  }
+  rank(question, rows, depth, constraints) {
+    const cfg = DEPTH_CONFIG[depth];
+    const deduped = /* @__PURE__ */ new Set();
+    const scored = [];
+    for (const row of rows) {
+      const url = normalizeUrl(row.result.url);
+      if (!url || deduped.has(url)) continue;
+      deduped.add(url);
+      const domain = domainOf(url);
+      if (constraints.enforceRequiredDomains && constraints.requiredDomains.length > 0) {
+        if (!domainMatches(domain, constraints.requiredDomains)) continue;
+      }
+      const preferredBoost = constraints.preferredDomains.length > 0 && domainMatches(domain, constraints.preferredDomains) ? 1 : 0;
+      const constrainedBoost = row.constrainedToDomain && domainMatches(domain, [row.constrainedToDomain]) ? 1 : 0;
+      const score = lexicalScore(question, `${row.result.title} ${row.result.snippet}`) * 0.45 + lexicalScore(row.plannedQuery, `${row.result.title} ${row.result.snippet}`) * 0.15 + authorityScore(domain) * 0.15 + recencyScore(`${row.result.title} ${row.result.snippet}`, url) * 0.1 + preferredBoost * 0.1 + constrainedBoost * 0.05;
+      scored.push({
+        id: 0,
+        title: row.result.title,
+        snippet: row.result.snippet,
+        url,
+        domain,
+        score,
+        retrievedFrom: row.plannedQuery
+      });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const diversified = [];
+    const domainCounts = /* @__PURE__ */ new Map();
+    for (const source of scored) {
+      const seenFromDomain = domainCounts.get(source.domain) || 0;
+      if (seenFromDomain >= cfg.maxPerDomain) continue;
+      diversified.push(source);
+      domainCounts.set(source.domain, seenFromDomain + 1);
+      if (diversified.length >= cfg.sourceLimit) break;
+    }
+    return diversified.map((entry, index) => ({ ...entry, id: index + 1 }));
+  }
+  verify(rankedSources) {
+    const clusters = [];
+    for (const source of rankedSources) {
+      const candidates = sentenceCandidates(source.snippet || source.title);
+      if (!candidates.length && source.title) candidates.push(source.title);
+      for (const sentence of candidates) {
+        let attached = false;
+        for (const cluster of clusters) {
+          if (jaccardSimilarity(cluster.claim, sentence) >= 0.66) {
+            cluster.citationIds.add(source.id);
+            cluster.domains.add(source.domain);
+            attached = true;
+            break;
+          }
+        }
+        if (!attached) {
+          clusters.push({
+            claim: sentence,
+            citationIds: /* @__PURE__ */ new Set([source.id]),
+            domains: /* @__PURE__ */ new Set([source.domain])
+          });
+        }
+      }
+    }
+    const claims = clusters.map((cluster) => {
+      const citationIds = Array.from(cluster.citationIds).sort((a, b) => a - b);
+      const domains = Array.from(cluster.domains);
+      return {
+        claim: cluster.claim,
+        citationIds,
+        domains,
+        confidence: confidenceFromSupport(citationIds.length, domains.length)
+      };
+    }).sort((a, b) => {
+      const scoreA = a.citationIds.length * 10 + (a.confidence === "high" ? 3 : a.confidence === "medium" ? 2 : 1);
+      const scoreB = b.citationIds.length * 10 + (b.confidence === "high" ? 3 : b.confidence === "medium" ? 2 : 1);
+      return scoreB - scoreA;
+    }).slice(0, 20);
+    const contradictions = [];
+    for (let i = 0; i < claims.length; i += 1) {
+      for (let j = i + 1; j < claims.length; j += 1) {
+        const left = claims[i];
+        const right = claims[j];
+        if (jaccardSimilarity(left.claim, right.claim) < 0.78) continue;
+        const negationConflict = hasNegation(left.claim) !== hasNegation(right.claim);
+        const leftNumbers = extractNumericTokens(left.claim);
+        const rightNumbers = extractNumericTokens(right.claim);
+        const numericConflict = leftNumbers.length > 0 && rightNumbers.length > 0 && leftNumbers.join("|") !== rightNumbers.join("|");
+        if (negationConflict || numericConflict) {
+          contradictions.push(
+            `Potential conflict between [${left.citationIds[0]}] and [${right.citationIds[0]}] on similar claim wording.`
+          );
+        }
+      }
+    }
+    const unresolvedQuestions = claims.filter((claim) => claim.confidence === "low").slice(0, 4).map((claim) => `Need stronger corroboration for: ${claim.claim}`);
+    return {
+      claims,
+      contradictions: Array.from(new Set(contradictions)).slice(0, 6),
+      unresolvedQuestions
+    };
+  }
+  buildPromptContext(params) {
+    const constraintsLine = params.constraints.requiredDomains.length ? `Required domains: ${params.constraints.requiredDomains.join(", ")} (strict=${String(
+      params.constraints.enforceRequiredDomains
+    )})` : params.constraints.preferredDomains.length ? `Preferred domains: ${params.constraints.preferredDomains.join(", ")}` : "No strict domain constraints requested.";
+    const sourcePayload = params.rankedSources.map((source) => ({
+      id: source.id,
+      title: source.title,
+      snippet: source.snippet,
+      url: source.url,
+      domain: source.domain,
+      score: Number(source.score.toFixed(4)),
+      retrievedFrom: source.retrievedFrom
+    }));
+    const claimPayload = params.claims.map((claim) => ({
+      claim: claim.claim,
+      confidence: claim.confidence,
+      citations: claim.citationIds,
+      domains: claim.domains
+    }));
+    const contextSection = (params.contextBlocks || []).filter(Boolean);
+    return [
+      "UPAI OPEN DEEPRESEARCH DOSSIER",
+      `Question: ${params.query}`,
+      `Depth: ${params.depth}`,
+      `Retrieval rounds: ${params.retrievalRounds}`,
+      constraintsLine,
+      "",
+      ...contextSection.length ? ["Additional context:", ...contextSection, ""] : [],
+      "Research plan:",
+      ...params.plan.map((entry, index) => `${index + 1}. ${entry.intent}: ${entry.query}`),
+      "",
+      "Claim graph:",
+      "```json",
+      JSON.stringify(claimPayload, null, 2),
+      "```",
+      "",
+      "Evidence table:",
+      "```json",
+      JSON.stringify(sourcePayload, null, 2),
+      "```",
+      "",
+      "Contradictions:",
+      params.contradictions.length ? params.contradictions.join("\n") : "None detected.",
+      "",
+      "Unresolved questions:",
+      params.unresolvedQuestions.length ? params.unresolvedQuestions.join("\n") : "None",
+      "",
+      "Answer requirements:",
+      "1) Start with a direct answer in 1-2 sentences.",
+      "2) Use only evidence supported by citations from this dossier.",
+      "3) Cite evidence as [1], [2], ... with bracket IDs.",
+      "4) Add a short 'What is uncertain' section.",
+      "5) If contradictions exist, explicitly mention them.",
+      "6) Respect required/preferred domain constraints in framing.",
+      "",
+      buildTruthContractInstruction("strict")
+    ].join("\n");
+  }
+  async synthesize(promptContext, providerHint) {
+    const order = [];
+    if (providerHint) order.push(providerHint);
+    if (!order.includes(this.config.defaultProvider)) order.push(this.config.defaultProvider);
+    for (const key of ["openrouter", "nim", "fallback"]) {
+      if (!order.includes(key)) order.push(key);
+    }
+    const errors = [];
+    for (const provider of order) {
+      const adapter = this.config.llmAdapters[provider];
+      if (!adapter) continue;
+      try {
+        const answer = await adapter.complete(`${promptContext}
+
+Now produce the final answer.`);
+        if (answer.trim()) {
+          return { provider, answer };
+        }
+      } catch (error) {
+        errors.push(`${provider}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    throw new Error(`All synthesis providers failed. ${errors.join(" | ")}`);
+  }
+  async run(query, options) {
+    const depth = options?.depth || "deep";
+    const onProgress = options?.onProgress;
+    const cfg = DEPTH_CONFIG[depth];
+    const inferred = extractSearchConstraints(query);
+    const constraints = mergeConstraints(inferred, options?.constraints);
+    this.emit(onProgress, "planning", "Planning multi-angle research queries...", 1, 6);
+    const plan = this.buildPlan(query, depth, constraints);
+    const gathered = [];
+    this.emit(onProgress, "retrieving", "Running retrieval round 1...", 2, 6);
+    for (let index = 0; index < plan.length; index += 1) {
+      const step = plan[index];
+      this.emit(onProgress, "retrieving", `Query ${index + 1}/${plan.length}: ${step.intent}`, 2, 6);
+      const results = await this.retrieveWithCache(step.query, constraints);
+      for (const result of results) {
+        gathered.push({ plannedQuery: step.query, constrainedToDomain: step.constrainedToDomain, result });
+      }
+    }
+    let retrievalRounds = 1;
+    let rankedSources = this.rank(query, gathered, depth, constraints);
+    const diversity = new Set(rankedSources.map((source) => source.domain)).size;
+    const needsRefinement = depth !== "standard" && (rankedSources.length < Math.floor(cfg.sourceLimit * 0.7) || diversity < cfg.minDomainDiversity);
+    if (needsRefinement) {
+      retrievalRounds += 1;
+      const refinementPlan = this.buildRefinementQueries(query, rankedSources, constraints, depth);
+      this.emit(onProgress, "retrieving", "Running adaptive refinement queries...", 2, 6);
+      for (let index = 0; index < refinementPlan.length; index += 1) {
+        const step = refinementPlan[index];
+        this.emit(onProgress, "retrieving", `Refinement ${index + 1}/${refinementPlan.length}: ${step.intent}`, 2, 6);
+        const results = await this.retrieveWithCache(step.query, constraints);
+        for (const result of results) {
+          gathered.push({ plannedQuery: step.query, constrainedToDomain: step.constrainedToDomain, result });
+        }
+      }
+      rankedSources = this.rank(query, gathered, depth, constraints);
+    }
+    this.emit(onProgress, "ranking", "Ranking and diversifying evidence...", 3, 6);
+    this.emit(onProgress, "verifying", "Building claim graph and contradiction checks...", 4, 6);
+    const { claims, contradictions, unresolvedQuestions } = this.verify(rankedSources);
+    this.emit(onProgress, "synthesizing", "Synthesizing final answer with citations...", 5, 6);
+    const promptContext = this.buildPromptContext({
+      query,
+      depth,
+      plan,
+      retrievalRounds,
+      constraints,
+      claims,
+      contradictions,
+      unresolvedQuestions,
+      rankedSources,
+      contextBlocks: options?.contextBlocks
+    });
+    const synthesis = await this.synthesize(promptContext, options?.providerHint);
+    let finalAnswer = synthesis.answer;
+    this.emit(onProgress, "critiquing", "Running citation/uncertainty critique pass...", 6, 6);
+    const critique = evaluateTruthContract(finalAnswer, {
+      requiresCitations: rankedSources.length > 0,
+      strictness: "strict"
+    });
+    if (!critique.passed) {
+      const repairPrompt = [
+        promptContext,
+        "",
+        "Your previous answer violated the response contract.",
+        `Violations: ${critique.violations.join("; ")}`,
+        "Rewrite the answer to satisfy all requirements.",
+        "",
+        "Previous answer:",
+        finalAnswer
+      ].join("\n");
+      const adapter = this.config.llmAdapters[synthesis.provider];
+      if (adapter) {
+        try {
+          const repaired = await adapter.complete(repairPrompt);
+          if (repaired.trim()) finalAnswer = repaired;
+        } catch {
+        }
+      }
+    }
+    const sourcesForMessage = rankedSources.map((source) => ({
+      title: source.title,
+      snippet: source.snippet,
+      url: source.url
+    }));
+    return {
+      query,
+      depth,
+      plan,
+      retrievalRounds,
+      rankedSources,
+      claims,
+      contradictions,
+      unresolvedQuestions,
+      promptContext,
+      finalAnswer,
+      synthesis: {
+        provider: synthesis.provider,
+        critiqueViolations: critique.violations
+      },
+      constraints,
+      sourcesForMessage
+    };
+  }
+};
+
+// src/adapters/llm/openrouter.ts
+var OpenRouterAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.endpoint = config.endpoint || "https://openrouter.ai/api/v1/chat/completions";
+    this.timeoutMs = config.timeoutMs || 6e4;
+    this.siteUrl = config.siteUrl || "https://github.com/blackdrome/upai-open-deepresearch";
+    this.siteName = config.siteName || "UPAI Open DeepResearch";
+  }
+  provider = "openrouter";
+  endpoint;
+  timeoutMs;
+  siteUrl;
+  siteName;
+  async complete(prompt) {
+    if (!this.config.apiKey) {
+      throw new Error("OpenRouter API key is required.");
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json",
+          "HTTP-Referer": this.siteUrl,
+          "X-Title": this.siteName
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          messages: [
+            {
+              role: "system",
+              content: "You are a grounded research synthesis model. Keep claims source-bound and concise."
+            },
+            {
+              role: "user",
+              content: prompt
+            }
+          ],
+          stream: false,
+          temperature: 0.2
+        }),
+        signal: controller.signal
+      });
+      const raw = await response.text();
+      let payload = null;
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        payload = null;
+      }
+      if (!response.ok) {
+        throw new Error(payload?.error?.message || raw || `OpenRouter request failed (${response.status})`);
+      }
+      const text = payload?.choices?.[0]?.message?.content?.trim();
+      if (!text) {
+        throw new Error("OpenRouter returned an empty completion.");
+      }
+      return text;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/adapters/llm/nim.ts
+var normalizeNimError = (status, raw, parsed) => {
+  const text = parsed?.error?.message || parsed?.message || parsed?.detail || raw || `NIM request failed (${status})`;
+  const lowered = text.toLowerCase();
+  if (lowered.includes("not found for account") || /function\s+'[^']+'\s*:\s*not found/i.test(text)) {
+    return "Selected NVIDIA NIM model is unavailable for this account.";
+  }
+  if (status === 401 || lowered.includes("authentication") || lowered.includes("invalid api key")) {
+    return "NVIDIA NIM authentication failed. Verify your API key.";
+  }
+  if (status === 429 || lowered.includes("rate limit")) {
+    return "NVIDIA NIM rate limit reached. Retry later or switch model.";
+  }
+  if (status === 408 || lowered.includes("timed out") || lowered.includes("timeout")) {
+    return "NVIDIA NIM timed out. Try a faster model or reduce response size.";
+  }
+  return text;
+};
+var NimAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.endpoint = config.endpoint || "https://integrate.api.nvidia.com/v1/chat/completions";
+    this.timeoutMs = config.timeoutMs || 7e4;
+    this.maxTokens = config.maxTokens || 1100;
+    this.temperature = config.temperature ?? 0.2;
+  }
+  provider = "nim";
+  endpoint;
+  timeoutMs;
+  maxTokens;
+  temperature;
+  async complete(prompt) {
+    if (!this.config.apiKey) {
+      throw new Error("NVIDIA NIM API key is required.");
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: this.maxTokens,
+          temperature: this.temperature,
+          stream: false
+        }),
+        signal: controller.signal
+      });
+      const raw = await response.text();
+      let payload = null;
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        payload = null;
+      }
+      if (!response.ok) {
+        throw new Error(normalizeNimError(response.status, raw, payload));
+      }
+      const content = payload?.choices?.[0]?.message?.content;
+      const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((entry) => entry.text || "").join("\n").trim() : "";
+      if (!text) {
+        throw new Error("NVIDIA NIM returned an empty completion.");
+      }
+      return text;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error("NVIDIA NIM request timed out.");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/adapters/llm/function-adapter.ts
+var FunctionLlmAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.provider = config.provider;
+  }
+  provider;
+  complete(prompt) {
+    return this.config.complete(prompt);
+  }
+};
+
+// src/adapters/search/http-json.ts
+var sanitizeResults = (input) => input.filter((item) => item.url && item.url !== "#" && item.title).map((item) => ({
+  title: item.title,
+  snippet: item.snippet || "",
+  url: item.url
+}));
+var HttpJsonSearchAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.method = config.method || "POST";
+    this.timeoutMs = config.timeoutMs || 2e4;
+    this.apiKeyHeader = config.apiKeyHeader || "Authorization";
+  }
+  method;
+  timeoutMs;
+  apiKeyHeader;
+  async search(query, options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        ...this.config.extraHeaders || {}
+      };
+      if (this.config.apiKey) {
+        headers[this.apiKeyHeader] = this.apiKeyHeader.toLowerCase() === "authorization" ? `Bearer ${this.config.apiKey}` : this.config.apiKey;
+      }
+      const payload = {
+        query,
+        ...this.config.staticPayload,
+        sites: options.sites || [],
+        preferredSites: options.preferredSites || [],
+        enforceSites: Boolean(options.enforceSites),
+        forumHints: options.forumHints || []
+      };
+      let response;
+      if (this.method === "GET") {
+        const url = new URL(this.config.endpoint);
+        url.searchParams.set("query", query);
+        response = await fetch(url.toString(), {
+          method: "GET",
+          headers,
+          signal: controller.signal
+        });
+      } else {
+        response = await fetch(this.config.endpoint, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+      }
+      const raw = await response.text();
+      let parsed = null;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        parsed = null;
+      }
+      if (!response.ok) {
+        throw new Error(parsed?.error || raw || `Search adapter request failed (${response.status})`);
+      }
+      const byResults = Array.isArray(parsed?.results) ? parsed?.results : [];
+      if (byResults.length > 0) {
+        return sanitizeResults(byResults);
+      }
+      const byItems = Array.isArray(parsed?.items) ? parsed.items.map((item) => ({
+        title: item.title || "Untitled",
+        snippet: item.snippet || "",
+        url: item.url || item.link || "#"
+      })) : [];
+      return sanitizeResults(byItems);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error("Search adapter timed out.");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/index.ts
+var createOpenDeepResearchEngine = (options) => {
+  const llmAdapters = {};
+  if (options.openRouter) {
+    llmAdapters.openrouter = new OpenRouterAdapter(options.openRouter);
+  }
+  if (options.nim) {
+    llmAdapters.nim = new NimAdapter(options.nim);
+  }
+  if (options.fallbackComplete) {
+    llmAdapters.fallback = new FunctionLlmAdapter({
+      provider: "fallback",
+      complete: options.fallbackComplete
+    });
+  }
+  const defaultProvider = options.defaultProvider || "openrouter";
+  const config = {
+    searchAdapter: options.searchAdapter,
+    llmAdapters,
+    defaultProvider
+  };
+  return new OpenDeepResearchEngine(config);
+};
+export {
+  FunctionLlmAdapter,
+  HttpJsonSearchAdapter,
+  NimAdapter,
+  OpenDeepResearchEngine,
+  OpenRouterAdapter,
+  buildTruthContractInstruction,
+  createOpenDeepResearchEngine,
+  domainMatches,
+  evaluateTruthContract,
+  extractSearchConstraints,
+  extractSiteTokens,
+  mergeConstraints,
+  normalizeDomain
+};
+//# sourceMappingURL=index.js.map