@fitchmultz/pi-mcp-adapter 7.1.0 → 8.0.0

package/dist/tool-loader.js

@@ -4,21 +4,13 @@ import { isServerCacheValid, reconstructToolMetadata } from "./metadata-cache.js
 import { createMcpDirectToolCallRenderer, renderMcpToolResult } from "./tool-result-renderer.js";
 import { isServerDisabled } from "./types.js";
 import { normalizeDirectToolInputSchema } from "./utils.js";
-import { isToolCallApprovalRequired } from "./tool-approval.js";
-const featureRefs = { gateway: { name: "mcp" }, script: { name: "mcp_script" } };
+import { nativeMcpOutputSchema } from "./tool-registrar.js";
+import { toolErrorOverride } from "./error-signal.js";
+const featureNames = { gateway: "mcp", script: "mcp_script" };
 const ENTRY = "mcp-tool-selection";
 const key = (value) => JSON.stringify([value.server, value.tool]);
-const refKey = (value) => JSON.stringify([value.namespace ?? null, value.name]);
 const reserved = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls", "mcp", "mcp_search", "mcp_script"]);
-export function supportsNativeAsync(ctx) {
-    const compat = ctx.model?.compat;
-    return "getPendingToolCalls" in ctx && typeof ctx.getPendingToolCalls === "function"
-        && !!compat && "supportsAsyncTools" in compat && compat.supportsAsyncTools === true;
-}
 export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
-    const native = typeof pi.registerToolSearch === "function"
-        && typeof pi.getActiveToolReferences === "function"
-        && typeof pi.setActiveToolReferences === "function";
     pi.registerEntryRenderer(ENTRY, () => undefined);
     const registered = new Map();
     let available = new Set();
@@ -29,24 +21,24 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
     let inactiveFeatures = new Set();
     const registeredFeatures = new Set();
     let restoring = true;
