@getpaseo/server 0.1.91-beta.2 → 0.1.92

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { importSessionFromPersistence } from "../provider-session-import.js";
 import { getAgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 export const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
 export const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
@@ -8,6 +9,7 @@ const MOCK_LOAD_TEST_INTERVAL_MS = 40;
 const CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
+    supportsSessionListing: true,
     supportsDynamicModes: false,
     supportsMcpServers: false,
     supportsReasoningStream: true,
@@ -308,9 +310,17 @@ export class MockLoadTestAgentClient {
     async listModes(_options) {
         return getAgentProviderDefinition(MOCK_LOAD_TEST_PROVIDER_ID).modes;
     }
-    async listPersistedAgents(_options) {
+    async listImportableSessions() {
         return [];
     }
+    async importSession(input, context) {
+        return importSessionFromPersistence({
+            provider: MOCK_LOAD_TEST_PROVIDER_ID,
+            request: input,
+            context,
+            resumeSession: this.resumeSession.bind(this),
+        });
+    }
     async isAvailable() {
         return true;
     }

package/dist/server/server/agent/providers/mock-slow-provider.d.ts

@@ -1,4 +1,4 @@
-import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, ListModelsOptions, ListModesOptions, ListPersistedAgentsOptions, PersistedAgentDescriptor } from "../agent-sdk-types.js";
+import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, ListModelsOptions, ListModesOptions } from "../agent-sdk-types.js";
 export declare const MOCK_SLOW_PROVIDER_ID = "mock-slow";
 export declare class MockSlowProviderClient implements AgentClient {
     readonly provider: AgentProvider;
@@ -6,7 +6,6 @@ export declare class MockSlowProviderClient implements AgentClient {
     isAvailable(): Promise<boolean>;
     listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
     listModes(_options: ListModesOptions): Promise<AgentMode[]>;
-    listPersistedAgents(_options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
     getDiagnostic(): Promise<{
         diagnostic: string;
     }>;

package/dist/server/server/agent/providers/mock-slow-provider.js

@@ -27,9 +27,6 @@ export class MockSlowProviderClient {
     listModes(_options) {
         return neverResolves();
     }
-    async listPersistedAgents(_options) {
-        return [];
-    }
     async getDiagnostic() {
         return {
             diagnostic: "Mock slow provider: dev-only. listModels() never resolves so the snapshot manager will time out.",

package/dist/server/server/agent/providers/opencode/test-utils/test-opencode-runtime.d.ts

@@ -51,6 +51,7 @@ export declare class TestOpenCodeClient {
         sessionCommand: unknown[];
         sessionCreate: unknown[];
         sessionDelete: unknown[];
+        sessionGet: unknown[];
         sessionMessages: unknown[];
         sessionPromptAsync: unknown[];
         sessionSummarize: unknown[];
@@ -73,9 +74,11 @@ export declare class TestOpenCodeClient {
     sessionCommandResponse: OpenCodeResponse;
     sessionCreateResponse: OpenCodeResponse;
     sessionDeleteResponse: OpenCodeResponse;
+    sessionGetResponse: OpenCodeResponse;
     sessionMessagesResponse: OpenCodeResponse;
     sessionPromptAsyncEvents: unknown[];
     sessionPromptAsyncResponse: OpenCodeResponse;
+    sessionSummarizeEvents: unknown[];
     sessionSummarizeResponse: OpenCodeResponse;
     sessionUpdateResponse: OpenCodeResponse;
     private readonly queuedEventStream;

package/dist/server/server/agent/providers/opencode/test-utils/test-opencode-runtime.js

@@ -46,6 +46,7 @@ export class TestOpenCodeClient {
             sessionCommand: [],
             sessionCreate: [],
             sessionDelete: [],
+            sessionGet: [],
             sessionMessages: [],
             sessionPromptAsync: [],
             sessionSummarize: [],
@@ -67,9 +68,13 @@ export class TestOpenCodeClient {
         this.sessionCommandResponse = {};
         this.sessionCreateResponse = { data: { id: "session-1" } };
         this.sessionDeleteResponse = {};
+        this.sessionGetResponse = {
+            data: { id: "session-1", directory: "/workspace/repo", title: null },
+        };
         this.sessionMessagesResponse = { data: [] };
         this.sessionPromptAsyncEvents = [idleEvent()];
         this.sessionPromptAsyncResponse = {};
+        this.sessionSummarizeEvents = [idleEvent()];
         this.sessionSummarizeResponse = { data: {} };
         this.sessionUpdateResponse = {};
         this.queuedEventStream = createQueuedEventStream();
@@ -169,6 +174,10 @@ export class TestOpenCodeClient {
                     this.calls.sessionDelete.push(parameters);
                     return this.sessionDeleteResponse;
                 },
+                get: async (parameters) => {
+                    this.calls.sessionGet.push(parameters);
+                    return this.sessionGetResponse;
+                },
                 messages: async (parameters) => {
                     this.calls.sessionMessages.push(parameters);
                     return this.sessionMessagesResponse;
@@ -182,6 +191,9 @@ export class TestOpenCodeClient {
                 },
                 summarize: async (parameters) => {
                     this.calls.sessionSummarize.push(parameters);
+                    for (const event of this.sessionSummarizeEvents) {
+                        this.emitEvent(event);
+                    }
                     return this.sessionSummarizeResponse;
                 },
                 update: async (parameters) => {

package/dist/server/server/agent/providers/opencode-agent.d.ts

@@ -1,6 +1,6 @@
-import { type AssistantMessage as OpenCodeAssistantMessage, type Event as OpenCodeEvent, type FilePartInput as OpenCodeFilePartInput, type OpencodeClient, type TextPartInput as OpenCodeTextPartInput } from "@opencode-ai/sdk/v2/client";
+import { type AssistantMessage as OpenCodeAssistantMessage, type Event as OpenCodeEvent, type FilePartInput as OpenCodeFilePartInput, type Message as OpenCodeMessage, type OpencodeClient, type Part as OpenCodePart, type TextPartInput as OpenCodeTextPartInput } from "@opencode-ai/sdk/v2/client";
 import type { Logger } from "pino";
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, 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 AgentUsage, type ResolveAgentCreateConfigInput, type ResolveAgentCreateConfigResult, type ListModelsOptions, type ListModesOptions, type ListPersistedAgentsOptions, type PersistedAgentDescriptor, type ToolCallTimelineItem } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, 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 AgentTimelineItem, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ResolveAgentCreateConfigInput, type ResolveAgentCreateConfigResult, type ListModelsOptions, type ListModesOptions, type ToolCallTimelineItem } from "../agent-sdk-types.js";
 import { isDefaultAgentCreateConfigUnattended } from "../create-agent-mode.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { type OpenCodeRuntime } from "./opencode/runtime.js";
@@ -10,6 +10,10 @@ type OpenCodeAgentConfig = AgentSessionConfig & {
     provider: "opencode";
 };
 type OpenCodeMessageRole = "user" | "assistant";
+interface OpenCodeSessionMessage {
+    info: OpenCodeMessage;
+    parts: OpenCodePart[];
+}
 declare function reconcileOpenCodeSessionClose(params: {
     client: Pick<OpencodeClient, "session">;
     sessionId: string;
@@ -79,8 +83,10 @@ declare function mergeOpenCodeStepFinishUsage(usage: AgentUsage, part: {
 }): void;
 declare function hasNormalizedOpenCodeUsage(usage: AgentUsage): boolean;
 declare function buildOpenCodePromptParts(prompt: AgentPromptInput): Array<OpenCodeTextPartInput | OpenCodeFilePartInput>;
+declare function buildOpenCodeSessionTimeline(messages: ReadonlyArray<OpenCodeSessionMessage>): AgentTimelineItem[];
 export declare const __openCodeInternals: {
     buildOpenCodePromptParts: typeof buildOpenCodePromptParts;
+    buildOpenCodeSessionTimeline: typeof buildOpenCodeSessionTimeline;
     buildOpenCodeModelContextWindowLookup: typeof buildOpenCodeModelContextWindowLookup;
     buildOpenCodeModelDefinition: typeof buildOpenCodeModelDefinition;
     buildOpenCodeModelLookupKey: typeof buildOpenCodeModelLookupKey;
@@ -114,7 +120,8 @@ export declare class OpenCodeAgentClient implements AgentClient {
     listModes(options: ListModesOptions): Promise<AgentMode[]>;
     listCommands(config: AgentSessionConfig): Promise<AgentSlashCommand[]>;
     listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
-    listPersistedAgents(options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+    listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;
     shutdown(): Promise<void>;
     getDiagnostic(): Promise<{
@@ -133,6 +140,11 @@ export interface OpenCodeEventTranslationState {
     sessionTotalCostUsd?: number;
     streamedPartKeys: Set<string>;
     emittedStructuredMessageIds: Set<string>;
+    compactionSummaryMessageIds: Set<string>;
+    emittedCompactionPartIds: Set<string>;
+    suppressAssistantMessagesUntilIdle?: {
+        active: boolean;
+    };
     /** Tracks the type of each part by ID, learned from message.part.updated events. */
     partTypes: Map<string, string>;
     subAgentsByCallId?: Map<string, OpenCodeSubAgentActivityState>;
@@ -186,6 +198,9 @@ declare class OpenCodeAgentSession implements AgentSession {
     private streamedPartKeys;
     /** Tracks assistant messages already emitted from structured payloads. */
     private emittedStructuredMessageIds;
+    private compactionSummaryMessageIds;
+    private emittedCompactionPartIds;
+    private suppressAssistantMessagesUntilIdle;
     /** Tracks the type of each part by ID, learned from message.part.updated events. */
     private partTypes;
     private availableModesCache;

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

@@ -3,6 +3,7 @@ import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import pLimit from "p-limit";
 import { z } from "zod";
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
+import { importSessionFromPersistence } from "../provider-session-import.js";
 import { isDefaultAgentCreateConfigUnattended, resolveDefaultAgentCreateConfig, } from "../create-agent-mode.js";
 import { checkProviderLaunchAvailable, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { withTimeout } from "../../../utils/promise-timeout.js";
@@ -20,6 +21,7 @@ import { revertOpenCodeConversationAndFiles } from "./opencode/rewind.js";
 const OPENCODE_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
+    supportsSessionListing: true,
     supportsDynamicModes: true,
     supportsMcpServers: true,
     supportsReasoningStream: true,
@@ -135,8 +137,18 @@ const OPENCODE_PROVIDER_LIST_TIMEOUT_MS = 30000;
 const OPENCODE_METADATA_CONCURRENCY = 4;
 const openCodeMetadataLimit = pLimit(OPENCODE_METADATA_CONCURRENCY);
 const OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS = [
-    { name: "compact", description: "Compact the current session", argumentHint: "" },
-    { name: "summarize", description: "Compact the current session", argumentHint: "" },
+    {
+        name: "compact",
+        description: "Compact the current session",
+        argumentHint: "",
+        kind: "command",
+    },
+    {
+        name: "summarize",
+        description: "Compact the current session",
+        argumentHint: "",
+        kind: "command",
+    },
 ];
 const OPENCODE_HEADERS_TIMEOUT_TOKENS = [
     "headers timeout",
@@ -616,7 +628,7 @@ function buildOpenCodeUserTimelineText(prompt) {
         .filter((text) => text.trim().length > 0)
         .join("\n");
 }
-async function collectOpenCodePersistedAgentsFromSdk(client, options) {
+async function collectOpenCodeImportableSessionsFromSdk(client, options) {
     const limit = options?.limit ?? OPENCODE_PERSISTED_SESSION_LIMIT;
     const sessionListLimit = options?.cwd ? Math.max(limit, OPENCODE_PERSISTED_SESSION_LIMIT) : limit;
     const response = await client.experimental.session.list({
@@ -627,39 +639,19 @@ async function collectOpenCodePersistedAgentsFromSdk(client, options) {
     if (response.error) {
         throw new Error(`Failed to list OpenCode sessions: ${JSON.stringify(response.error)}`);
     }
-    const sessions = response.data ?? [];
     const matchesCwd = options?.cwd ? createPathEquivalenceMatcher(options.cwd) : null;
-    const candidates = sessions
+    return (response.data ?? [])
         .filter((session) => !matchesCwd || matchesCwd(session.directory))
         .sort((left, right) => getOpenCodeSessionTimestamp(right) - getOpenCodeSessionTimestamp(left))
-        .slice(0, limit);
-    return await Promise.all(candidates.map((session) => buildOpenCodePersistedAgentDescriptor(client, session)));
-}
-async function buildOpenCodePersistedAgentDescriptor(client, session) {
-    const messages = await readOpenCodeSessionMessagesFromSdk(client, session);
-    const timeline = buildOpenCodeSessionTimeline(messages);
-    const modeId = resolveOpenCodePersistedSessionModeId(session, messages);
-    const model = resolveOpenCodePersistedSessionModel(session, messages);
-    return {
-        provider: "opencode",
-        sessionId: session.id,
+        .slice(0, limit)
+        .map((session) => ({
+        providerHandleId: session.id,
         cwd: session.directory,
         title: normalizeOpenCodeSessionTitle(session.title),
+        firstPromptPreview: null,
+        lastPromptPreview: null,
         lastActivityAt: new Date(getOpenCodeSessionTimestamp(session)),
-        persistence: {
-            provider: "opencode",
-            sessionId: session.id,
-            nativeHandle: session.id,
-            metadata: {
-                provider: "opencode",
-                cwd: session.directory,
-                title: normalizeOpenCodeSessionTitle(session.title),
-                ...(modeId ? { modeId } : {}),
-                ...(model ? { model } : {}),
-            },
-        },
-        timeline,
-    };
+    }));
 }
 function normalizeOpenCodeSessionTitle(title) {
     const normalized = title?.trim();
@@ -728,6 +720,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 +738,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 +794,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 +835,7 @@ function buildOpenCodeReplayTimelineEvents(message) {
 }
 export const __openCodeInternals = {
     buildOpenCodePromptParts,
+    buildOpenCodeSessionTimeline,
     buildOpenCodeModelContextWindowLookup,
     buildOpenCodeModelDefinition,
     buildOpenCodeModelLookupKey,
@@ -1005,7 +1025,7 @@ export class OpenCodeAgentClient {
     async listFeatures(config) {
         return [buildOpenCodeAutoAcceptFeature(this.assertConfig(config))];
     }
-    async listPersistedAgents(options) {
+    async listImportableSessions(options) {
         const acquisition = await this.runtime.acquireServer({ force: false });
         const { url } = acquisition.server;
         const client = this.runtime.createClient({
@@ -1013,7 +1033,42 @@ export class OpenCodeAgentClient {
             directory: options?.cwd ?? "",
         });
         try {
-            return await collectOpenCodePersistedAgentsFromSdk(client, options);
+            return await collectOpenCodeImportableSessionsFromSdk(client, options);
+        }
+        finally {
+            acquisition.release();
+        }
+    }
+    async importSession(input, context) {
+        const acquisition = await this.runtime.acquireServer({ force: false });
+        const { url } = acquisition.server;
+        const client = this.runtime.createClient({
+            baseUrl: url,
+            directory: input.cwd,
+        });
+        try {
+            const sessionResponse = await client.session.get({
+                sessionID: input.providerHandleId,
+                directory: input.cwd,
+            });
+            if (sessionResponse.error || !sessionResponse.data) {
+                throw new Error(`Failed to load OpenCode session ${input.providerHandleId}`);
+            }
+            const session = sessionResponse.data;
+            const messages = await readOpenCodeSessionMessagesFromSdk(client, session);
+            const modeId = resolveOpenCodePersistedSessionModeId(session, messages);
+            const model = resolveOpenCodePersistedSessionModel(session, messages);
+            return await importSessionFromPersistence({
+                provider: "opencode",
+                request: input,
+                context,
+                resumeSession: this.resumeSession.bind(this),
+                config: {
+                    title: normalizeOpenCodeSessionTitle(session.title) ?? undefined,
+                    ...(modeId ? { modeId } : {}),
+                    ...(model ? { model } : {}),
+                },
+            });
         }
         finally {
             acquisition.release();
@@ -1151,6 +1206,7 @@ async function listOpenCodeCommandsFromSdk(client, directory) {
             name: cmd.name,
             description: cmd.description ?? "",
             argumentHint: cmd.hints?.length ? cmd.hints.join(" ") : "",
+            kind: cmd.source === "skill" ? "skill" : "command",
         });
     }
     return Array.from(commandsByName.values());
@@ -1370,6 +1426,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 +1653,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 +1707,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 +1730,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 +1758,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 +1809,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 +1829,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 +2030,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 +2164,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 +2184,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 +2193,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 +2806,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 { 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 { 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 ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModesOptions, type ListModelsOptions } 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,15 @@ 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[]>;
+    listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;
     getDiagnostic(): Promise<{
         diagnostic: string;