@getpaseo/server 0.1.80 → 0.1.82

package/dist/server/server/agent/providers/pi/agent.js

@@ -7,13 +7,18 @@ import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { composeSystemPromptParts } from "../../system-prompt.js";
 import { findExecutable } from "../../../../utils/executable.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
-import { streamPiHistory } from "./history-mapper.js";
+import { getUserMessageText, streamPiHistory, } from "./history-mapper.js";
 import { PiCliRuntime } from "./cli-runtime.js";
-import { listPiPersistedAgents } from "./session-descriptor.js";
+import { revertPiConversation } from "./rewind.js";
 import { mapToolDetail, parseToolArgs, parseToolResult, resolveToolCallName, } from "./tool-call-mapper.js";
 const PI_PROVIDER = "pi";
 const DEFAULT_PI_THINKING_LEVEL = "medium";
 const PI_BINARY_COMMAND = process.env.PI_COMMAND ?? process.env.PI_ACP_PI_COMMAND ?? "pi";
+const PASEO_PI_TREE_EXTENSION_COMMAND = "paseo_tree";
+const PASEO_PI_CAPTURE_EXTENSION_COMMAND = "paseo_capture_entries";
+const PASEO_PI_ENTRY_CAPTURE_MARKER = "PASEO_ENTRY_CAPTURE";
+const PASEO_PI_COMMAND_RESULT_MARKER = "PASEO_COMMAND_RESULT";
+const PASEO_PI_EXTENSION_RESULT_TIMEOUT_MS = 10000;
 const PI_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -21,6 +26,9 @@ const PI_CAPABILITIES = {
     supportsMcpServers: false,
     supportsReasoningStream: true,
     supportsToolInvocations: true,
+    supportsRewindConversation: true,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
 };
 const PI_THINKING_OPTIONS = [
     { id: "off", label: "Off", description: "No extra reasoning" },
@@ -211,6 +219,103 @@ function createPiMcpConfigFile(servers) {
         cleanup: () => rmSync(dir, { recursive: true, force: true }),
     };
 }
