@mono-agent/agent-runtime 0.15.3 → 0.15.4

package/src/ai/providers/pi-native/turn-runner.js

@@ -15,6 +15,7 @@ import {
   initPiMcpTools,
 } from "../../../agent/tools/pi-bridge.js";
 import { createNodeReplController } from "../../../agent/tools/node-repl.js";
+import { createWebToolController } from "../../../agent/tools/web-controller.js";
 import { readToolRuntime } from "../../../agent/tools/shared/runtime-context.js";
 import { formatLiveInputGuidance } from "../../live-input-prompt.js";
 import { appendStructuredOutputInstruction } from "./structured-output.js";
@@ -40,6 +41,7 @@ export async function buildTurnTools(runState, {
   resolved,
   onEvent,
   runtimeWarnings,
+  toolExecutionMode = "safe-parallel",
 }) {
   const onTruncate = (info) => {
     try {
@@ -73,6 +75,15 @@ export async function buildTurnTools(runState, {
       sandboxEngine,
       ctx: runCtx,
     });
+  const webController = capabilities.tool_use === false
+    ? null
+    : createWebToolController({
+      searchConfig: options.webSearchConfig,
+      fetchConfig: options.webFetchConfig,
+      sandboxPolicy: options.sandboxPolicy,
+      sandboxEngine,
+      ctx: runCtx,
+    });
 
   // REUSED custom pieces: built-in tool sandboxing + allowlist/bloat filter +
   // approval gates. These are identical to the legacy bridge.
@@ -109,6 +120,21 @@ export async function buildTurnTools(runState, {
       approvalManager,
       approvalModel: runtime.model?.id || runtime.model?.name || resolved.model,
       nodeReplController,
+      webController,
+      toolExecutionMode,
+      subagents: options.subagents,
+      // The child inherits the parent's route and workspace unless its profile
+      // pins a model; the tool closure reads these to build each child request.
+      subagentContext: {
+        model: options.model,
+        executionMode: options.executionMode,
+        cwd: options.cwd,
+        parentRunId: runCtx?.runId,
+        // Same policy + engine this turn's own tools are confined by, so a
+        // child is never less sandboxed than the parent that spawned it.
+        sandboxPolicy: options.sandboxPolicy,
+        sandboxEngine,
+      },
       ctx: runCtx,
     }));
 
@@ -143,14 +169,19 @@ export async function buildTurnTools(runState, {
 
   const tools = [
     ...builtIns,
-    ...mcpInit.tools,
+    ...mcpInit.tools.map((tool) => ({ ...tool, executionMode: "sequential" })),
     ...(structuredTool ? [structuredTool] : []),
   ];
   return {
     tools,
     structuredTool,
     mcpClients: mcpInit.clients,
-    closeRunTools: async () => { await nodeReplController?.close(); },
+    closeRunTools: async () => {
+      await Promise.allSettled([
+        nodeReplController?.close(),
+        webController?.close(),
+      ].filter(Boolean));
+    },
   };
 }
 
@@ -189,6 +220,26 @@ export function thinkingLevelForEffort(effort, capabilities) {
  * @param {any} params
  * @returns {any}
  */
+/**
+ * Restore the error flag on a tool result pi resolved successfully.
+ *
+ * pi hardcodes `isError: false` for every `execute()` that returns rather than
+ * throws, so any tool that reports failure in its payload needs this hook or
+ * the model is told the call succeeded.
+ *
+ * @param {*} details Tool-result details recorded by the bridge.
+ * @returns {{isError: true}|undefined}
+ */
+export function toolResultErrorOverride(details) {
+  const subagentStatus = details?.subagent?.status;
+  const failed = details?.mcp_result_is_error === true
+    || details?.outcome?.status === "error"
+    // A failed subagent returns its answer-plus-log instead of throwing,
+    // precisely so a failed delegation keeps its activity log.
+    || (typeof subagentStatus === "string" && subagentStatus !== "ok");
+  return failed ? { isError: true } : undefined;
+}
+
 export function buildTurnHarness(runState, {
   cwd,
   session,
@@ -225,9 +276,13 @@ export function buildTurnHarness(runState, {
   // this after-tool hook restores the error flag while preserving the already
   // bounded content/details verbatim. Downstream tool_execution_end and timing
   // events therefore report the failure accurately.
-  harness.on("tool_result", (event) => /** @type {any} */ (event?.details)?.mcp_result_is_error === true
-    ? { isError: true }
-    : undefined);
+  //
+  // A failed subagent is the same shape of problem: the `Agent` tool returns
+  // its formatted answer-plus-activity-log rather than throwing, precisely so a
+  // failed delegation keeps its log — but pi hardcodes `isError: false` for
+  // every resolved execute(), so without this the model would be told a failed,
+  // timed-out, or empty delegation succeeded.
+  harness.on("tool_result", (event) => toolResultErrorOverride(event?.details));
   runState.harness = harness;
 
   harness.subscribe(createStreamSubscriber(runState, {

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

@@ -78,6 +78,37 @@ import {
 } from "./pi-native/turn-runner.js";
 import { resolvePiTransport } from "./pi-native/transport.js";
 
+/**
+ * Pi 0.80.6 exposes per-tool execution markers but not AgentHarness's global
+ * toolExecution option. Resolve mono-agent's programmatic mode once per run;
+ * individual tool builders then mark stateful/mutating tools sequential.
+ */
+export function resolvePiToolExecutionMode(options = {}) {
+  const warnings = [];
+  const requested = options.piToolExecutionMode;
+  let mode = requested === "sequential" || requested === "safe-parallel"
+    ? requested
+    : null;
+  if (requested !== undefined && mode === null) {
+    warnings.push({
+      warning_kind: "invalid_pi_tool_execution_mode",
+      message: `Unknown piToolExecutionMode ${JSON.stringify(requested)}; using safe-parallel.`,
+    });
+  }
+  if (options.piToolParallelismMode !== undefined) {
+    warnings.push({
+      warning_kind: "deprecated_pi_tool_parallelism_mode",
+      message: "piToolParallelismMode is deprecated; use piToolExecutionMode (sequential or safe-parallel).",
+    });
+    if (mode === null) {
+      mode = options.piToolParallelismMode === "one-at-a-time"
+        ? "sequential"
+        : "safe-parallel";
+    }
+  }
+  return { mode: mode || "safe-parallel", warnings };
+}
+
 async function resolveApiKey(provider, { apiKeys, resolvePiApiKey, runtimeWarnings }) {
   if (apiKeys?.has(provider)) return apiKeys.get(provider);
   if (typeof resolvePiApiKey !== "function") return undefined;
@@ -307,13 +338,21 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
   const piTransport = resolvePiTransport(options.piTransport);
 
   const onEvent = (event) => emitCaptured(events, options.onEvent, event);
+  const approvalRiskTiers = {
+    ...(options.toolRiskTiers || {}),
+    ...(
+      options.toolRiskTiers?.Exec === undefined && options.toolRiskTiers?.Bash !== undefined
+        ? { Exec: options.toolRiskTiers.Bash }
+        : {}
+    ),
+  };
   const approvalManager = options.onToolApprovalRequest
     ? createApprovalManager({
       onToolApprovalRequest: options.onToolApprovalRequest,
       defaultRiskTier: options.approvalDefaultRiskTier,
       timeoutMs: options.approvalTimeoutMs,
       onEvent,
-      riskTiersByTool: options.toolRiskTiers,
+      riskTiersByTool: approvalRiskTiers,
       alwaysAllowTools: options.approvalAlwaysAllowTools,
     })
     : null;
@@ -396,6 +435,11 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
     // normalization. Restores configurable clamping (toolTextLimitChars,
     // searchResultLimit, ...) on top of the 256KB hard ceiling.
     const toolLimits = resolveAgentCompactionPolicy(settingsLike, runtime.model);
+    const toolExecution = resolvePiToolExecutionMode(options);
+    for (const warning of toolExecution.warnings) {
+      runtimeWarnings.push(warning);
+      onEvent({ type: "runtime_warning", ...warning });
+    }
 
     // Build the turn's tools (builtins + MCP bridge + StructuredOutput). The
     // StructuredOutput callback writes runState.structuredResult; the MCP clients
@@ -414,6 +458,7 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       resolved,
       onEvent,
       runtimeWarnings,
+      toolExecutionMode: toolExecution.mode,
     });
     mcpClients = builtMcpClients;
     closeRunTools = builtCloseRunTools;
@@ -426,10 +471,9 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
     const maxRetryDelayMs = Number.isFinite(Number(options.maxRetryDelayMs))
       ? Number(options.maxRetryDelayMs)
       : 60_000;
-    // Tool steering: default "one-at-a-time" (safe, deterministic ordering).
-    // Opt-in "all" lets pi-agent-core run a model step's tool calls concurrently
-    // (QueueMode). Only enable when tools in a step are independent.
-    const toolSteeringMode = options.piToolParallelismMode === "all" ? "all" : "one-at-a-time";
+    // Steering controls user follow-up delivery, not tool scheduling. Keep it
+    // independent from piToolExecutionMode; tools carry their own executionMode.
+    const toolSteeringMode = "one-at-a-time";
 
     const piModels = buildRunModels(runtime, options, runtimeWarnings);