@mono-agent/agent-runtime 0.20.11 → 0.20.14

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

@@ -24,7 +24,7 @@
 // on the caller-owned runState.compaction.
 
 import {
-  buildSessionContext,
+  BACKGROUND_CONTEXT,
   calculateContextTokens,
   compact as compactPreparedContext,
   estimateContextTokens,
@@ -45,6 +45,7 @@ import {
   parseContextLimitFromError,
 } from "../pi-errors.js";
 import { appendStructuredOutputInstruction } from "./structured-output.js";
+import { buildPiSessionContext } from "./harness-adapter.js";
 import { runHarnessPrompt } from "./turn-runner.js";
 
 // Per-process cache of real context-window ceilings discovered from overflow
@@ -157,9 +158,10 @@ async function estimateSessionMessageTokens(session) {
   }
 }
 
-function estimateBuiltContextTokens(branchEntries) {
+async function estimateBuiltContextTokens(branchEntries) {
   try {
-    return buildSessionContext(branchEntries).messages.reduce(
+    const messages = buildPiSessionContext(branchEntries);
+    return messages.reduce(
       (total, message) => total + (Number(estimateTokens(message)) || 0),
       0,
     );
@@ -190,16 +192,17 @@ export function piSummaryReserveTokens(summaryMaxTokens, isSplitTurn) {
   return reserve;
 }
 
-function previewCompactedContext(branchEntries, result) {
+async function previewCompactedContext(branchEntries, result) {
   const previewEntry = {
     type: "compaction",
     id: "mono-agent-compaction-preview",
     parentId: branchEntries.at(-1)?.id || null,
-    timestamp: new Date().toISOString(),
+    timestamp: Date.now(),
     summary: result.summary,
-    firstKeptEntryId: result.firstKeptEntryId,
+    retainedTail: result.retainedTail,
     tokensBefore: result.tokensBefore,
     details: result.details,
+    usage: result.usage,
     fromHook: true,
   };
   return estimateBuiltContextTokens([...branchEntries, previewEntry]);
@@ -273,7 +276,7 @@ export async function tryCompact(harness, {
     model,
   });
   let effectivePolicy = policy || {};
-  /** @type {null | {kind: string, tokensBefore?: number|null, tokensAfter?: number|null, savings?: number|null, error?: any}} */
+  /** @type {null | {kind: string, tokensBefore?: number|null, tokensAfter?: number|null, savings?: number|null, firstKeptEntryId?: string|null, error?: any}} */
   let hookDecision = null;
   let removeHook = null;
   try {
@@ -281,16 +284,20 @@ export async function tryCompact(harness, {
       contextWindow: typeof harness?.getModel === "function" ? harness.getModel()?.contextWindow : undefined,
     });
     effectivePolicy = { ...adaptivePolicy, ...(policy || {}) };
+    const compactionSettings = {
+      enabled: true,
+      reserveTokens: piSummaryReserveTokens(effectivePolicy.summaryMaxTokens, false),
+      keepRecentTokens: effectivePolicy.keepRecentTokens,
+    };
+    if (typeof harness?.setCompactionSettings === "function") {
+      await harness.setCompactionSettings(compactionSettings);
+    }
     if (typeof harness?.on !== "function") {
       throw new Error("Pi AgentHarness does not expose session_before_compact hooks");
     }
     removeHook = harness.on("session_before_compact", async (event) => {
       try {
-        let settings = {
-          enabled: true,
-          reserveTokens: piSummaryReserveTokens(effectivePolicy.summaryMaxTokens, false),
-          keepRecentTokens: effectivePolicy.keepRecentTokens,
-        };
+        let settings = compactionSettings;
         let prepared = prepareCompaction(event.branchEntries, settings);
         if (prepared.ok === false) {
           hookDecision = { kind: "failed", error: prepared.error };
@@ -320,16 +327,22 @@ export async function tryCompact(harness, {
           harness.models,
           harness.getModel(),
           event.customInstructions,
-          event.signal,
           typeof harness.getThinkingLevel === "function" ? harness.getThinkingLevel() : undefined,
+          undefined,
+          undefined,
+          event.context || BACKGROUND_CONTEXT,
         );
         if (compacted.ok === false) {
           hookDecision = { kind: "failed", error: compacted.error };
           return { cancel: true };
         }
-        const tokensBefore = estimateBuiltContextTokens(event.branchEntries);
-        const tokensAfter = previewCompactedContext(event.branchEntries, compacted.value);
+        const tokensBefore = await estimateBuiltContextTokens(event.branchEntries);
+        const tokensAfter = await previewCompactedContext(event.branchEntries, compacted.value);
         const savings = tokensBefore === null || tokensAfter === null ? null : tokensBefore - tokensAfter;
+        const firstRetainedMessage = prepared.value.retainedTail[0];
+        const firstKeptEntryId = firstRetainedMessage
+          ? event.branchEntries.find((entry) => entry?.type === "message" && entry.message === firstRetainedMessage)?.id || null
+          : null;
         if (savings === null || savings <= 0) {
           hookDecision = { kind: "not_reducible", tokensBefore, tokensAfter, savings };
           return { cancel: true };
@@ -338,7 +351,7 @@ export async function tryCompact(harness, {
           hookDecision = { kind: "insufficient_savings", tokensBefore, tokensAfter, savings };
           return { cancel: true };
         }
-        hookDecision = { kind: "accepted", tokensBefore, tokensAfter, savings };
+        hookDecision = { kind: "accepted", tokensBefore, tokensAfter, savings, firstKeptEntryId };
         return { compaction: compacted.value };
       } catch (error) {
         hookDecision = { kind: "failed", error };
@@ -379,7 +392,10 @@ export async function tryCompact(harness, {
           model: model || null,
           tokens_before: tokensBefore,
           summary: result?.summary || "",
-          first_kept_entry_id: result?.firstKeptEntryId || null,
+          // Pi 0.85 returns retained messages rather than their entry ids. The
+          // preparation still retains object identity, so preserve this legacy
+          // diagnostic when its first retained message came from a real entry.
+          first_kept_entry_id: hookDecision?.firstKeptEntryId || null,
           status: "succeeded",
           created_at: Date.now(),
         });
@@ -446,12 +462,15 @@ export async function tryCompact(harness, {
       : err;
     const message = effectiveError?.message || String(effectiveError);
     const code = effectiveError?.code;
-    const nothingToCompact = code === "compaction" && /nothing to compact/i.test(message);
+    const tag = effectiveError?._tag;
+    const nothingToCompact = tag === "NothingToCompact"
+      || (code === "compaction" && /nothing to compact/i.test(message));
+    const busy = tag === "LaneBusy" || code === "busy";
     const warningKind = nothingToCompact
       ? "context_compaction_nothing_to_compact"
       : code === "auth"
         ? "context_compaction_auth_failed"
-        : code === "busy"
+        : busy
           ? "context_compaction_busy"
           : "context_compaction_failed";
     runtimeWarnings?.push({ warning_kind: warningKind, source: "pi", trigger, message });
@@ -464,7 +483,7 @@ export async function tryCompact(harness, {
         ? "nothing_to_compact"
         : code === "auth"
           ? "authentication"
-          : code === "busy"
+          : busy
             ? "busy"
             : code === "aborted"
               ? "cancelled"
@@ -474,7 +493,7 @@ export async function tryCompact(harness, {
         : {
           message: code === "auth"
             ? "Compaction authentication failed."
-            : code === "busy"
+            : busy
               ? "Context was busy and could not be compacted."
               : code === "aborted"
                 ? "Compaction was cancelled."
@@ -484,6 +503,15 @@ export async function tryCompact(harness, {
     return { applied: false, tokensBefore: null, tokensAfter: null, reduced: null, nothingToCompact };
   } finally {
     removeHook?.();
+    if (typeof harness?.setCompactionSettings === "function") {
+      try {
+        await harness.setCompactionSettings({
+          enabled: false,
+          reserveTokens: 16_384,
+          keepRecentTokens: 20_000,
+        });
+      } catch { /* best-effort */ }
+    }
   }
 }
 

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

@@ -0,0 +1,338 @@
+// @ts-check
+// Compatibility boundary between mono-agent's Pi-native bridge and the
+// lane-based AgentHarness API introduced in pi-agent-core 0.85.
+
+import {
+  AgentHarness,
+  BACKGROUND_CONTEXT,
+  createBranchSummaryMessage,
+  createCompactionSummaryMessage,
+  getOrThrow,
+} from "@earendil-works/pi-agent-core";
+
+export const PI_CONTEXT = BACKGROUND_CONTEXT;
+
+function operationError(record, fallback) {
+  const error = new Error(record?.error?.message || fallback);
+  if (record?.error?.code) /** @type {any} */ (error).code = record.error.code;
+  return error;
+}
+
+function isContextMessage(message) {
+  return message?.role !== "assistant"
+    || !["error", "aborted", "deferred"].includes(message.stopReason);
+}
+
+/**
+ * Pi 0.85 no longer exports its session-context projector. Reproduce the
+ * public entry contract here so transcript accounting uses the same latest-
+ * compaction and failed-assistant filtering rules as the harness.
+ * @param {any[]} pathEntries
+ * @param {{includeFailed?: boolean}} [options]
+ */
+export function buildPiSessionContext(pathEntries, { includeFailed = false } = {}) {
+  let start = 0;
+  for (let index = pathEntries.length - 1; index >= 0; index -= 1) {
+    if (pathEntries[index]?.type === "compaction") {
+      start = index;
+      break;
+    }
+  }
+  const entries = start > 0 ? pathEntries.slice(start) : pathEntries;
+  const messages = [];
+  for (const entry of entries) {
+    if (entry?.type === "message") {
+      if (includeFailed || isContextMessage(entry.message)) messages.push(entry.message);
+    } else if (entry?.type === "compaction") {
+      messages.push(createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp));
+      messages.push(...(includeFailed
+        ? (entry.retainedTail || [])
+        : (entry.retainedTail || []).filter(isContextMessage)));
+    } else if (entry?.type === "branch_summary" && entry.summary) {
+      messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
+    }
+  }
+  return messages;
+}
+
+/**
+ * Give the surrounding bridge the small session surface it used before Pi
+ * moved branch operations onto AgentLane. The raw session remains available to
+ * AgentHarness.create(), while all transcript reads and writes use the attached
+ * main lane once the harness exists.
+ * @param {any} rawSession
+ */
+export function createPiSessionAdapter(rawSession) {
+  let lane = null;
+  let harness = null;
+  let closePromise = null;
+
+  const requireLane = () => {
+    if (!lane) throw new Error("Pi session lane is not attached");
+    return lane;
+  };
+
+  return {
+    rawSession,
+    get metadata() { return rawSession.metadata; },
+    attach(nextHarness, nextLane) {
+      harness = nextHarness;
+      lane = nextLane;
+    },
+    async buildContext() {
+      const entries = await requireLane().findEntries({ order: "oldestFirst" }, PI_CONTEXT);
+      // This bridge-facing transcript includes terminal error/abort messages so
+      // result classification can observe them. Pi filters those only when it
+      // constructs the next provider request.
+      return { messages: buildPiSessionContext(entries, { includeFailed: true }) };
+    },
+    getEntries() {
+      return requireLane().findEntries({ order: "oldestFirst" }, PI_CONTEXT);
+    },
+    getLeafId() {
+      return requireLane().getTipId(PI_CONTEXT);
+    },
+    appendMessage(message) {
+      return requireLane().appendMessage(message, PI_CONTEXT);
+    },
+    async moveTo(targetId) {
+      const result = getOrThrow(await requireLane().navigateTree(
+        targetId,
+        { summarize: false },
+        PI_CONTEXT,
+      ));
+      const record = result.navigation;
+      if (record.status === "failed") throw operationError(record, "Pi session navigation failed");
+      if (record.status !== "completed") throw operationError(record, "Pi session navigation was not completed");
+      return record.tipId;
+    },
+    getMetadata() {
+      return Promise.resolve(rawSession.metadata);
+    },
+    close() {
+      if (!closePromise) {
+        closePromise = (harness
+          ? harness.close(PI_CONTEXT)
+          : rawSession.close(PI_CONTEXT));
+      }
+      return closePromise;
+    },
+  };
+}
+
+function adaptTool(tool) {
+  return {
+    ...tool,
+    async execute(toolCallId, params, onUpdate, _toolContext, _invocation, context) {
+      return tool.execute(toolCallId, params, context.abortSignal, onUpdate);
+    },
+  };
+}
+
+const FORWARDED_EVENT_TYPES = [
+  "run_start",
+  "run_resume",
+  "run_suspend",
+  "operation_abort",
+  "run_end",
+  "fault",
+  "handler_error",
+  "turn_start",
+  "turn_end",
+  "retry_scheduled",
+  "retry_start",
+  "retry_end",
+  "message_start",
+  "message_update",
+  "message_end",
+  "tool_start",
+  "tool_update",
+  "tool_end",
+  "entry_added",
+  "queue_update",
+  "value_update",
+  "config_update",
+  "compaction_start",
+  "compaction_end",
+  "navigation_start",
+  "navigation_end",
+  "lane_created",
+  "usage",
+];
+
+function legacyEvent(event) {
+  // appendMessage() emits runless lifecycle events for transcript seeding.
+  // They are persistence notifications, not output from the active provider
+  // run, and forwarding them would manufacture assistant boundaries/usage for
+  // prior history. Real run-owned message events always carry runId in Pi 0.85.
+  if ((event.type === "message_start" || event.type === "message_end") && !event.runId) {
+    return null;
+  }
+  if (event.type === "message_update") {
+    return { ...event, assistantMessageEvent: event.event };
+  }
+  if (event.type === "tool_start") return { ...event, type: "tool_execution_start" };
+  if (event.type === "tool_update") return { ...event, type: "tool_execution_update" };
+  if (event.type === "tool_end") return { ...event, type: "tool_execution_end" };
+  return event;
+}
+
+/**
+ * Attach Pi 0.85's harness to one session and expose the intentionally small
+ * surface consumed by mono-agent's turn runner.
+ * @param {any} session
+ * @param {any} options
+ */
+export async function createPiHarnessAdapter(session, options) {
+  const originalTools = Array.isArray(options.tools) ? options.tools : [];
+  const adaptedTools = originalTools.map(adaptTool);
+  const activeToolNames = originalTools.map((tool) => tool.name);
+  // Pi 0.85 removed mixed per-tool scheduling from AgentHarness: its runner
+  // consults only this global setting. Preserve the safety contract by
+  // serializing the batch whenever any offered tool is stateful, mutating, or
+  // MCP-backed. Read-only-only tool sets can still overlap in safe-parallel.
+  const toolExecution = originalTools.some((tool) => tool?.executionMode === "sequential")
+    ? "sequential"
+    : "parallel";
+
+  /** @type {any} */
+  let created;
+  /** @type {any} */
+  let rawHarness;
+  /** @type {any} */
+  let lane;
+  try {
+    created = await AgentHarness.create({
+      ...options,
+      session: session.rawSession,
+      tools: adaptedTools,
+      activeToolNames,
+      toolExecution,
+      // mono-agent owns proactive/reactive compaction policy. The permanent hook
+      // below also declines Pi's overflow recovery so one bridge never runs two
+      // competing policies.
+      compaction: { enabled: false, reserveTokens: 16_384, keepRecentTokens: 20_000 },
+    }, PI_CONTEXT);
+    rawHarness = created.harness;
+    // Attach the harness before lane/configuration awaits so any later failure
+    // can close the partially constructed handle instead of wedging the repo.
+    session.attach(rawHarness, null);
+    lane = await rawHarness.lane("main", PI_CONTEXT);
+    session.attach(rawHarness, lane);
+
+    // A restored lane carries its prior configuration, so explicitly bind it to
+    // this run's model, effort, and available tools. Legacy v3 transcripts import
+    // with an empty active-tool list and are upgraded atomically by Pi on write.
+    await rawHarness.setTools(adaptedTools, PI_CONTEXT);
+    await lane.setModel({ provider: options.model.provider, modelId: options.model.id }, PI_CONTEXT);
+    await lane.setThinkingLevel(options.thinkingLevel ?? "off", PI_CONTEXT);
+    await lane.setActiveTools(activeToolNames, PI_CONTEXT);
+
+    rawHarness.hooks.on("before_compaction", (event) => (
+      event.reason === "manual" ? undefined : { decline: true }
+    ), { id: "mono-agent-compaction-owner" });
+  } catch (error) {
+    try { await session.close(); } catch { /* preserve the construction error */ }
+    throw error;
+  }
+
+  let closed = false;
+  let currentModel = options.model;
+  let currentThinkingLevel = options.thinkingLevel ?? "off";
+  let currentActiveToolNames = [...activeToolNames];
+  const manuallyAppendedEntryIds = new Set();
+
+  const adapter = {
+    models: options.models,
+    getModel: () => currentModel,
+    getThinkingLevel: () => currentThinkingLevel,
+    getActiveTools: () => originalTools.filter((tool) => currentActiveToolNames.includes(tool.name)),
+    async setActiveTools(names) {
+      await lane.setActiveTools(names, PI_CONTEXT);
+      currentActiveToolNames = [...names];
+    },
+    async setCompactionSettings(settings) {
+      await rawHarness.setCompactionSettings(settings, PI_CONTEXT);
+    },
+    async appendMessage(message) {
+      const entryId = await lane.appendMessage(message, PI_CONTEXT);
+      manuallyAppendedEntryIds.add(entryId);
+      return entryId;
+    },
+    async prompt(text, promptOptions) {
+      return getOrThrow(await lane.prompt(text, promptOptions?.images, PI_CONTEXT));
+    },
+    async steer(message) {
+      return getOrThrow(await lane.steer(message, undefined, PI_CONTEXT));
+    },
+    async abort() {
+      const result = await lane.abort(PI_CONTEXT);
+      // Aborting an already-idle lane is a benign race with prompt settlement.
+      if (!result.ok) {
+        const error = /** @type {{error: any}} */ (result).error;
+        if (error?._tag !== "NoActiveOperation") throw error;
+      }
+    },
+    waitForIdle() {
+      return lane.waitForIdle(PI_CONTEXT);
+    },
+    async compact() {
+      const value = getOrThrow(await lane.compact(undefined, PI_CONTEXT));
+      const record = value.compaction;
+      if (record.status === "failed") throw operationError(record, "Pi compaction failed");
+      if (record.status !== "completed") throw operationError(record, "Pi compaction cancelled");
+      const entry = record.tipId
+        ? await session.rawSession.getEntry(record.tipId, PI_CONTEXT)
+        : undefined;
+      if (!entry || entry.type !== "compaction") {
+        throw new Error("Pi compaction completed without a compaction entry");
+      }
+      return entry;
+    },
+    on(type, handler) {
+      if (type === "tool_result") {
+        return rawHarness.hooks.on("after_tool", (event) => handler(event));
+      }
+      if (type === "session_before_compact") {
+        return rawHarness.hooks.on("before_compaction", async (event, context) => {
+          const branchEntries = await lane.findEntries({ order: "oldestFirst" }, context);
+          const result = await handler({
+            ...event,
+            branchEntries,
+            signal: context.abortSignal,
+            context,
+          });
+          if (result?.cancel) return { decline: true };
+          return result?.compaction === undefined ? undefined : { compaction: result.compaction };
+        });
+      }
+      throw new Error(`Unsupported Pi harness hook: ${String(type)}`);
+    },
+    subscribe(listener) {
+      const removes = FORWARDED_EVENT_TYPES.map((type) => rawHarness.events.on(
+        /** @type {any} */ (type),
+        (event) => {
+          if (event.type === "message_end" && manuallyAppendedEntryIds.has(event.entryId)) return;
+          const converted = legacyEvent(event);
+          if (converted) listener(converted);
+        },
+      ));
+      return () => removes.forEach((remove) => remove());
+    },
+    async abortOpenOperations() {
+      if (!created.open.some((operation) => operation.lane === "main")) return;
+      // mono-agent tools predate Pi's invocation memo/checkpoint API, so replaying
+      // an interrupted durable operation could repeat an external side effect.
+      // Fail closed by settling it as aborted before admitting a new prompt.
+      getOrThrow(await lane.abort(PI_CONTEXT));
+      await lane.waitForIdle(PI_CONTEXT);
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      await session.close();
+    },
+  };
+
+  return adapter;
+}

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

@@ -118,14 +118,14 @@ export function emitUsageCostEvents({
   externalAbort,
 }) {
   if (usage.cacheRead > 0) {
-    onEvent({ type: "cache_hit", sdk: resolved.sdk, model: reference, tokens: usage.cacheRead, source: "prompt_cache" });
+    onEvent({ type: "cache_hit", sdk: "pi", model: reference, tokens: usage.cacheRead, source: "prompt_cache" });
   }
   if (usage.cacheWrite > 0) {
-    onEvent({ type: "cache_miss", sdk: resolved.sdk, model: reference, tokens: usage.cacheWrite, source: "prompt_cache" });
+    onEvent({ type: "cache_miss", sdk: "pi", model: reference, tokens: usage.cacheWrite, source: "prompt_cache" });
   }
   onEvent({
     type: "cost_accumulated",
-    sdk: resolved.sdk,
+    sdk: "pi",
     model: reference,
     cumulativeUsd: Number(usage.cost) || Number(estimatedCost) || 0,
     tokens: {
@@ -137,7 +137,7 @@ export function emitUsageCostEvents({
   });
   onEvent({
     type: "provider_request_completed",
-    sdk: resolved.sdk,
+    sdk: "pi",
     model: reference,
     runtime: "pi",
     timestamp: Date.now(),
@@ -167,9 +167,9 @@ export function abortedResult({ resolved, options, events, runtimeWarnings, star
     usage: {},
     durationMs: Date.now() - start,
     numTurns: 0,
-    model: resolved?.reference || resolved?.model || null,
+    model: resolved?.reference || (resolved?.provider && resolved?.model ? `${resolved.provider}:${resolved.model}` : null),
     effort: options.effort || null,
-    sdk: resolved?.sdk || "pi",
+    sdk: "pi",
     cancelled: true,
     error: null,
     failureKind: null,
@@ -226,9 +226,9 @@ export function buildSuccessResult(params) {
     },
     durationMs: Date.now() - start,
     numTurns: turnCount || runAssistantCount,
-    model: resolved.reference || `pi:${resolved.provider}:${resolved.model}`,
+    model: resolved.reference || `${resolved.provider}:${resolved.model}`,
     effort: options.effort || null,
-    sdk: resolved.sdk,
+    sdk: "pi",
     cancelled: externalAbort,
     error: errorMessage,
     errorDetails,
@@ -273,9 +273,9 @@ export function buildErrorResult(params) {
     usage: {},
     durationMs: Date.now() - start,
     numTurns: turnCount,
-    model: resolved?.reference || resolved?.model || null,
+    model: resolved?.reference || (resolved?.provider && resolved?.model ? `${resolved.provider}:${resolved.model}` : null),
     effort: options.effort || null,
-    sdk: resolved?.sdk || "pi",
+    sdk: "pi",
     cancelled: externalAbort,
     error: externalAbort ? null : errorMessage,
     errorDetails: externalAbort ? null : {