@getpaseo/server 0.1.91-beta.2 → 0.1.91

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

@@ -1,11 +1,20 @@
 import type { Logger } from "pino";
+import { z } from "zod";
 import { type AgentCapabilityFlags, type AgentClient, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type ListPersistedAgentsOptions, type ListModesOptions, type ListModelsOptions, type PersistedAgentDescriptor } from "../../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 import type { PiRuntime, PiRuntimeSession } from "./runtime.js";
 import type { PiSessionState } from "./rpc-types.js";
+export declare const PiProviderParamsSchema: z.ZodObject<{
+    sessionDir: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    sessionDir?: string | undefined;
+}, {
+    sessionDir?: string | undefined;
+}>;
 interface PiRpcAgentClientOptions {
     logger: Logger;
     runtimeSettings?: ProviderRuntimeSettings;
+    providerParams?: unknown;
     runtime?: PiRuntime;
 }
 interface StartTurnResult {
@@ -35,6 +44,9 @@ export declare class PiRpcAgentSession implements AgentSession {
     private readonly seenUserEntryIds;
     private readonly pendingUserMessages;
     private readonly pendingExtensionResults;
+    private outOfBandCompactionEmit;
+    private outOfBandCompactionStarted;
+    private outOfBandCompactionCompleted;
     private state;
     private closed;
     constructor(options: PiRpcAgentSessionOptions);
@@ -60,10 +72,18 @@ export declare class PiRpcAgentSession implements AgentSession {
     private runPiTreeExtensionCommand;
     close(): Promise<void>;
     listCommands(): Promise<AgentSlashCommand[]>;
+    tryHandleOutOfBand(prompt: AgentPromptInput): {
+        run(ctx: {
+            emit: (event: AgentStreamEvent) => void;
+        }): Promise<void>;
+    } | null;
     setModel(modelId: string | null): Promise<void>;
     setThinkingOption(thinkingOptionId: string | null): Promise<void>;
     private emit;
     private currentTurnIdForEvent;
+    private parseSlashCommandInput;
+    private executeCompactCommand;
+    private executeAutoCompactCommand;
     private requestEntryCapture;
     private waitForExtensionResult;
     private resolveExtensionResult;
@@ -78,6 +98,7 @@ export declare class PiRpcAgentSession implements AgentSession {
     private handleRuntimeEvent;
     private handleProcessExit;
     private handleSessionEvent;
+    private emitCompactionTimeline;
     private handleMessageUpdate;
     private handleMessageEnd;
     private emitToolCallEvent;
@@ -90,13 +111,14 @@ export declare class PiRpcAgentClient implements AgentClient {
     readonly capabilities: AgentCapabilityFlags;
     private readonly logger;
     private readonly runtimeSettings?;
+    private readonly providerParams;
     private readonly runtime;
     constructor(options: PiRpcAgentClientOptions);
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
     listModels(options: ListModelsOptions): Promise<AgentModelDefinition[]>;
     listModes(_options: ListModesOptions): Promise<AgentMode[]>;
-    listPersistedAgents(_options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+    listPersistedAgents(options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
     isAvailable(): Promise<boolean>;
     getDiagnostic(): Promise<{
         diagnostic: string;

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

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
+import { z } from "zod";
 import { runProviderTurn } from "../provider-runner.js";
 import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
@@ -10,6 +11,7 @@ import { buildBinaryDiagnosticRows, formatDiagnosticStatus, formatProviderDiagno
 import { getUserMessageText, streamPiHistory, } from "./history-mapper.js";
 import { PiCliRuntime } from "./cli-runtime.js";
 import { revertPiConversation } from "./rewind.js";
+import { listPiPersistedAgents } from "./session-descriptor.js";
 import { mapToolDetail, parseToolArgs, parseToolResult, resolveToolCallName, } from "./tool-call-mapper.js";
 const PI_PROVIDER = "pi";
 const DEFAULT_PI_THINKING_LEVEL = "medium";
@@ -23,6 +25,23 @@ 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(),
+})
+    .strict();
+const PI_HANDLED_BUILTIN_SLASH_COMMANDS = [
+    {
+        name: "compact",
+        description: "Manually compact the session context",
+        argumentHint: "[instructions]",
+    },
+    {
+        name: "autocompact",
+        description: "Toggle automatic context compaction",
+        argumentHint: "[on|off|toggle]",
+    },
+];
 const PI_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -76,6 +95,19 @@ function normalizePiThinkingOption(value) {
     }
     return isPiThinkingLevel(value) ? value : null;
 }
+function parseAutoCompactMode(value) {
+    const mode = (value ?? "toggle").trim().toLowerCase();
+    if (mode === "on" || mode === "true" || mode === "enable" || mode === "enabled") {
+        return true;
+    }
+    if (mode === "off" || mode === "false" || mode === "disable" || mode === "disabled") {
+        return false;
+    }
+    if (mode === "toggle") {
+        return "toggle";
+    }
+    return "unknown";
+}
 function mapThinkingOption(option) {
     const mappedOption = {
         id: option.id,
@@ -654,6 +686,9 @@ export class PiRpcAgentSession {
         this.seenUserEntryIds = new Set();
         this.pendingUserMessages = [];
         this.pendingExtensionResults = new Map();
+        this.outOfBandCompactionEmit = null;
+        this.outOfBandCompactionStarted = false;
+        this.outOfBandCompactionCompleted = false;
         this.closed = false;
         this.runtimeSession = options.runtimeSession;
         this.config = options.config;
@@ -821,11 +856,41 @@ export class PiRpcAgentSession {
     }
     async listCommands() {
         const commands = await this.runtimeSession.getCommands();
-        return commands.map((command) => ({
-            name: command.name,
-            description: command.description ?? command.source,
-            argumentHint: "",
-        }));
+        const mappedCommands = new Map(PI_HANDLED_BUILTIN_SLASH_COMMANDS.map((command) => [command.name, { ...command }]));
+        for (const command of commands) {
+            const knownCommand = mappedCommands.get(command.name);
+            mappedCommands.set(command.name, {
+                name: command.name,
+                description: command.description ?? command.source,
+                argumentHint: knownCommand?.argumentHint ?? "",
+            });
+        }
+        return [...mappedCommands.values()];
+    }
+    tryHandleOutOfBand(prompt) {
+        if (typeof prompt !== "string") {
+            return null;
+        }
+        const parsed = this.parseSlashCommandInput(prompt);
+        if (!parsed) {
+            return null;
+        }
+        const commandName = parsed.commandName.toLowerCase();
+        if (commandName === "compact") {
+            return {
+                run: async ({ emit }) => {
+                    await this.executeCompactCommand(parsed.args, emit);
+                },
+            };
+        }
+        if (commandName === "autocompact") {
+            return {
+                run: async ({ emit }) => {
+                    await this.executeAutoCompactCommand(parsed.args, emit);
+                },
+            };
+        }
+        return null;
     }
     async setModel(modelId) {
         const parsedReference = parseModelReference(modelId);
@@ -860,6 +925,117 @@ export class PiRpcAgentSession {
     currentTurnIdForEvent() {
         return this.activeTurnId ?? undefined;
     }
+    parseSlashCommandInput(text) {
+        const trimmed = text.trim();
+        if (!trimmed.startsWith("/") || trimmed.length <= 1) {
+            return null;
+        }
+        const withoutPrefix = trimmed.slice(1);
+        const firstWhitespaceIdx = withoutPrefix.search(/\s/);
+        const commandName = firstWhitespaceIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, firstWhitespaceIdx);
+        if (!commandName || commandName.includes("/")) {
+            return null;
+        }
+        const rawArgs = firstWhitespaceIdx === -1 ? "" : withoutPrefix.slice(firstWhitespaceIdx + 1).trim();
+        return rawArgs.length > 0 ? { commandName, args: rawArgs } : { commandName };
+    }
+    async executeCompactCommand(customInstructions, emit) {
+        if (this.outOfBandCompactionEmit) {
+            throw new Error("A Pi compact command is already running");
+        }
+        this.outOfBandCompactionEmit = emit;
+        this.outOfBandCompactionStarted = false;
+        this.outOfBandCompactionCompleted = false;
+        try {
+            await this.runtimeSession.compact(customInstructions);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (this.outOfBandCompactionEmit === emit &&
+                this.outOfBandCompactionStarted &&
+                !this.outOfBandCompactionCompleted) {
+                this.emitCompactionTimeline({
+                    turnId: undefined,
+                    item: {
+                        type: "compaction",
+                        status: "completed",
+                        trigger: "manual",
+                    },
+                });
+            }
+            emit({
+                type: "timeline",
+                provider: PI_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: `[Error] Failed to compact context: ${message}`,
+                },
+            });
+        }
+        finally {
+            if (this.outOfBandCompactionEmit === emit && !this.outOfBandCompactionStarted) {
+                this.outOfBandCompactionEmit = null;
+                this.outOfBandCompactionStarted = false;
+                this.outOfBandCompactionCompleted = false;
+            }
+        }
+    }
+    async executeAutoCompactCommand(mode, emit) {
+        let enabled = parseAutoCompactMode(mode);
+        if (enabled === "unknown") {
+            emit({
+                type: "timeline",
+                provider: PI_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: "[Error] Usage: /autocompact [on|off|toggle]",
+                },
+            });
+            return;
+        }
+        if (enabled === "toggle") {
+            const state = await this.runtimeSession.getState();
+            if (typeof state.autoCompactionEnabled !== "boolean") {
+                emit({
+                    type: "timeline",
+                    provider: PI_PROVIDER,
+                    item: {
+                        type: "assistant_message",
+                        text: "[Error] Auto-compaction state is unavailable. Use /autocompact on or /autocompact off.",
+                    },
+                });
+                return;
+            }
+            enabled = !state.autoCompactionEnabled;
+        }
+        try {
+            await this.runtimeSession.setAutoCompaction(enabled);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            emit({
+                type: "timeline",
+                provider: PI_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: `[Error] Failed to set auto-compaction: ${message}`,
+                },
+            });
+            return;
+        }
+        this.state = {
+            ...this.state,
+            autoCompactionEnabled: enabled,
+        };
+        emit({
+            type: "timeline",
+            provider: PI_PROVIDER,
+            item: {
+                type: "assistant_message",
+                text: `Auto-compaction ${enabled ? "enabled" : "disabled"}.`,
+            },
+        });
+    }
     async requestEntryCapture(reason) {
         const requestId = randomUUID();
         const resultPromise = this.waitForExtensionResult(requestId);
@@ -1090,9 +1266,7 @@ export class PiRpcAgentSession {
                 return;
             }
             case "compaction_start":
-                this.emit({
-                    type: "timeline",
-                    provider: PI_PROVIDER,
+                this.emitCompactionTimeline({
                     turnId,
                     item: {
                         type: "compaction",
@@ -1102,13 +1276,12 @@ export class PiRpcAgentSession {
                 });
                 return;
             case "compaction_end":
-                this.emit({
-                    type: "timeline",
-                    provider: PI_PROVIDER,
+                this.emitCompactionTimeline({
                     turnId,
                     item: {
                         type: "compaction",
                         status: "completed",
+                        trigger: event.reason === "manual" ? "manual" : "auto",
                     },
                 });
                 return;
@@ -1119,6 +1292,33 @@ export class PiRpcAgentSession {
                 return;
         }
     }
+    emitCompactionTimeline(input) {
+        const emitOutOfBand = this.outOfBandCompactionEmit;
+        if (emitOutOfBand && input.item.type === "compaction") {
+            if (input.item.status === "loading") {
+                this.outOfBandCompactionStarted = true;
+            }
+            if (input.item.status === "completed") {
+                this.outOfBandCompactionCompleted = true;
+            }
+        }
+        const event = {
+            type: "timeline",
+            provider: PI_PROVIDER,
+            ...(emitOutOfBand ? {} : { turnId: input.turnId }),
+            item: input.item,
+        };
+        if (emitOutOfBand) {
+            emitOutOfBand(event);
+            if (input.item.type === "compaction" && input.item.status === "completed") {
+                this.outOfBandCompactionEmit = null;
+                this.outOfBandCompactionStarted = false;
+                this.outOfBandCompactionCompleted = false;
+            }
+            return;
+        }
+        this.emit(event);
+    }
     handleMessageUpdate(event, turnId) {
         if (event.message.role !== "assistant") {
             return;
@@ -1240,6 +1440,7 @@ export class PiRpcAgentClient {
         this.capabilities = PI_CAPABILITIES;
         this.logger = options.logger;
         this.runtimeSettings = options.runtimeSettings;
+        this.providerParams = PiProviderParamsSchema.parse(options.providerParams ?? {});
         this.runtime = options.runtime ?? createRuntime(options.logger, options.runtimeSettings);
     }
     async createSession(config, launchContext) {
@@ -1332,8 +1533,13 @@ export class PiRpcAgentClient {
     async listModes(_options) {
         return [];
     }
-    async listPersistedAgents(_options) {
-        return [];
+    async listPersistedAgents(options) {
+        return await listPiPersistedAgents({
+            ...options,
+            provider: PI_PROVIDER,
+            sessionDir: this.providerParams.sessionDir,
+            runtimeSettings: this.runtimeSettings,
+        });
     }
     async isAvailable() {
         const launch = await this.resolvePiLaunch();

package/dist/server/server/agent/providers/pi/cli-runtime.js

@@ -76,6 +76,15 @@ class PiCliRuntimeSession {
     async prompt(message, images) {
         await this.request({ type: "prompt", message, ...(images?.length ? { images } : {}) });
     }
+    async compact(customInstructions) {
+        await this.request({
+            type: "compact",
+            ...(customInstructions ? { customInstructions } : {}),
+        });
+    }
+    async setAutoCompaction(enabled) {
+        await this.request({ type: "set_auto_compaction", enabled });
+    }
     async abort() {
         await this.request({ type: "abort" });
     }

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

@@ -66,6 +66,7 @@ export interface PiSessionState {
     thinkingLevel: PiThinkingLevel;
     isStreaming: boolean;
     isCompacting: boolean;
+    autoCompactionEnabled?: boolean;
     sessionFile?: string;
     sessionId: string;
     sessionName?: string;
@@ -98,6 +99,14 @@ export type PiRpcCommand = {
     type: "prompt";
     message: string;
     images?: PiImageContent[];
+} | {
+    id?: string;
+    type: "compact";
+    customInstructions?: string;
+} | {
+    id?: string;
+    type: "set_auto_compaction";
+    enabled: boolean;
 } | {
     id?: string;
     type: "abort";

package/dist/server/server/agent/providers/pi/runtime.d.ts

@@ -28,6 +28,8 @@ export interface PiRuntimeSession {
         data: string;
         mimeType: string;
     }>): Promise<void>;
+    compact(customInstructions?: string): Promise<void>;
+    setAutoCompaction(enabled: boolean): Promise<void>;
     abort(): Promise<void>;
     getState(): Promise<PiSessionState>;
     getMessages(): Promise<PiAgentMessage[]>;

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

@@ -0,0 +1,12 @@
+import type { ListPersistedAgentsOptions, PersistedAgentDescriptor } from "../../agent-sdk-types.js";
+import type { ProviderRuntimeSettings } from "../../provider-launch-config.js";
+interface PiSessionDescriptorOptions extends ListPersistedAgentsOptions {
+    provider?: string;
+    sessionDir?: string;
+    runtimeSettings?: ProviderRuntimeSettings;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+}
+export declare function listPiPersistedAgents(options?: PiSessionDescriptorOptions): Promise<PersistedAgentDescriptor[]>;
+export {};
+//# sourceMappingURL=session-descriptor.d.ts.map