@getpaseo/server 0.1.91-beta.1 → 0.1.91

package/dist/server/server/agent/providers/opencode-agent.js

@@ -728,6 +728,13 @@ function buildOpenCodeReplayPartTimelineEvent(params) {
         part,
     });
 }
+function isOpenCodeCompactionSummaryMessage(message) {
+    return (message.role === "assistant" &&
+        (message.summary === true || message.agent === "compaction" || message.mode === "compaction"));
+}
+function findOpenCodeCompactionPart(message) {
+    return message.parts.find((part) => part.type === "compaction");
+}
 async function readOpenCodeSessionMessagesFromSdk(client, session) {
     const response = await client.session.messages({
         sessionID: session.id,
@@ -739,7 +746,24 @@ async function readOpenCodeSessionMessagesFromSdk(client, session) {
     return filterOpenCodeRevertedMessages(response.data, session.revert);
 }
 function buildOpenCodeSessionTimeline(messages) {
-    return messages.flatMap((message) => buildOpenCodeReplayTimelineEvents(message).map((event) => event.item));
+    const timeline = [];
+    let hideNextAssistantAfterCompaction = false;
+    for (const message of messages) {
+        const compactionPart = findOpenCodeCompactionPart(message);
+        if (message.info.role === "assistant" && hideNextAssistantAfterCompaction) {
+            hideNextAssistantAfterCompaction = false;
+            continue;
+        }
+        if (message.info.role === "user" && !compactionPart) {
+            hideNextAssistantAfterCompaction = false;
+        }
+        timeline.push(...buildOpenCodeReplayTimelineEvents(message).map((event) => event.item));
+        if (message.info.role === "user" && compactionPart) {
+            timeline.push(createCompactionTimelineItem("completed", compactionPart.auto ? "auto" : "manual"));
+            hideNextAssistantAfterCompaction = true;
+        }
+    }
+    return timeline;
 }
 function filterOpenCodeRevertedMessages(messages, revert) {
     if (!revert?.messageID || revert.partID) {
@@ -778,6 +802,9 @@ function readOpenCodeMessageModel(message) {
 }
 function buildOpenCodeReplayTimelineEvents(message) {
     const { info, parts } = message;
+    if (isOpenCodeCompactionSummaryMessage(info)) {
+        return [];
+    }
     if (info.role === "user") {
         const text = parts
             .filter((part) => part.type === "text")
@@ -816,6 +843,7 @@ function buildOpenCodeReplayTimelineEvents(message) {
 }
 export const __openCodeInternals = {
     buildOpenCodePromptParts,
+    buildOpenCodeSessionTimeline,
     buildOpenCodeModelContextWindowLookup,
     buildOpenCodeModelDefinition,
     buildOpenCodeModelLookupKey,
@@ -1370,6 +1398,11 @@ export function translateOpenCodeEvent(event, state) {
 function resetOpenCodeTurnTrackingState(state) {
     state.streamedPartKeys.clear();
     state.partTypes.clear();
+    state.compactionSummaryMessageIds.clear();
+    state.emittedCompactionPartIds.clear();
+    if (state.suppressAssistantMessagesUntilIdle) {
+        state.suppressAssistantMessagesUntilIdle.active = false;
+    }
 }
 function getOpenCodeSubAgentMaps(state) {
     state.subAgentsByCallId ?? (state.subAgentsByCallId = new Map());
@@ -1592,6 +1625,14 @@ function appendOpenCodeMessageUpdated(event, state, events) {
     if (info.role !== "assistant") {
         return;
     }
+    if (state.suppressAssistantMessagesUntilIdle?.active) {
+        state.compactionSummaryMessageIds.add(info.id);
+        return;
+    }
+    if (isOpenCodeCompactionSummaryMessage(info)) {
+        state.compactionSummaryMessageIds.add(info.id);
+        return;
+    }
     const modelLookupKey = resolveOpenCodeModelLookupKeyFromAssistantMessage(info);
     if (modelLookupKey) {
         const contextWindowMaxTokens = state.modelContextWindowsByModelKey?.get(modelLookupKey);
@@ -1638,6 +1679,13 @@ function appendOpenCodeMessagePartUpdated(event, state, events) {
     }
     const messageRole = state.messageRoles.get(part.messageID);
     state.partTypes.set(part.id, part.type);
+    if (state.compactionSummaryMessageIds.has(part.messageID)) {
+        return;
+    }
+    if (shouldSuppressOpenCodeAssistantPart(part, messageRole, state)) {
+        state.compactionSummaryMessageIds.add(part.messageID);
+        return;
+    }
     if (part.type === "text") {
         appendOpenCodeTextPart(part, messageRole, state, events);
         return;
@@ -1654,6 +1702,10 @@ function appendOpenCodeMessagePartUpdated(event, state, events) {
         return;
     }
     if (part.type === "compaction") {
+        if (state.emittedCompactionPartIds.has(part.id)) {
+            return;
+        }
+        state.emittedCompactionPartIds.add(part.id);
         events.push({
             type: "timeline",
             provider: "opencode",
@@ -1678,6 +1730,11 @@ function appendOpenCodeMessagePartUpdated(event, state, events) {
         }
     }
 }
+function shouldSuppressOpenCodeAssistantPart(part, messageRole, state) {
+    return (state.suppressAssistantMessagesUntilIdle?.active === true &&
+        part.type === "text" &&
+        messageRole !== "user");
+}
 function appendOpenCodeTextPart(part, messageRole, state, events) {
     if (messageRole === "user") {
         return;
@@ -1724,6 +1781,9 @@ function appendOpenCodeMessagePartDelta(event, state, events) {
     const messageRole = messageID ? state.messageRoles.get(messageID) : undefined;
     const knownPartType = partID ? state.partTypes.get(partID) : undefined;
     const isReasoning = knownPartType === "reasoning" || field === "reasoning";
+    if (messageID && state.compactionSummaryMessageIds.has(messageID)) {
+        return;
+    }
     if (isReasoning) {
         if (partID) {
             state.streamedPartKeys.add(`reasoning:${partID}`);
@@ -1741,6 +1801,10 @@ function appendOpenCodeMessagePartDelta(event, state, events) {
     if (messageRole === "user") {
         return;
     }
+    if (messageID && state.suppressAssistantMessagesUntilIdle?.active === true) {
+        state.compactionSummaryMessageIds.add(messageID);
+        return;
+    }
     if (partID) {
         state.streamedPartKeys.add(`text:${partID}`);
     }
@@ -1938,6 +2002,9 @@ class OpenCodeAgentSession {
         this.streamedPartKeys = new Set();
         /** Tracks assistant messages already emitted from structured payloads. */
         this.emittedStructuredMessageIds = new Set();
+        this.compactionSummaryMessageIds = new Set();
+        this.emittedCompactionPartIds = new Set();
+        this.suppressAssistantMessagesUntilIdle = { active: false };
         /** Tracks the type of each part by ID, learned from message.part.updated events. */
         this.partTypes = new Map();
         this.availableModesCache = null;
@@ -2069,6 +2136,7 @@ class OpenCodeAgentSession {
         this.accumulatedUsage = contextWindowMaxTokens !== undefined ? { contextWindowMaxTokens } : {};
         const parts = buildOpenCodePromptParts(prompt);
         this.pendingUserMessageText = buildOpenCodeUserTimelineText(prompt);
+        this.suppressAssistantMessagesUntilIdle.active = false;
         const model = this.parseModel(this.config.model);
         const thinkingOptionId = this.config.thinkingOptionId;
         const effectiveVariant = thinkingOptionId ?? undefined;
@@ -2088,6 +2156,7 @@ class OpenCodeAgentSession {
         const slashCommand = await this.resolveSlashCommandInvocation(prompt);
         if (slashCommand) {
             if (slashCommand.commandName === "compact" || slashCommand.commandName === "summarize") {
+                this.suppressAssistantMessagesUntilIdle.active = true;
                 void this.client.session
                     .summarize({
                     sessionID: this.sessionId,
@@ -2096,18 +2165,17 @@ class OpenCodeAgentSession {
                 })
                     .then((response) => {
                     if (response.error) {
+                        this.suppressAssistantMessagesUntilIdle.active = false;
                         this.finishForegroundTurn({
                             type: "turn_failed",
                             provider: "opencode",
                             error: toDiagnosticErrorMessage(response.error),
                         }, turnId);
                     }
-                    else {
-                        this.finishForegroundTurn({ type: "turn_completed", provider: "opencode", usage: undefined }, turnId);
-                    }
                     return;
                 })
                     .catch((error) => {
+                    this.suppressAssistantMessagesUntilIdle.active = false;
                     this.finishForegroundTurn({
                         type: "turn_failed",
                         provider: "opencode",
@@ -2710,6 +2778,9 @@ class OpenCodeAgentSession {
             sessionTotalCostUsd: this.sessionTotalCostUsd,
             streamedPartKeys: this.streamedPartKeys,
             emittedStructuredMessageIds: this.emittedStructuredMessageIds,
+            compactionSummaryMessageIds: this.compactionSummaryMessageIds,
+            emittedCompactionPartIds: this.emittedCompactionPartIds,
+            suppressAssistantMessagesUntilIdle: this.suppressAssistantMessagesUntilIdle,
             partTypes: this.partTypes,
             subAgentsByCallId: this.subAgentsByCallId,
             subAgentCallIdByChildSessionId: this.subAgentCallIdByChildSessionId,

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