@fitchmultz/pi-mcp-adapter 7.1.1 → 8.0.1

package/dist/config.js

@@ -49,7 +49,7 @@ export const KNOWN_SERVER_PRESETS = [
         id: "chrome-devtools",
         name: "Chrome DevTools",
         summary: "Inspect and automate a local Chrome browser.",
-        entry: { command: "npx", args: ["-y", "chrome-devtools-mcp@latest"] },
+        entry: { command: "npx", args: ["-y", "chrome-devtools-mcp"] },
     },
 ];
 const IMPORT_PATHS = {

package/dist/direct-tools.js

@@ -3,6 +3,7 @@ import { parseDirectToolSelectors } from "./metadata-cache.js";
 export { getMissingConfiguredDirectToolServers } from "./metadata-cache.js";
 import { executeCall } from "./proxy-modes.js";
 import { isServerDisabled } from "./types.js";
+import { nativeMcpResult } from "./tool-registrar.js";
 export function directToolSelection(config, serverName, envOverride) {
     if (envOverride) {
         const selection = parseDirectToolSelectors(envOverride);
@@ -33,20 +34,20 @@ export function createDirectToolExecutor(getState, getInitPromise, spec, beforeE
             catch (error) {
                 throwIfAborted(signal);
                 const message = error instanceof Error ? error.message : String(error);
-                return {
+                return nativeMcpResult({
                     content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
                     details: { error: "init_failed", message },
-                };
+                }, !!spec.outputSchema);
             }
         }
         if (!state) {
-            return {
+            return nativeMcpResult({
                 content: [{ type: "text", text: "MCP not initialized" }],
                 details: { error: "not_initialized" },
-            };
+            }, !!spec.outputSchema);
         }
         const result = await executeCall(state, spec.originalName, params, spec.serverName, undefined, signal, { toolCallId }, beforeExecute ? (callSignal, operation) => beforeExecute(toolCallId, { ...ctx, signal: callSignal }, operation) : undefined, { exactOriginalName: true, ...(spec.resourceUri ? { resourceUri: spec.resourceUri } : {}) });
         const { mode: _mode, ...details } = result.details;
-        return { ...result, details };
+        return nativeMcpResult({ ...result, details }, !!spec.outputSchema);
     };
 }

package/dist/error-signal.d.ts

@@ -1,11 +1,9 @@
 /**
- * Decide the `isError` override for a finished tool result in the `tool_result` hook.
+ * Classify returned MCP execution failures for Pi's native result-level isError.
  *
  * A failed MCP tool call is *returned* (not thrown), tagged `details.error: "tool_error"` (the server
- * returned an error result) or `"call_failed"` (the call itself threw and was caught). pi never reads a
- * result-level `isError`, so without this such a call is recorded as a success. Returning
- * `{ isError: true }` (and nothing else) flips the flag; pi's field-by-field merge keeps the original
- * `content` and `details` intact.
+ * returned an error result) or `"call_failed"` (the call itself threw and was caught).
+ * Spread this onto the returned result without replacing human or structured content.
  *
  * Limited to those two codes: the adapter's other `details.error` values (`auth_required`, connection
  * states, search/validation feedback, ...) are not failed tool calls, so they get no override.

package/dist/error-signal.js

@@ -1,11 +1,9 @@
 /**
- * Decide the `isError` override for a finished tool result in the `tool_result` hook.
+ * Classify returned MCP execution failures for Pi's native result-level isError.
  *
  * A failed MCP tool call is *returned* (not thrown), tagged `details.error: "tool_error"` (the server
- * returned an error result) or `"call_failed"` (the call itself threw and was caught). pi never reads a
- * result-level `isError`, so without this such a call is recorded as a success. Returning
- * `{ isError: true }` (and nothing else) flips the flag; pi's field-by-field merge keeps the original
- * `content` and `details` intact.
+ * returned an error result) or `"call_failed"` (the call itself threw and was caught).
+ * Spread this onto the returned result without replacing human or structured content.
  *
  * Limited to those two codes: the adapter's other `details.error` values (`auth_required`, connection
  * states, search/validation feedback, ...) are not failed tool calls, so they get no override.

package/dist/index.js

@@ -10,7 +10,6 @@ import { executeAuthComplete, executeAuthStart, executeCall, executeConnect, exe
 import { formatTerminalError } from "./utils.js";
 import { createOAuthRuntime, shutdownOAuth } from "./mcp-auth-flow.js";
 import { renderMcpProxyToolCall, renderMcpToolResult } from "./tool-result-renderer.js";
-import { toolErrorOverride } from "./error-signal.js";
 import { createMcpRuntimeOwner, createOwnedUi, isAbortError } from "./runtime-owner.js";
 import { publishMcpStatusShutdown } from "./mcp-status.js";
 import { DEFAULT_MCP_SCRIPT_TIMEOUT_MS, runMcpScript } from "./mcp-code.js";
@@ -20,7 +19,6 @@ import { gatewayParameters, prepareGatewayArguments } from "./gateway-arguments.
 import { executeResourceList, executeResourceRead } from "./resource-tools.js";
 import { guardMcpOutput, guardedMcpDetails, readMcpResult, resolveMcpOutputGuardOptions } from "./mcp-output-guard.js";
 import { abortable, throwIfAborted } from "./abort.js";
-import { onSessionCheckpoint, prepareMcpCheckpoint } from "./checkpoint.js";
 export { MCP_STATUS_EVENT, MCP_STATUS_SNAPSHOT_VERSION, } from "./types.js";
 const INIT_WAIT_TIMEOUT_MS = 30_000;
 const INIT_WAIT_TIMED_OUT = Symbol("init-wait-timed-out");
@@ -269,13 +267,6 @@ function installMcpAdapter(pi, options) {
         if (ctx.cwd !== runtimeCwd)
             await startSession(ctx);
     });
-    onSessionCheckpoint(pi, async (event) => {
-        if (initPromise)
-            return { sleepReady: false, reason: "MCP initialization is active" };
-        if (!state || !currentOwner?.isActive())
-            return { sleepReady: false, reason: "MCP runtime is not initialized" };
-        return prepareMcpCheckpoint(state, event);
-    });
     pi.on("session_shutdown", async () => {
         // Cached tool selections exist before background server initialization finishes.
         toolLoader.persist();
@@ -300,8 +291,6 @@ function installMcpAdapter(pi, options) {
         if (failures.length)
             throw new AggregateError(failures, "MCP session shutdown persistence/cleanup failed");
     });
-    // Re-flag returned MCP tool failures so pi registers them as errors (see toolErrorOverride).
-    pi.on("tool_result", (event) => toolErrorOverride(event.details));
     function createCommandContext(ctx) {
         const owner = currentOwner;
         const hasUI = ctx.hasUI;

package/dist/init.js

@@ -43,7 +43,6 @@ export function recordFailure(state, serverName, message) {
             getFailureExpiryTimers(state).delete(serverName);
             return;
         }
-        state.owner.beforeActivity();
         if (state.failureTracker.get(serverName) === failedAt) {
             state.failureTracker.delete(serverName);
             state.failureMessages?.delete(serverName);

package/dist/lifecycle.d.ts

@@ -15,10 +15,6 @@ export declare class McpLifecycleManager {
     private activeHealthCheck;
     private shutdownPromise;
     private stopped;
-    private checkpointPauses;
-    hasActiveHealthCheck(): boolean;
-    /** Skip ticks, without cancelling accepted work or permanently closing the manager. */
-    pauseForCheckpoint(): () => void;
     private healthSignal;
     private removeHealthAbortListener;
     private readonly manager;

package/dist/lifecycle.js

@@ -14,19 +14,6 @@ export class McpLifecycleManager {
     activeHealthCheck;
     shutdownPromise;
     stopped = false;
-    checkpointPauses = 0;
-    hasActiveHealthCheck() { return this.activeHealthCheck !== undefined; }
-    /** Skip ticks, without cancelling accepted work or permanently closing the manager. */
-    pauseForCheckpoint() {
-        this.checkpointPauses++;
-        let released = false;
-        return () => {
-            if (!released) {
-                released = true;
-                this.checkpointPauses--;
-            }
-        };
-    }
     healthSignal;
     removeHealthAbortListener;
     manager;
@@ -81,7 +68,7 @@ export class McpLifecycleManager {
         signal?.addEventListener("abort", stop, { once: true });
         this.removeHealthAbortListener = () => signal?.removeEventListener("abort", stop);
         this.healthCheckInterval = setInterval(() => {
-            if (this.stopped || signal?.aborted || this.activeHealthCheck || this.checkpointPauses > 0)
+            if (this.stopped || signal?.aborted || this.activeHealthCheck)
                 return;
             const check = this.checkConnections(signal)
                 .catch(error => {

package/dist/mcp-auth-flow.d.ts

@@ -9,7 +9,6 @@ import { type AuthStorageOptions } from "./mcp-auth.ts";
 import { type ServerEntry } from "./types.ts";
 /** Auth status for a server */
 export type AuthStatus = "authenticated" | "expired" | "not_authenticated";
-import type { McpCheckpointEvent } from "./checkpoint.ts";
 export interface McpOAuthRuntime {
     readonly signal: AbortSignal;
 }
@@ -20,8 +19,6 @@ export interface AuthenticateOptions {
     runtime?: McpOAuthRuntime;
 }
 export declare function createOAuthRuntime(signal?: AbortSignal): McpOAuthRuntime;
-export declare function holdOAuthCheckpoint(runtime: McpOAuthRuntime, event: McpCheckpointEvent): () => void;
-export declare function getOAuthCheckpointBlocker(runtime: McpOAuthRuntime): string | undefined;
 type OAuthRequest = {
     serverName: string;
     serverUrl: string;
@@ -46,8 +43,7 @@ export declare function extractOAuthConfig(definition: ServerEntry): McpOAuthCon
  * Start OAuth authentication flow for a server.
  * Returns the authorization URL when browser authorization is required.
  */
-export declare const startAuth: typeof startAuthOperation;
-declare function startAuthOperation(serverName: string, serverUrl: string, definition?: ServerEntry, options?: AuthenticateOptions): Promise<{
+export declare function startAuth(serverName: string, serverUrl: string, definition?: ServerEntry, options?: AuthenticateOptions): Promise<{
     authorizationUrl: string;
 }>;
 /** Authorization code plus the optional RFC 9207 `iss` callback parameter. */
@@ -74,8 +70,7 @@ export declare function completeAuthFromInput(serverName: string, input?: string
 /**
  * Complete OAuth authentication with an explicit code or a captured callback.
  */
-export declare const completeAuth: typeof completeAuthOperation;
-declare function completeAuthOperation(serverName: string, authorizationCode?: string | AuthorizationResponseInput, options?: AuthenticateOptions): Promise<AuthStatus>;
+export declare function completeAuth(serverName: string, authorizationCode?: string | AuthorizationResponseInput, options?: AuthenticateOptions): Promise<AuthStatus>;
 /**
  * Perform the complete OAuth authentication flow for a server.
  *
@@ -90,8 +85,7 @@ export declare function authenticate(serverName: string, serverUrl: string, defi
  *
  * @param serverName - The name of the MCP server
  */
-export declare const removeAuth: typeof removeAuthOperation;
-declare function removeAuthOperation(serverName: string, options?: AuthenticateOptions): Promise<void>;
+export declare function removeAuth(serverName: string, options?: AuthenticateOptions): Promise<void>;
 /**
  * Check if OAuth is supported for a server configuration.
  * OAuth is supported for HTTP servers unless explicitly disabled.

package/dist/mcp-auth-flow.js

@@ -42,7 +42,6 @@ export function createOAuthRuntime(signal) {
     runtimeStates.set(runtime, {
         controller,
         generation: 0,
-        activeOperations: 0,
         pendingAuths: new Map(),
         pendingAuthStates: new Map(),
         pendingAuthCleanupTimers: new Map(),
@@ -71,36 +70,6 @@ function getRuntimeState(runtime) {
         throw new Error("Unknown OAuth runtime");
     return state;
 }
-export function holdOAuthCheckpoint(runtime, event) {
-    const state = getRuntimeState(runtime);
-    if (state.checkpoint)
-        throw new Error("MCP OAuth checkpoint is already held");
-    state.checkpoint = event;
-    return () => { if (state.checkpoint === event)
-        state.checkpoint = undefined; };
-}
-export function getOAuthCheckpointBlocker(runtime) {
-    const state = getRuntimeState(runtime);
-    if (state.activeOperations || state.pendingAuthentications.size)
-        return "MCP OAuth operation is active";
-    if (state.pendingAuths.size || state.pendingAuthStates.size || state.pendingAuthCleanupTimers.size)
-        return "MCP browser OAuth callback/flow is pending";
-    // requests caches server challenges/discovery, not a pending user callback.
-    // Cold connect re-challenges; granted scopes and issuer bindings live in the
-    // native credential store. Actual interactive/auth operations veto above.
-    return undefined;
-}
-async function withOAuthOperation(runtime, run) {
-    const state = getRuntimeState(runtime);
-    state.checkpoint?.invalidate();
-    state.activeOperations++;
-    try {
-        return await run();
-    }
-    finally {
-        state.activeOperations--;
-    }
-}
 function getPendingAuthKey(serverName, options) {
     return JSON.stringify([serverName, getAuthBaseDir(options)]);
 }
@@ -118,7 +87,6 @@ export function getOAuthRequest(serverName, serverUrl, storageBase, runtime = le
 export function recordOAuthChallenge(serverName, serverUrl, storageBase, error, runtime = legacyRuntime) {
     if (runtime.signal.aborted || !isOAuthChallenge(error))
         return;
-    getRuntimeState(runtime).checkpoint?.invalidate();
     const previous = getOAuthRequest(serverName, serverUrl, storageBase, runtime);
     const request = { ...previous, serverName, serverUrl };
     if (error instanceof InsufficientScopeError) {
@@ -315,8 +283,7 @@ function parseOAuthRedirectUri(redirectUri) {
  * Start OAuth authentication flow for a server.
  * Returns the authorization URL when browser authorization is required.
  */
-export const startAuth = async (...args) => withOAuthOperation(getRuntime(args[3]), () => startAuthOperation(...args));
-async function startAuthOperation(serverName, serverUrl, definition, options = {}) {
+export async function startAuth(serverName, serverUrl, definition, options = {}) {
     if (isServerDisabled(definition))
         throw new Error(`MCP server "${serverName}" is disabled`);
     const runtime = getRuntime(options);
@@ -479,10 +446,7 @@ async function setPendingAuth(runtime, serverName, pendingAuth, oauthState, sign
     cleanupTimer.unref?.();
     state.pendingAuthCleanupTimers.set(key, cleanupTimer);
 }
-function clearPendingAuth(...args) {
-    return withOAuthOperation(args[0], () => clearPendingAuthOperation(...args));
-}
-async function clearPendingAuthOperation(runtime, serverName, oauthState, fallbackStorageOptions = {}) {
+async function clearPendingAuth(runtime, serverName, oauthState, fallbackStorageOptions = {}) {
     const state = getRuntimeState(runtime);
     const key = getPendingAuthKey(serverName, fallbackStorageOptions);
     const pendingAuth = state.pendingAuths.get(key);
@@ -576,8 +540,7 @@ export async function completeAuthFromInput(serverName, input, options = {}) {
 /**
  * Complete OAuth authentication with an explicit code or a captured callback.
  */
-export const completeAuth = async (...args) => withOAuthOperation(getRuntime(args[2]), () => completeAuthOperation(...args));
-async function completeAuthOperation(serverName, authorizationCode, options = {}) {
+export async function completeAuth(serverName, authorizationCode, options = {}) {
     const runtime = getRuntime(options);
     const runtimeState = getRuntimeState(runtime);
     const fallbackAuthStorageOptions = options.authStorageOptions ?? {};
@@ -743,8 +706,7 @@ export async function authenticate(serverName, serverUrl, definition, options =
  *
  * @param serverName - The name of the MCP server
  */
-export const removeAuth = async (...args) => withOAuthOperation(getRuntime(args[1]), () => removeAuthOperation(...args));
-async function removeAuthOperation(serverName, options = {}) {
+export async function removeAuth(serverName, options = {}) {
     const runtime = getRuntime(options);
     const signal = combineAbortSignals(runtime.signal, options.signal);
     throwIfAborted(signal);
@@ -811,7 +773,6 @@ export async function shutdownOAuth(runtime = legacyRuntime) {
     const state = getRuntimeState(runtime);
     if (state.controller.signal.aborted)
         return;
-    state.checkpoint?.invalidate();
     state.generation += 1;
     state.controller.abort(new Error("OAuth runtime stopped"));
     for (const callbackState of Array.from(state.pendingAuthStates.values()))

package/dist/mcp-code.js

@@ -98,7 +98,6 @@ class McpScriptCaptureError extends Error {
 }
 export const runMcpScript = async (...args) => {
     const state = args[0];
-    state.owner?.beforeActivity();
     state.activeScripts = (state.activeScripts ?? 0) + 1;
     try {
         return await runMcpScriptOperation(...args);

package/dist/mcp-output-guard.d.ts

@@ -78,6 +78,11 @@ export declare function guardMcpOutput(content: ContentBlock[], options?: McpOut
 export declare function retainMcpResult(result: unknown, options?: McpOutputGuardOptions, rawResult?: boolean): Promise<RetainedMcpResult>;
 export declare function formatMcpPayloadFile(file: McpPayloadFile): string;
 export declare function formatMcpResultReference(ref: string): string;
+/** Stream histories through the same private output-artifact and paged-reader boundary. */
+export declare function saveMcpOutputStream(chunks: AsyncIterable<string>, outputDirectory?: string): Promise<{
+    path?: string;
+    error?: string;
+}>;
 export interface ReadMcpResultInput {
     ref: string;
     /** RFC 6901 JSON Pointer. Omit to read the entire retained result. */

package/dist/mcp-output-guard.js

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
-import { mkdir, mkdtemp, readFile, realpath, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, open, readFile, realpath, writeFile } from "node:fs/promises";
+import { createReadStream } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 export const DEFAULT_MCP_OUTPUT_MAX_BYTES = 50 * 1024;
@@ -320,6 +321,26 @@ async function saveArtifact(kind, text, outputDirectory) {
         return { error: error instanceof Error ? error.message : String(error) };
     }
 }
+/** Stream histories through the same private output-artifact and paged-reader boundary. */
+export async function saveMcpOutputStream(chunks, outputDirectory) {
+    const artifact = await saveArtifact("output", "", outputDirectory);
+    if (!artifact.path)
+        return artifact;
+    try {
+        const file = await open(artifact.path, "a");
+        try {
+            for await (const chunk of chunks)
+                await file.writeFile(chunk);
+        }
+        finally {
+            await file.close();
+        }
+        return artifact;
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
 export async function readMcpResult(input, options = {}) {
     try {
         if (!input || typeof input.ref !== "string")
@@ -330,6 +351,39 @@ export async function readMcpResult(input, options = {}) {
         if (dirname(dirname(ref)) !== root || !/^pi-mcp-output-/.test(basename(dirname(ref)))
             || !/^(mcp-result|output)-[a-f0-9]+\.txt$/.test(basename(ref)))
             throw new Error("ref is not an MCP output artifact in this host's output directory");
+        // Plain output pages without flattening a complete UI history into memory.
+        if (basename(ref).startsWith("output-") && input.path === undefined && input.fields === undefined) {
+            const offset = input.offset ?? 0;
+            const limit = input.limit ?? 12_000;
+            if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1)
+                throw new Error("offset must be a non-negative integer and limit a positive integer");
+            const maxBytes = Math.max(1, (options.maxBytes ?? DEFAULT_MCP_OUTPUT_MAX_BYTES) - 256);
+            const maxLines = Math.max(1, (options.maxLines ?? DEFAULT_MCP_OUTPUT_MAX_LINES) - 1);
+            let total = 0, bytes = 0, lines = 1;
+            let page = "";
+            let finished = false;
+            for await (const chunk of createReadStream(ref, { encoding: "utf8" })) {
+                for (const char of chunk) {
+                    if (total < offset && total + char.length > offset)
+                        throw new Error("offset must not split a Unicode surrogate pair");
+                    if (total >= offset && !finished) {
+                        const nextBytes = bytes + byteLength(char);
+                        const nextLines = lines + (char === "\n" ? 1 : 0);
+                        if (page && (nextBytes > maxBytes || nextLines > maxLines || page.length + char.length > limit))
+                            finished = true;
+                        else {
+                            page += char;
+                            bytes = nextBytes;
+                            lines = nextLines;
+                        }
+                    }
+                    total += char.length;
+                }
+            }
+            const end = offset + page.length;
+            const nextOffset = end < total ? end : null;
+            return { content: [{ type: "text", text: page }, ...(nextOffset !== null ? [{ type: "text", text: `[MCP result page: ${offset}–${end} of ${total} characters. Continue with offset: ${end}.]` }] : [])], details: { ref, offset, nextOffset, totalCharacters: total } };
+        }
         let rendered = await readFile(ref, "utf8");
         if (input.path !== undefined || input.fields !== undefined || basename(ref).startsWith("mcp-result-")) {
             let value = JSON.parse(rendered);

package/dist/mcp-setup-panel.js

@@ -461,7 +461,7 @@ export class McpSetupPanel {
                     '  "mcpServers": {',
                     '    "chrome-devtools": {',
                     '      "command": "npx",',
-                    '      "args": ["-y", "chrome-devtools-mcp@latest"]',
+                    '      "args": ["-y", "chrome-devtools-mcp"]',
                     "    }",
                     "  }",
                     "}",

package/dist/proxy-modes.d.ts

@@ -4,7 +4,7 @@ import type { ServerConnection } from "./server-manager.ts";
 import type { ToolMetadata, McpOperationContext, McpToolCallIdentity } from "./types.ts";
 import { type SessionRecoveryDeps } from "./session-recovery.ts";
 type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
-export declare function executeUiMessages(state: McpExtensionState): ProxyToolResult;
+export declare function executeUiMessages(state: McpExtensionState): Promise<ProxyToolResult>;
 export declare function executeStatus(state: McpExtensionState): ProxyToolResult;
 export declare function executeAuthStart(state: McpExtensionState, serverName: string, signal?: AbortSignal): Promise<ProxyToolResult>;
 export declare function executeAuthComplete(state: McpExtensionState, serverName: string, input?: string, signal?: AbortSignal): Promise<ProxyToolResult>;

package/dist/proxy-modes.js

@@ -6,13 +6,14 @@ import { combineAbortSignals, isAbortError } from "./runtime-owner.js";
 import { buildToolMetadata, catalogCoverage, findToolByName, formatSchema, toToolDescriptor } from "./tool-metadata.js";
 import { reconstructPromptMetadata } from "./metadata-cache.js";
 import { renderMcpResultContent } from "./tool-registrar.js";
-import { guardMcpOutput, guardedMcpDetails, retainMcpResult, resolveMcpOutputGuardOptions, formatMcpResultReference } from "./mcp-output-guard.js";
+import { guardMcpOutput, guardedMcpDetails, retainMcpResult, resolveMcpOutputGuardOptions, formatMcpResultReference, saveMcpOutputStream } from "./mcp-output-guard.js";
 import { maybeStartUiSession, summarizeUiSessionResult } from "./ui-session.js";
 import { formatAuthRequiredMessage, formatMcpStatus, resolveServerUrl, truncateAtWord } from "./utils.js";
 import { authenticate, completeAuthFromInput, startAuth, supportsOAuth } from "./mcp-auth-flow.js";
 import { isInterruptedToolCall, isToolTransportFailure, trackToolCallOutcome, SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
 import { paginate, rankSuggestions, rankToolMatches } from "./search-ranking.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
+import { materializeUiMessages, uiMessages } from "./ui-message-history.js";
 const INSTRUCTIONS_PREVIEW_LENGTH = 300;
 function disabledResult(mode, serverName) {
     const message = `Server "${serverName}" is disabled. Run /mcp enable ${serverName} and /reload to enable it.`;
@@ -120,8 +121,80 @@ async function attemptAutoAuth(state, serverName, signal) {
         };
     }
 }
-export function executeUiMessages(state) {
-    const sessions = state.completedUiSessions;
+async function* uiSessionText(session) {
+    yield `\n## ${session.serverName} / ${session.toolName} (${session.completedAt.toLocaleTimeString()}, ${session.reason})`;
+    let heading = false;
+    for await (const prompt of uiMessages(session.messages, "prompts")) {
+        if (parseUiPromptHandoff(prompt))
+            continue;
+        if (!heading) {
+            yield "\n\n### Prompts:";
+            heading = true;
+        }
+        yield `\n- ${prompt}`;
+    }
+    heading = false;
+    for await (const value of uiMessages(session.messages, "intents")) {
+        const intent = value;
+        if (!heading) {
+            yield "\n\n### Intents:";
+            heading = true;
+        }
+        yield `\n- ${intent.intent}${intent.params ? ` (${JSON.stringify(intent.params)})` : ""}`;
+    }
+    for await (const prompt of uiMessages(session.messages, "prompts")) {
+        const handoff = parseUiPromptHandoff(prompt);
+        if (!handoff)
+            continue;
+        if (!heading) {
+            yield "\n\n### Intents:";
+            heading = true;
+        }
+        yield `\n- ${handoff.intent} (${JSON.stringify(handoff.params)})`;
+    }
+    if (session.messages.contexts.length) {
+        yield "\n\n### Context updates:";
+        for (const context of session.messages.contexts)
+            yield `\n- ${context.summary}${context.truncated ? " (truncated)" : ""}`;
+    }
+    heading = false;
+    for await (const notification of uiMessages(session.messages, "notifications")) {
+        if (!heading) {
+            yield "\n\n### Notifications:";
+            heading = true;
+        }
+        yield `\n- ${notification}`;
+    }
+}
+export async function executeUiMessages(state) {
+    const pending = [...state.completedUiSessions];
+    const options = resolveMcpOutputGuardOptions(state.config?.settings, state.outputDirectory);
+    // Bound both inline output and details. Large retrieval streams; it never flattens all events.
+    const size = pending.reduce((bytes, session) => bytes + (session.messages.historyBytes ?? 0) + Buffer.byteLength(JSON.stringify(session.messages)), 0);
+    const large = size > Math.min(options.maxBytes, options.detailsMaxBytes);
+    const warnings = pending.flatMap(session => session.messages.historyError ? [session.messages.historyError] : []);
+    const paged = async () => {
+        async function* output() {
+            yield `UI Session Messages (${pending.length} sessions):\n`;
+            for (const session of pending)
+                yield* uiSessionText(session);
+        }
+        const artifact = await saveMcpOutputStream(output(), state.outputDirectory);
+        if (!artifact.path)
+            return { content: [{ type: "text", text: `UI messages remain available; retrieval could not be saved: ${artifact.error}` }], isError: true, details: { error: "ui_history_delivery_failed", cleared: false } };
+        // Newly completed sessions during I/O are not part of this drain.
+        state.completedUiSessions = state.completedUiSessions.filter(session => !pending.includes(session));
+        return { content: [{ type: "text", text: `UI Session Messages (${pending.length} sessions). ${formatMcpResultReference(artifact.path)}${warnings.length ? `\nHistory persistence warning: ${warnings.join("; ")}` : ""}` }], details: { sessions: pending.length, resultRef: artifact.path, historyRefs: pending.flatMap(session => session.messages.historyRef ? [session.messages.historyRef] : []), cleared: true } };
+    };
+    if (large)
+        return paged();
+    let sessions;
+    try {
+        sessions = await Promise.all(pending.map(async (session) => ({ ...session, messages: await materializeUiMessages(session.messages) })));
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: `UI messages remain available; history could not be read: ${String(error)}` }], isError: true, details: { error: "ui_history_delivery_failed", cleared: false } };
+    }
     if (sessions.length === 0) {
         return {
             content: [{ type: "text", text: "No UI session messages available." }],
@@ -183,9 +256,8 @@ export function executeUiMessages(state) {
         }
     }
     const count = sessions.length;
-    state.completedUiSessions = [];
-    return {
-        content: [{ type: "text", text: output.join("\n") }],
+    const inline = {
+        content: [{ type: "text", text: output.join("\n") + (warnings.length ? `\nHistory persistence warning: ${warnings.join("; ")}` : "") }],
         details: {
             sessions: count,
             prompts: allPrompts,
@@ -195,6 +267,11 @@ export function executeUiMessages(state) {
             cleared: true,
         },
     };
+    const text = inline.content.map(block => block.type === "text" ? block.text : "").join("\n");
+    if (Buffer.byteLength(JSON.stringify(inline.details)) > options.detailsMaxBytes || Buffer.byteLength(text) > options.maxBytes || text.split("\n").length > options.maxLines)
+        return paged();
+    state.completedUiSessions = state.completedUiSessions.filter(session => !pending.includes(session));
+    return inline;
 }
 export function executeStatus(state) {
     const servers = [];
@@ -699,7 +776,7 @@ export async function runToolCall(state, serverName, target, args, options) {
             beforeDispatchPending = false;
         }
         throwIfAborted(callerSignal);
-        // Host checkpoints and UI preparation do not consume the service deadline.
+        // Approval and UI preparation do not consume the service deadline.
         const ownedSignal = combineAbortSignals(callerSignal, AbortSignal.timeout(Math.ceil(configuredOptions?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC)));
         const requestOptions = { ...configuredOptions, signal: ownedSignal };
         const recovery = { manager: state.manager, config: state.config, signal: ownedSignal, onNeedsAuth: recoverAuthConnection };
@@ -735,7 +812,7 @@ export async function runToolCall(state, serverName, target, args, options) {
         if (options.raw) {
             const message = isError
                 ? (Array.isArray(record.content) ? record.content.filter(block => block.type === "text").map(block => block.text).join("\n") : "") || "Tool execution failed" : undefined;
-            return { content: [], details: { ...details, ...retained, ...(message ? { message } : {}) } };
+            return { content: [], ...(isError ? { isError: true } : {}), details: { ...details, ...retained, ...(message ? { message } : {}) } };
         }
         const content = renderMcpResultContent(record, retained.payloadFiles);
         const guarded = await guardMcpOutput(content.length ? content : [{ type: "text", text: target.resourceUri ? "(empty resource)" : "(empty result)" }], {
@@ -743,7 +820,7 @@ export async function runToolCall(state, serverName, target, args, options) {
             ...(isError ? { prefix: "Error: ", suffix: schemaSuffix(), emptyTextFallback: "Tool execution failed" }
                 : uiSummary ? { suffix: `\n\n${uiSummary.message}` } : {}),
         });
-        return { content: guarded.content, details: { ...details, ...guardedMcpDetails(guarded) } };
+        return { content: guarded.content, ...(isError ? { isError: true } : {}), details: { ...details, ...guardedMcpDetails(guarded) } };
     }
     catch (error) {
         // Direct/proxy host errors throw; scripts retain their failed-call envelope.
@@ -759,6 +836,7 @@ export async function runToolCall(state, serverName, target, args, options) {
                 ? await retainMcpResult(captureFailure.result, { ...outputGuardOptions, enabled: true, detailsMaxBytes: 1 }) : {};
             return {
                 content: [{ type: "text", text: message }, ...(retained.resultRef ? [{ type: "text", text: formatMcpResultReference(retained.resultRef) }] : [])],
+                isError: true,
                 details: { ...detailsBase, ...retained, error: isAbortError(error, callerSignal) ? "aborted" : "call_capture_failed", message, recovery: context },
             };
         }
@@ -767,6 +845,7 @@ export async function runToolCall(state, serverName, target, args, options) {
             uiSession?.sendToolCancelled(message);
             return {
                 content: [{ type: "text", text: message }],
+                isError: true,
                 details: { ...detailsBase, error: "ambiguous_outcome", message, recovery: { ...identity, action: "readback" } },
             };
         }
@@ -794,6 +873,7 @@ export async function runToolCall(state, serverName, target, args, options) {
         const guarded = await guardMcpOutput([{ type: "text", text: message }], { ...outputGuardOptions, prefix: "Failed to call tool: ", suffix: schemaSuffix() });
         return {
             content: guarded.content,
+            isError: true,
             details: {
                 ...detailsBase,
                 error: isAbortError(error, callerSignal) ? "aborted" : "call_failed",

package/dist/runtime-owner.d.ts

@@ -1,4 +1,3 @@
-import type { McpCheckpointEvent } from "./checkpoint.ts";
 import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 export interface McpRuntimeOwner {
     readonly signal: AbortSignal;
@@ -6,10 +5,7 @@ export interface McpRuntimeOwner {
     addCleanup(cleanup: () => void | Promise<void>): void;
     stop(reason?: string): Promise<void>;
     throwIfInactive(): void;
-    beforeActivity(): void;
-    holdCheckpoint(event: McpCheckpointEvent): () => void;
     runCallback<T>(kind: "beforeExecute" | "onToolCall", run: () => Promise<T>): Promise<T>;
-    getCheckpointBlocker(): string | undefined;
 }
 export declare function createMcpRuntimeOwner(): McpRuntimeOwner;
 export declare function combineAbortSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined;