@mono-agent/agent-runtime 0.15.2 → 0.15.4

package/src/agent/tools/web-search.js

@@ -1,28 +1,580 @@
+// @ts-check
+
+import { parseHTML } from "linkedom";
 import { passthroughSandbox } from "../sandbox-seam.js";
 import { readToolRuntime } from "./shared/runtime-context.js";
 import { resolveSandboxPolicy } from "./shared/tool-context.js";
 
+const SEARCH_TIMEOUT_MS = 15_000;
+const SEARCH_RESPONSE_MAX_BYTES = 2 * 1024 * 1024;
+const RRF_K = 60;
+const TRACKING_PARAMETERS = new Set([
+  "dclid",
+  "fbclid",
+  "gclid",
+  "igshid",
+  "mc_cid",
+  "mc_eid",
+  "mkt_tok",
+  "msclkid",
+  "ref_src",
+  "s_cid",
+  "vero_conv",
+  "vero_id",
+]);
+
+/**
+ * Compatibility wrapper for direct callers.
+ *
+ * @param {{query: string, limit?: number, alternate_queries?: string[], domains?: string[], exclude_domains?: string[], language?: string, time_range?: string}} params
+ * @param {{sandboxPolicy?: any, ctx?: any, signal?: AbortSignal, searchConfig?: any, fetchImpl?: typeof fetch}} [options]
+ */
+export async function webSearchToolImpl(params, options = {}) {
+  return (await performWebSearch(params, options)).text;
+}
+
 /**
- * @param {{query: string, limit?: number}} params
- * @param {{sandboxPolicy?: any, ctx?: any}} [options]
+ * Search through an operator-owned SearXNG endpoint and/or the keyless HTML
+ * fallback chain. Returns a structured internal outcome for the Pi bridge.
+ *
+ * @param {{query: string, limit?: number, alternate_queries?: string[], domains?: string[], exclude_domains?: string[], language?: string, time_range?: string}} params
+ * @param {{sandboxPolicy?: any, ctx?: any, signal?: AbortSignal, searchConfig?: any, fetchImpl?: typeof fetch}} [options]
  */
