@mono-agent/agent-runtime 0.15.3 → 0.16.0

package/src/ai/pi-oauth-compat.js

@@ -0,0 +1,193 @@
+// @ts-check
+
+// Adapter over pi-ai's provider-owned OAuth surface.
+//
+// pi-ai 0.83.0 removed the generic OAuth registry — `getOAuthApiKey`,
+// `getOAuthProvider` and `getOAuthProviders` are gone, and the
+// `@earendil-works/pi-ai/oauth` entry point is now type-only (`export {}` at
+// runtime). The per-provider implementations (`anthropicOAuth`, …) live under
+// `dist/auth/oauth/*`, which has no entry in the package's `exports` map, so
+// they cannot be imported. The supported surface is `provider.auth.oauth`,
+// reached through the provider factories.
+//
+// mono-agent resolves providers dynamically from `pi:<provider>:<model>`, so it
+// needs a lookup by id — this module rebuilds that over `builtinProviders()` and
+// preserves the old call contracts exactly, keeping the migration confined here.
+//
+// Deliberately NOT using `createModels({credentials})`: that hands credential
+// locking and persistence to pi, while mono-agent already owns `auth.json`
+// through `pi-auth.js` (serialized writes, atomic 0600 rename). `refresh()` and
+// `toAuth()` are callable directly, so the pure caller-persists contract stays.
+
+import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
+
+/**
+ * @typedef {import("@earendil-works/pi-ai").OAuthAuth} OAuthAuth
+ * @typedef {import("@earendil-works/pi-ai").OAuthCredential} OAuthCredential
+ * @typedef {import("@earendil-works/pi-ai").AuthInteraction} AuthInteraction
+ * @typedef {import("@earendil-works/pi-ai").AuthPrompt} AuthPrompt
+ * @typedef {import("@earendil-works/pi-ai").AuthEvent} AuthEvent
+ * @typedef {import("@earendil-works/pi-ai/oauth").OAuthLoginCallbacks} OAuthLoginCallbacks
+ */
+
+/** @type {Map<string, import("@earendil-works/pi-ai").Provider>|undefined} */
+let providerIndexCache;
+
+/**
+ * `builtinProviders()` freshly constructs every provider (~37 objects) on each
+ * call, and `pi-auth.js` sits on the per-request credential path. The catalog is
+ * static for the process lifetime, so index it once.
+ *
+ * @returns {Map<string, import("@earendil-works/pi-ai").Provider>}
+ */
+function providerIndex() {
+  if (providerIndexCache === undefined) {
+    providerIndexCache = new Map(builtinProviders().map((provider) => [provider.id, provider]));
+  }
+  return providerIndexCache;
+}
+
+/** @internal Exported only so tests can force a rebuild of the memoized index. */
+export function resetPiProviderIndexForTests() {
+  providerIndexCache = undefined;
+}
+
+/**
+ * The OAuth implementation for a Pi provider id, or undefined when the provider
+ * is unknown or supports only API-key auth (e.g. `opencode-go`).
+ *
+ * @param {string} providerId
+ * @returns {OAuthAuth|undefined}
+ */
+export function getPiOAuthAuth(providerId) {
+  if (typeof providerId !== "string" || providerId.length === 0) return undefined;
+  return providerIndex().get(providerId)?.auth?.oauth;
+}
+
+/**
+ * Every Pi provider id that supports OAuth. Replaces
+ * `getOAuthProviders().map((provider) => provider.id)`.
+ *
+ * @returns {string[]}
+ */
+export function getPiOAuthProviderIds() {
+  const ids = [];
+  for (const [id, provider] of providerIndex()) {
+    if (provider.auth?.oauth !== undefined) ids.push(id);
+  }
+  return ids;
+}
+
+/**
+ * Resolve an API key from stored OAuth credentials, refreshing first when the
+ * token has expired.
+ *
+ * Reproduces pi-ai 0.80.6's `getOAuthApiKey(providerId, credentials)` contract
+ * so its call sites keep their shape: takes the whole provider-keyed credential
+ * map, returns `null` when this provider has no stored credential, and is
+ * *pure* — the refreshed credential comes back as `newCredentials` for the
+ * caller to persist rather than being written here.
+ *
+ * The refresh trigger is deliberately the old exact-expiry check. pi's own
+ * `Models.getAuth()` refreshes five minutes ahead of expiry; matching that would
+ * change live token rotation timing, which this migration does not intend.
+ *
+ * @param {string} providerId
+ * @param {Record<string, *>|undefined} credentials Provider-keyed credential map.
+ * @returns {Promise<{newCredentials: OAuthCredential, apiKey: string|undefined}|null>}
+ */
+export async function resolveOAuthApiKey(providerId, credentials) {
+  const oauth = getPiOAuthAuth(providerId);
+  if (oauth === undefined) {
+    throw new Error(`Unknown OAuth provider: ${providerId}`);
+  }
+
+  const stored = credentials?.[providerId];
+  if (stored === undefined || stored === null) return null;
+
+  // 0.83.0's OAuthCredential carries a `type: "oauth"` discriminant that the
+  // 0.80.6 shape did not. Stored entries written by mono-agent already have it;
+  // tag defensively so hand-edited or externally written files still work.
+  let credential = /** @type {OAuthCredential} */ ({ ...stored, type: "oauth" });
+
+  if (Date.now() >= credential.expires) {
+    try {
+      credential = await oauth.refresh(credential);
+    } catch {
+      throw new Error(`Failed to refresh OAuth token for ${providerId}`);
+    }
+  }
+
+  // `toAuth()` also derives a per-credential baseUrl (GitHub Copilot's
+  // per-account proxy). 0.80.6 discarded it and callers here have no field for
+  // it, so it stays dropped — behaviour preserved, worth revisiting separately.
+  const auth = await oauth.toAuth(credential);
+  return { newCredentials: credential, apiKey: auth?.apiKey };
+}
+
+/**
+ * Bridge the legacy six-callback OAuth surface onto 0.83.0's single
+ * `prompt`/`notify` pair.
+ *
+ * `manual_code` must stay wired to `onManualCodeInput`: Anthropic races its
+ * localhost callback against a pasted redirect URL, and that path is the reason
+ * `agent-app`'s `runPiOAuthLogin` exists at all.
+ *
+ * @param {OAuthLoginCallbacks} callbacks
+ * @returns {AuthInteraction}
+ */
+export function toAuthInteraction(callbacks) {
+  if (callbacks === null || typeof callbacks !== "object") {
+    throw new TypeError("toAuthInteraction requires an OAuthLoginCallbacks object");
+  }
+
+  return {
+    ...(callbacks.signal === undefined ? {} : { signal: callbacks.signal }),
+
+    /** @param {AuthPrompt} prompt */
+    async prompt(prompt) {
+      if (prompt.type === "select") {
+        const selected = await callbacks.onSelect({
+          message: prompt.message,
+          options: prompt.options.map((option) => ({ id: option.id, label: option.label })),
+        });
+        // The legacy callback resolves undefined when the user cancels; the new
+        // contract requires a string and rejects on cancel.
+        if (typeof selected !== "string") {
+          throw new Error("OAuth provider selection was cancelled.");
+        }
+        return selected;
+      }
+
+      if (prompt.type === "manual_code" && typeof callbacks.onManualCodeInput === "function") {
+        return await callbacks.onManualCodeInput();
+      }
+
+      return await callbacks.onPrompt({
+        message: prompt.message,
+        ...(prompt.placeholder === undefined ? {} : { placeholder: prompt.placeholder }),
+      });
+    },
+
+    /** @param {AuthEvent} event */
+    notify(event) {
+      if (event.type === "auth_url") {
+        callbacks.onAuth({
+          url: event.url,
+          ...(event.instructions === undefined ? {} : { instructions: event.instructions }),
+        });
+        return;
+      }
+      if (event.type === "device_code") {
+        callbacks.onDeviceCode({
+          userCode: event.userCode,
+          verificationUri: event.verificationUri,
+          ...(event.intervalSeconds === undefined ? {} : { intervalSeconds: event.intervalSeconds }),
+          ...(event.expiresInSeconds === undefined ? {} : { expiresInSeconds: event.expiresInSeconds }),
+        });
+        return;
+      }
+      callbacks.onProgress?.(event.message);
+    },
+  };
+}

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({

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

@@ -8,13 +8,13 @@
 // caller-owned runState.
 
 import { AgentHarness } from "@earendil-works/pi-agent-core";
-import { NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
 import {
   createStructuredOutputTool,
   getPiBuiltinTools,
   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 +40,7 @@ export async function buildTurnTools(runState, {
   resolved,
   onEvent,
   runtimeWarnings,
+  toolExecutionMode = "safe-parallel",
 }) {
   const onTruncate = (info) => {
     try {
@@ -73,6 +74,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 +119,29 @@ 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,
+        // The same skills this turn was disclosed. A child runs OUTSIDE the
+        // harness, so without this it gets no index and — because ReadSkill is
+        // only built when `skills` is non-empty — no way to read one either. It
+        // then rediscovers by trial and error whatever its parent could simply
+        // have looked up. Pass-through only: whether the child actually receives
+        // them is the host's decision, not this layer's.
+        skills: options.skills,
+        skillsRoot: options.skillsRoot,
+      },
       ctx: runCtx,
     }));
 
@@ -143,14 +176,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,8 +227,27 @@ 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,
   piModels,
   model,
@@ -208,8 +265,12 @@ export function buildTurnHarness(runState, {
   sdk,
   reference,
 }) {
+  // pi-agent-core 0.83.0 removed `env` from AgentHarnessOptions: an
+  // ExecutionEnv now reaches tools through the generic per-turn `toolContext`
+  // instead. mono-agent needs neither — it uses none of pi's built-in
+  // file/shell tools, and its own tools close over what they need — so the
+  // option is dropped rather than migrated.
   const harness = new AgentHarness({
-    env: new NodeExecutionEnv({ cwd: cwd || process.cwd() }),
     session,
     models: piModels,
     model,
@@ -225,9 +286,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

@@ -31,7 +31,9 @@ import {
   resolveAgentCompactionPolicy,
   resolveRuntimePolicyInputs,
 } from "../../agent/compaction.js";
+import { subagentInvocationCount } from "../../agent/tools/agent-tool.js";
 import { closePiMcpClients } from "../../agent/tools/pi-bridge.js";
+import { readToolRuntime } from "../../agent/tools/shared/runtime-context.js";
 import { createApprovalManager } from "../../agent/approval.js";
 import { buildCapabilitiesUsed, toolCompactionAppliedFromWarnings } from "../runtime/capabilities-used.js";
 import { reasoningLevelsForPiModel, resolvePiRuntimeModel } from "./pi-models.js";
@@ -78,6 +80,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 +340,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 +437,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 +460,7 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       resolved,
       onEvent,
       runtimeWarnings,
+      toolExecutionMode: toolExecution.mode,
     });
     mcpClients = builtMcpClients;
     closeRunTools = builtCloseRunTools;
@@ -426,10 +473,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);
 
@@ -437,7 +483,6 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
     // external abort handler (which sets runState.externalAbort and aborts the
     // harness). Sets runState.harness + runState.removeAbortHandler.
     harness = buildTurnHarness(runState, {
-      cwd: options.cwd,
       session: runState.session,
       piModels,
       model: runtime.model,
@@ -665,8 +710,23 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       promptCacheActive: usage.cacheRead > 0 || usage.cacheWrite > 0,
       thinkingEnabled: effectiveThinkingLevel !== "off" && effectiveThinkingLevel !== "low",
       structuredOutputEnforced: !!options.outputSchema,
-      subagentInvoked: false,
+      // What actually happened, not what was configured. This used to be a
+      // hardcoded `false`, which reported "no subagent ran" for runs that had
+      // just spawned several — the one signal that would have shown delegation
+      // working said it never happened.
+      //
+      // The count is keyed by the same parentRunId the Agent tool stamps its
+      // budget under (turn-runner threads `runCtx?.runId`); `runId` survives the
+      // sandbox-branch spread there, so reading it off the tool context directly
+      // yields the same key.
+      subagentInvoked: subagentInvocationCount(
+        options.subagents,
+        (options.toolContext ?? readToolRuntime())?.runId,
+      ) > 0,
       mcpServersUsed: mcpClients.map((entry) => entry?.name).filter(Boolean),
+      // Empty by contract, not by omission: "native" means provider-native
+      // subagents (Claude's Task tool). mono-agent's `Agent` is its own, so pi
+      // has none — `subagent_invoked` above is where pi delegation is reported.
       nativeSubagentsUsed: [],
       toolCompactionApplied: toolCompactionAppliedFromWarnings(runtimeWarnings),
       // Tristate: true = a compaction fired this run (proactive or reactive),