@getpaseo/server 0.9.2 → 0.10.0-beta.1

package/dist/server/server/agent/providers/pi/extensions/tintinweb-pi-subagents/index.js

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import { extractTextFromToolResult } from "../../tool-call-mapper.js";
+const SpawnArgs = z
+    .object({
+    subagent_type: z.string().trim().min(1),
+    prompt: z.string().trim().min(1),
+    description: z.string().optional(),
+})
+    .passthrough();
+const FollowupArgs = z.object({ agent_id: z.string().trim().min(1) }).passthrough();
+const Details = z
+    .object({
+    agentId: z.string().trim().min(1),
+    status: z.string(),
+    displayName: z.string().optional(),
+    description: z.string().optional(),
+})
+    .passthrough();
+const Notification = z
+    .object({
+    id: z.string().trim().min(1),
+    status: z.string(),
+    description: z.string().optional(),
+    outputFile: z.string().trim().min(1).optional(),
+})
+    .passthrough();
+const status = (value) => {
+    if (value === "completed")
+        return "completed";
+    if (value === "error")
+        return "failed";
+    if (value === "aborted" || value === "stopped")
+        return "canceled";
+    return "running";
+};
+export const tintinwebPiSubagents = {
+    id: "@tintinweb/pi-subagents",
+    createSession: () => {
+        const callsByAgent = new Map();
+        const readSessions = new Set();
+        const mapSpawn = (call) => {
+            const args = SpawnArgs.safeParse(call.args);
+            if (!args.success)
+                return undefined;
+            const details = Details.safeParse(typeof call.result === "object" ? call.result?.details : null);
+            const title = args.data.subagent_type;
+            const description = args.data.description ?? args.data.prompt;
+            const detail = {
+                type: "sub_agent",
+                subAgentType: title,
+                description,
+                log: extractTextFromToolResult(call.result)?.trim() ?? "",
+            };
+            if (call.status === "running")
+                return {
+                    detail,
+                    subagents: [
+                        {
+                            type: "upsert",
+                            id: call.callId,
+                            title,
+                            description,
+                            toolCallId: call.callId,
+                            status: "running",
+                        },
+                    ],
+                };
+            if (!details.success)
+                return call.status === "failed"
+                    ? {
+                        detail,
+                        subagents: [{ type: "upsert", id: call.callId, status: "failed" }],
+                    }
+                    : { detail };
+            callsByAgent.set(details.data.agentId, call.callId);
+            return {
+                detail,
+                subagents: [
+                    {
+                        type: "upsert",
+                        id: call.callId,
+                        title,
+                        description,
+                        toolCallId: call.callId,
+                        status: status(details.data.status),
+                    },
+                ],
+            };
+        };
+        const mapFollowup = (call) => {
+            const args = FollowupArgs.safeParse(call.args);
+            if (!args.success)
+                return undefined;
+            const id = callsByAgent.get(args.data.agent_id);
+            if (!id)
+                return undefined;
+            const details = Details.safeParse(typeof call.result === "object" ? call.result?.details : null);
+            const detail = {
+                type: "sub_agent",
+                description: details.success ? details.data.description : undefined,
+                log: extractTextFromToolResult(call.result)?.trim() ?? "",
+            };
+            if (call.status === "running" || !details.success)
+                return { detail };
+            return {
+                detail,
+                subagents: [{ type: "upsert", id, status: status(details.data.status) }],
+            };
+        };
+        return {
+            mapToolCall(call) {
+                if (call.toolName === "Agent")
+                    return mapSpawn(call);
+                if (call.toolName === "get_subagent_result" || call.toolName === "steer_subagent")
+                    return mapFollowup(call);
+                return undefined;
+            },
+            mapCustomMessage(message) {
+                if (message.customType !== "subagent-notification" &&
+                    message.customType !== "subagent-update")
+                    return undefined;
+                const details = Notification.safeParse(message.details);
+                if (!details.success)
+                    return undefined;
+                const id = callsByAgent.get(details.data.id);
+                if (!id)
+                    return undefined;
+                const file = details.data.outputFile;
+                const childSessions = file && status(details.data.status) !== "running" && !readSessions.has(file)
+                    ? [{ id, file }]
+                    : [];
+                if (childSessions.length && file)
+                    readSessions.add(file);
+                return {
+                    subagents: [
+                        {
+                            type: "upsert",
+                            id,
+                            description: details.data.description,
+                            status: status(details.data.status),
+                        },
+                    ],
+                    childSessions,
+                };
+            },
+        };
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/server/server/agent/providers/pi/history-mapper.d.ts

@@ -1,4 +1,5 @@
 import type { AgentStreamEvent, ToolCallDetail } from "../../agent-sdk-types.js";
+import { type PiExtensionHost } from "./extensions/index.js";
 import type { PiAgentMessage, PiImageContent, PiTextContent } from "./rpc-types.js";
 import { type PiToolResult, type PiTrackedToolCall } from "./tool-call-mapper.js";
 export interface PiCapturedUserMessageEntry {
@@ -19,18 +20,22 @@ export declare class PiHistoryMapper {
     private readonly provider;
     private readonly userEntries;
     private readonly hooks;
+    private readonly extensionHost;
     private readonly pendingToolCalls;
+    private readonly hydrations;
     private userIndex;
     private assistantIndex;
-    constructor(provider: string, userEntries?: readonly PiCapturedUserMessageEntry[], hooks?: PiHistoryMapperHooks);
+    constructor(provider: string, userEntries?: readonly PiCapturedUserMessageEntry[], hooks?: PiHistoryMapperHooks, extensionHost?: PiExtensionHost);
     mapMessages(messages: readonly PiAgentMessage[]): AgentStreamEvent[];
+    hydrate(): Promise<AgentStreamEvent[]>;
     private mapUserMessage;
     private mapCustomMessage;
     private mapAssistantMessage;
     private mapToolResultMessage;
+    private extensionEvents;
     private mapBashExecutionMessage;
     private resolveToolCallId;
     private mapToolDetail;
 }
-export declare function streamPiHistory(provider: string, messages: PiAgentMessage[], userEntries?: readonly PiCapturedUserMessageEntry[], hooks?: PiHistoryMapperHooks): AsyncGenerator<AgentStreamEvent>;
+export declare function streamPiHistory(provider: string, messages: PiAgentMessage[], userEntries?: readonly PiCapturedUserMessageEntry[], hooks?: PiHistoryMapperHooks, extensionHost?: PiExtensionHost, signal?: AbortSignal): AsyncGenerator<AgentStreamEvent>;
 //# sourceMappingURL=history-mapper.d.ts.map

package/dist/server/server/agent/providers/pi/history-mapper.js

@@ -1,4 +1,5 @@
-import { extractTextFromToolResult, mapToolDetail, parseToolArgs, parseToolResult, resolveToolCallName, } from "./tool-call-mapper.js";
+import { createPiExtensionHost, } from "./extensions/index.js";
+import { extractTextFromToolResult, mapToolDetail, parseToolArgs, parseToolResult, } from "./tool-call-mapper.js";
 function isTextContentBlock(block) {
     return (typeof block === "object" &&
         block !== null &&
@@ -19,11 +20,13 @@ export function getUserMessageText(content) {
     return textParts.join("\n\n");
 }
 export class PiHistoryMapper {
-    constructor(provider, userEntries = [], hooks = {}) {
+    constructor(provider, userEntries = [], hooks = {}, extensionHost = createPiExtensionHost()) {
         this.provider = provider;
         this.userEntries = userEntries;
         this.hooks = hooks;
+        this.extensionHost = extensionHost;
         this.pendingToolCalls = new Map();
+        this.hydrations = [];
         this.userIndex = 0;
         this.assistantIndex = 0;
     }
@@ -41,10 +44,7 @@ export class PiHistoryMapper {
                     events.push(...this.mapAssistantMessage(message));
                     break;
                 case "toolResult": {
-                    const event = this.mapToolResultMessage(message);
-                    if (event) {
-                        events.push(event);
-                    }
+                    events.push(...this.mapToolResultMessage(message));
                     break;
                 }
                 case "bashExecution":
@@ -54,6 +54,9 @@ export class PiHistoryMapper {
         }
         return events;
     }
+    async hydrate() {
+        return (await Promise.all(this.hydrations)).flat();
+    }
     mapUserMessage(message) {
         const text = getUserMessageText(message.content);
         this.userIndex += 1;
@@ -74,20 +77,25 @@ export class PiHistoryMapper {
         ];
     }
     mapCustomMessage(message) {
+        const extensionMapping = this.extensionHost.mapCustomMessage(message);
+        const extensionEvents = this.extensionEvents(extensionMapping);
         const text = getUserMessageText(message.content);
         const mappedEvent = text ? this.hooks.mapCustomMessage?.(text, this.provider) : null;
         if (mappedEvent) {
-            return [mappedEvent];
+            return [...extensionEvents, mappedEvent];
         }
-        return text
-            ? [
-                {
-                    type: "timeline",
-                    provider: this.provider,
-                    item: { type: "assistant_message", text },
-                },
-            ]
-            : [];
+        return [
+            ...extensionEvents,
+            ...(text
+                ? [
+                    {
+                        type: "timeline",
+                        provider: this.provider,
+                        item: { type: "assistant_message", text },
+                    },
+                ]
+                : []),
+        ];
     }
     mapAssistantMessage(message) {
         const events = [];
@@ -113,7 +121,14 @@ export class PiHistoryMapper {
             if (content.type === "toolCall") {
                 const tracked = parseToolArgs(content.name, content.arguments);
                 this.pendingToolCalls.set(content.id, tracked);
-                const detail = this.mapToolDetail(content.id, tracked, null);
+                const mapping = this.extensionHost.mapToolCall({
+                    callId: content.id,
+                    toolName: tracked.toolName,
+                    args: tracked.args,
+                    status: "running",
+                    result: null,
+                });
+                const detail = this.mapToolDetail(content.id, tracked, null, mapping?.detail);
                 if (!detail) {
                     continue;
                 }
@@ -123,12 +138,13 @@ export class PiHistoryMapper {
                     item: {
                         type: "tool_call",
                         callId: this.resolveToolCallId(content.id, tracked),
-                        name: tracked.toolName,
+                        name: mapping?.name ?? tracked.toolName,
                         status: "running",
                         detail,
                         error: null,
                     },
                 });
+                events.push(...this.extensionEvents(mapping));
             }
         }
         return events;
@@ -137,21 +153,37 @@ export class PiHistoryMapper {
         const tracked = this.pendingToolCalls.get(message.toolCallId) ?? parseToolArgs(message.toolName, null);
         this.pendingToolCalls.delete(message.toolCallId);
         const result = parseToolResult({ content: message.content, details: message.details });
-        const detail = this.mapToolDetail(message.toolCallId, tracked, result);
+        const mapping = this.extensionHost.mapToolCall({
+            callId: message.toolCallId,
+            toolName: tracked.toolName,
+            args: tracked.args,
+            status: message.isError ? "failed" : "completed",
+            result,
+        });
+        const detail = this.mapToolDetail(message.toolCallId, tracked, result, mapping?.detail);
         if (!detail) {
-            return null;
+            return [];
         }
-        return {
-            type: "timeline",
-            provider: this.provider,
-            item: toToolResultTimelineItem({
-                callId: this.resolveToolCallId(message.toolCallId, tracked),
-                name: resolveToolCallName(tracked, result),
-                isError: Boolean(message.isError),
-                detail,
-                errorText: extractTextFromToolResult(result) ?? "Tool call failed",
-            }),
-        };
+        return [
+            {
+                type: "timeline",
+                provider: this.provider,
+                item: toToolResultTimelineItem({
+                    callId: this.resolveToolCallId(message.toolCallId, tracked),
+                    name: mapping?.name ?? tracked.toolName,
+                    isError: Boolean(message.isError),
+                    detail,
+                    errorText: extractTextFromToolResult(result) ?? "Tool call failed",
+                }),
+            },
+            ...this.extensionEvents(mapping),
+        ];
+    }
+    extensionEvents(mapping) {
+        if (!mapping)
+            return [];
+        this.hydrations.push(mapping.hydration);
+        return mapping.events;
     }
     mapBashExecutionMessage(message) {
         const detail = {
@@ -176,18 +208,29 @@ export class PiHistoryMapper {
     resolveToolCallId(toolCallId, toolCall) {
         return this.hooks.resolveToolCallId?.(toolCallId, toolCall) ?? toolCallId;
     }
-    mapToolDetail(toolCallId, toolCall, result) {
+    mapToolDetail(toolCallId, toolCall, result, extensionDetail) {
         const hook = this.hooks.mapToolDetail;
-        return hook ? hook(toolCall, result, { toolCallId }) : mapToolDetail(toolCall, result);
+        return hook
+            ? hook(toolCall, result, { toolCallId })
+            : (extensionDetail ?? mapToolDetail(toolCall, result));
     }
 }
-export async function* streamPiHistory(provider, messages, userEntries = [], hooks = {}) {
-    const mapper = new PiHistoryMapper(provider, userEntries, hooks);
+export async function* streamPiHistory(provider, messages, userEntries = [], hooks = {}, 
+// At most eight 2 MiB child files per replay; remaining cards keep their summaries.
+extensionHost = createPiExtensionHost(undefined, undefined, 16 * 1024 * 1024), signal) {
+    const mapper = new PiHistoryMapper(provider, userEntries, hooks, extensionHost);
     for (const event of mapper.mapMessages(messages)) {
+        if (signal?.aborted)
+            return;
         if (event) {
             yield event;
         }
     }
+    for (const event of await mapper.hydrate()) {
+        if (signal?.aborted)
+            return;
+        yield event;
+    }
 }
 function toToolResultTimelineItem(input) {
     if (input.isError) {

package/dist/server/server/agent/providers/pi/rpc-types.d.ts

@@ -32,6 +32,9 @@ export type PiAgentMessage = {
 } | {
     role: "custom";
     content: string | Array<PiTextContent | PiImageContent>;
+    customType?: string;
+    details?: unknown;
+    display?: boolean;
 } | {
     role: "assistant";
     content: PiAssistantContent[];

package/dist/server/server/agent/providers/pi/test-utils/fake-pi.d.ts

@@ -0,0 +1,170 @@
+import type { PiRuntime, PiRuntimeLaunch, PiRuntimeSession, PiStartSessionInput } from "../runtime.js";
+import type { PiAgentMessage, PiModel, PiPromptAck, PiRpcSlashCommand, PiRuntimeEvent, PiSessionState, PiSessionStats } from "../rpc-types.js";
+type FakePiSubagentSubscriptionLevel = "off" | "progress" | "events";
+type FakePiSubagentStatus = "pending" | "running" | "completed" | "failed" | "aborted";
+export interface FakePiSubagentSnapshot {
+    id: string;
+    index: number;
+    agent: string;
+    description?: string;
+    status: FakePiSubagentStatus;
+    task?: string;
+    assignment?: string;
+    sessionFile?: string;
+    parentToolCallId?: string;
+    lastUpdate?: number;
+}
+export interface FakePiSubagentMessagesSelector {
+    subagentId?: string;
+    sessionFile?: string;
+    fromByte?: number;
+}
+export interface FakePiSubagentMessagesResult {
+    sessionFile: string;
+    fromByte: number;
+    nextByte: number;
+    reset: boolean;
+    messages: PiAgentMessage[];
+}
+interface FakePiUserEntry {
+    id: string;
+    parentId: string | null;
+    text: string;
+}
+export declare class FakePi implements PiRuntime {
+    readonly recordedLaunches: PiRuntimeLaunch[];
+    private readonly sessions;
+    private readonly command;
+    private readonly queuedCommands;
+    private readonly queuedSessionSetups;
+    constructor(command?: [string, ...string[]]);
+    startSession(input: PiStartSessionInput): Promise<FakePiSession>;
+    queueCommands(commands: PiRpcSlashCommand[]): void;
+    queueSessionSetup(setup: (session: FakePiSession) => void): void;
+    latestSession(): FakePiSession;
+}
+export declare class FakePiSession implements PiRuntimeSession {
+    readonly prompts: Array<{
+        message: string;
+        imageCount: number;
+    }>;
+    readonly steerCalls: Array<{
+        message: string;
+        imageCount: number;
+    }>;
+    steerError: Error | null;
+    readonly controlRequests: string[];
+    clearQueueError: Error | null;
+    readonly compactRequests: Array<{
+        customInstructions?: string;
+    }>;
+    readonly setAutoCompactionRequests: boolean[];
+    readonly subagentSubscriptionRequests: FakePiSubagentSubscriptionLevel[];
+    readonly subagentMessageRequests: FakePiSubagentMessagesSelector[];
+    readonly setModelRequests: Array<{
+        provider: string;
+        modelId: string;
+    }>;
+    readonly setThinkingLevelRequests: string[];
+    readonly treeNavigationRequests: string[];
+    readonly handoffRequests: Array<{
+        customInstructions?: string;
+    }>;
+    readonly sessionNameRequests: string[];
+    readonly rawFrames: Array<object & {
+        type: string;
+    }>;
+    treeUserEntries: FakePiUserEntry[];
+    contextUserEntries: FakePiUserEntry[];
+    abortRequested: boolean;
+    readonly canceledExtensionUiRequests: string[];
+    readonly extensionUiResponses: Array<{
+        id: string;
+        response: {
+            value?: string;
+            confirmed?: boolean;
+            cancelled?: boolean;
+        };
+    }>;
+    setModelResult: PiModel | null;
+    models: PiModel[];
+    messages: PiAgentMessage[];
+    stats: PiSessionStats;
+    commands: PiRpcSlashCommand[];
+    subagents: FakePiSubagentSnapshot[];
+    subagentSubscriptionError: Error | null;
+    setSessionNameError: Error | null;
+    compactError: Error | null;
+    emitCompactEnd: boolean;
+    getStateError: Error | null;
+    getSessionStatsError: Error | null;
+    promptAck: PiPromptAck;
+    branchResponse: {
+        text?: string;
+        cancelled?: boolean;
+    };
+    readonly branchRequests: string[];
+    state: PiSessionState;
+    private readonly subscribers;
+    private readonly subagentMessageResults;
+    private nextHeldPrompt;
+    private activeHeldPrompt;
+    constructor(launch: PiRuntimeLaunch);
+    onEvent(callback: (event: PiRuntimeEvent) => void): () => void;
+    prompt(message: string, images?: Array<{
+        type: "image";
+        data: string;
+        mimeType: string;
+    }>): Promise<PiPromptAck>;
+    holdNextPrompt(): void;
+    failHeldPrompt(error: Error): Promise<void>;
+    steer(message: string, images?: Array<{
+        type: "image";
+        data: string;
+        mimeType: string;
+    }>): Promise<void>;
+    clearQueue(): Promise<void>;
+    compact(customInstructions?: string): Promise<void>;
+    setAutoCompaction(enabled: boolean): Promise<void>;
+    abort(): Promise<void>;
+    getState(): Promise<PiSessionState>;
+    getMessages(): Promise<PiAgentMessage[]>;
+    getAvailableModels(_timeoutMs?: number | null): Promise<PiModel[]>;
+    setModel(provider: string, modelId: string): Promise<PiModel>;
+    setThinkingLevel(level: string): Promise<void>;
+    getSessionStats(): Promise<PiSessionStats>;
+    setSubagentSubscription(level: FakePiSubagentSubscriptionLevel): Promise<void>;
+    getSubagents(): Promise<FakePiSubagentSnapshot[]>;
+    getSubagentMessages(selector: FakePiSubagentMessagesSelector): Promise<FakePiSubagentMessagesResult>;
+    queueSubagentMessages(result: FakePiSubagentMessagesResult): void;
+    getCommands(): Promise<PiRpcSlashCommand[]>;
+    sendRawFrame(frame: object & {
+        type: string;
+    }): void;
+    request(command: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<unknown>;
+    respondToExtensionUiRequest(id: string, response: {
+        value?: string;
+        confirmed?: boolean;
+        cancelled?: boolean;
+    }): void;
+    cancelExtensionUiRequest(id: string): void;
+    close(): Promise<void>;
+    emit(event: PiRuntimeEvent): void;
+    finishAgentRun({ message, willRetry }: {
+        message: PiAgentMessage;
+        willRetry: boolean;
+    }): void;
+    settleTurn(): void;
+    finishTurn(message?: PiAgentMessage): void;
+    finishLegacyTurn(message?: PiAgentMessage): void;
+    finishSubmittedUserMessage(entry: FakePiUserEntry): void;
+    private handleTreeNavigationCommand;
+    private handleEntryCaptureCommand;
+    emitEntryCapture(requestId?: string, reason?: string): void;
+    private emitExtensionCommandResult;
+}
+export {};
+//# sourceMappingURL=fake-pi.d.ts.map