-export async function webSearchToolImpl({ query, limit = 5 }, { sandboxPolicy, ctx } = {}) {
-  const max = Math.min(Math.max(Number(limit) || 5, 1), 10);
-  const url = `https://duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+export async function performWebSearch(
+  {
+    query,
+    limit = 5,
+    alternate_queries = [],
+    domains = [],
+    exclude_domains = [],
+    language,
+    time_range,
+  },
+  {
+    sandboxPolicy,
+    ctx,
+    signal,
+    searchConfig,
+    fetchImpl = globalThis.fetch,
+  } = {},
+) {
+  const startedAt = Date.now();
+  const normalizedQuery = typeof query === "string" ? query.trim() : "";
+  if (!normalizedQuery) {
+    return failure("Error: WebSearch query must not be empty.", "invalid_query", startedAt);
+  }
+  const max = clampInteger(limit, 1, 10, 5);
+  const includeDomains = normalizeDomains(domains);
+  const excludeDomains = normalizeDomains(exclude_domains);
+  const config = normalizeSearchConfig(searchConfig);
+  if (config.error) return failure(`Error: ${config.error}`, "invalid_search_config", startedAt);
+
   const resolvedCtx = ctx ?? readToolRuntime();
   const sandbox = resolvedCtx.sandbox ?? passthroughSandbox;
-  if (!sandbox.networkAllowsUrl(resolveSandboxPolicy(resolvedCtx, sandboxPolicy), url)) return "Error: Network access denied by sandbox policy.";
-  const resp = await fetch(url, {
-    headers: { "User-Agent": "Mozilla/5.0 AgentRuntime/0.1" },
-    signal: AbortSignal.timeout(15000),
+  const policy = resolveSandboxPolicy(resolvedCtx, sandboxPolicy);
+  const initialQueries = uniqueStrings([normalizedQuery, ...alternate_queries], 4);
+  /** @type {Array<Array<{title: string, url: string, snippet: string, backend: string}>>} */
+  const rankedLists = [];
+  const providerFailures = [];
+  const providersUsed = new Set();
+  let attempts = 0;
+  let anyProviderSucceeded = false;
+
+  const runQuery = async (candidate) => {
+    attempts += 1;
+    return await searchOneQuery(
+      queryWithDomains(candidate, includeDomains),
+      {
+        config,
+        language,
+        timeRange: time_range,
+        sandbox,
+        policy,
+        signal,
+        fetchImpl,
+      },
+    );
+  };
+  const recordResult = (result) => {
+    if (result.ok) {
+      anyProviderSucceeded = true;
+      providersUsed.add(result.backend);
+      rankedLists.push(filterByDomains(result.results, includeDomains, excludeDomains));
+    } else {
+      providerFailures.push(result);
+    }
+  };
+
+  const initialResults = await Promise.all(initialQueries.map(runQuery));
+  initialResults.forEach(recordResult);
+  if (signal?.aborted) {
+    return failure("Error: WebSearch was aborted.", "aborted", startedAt, {
+      attempts,
+      retryable: false,
+    });
+  }
+
+  let merged = mergeRankedResults(rankedLists, max);
+  if (merged.length < max && initialQueries.length < 4) {
+    const relaxed = relaxedQuery(normalizedQuery);
+    if (relaxed && !initialQueries.includes(relaxed)) {
+      recordResult(await runQuery(relaxed));
+      merged = mergeRankedResults(rankedLists, max);
+    }
+  }
+
+  if (!anyProviderSucceeded) {
+    const reason = providerFailures.map((entry) => entry.message).filter(Boolean).join("; ")
+      || "No search backend was available.";
+    const networkDenied = providerFailures.length > 0
+      && providerFailures.every((entry) => entry.message === "Network access denied by sandbox policy.");
+    return failure(networkDenied
+      ? "Error: Network access denied by sandbox policy."
+      : `Error: WebSearch failed: ${reason}`, networkDenied ? "network_denied" : "backend_unavailable", startedAt, {
+      attempts,
+      backend: config.backend,
+      retryable: providerFailures.some((entry) => entry.retryable),
+    });
+  }
+
+  const backend = providersUsed.size === 1 ? [...providersUsed][0] : "mixed";
+  const body = merged.length === 0
+    ? "No results."
+    : merged.map((result, index) => {
+        const snippet = result.snippet ? `\n   ${collapseWhitespace(result.snippet)}` : "";
+        return `${index + 1}. [${escapeMarkdownLabel(result.title || result.url)}](${result.url})${snippet}`;
+      }).join("\n\n");
+  const text = [
+    "[BEGIN UNTRUSTED WEB SEARCH RESULTS]",
+    body,
+    "[END UNTRUSTED WEB SEARCH RESULTS]",
+  ].join("\n");
+  return {
+    text,
+    outcome: {
+      status: "ok",
+      code: merged.length === 0 ? "no_results" : "ok",
+      retryable: false,
+      attempts,
+      backend,
+      cacheHit: false,
+      durationMs: Date.now() - startedAt,
+      bytes: Buffer.byteLength(text, "utf8"),
+      truncated: false,
+      resultCount: merged.length,
+      providerFailureCount: providerFailures.length,
+    },
+    error: false,
+  };
+}
+
+async function searchOneQuery(query, options) {
+  const { config } = options;
+  const failures = [];
+  if (options.signal?.aborted) return abortedSearch(config.backend);
+  if (config.backend === "searxng" || (config.backend === "auto" && config.endpoint)) {
+    const result = await searchSearxng(query, options);
+    if (result.ok || config.backend === "searxng") return result;
+    failures.push(result);
+    if (options.signal?.aborted) return abortedSearch(result.backend);
+  }
+  if (config.backend === "keyless" || config.backend === "auto") {
+    const duck = await searchDuckDuckGo(query, options);
+    if (duck.ok && duck.results.length > 0) return duck;
+    if (!duck.ok) failures.push(duck);
+    if (options.signal?.aborted) return abortedSearch(duck.backend);
+    const startpage = await searchStartpage(query, options);
+    if (startpage.ok) return startpage;
+    failures.push(startpage);
+    if (duck.ok) return duck;
+  }
+  return failures[failures.length - 1] || {
+    ok: false,
+    backend: config.backend,
+    message: "No configured search backend.",
+    retryable: false,
+  };
+}
+
+function abortedSearch(backend) {
+  return {
+    ok: false,
+    backend,
+    message: "WebSearch was aborted.",
+    retryable: false,
+  };
+}
+
+async function searchSearxng(query, options) {
+  const endpoint = options.config.endpoint;
+  if (!endpoint) {
+    return { ok: false, backend: "searxng", message: "SearXNG endpoint is not configured.", retryable: false };
+  }
+  const url = `${endpoint}/search`;
+  if (!options.sandbox.networkAllowsUrl(options.policy, url)) {
+    return { ok: false, backend: "searxng", message: "Network access denied by sandbox policy.", retryable: false };
+  }
+  const body = new URLSearchParams({ q: query, format: "json", categories: "general" });
+  if (typeof options.language === "string" && options.language.trim()) {
+    body.set("language", options.language.trim());
+  }
+  if (["day", "month", "year"].includes(options.timeRange)) {
+    body.set("time_range", options.timeRange);
+  }
+  try {
+    const response = await options.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+        "User-Agent": "mono-agent-web/1",
+      },
+      body,
+      signal: requestSignal(options.signal),
+      redirect: "error",
+    });
+    const text = await readLimitedText(response);
+    if (!response.ok) {
+      return {
+        ok: false,
+        backend: "searxng",
+        message: `SearXNG HTTP ${response.status}`,
+        retryable: response.status === 429 || response.status >= 500,
+      };
+    }
+    let data;
+    try { data = JSON.parse(text); } catch {
+      return { ok: false, backend: "searxng", message: "SearXNG returned invalid JSON.", retryable: false };
+    }
+    const results = Array.isArray(data?.results)
+      ? data.results.flatMap((entry) => normalizedResult(entry, "searxng"))
+      : [];
+    return { ok: true, backend: "searxng", results };
+  } catch (error) {
+    return fetchFailure("searxng", error);
+  }
+}
+
+async function searchDuckDuckGo(query, options) {
+  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+  if (!options.sandbox.networkAllowsUrl(options.policy, url)) {
+    return { ok: false, backend: "duckduckgo", message: "Network access denied by sandbox policy.", retryable: false };
+  }
+  try {
+    const response = await options.fetchImpl(url, {
+      headers: {
+        Accept: "text/html,application/xhtml+xml",
+        "Accept-Language": options.language || "en-US,en;q=0.8",
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) mono-agent-web/1",
+      },
+      signal: requestSignal(options.signal),
+      redirect: "error",
+    });
+    const html = await readLimitedText(response);
+    if (!response.ok) {
+      return {
+        ok: false,
+        backend: "duckduckgo",
+        message: `DuckDuckGo HTTP ${response.status}`,
+        retryable: response.status === 429 || response.status >= 500,
+      };
+    }
+    return { ok: true, backend: "duckduckgo", results: parseDuckDuckGoResults(html) };
+  } catch (error) {
+    return fetchFailure("duckduckgo", error);
+  }
+}
+
+async function searchStartpage(query, options) {
+  const url = `https://www.startpage.com/sp/search?query=${encodeURIComponent(query)}`;
+  if (!options.sandbox.networkAllowsUrl(options.policy, url)) {
+    return { ok: false, backend: "startpage", message: "Network access denied by sandbox policy.", retryable: false };
+  }
+  try {
+    const response = await options.fetchImpl(url, {
+      headers: {
+        Accept: "text/html,application/xhtml+xml",
+        "Accept-Language": options.language || "en-US,en;q=0.8",
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) mono-agent-web/1",
+      },
+      signal: requestSignal(options.signal),
+      redirect: "error",
+    });
+    const html = await readLimitedText(response);
+    if (!response.ok) {
+      return {
+        ok: false,
+        backend: "startpage",
+        message: `Startpage HTTP ${response.status}`,
+        retryable: response.status === 429 || response.status >= 500,
+      };
+    }
+    return { ok: true, backend: "startpage", results: parseStartpageResults(html) };
+  } catch (error) {
+    return fetchFailure("startpage", error);
+  }
+}
+
+export function parseDuckDuckGoResults(html) {
+  const { document } = parseHTML(String(html || ""));
+  const rows = [...document.querySelectorAll(".result")];
+  return rows.flatMap((row) => {
+    const link = row.querySelector("a.result__a");
+    if (!link) return [];
+    const url = canonicalizeSearchUrl(link.getAttribute("href"), "https://html.duckduckgo.com/");
+    if (!url) return [];
+    return [{
+      title: collapseWhitespace(link.textContent),
+      url,
+      snippet: collapseWhitespace(row.querySelector(".result__snippet")?.textContent),
+      backend: "duckduckgo",
+    }];
   });
-  if (!resp.ok) return `Search failed: HTTP ${resp.status}`;
-  const html = await resp.text();
+}
+
+export function parseStartpageResults(html) {
+  const { document } = parseHTML(String(html || ""));
+  const selectors = [".w-gl__result", ".result", "article"];
+  const rows = selectors.flatMap((selector) => [...document.querySelectorAll(selector)]);
+  const seen = new Set();
   const results = [];
-  const re = /<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
-  let m;
-  while ((m = re.exec(html)) && results.length < max) {
-    results.push(`${m[2].replace(/<[^>]+>/g, "").trim()}\n${m[1]}\n${m[3].replace(/<[^>]+>/g, "").trim()}`);
+  for (const row of rows) {
+    const link = row.querySelector("a.w-gl__result-title, a.result-link, h2 a, h3 a");
+    if (!link) continue;
+    const url = canonicalizeSearchUrl(link.getAttribute("href"), "https://www.startpage.com/");
+    if (!url || seen.has(url)) continue;
+    seen.add(url);
+    results.push({
+      title: collapseWhitespace(link.textContent),
+      url,
+      snippet: collapseWhitespace(
+        row.querySelector(".w-gl__description, .result-description, p")?.textContent,
+      ),
+      backend: "startpage",
+    });
   }
-  return results.length ? results.join("\n\n") : "No results.";
+  return results;
+}
+
+function normalizedResult(entry, backend) {
+  if (!entry || typeof entry !== "object") return [];
+  const url = canonicalizeSearchUrl(entry.url);
+  if (!url) return [];
+  return [{
+    title: collapseWhitespace(entry.title) || url,
+    url,
+    snippet: collapseWhitespace(entry.content || entry.snippet),
+    backend,
+  }];
+}
+
+export function canonicalizeSearchUrl(value, base) {
+  if (typeof value !== "string" || value.trim().length === 0) return null;
+  let parsed;
+  try { parsed = new URL(value, base); } catch { return null; }
+  const wrapped = ["uddg", "url", "u", "target"].map((key) => parsed.searchParams.get(key)).find(Boolean);
+  if (wrapped && (
+    parsed.hostname.endsWith("duckduckgo.com")
+    || parsed.hostname.endsWith("startpage.com")
+  )) {
+    try { parsed = new URL(wrapped); } catch { /* keep the wrapper URL */ }
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  parsed.username = "";
+  parsed.password = "";
+  parsed.hash = "";
+  parsed.hostname = parsed.hostname.toLowerCase();
+  for (const key of [...parsed.searchParams.keys()]) {
+    if (key.toLowerCase().startsWith("utm_") || TRACKING_PARAMETERS.has(key.toLowerCase())) {
+      parsed.searchParams.delete(key);
+    }
+  }
+  parsed.searchParams.sort();
+  if ((parsed.protocol === "https:" && parsed.port === "443") || (parsed.protocol === "http:" && parsed.port === "80")) {
+    parsed.port = "";
+  }
+  if (parsed.pathname.length > 1) parsed.pathname = parsed.pathname.replace(/\/+$/u, "");
+  return parsed.href;
+}
+
+export function mergeRankedResults(rankedLists, limit = 10) {
+  const merged = new Map();
+  for (const list of rankedLists) {
+    for (let index = 0; index < list.length; index += 1) {
+      const result = list[index];
+      const url = canonicalizeSearchUrl(result.url);
+      if (!url) continue;
+      const existing = merged.get(url);
+      const score = 1 / (RRF_K + index + 1);
+      if (existing) {
+        existing.score += score;
+        if (!existing.snippet && result.snippet) existing.snippet = result.snippet;
+      } else {
+        merged.set(url, { ...result, url, score });
+      }
+    }
+  }
+  return [...merged.values()]
+    .sort((left, right) => right.score - left.score || left.url.localeCompare(right.url))
+    .slice(0, clampInteger(limit, 1, 10, 10))
+    .map(({ score: _score, ...result }) => result);
+}
+
+function normalizeSearchConfig(input) {
+  const backend = input?.backend ?? "auto";
+  if (!["auto", "searxng", "keyless"].includes(backend)) {
+    return { error: "Web search backend must be auto, searxng, or keyless." };
+  }
+  let endpoint;
+  if (input?.endpoint !== undefined && String(input.endpoint).trim()) {
+    try {
+      const parsed = new URL(String(input.endpoint));
+      if (parsed.protocol !== "http:" || !isLoopbackHost(parsed.hostname) || parsed.username || parsed.password) {
+        return { error: "SearXNG endpoint must be an unauthenticated loopback http URL." };
+      }
+      if (parsed.search || parsed.hash) {
+        return { error: "SearXNG endpoint must not contain a query string or fragment." };
+      }
+      parsed.pathname = parsed.pathname.replace(/\/+$/u, "");
+      endpoint = parsed.href.replace(/\/+$/u, "");
+    } catch {
+      return { error: "SearXNG endpoint must be a valid loopback http URL." };
+    }
+  }
+  if (backend === "searxng" && !endpoint) {
+    return { error: "SearXNG backend requires tools.web.search.endpoint." };
+  }
+  return { backend, endpoint };
+}
+
+function isLoopbackHost(hostname) {
+  const value = hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  return value === "localhost" || value === "127.0.0.1" || value === "::1";
+}
+
+function normalizeDomains(values) {
+  if (!Array.isArray(values)) return [];
+  const out = [];
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const normalized = value.trim().toLowerCase().replace(/^\*\./u, "").replace(/\.$/u, "");
+    if (!/^[a-z0-9.-]+$/u.test(normalized) || normalized.includes("..")) continue;
+    if (!out.includes(normalized)) out.push(normalized);
+    if (out.length >= 10) break;
+  }
+  return out;
+}
+
+function filterByDomains(results, include, exclude) {
+  return results.filter((result) => {
+    let host;
+    try { host = new URL(result.url).hostname.toLowerCase(); } catch { return false; }
+    if (exclude.some((domain) => domainMatches(host, domain))) return false;
+    return include.length === 0 || include.some((domain) => domainMatches(host, domain));
+  });
+}
+
+function domainMatches(host, domain) {
+  return host === domain || host.endsWith(`.${domain}`);
+}
+
+function queryWithDomains(query, domains) {
+  if (domains.length === 0) return query;
+  return `${query} (${domains.map((domain) => `site:${domain}`).join(" OR ")})`;
+}
+
+function relaxedQuery(query) {
+  const relaxed = query
+    .replace(/"([^"]+)"/gu, "$1")
+    .replace(/\bsite:\S+/giu, " ")
+    .replace(/\s+/gu, " ")
+    .trim();
+  return relaxed && relaxed !== query ? relaxed : null;
+}
+
+function uniqueStrings(values, limit) {
+  const out = [];
+  for (const value of Array.isArray(values) ? values : []) {
+    if (typeof value !== "string") continue;
+    const normalized = value.trim();
+    if (!normalized || out.includes(normalized)) continue;
+    out.push(normalized);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function collapseWhitespace(value) {
+  return String(value || "").replace(/\s+/gu, " ").trim();
+}
+
+function escapeMarkdownLabel(value) {
+  return collapseWhitespace(value).replace(/[[\]\\]/gu, "\\$&");
+}
+
+function requestSignal(signal) {
+  const timeout = AbortSignal.timeout(SEARCH_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+async function readLimitedText(response) {
+  const reader = response.body?.getReader?.();
+  if (!reader) {
+    const text = await response.text();
+    if (Buffer.byteLength(text, "utf8") > SEARCH_RESPONSE_MAX_BYTES) {
+      throw new Error(`search response exceeded ${SEARCH_RESPONSE_MAX_BYTES} bytes`);
+    }
+    return text;
+  }
+  const chunks = [];
+  let bytes = 0;
+  while (true) {
+    const next = await reader.read();
+    if (next.done) break;
+    bytes += next.value.byteLength;
+    if (bytes > SEARCH_RESPONSE_MAX_BYTES) {
+      try { await reader.cancel(); } catch { /* best effort */ }
+      throw new Error(`search response exceeded ${SEARCH_RESPONSE_MAX_BYTES} bytes`);
+    }
+    chunks.push(Buffer.from(next.value));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+function fetchFailure(backend, error) {
+  const name = error?.name;
+  const retryable = name === "AbortError"
+    || name === "TimeoutError"
+    || ["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "EAI_AGAIN"].includes(error?.code ?? error?.cause?.code);
+  return {
+    ok: false,
+    backend,
+    message: `${backend} request failed: ${error?.message || String(error)}`,
+    retryable,
+  };
+}
+
+function failure(text, code, startedAt, extra = {}) {
+  return {
+    text,
+    outcome: {
+      status: "error",
+      code,
+      retryable: false,
+      attempts: 0,
+      backend: "none",
+      cacheHit: false,
+      durationMs: Date.now() - startedAt,
+      bytes: Buffer.byteLength(text, "utf8"),
+      truncated: false,
+      ...extra,
+    },
+    error: true,
+  };
+}
+
+function clampInteger(value, min, max, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(number)));
 }

package/src/ai/providers/codex-app.js

@@ -617,6 +617,19 @@ function codexMcpConfig(mcpServers = {}) {
   return servers;
 }
 
+function codexConfiguredMcpApprovalResponse(request, configuredMcpServerNames) {
+  const params = request?.params;
+  if (
+    request?.method !== "mcpServer/elicitation/request"
+    || params?._meta?.codex_approval_kind !== "mcp_tool_call"
+    || typeof params?.serverName !== "string"
+    || !configuredMcpServerNames.has(params.serverName)
+  ) {
+    return null;
+  }
+  return { action: "accept", content: {}, _meta: null };
+}
+
 function codexErrorMessage(error) {
   if (!error) return "Codex app-server error";
   if (typeof error === "string") return error;
@@ -1109,6 +1122,7 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
   const makeClient = options.codexClientFactory || createCodexAppServerClient;
   const keepAlive = options.sessionKeepAlive === true;
   const noToolsProbe = options.codexNoToolsProbe === true;
+  const configuredMcpServerNames = new Set(Object.keys(codexMcpConfig(options.mcpServers)));
   // The bridge TTL is a backstop behind the host's session policy; the grace
   // keeps the host's lazy expiry firing first so eviction stays host-driven.
   const sessionTtlMs = Number.isFinite(Number(options.sessionIdleTimeoutMs))
@@ -1446,6 +1460,10 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
       ),
       onServerRequest: (request) => {
         const method = typeof request?.method === "string" ? request.method : "unknown";
+        const approval = noToolsProbe
+          ? null
+          : codexConfiguredMcpApprovalResponse(request, configuredMcpServerNames);
+        if (approval) return approval;
         failUnsupportedServerRequest(method);
         throw new Error(`Unsupported Codex app-server request: ${method}`);
       },

package/src/ai/providers/pi-native/stream-subscriber.js

@@ -22,6 +22,41 @@ function toolResultFileChange(result) {
     : null;
 }
 
+function toolResultOutcome(result) {
+  const source = result?.details?.outcome;
+  if (!source || typeof source !== "object" || Array.isArray(source)) return null;
+  const bounded = {};
+  const strings = {
+    status: "status",
+    code: "code",
+    backend: "backend",
+    signal: "signal",
+  };
+  const numbers = {
+    attempts: "attempts",
+    bytes: "bytes",
+    exitCode: "exit_code",
+    statusCode: "status_code",
+  };
+  const booleans = {
+    retryable: "retryable",
+    cacheHit: "cache_hit",
+    truncated: "truncated",
+    timedOut: "timed_out",
+    rendered: "rendered",
+  };
+  for (const [input, output] of Object.entries(strings)) {
+    if (typeof source[input] === "string") bounded[output] = source[input].slice(0, 120);
+  }
+  for (const [input, output] of Object.entries(numbers)) {
+    if (Number.isFinite(Number(source[input]))) bounded[output] = Number(source[input]);
+  }
+  for (const [input, output] of Object.entries(booleans)) {
+    if (typeof source[input] === "boolean") bounded[output] = source[input];
+  }
+  return bounded;
+}
+
 /**
  * The slice of run state the stream subscriber reads and mutates. A structural
  * subset of the orchestrator's runState.
@@ -107,6 +142,7 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
     } else if (event.type === "tool_execution_end") {
       const resultContent = toolResultContent(event.result);
       const fileChange = toolResultFileChange(event.result);
+      const outcome = toolResultOutcome(event.result);
       if (!event.isError) runState.toolResultsSeen += 1;
       const startedAt = runState.toolStartTimes.get(event.toolCallId);
       if (startedAt !== undefined) {
@@ -117,6 +153,7 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
           name: event.toolName,
           execution_ms: Date.now() - startedAt,
           is_error: !!event.isError,
+          ...(outcome || {}),
         });
       }
       onEvent({