@agentprojectcontext/apx 1.30.1 → 1.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.30.1",
+  "version": "1.31.0",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"

package/src/core/agent/prompt-builder.js

@@ -271,6 +271,11 @@ export function buildSuperAgentSystem({
   // Pre-rendered "# Hilos activos en otros canales" block (recency-based
   // cross-channel awareness; see core/memory/active-threads.js). "" → omitted.
   activeThreadsBlock = "",
+  // Compact "# Tools adicionales (activación on-demand)" block: instructions +
+  // the NAMES (no schemas) of tools that exist but aren't loaded on this
+  // channel, so the model knows they're reachable via discover_tools without
+  // paying for their schemas. "" → omitted (full channels load everything).
+  lazyToolsBlock = "",
 }) {
   const sa = globalConfig.super_agent;
   const projectIndex = projects
@@ -305,6 +310,7 @@ export function buildSuperAgentSystem({
     projectIndex || "(no projects registered)",
     buildProjectAgentsBlock(channelMeta?.projectPath),
     buildSkillsCatalog(listSkills),
+    lazyToolsBlock,
     voiceModeBlock,
     systemSuffix,
   ]

package/src/core/agent/run-agent.js

@@ -178,6 +178,25 @@ export async function runAgent({
       })
     : rawHandlers;
 
+  // Lazy tools: when the super-agent runs a `discover_tools` activation, its
+  // handler pushes the newly-revealed schemas onto session.pending. We drain
+  // that queue into effectiveSchemas at the top of each iteration, so tools
+  // activated on step N are callable from step N+1. No session → no-op.
+  const toolSession = toolHandlerCtx?.toolSession || null;
+  const drainPendingTools = () => {
+    if (!toolSession || toolSession.pending.length === 0) return;
+    const seen = new Set(
+      effectiveSchemas.map((s) => s?.function?.name || s?.name)
+    );
+    const additions = [];
+    for (const sc of toolSession.pending) {
+      const n = sc?.function?.name || sc?.name;
+      if (n && !seen.has(n)) { additions.push(sc); seen.add(n); }
+    }
+    toolSession.pending = [];
+    if (additions.length > 0) effectiveSchemas = effectiveSchemas.concat(additions);
+  };
+
   const conversation = [...previousMessages, { role: "user", content: prompt }];
   const trace = [];
   let totalUsage = { input_tokens: 0, output_tokens: 0 };
@@ -236,6 +255,8 @@ export async function runAgent({
   };
 
   for (let iter = 0; iter < maxIters; iter++) {
+    // Merge any tools activated via discover_tools on the previous iteration.
+    drainPendingTools();
     await emitProgress(onEvent, { type: "model_start", iteration: iter + 1, model: activeModel });
     // Force a tool call on iter 0 ONLY when the user message looks like a real
     // action request ("listame…", "mandá…", "buscá…"). For chit-chat ("hola",

package/src/core/tools/browser.js

@@ -181,19 +181,104 @@ async function ensureBrowser({ launch_options, allow_dangerous } = {}) {
   return _page;
 }
 
+// ---------------------------------------------------------------------------
+// Context-destruction resilience
+// ---------------------------------------------------------------------------
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// Puppeteer throws this family of errors when an action (evaluate / get_text /
+// click / …) runs while the page is navigating, redirecting, or reloading —
+// the frame's JS execution context is torn down mid-call. Redirect-heavy sites
+// (ESPN geo/consent hops, login walls) trigger it constantly. These are
+// transient: waiting for the navigation to settle and retrying succeeds.
+const CONTEXT_DESTROYED_RE =
+  /Execution context was destroyed|Cannot find context|Execution context is not available|detached frame|frame (?:was|got) detached|Target closed|Session closed|Protocol error.*(?:Runtime|Page)\./i;
+
+export function isContextDestroyed(err) {
+  return CONTEXT_DESTROYED_RE.test(String(err?.message || err));
+}
+
+// Let any in-flight navigation finish so the next action sees a stable context.
+async function settlePage(page, { timeout = 5000 } = {}) {
+  if (!page || page.isClosed()) return;
+  await page.waitForNetworkIdle({ idleTime: 500, timeout }).catch(() => {});
+}
+
+// Run a page action, retrying on a transient "Execution context was destroyed"
+// (and friends): wait `delayMs`, let the page settle, try again — up to
+// `retries` extra attempts. Non-context errors bubble immediately.
+export async function withContextRetry(fn, { retries = 2, delayMs = 1500 } = {}) {
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (e) {
+      lastErr = e;
+      if (!isContextDestroyed(e) || attempt === retries) throw e;
+      await sleep(delayMs);
+      await settlePage(_page);
+    }
+  }
+  throw lastErr;
+}
+
+// Convenience: ensure the browser/page, then run an action under context-retry.
+async function onPage(fn) {
+  const page = await ensureBrowser();
+  return withContextRetry(() => fn(page));
+}
+
 // ---------------------------------------------------------------------------
 // Tool implementations
 // ---------------------------------------------------------------------------
 
-export async function browser_navigate({ url, launch_options, allow_dangerous } = {}) {
+export async function browser_navigate({ url, launch_options, allow_dangerous, wait_until } = {}) {
   if (!url) throw new Error("url required");
   const page = await ensureBrowser({ launch_options, allow_dangerous });
-  const response = await page.goto(url, { waitUntil: "networkidle2", timeout: 30000 });
+
+  const go = async (waitUntil) => {
+    const response = await page.goto(url, { waitUntil, timeout: 30000 });
+    // Some sites fire a client-side redirect/reload right after the initial
+    // load. Give it a beat to settle so the execution context is stable for
+    // the caller's NEXT tool (get_text/evaluate) instead of being destroyed
+    // out from under it.
+    await settlePage(page, { timeout: 3000 });
+    return response;
+  };
+
+  // Preferred wait strategy: networkidle2 (or caller override). On a
+  // context-destroyed / timeout / navigation error, fall back to the much more
+  // permissive "domcontentloaded" which resolves as soon as the DOM is parsed,
+  // before late redirects/XHR can tear the context down.
+  const preferred = wait_until || "networkidle2";
+  let response;
+  try {
+    response = await go(preferred);
+  } catch (e) {
+    const recoverable =
+      isContextDestroyed(e) ||
+      /TimeoutError|Navigation timeout|net::ERR_ABORTED|frame was detached/i.test(String(e?.message || e));
+    if (!recoverable || preferred === "domcontentloaded") throw e;
+    await sleep(1500);
+    response = await go("domcontentloaded");
+  }
+
+  // title() evaluates in-page, so it can itself throw if a redirect is still
+  // in flight — read it defensively (url() is sync and always safe).
+  let title = "";
+  try {
+    title = await withContextRetry(() => page.title(), { retries: 1, delayMs: 1000 });
+  } catch {
+    title = "";
+  }
+
   return {
     ok: true,
     url: page.url(),
     status: response?.status() ?? null,
-    title: await page.title(),
+    title,
+    wait_until: response ? (preferred) : null,
   };
 }
 
@@ -206,12 +291,13 @@ export async function browser_screenshot({ selector, full_page = false, width, h
     });
   }
 
-  const target = selector ? await page.$(selector) : null;
-  if (selector && !target) throw new Error(`Element not found: ${selector}`);
-
-  const buf = target
-    ? await target.screenshot({ type: "png", encoding: "base64" })
-    : await page.screenshot({ type: "png", encoding: "base64", fullPage: !!full_page });
+  const buf = await withContextRetry(async () => {
+    const target = selector ? await page.$(selector) : null;
+    if (selector && !target) throw new Error(`Element not found: ${selector}`);
+    return target
+      ? await target.screenshot({ type: "png", encoding: "base64" })
+      : await page.screenshot({ type: "png", encoding: "base64", fullPage: !!full_page });
+  });
 
   const size = Buffer.from(String(buf), "base64").length;
   if (size > MAX_SCREENSHOT_BYTES) {
@@ -248,50 +334,56 @@ export async function browser_screenshot({ selector, full_page = false, width, h
 
 export async function browser_click({ selector } = {}) {
   if (!selector) throw new Error("selector required");
-  const page = await ensureBrowser();
-  await page.waitForSelector(selector, { timeout: 10000 });
-  await page.click(selector);
-  await page.waitForNetworkIdle({ timeout: 5000 }).catch(() => {});
-  return { ok: true, selector, url: page.url() };
+  return onPage(async (page) => {
+    await page.waitForSelector(selector, { timeout: 10000 });
+    await page.click(selector);
+    await page.waitForNetworkIdle({ timeout: 5000 }).catch(() => {});
+    return { ok: true, selector, url: page.url() };
+  });
 }
 
 export async function browser_type({ selector, text, clear = true } = {}) {
   if (!selector) throw new Error("selector required");
   if (text === undefined) throw new Error("text required");
-  const page = await ensureBrowser();
-  await page.waitForSelector(selector, { timeout: 10000 });
-  await page.focus(selector);
-  if (clear) {
-    await page.keyboard.down("Control");
-    await page.keyboard.press("KeyA");
-    await page.keyboard.up("Control");
-    await page.keyboard.press("Backspace");
-  }
-  await page.type(selector, String(text), { delay: 20 });
-  return { ok: true, selector, typed: String(text).length };
+  return onPage(async (page) => {
+    await page.waitForSelector(selector, { timeout: 10000 });
+    await page.focus(selector);
+    if (clear) {
+      await page.keyboard.down("Control");
+      await page.keyboard.press("KeyA");
+      await page.keyboard.up("Control");
+      await page.keyboard.press("Backspace");
+    }
+    await page.type(selector, String(text), { delay: 20 });
+    return { ok: true, selector, typed: String(text).length };
+  });
 }
 
 export async function browser_select({ selector, value } = {}) {
   if (!selector) throw new Error("selector required");
   if (value === undefined) throw new Error("value required");
-  const page = await ensureBrowser();
-  await page.waitForSelector(selector, { timeout: 10000 });
-  await page.select(selector, String(value));
-  return { ok: true, selector, value };
+  return onPage(async (page) => {
+    await page.waitForSelector(selector, { timeout: 10000 });
+    await page.select(selector, String(value));
+    return { ok: true, selector, value };
+  });
 }
 
 export async function browser_hover({ selector } = {}) {
   if (!selector) throw new Error("selector required");
-  const page = await ensureBrowser();
-  await page.waitForSelector(selector, { timeout: 10000 });
-  await page.hover(selector);
-  return { ok: true, selector };
+  return onPage(async (page) => {
+    await page.waitForSelector(selector, { timeout: 10000 });
+    await page.hover(selector);
+    return { ok: true, selector };
+  });
 }
 
 export async function browser_evaluate({ code } = {}) {
   if (!code) throw new Error("code required");
-  const page = await ensureBrowser();
+  return onPage((page) => evaluateOnPage(page, code));
+}
 
+async function evaluateOnPage(page, code) {
   // Install in-page console capture so evaluated code's logs come back.
   await page.evaluate(() => {
     window.__apxHelper = { logs: [], orig: { ...console } };
@@ -325,54 +417,56 @@ export async function browser_evaluate({ code } = {}) {
 }
 
 export async function browser_get_text({ selector } = {}) {
-  const page = await ensureBrowser();
-  const text = await page.evaluate((sel) => {
-    const root = sel ? document.querySelector(sel) : document.body;
-    if (!root) return null;
-    const clone = root.cloneNode(true);
-    for (const tag of ["script", "style", "nav", "header", "footer", "noscript"]) {
-      for (const el of clone.querySelectorAll(tag)) el.remove();
-    }
-    return clone.innerText || clone.textContent || "";
-  }, selector ?? null);
-  if (text === null) throw new Error(`Element not found: ${selector}`);
-  const cleaned = text.replace(/\n{3,}/g, "\n\n").trim();
-  return {
-    ok: true,
-    url: page.url(),
-    title: await page.title(),
-    text: cleaned,
-    chars: cleaned.length,
-  };
+  return onPage(async (page) => {
+    const text = await page.evaluate((sel) => {
+      const root = sel ? document.querySelector(sel) : document.body;
+      if (!root) return null;
+      const clone = root.cloneNode(true);
+      for (const tag of ["script", "style", "nav", "header", "footer", "noscript"]) {
+        for (const el of clone.querySelectorAll(tag)) el.remove();
+      }
+      return clone.innerText || clone.textContent || "";
+    }, selector ?? null);
+    if (text === null) throw new Error(`Element not found: ${selector}`);
+    const cleaned = text.replace(/\n{3,}/g, "\n\n").trim();
+    let title = "";
+    try { title = await page.title(); } catch { title = ""; }
+    return {
+      ok: true,
+      url: page.url(),
+      title,
+      text: cleaned,
+      chars: cleaned.length,
+    };
+  });
 }
 
 export async function browser_get_content({ selector } = {}) {
-  const page = await ensureBrowser();
-  let content = selector
-    ? await page.$eval(selector, el => el.innerHTML).catch(() => null)
-    : await page.content();
-  if (content === null) throw new Error(`Element not found: ${selector}`);
-
-  let truncated = false;
-  if (content.length > MAX_CONTENT_CHARS) {
-    content = content.slice(0, MAX_CONTENT_CHARS) + "\n[TRUNCATED]";
-    truncated = true;
-  }
-  return {
-    ok: true,
-    url: page.url(),
-    selector: selector ?? null,
-    chars: content.length,
-    truncated,
-    html: content,
-  };
+  return onPage(async (page) => {
+    let content = selector
+      ? await page.$eval(selector, el => el.innerHTML).catch(() => null)
+      : await page.content();
+    if (content === null) throw new Error(`Element not found: ${selector}`);
+
+    let truncated = false;
+    if (content.length > MAX_CONTENT_CHARS) {
+      content = content.slice(0, MAX_CONTENT_CHARS) + "\n[TRUNCATED]";
+      truncated = true;
+    }
+    return {
+      ok: true,
+      url: page.url(),
+      selector: selector ?? null,
+      chars: content.length,
+      truncated,
+      html: content,
+    };
+  });
 }
 
 export async function browser_wait_for_selector({ selector, timeout = 30000 } = {}) {
   if (!selector) throw new Error("selector required");
-  const page = await ensureBrowser();
-  await page.waitForSelector(selector, { timeout });
-  return { ok: true, selector };
+  return onPage((page) => page.waitForSelector(selector, { timeout }).then(() => ({ ok: true, selector })));
 }
 
 export async function browser_close() {

package/src/core/tools/registry.js

@@ -350,12 +350,17 @@ const TOOL_DEFINITIONS = [
   {
     name: "browser_navigate",
     category: "browser",
-    description: "Navigate the headless browser to a URL. Launches Chromium lazily on first call.",
+    description: "Navigate the headless browser to a URL. Launches Chromium lazily on first call. Auto-retries and falls back to a more permissive wait strategy on redirect-heavy sites.",
     endpoint: { method: "POST", path: "/tools/browser/navigate" },
     parameters: {
       type: "object",
       properties: {
         url: { type: "string" },
+        wait_until: {
+          type: "string",
+          enum: ["load", "domcontentloaded", "networkidle0", "networkidle2"],
+          description: "Puppeteer wait strategy (default networkidle2). Use 'domcontentloaded' for slow/redirect-heavy sites; navigate auto-falls back to it on failure anyway.",
+        },
         launch_options: { type: "object", description: "Puppeteer launch overrides (headless, args, defaultViewport, etc.)." },
         allow_dangerous: { type: "boolean", description: "Allow dangerous launch args (--no-sandbox, --single-process, etc.)." },
       },

package/src/core/tools/search.js

@@ -45,26 +45,54 @@ function extractText(html) {
     .replace(/&lt;/g, "<")
     .replace(/&gt;/g, ">")
     .replace(/&quot;/g, '"')
-    .replace(/&#039;/g, "'")
+    .replace(/&#0?39;/g, "'")
     .replace(/&nbsp;/g, " ")
+    // Generic numeric entities (decimal &#92; and hex &#x27;) DDG sprinkles into
+    // titles/snippets — decode so results read cleanly.
+    .replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+    .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
     .replace(/\s{2,}/g, " ")
     .trim();
 }
 
+/**
+ * Unwrap DuckDuckGo's result redirect. DDG no longer exposes the target URL
+ * directly: every result href is `//duckduckgo.com/l/?uddg=<urlencoded real
+ * url>&rut=...`. We pull the `uddg` param out and decode it back to the real
+ * destination. Plain/protocol-relative URLs are normalized to https.
+ */
+export function unwrapDdgUrl(href) {
+  if (!href) return href;
+  const m = href.match(/[?&]uddg=([^&]+)/);
+  if (m) {
+    try {
+      return decodeURIComponent(m[1].replace(/&amp;/g, "&"));
+    } catch {
+      /* fall through to raw href */
+    }
+  }
+  if (href.startsWith("//")) return "https:" + href;
+  return href;
+}
+
 /** Parse DuckDuckGo HTML results */
-function parseDdgResults(html, limit) {
+export function parseDdgResults(html, limit) {
   const results = [];
-  // Match result blocks: each has a link (.result__a) and snippet (.result__snippet)
-  const blockRe = /<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+  // Match result blocks: each has a link (.result__a) and snippet (.result__snippet).
+  // Attribute order varies (rel/class/href), so don't assume class precedes href.
+  const blockRe = /<a[^>]+class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
   const snippetRe = /<a[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
 
   const links = [];
   let m;
   while ((m = blockRe.exec(html)) !== null && links.length < limit * 2) {
-    const href = m[1];
+    // DDG wraps every external link in a //duckduckgo.com/l/?uddg= redirect —
+    // decode it to the real target instead of discarding it (the old code
+    // dropped everything containing "duckduckgo.com", yielding zero results).
+    const url = unwrapDdgUrl(m[1]);
     const title = extractText(m[2]).trim();
-    if (href && title && !href.startsWith("//duckduckgo") && !href.includes("duckduckgo.com")) {
-      links.push({ url: href, title });
+    if (url && title && !/^https?:\/\/(?:[a-z]+\.)?duckduckgo\.com\//i.test(url) && !url.startsWith("//duckduckgo")) {
+      links.push({ url, title });
     }
   }
 

package/src/host/daemon/plugins/telegram.js

@@ -510,6 +510,10 @@ class ChannelPoller {
       const token = resolveBotToken(this.channel);
       const mediaDir = path.join(APX_HOME, "media");
       fs.mkdirSync(mediaDir, { recursive: true });
+      // Show "typing…" right away — download + transcription is the slow part of
+      // a voice message, and the reply-path typing (below) only starts after it,
+      // so without this the chat sits silent for seconds with no feedback.
+      const stopVoiceTyping = this._startTyping(chat_id);
       let localPath = null;
       let transcript = "";
       let transcribeError = null;
@@ -531,6 +535,7 @@ class ChannelPoller {
           this.log(`telegram[${this.channel.name}] audio transcription failed: ${e.message}`);
         }
       }
+      stopVoiceTyping(); // reply-path typing takes over from here
       const audioBody = transcript
         ? `[audio] ${transcript}`
         : `[audio] (transcription unavailable${transcribeError ? ": " + transcribeError : ""})`;