@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-web-access/pdf-extract.js

@@ -11,10 +11,16 @@ import {
   extractPDFViaDatalab
 } from "./datalab-pdf-extract.js";
 import { isGeminiApiAvailable } from "./gemini-api.js";
+import {
+  extractPDFViaEndpoint,
+  getEndpointTimeoutMs,
+  isEndpointApiAvailable
+} from "./endpoint-pdf-extract.js";
 import { extractPDFViaGemini } from "./gemini-pdf-extract.js";
 import { getWebSearchConfigPath } from "./utils.js";
 export const PDF_PROVIDER_VALUES = new Set([
   "auto",
+  "endpoint",
   "gemini",
   "datalab",
   "unpdf"
@@ -89,6 +95,31 @@ export async function extractPDFToMarkdown(buffer, url, options = {}) {
   const safeMaxPages = maxPages === undefined ? pdfConfig.maxPages : Number.isFinite(maxPages) ? Math.max(1, Math.floor(maxPages)) : DEFAULT_MAX_PAGES;
   const urlTitle = extractTitleFromURL(url);
   const provider = pdfConfig.provider;
+  if (provider === "auto" || provider === "endpoint") {
+    if (provider === "endpoint" && !isEndpointApiAvailable()) {
+      throw new Error('PDF provider "endpoint" requires a configured pdf.endpointUrl');
+    }
+    try {
+      if (isEndpointApiAvailable()) {
+        const result = await extractPDFViaEndpoint(buffer, {
+          maxPages: safeMaxPages,
+          timeoutMs: getEndpointTimeoutMs(),
+          ...signal ? { signal } : {}
+        });
+        return writeMarkdownResult({
+          markdownBody: result.markdown,
+          title: urlTitle,
+          pages: result.pages ?? countPageMarkers(result.markdown),
+          outputDir,
+          filename,
+          url
+        });
+      }
+    } catch (err) {
+      if (shouldRethrowExtractionError(err, signal))
+        throw err;
+    }
+  }
   if (provider === "auto" || provider === "datalab") {
     try {
       if (isDatalabApiAvailable()) {
@@ -186,7 +217,9 @@ async function writeMarkdownResult(options) {
   lines.push(`# ${options.title}`);
   lines.push("");
   lines.push(`> Source: ${options.url}`);
-  lines.push(`> Pages: ${options.pages}${options.truncated ? ` (extracted first ${options.pagesToExtract})` : ""}`);
+  if (options.pages > 0) {
+    lines.push(`> Pages: ${options.pages}${options.truncated ? ` (extracted first ${options.pagesToExtract})` : ""}`);
+  }
   if (options.metaAuthor)
     lines.push(`> Author: ${options.metaAuthor}`);
   lines.push("");

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

@@ -1,9 +1,12 @@
 import { existsSync, readFileSync } from "node:fs";
 import { activityMonitor } from "./activity.js";
 import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { formatSearchResultsAsAnswer } from "./search-answer-formatting.js";
 import { getWebSearchConfigPath } from "./utils.js";
-const PERPLEXITY_API_URL = "https://api.perplexity.ai/chat/completions";
+const PERPLEXITY_SEARCH_URL = "https://api.perplexity.ai/search";
+const PERPLEXITY_CHAT_URL = "https://api.perplexity.ai/chat/completions";
 const CONFIG_PATH = getWebSearchConfigPath();
+const REQUEST_TIMEOUT_MS = 30000;
 const RATE_LIMIT = {
   maxRequests: 10,
   windowMs: 60 * 1000
@@ -66,17 +69,9 @@ export function isPerplexityAvailable() {
     environmentValue: process.env.PERPLEXITY_API_KEY
   });
 }
-const MAX_CITATIONS = 20;
-function citationsToKeep(answer, available, numResults) {
-  let highestCited = 0;
-  for (const match of answer.matchAll(/\[(\d{1,3})\]/g)) {
-    highestCited = Math.max(highestCited, Number(match[1]));
-  }
-  return Math.min(available, MAX_CITATIONS, Math.max(numResults, highestCited));
-}
-export async function searchWithPerplexity(query, options = {}) {
+async function postPerplexity(url, body, options) {
   checkRateLimit();
-  const activityId = activityMonitor.logStart({ type: "api", query });
+  const activityId = activityMonitor.logStart({ type: "api", query: options.activityQuery });
   activityMonitor.updateRateLimit({
     used: requestTimestamps.length,
     max: RATE_LIMIT.maxRequests,
@@ -84,34 +79,25 @@ export async function searchWithPerplexity(query, options = {}) {
     windowMs: RATE_LIMIT.windowMs
   });
   const apiKey = await getApiKey(options.signal);
-  const numResults = typeof options.numResults === "number" && Number.isFinite(options.numResults) ? Math.max(1, Math.min(Math.floor(options.numResults), 20)) : 5;
-  const requestBody = {
-    model: "sonar",
-    messages: [{ role: "user", content: query }],
-    max_tokens: 1024,
-    return_related_questions: false
-  };
-  if (options.recencyFilter) {
-    requestBody.search_recency_filter = options.recencyFilter;
-  }
-  if (options.domainFilter && options.domainFilter.length > 0) {
-    const validated = validateDomainFilter(options.domainFilter);
-    if (validated.length > 0) {
-      requestBody.search_domain_filter = validated;
-    }
-  }
+  const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+  const timedOut = () => timeout.aborted && !options.signal?.aborted;
+  const timeoutError = () => new Error("Perplexity API error 408: request timed out");
   let response;
   try {
-    response = await fetch(PERPLEXITY_API_URL, {
+    response = await fetch(url, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(requestBody),
-      ...options.signal ? { signal: options.signal } : {}
+      body: JSON.stringify(body),
+      signal: options.signal ? AbortSignal.any([options.signal, timeout]) : timeout
     });
   } catch (err) {
+    if (timedOut()) {
+      activityMonitor.logError(activityId, "request timed out");
+      throw timeoutError();
+    }
     const message = err instanceof Error ? err.message : String(err);
     const redactedMessage = redactCredential(message, apiKey);
     if (redactedMessage.toLowerCase().includes("abort")) {
@@ -126,35 +112,66 @@ export async function searchWithPerplexity(query, options = {}) {
       redactedError.name = err.name;
     throw redactedError;
   }
+  activityMonitor.logComplete(activityId, response.status);
   if (!response.ok) {
-    activityMonitor.logComplete(activityId, response.status);
-    const errorText = redactCredential(await response.text(), apiKey);
+    let errorText;
+    try {
+      errorText = redactCredential(await response.text(), apiKey);
+    } catch (err) {
+      if (timedOut())
+        throw timeoutError();
+      throw err;
+    }
     throw new Error(`Perplexity API error ${response.status}: ${errorText}`);
   }
-  let data;
   try {
-    data = await response.json();
+    return await response.json();
   } catch (err) {
-    activityMonitor.logComplete(activityId, response.status);
+    if (timedOut())
+      throw timeoutError();
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`Perplexity API returned invalid JSON: ${message}`);
   }
-  const answer = data.choices?.[0]?.message?.content || "";
-  const citations = Array.isArray(data.citations) ? data.citations : [];
-  const results = [];
-  const citationCount = citationsToKeep(answer, citations.length, numResults);
-  for (let i = 0;i < citationCount; i++) {
-    const citation = citations[i];
-    if (typeof citation === "string") {
-      results.push({ title: `Source ${i + 1}`, url: citation, snippet: "" });
-    } else if (citation && typeof citation === "object" && typeof citation.url === "string") {
-      results.push({
-        title: citation.title || `Source ${i + 1}`,
-        url: citation.url,
-        snippet: ""
-      });
+}
+export async function searchWithPerplexity(query, options = {}) {
+  const numResults = typeof options.numResults === "number" && Number.isFinite(options.numResults) ? Math.max(1, Math.min(Math.floor(options.numResults), 20)) : 5;
+  const requestBody = {
+    query,
+    max_results: numResults,
+    search_type: "fast",
+    search_context_size: "medium"
+  };
+  if (options.recencyFilter) {
+    requestBody.search_recency_filter = options.recencyFilter;
+  }
+  if (options.domainFilter && options.domainFilter.length > 0) {
+    const validated = validateDomainFilter(options.domainFilter);
+    if (validated.length > 0) {
+      requestBody.search_domain_filter = validated;
     }
   }
-  activityMonitor.logComplete(activityId, response.status);
-  return { answer, results };
+  const data = await postPerplexity(PERPLEXITY_SEARCH_URL, requestBody, { activityQuery: query, signal: options.signal });
+  const results = [];
+  for (const entry of Array.isArray(data.results) ? data.results : []) {
+    if (!entry || typeof entry !== "object" || typeof entry.url !== "string" || !entry.url)
+      continue;
+    results.push({
+      title: typeof entry.title === "string" && entry.title.trim() ? entry.title.trim() : `Source ${results.length + 1}`,
+      url: entry.url,
+      snippet: typeof entry.snippet === "string" ? entry.snippet.trim() : ""
+    });
+    if (results.length >= numResults)
+      break;
+  }
+  return { answer: formatSearchResultsAsAnswer(results), results };
+}
+export async function askPerplexity(prompt, options = {}) {
+  const data = await postPerplexity(PERPLEXITY_CHAT_URL, {
+    model: "sonar",
+    messages: [{ role: "user", content: prompt }],
+    max_tokens: 1024,
+    return_related_questions: false
+  }, { activityQuery: prompt, signal: options.signal });
+  const content = data.choices?.[0]?.message?.content;
+  return typeof content === "string" ? content : "";
 }

package/extensions/dm-web-access/query-rewrite.js

@@ -1,13 +1,12 @@
 import { awaitWithAbort } from "./abortable.js";
-import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns } from "./summary-model-scope.js";
+import { findModelWithProviderRouting, isModelInScope } from "./summary-model-scope.js";
 async function resolveFirstAvailableModel(ctx, candidates) {
-  const enabledModelPatterns = loadEnabledModelPatterns(ctx);
   for (const { provider, id } of candidates) {
     const model = findModelWithProviderRouting(ctx.modelRegistry, provider, id);
-    if (!model || !modelMatchesEnabledPatterns(model, enabledModelPatterns))
+    if (!model || !isModelInScope(model, ctx.scopedModels))
       continue;
     const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-    if (auth.ok && auth.apiKey)
+    if (auth.ok)
       return { model, apiKey: auth.apiKey, headers: auth.headers };
   }
   throw new Error(`No enabled model available: ${candidates.map((candidate) => `${candidate.provider}/${candidate.id}`).join(", ")}`);

package/extensions/dm-web-access/scripts/build.js

@@ -0,0 +1,8 @@
+import { chmodSync, readFileSync } from "node:fs";
+import { buildSync } from "esbuild";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const externals = [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.peerDependencies ?? {})];
+const options = { bundle: true, format: "esm", platform: "node", target: "node20", outdir: "dist", outbase: "." };
+buildSync({ ...options, entryPoints: ["index.js"], external: externals });
+buildSync({ ...options, entryPoints: ["mcp-cli.js"], external: externals.filter((name) => name !== "typebox") });
+chmodSync("dist/mcp-cli.js", 493);

package/extensions/dm-web-access/ssrf-protection.js

@@ -1,10 +1,11 @@
 import { lookup as dnsLookup } from "node:dns/promises";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import net from "node:net";
-import { getActiveProxy, getWebSearchConfigPath, hasScopedProxyDecision, isProxyBypassedUrl } from "./utils.js";
+import { getActiveProxy, getWebSearchConfigPath, hasScopedProxyDecision, isProxyBypassedUrl, loadConfiguredProxy, normalizeProxyUrl } from "./utils.js";
 const DEFAULT_MAX_REDIRECTS = 5;
 const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 const LOOPBACK_ALLOW_RANGES = ["127.0.0.0/8", "::1", "::ffff:127.0.0.0/104"];
+const REMOTE_DNS_PROXY_PROTOCOLS = new Set(["http:", "https:", "socks4a:", "socks5h:"]);
 const WEB_SEARCH_CONFIG_PATH = getWebSearchConfigPath();
 let cachedConfigRoot = null;
 function loadConfigRoot() {
@@ -139,14 +140,17 @@ export async function validateRemoteUrl(rawUrl, options = {}) {
     assertPublicAddress(hostname, hostname, addressAllowRanges);
     return url;
   }
-  if (shouldTrustEnvProxy(url, options.trustEnvProxy === true))
+  const trustProxy = options.trustEnvProxy === true;
+  const proxy = options.proxy !== undefined ? normalizeProxyUrl(options.proxy, "proxy") : hasScopedProxyDecision() ? getActiveProxy() : undefined;
+  if (proxy === undefined ? shouldTrustEnvProxy(url, trustProxy) : trustProxy && isConfiguredRemoteDnsProxy(url, proxy))
     return url;
   let addresses;
   try {
     addresses = await (options.lookup ?? defaultLookup)(hostname);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to resolve ${hostname}: ${message}`);
+    const hint = !trustProxy && proxy && isConfiguredRemoteDnsProxy(url, proxy) ? ". If your configured proxy resolves hostnames, set ssrf.trustEnvProxy to true in web-search.json." : "";
+    throw new Error(`Failed to resolve ${hostname}: ${message}${hint}`);
   }
   if (addresses.length === 0)
     throw new Error(`Failed to resolve ${hostname}: no addresses returned`);
@@ -248,16 +252,14 @@ function hostnameMatchesNoProxy(hostname, port, entry) {
 function shouldTrustEnvProxy(url, enabled) {
   if (!enabled || !getProxyForProtocol(url.protocol))
     return false;
-  if (hasScopedProxyDecision())
-    return false;
-  const activeProxy = getActiveProxy();
-  if (activeProxy && !isProxyBypassedUrl(url))
-    return false;
   const hostname = normalizeHostname(url.hostname);
   const port = url.port || (url.protocol === "https:" ? "443" : "80");
   const noProxy = process.env.NO_PROXY || process.env.no_proxy || "";
   return !noProxy.split(",").some((entry) => hostnameMatchesNoProxy(hostname, port, entry));
 }
+function isConfiguredRemoteDnsProxy(url, proxy) {
+  return proxy !== null && REMOTE_DNS_PROXY_PROTOCOLS.has(new URL(proxy).protocol) && !isProxyBypassedUrl(url) && proxy === loadConfiguredProxy();
+}
 function assertPublicAddress(address, hostname, allowRanges = []) {
   const normalized = normalizeHostname(address);
   const ipVersion = net.isIP(normalized);

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

@@ -13,11 +13,12 @@ const DEFAULT_CACHE_LIMITS = { maxEntries: 128, maxBytes: 128 * 1024 * 1024 };
 const O_DIRECTORY = process.platform === "win32" ? 0 : constants.O_DIRECTORY ?? 0;
 const O_NOFOLLOW = process.platform === "win32" ? 0 : constants.O_NOFOLLOW ?? 0;
 const storedResults = new Map;
+const resultHolders = new Map;
 export function generateId() {
   return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
 }
 export function getFetchCacheDir() {
-  return join(getWebSearchConfigDir(), FETCH_CACHE_DIR);
+  return join(process.env.PI_WEB_ACCESS_CACHE_ROOT || getWebSearchConfigDir(), FETCH_CACHE_DIR);
 }
 function fetchCachePath(key) {
   if (!CACHE_KEY_PATTERN.test(key))
@@ -77,17 +78,9 @@ function cacheLimits(limits) {
   }
   return resolved;
 }
-function enforceDirectoryMode(fd) {
+function enforceMode(fd, mode) {
   try {
-    fchmodSync(fd, 448);
-  } catch (err) {
-    if (process.platform !== "win32")
-      throw err;
-  }
-}
-function enforceFileMode(fd) {
-  try {
-    fchmodSync(fd, 384);
+    fchmodSync(fd, mode);
   } catch (err) {
     if (process.platform !== "win32")
       throw err;
@@ -108,34 +101,23 @@ function safeFetchCacheDir(create) {
   if (before.isSymbolicLink() || !before.isDirectory()) {
     throw new Error("Fetched content cache path is not a safe directory");
   }
-  if (process.platform === "win32") {
-    const after = lstatSync(dir);
-    if (after.isSymbolicLink() || !after.isDirectory() || after.dev !== before.dev || after.ino !== before.ino) {
-      throw new Error("Fetched content cache directory changed while securing it");
+  if (process.platform !== "win32") {
+    const fd = openSync(dir, constants.O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
+    try {
+      const opened = fstatSync(fd);
+      if (!opened.isDirectory() || opened.dev !== before.dev || opened.ino !== before.ino) {
+        throw new Error("Fetched content cache directory changed while opening");
+      }
+      enforceMode(fd, 448);
+    } finally {
+      closeSync(fd);
     }
-    return dir;
   }
-  let fd = null;
-  try {
-    fd = openSync(dir, constants.O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
-    const opened = fstatSync(fd);
-    if (!opened.isDirectory() || opened.dev !== before.dev || opened.ino !== before.ino) {
-      throw new Error("Fetched content cache directory changed while opening");
-    }
-    enforceDirectoryMode(fd);
-    closeSync(fd);
-    fd = null;
-    const after = lstatSync(dir);
-    if (after.isSymbolicLink() || !after.isDirectory() || after.dev !== before.dev || after.ino !== before.ino) {
-      throw new Error("Fetched content cache directory changed while securing it");
-    }
-    return dir;
-  } finally {
-    if (fd !== null)
-      try {
-        closeSync(fd);
-      } catch {}
+  const after = lstatSync(dir);
+  if (after.isSymbolicLink() || !after.isDirectory() || after.dev !== before.dev || after.ino !== before.ino) {
+    throw new Error("Fetched content cache directory changed while securing it");
   }
+  return dir;
 }
 function openRegularFile(path) {
   const before = lstatSync(path);
@@ -157,24 +139,19 @@ function unlinkCacheFile(dir, file) {
   try {
     const root = lstatSync(dir);
     if (root.isSymbolicLink() || !root.isDirectory())
-      return "changed";
+      return false;
+  } catch {
+    return false;
+  }
+  try {
     const path = join(dir, file.name);
-    let current;
-    try {
-      current = lstatSync(path);
-    } catch (err) {
-      return err.code === "ENOENT" ? "missing" : "error";
-    }
+    const current = lstatSync(path);
     if (current.isSymbolicLink() || !current.isFile() || current.dev !== file.dev || current.ino !== file.ino)
-      return "changed";
-    try {
-      unlinkSync(path);
-      return "removed";
-    } catch (err) {
-      return err.code === "ENOENT" ? "missing" : "error";
-    }
-  } catch {
-    return "error";
+      return false;
+    unlinkSync(path);
+    return true;
+  } catch (err) {
+    return err.code === "ENOENT";
   }
 }
 function pruneFetchCache(now, limits, preferredKey, reservation) {
@@ -196,24 +173,21 @@ function pruneFetchCache(now, limits, preferredKey, reservation) {
   for (const entry of entries) {
     if (!CACHE_KEY_PATTERN.test(entry) && !CACHE_TMP_PATTERN.test(entry))
       continue;
-    const path = join(dir, entry);
-    let opened;
-    try {
-      opened = openRegularFile(path);
-    } catch {
-      continue;
-    }
+    let info;
     try {
-      enforceFileMode(opened.fd);
+      const opened = openRegularFile(join(dir, entry));
+      info = opened.info;
+      try {
+        enforceMode(opened.fd, 384);
+      } finally {
+        closeSync(opened.fd);
+      }
     } catch {
-      closeSync(opened.fd);
       continue;
     }
-    closeSync(opened.fd);
-    const file = { name: entry, size: opened.info.size, mtimeMs: opened.info.mtimeMs, dev: opened.info.dev, ino: opened.info.ino };
+    const file = { name: entry, size: info.size, mtimeMs: info.mtimeMs, dev: info.dev, ino: info.ino };
     if (now - file.mtimeMs >= CACHE_TTL_MS) {
-      const removed = unlinkCacheFile(dir, file);
-      if (removed !== "removed" && removed !== "missing")
+      if (!unlinkCacheFile(dir, file))
         return false;
       continue;
     }
@@ -236,8 +210,7 @@ function pruneFetchCache(now, limits, preferredKey, reservation) {
       break;
     const file = files[index];
     attempted.add(file.name);
-    const removed = unlinkCacheFile(dir, file);
-    if (removed === "removed" || removed === "missing")
+    if (unlinkCacheFile(dir, file))
       files.splice(index, 1);
     usage = projectedUsage();
   }
@@ -264,7 +237,7 @@ function writeFetchCache(data) {
     fd = openSync(tmpPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | O_NOFOLLOW, 384);
     const tmpInfo = fstatSync(fd);
     tmpFile = { name: tmpName, size: tmpInfo.size, mtimeMs: tmpInfo.mtimeMs, dev: tmpInfo.dev, ino: tmpInfo.ino };
-    enforceFileMode(fd);
+    enforceMode(fd, 384);
     writeFileSync(fd, serialized, "utf8");
     fsyncSync(fd);
     closeSync(fd);
@@ -290,10 +263,6 @@ function writeFetchCache(data) {
   }
   return { version: FETCH_CACHE_VERSION, key, storedAt: Date.now() };
 }
-function cacheWriteError(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  return `Failed to write fetched content cache: ${message}`;
-}
 function createFetchSessionData(data, ref, cacheError) {
   return {
     id: data.id,
@@ -323,10 +292,10 @@ function unavailableFetchData(data, reason) {
     }))
   };
 }
-function readCachedFetchData(data, now = Date.now()) {
+function readCachedFetchData(data) {
   if (data.type !== "fetch")
     return data;
-  if (now - data.timestamp >= CACHE_TTL_MS) {
+  if (Date.now() - data.timestamp >= CACHE_TTL_MS) {
     return unavailableFetchData(data, "Cached fetched content is missing or expired");
   }
   if (isInlineFetchData(data))
@@ -343,7 +312,7 @@ function readCachedFetchData(data, now = Date.now()) {
       return unavailableFetchData(data, "Cached fetched content is missing or expired");
     const opened = openRegularFile(path);
     fd = opened.fd;
-    enforceFileMode(fd);
+    enforceMode(fd, 384);
     const parsed = JSON.parse(readFileSync(fd, "utf8"));
     if (!isValidStoredData(parsed) || parsed.type !== "fetch" || parsed.id !== data.id || !isInlineFetchData(parsed)) {
       return unavailableFetchData(data, "Cached fetched content is invalid");
@@ -386,7 +355,7 @@ export function storeFetchedContentResult(id, data) {
   try {
     ref = writeFetchCache(data);
   } catch (err) {
-    cacheError = cacheWriteError(err);
+    cacheError = `Failed to write fetched content cache: ${err instanceof Error ? err.message : String(err)}`;
   }
   storedResults.set(id, ref ? { ...data, fetchCache: ref, urlMetadata: metadataForUrls(data.urls) } : { ...data, fetchCacheError: cacheError });
   return createFetchSessionData(data, ref, cacheError);
@@ -417,10 +386,33 @@ export function deleteResult(id) {
       }
     } catch {}
   }
+  resultHolders.delete(id);
   return storedResults.delete(id);
 }
 export function clearResults() {
   storedResults.clear();
+  resultHolders.clear();
+}
+export function holdResults(ids) {
+  for (const id of ids)
+    resultHolders.set(id, (resultHolders.get(id) ?? 0) + 1);
+}
+export function releaseResults(ids) {
+  for (const id of ids) {
+    const holders = (resultHolders.get(id) ?? 0) - 1;
+    if (holders > 0) {
+      resultHolders.set(id, holders);
+      continue;
+    }
+    resultHolders.delete(id);
+    storedResults.delete(id);
+  }
+}
+export function deleteHeldResult(id) {
+  if ((resultHolders.get(id) ?? 0) > 1)
+    releaseResults([id]);
+  else
+    deleteResult(id);
 }
 function isValidStoredData(data) {
   if (!data || typeof data !== "object")
@@ -447,14 +439,25 @@ function isValidStoredData(data) {
 }
 export function restoreFromSession(ctx) {
   storedResults.clear();
+  loadSessionResults(ctx);
+}
+export function loadSessionResults(ctx) {
   const now = Date.now();
   pruneExpiredFetchCache(now);
+  const loaded = [];
   for (const entry of ctx.sessionManager.getBranch()) {
     if (entry.type === "custom" && entry.customType === "web-search-results") {
       const data = entry.data;
       if (isValidStoredData(data) && now - data.timestamp < CACHE_TTL_MS) {
+        const live = storedResults.get(data.id);
+        if (live) {
+          loaded.push(live);
+          continue;
+        }
         storedResults.set(data.id, data);
+        loaded.push(data);
       }
     }
   }
+  return loaded;
 }

package/extensions/dm-web-access/summary-model-scope.js

@@ -1,6 +1,3 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 export function findModelWithProviderRouting(registry, provider, id) {
   const available = registry.getAvailable();
@@ -11,32 +8,8 @@ export function findModelWithProviderRouting(registry, provider, id) {
   const routed = available.find((model) => model.id === routedId);
   return routed ?? registry.find(provider, id);
 }
-function getAgentDir() {
-  return process.env.DM_CODING_AGENT_DIR || join(homedir(), ".dm", "agent");
-}
-function readSettings(path) {
-  if (!existsSync(path))
-    return {};
-  const raw = readFileSync(path, "utf8");
-  try {
-    return JSON.parse(raw);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${path}: ${message}`);
-  }
-}
-export function loadEnabledModelPatterns(ctx) {
-  const globalSettings = readSettings(join(getAgentDir(), "settings.json"));
-  const projectSettings = ctx.isProjectTrusted() ? readSettings(join(ctx.cwd, ".dm", "settings.json")) : {};
-  const value = Object.hasOwn(projectSettings, "enabledModels") ? projectSettings.enabledModels : globalSettings.enabledModels;
-  if (value === undefined)
-    return null;
-  if (!Array.isArray(value))
-    throw new Error("enabledModels must be an array");
-  return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
-}
-export function summaryModelValue(model) {
-  return `${model.provider}/${model.id}`;
+export function isModelInScope(model, scopedModels) {
+  return scopedModels.length === 0 || scopedModels.some((scoped) => scoped.model.provider === model.provider && scoped.model.id === model.id);
 }
 export function splitThinkingSuffix(value) {
   const index = value.lastIndexOf(":");
@@ -45,39 +18,7 @@ export function splitThinkingSuffix(value) {
   const suffix = value.slice(index + 1);
   return THINKING_LEVELS.has(suffix) ? { value: value.slice(0, index), thinkingLevel: suffix } : { value };
 }
-function stripThinkingSuffix(pattern) {
-  return splitThinkingSuffix(pattern).value;
-}
-function globToRegExp(pattern) {
-  let source = "^";
-  for (const char of pattern) {
-    if (char === "*") {
-      source += ".*";
-    } else if (char === "?") {
-      source += ".";
-    } else {
-      source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-    }
-  }
-  return new RegExp(`${source}$`, "i");
-}
-export function modelMatchesEnabledPatterns(model, patterns) {
-  if (patterns === null)
-    return true;
-  const value = summaryModelValue(model).toLowerCase();
-  const id = model.id.toLowerCase();
-  for (const rawPattern of patterns) {
-    const pattern = stripThinkingSuffix(rawPattern.trim()).toLowerCase();
-    if (!pattern)
-      continue;
-    if (pattern.includes("*") || pattern.includes("?")) {
-      const regex = globToRegExp(pattern);
-      if (regex.test(value) || regex.test(id))
-        return true;
-      continue;
-    }
-    if (pattern === value || pattern === id)
-      return true;
-  }
-  return false;
+export function getDmScopedModels(ctx) {
+  const scoped = ctx.scopedModels;
+  return Array.isArray(scoped) ? scoped : ctx.model ? [{ model: ctx.model }] : [];
 }