-    const active = () => native ? pi.getActiveToolReferences() : pi.getActiveTools().map(name => ({ name }));
-    const setActive = (refs) => {
-        const unique = [...new Map(refs.map(ref => [refKey(ref), ref])).values()];
+    const active = () => pi.getActiveTools();
+    const setActive = (names) => {
+        const unique = [...new Set(names)];
         if (JSON.stringify(active()) === JSON.stringify(unique))
             return;
-        if (native)
-            pi.setActiveToolReferences(unique);
-        else
-            pi.setActiveTools(unique.map(ref => ref.name));
+        pi.setActiveTools(unique);
     };
     function registerFeature(feature, definition) {
-        pi.registerTool(definition);
+        pi.registerTool({ defaultActive: false, ...definition, async execute(...args) {
+                const result = await definition.execute(...args);
+                return { ...result, ...toolErrorOverride(result.details) };
+            } });
         registeredFeatures.add(feature);
     }
     function capture() {
-        const current = new Set(active().map(refKey));
+        const current = new Set(active());
         for (const feature of Object.keys(features)) {
-            if (current.has(refKey(featureRefs[feature]))) {
+            if (current.has(featureNames[feature])) {
                 if (!features[feature]?.eager)
                     selectedFeatures.add(feature);
                 inactiveFeatures.delete(feature);
@@ -57,10 +49,10 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                     inactiveFeatures.add(feature);
             }
         }
-        for (const [id, { selection, ref, pinned }] of registered) {
+        for (const [id, { selection, name, pinned }] of registered) {
             if (!available.has(id))
                 continue;
-            if (current.has(refKey(ref))) {
+            if (current.has(name)) {
                 if (!pinned)
                     selected.set(id, selection);
                 inactive.delete(id);
@@ -81,10 +73,25 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
         inactive = new Map();
         selectedFeatures = new Set();
         inactiveFeatures = new Set();
-        for (const entry of ctx.sessionManager.getBranch()) {
-            if (entry.type !== "custom" || entry.customType !== ENTRY || !entry.data || typeof entry.data !== "object")
+        const manager = ctx.sessionManager;
+        function* snapshots() {
+            let id = manager.getLeafId();
+            while (id) {
+                const entry = manager.getEntry(id);
+                if (!entry)
+                    break;
+                yield entry;
+                id = entry.parentId;
+            }
+        }
+        for (const entry of snapshots()) {
+            if (entry?.type !== "custom" || entry.customType !== ENTRY || !entry.data || typeof entry.data !== "object")
                 continue;
             const data = entry.data;
+            if (!Array.isArray(data.selected) || [data.inactive, data.features, data.inactiveFeatures].some(value => value !== undefined && !Array.isArray(value)))
+                continue;
+            if ([...data.selected, ...(data.inactive ?? [])].some(value => !value || typeof value.server !== "string" || typeof value.tool !== "string"))
+                continue;
             selectedFeatures = new Set(Array.isArray(data.features) ? data.features.filter(value => value === "gateway" || value === "script") : []);
             inactiveFeatures = new Set(Array.isArray(data.inactiveFeatures) ? data.inactiveFeatures.filter(value => value === "gateway" || value === "script") : []);
             for (const [field, target] of [[data.selected, selected], [data.inactive, inactive]]) {
@@ -94,14 +101,15 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                         target.set(key(selection), selection);
                 }
             }
+            break;
         }
         restoring = true;
     }
-    function sync(config, cache, env, asyncSupported = false, registerGateways) {
+    function sync(config, cache, env, registerGateways) {
         if (!restoring)
             capture();
-        const previousRefs = new Set([...registered.values()].map(item => refKey(item.ref)));
-        const existing = new Set(pi.getAllTools().map(tool => refKey(tool)));
+        const previousNames = new Set([...registered.values()].map(item => item.name));
+        const existing = new Set(pi.getAllTools().map(tool => tool.name));
         const specs = [];
         for (const [server, definition] of Object.entries(env === null ? {} : config.mcpServers)) {
             if (isServerDisabled(definition))
@@ -114,27 +122,34 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                 if (tool.resourceUri)
                     continue;
                 const pinned = selection === true || (Array.isArray(selection) && selection.includes(tool.originalName));
-                const ref = native && !pinned ? { namespace: `mcp_${server}`, name: tool.originalName } : { name: prefixedName };
-                specs.push({ spec: { ...tool, prefixedName, serverName: server }, selection: { server, tool: tool.originalName }, ref, pinned });
+                specs.push({ spec: { ...tool, prefixedName, serverName: server }, selection: { server, tool: tool.originalName }, name: prefixedName, pinned });
             }
         }
         const counts = new Map();
-        for (const { ref } of specs)
-            counts.set(refKey(ref), (counts.get(refKey(ref)) ?? 0) + 1);
+        for (const { name } of specs)
+            counts.set(name, (counts.get(name) ?? 0) + 1);
         available = new Set();
         const enabled = [];
-        for (const { spec, selection, ref, pinned } of specs) {
+        for (const { spec, selection, name, pinned } of specs) {
             const id = key(selection);
-            const refId = refKey(ref);
-            if ((!ref.namespace && reserved.has(ref.name)) || counts.get(refId) > 1 || (existing.has(refId) && !previousRefs.has(refId)))
+            if (reserved.has(name) || counts.get(name) > 1 || (existing.has(name) && !previousNames.has(name)))
                 continue;
             available.add(id);
-            const asyncTool = asyncSupported && !beforeExecute && !spec.uiResourceUri && !isToolCallApprovalRequired(config, spec.serverName, spec);
-            const fingerprint = JSON.stringify({ spec, ref, asyncTool });
+            const instructions = getState()?.serverInstructions.get(spec.serverName) ?? cache?.servers[spec.serverName]?.instructions;
+            const fingerprint = JSON.stringify({ spec, name, instructions });
             if (registered.get(id)?.fingerprint !== fingerprint) {
                 pi.registerTool({
-                    ...ref,
-                    ...(asyncTool ? { async: true } : {}),
+                    name,
+                    namespace: { name: `mcp_${spec.serverName}`, ...(instructions !== undefined ? { instructions } : {}) },
+                    ...(spec.outputSchema ? { outputSchema: nativeMcpOutputSchema(spec.outputSchema) } : {}),
+                    ...(spec.annotations ? { annotations: {
+                            ...(typeof spec.annotations.readOnlyHint === "boolean" ? { readOnlyHint: spec.annotations.readOnlyHint } : {}),
+                            ...(typeof spec.annotations.destructiveHint === "boolean" ? { destructiveHint: spec.annotations.destructiveHint } : {}),
+                            ...(typeof spec.annotations.idempotentHint === "boolean" ? { idempotentHint: spec.annotations.idempotentHint } : {}),
+                            ...(typeof spec.annotations.openWorldHint === "boolean" ? { openWorldHint: spec.annotations.openWorldHint } : {}),
+                        } } : {}),
+                    // Inactive direct tools are not callable through codemode or nested execution.
+                    defaultActive: false,
                     ...(beforeExecute ? { executionMode: "sequential" } : {}),
                     label: spec.title ?? `MCP: ${spec.originalName}`,
                     description: spec.description || "(no description)",
@@ -144,22 +159,22 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                     renderResult: renderMcpToolResult,
                 });
             }
-            registered.set(id, { selection, ref, fingerprint, pinned });
+            registered.set(id, { selection, name, fingerprint, pinned });
             if (selected.has(id) || (pinned && !inactive.has(id)))
-                enabled.push(ref);
+                enabled.push(name);
         }
-        const permitted = new Set(pi.getAllTools().map(refKey));
-        const pins = specs.filter(item => item.pinned && available.has(key(item.selection)) && permitted.has(refKey(item.ref))).map(item => item.spec);
+        const permitted = new Set(pi.getAllTools().map(tool => tool.name));
+        const pins = specs.filter(item => item.pinned && available.has(key(item.selection)) && permitted.has(item.name)).map(item => item.spec);
         const policy = registerGateways?.(pins);
         if (policy) {
-            const permittedFeatures = new Set(pi.getAllTools().map(refKey));
-            const loaderMissing = !permittedFeatures.has(refKey({ name: "mcp_search" }));
+            const permittedFeatures = new Set(pi.getAllTools().map(tool => tool.name));
+            const loaderMissing = !permittedFeatures.has("mcp_search");
             features = {};
-            for (const feature of Object.keys(featureRefs)) {
-                if (policy[feature] && permittedFeatures.has(refKey(featureRefs[feature]))) {
+            for (const feature of Object.keys(featureNames)) {
+                if (policy[feature] && permittedFeatures.has(featureNames[feature])) {
                     features[feature] = { eager: policy[feature].eager || loaderMissing };
                     if (selectedFeatures.has(feature) || (features[feature]?.eager && !inactiveFeatures.has(feature)))
-                        enabled.push(featureRefs[feature]);
+                        enabled.push(featureNames[feature]);
                 }
                 else {
                     selectedFeatures.delete(feature);
@@ -167,11 +182,11 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                 }
             }
         }
-        // Official 0.87 reactivates allowlisted definitions on registration. Apply our loadout last.
-        const ownedRefs = new Set([...previousRefs, ...[...registered.values()].map(item => refKey(item.ref))]);
+        // Retain the journal: official 1.0 initial SDK resume has a native loadout restoration gap.
+        const ownedNames = new Set([...previousNames, ...[...registered.values()].map(item => item.name)]);
         for (const feature of registeredFeatures)
-            ownedRefs.add(refKey(featureRefs[feature]));
-        setActive([...active().filter(ref => !ownedRefs.has(refKey(ref))), ...enabled]);
+            ownedNames.add(featureNames[feature]);
+        setActive([...active().filter(name => !ownedNames.has(name)), ...enabled]);
         restoring = false;
         return pins;
     }
@@ -182,22 +197,22 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
             return registration ? [registration] : [];
         });
         // No await between reading and extending the current loadout: parallel searches union their selections.
-        const permitted = new Set(pi.getAllTools().map(refKey));
-        const requestedFeatures = [...new Set(enable)].filter(feature => features[feature] && permitted.has(refKey(featureRefs[feature])));
-        setActive([...active(), ...requested.map(item => item.ref), ...requestedFeatures.map(feature => featureRefs[feature])]);
-        const current = new Set(active().map(refKey));
-        const tools = requested.filter(item => current.has(refKey(item.ref))).map(({ selection, ref }) => {
+        const permitted = new Set(pi.getAllTools().map(tool => tool.name));
+        const requestedFeatures = [...new Set(enable)].filter(feature => features[feature] && permitted.has(featureNames[feature]));
+        setActive([...active(), ...requested.map(item => item.name), ...requestedFeatures.map(feature => featureNames[feature])]);
+        const current = new Set(active());
+        const tools = requested.filter(item => current.has(item.name)).map(({ selection, name }) => {
             selected.set(key(selection), selection);
-            return ref;
+            return { name };
         });
         for (const feature of requestedFeatures) {
-            if (!current.has(refKey(featureRefs[feature])))
+            if (!current.has(featureNames[feature]))
                 continue;
             selectedFeatures.add(feature);
-            tools.push(featureRefs[feature]);
+            tools.push({ name: featureNames[feature] });
         }
         persist();
         return tools;
     }
-    return { native, registerFeature, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
+    return { registerFeature, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
 }

package/dist/tool-registrar.d.ts

@@ -1,5 +1,16 @@
 import type { McpContent, ContentBlock } from "./types.ts";
 import { type McpPayloadFile } from "./mcp-output-guard.ts";
+import { Type } from "typebox";
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+/** Overflow/not-run outcomes are receipts, never a fabricated server-schema result. */
+export declare function nativeMcpOutputSchema(schema: Record<string, unknown>): Type.TUnion<[Type.TUnsafe<unknown>, Type.TObject<{
+    mcpAdapter: Type.TObject<{
+        omitted: Type.TLiteral<true>;
+        resultRef: Type.TOptional<Type.TString>;
+        error: Type.TOptional<Type.TString>;
+    }>;
+}>]>;
+export declare function nativeMcpResult(result: AgentToolResult<Record<string, unknown>>, structured?: boolean): AgentToolResult<Record<string, unknown>>;
 /**
  * Transform MCP content types to Pi content blocks.
  */

package/dist/tool-registrar.js

@@ -1,5 +1,28 @@
 // MCP protocol content to model-visible content.
 import { formatMcpPayloadFile } from "./mcp-output-guard.js";
+import { Type } from "typebox";
+import { toolErrorOverride } from "./error-signal.js";
+/** Overflow/not-run outcomes are receipts, never a fabricated server-schema result. */
+export function nativeMcpOutputSchema(schema) {
+    return Type.Union([Type.Unsafe(schema), Type.Object({
+            mcpAdapter: Type.Object({
+                omitted: Type.Literal(true),
+                resultRef: Type.Optional(Type.String()),
+                error: Type.Optional(Type.String()),
+            }),
+        })]);
+}
+export function nativeMcpResult(result, structured = false) {
+    const { details } = result;
+    const raw = details.mcpResult;
+    return {
+        ...result,
+        ...toolErrorOverride(details),
+        ...(structured ? { structuredContent: !details.outputGuard && (!details.error || details.error === "tool_error") && raw?.structuredContent !== undefined
+                ? raw.structuredContent
+                : { mcpAdapter: { omitted: true, ...(typeof details.resultRef === "string" ? { resultRef: details.resultRef } : {}), ...(typeof details.error === "string" ? { error: details.error } : {}) } } } : {}),
+    };
+}
 /**
  * Transform MCP content types to Pi content blocks.
  */

package/dist/types.d.ts

@@ -136,6 +136,11 @@ export declare function parseUiPromptHandoff(prompt: string): UiPromptHandoff |
  * Collected during the session and available when it ends.
  */
 export interface UiSessionMessages {
+    /** Private JSONL history, readable with the normal paged result reader. */
+    historyRef?: string;
+    historyBytes?: number;
+    historyCount?: number;
+    historyError?: string;
     prompts: string[];
     notifications: string[];
     intents: Array<{

package/dist/ui-message-history.d.ts

@@ -0,0 +1,11 @@
+import type { UiSessionMessages } from "./types.ts";
+type Category = "prompts" | "intents" | "notifications";
+type Message = string | UiSessionMessages["intents"][number];
+/** Private append-only history; failed writes stay owned in memory, never silently discarded. */
+export declare function createUiMessageHistory(outputDirectory?: string): {
+    messages: UiSessionMessages;
+    append(category: Category, value: Message): string | undefined;
+};
+export declare function uiMessages(messages: UiSessionMessages, category: Category): AsyncGenerator<Message>;
+export declare function materializeUiMessages(messages: UiSessionMessages): Promise<UiSessionMessages>;
+export {};

package/dist/ui-message-history.js

@@ -0,0 +1,81 @@
+import { appendFileSync, createReadStream, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { randomBytes } from "node:crypto";
+import { createInterface } from "node:readline";
+/** Private append-only history; failed writes stay owned in memory, never silently discarded. */
+export function createUiMessageHistory(outputDirectory) {
+    const messages = { prompts: [], intents: [], notifications: [], contexts: [] };
+    let failed = false;
+    return {
+        messages,
+        append(category, value) {
+            try {
+                if (failed)
+                    throw new Error(messages.historyError);
+                if (!messages.historyRef) {
+                    const root = outputDirectory === undefined ? tmpdir() : resolve(outputDirectory);
+                    if (outputDirectory !== undefined)
+                        mkdirSync(root, { recursive: true, mode: 0o700 });
+                    const dir = mkdtempSync(join(root, "pi-mcp-output-"));
+                    const ref = join(dir, `output-${randomBytes(4).toString("hex")}.txt`);
+                    writeFileSync(ref, "", { mode: 0o600 });
+                    messages.historyRef = ref;
+                    messages.historyBytes = 0;
+                    messages.historyCount = 0;
+                }
+                const line = JSON.stringify({ category, value }) + "\n";
+                // ponytail: synchronous append owns acceptance order; upgrade to an awaited serial writer if local disk latency becomes material.
+                appendFileSync(messages.historyRef, line, { flush: true });
+                messages.historyBytes += Buffer.byteLength(line);
+                messages.historyCount++;
+                return undefined;
+            }
+            catch (error) {
+                failed = true;
+                messages.historyError = error instanceof Error ? error.message : String(error);
+                if (category === "intents")
+                    messages.intents.push(value);
+                else
+                    messages[category].push(value);
+                return `UI history could not be saved; messages remain in memory for recovery: ${messages.historyError}. Unsaved messages will be lost on reload or process exit.`;
+            }
+        },
+    };
+}
+export async function* uiMessages(messages, category) {
+    if (messages.historyRef && messages.historyBytes) {
+        // A failed partial append is not an accepted event; the in-memory tail owns it instead.
+        const input = createReadStream(messages.historyRef, { encoding: "utf8", end: messages.historyBytes - 1 });
+        let bytes = 0, count = 0;
+        input.on("data", chunk => { bytes += Buffer.byteLength(chunk); });
+        const lines = createInterface({ input, crlfDelay: Infinity });
+        try {
+            for await (const line of lines) {
+                const record = JSON.parse(line);
+                count++;
+                if (record.category === category)
+                    yield record.value;
+            }
+            if (bytes !== messages.historyBytes || (messages.historyCount !== undefined && count !== messages.historyCount)) {
+                throw new Error("UI history is incomplete; accepted messages remain pending recovery");
+            }
+        }
+        finally {
+            lines.close();
+            input.destroy();
+        }
+    }
+    for (const value of messages[category])
+        yield value;
+}
+export async function materializeUiMessages(messages) {
+    const result = { prompts: [], intents: [], notifications: [], contexts: messages.contexts };
+    for await (const value of uiMessages(messages, "prompts"))
+        result.prompts.push(value);
+    for await (const value of uiMessages(messages, "intents"))
+        result.intents.push(value);
+    for await (const value of uiMessages(messages, "notifications"))
+        result.notifications.push(value);
+    return result;
+}

package/dist/ui-server.js

@@ -10,6 +10,7 @@ import { logger } from "./logger.js";
 import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
 import { extractUiToolVisibility, isUiToolCallableByApp } from "./ui-tool-visibility.js";
+import { createUiMessageHistory } from "./ui-message-history.js";
 import { createUiModelContextUpdate, extractUiPromptText, getVisualizationStreamEnvelope, isServerDisabled, isToolAllowed, resolveToolPrefix, } from "./types.js";
 const MAX_BODY_SIZE = 2 * 1024 * 1024;
 const ABANDONED_GRACE_MS = 60_000;
@@ -38,12 +39,8 @@ export async function startUiServer(options) {
     const eventLog = [];
     let streamSummary;
     // Track messages from UI for retrieval
-    const sessionMessages = {
-        prompts: [],
-        notifications: [],
-        intents: [],
-        contexts: [],
-    };
+    const history = createUiMessageHistory(options.state?.outputDirectory);
+    const sessionMessages = history.messages;
     const hostContext = {
         displayMode: currentDisplayMode,
         availableDisplayModes: ["inline", "fullscreen", "pip"],
@@ -281,6 +278,11 @@ export async function startUiServer(options) {
                 return;
             if (!validateTokenBody(body, sessionToken, res))
                 return;
+            // A partial upload is not accepted until its authenticated body is complete.
+            if (completed && (url.pathname === "/proxy/ui/message" || url.pathname === "/proxy/ui/context")) {
+                sendJson(res, 409, { ok: false, error: "UI session is complete; message was not accepted" });
+                return;
+            }
             const params = body.params ?? {};
             touchHeartbeat();
             if (url.pathname === "/proxy/tools/call") {
@@ -376,14 +378,15 @@ export async function startUiServer(options) {
                 const promptText = extractUiPromptText(msgParams);
                 // Track messages by type (order: prompt → intent → notify)
                 // Must match the order in index.ts onMessage handler
+                let warning;
                 if (promptText) {
-                    sessionMessages.prompts.push(promptText);
+                    warning = history.append("prompts", promptText);
                     log.debug("UI prompt received", { prompt: promptText.slice(0, 100) });
                 }
                 else if (msgParams.type === "intent" || msgParams.intent) {
                     const intentName = msgParams.intent ?? "";
                     if (intentName) {
-                        sessionMessages.intents.push({
+                        warning = history.append("intents", {
                             intent: intentName,
                             ...(msgParams.params !== undefined ? { params: msgParams.params } : {}),
                         });
@@ -393,12 +396,16 @@ export async function startUiServer(options) {
                 else if (msgParams.type === "notify" || msgParams.message) {
                     const notifyText = msgParams.message ?? "";
                     if (notifyText) {
-                        sessionMessages.notifications.push(notifyText);
+                        warning = history.append("notifications", notifyText);
                         log.debug("UI notification", { message: notifyText.slice(0, 100) });
                     }
                 }
                 await options.onMessage?.(msgParams);
-                sendJson(res, 200, { ok: true, result: {} });
+                if (warning) {
+                    log.warn(warning);
+                    options.state?.ui?.notify(warning, "warning");
+                }
+                sendJson(res, 200, { ok: true, result: {}, ...(warning ? { warning } : {}) });
                 return;
             }
             if (url.pathname === "/proxy/ui/context") {

package/dist/ui-session.js

@@ -297,7 +297,8 @@ export async function maybeStartUiSession(state, request) {
                 if (state.uiServer === handle) {
                     const messages = handle.getSessionMessages();
                     const stream = handle.getStreamSummary();
-                    const hasContent = messages.prompts.length > 0 ||
+                    const hasContent = !!messages.historyCount ||
+                        messages.prompts.length > 0 ||
                         messages.intents.length > 0 ||
                         messages.notifications.length > 0 ||
                         messages.contexts.length > 0 ||
@@ -316,7 +317,7 @@ export async function maybeStartUiSession(state, request) {
                         }
                         log.debug("Session completed", {
                             reason,
-                            prompts: messages.prompts.length,
+                            prompts: messages.historyCount ?? messages.prompts.length,
                             intents: messages.intents.length,
                             notifications: messages.notifications.length,
                             contexts: messages.contexts.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitchmultz/pi-mcp-adapter",
-  "version": "7.1.0",
+  "version": "8.0.0",
   "description": "Fitch's independently maintained MCP adapter for Pi coding agent",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -35,7 +35,7 @@
     "build:bridge": "node ./scripts/build-app-bridge.mjs",
     "prepare": "node ./scripts/prepare.mjs",
     "check:compat": "node scripts/compat-host.mjs && npm run build && npm run typecheck && vitest run --exclude __tests__/interactive-visualizer-server.test.ts && npm run test:oauth && node scripts/compat-package-smoke.mjs",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "node ./scripts/tsc.mjs --noEmit",
     "test": "vitest run && npm run test:oauth",
     "test:watch": "vitest",
     "test:oauth": "PI_MCP_ADAPTER_TEST_AUTH_STORE=memory node --test --test-concurrency=1 mcp-auth.test.ts mcp-auth-flow.test.ts mcp-callback-server.test.ts mcp-oauth-provider.test.ts",
@@ -76,9 +76,9 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@modelcontextprotocol/client": "2.1.0",
-    "@modelcontextprotocol/core": "2.1.0",
-    "@modelcontextprotocol/ext-apps": "2.0.0",
+    "@modelcontextprotocol/client": "2.2.0",
+    "@modelcontextprotocol/core": "2.2.0",
+    "@modelcontextprotocol/ext-apps": "2.0.3",
     "@napi-rs/keyring": "2.1.0",
     "cross-spawn": "7.0.6",
     "minisearch": "7.2.0",
@@ -108,16 +108,16 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.87.1",
-    "@earendil-works/pi-coding-agent": "0.87.1",
-    "@earendil-works/pi-tui": "0.87.1",
-    "@modelcontextprotocol/server": "2.1.0",
+    "@earendil-works/pi-ai": "1.0.0",
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
+    "@modelcontextprotocol/server": "2.2.0",
     "@types/cross-spawn": "6.0.6",
     "@types/node": "24.19.0",
     "esbuild": "0.28.2",
-    "typebox": "1.3.34",
+    "typebox": "1.3.27",
     "typescript": "7.0.2",
-    "vitest": "5.0.2"
+    "vitest": "5.0.3"
   },
-  "packageManager": "npm@12.1.0"
+  "packageManager": "npm@12.2.0"
 }

package/dist/checkpoint.d.ts

@@ -1,18 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { McpExtensionState } from "./state.ts";
-/** Optional host event. Published Pi hosts without this event simply never emit it.
- * Keep its structural typing local; do not require a private host package/version. */
-export interface McpCheckpointEvent {
-    readonly boundary: "turn" | "settled";
-    readonly signal: AbortSignal;
-    invalidate(): void;
-}
-export type McpCheckpointResult = {
-    sleepReady: true;
-} | {
-    sleepReady: false;
-    reason: string;
-};
-export declare function onSessionCheckpoint(pi: ExtensionAPI, handler: (event: McpCheckpointEvent) => Promise<McpCheckpointResult>): void;
-/** No shutdown, credential copying, connection replay or permanent owner cancellation. */
-export declare function prepareMcpCheckpoint(state: McpExtensionState, event: McpCheckpointEvent): Promise<McpCheckpointResult>;

package/dist/checkpoint.js

@@ -1,53 +0,0 @@
-import { flushMetadataCache } from "./init.js";
-import { getOAuthCheckpointBlocker, holdOAuthCheckpoint } from "./mcp-auth-flow.js";
-import { isServerDisabled } from "./types.js";
-export function onSessionCheckpoint(pi, handler) {
-    pi.on("session_checkpoint", handler);
-}
-/** No shutdown, credential copying, connection replay or permanent owner cancellation. */
-export async function prepareMcpCheckpoint(state, event) {
-    event.signal.throwIfAborted();
-    const releases = [];
-    const release = () => { for (const undo of releases.splice(0).reverse())
-        undo(); };
-    // Fence all owned sources synchronously, before the first await (including trace flush).
-    event.signal.addEventListener("abort", release, { once: true });
-    const undo = () => { release(); event.signal.removeEventListener("abort", release); };
-    const blocked = (reason) => { undo(); return { sleepReady: false, reason }; };
-    try {
-        releases.push(state.owner.holdCheckpoint(event));
-        releases.push(state.manager.holdCheckpoint(event));
-        releases.push(holdOAuthCheckpoint(state.oauthRuntime, event));
-        releases.push(state.lifecycle.pauseForCheckpoint());
-        if (state.lifecycle.hasActiveHealthCheck())
-            return blocked("MCP health check is active");
-        for (const [name, definition] of Object.entries(state.config.mcpServers)) {
-            if (!isServerDisabled(definition) && !definition.url)
-                return blocked(`MCP ${name}: stdio/Unix server state is not reconstructible`);
-        }
-        const callback = state.owner.getCheckpointBlocker();
-        if (callback)
-            return blocked(callback);
-        if (state.activeScripts)
-            return blocked("MCP script is active");
-        if (state.uiServer || state.completedUiSessions.length)
-            return blocked("MCP UI session/messages require the running runtime");
-        if (state.approvedToolCalls.size || state.consentManager.hasDecisions())
-            return blocked("MCP session approvals are not persisted");
-        const oauth = getOAuthCheckpointBlocker(state.oauthRuntime);
-        if (oauth)
-            return blocked(oauth);
-        const manager = state.manager.getCheckpointBlocker();
-        if (manager)
-            return blocked(manager);
-        flushMetadataCache(state);
-        await state.manager.flushForCheckpoint();
-        event.signal.throwIfAborted();
-        // Release/cancellation is host-owned. Existing clients/timers remain usable afterwards.
-        return { sleepReady: true };
-    }
-    catch (error) {
-        undo();
-        throw error;
-    }
-}