+function createPiPaseoExtensionFile() {
+    const dir = mkdtempSync(join(tmpdir(), "paseo-pi-extension-"));
+    const filePath = join(dir, "paseo-integration.mjs");
+    writeFileSync(filePath, `
+	function decodePayload(encoded) {
+	  return JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+	}
+
+	function readTextContent(content) {
+	  if (typeof content === "string") {
+	    return content;
+	  }
+	  if (!Array.isArray(content)) {
+	    return "";
+	  }
+	  return content
+	    .filter((part) => part && part.type === "text" && typeof part.text === "string")
+	    .map((part) => part.text)
+	    .join("\\n\\n");
+	}
+
+	function getCapturedUserEntries(ctx) {
+	  return ctx.sessionManager
+	    .getEntries()
+	    .filter((entry) => entry.type === "message" && entry.message?.role === "user")
+	    .map((entry) => ({
+	      id: entry.id,
+	      parentId: entry.parentId ?? null,
+	      text: readTextContent(entry.message.content),
+	    }));
+	}
+
+	function emitEntryCapture(ctx, reason, requestId) {
+	  ctx.ui.notify(
+	    "${PASEO_PI_ENTRY_CAPTURE_MARKER} " +
+	      JSON.stringify({ reason, requestId, entries: getCapturedUserEntries(ctx) }),
+	    "info",
+	  );
+	}
+
+	function emitCommandResult(ctx, requestId, result) {
+	  ctx.ui.notify(
+	    "${PASEO_PI_COMMAND_RESULT_MARKER} " + JSON.stringify({ requestId, ...result }),
+	    result.ok ? "info" : "error",
+	  );
+	}
+	
+	export default function paseoIntegration(pi) {
+	  pi.on("session_start", async (_event, ctx) => {
+	    emitEntryCapture(ctx, "session_start");
+	  });
+
+	  pi.on("turn_end", async (_event, ctx) => {
+	    emitEntryCapture(ctx, "turn_end");
+	  });
+
+	  pi.registerCommand("${PASEO_PI_CAPTURE_EXTENSION_COMMAND}", {
+	    description: "Internal Paseo entry capture bridge",
+	    handler: async (args, ctx) => {
+	      const payload = decodePayload(args.trim());
+	      emitEntryCapture(ctx, "command", payload.requestId);
+	    },
+	  });
+
+	  pi.registerCommand("${PASEO_PI_TREE_EXTENSION_COMMAND}", {
+	    description: "Internal Paseo tree navigation bridge",
+	    handler: async (args, ctx) => {
+	      const payload = decodePayload(args.trim());
+	      try {
+	        const result = await ctx.navigateTree(payload.targetId, { summarize: false });
+	        emitEntryCapture(ctx, "tree_navigation");
+	        emitCommandResult(ctx, payload.requestId, { ok: true, result });
+	      } catch (error) {
+	        const message = error instanceof Error ? error.message : String(error);
+	        emitCommandResult(ctx, payload.requestId, { ok: false, error: message });
+	        throw error;
+	      }
+	    },
+	  });
+	}
+`.trimStart(), "utf8");
+    return {
+        path: filePath,
+        cleanup: () => rmSync(dir, { recursive: true, force: true }),
+    };
+}
+function combineCleanup(cleanups) {
+    const activeCleanups = cleanups.filter((cleanup) => Boolean(cleanup));
+    if (activeCleanups.length === 0) {
+        return undefined;
+    }
+    return () => {
+        for (const cleanup of activeCleanups) {
+            cleanup();
+        }
+    };
+}
 function isPiMcpAdapterCommand(command) {
     if (command.source !== "extension" || !/^mcp(?::\d+)?$/.test(command.name)) {
         return false;
@@ -239,11 +344,163 @@ function resolveThinkingOptionId(cachedThinkingOptionId, sessionThinkingLevel) {
 function modelToId(model) {
     return model?.provider && model.id ? `${model.provider}/${model.id}` : null;
 }
+function piAssistantText(message) {
+    const text = message.content
+        .flatMap((part) => {
+        if (part.type === "text") {
+            return [part.text];
+        }
+        if (part.type === "thinking") {
+            return [part.thinking];
+        }
+        return [];
+    })
+        .join("\n\n")
+        .trim();
+    return text.length > 0 ? text : null;
+}
+function formatPiErrorMessage(message) {
+    const headline = message.errorMessage?.trim() || "Pi turn failed";
+    const details = [
+        message.stopReason ? `stopReason=${message.stopReason}` : null,
+        message.provider && message.model ? `model=${message.provider}/${message.model}` : null,
+        message.responseModel ? `responseModel=${message.responseModel}` : null,
+        message.responseId ? `responseId=${message.responseId}` : null,
+    ].filter((detail) => detail !== null);
+    const partialText = piAssistantText(message);
+    if (partialText) {
+        details.push(`partial=${JSON.stringify(partialText.slice(0, 500))}`);
+    }
+    return details.length > 0 ? `${headline} (${details.join(", ")})` : headline;
+}
 function latestPiErrorMessage(messages) {
     const latestAssistant = messages.findLast((message) => message.role === "assistant");
-    return latestAssistant && "errorMessage" in latestAssistant
-        ? (latestAssistant.errorMessage ?? null)
-        : null;
+    if (!latestAssistant || !latestAssistant.errorMessage?.trim()) {
+        return null;
+    }
+    return formatPiErrorMessage(latestAssistant);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function parseExtensionMarkerPayload(message, marker) {
+    const prefix = `${marker} `;
+    if (!message.startsWith(prefix)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(message.slice(prefix.length));
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseCapturedEntries(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const id = optionalString(entry.id)?.trim();
+        const text = optionalString(entry.text);
+        if (!id || text === undefined) {
+            return [];
+        }
+        const parentId = entry.parentId === null ? null : optionalString(entry.parentId)?.trim();
+        return [
+            {
+                id,
+                parentId: parentId || null,
+                text,
+            },
+        ];
+    });
+}
+function mapExtensionUiRequestToPermission(event) {
+    switch (event.method) {
+        case "select":
+            return buildExtensionUiQuestionPermission(event, {
+                question: optionalString(event.title) ?? "Select an option",
+                options: Array.isArray(event.options)
+                    ? event.options.filter((option) => typeof option === "string")
+                    : [],
+                multiSelect: false,
+            });
+        case "input":
+            return buildExtensionUiQuestionPermission(event, {
+                question: optionalString(event.title) ?? "Enter a value",
+                options: [],
+                multiSelect: false,
+            });
+        case "editor":
+            return buildExtensionUiQuestionPermission(event, {
+                question: optionalString(event.title) ?? "Edit text",
+                options: [],
+                multiSelect: false,
+            });
+        case "confirm":
+            return buildExtensionUiQuestionPermission(event, {
+                question: [optionalString(event.title), optionalString(event.message)]
+                    .filter(Boolean)
+                    .join("\n\n"),
+                options: ["Yes", "No"],
+                multiSelect: false,
+            });
+        default:
+            return null;
+    }
+}
+function buildExtensionUiQuestionPermission(event, input) {
+    const header = "Response";
+    return {
+        id: event.id,
+        provider: PI_PROVIDER,
+        name: `Pi ${event.method}`,
+        kind: "question",
+        title: input.question,
+        input: {
+            questions: [
+                {
+                    question: input.question,
+                    header,
+                    options: input.options.map((label) => ({ label })),
+                    multiSelect: input.multiSelect,
+                },
+            ],
+        },
+        metadata: {
+            extensionUiMethod: event.method,
+            answerHeader: header,
+        },
+    };
+}
+function firstPermissionAnswer(input) {
+    const answers = isRecord(input?.answers) ? input.answers : null;
+    if (!answers) {
+        return null;
+    }
+    const first = Object.values(answers).find((value) => typeof value === "string");
+    return typeof first === "string" ? first : null;
+}
+function buildExtensionUiResponse(request, response) {
+    if (response.behavior === "deny") {
+        return { cancelled: true };
+    }
+    const method = optionalString(request.metadata?.extensionUiMethod);
+    const answer = firstPermissionAnswer(response.updatedInput);
+    if (answer === null) {
+        return { cancelled: true };
+    }
+    if (method === "confirm") {
+        return { confirmed: /^yes$/i.test(answer.trim()) };
+    }
+    return { value: answer };
 }
 function mapPiModel(model) {
     return {
@@ -267,7 +524,13 @@ export class PiRpcAgentSession {
         this.provider = PI_PROVIDER;
         this.subscribers = new Set();
         this.activeToolCalls = new Map();
+        this.pendingExtensionUiRequests = new Map();
         this.activeTurnId = null;
+        this.capturedUserEntries = [];
+        this.capturedUserEntriesById = new Map();
+        this.seenUserEntryIds = new Set();
+        this.pendingUserMessages = [];
+        this.pendingExtensionResults = new Map();
         this.closed = false;
         this.runtimeSession = options.runtimeSession;
         this.config = options.config;
@@ -330,7 +593,8 @@ export class PiRpcAgentSession {
         };
     }
     async *streamHistory() {
-        yield* streamPiHistory(PI_PROVIDER, await this.runtimeSession.getMessages());
+        await this.requestEntryCapture("history");
+        yield* streamPiHistory(PI_PROVIDER, await this.runtimeSession.getMessages(), this.capturedUserEntries);
     }
     async getRuntimeInfo() {
         await this.refreshState();
@@ -353,11 +617,22 @@ export class PiRpcAgentSession {
         throw new Error("Pi does not expose selectable modes");
     }
     getPendingPermissions() {
-        return [];
+        return [...this.pendingExtensionUiRequests.values()];
     }
     async respondToPermission(requestId, response) {
-        void requestId;
-        void response;
+        const request = this.pendingExtensionUiRequests.get(requestId);
+        if (!request) {
+            throw new Error(`No pending permission request with id '${requestId}'`);
+        }
+        this.pendingExtensionUiRequests.delete(requestId);
+        this.runtimeSession.respondToExtensionUiRequest(requestId, buildExtensionUiResponse(request, response));
+        this.emit({
+            type: "permission_resolved",
+            provider: PI_PROVIDER,
+            requestId,
+            resolution: response,
+            turnId: this.currentTurnIdForEvent(),
+        });
     }
     describePersistence() {
         return {
@@ -374,6 +649,33 @@ export class PiRpcAgentSession {
     async interrupt() {
         await this.runtimeSession.abort();
     }
+    async revertConversation(input) {
+        if (this.activeTurnId) {
+            throw new Error("Cannot rewind the Pi conversation while a Pi turn is active");
+        }
+        await this.refreshState().catch(() => undefined);
+        await this.requestEntryCapture("rewind");
+        const targetEntry = this.capturedUserEntriesById.get(input.messageId);
+        if (!targetEntry) {
+            throw new Error(`Pi rewind target ${input.messageId} was not found in captured tree entries`);
+        }
+        await revertPiConversation({
+            messageId: input.messageId,
+            navigator: {
+                navigateTree: (treeEntryId) => this.runPiTreeExtensionCommand(treeEntryId),
+            },
+        });
+        // Pi keeps all tree nodes, so selecting the previous leaf later reverses this rewind.
+        this.currentLeafOverrideId = targetEntry.parentId;
+        this.activeToolCalls.clear();
+    }
+    async runPiTreeExtensionCommand(targetId) {
+        const requestId = randomUUID();
+        const resultPromise = this.waitForExtensionResult(requestId);
+        const payload = Buffer.from(JSON.stringify({ targetId, requestId })).toString("base64url");
+        await this.runtimeSession.prompt(`/${PASEO_PI_TREE_EXTENSION_COMMAND} ${payload}`);
+        return await resultPromise;
+    }
     async close() {
         if (this.closed) {
             return;
@@ -383,6 +685,7 @@ export class PiRpcAgentSession {
             await this.runtimeSession.close();
         }
         finally {
+            this.rejectAllExtensionResults(new Error("Pi session closed"));
             this.cleanup?.();
         }
     }
@@ -427,9 +730,129 @@ export class PiRpcAgentSession {
     currentTurnIdForEvent() {
         return this.activeTurnId ?? undefined;
     }
+    async requestEntryCapture(reason) {
+        const requestId = randomUUID();
+        const resultPromise = this.waitForExtensionResult(requestId);
+        const payload = Buffer.from(JSON.stringify({ requestId, reason })).toString("base64url");
+        await this.runtimeSession.prompt(`/${PASEO_PI_CAPTURE_EXTENSION_COMMAND} ${payload}`);
+        await resultPromise;
+    }
+    waitForExtensionResult(requestId) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingExtensionResults.delete(requestId);
+                reject(new Error(`Pi extension result timed out for request ${requestId}`));
+            }, PASEO_PI_EXTENSION_RESULT_TIMEOUT_MS);
+            this.pendingExtensionResults.set(requestId, { resolve, reject, timer });
+        });
+    }
+    resolveExtensionResult(requestId, result) {
+        const pending = this.pendingExtensionResults.get(requestId);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pendingExtensionResults.delete(requestId);
+        pending.resolve(result);
+    }
+    rejectExtensionResult(requestId, error) {
+        const pending = this.pendingExtensionResults.get(requestId);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pendingExtensionResults.delete(requestId);
+        pending.reject(error);
+    }
+    rejectAllExtensionResults(error) {
+        for (const requestId of this.pendingExtensionResults.keys()) {
+            this.rejectExtensionResult(requestId, error);
+        }
+    }
+    recordCapturedUserEntries(entries) {
+        const previouslySeenEntryIds = new Set(this.seenUserEntryIds);
+        this.capturedUserEntries.splice(0, this.capturedUserEntries.length, ...entries);
+        this.capturedUserEntriesById.clear();
+        for (const entry of entries) {
+            this.capturedUserEntriesById.set(entry.id, entry);
+        }
+        this.flushPendingUserMessages(previouslySeenEntryIds);
+        for (const entry of entries) {
+            this.seenUserEntryIds.add(entry.id);
+        }
+    }
+    flushPendingUserMessages(previouslySeenEntryIds) {
+        for (let index = 0; index < this.pendingUserMessages.length; index += 1) {
+            const pending = this.pendingUserMessages[index];
+            const entry = this.capturedUserEntries.find((candidate) => !previouslySeenEntryIds.has(candidate.id));
+            if (!entry) {
+                continue;
+            }
+            previouslySeenEntryIds.add(entry.id);
+            this.pendingUserMessages.splice(index, 1);
+            index -= 1;
+            this.emit({
+                type: "timeline",
+                provider: PI_PROVIDER,
+                turnId: pending.turnId,
+                item: {
+                    type: "user_message",
+                    text: pending.text,
+                    messageId: entry.id,
+                },
+            });
+        }
+    }
+    handleEntryCaptureMarker(message) {
+        const payload = parseExtensionMarkerPayload(message, PASEO_PI_ENTRY_CAPTURE_MARKER);
+        if (!payload) {
+            return false;
+        }
+        const entries = parseCapturedEntries(payload.entries);
+        this.recordCapturedUserEntries(entries);
+        if (typeof payload.requestId === "string") {
+            this.resolveExtensionResult(payload.requestId, entries);
+        }
+        return true;
+    }
+    handleCommandResultMarker(message) {
+        const payload = parseExtensionMarkerPayload(message, PASEO_PI_COMMAND_RESULT_MARKER);
+        if (!payload) {
+            return false;
+        }
+        if (typeof payload.requestId !== "string") {
+            return true;
+        }
+        if (payload.ok === true) {
+            this.resolveExtensionResult(payload.requestId, payload.result);
+            return true;
+        }
+        const error = typeof payload.error === "string" ? payload.error : "Pi extension command failed";
+        this.rejectExtensionResult(payload.requestId, new Error(error));
+        return true;
+    }
+    handleExtensionUiRequest(event) {
+        const message = optionalString(event.message);
+        if (event.method === "notify" && message) {
+            if (this.handleEntryCaptureMarker(message) || this.handleCommandResultMarker(message)) {
+                return;
+            }
+        }
+        const request = mapExtensionUiRequestToPermission(event);
+        if (!request) {
+            return;
+        }
+        this.pendingExtensionUiRequests.set(request.id, request);
+        this.emit({
+            type: "permission_requested",
+            provider: PI_PROVIDER,
+            request,
+            turnId: this.currentTurnIdForEvent(),
+        });
+    }
     handleRuntimeEvent(event) {
         if (event.type === "extension_ui_request") {
-            this.runtimeSession.cancelExtensionUiRequest(event.id);
+            this.handleExtensionUiRequest(event);
             return;
         }
         if (event.type === "process_exit") {
@@ -439,6 +862,7 @@ export class PiRpcAgentSession {
         this.handleSessionEvent(event);
     }
     handleProcessExit(error) {
+        this.rejectAllExtensionResults(new Error(error));
         if (!this.activeTurnId) {
             return;
         }
@@ -468,6 +892,11 @@ export class PiRpcAgentSession {
                     turnId,
                 });
                 return;
+            case "message_start":
+                return;
+            case "message_end":
+                this.handleMessageEnd(event, turnId);
+                return;
             case "message_update":
                 this.handleMessageUpdate(event, turnId);
                 return;
@@ -553,6 +982,25 @@ export class PiRpcAgentSession {
             });
         }
     }
+    handleMessageEnd(event, turnId) {
+        if (event.message.role !== "user") {
+            return;
+        }
+        const text = getUserMessageText(event.message.content);
+        if (!text) {
+            return;
+        }
+        this.pendingUserMessages.push({ text, turnId });
+        void this.requestEntryCapture("message_end").catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.emit({
+                type: "turn_failed",
+                provider: PI_PROVIDER,
+                turnId,
+                error: message,
+            });
+        });
+    }
     emitToolCallEvent(toolCallId, toolCall, status, result, error) {
         const turnId = this.currentTurnIdForEvent();
         const detail = mapToolDetail(toolCall, result);
@@ -618,6 +1066,7 @@ export class PiRpcAgentClient {
     }
     async createSession(config, launchContext) {
         const mcpConfig = await this.prepareMcpConfig(config.cwd, config.mcpServers);
+        const paseoExtension = createPiPaseoExtensionFile();
         let runtimeSession;
         try {
             runtimeSession = await this.runtime.startSession({
@@ -627,10 +1076,12 @@ export class PiRpcAgentClient {
                 systemPrompt: composeSystemPromptParts(config.systemPrompt, config.daemonAppendSystemPrompt),
                 env: launchContext?.env,
                 mcpConfigPath: mcpConfig?.path,
+                extensionPaths: [paseoExtension.path],
             });
         }
         catch (error) {
             mcpConfig?.cleanup();
+            paseoExtension.cleanup();
             throw error;
         }
         try {
@@ -639,12 +1090,13 @@ export class PiRpcAgentClient {
                 config,
                 initialState: await runtimeSession.getState(),
                 capabilities: withPiMcpCapability(mcpConfig !== null),
-                cleanup: mcpConfig?.cleanup,
+                cleanup: combineCleanup([mcpConfig?.cleanup, paseoExtension.cleanup]),
             });
         }
         catch (error) {
             await runtimeSession.close().catch(() => undefined);
             mcpConfig?.cleanup();
+            paseoExtension.cleanup();
             throw error;
         }
     }
@@ -656,6 +1108,7 @@ export class PiRpcAgentClient {
         const persistenceMetadata = parsePersistenceMetadata(handle.metadata);
         const resumeConfig = buildResumeConfig(persistenceMetadata, overrides);
         const mcpConfig = await this.prepareMcpConfig(resumeConfig.cwd, resumeConfig.config.mcpServers);
+        const paseoExtension = createPiPaseoExtensionFile();
         let runtimeSession;
         try {
             runtimeSession = await this.runtime.startSession({
@@ -665,10 +1118,12 @@ export class PiRpcAgentClient {
                 thinkingOptionId: normalizePiThinkingOption(resumeConfig.thinkingOptionId) ?? undefined,
                 systemPrompt: composeSystemPromptParts(resumeConfig.config.systemPrompt, resumeConfig.config.daemonAppendSystemPrompt),
                 mcpConfigPath: mcpConfig?.path,
+                extensionPaths: [paseoExtension.path],
             });
         }
         catch (error) {
             mcpConfig?.cleanup();
+            paseoExtension.cleanup();
             throw error;
         }
         try {
@@ -677,12 +1132,13 @@ export class PiRpcAgentClient {
                 config: resumeConfig.config,
                 initialState: await runtimeSession.getState(),
                 capabilities: withPiMcpCapability(mcpConfig !== null),
-                cleanup: mcpConfig?.cleanup,
+                cleanup: combineCleanup([mcpConfig?.cleanup, paseoExtension.cleanup]),
             });
         }
         catch (error) {
             await runtimeSession.close().catch(() => undefined);
             mcpConfig?.cleanup();
+            paseoExtension.cleanup();
             throw error;
         }
     }
@@ -698,11 +1154,8 @@ export class PiRpcAgentClient {
     async listModes(_options) {
         return [];
     }
-    async listPersistedAgents(options) {
-        return await listPiPersistedAgents({
-            ...options,
-            runtimeSettings: this.runtimeSettings,
-        });
+    async listPersistedAgents(_options) {
+        return [];
     }
     async isAvailable() {
         const binary = await this.resolvePiBinary();