@mono-agent/agent-runtime 0.2.2 → 0.4.0

package/src/agent/index.js

@@ -5,8 +5,8 @@
 // from edge layers.
 
 export {
-  createAgentCompactionManager,
   isLikelyContextTermination,
+  resolveAgentCompactionPolicy,
 } from "./compaction.js";
 
 export {

package/src/agent/tools/pi-bridge.js

@@ -542,6 +542,9 @@ export async function initPiMcpTools(mcpConfig, reservedNames = new Set(), {
   const warnings = [];
   const seen = new Set(reservedNames);
 
+  // Phase 1: collect connected clients in entry order (so tool registration is
+  // deterministic) and record connect failures.
+  const connectedList = [];
   for (const [index, result] of settled.entries()) {
     const serverName = entries[index]?.[0];
     if (result.status !== "fulfilled") {
@@ -553,18 +556,28 @@ export async function initPiMcpTools(mcpConfig, reservedNames = new Set(), {
       });
       continue;
     }
+    clients.push(result.value);
+    connectedList.push({ serverName, connected: result.value });
+  }
 
-    const connected = result.value;
-    clients.push(connected);
-    let listed;
+  // Phase 2: list tools from every connected server CONCURRENTLY (previously
+  // serial, adding ~Nx the slowest listTools to turn startup, painful over a
+  // SOCKS proxy). Results are awaited in entry order to keep registration stable.
+  const listings = await Promise.all(connectedList.map(async ({ serverName, connected }) => {
     try {
-      listed = await connected.client.listTools();
+      return { serverName, connected, listed: await connected.client.listTools() };
     } catch (err) {
+      return { serverName, connected, error: err };
+    }
+  }));
+
+  for (const { serverName, connected, listed, error } of listings) {
+    if (error) {
       warnings.push({
         type: "runtime_warning",
         warning_kind: "mcp_list_tools_failed",
         server: serverName,
-        message: err?.message || String(err),
+        message: error?.message || String(error),
       });
       continue;
     }
@@ -583,12 +596,16 @@ export async function initPiMcpTools(mcpConfig, reservedNames = new Set(), {
           const textLimit = limits.mcpTextLimitChars || MCP_TEXT_RESULT_LIMIT;
           const imageInlineMaxBytes = limits.imageInlineMaxBytes ?? MCP_IMAGE_INLINE_MAX_BYTES;
           const normalizedParams = normalizeMcpToolParams(serverName, sourceTool.name, params || {}, { qaOutputDir });
+          // Measure the MCP round-trip so observability can separate slow MCP
+          // servers (e.g. context-a8c over a SOCKS proxy) from model latency.
+          const mcpCallStartMs = Date.now();
           const out = await withTimeout(
             connected.client.callTool({ name: sourceTool.name, arguments: normalizedParams || {} }),
             limits.mcpCallTimeoutMs || 120000,
             signal,
             `${serverName}:${sourceTool.name}`,
           );
+          const mcpCallDurationMs = Date.now() - mcpCallStartMs;
           const imageTruncations = [];
           return {
             content: coerceMcpContent(out, {
@@ -605,6 +622,7 @@ export async function initPiMcpTools(mcpConfig, reservedNames = new Set(), {
             details: {
               server: serverName,
               tool: sourceTool.name,
+              mcp_call_duration_ms: mcpCallDurationMs,
               result_truncated: mcpContentWasTruncated(out, { textLimit, imageInlineMaxBytes }),
               raw: compactRawMcpResult(out),
               ...(imageTruncations.length ? {
@@ -629,10 +647,28 @@ export async function initPiMcpTools(mcpConfig, reservedNames = new Set(), {
   };
 }
 
-export async function closePiMcpClients(clients) {
-  for (const { client, transport } of clients || []) {
-    try { await client.close?.(); } catch { /* best-effort */ }
-    try { await transport.close?.(); } catch { /* best-effort */ }
-    try { await transport.__monoSandboxCleanup?.(); } catch { /* best-effort */ }
+async function closeWithTimeout(close, timeoutMs) {
+  if (typeof close !== "function") return;
+  const result = close();
+  if (!(result && typeof result.then === "function")) return;
+  let timer;
+  try {
+    await Promise.race([
+      result,
+      new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs); }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
   }
 }
+
+export async function closePiMcpClients(clients, { timeoutMs = 5000 } = {}) {
+  // Close the client first (stop accepting messages) then the transport (tear
+  // down I/O), each bounded by a timeout so a hung stdio pipe cannot stall
+  // shutdown — a common source of "Connection closed" churn on reconnect.
+  await Promise.all((clients || []).map(async ({ client, transport }) => {
+    try { await closeWithTimeout(client?.close?.bind(client), timeoutMs); } catch { /* best-effort */ }
+    try { await closeWithTimeout(transport?.close?.bind(transport), timeoutMs); } catch { /* best-effort */ }
+    try { await transport?.__monoSandboxCleanup?.(); } catch { /* best-effort */ }
+  }));
+}

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

@@ -5,8 +5,26 @@ import { resolveSandboxPolicy } from "./shared/runtime-context.js";
 
 const FETCH_TIMEOUT_MS = 15000;
 const MAX_REDIRECTS = 5;
+// Backoff delays between retry attempts (length = number of retries). Retrying
+// transient failures in-tool stops the model from burning whole reasoning rounds
+// re-issuing the fetch (or falling back to Bash curl) on a momentary network blip.
+const DEFAULT_FETCH_RETRY_DELAYS_MS = [1000, 2000];
 
-export async function webFetchToolImpl({ url, headers = {}, max_output_chars }, { sandboxPolicy } = {}) {
+function isTransientFetchError(err) {
+  if (err === undefined || err === null) return false;
+  if (err.name === "AbortError" || err.name === "TimeoutError") return true; // timeout
+  const code = err.code ?? err.cause?.code;
+  return code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ETIMEDOUT" || code === "EAI_AGAIN";
+}
+
+function fetchRetryDelay(ms) {
+  return new Promise((resolve) => { setTimeout(resolve, ms); });
+}
+
+export async function webFetchToolImpl(
+  { url, headers = {}, max_output_chars },
+  { sandboxPolicy, retryDelaysMs = DEFAULT_FETCH_RETRY_DELAYS_MS } = {},
+) {
   const maxChars = Number(max_output_chars) || DEFAULT_MAX_TOOL_OUTPUT_CHARS;
   let parsed;
   try { parsed = new URL(url); } catch { return "Error: Invalid URL"; }
@@ -16,18 +34,36 @@ export async function webFetchToolImpl({ url, headers = {}, max_output_chars },
   const policy = resolveSandboxPolicy(sandboxPolicy);
   if (!networkPolicyAllowsUrl(policy, parsed.href)) return "Error: Network access denied by sandbox policy.";
   const requestHeaders = { "User-Agent": "AgentRuntime/0.1", ...headers };
-  try {
-    const restricted = policy !== undefined && policy.network.mode !== "all";
-    const resp = restricted
-      ? await fetchCheckingRedirects(parsed, requestHeaders, policy)
-      : await fetch(url, { headers: requestHeaders, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
-    if (typeof resp === "string") return resp;
-    const text = await resp.text();
-    if (!resp.ok) return `HTTP ${resp.status}: ${text.slice(0, 500)}`;
-    return capChars(text, { label: "WebFetch", maxChars });
-  } catch (err) {
-    return `Error fetching URL: ${err.message}`;
+  const restricted = policy !== undefined && policy.network.mode !== "all";
+  const maxRetries = Array.isArray(retryDelaysMs) ? retryDelaysMs.length : 0;
+
+  let lastErrorMessage = "request failed";
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    try {
+      const resp = restricted
+        ? await fetchCheckingRedirects(parsed, requestHeaders, policy)
+        : await fetch(url, { headers: requestHeaders, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+      if (typeof resp === "string") return resp; // policy/redirect error — not retryable
+      // Transient server errors (5xx) are worth one more attempt.
+      if (resp.status >= 500 && resp.status < 600 && attempt < maxRetries) {
+        try { await resp.body?.cancel(); } catch { /* best-effort */ }
+        lastErrorMessage = `HTTP ${resp.status}`;
+        await fetchRetryDelay(retryDelaysMs[attempt]);
+        continue;
+      }
+      const text = await resp.text();
+      if (!resp.ok) return `HTTP ${resp.status}: ${text.slice(0, 500)}`;
+      return capChars(text, { label: "WebFetch", maxChars });
+    } catch (err) {
+      lastErrorMessage = err.message;
+      if (isTransientFetchError(err) && attempt < maxRetries) {
+        await fetchRetryDelay(retryDelaysMs[attempt]);
+        continue;
+      }
+      return `Error fetching URL: ${err.message}`;
+    }
   }
+  return `Error fetching URL: ${lastErrorMessage}`;
 }
 
 // fetch() follows redirects transparently, which would let an allowed host

package/src/ai/failure.js

@@ -29,7 +29,7 @@ export const FAILURE_KINDS = [
 ];
 
 const USAGE_LIMIT_RE = /(rate limit|usage limit|max tokens|max turns|context length|too many tokens)/i;
-const PROVIDER_UNAVAILABLE_RE = /(econn|enotfound|etimedout|service unavailable|503|502|gateway|fetch failed|network|websocket)/i;
+const PROVIDER_UNAVAILABLE_RE = /(econn|enotfound|etimedout|timed? ?out|service unavailable|503|502|gateway|fetch failed|network|websocket)/i;
 const TOOL_FAILURE_RE = /(tool .* failed|mcp tool|permission denied|EACCES|read-only file system)/i;
 const NON_RETRYABLE_PROVIDER_RE = /(invalid[_ ]request|unknown parameter|invalid api key|incorrect api key|authentication|authorization|not authorized|forbidden|billing|insufficient[_ ]quota|quota exceeded|model[_ ]not[_ ]found|unsupported model|permission denied|bad request|401|403|404)/i;
 const RETRYABLE_PROVIDER_RE = /(currently overloaded|server(?:s)? (?:is |are )?overloaded|try again later|retry your request|request id|service unavailable|temporar(?:y|ily)|timed? ?out|stream disconnected|fetch failed|econnreset|econnrefused|eai_again|enotfound|etimedout|network|429|too many requests|500|502|503|504|gateway|internal server error)/i;

package/src/ai/index.js

@@ -9,6 +9,7 @@ export {
   disposeProviderSession,
 } from "./runtime/sessions.js";
 export { createMetricsObserver, createObserverHub } from "./observer.js";
+export { generatePiNativeResponse, piNativeRuntimeBridge } from "./providers/pi-native.js";
 export {
   buildCapabilitiesUsed,
   toolCompactionAppliedFromWarnings,

package/src/ai/providers/claude-cli.js

@@ -450,7 +450,11 @@ export async function generateCliResponse(systemPrompt, options = {}) {
   const mcpConfigPath = hasEntries(mcpServers) && resolved.sdk === "claude-code"
     ? join(dir, "mcp.json")
     : null;
-  if (mcpConfigPath) writeFileSync(mcpConfigPath, JSON.stringify({ mcpServers }, null, 2));
+  // Owner-only mode: this temp config carries full mcpServers env (including a
+  // resolved embedding apiKey) and lives under shared /tmp. The 0700 parent dir
+  // (mkdtempSync) already blocks cross-user traversal; 0o600 is defense-in-depth
+  // matching the idiom in packages/settings/src/json-source.ts and pi-auth.js.
+  if (mcpConfigPath) writeFileSync(mcpConfigPath, JSON.stringify({ mcpServers }, null, 2), { mode: 0o600 });
   const reusableSessionId = (typeof options.sessionId === "string" && options.sessionId.trim())
     || (typeof options.providerSessionId === "string" && options.providerSessionId.trim())
     || null;

package/src/ai/providers/pi-errors.js

@@ -0,0 +1,65 @@
+// Shared pi error-normalization helpers.
+//
+// Extracted so the pi-native bridge does not have to import from a sibling
+// provider module. Both the message-normalizer (unwrap nested provider error
+// envelopes) and the context-limit classifier are pure string helpers with no
+// runtime dependencies.
+
+function tryParseJson(text) {
+  try { return JSON.parse(text); } catch { return null; }
+}
+
+export function normalizePiErrorMessage(message) {
+  const text = String(message || "").trim();
+  if (!text) return null;
+  const codexMatch = /^Codex error:\s*(\{[\s\S]*\})$/i.exec(text);
+  const parsed = tryParseJson(codexMatch ? codexMatch[1] : text);
+  const nested = parsed?.error || parsed;
+  if (typeof nested?.message === "string" && nested.message.trim()) return nested.message.trim();
+  if (typeof nested?.error?.message === "string" && nested.error.message.trim()) return nested.error.message.trim();
+  return text;
+}
+
+export function isContextLimitError(message) {
+  const text = String(message || "");
+  // Rate-limit wording takes precedence: it is a throttle, not a context overflow.
+  if (/rate limit|too many requests/i.test(text)) return false;
+  // Broadened to catch the many ways providers phrase a context/token overflow:
+  // "context length/window/budget", "max(imum) tokens", "token limit",
+  // "too many tokens", "prompt (is) too long", "exceeds the context/maximum/max",
+  // "input tokens/exceeds", "output token(s)", "token(s) exceed".
+  return /context[_ ](?:length|window|budget)|max(?:imum)?[_ ]?tokens?|token[_ ]limit|too[_ ]many[_ ]tokens?|prompt[_ ](?:is[_ ])?too[_ ]long|exceeds?[_ ](?:the context|maximum|max)|input[_ ](?:tokens?|exceeds)|output[_ ]tokens?|tokens?[_ ]exceed/i.test(text);
+}
+
+// Best-effort extraction of the model's real context-window ceiling from an
+// overflow error. Providers usually state the limit ("maximum context length is
+// 200000 tokens", "context window of 128000", "this model supports at most
+// 32768 tokens"). We use the discovered value to lower the proactive compaction
+// trigger on the running model so a wrong/default contextWindow self-corrects.
+// Returns the smallest plausible token count found, or null.
+export function parseContextLimitFromError(message) {
+  const text = String(message || "");
+  if (!text) return null;
+  // Capture a number that sits next to context/window/token wording, tolerating
+  // separators in large numbers (e.g. "128,000" or "128 000"). Phrases like
+  // "however you requested 210000 tokens" would over-count the limit, so we
+  // anchor on max/limit/context/window wording and take the smallest match.
+  const patterns = [
+    /(?:maximum|max(?:imum)?)\s+context\s+(?:length|window)\s*(?:is|of|=|:)?\s*([\d][\d,_ ]*)/ig,
+    /context\s+(?:length|window|budget)\s*(?:is|of|=|:)?\s*([\d][\d,_ ]*)/ig,
+    /(?:maximum|max(?:imum)?|at most|supports?(?:\s+up\s+to)?)\s+([\d][\d,_ ]*)\s*(?:input\s+)?tokens?/ig,
+    /(?:token|context)\s+limit\s*(?:is|of|=|:)?\s*([\d][\d,_ ]*)/ig,
+  ];
+  const found = [];
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const n = Number(String(m[1]).replace(/[,_ ]/g, ""));
+      // Guard against matching small token counts (e.g. "8 tokens") that are not
+      // a real window; a context window is at least a few thousand tokens.
+      if (Number.isFinite(n) && n >= 1000) found.push(n);
+    }
+  }
+  if (found.length === 0) return null;
+  return Math.min(...found);
+}