@getpaseo/server 0.9.2 → 0.10.0

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

@@ -14,24 +14,23 @@ import { buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, format
 import { getUserMessageText, streamPiHistory, } from "./history-mapper.js";
 import { materializeProviderImage } from "../provider-image-output.js";
 import { PiCliRuntime } from "./cli-runtime.js";
+import { createPiExtensionHost } from "./extensions/index.js";
 import { revertPiConversation } from "./rewind.js";
 import { listPiImportableSessions, readPiImportSessionConfig } from "./session-descriptor.js";
 import { PiUsagePoller } from "./usage-poller.js";
-import { mapToolDetail, parseToolArgs, parseToolResult, resolveToolCallName, } from "./tool-call-mapper.js";
+import { mapToolDetail, parseToolArgs, parseToolResult, } 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_REWIND_ENTRY_TYPE = "paseo_rewind";
 const PASEO_PI_ENTRY_CAPTURE_MARKER = "PASEO_ENTRY_CAPTURE";
 const PASEO_PI_SUBMITTED_USER_ENTRY_MARKER = "PASEO_SUBMITTED_USER_ENTRY";
 const PASEO_PI_COMMAND_RESULT_MARKER = "PASEO_COMMAND_RESULT";
 const DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS = 30000;
 const DEFAULT_PI_RPC_TIMEOUT_MS = 60000;
 const QUESTION_RESPONSE_HEADER = "Response";
-const QUESTION_COMMENT_HEADER = "Comment";
-const PI_ASK_USER_FREEFORM_SENTINEL = "✏️ Type custom response...";
-const COMBINED_ASK_USER_METADATA = "ask_user_select_optional_comment";
 export const PiProviderParamsSchema = z
     .object({
     sessionDir: z.string().min(1).optional(),
@@ -374,9 +373,8 @@ function createPiPaseoExtensionFile(systemPrompt) {
 	    .join("\\n\\n");
 	}
 
-	function getCapturedUserEntries(ctx) {
-	  return ctx.sessionManager
-	    .getEntries()
+	function toCapturedUserEntries(entries) {
+	  return entries
 	    .filter((entry) => entry.type === "message" && entry.message?.role === "user")
 	    .map(toCapturedUserEntry);
 	}
@@ -392,7 +390,14 @@ function createPiPaseoExtensionFile(systemPrompt) {
 	function emitEntryCapture(ctx, reason, requestId) {
 	  ctx.ui.notify(
 	    "${PASEO_PI_ENTRY_CAPTURE_MARKER} " +
-	      JSON.stringify({ reason, requestId, entries: getCapturedUserEntries(ctx) }),
+	      JSON.stringify({
+	        reason,
+	        requestId,
+	        // Rewind targets: rows can still show entries that a rewind or compaction left off the branch.
+	        treeEntries: toCapturedUserEntries(ctx.sessionManager.getEntries()),
+	        // The entries getMessages() replays, so the nth one is the nth replayed user message.
+	        contextEntries: toCapturedUserEntries(ctx.sessionManager.buildContextEntries()),
+	      }),
 	    "info",
 	  );
 	}
@@ -470,6 +475,8 @@ function createPiPaseoExtensionFile(systemPrompt) {
 	      const payload = decodePayload(args.trim());
 	      try {
 	        const result = await ctx.navigateTree(payload.targetId, { summarize: false });
+	        // Pi reopens a session at its last entry, so record the rewind on the new branch to keep it.
+	        pi.appendEntry("${PASEO_PI_REWIND_ENTRY_TYPE}", { targetId: payload.targetId });
 	        emitEntryCapture(ctx, "tree_navigation");
 	        emitCommandResult(ctx, payload.requestId, { ok: true, result });
 	      } catch (error) {
@@ -609,19 +616,6 @@ function parseCapturedEntries(value) {
         ];
     });
 }
-function optionalBoolean(value) {
-    return typeof value === "boolean" ? value : undefined;
-}
-function readActiveAskUserDialog(toolName, args) {
-    if (toolName !== "ask_user" || !isRecord(args)) {
-        return null;
-    }
-    return {
-        allowComment: optionalBoolean(args.allowComment) ?? false,
-        allowFreeform: optionalBoolean(args.allowFreeform) ?? true,
-        allowMultiple: optionalBoolean(args.allowMultiple) ?? false,
-    };
-}
 function isOptionalInputPlaceholder(placeholder) {
     return /\boptional\b|\bskip\b/i.test(placeholder ?? "");
 }
@@ -639,24 +633,12 @@ function readStringArray(value) {
         ? value.filter((item) => typeof item === "string")
         : [];
 }
-function isPiAskUserFreeformOption(option) {
-    return option === PI_ASK_USER_FREEFORM_SENTINEL;
-}
 function mapExtensionUiRequestToPermission(event, options = {}) {
     const provider = options.provider ?? PI_PROVIDER;
     const label = options.label ?? "Pi";
     switch (event.method) {
         case "select": {
             const selectOptions = readStringArray(event.options);
-            if (options.combineOptionalComment) {
-                return buildCombinedAskUserQuestionPermission(event, {
-                    provider,
-                    label,
-                    question: optionalString(event.title) ?? "Select an option",
-                    options: selectOptions,
-                    allowFreeform: options.allowFreeform === true,
-                });
-            }
             return buildExtensionUiQuestionPermission(event, {
                 provider,
                 label,
@@ -753,52 +735,6 @@ function buildExtensionUiQuestionPermission(event, input) {
         },
     };
 }
-function buildCombinedAskUserQuestionPermission(event, input) {
-    const visibleOptions = input.options.filter((option) => !isPiAskUserFreeformOption(option));
-    const allowOther = input.allowFreeform || visibleOptions.length !== input.options.length;
-    return {
-        id: event.id,
-        provider: input.provider,
-        name: `${input.label} ask_user`,
-        kind: "question",
-        title: input.question,
-        input: {
-            questions: [
-                {
-                    question: input.question,
-                    header: QUESTION_RESPONSE_HEADER,
-                    options: visibleOptions.map((label) => ({ label })),
-                    multiSelect: false,
-                    ...(allowOther ? { allowOther: true } : {}),
-                },
-                {
-                    question: "Optional comment",
-                    header: QUESTION_COMMENT_HEADER,
-                    options: [],
-                    multiSelect: false,
-                    placeholder: "Optional comment (press Enter to skip)...",
-                    allowEmpty: true,
-                },
-            ],
-        },
-        metadata: {
-            extensionUiMethod: event.method,
-            answerHeader: QUESTION_RESPONSE_HEADER,
-            commentHeader: QUESTION_COMMENT_HEADER,
-            combinedAskUser: COMBINED_ASK_USER_METADATA,
-            selectOptions: visibleOptions,
-            ...(allowOther ? { freeformSentinel: PI_ASK_USER_FREEFORM_SENTINEL } : {}),
-        },
-    };
-}
-function permissionAnswer(input, header) {
-    const answers = isRecord(input?.answers) ? input.answers : null;
-    if (!answers) {
-        return null;
-    }
-    const answer = answers[header];
-    return typeof answer === "string" ? answer : null;
-}
 function firstPermissionAnswer(input) {
     const answers = isRecord(input?.answers) ? input.answers : null;
     if (!answers) {
@@ -807,29 +743,6 @@ function firstPermissionAnswer(input) {
     const first = Object.values(answers).find((value) => typeof value === "string");
     return typeof first === "string" ? first : null;
 }
-function isCombinedAskUserPermission(request) {
-    return request.metadata?.combinedAskUser === COMBINED_ASK_USER_METADATA;
-}
-function buildCombinedAskUserSelectionResponse(request, response) {
-    if (response.behavior === "deny") {
-        return { uiResponse: { cancelled: true }, pendingResponse: null };
-    }
-    const answer = permissionAnswer(response.updatedInput, QUESTION_RESPONSE_HEADER);
-    if (answer === null) {
-        return { uiResponse: { cancelled: true }, pendingResponse: null };
-    }
-    const selectOptions = readStringArray(request.metadata?.selectOptions);
-    const freeformSentinel = optionalString(request.metadata?.freeformSentinel);
-    const isFreeform = Boolean(freeformSentinel) && !selectOptions.includes(answer);
-    const comment = permissionAnswer(response.updatedInput, QUESTION_COMMENT_HEADER) ?? "";
-    return {
-        uiResponse: { value: isFreeform ? freeformSentinel : answer },
-        pendingResponse: {
-            comment,
-            freeform: isFreeform ? answer : null,
-        },
-    };
-}
 function buildExtensionUiResponse(request, response) {
     if (response.behavior === "deny") {
         return { cancelled: true };
@@ -907,8 +820,6 @@ export class PiRpcAgentSession {
         this.subscribers = new Set();
         this.activeToolCalls = new Map();
         this.pendingExtensionUiRequests = new Map();
-        this.activeAskUserDialog = null;
-        this.pendingCombinedAskUserResponse = null;
         this.activeTurnId = null;
         this.activeClientMessageId = null;
         this.activeAssistantMessageId = null;
@@ -920,14 +831,16 @@ export class PiRpcAgentSession {
         this.activePromptRequestId = null;
         this.pendingPromptResults = new Map();
         this.pendingSteerSubmissions = [];
-        this.capturedUserEntries = [];
-        this.capturedUserEntriesById = new Map();
+        this.contextUserEntries = [];
+        this.treeUserEntriesById = new Map();
         this.pendingExtensionResults = new Map();
         this.outOfBandCompactionEmit = null;
         this.outOfBandCompactionStarted = false;
         this.outOfBandCompactionCompleted = false;
         this.commandCache = null;
         this.closed = false;
+        this.closeController = new AbortController();
+        this.pendingExtensionHydrations = new Set();
         // Pi publishes the terminal before acknowledging abort. Autonomous runs have no
         // turn ID; retain their errors too until the cancellation request settles.
         this.interruptingTurn = null;
@@ -941,6 +854,7 @@ export class PiRpcAgentSession {
         this.cleanup = options.cleanup;
         this.extensionTimeoutMs = options.extensionTimeoutMs ?? DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS;
         this.logger = options.logger;
+        this.extensionHost = createPiExtensionHost(this.logger);
         this.usagePoller = new PiUsagePoller({
             scheduler: options.usagePollScheduler,
             readStats: () => this.runtimeSession.getSessionStats(),
@@ -1102,7 +1016,9 @@ export class PiRpcAgentSession {
     }
     async *streamHistory() {
         await this.requestEntryCapture("history");
-        yield* streamPiHistory(this.provider, await this.runtimeSession.getMessages(), this.capturedUserEntries);
+        yield* streamPiHistory(this.provider, await this.runtimeSession.getMessages(), this.contextUserEntries, {}, 
+        // At most eight 2 MiB child files per replay; later cards retain their summaries.
+        createPiExtensionHost(this.logger, undefined, 16 * 1024 * 1024), this.closeController.signal);
     }
     async getRuntimeInfo() {
         await this.refreshState();
@@ -1132,13 +1048,11 @@ export class PiRpcAgentSession {
             throw new Error(`No pending permission request with id '${requestId}'`);
         }
         this.pendingExtensionUiRequests.delete(requestId);
-        if (isCombinedAskUserPermission(request)) {
-            const combined = buildCombinedAskUserSelectionResponse(request, response);
-            this.pendingCombinedAskUserResponse = combined.pendingResponse;
-            this.runtimeSession.respondToExtensionUiRequest(requestId, combined.uiResponse);
-        }
-        else {
-            this.runtimeSession.respondToExtensionUiRequest(requestId, buildExtensionUiResponse(request, response));
+        const mapped = this.extensionHost.respondToPermission(request, response);
+        for (const reply of mapped?.responses ?? [
+            { id: requestId, response: buildExtensionUiResponse(request, response) },
+        ]) {
+            this.runtimeSession.respondToExtensionUiRequest(reply.id, reply.response);
         }
         this.emit({
             type: "permission_resolved",
@@ -1232,7 +1146,7 @@ export class PiRpcAgentSession {
         }
         await this.refreshState().catch(() => undefined);
         await this.requestEntryCapture("rewind");
-        const targetEntry = this.capturedUserEntriesById.get(input.messageId);
+        const targetEntry = this.treeUserEntriesById.get(input.messageId);
         if (!targetEntry) {
             throw new Error(`Pi rewind target ${input.messageId} was not found in captured tree entries`);
         }
@@ -1257,11 +1171,13 @@ export class PiRpcAgentSession {
             return;
         }
         this.closed = true;
+        this.closeController.abort();
         this.usagePoller.close();
         try {
             await this.runtimeSession.close();
         }
         finally {
+            await Promise.all(this.pendingExtensionHydrations);
             this.rejectAllExtensionResults(new Error("Pi session closed"));
             this.cleanup?.();
         }
@@ -1321,6 +1237,26 @@ export class PiRpcAgentSession {
             subscriber(event);
         }
     }
+    emitExtensionOutput(output, turnId) {
+        if (!output || this.closed)
+            return;
+        for (const event of output.events) {
+            this.emit(event.type === "timeline" ? { ...event, turnId } : event);
+        }
+        const pending = output.hydration
+            .then((events) => {
+            if (this.closeController.signal.aborted)
+                return;
+            for (const event of events)
+                this.emit(event);
+            return undefined;
+        })
+            .catch((error) => {
+            this.logger.warn({ err: error }, "Pi extension hydration failed");
+        });
+        this.pendingExtensionHydrations.add(pending);
+        void pending.then(() => this.pendingExtensionHydrations.delete(pending));
+    }
     currentTurnIdForEvent() {
         return this.activeTurnId ?? undefined;
     }
@@ -1544,11 +1480,11 @@ export class PiRpcAgentSession {
             this.rejectExtensionResult(requestId, error);
         }
     }
-    recordCapturedUserEntries(entries) {
-        this.capturedUserEntries.splice(0, this.capturedUserEntries.length, ...entries);
-        this.capturedUserEntriesById.clear();
-        for (const entry of entries) {
-            this.capturedUserEntriesById.set(entry.id, entry);
+    recordCapturedUserEntries(input) {
+        this.contextUserEntries.splice(0, this.contextUserEntries.length, ...input.contextEntries);
+        this.treeUserEntriesById.clear();
+        for (const entry of input.treeEntries) {
+            this.treeUserEntriesById.set(entry.id, entry);
         }
     }
     handleSubmittedUserEntryMarker(message) {
@@ -1582,10 +1518,12 @@ export class PiRpcAgentSession {
         if (!payload) {
             return false;
         }
-        const entries = parseCapturedEntries(payload.entries);
-        this.recordCapturedUserEntries(entries);
+        this.recordCapturedUserEntries({
+            treeEntries: parseCapturedEntries(payload.treeEntries),
+            contextEntries: parseCapturedEntries(payload.contextEntries),
+        });
         if (typeof payload.requestId === "string") {
-            this.resolveExtensionResult(payload.requestId, entries);
+            this.resolveExtensionResult(payload.requestId, undefined);
         }
         return true;
     }
@@ -1625,18 +1563,16 @@ export class PiRpcAgentSession {
             });
             return;
         }
-        if (this.respondToCombinedAskUserFollowUp(event)) {
+        const mapped = this.extensionHost.mapDialog(event, this.provider);
+        if (mapped?.type === "response") {
+            this.runtimeSession.respondToExtensionUiRequest(event.id, mapped.response);
             return;
         }
-        const shouldCombineOptionalComment = event.method === "select" &&
-            this.activeAskUserDialog?.allowComment === true &&
-            this.activeAskUserDialog.allowMultiple === false;
-        const request = mapExtensionUiRequestToPermission(event, {
-            provider: this.provider,
-            label: "Pi",
-            combineOptionalComment: shouldCombineOptionalComment,
-            allowFreeform: this.activeAskUserDialog?.allowFreeform,
-        });
+        if (mapped?.type === "deferred")
+            return;
+        const request = mapped?.type === "permission"
+            ? mapped.request
+            : mapExtensionUiRequestToPermission(event, { provider: this.provider, label: "Pi" });
         if (!request) {
             return;
         }
@@ -1648,27 +1584,6 @@ export class PiRpcAgentSession {
             turnId: this.currentTurnIdForEvent(),
         });
     }
-    respondToCombinedAskUserFollowUp(event) {
-        const pending = this.pendingCombinedAskUserResponse;
-        if (!pending || event.method !== "input") {
-            return false;
-        }
-        const placeholder = optionalString(event.placeholder);
-        if (pending.freeform !== null && !isOptionalInputPlaceholder(placeholder)) {
-            this.pendingCombinedAskUserResponse = {
-                ...pending,
-                freeform: null,
-            };
-            this.runtimeSession.respondToExtensionUiRequest(event.id, { value: pending.freeform });
-            return true;
-        }
-        if (isOptionalInputPlaceholder(placeholder)) {
-            this.pendingCombinedAskUserResponse = null;
-            this.runtimeSession.respondToExtensionUiRequest(event.id, { value: pending.comment });
-            return true;
-        }
-        return false;
-    }
     handleCommandOutput(textValue) {
         if (!this.activeTurnId) {
             return;
@@ -1786,7 +1701,22 @@ export class PiRpcAgentSession {
             case "tool_execution_start": {
                 const toolCall = parseToolArgs(event.toolName, event.args);
                 this.activeToolCalls.set(event.toolCallId, toolCall);
-                this.activeAskUserDialog = readActiveAskUserDialog(event.toolName, event.args);
+                const request = this.extensionHost.onToolStart({
+                    callId: event.toolCallId,
+                    toolName: event.toolName,
+                    args: toolCall.args,
+                    status: "running",
+                    result: null,
+                }, this.provider);
+                if (request) {
+                    this.pendingExtensionUiRequests.set(request.id, request);
+                    this.emit({
+                        type: "permission_requested",
+                        provider: this.provider,
+                        request,
+                        turnId: this.currentTurnIdForEvent(),
+                    });
+                }
                 this.emitToolCallEvent(event.toolCallId, toolCall, "running", null, null);
                 return;
             }
@@ -1857,13 +1787,16 @@ export class PiRpcAgentSession {
     handleToolExecutionEnd(event) {
         const toolCall = this.activeToolCalls.get(event.toolCallId) ?? parseToolArgs(event.toolName, null);
         this.activeToolCalls.delete(event.toolCallId);
-        if (event.toolName === "ask_user") {
-            this.activeAskUserDialog = null;
-            this.pendingCombinedAskUserResponse = null;
-        }
         const result = parseToolResult(event.result);
         const error = event.isError ? event.result : null;
         const status = event.isError ? "failed" : "completed";
+        this.extensionHost.onToolEnd({
+            callId: event.toolCallId,
+            toolName: toolCall.toolName,
+            args: toolCall.args,
+            status,
+            result,
+        });
         this.emitToolCallEvent(event.toolCallId, toolCall, status, result, error);
     }
     emitCompactionTimeline(input) {
@@ -1935,6 +1868,8 @@ export class PiRpcAgentSession {
             return;
         }
         if (event.message.role === "custom") {
+            const customMapping = this.extensionHost.mapCustomMessage(event.message);
+            this.emitExtensionOutput(customMapping, turnId);
             const text = getUserMessageText(event.message.content);
             if (text) {
                 this.emit({
@@ -1952,14 +1887,21 @@ export class PiRpcAgentSession {
     }
     emitToolCallEvent(toolCallId, toolCall, status, result, error) {
         const turnId = this.currentTurnIdForEvent();
-        const detail = this.mapToolDetail(toolCallId, toolCall, result);
+        const mapping = this.extensionHost.mapToolCall({
+            callId: toolCallId,
+            toolName: toolCall.toolName,
+            args: toolCall.args,
+            status,
+            result,
+        });
+        const detail = mapping?.detail ?? mapToolDetail(toolCall, result);
         if (!detail) {
             return false;
         }
         const baseItem = {
             type: "tool_call",
             callId: toolCallId,
-            name: resolveToolCallName(toolCall, result),
+            name: mapping?.name ?? toolCall.toolName,
             detail,
         };
         const item = status === "failed" ? { ...baseItem, status, error } : { ...baseItem, status, error: null };
@@ -1969,11 +1911,9 @@ export class PiRpcAgentSession {
             turnId,
             item,
         });
+        this.emitExtensionOutput(mapping, turnId);
         return true;
     }
-    mapToolDetail(_toolCallId, toolCall, result) {
-        return mapToolDetail(toolCall, result);
-    }
     completeTurn(turnId, messages) {
         const errorMessage = latestPiErrorMessage(messages);
         if (this.interruptingTurn &&
@@ -2142,7 +2082,16 @@ export class PiRpcAgentClient {
             if (!runtimeSession)
                 throw new Error("Pi catalog runtime did not start");
             const catalogSession = runtimeSession;
-            const models = transformPiModels((await runProviderRefreshActivity(context, "get_available_models", () => catalogSession.getAvailableModels(null))).map((model) => mapPiModel(model, PI_PROVIDER)));
+            const piModels = await runProviderRefreshActivity(context, "get_available_models", () => catalogSession.getAvailableModels(null));
+            // A fresh Pi session starts on the model Pi resolves from its own settings.
+            const { model: configuredModel } = await runProviderRefreshActivity(context, "get_state", () => catalogSession.getState());
+            const models = transformPiModels(piModels.map((model) => {
+                const mapped = mapPiModel(model, PI_PROVIDER);
+                const isConfigured = model.provider === configuredModel?.provider && model.id === configuredModel?.id;
+                if (isConfigured)
+                    mapped.isDefault = true;
+                return mapped;
+            }));
             return { models, modes: [] };
         }
         finally {

package/dist/server/server/agent/providers/pi/extensions/child-session.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderSubagentInputEvent } from "../../../provider-subagents/store.js";
+/** Child session files are immutable once the completed result exposes their path. */
+export declare function mapPiChildSession(id: string, file: string, maxBytes?: number): Promise<ProviderSubagentInputEvent[]>;
+//# sourceMappingURL=child-session.d.ts.map

package/dist/server/server/agent/providers/pi/extensions/child-session.js

@@ -0,0 +1,59 @@
+import { open } from "node:fs/promises";
+import { limitAgentTimelineItemContent } from "../../../agent-timeline-content.js";
+import { PiHistoryMapper } from "../history-mapper.js";
+const MAX_BYTES = 2 * 1024 * 1024;
+const MAX_ITEMS = 200;
+/** Child session files are immutable once the completed result exposes their path. */
+export async function mapPiChildSession(id, file, maxBytes = MAX_BYTES) {
+    try {
+        const handle = await open(file, "r");
+        try {
+            const fileSize = (await handle.stat()).size;
+            const size = Math.min(fileSize, MAX_BYTES, maxBytes);
+            if (!size)
+                return [];
+            const buffer = Buffer.alloc(size);
+            const { bytesRead } = await handle.read(buffer, 0, size, 0);
+            const text = buffer.toString("utf8", 0, bytesRead);
+            const completeText = bytesRead < fileSize ? text.slice(0, text.lastIndexOf("\n")) : text;
+            return parseChildTimeline(id, completeText);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return [];
+    }
+}
+function parseChildTimeline(id, text) {
+    const mapper = new PiHistoryMapper("pi");
+    const events = [];
+    for (const line of text.split("\n")) {
+        if (!line || events.length >= MAX_ITEMS)
+            break;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!entry.message || typeof entry.message !== "object" || !("role" in entry.message))
+            continue;
+        for (const mapped of mapper.mapMessages([entry.message])) {
+            if (mapped.type !== "timeline")
+                continue;
+            events.push({
+                type: "timeline",
+                id,
+                item: limitAgentTimelineItemContent(mapped.item),
+                ...(entry.timestamp ? { timestamp: entry.timestamp } : {}),
+            });
+            if (events.length >= MAX_ITEMS)
+                break;
+        }
+    }
+    return events;
+}
+//# sourceMappingURL=child-session.js.map

package/dist/server/server/agent/providers/pi/extensions/contract.d.ts

@@ -0,0 +1,68 @@
+import type { AgentPermissionRequest, AgentPermissionResponse, ToolCallDetail, AgentTimelineItem } from "../../../agent-sdk-types.js";
+import type { PiRuntimeEvent } from "../rpc-types.js";
+import type { PiToolResult } from "../tool-call-mapper.js";
+import type { ProviderSubagentInputEvent } from "../../../provider-subagents/store.js";
+import type { PiAgentMessage } from "../rpc-types.js";
+export interface PiExtensionToolCall {
+    callId: string;
+    toolName: string;
+    args: unknown;
+    status: "running" | "completed" | "failed";
+    result: PiToolResult;
+}
+export interface PiExtensionToolMapping {
+    name?: string;
+    detail?: ToolCallDetail;
+    timeline?: AgentTimelineItem[];
+    subagents?: ProviderSubagentInputEvent[];
+    /** Completed Pi child sessions to hydrate through the normal Pi history mapper. */
+    childSessions?: Array<{
+        id: string;
+        file: string;
+    }>;
+}
+export interface PiExtensionCustomMapping {
+    subagents: ProviderSubagentInputEvent[];
+    childSessions?: Array<{
+        id: string;
+        file: string;
+    }>;
+}
+export type PiExtensionDialog = Extract<PiRuntimeEvent, {
+    type: "extension_ui_request";
+}>;
+export interface PiExtensionUiResponse {
+    value?: string;
+    cancelled?: boolean;
+    confirmed?: boolean;
+}
+export type PiExtensionDialogMapping = {
+    type: "permission";
+    request: AgentPermissionRequest;
+} | {
+    type: "response";
+    response: PiExtensionUiResponse;
+} | {
+    type: "deferred";
+};
+export interface PiExtensionUiReply {
+    responses: Array<{
+        id: string;
+        response: PiExtensionUiResponse;
+    }>;
+}
+export interface PiExtensionSession {
+    mapToolCall?(call: PiExtensionToolCall): PiExtensionToolMapping | undefined;
+    mapCustomMessage?(message: Extract<PiAgentMessage, {
+        role: "custom";
+    }>): PiExtensionCustomMapping | undefined;
+    onToolStart?(call: PiExtensionToolCall, provider: string): AgentPermissionRequest | undefined;
+    onToolEnd?(call: PiExtensionToolCall): void;
+    mapDialog?(dialog: PiExtensionDialog, provider: string): PiExtensionDialogMapping | undefined;
+    respondToPermission?(request: AgentPermissionRequest, response: AgentPermissionResponse): PiExtensionUiReply | undefined;
+}
+export interface PiExtension {
+    id: string;
+    createSession(): PiExtensionSession;
+}
+//# sourceMappingURL=contract.d.ts.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contract.js.map

package/dist/server/server/agent/providers/pi/extensions/gotgenes-pi-subagents/index.d.ts

@@ -0,0 +1,3 @@
+import type { PiExtension } from "../contract.js";
+export declare const gotgenesPiSubagents: PiExtension;
+//# sourceMappingURL=index.d.ts.map