@duckmind/dm-windows-x64 0.62.9 → 0.63.4

package/extensions/dm-web-access/summary-review.js

@@ -0,0 +1,364 @@
+import { clampThinkingLevel } from "@duckmind/dm-ai";
+import { complete, completeSimple } from "@duckmind/dm-ai/compat";
+import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns, splitThinkingSuffix } from "./summary-model-scope.js";
+const PREFERRED_SUMMARY_MODELS = [
+  { provider: "anthropic", id: "claude-haiku-4-5" },
+  { provider: "openai-codex", id: "gpt-5.6-luna" },
+  { provider: "openai-codex", id: "gpt-5.6-terra" },
+  { provider: "google", id: "gemini-3.6-flash" },
+  { provider: "openai", id: "gpt-5-mini" },
+  { provider: "deepseek", id: "deepseek-v4-flash" }
+];
+export const SUMMARY_GENERATION_DEADLINE_MS = 30000;
+function estimateTokens(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0)
+    return 0;
+  return Math.max(1, Math.ceil(trimmed.length / 4));
+}
+function summarizeQueryResult(result) {
+  if (result.error) {
+    return `Query: ${result.query}
+Status: Error
+Error: ${result.error}`;
+  }
+  const lines = [
+    `Query: ${result.query}`,
+    `Provider: ${result.provider ?? "unknown"}`,
+    `Answer: ${result.answer || "(no answer text returned)"}`
+  ];
+  if (result.results.length === 0) {
+    lines.push("Sources: none");
+    return lines.join(`
+`);
+  }
+  lines.push("Sources:");
+  for (let i = 0;i < result.results.length; i++) {
+    const source = result.results[i];
+    lines.push(`${i + 1}. ${source.title} — ${source.url}`);
+  }
+  return lines.join(`
+`);
+}
+export function buildSummaryPrompt(results, feedback) {
+  const sections = [
+    "You are writing the final web search summary for a coding assistant.",
+    "Write a concise, factual summary using only the provided search results.",
+    "Requirements:",
+    "- Keep it readable and skimmable.",
+    "- Include key findings and caveats.",
+    "- Do not invent sources or claims.",
+    "- If evidence is weak or conflicting, say so explicitly.",
+    '- End with a short "Sources" section listing the most relevant URLs.'
+  ];
+  if (feedback) {
+    sections.push("- Incorporate the user feedback provided below into the summary.");
+  }
+  sections.push("");
+  sections.push("<search_results>");
+  for (let i = 0;i < results.length; i++) {
+    sections.push(`
+[Result ${i + 1}]`);
+    sections.push(summarizeQueryResult(results[i]));
+  }
+  sections.push(`
+</search_results>`);
+  if (feedback) {
+    sections.push("");
+    sections.push("<user_feedback>");
+    sections.push(feedback);
+    sections.push("</user_feedback>");
+  }
+  return sections.join(`
+`);
+}
+function buildDeterministicAnswerPreview(answer) {
+  let text = answer.replace(/\s+/g, " ").trim();
+  if (text.length === 0)
+    return "";
+  const sourceMarker = text.search(/\bSources?\s*:/i);
+  if (sourceMarker >= 0)
+    text = text.slice(0, sourceMarker).trim();
+  if (text.length === 0)
+    return "";
+  return text.length > 240 ? `${text.slice(0, 237)}...` : text;
+}
+function buildDeterministicSummaryLines(results) {
+  if (results.length === 0) {
+    return [
+      "No completed search results were available when the curator session finished.",
+      "",
+      "Sources",
+      "- None"
+    ];
+  }
+  const lines = [
+    "Summary based on the currently selected search results.",
+    ""
+  ];
+  const sourceUrls = [];
+  let successful = 0;
+  let failed = 0;
+  for (const result of results) {
+    if (result.error) {
+      failed += 1;
+      lines.push(`- ${result.query}: failed (${result.error})`);
+      continue;
+    }
+    successful += 1;
+    const preview = buildDeterministicAnswerPreview(result.answer);
+    if (preview.length > 0) {
+      lines.push(`- ${result.query}: ${preview}`);
+    } else {
+      lines.push(`- ${result.query}: returned ${result.results.length} source${result.results.length === 1 ? "" : "s"} without answer text.`);
+    }
+    for (const source of result.results) {
+      if (!sourceUrls.includes(source.url)) {
+        sourceUrls.push(source.url);
+      }
+    }
+  }
+  lines.push("");
+  lines.push(`Completed queries: ${results.length}`);
+  lines.push(`Successful: ${successful}`);
+  lines.push(`Failed: ${failed}`);
+  lines.push("");
+  lines.push("Sources");
+  if (sourceUrls.length === 0) {
+    lines.push("- None");
+  } else {
+    for (const url of sourceUrls.slice(0, 12)) {
+      lines.push(`- ${url}`);
+    }
+    if (sourceUrls.length > 12) {
+      lines.push(`- ... and ${sourceUrls.length - 12} more`);
+    }
+  }
+  return lines;
+}
+export function buildDeterministicSummary(results) {
+  const summary = buildDeterministicSummaryLines(results).join(`
+`).trim();
+  const nonEmptySummary = summary.length > 0 ? summary : `No completed search results were available when the curator session finished.
+
+Sources
+- None`;
+  return {
+    summary: nonEmptySummary,
+    meta: {
+      model: null,
+      durationMs: 0,
+      tokenEstimate: estimateTokens(nonEmptySummary),
+      fallbackUsed: true,
+      fallbackReason: "deterministic-submit-fallback",
+      phase: "deterministic-fallback",
+      edited: false
+    }
+  };
+}
+function parseModelSelector(value) {
+  const selector = splitThinkingSuffix(value);
+  const slashIndex = selector.value.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= selector.value.length - 1) {
+    throw new Error(`Invalid summary model: ${value}. Use provider/model-id.`);
+  }
+  return {
+    provider: selector.value.slice(0, slashIndex),
+    id: selector.value.slice(slashIndex + 1),
+    thinkingLevel: selector.thinkingLevel
+  };
+}
+function resolveThinkingLevel(model, requested) {
+  if (!requested)
+    return;
+  return clampThinkingLevel(model, requested);
+}
+async function resolveSummaryModelCandidates(ctx, modelOverride) {
+  const enabledModelPatterns = loadEnabledModelPatterns(ctx);
+  const specs = [];
+  const normalizedOverride = typeof modelOverride === "string" ? modelOverride.trim() : "";
+  if (normalizedOverride.length > 0)
+    specs.push(parseModelSelector(normalizedOverride));
+  specs.push(...PREFERRED_SUMMARY_MODELS);
+  const candidates = [];
+  const errors = [];
+  const seen = new Set;
+  for (const spec of specs) {
+    const value = `${spec.provider}/${spec.id}`;
+    if (seen.has(value))
+      continue;
+    seen.add(value);
+    const model = findModelWithProviderRouting(ctx.modelRegistry, spec.provider, spec.id);
+    if (!model) {
+      errors.push(`Summary model not found: ${value}`);
+      continue;
+    }
+    if (!modelMatchesEnabledPatterns(model, enabledModelPatterns)) {
+      errors.push(`Summary model is not enabled: ${value}`);
+      continue;
+    }
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok) {
+      errors.push(`No API key available for summary model ${value}`);
+      continue;
+    }
+    candidates.push({ model, apiKey: auth.apiKey, headers: auth.headers, thinkingLevel: spec.thinkingLevel });
+  }
+  return { candidates, errors };
+}
+function buildFallbackSummary(results, fallbackReason, durationMs = 0) {
+  const deterministic = buildDeterministicSummary(results);
+  return {
+    summary: deterministic.summary,
+    meta: {
+      ...deterministic.meta,
+      durationMs,
+      fallbackReason
+    }
+  };
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const name = err.name;
+  const message = err.message;
+  return name === "AbortError" || typeof message === "string" && message.toLowerCase().includes("abort");
+}
+function getTextFromContentPart(part) {
+  if (!part || typeof part !== "object")
+    return "";
+  const value = part;
+  if (typeof value.text === "string")
+    return value.text;
+  if (typeof value.refusal === "string")
+    return value.refusal;
+  return "";
+}
+function getContentPartType(part) {
+  if (!part || typeof part !== "object")
+    return "unknown";
+  const value = part;
+  return typeof value.type === "string" ? value.type : "unknown";
+}
+export async function generateSummaryDraft(results, ctx, signal, modelOverride, feedback, completeFn, deadlineMs = SUMMARY_GENERATION_DEADLINE_MS) {
+  if (!ctx || !ctx.modelRegistry) {
+    throw new Error("Summary generation context unavailable");
+  }
+  const registry = ctx.modelRegistry;
+  const customCompleteFn = completeFn !== undefined;
+  const usesRegistryComplete = !customCompleteFn && typeof registry.complete === "function";
+  completeFn ??= usesRegistryComplete ? registry.complete.bind(registry) : complete;
+  const generationStartedAt = Date.now();
+  const deadlineController = new AbortController;
+  const deadlineMarker = Symbol("summary-generation-deadline");
+  let deadlineTimer;
+  let resolveDeadline;
+  const deadlinePromise = new Promise((resolve) => {
+    resolveDeadline = () => resolve(deadlineMarker);
+    deadlineTimer = setTimeout(() => {
+      deadlineController.abort();
+      resolveDeadline();
+    }, deadlineMs);
+  });
+  let callerAbortListener;
+  const callerAbortPromise = signal ? new Promise((_, reject) => {
+    callerAbortListener = () => reject(new Error("Aborted"));
+    if (signal.aborted)
+      callerAbortListener();
+    else
+      signal.addEventListener("abort", callerAbortListener, { once: true });
+  }) : undefined;
+  const completionSignal = signal ? AbortSignal.any([signal, deadlineController.signal]) : deadlineController.signal;
+  async function raceSummaryOperation(operation) {
+    operation.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    const contenders = [operation, deadlinePromise];
+    if (callerAbortPromise)
+      contenders.push(callerAbortPromise);
+    const result = await Promise.race(contenders);
+    if (result === deadlineMarker) {
+      if (signal?.aborted)
+        throw new Error("Aborted");
+      throw deadlineMarker;
+    }
+    return result;
+  }
+  try {
+    if (signal?.aborted)
+      throw new Error("Aborted");
+    const prompt = buildSummaryPrompt(results, feedback);
+    let resolved;
+    try {
+      resolved = await raceSummaryOperation(resolveSummaryModelCandidates(ctx, modelOverride));
+    } catch (err) {
+      if (signal?.aborted)
+        throw new Error("Aborted");
+      if (err === deadlineMarker || deadlineController.signal.aborted) {
+        return buildFallbackSummary(results, "summary-generation-timeout", Date.now() - generationStartedAt);
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return buildFallbackSummary(results, `summary-model-settings-error: ${message}`, Date.now() - generationStartedAt);
+    }
+    let lastError = resolved.errors.at(-1);
+    for (const { model, apiKey, headers, thinkingLevel } of resolved.candidates) {
+      const startedAt = Date.now();
+      try {
+        const userMessage = {
+          role: "user",
+          content: [{ type: "text", text: prompt }],
+          timestamp: Date.now()
+        };
+        const requestedThinkingLevel = resolveThinkingLevel(model, thinkingLevel);
+        const enabledThinkingLevel = requestedThinkingLevel && requestedThinkingLevel !== "off" ? requestedThinkingLevel : undefined;
+        const completionOptions = {
+          ...usesRegistryComplete ? {} : { apiKey, headers },
+          signal: completionSignal,
+          ...requestedThinkingLevel ? { reasoning: requestedThinkingLevel } : {},
+          ...enabledThinkingLevel ? { reasoningEffort: enabledThinkingLevel } : {}
+        };
+        const completion = thinkingLevel !== undefined && !customCompleteFn && !usesRegistryComplete ? completeSimple(model, { messages: [userMessage] }, { apiKey, headers, signal: completionSignal, ...enabledThinkingLevel ? { reasoning: enabledThinkingLevel } : {} }) : completeFn(model, { messages: [userMessage] }, completionOptions);
+        const response = await raceSummaryOperation(Promise.resolve(completion));
+        if (response.stopReason === "aborted") {
+          throw new Error("Aborted");
+        }
+        const contentParts = Array.isArray(response.content) ? response.content : [];
+        const summary = contentParts.map((part) => getTextFromContentPart(part)).filter((text) => text.trim().length > 0).join(`
+`).trim();
+        if (summary.length === 0) {
+          const partTypes = contentParts.map((part) => getContentPartType(part));
+          const typesLabel = partTypes.length > 0 ? partTypes.join(", ") : "none";
+          throw new Error(`Summary model returned empty response (content parts: ${typesLabel})`);
+        }
+        return {
+          summary,
+          meta: {
+            model: `${model.provider}/${model.id}`,
+            durationMs: Math.max(0, Date.now() - startedAt),
+            tokenEstimate: estimateTokens(summary),
+            fallbackUsed: false,
+            phase: "summary-model",
+            edited: false
+          }
+        };
+      } catch (err) {
+        if (signal?.aborted)
+          throw new Error("Aborted");
+        if (err === deadlineMarker || deadlineController.signal.aborted) {
+          return buildFallbackSummary(results, "summary-generation-timeout", Date.now() - generationStartedAt);
+        }
+        if (isAbortError(err))
+          throw err;
+        lastError = err instanceof Error ? err.message : String(err);
+      }
+    }
+    return buildFallbackSummary(results, lastError ? `summary-model-unavailable: ${lastError}` : "summary-model-unavailable", Date.now() - generationStartedAt);
+  } finally {
+    if (deadlineTimer)
+      clearTimeout(deadlineTimer);
+    if (signal && callerAbortListener)
+      signal.removeEventListener("abort", callerAbortListener);
+  }
+}

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

@@ -0,0 +1,199 @@
+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 TAVILY_API_BASE_URL = "https://api.tavily.com";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 60000;
+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: "Tavily",
+    configuredValue: loadConfig().tavilyApiKey,
+    environmentValue: process.env.TAVILY_API_KEY,
+    signal
+  });
+}
+function getApiUrl() {
+  return `${resolveApiBaseUrl({
+    configKey: "tavilyBaseUrl",
+    configuredValue: loadConfig().tavilyBaseUrl,
+    defaultValue: TAVILY_API_BASE_URL,
+    environmentKey: "TAVILY_BASE_URL",
+    environmentValue: process.env.TAVILY_BASE_URL
+  })}/search`;
+}
+async function requireApiKey(signal) {
+  const apiKey = await getApiKey(signal);
+  if (!apiKey) {
+    throw new Error(`Tavily API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "tavilyApiKey": "your-key" }
+` + `  2. Set TAVILY_API_KEY environment variable
+` + "Get a key at https://app.tavily.com/");
+  }
+  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 include_domains = [];
+  const exclude_domains = [];
+  for (const raw of domainFilter) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? exclude_domains : include_domains;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return {
+    ...include_domains.length > 0 ? { include_domains } : {},
+    ...exclude_domains.length > 0 ? { exclude_domains } : {}
+  };
+}
+function requestSignal(signal) {
+  const timeout = AbortSignal.timeout(SEARCH_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function mapResults(results, numResults) {
+  if (!Array.isArray(results))
+    return [];
+  const mapped = [];
+  for (const item of results) {
+    if (!item?.url)
+      continue;
+    mapped.push({
+      title: item.title || `Source ${mapped.length + 1}`,
+      url: item.url,
+      snippet: typeof item.content === "string" ? item.content.replace(/\s+/g, " ").trim() : ""
+    });
+    if (mapped.length >= numResults)
+      break;
+  }
+  return mapped;
+}
+function mapInlineContent(results) {
+  if (!Array.isArray(results))
+    return [];
+  return results.flatMap((item) => {
+    if (!item?.url || typeof item.raw_content !== "string" || item.raw_content.trim().length === 0)
+      return [];
+    return [{
+      url: item.url,
+      title: item.title || "",
+      content: item.raw_content,
+      error: null
+    }];
+  });
+}
+export function isTavilyAvailable() {
+  return hasCredentialSource({
+    provider: "Tavily",
+    configuredValue: loadConfig().tavilyApiKey,
+    environmentValue: process.env.TAVILY_API_KEY
+  });
+}
+export async function searchWithTavily(query, options = {}) {
+  const apiUrl = getApiUrl();
+  const apiKey = await requireApiKey(options.signal);
+  const numResults = normalizeCount(options.numResults);
+  const body = {
+    query,
+    search_depth: "basic",
+    max_results: numResults,
+    include_answer: "basic",
+    include_raw_content: options.includeContent ? "markdown" : false,
+    ...options.recencyFilter ? { time_range: options.recencyFilter } : {},
+    ...mapDomainFilter(options.domainFilter)
+  };
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  let response;
+  try {
+    response = await fetchWithCredentialRedirects(apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: requestSignal(options.signal)
+    }, ["Authorization"]);
+  } 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(`Tavily API error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw new Error(`Tavily API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  activityMonitor.logComplete(activityId, response.status);
+  const result = {
+    answer: typeof data.answer === "string" ? data.answer : "",
+    results: mapResults(data.results, numResults)
+  };
+  if (options.includeContent) {
+    const inlineContent = mapInlineContent(data.results);
+    if (inlineContent.length > 0)
+      result.inlineContent = inlineContent;
+  }
+  return result;
+}