@getpaseo/server 0.1.91-beta.2 → 0.1.91

package/dist/scripts/supervisor.js

@@ -127,6 +127,26 @@ export function runSupervisor(options) {
                 execArgv: workerExecArgv,
             });
         }
+        const currentChild = child;
+        const heartbeat = setInterval(() => {
+            const message = { type: "paseo:supervisor-heartbeat" };
+            if (currentChild.connected) {
+                currentChild.send?.(message, (error) => {
+                    if (error) {
+                        writeLifecycleLog("Worker heartbeat IPC send failed", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                });
+            }
+            else {
+                writeLifecycleLog("Worker heartbeat skipped because IPC channel is disconnected");
+            }
+        }, 1000);
+        heartbeat.unref();
+        child.on("disconnect", () => {
+            writeLifecycleLog("Worker IPC channel disconnected");
+        });
         child.stdout?.on("data", (chunk) => {
             process.stdout.write(chunk);
             writeDurableChunk(chunk);
@@ -157,6 +177,7 @@ export function runSupervisor(options) {
             requestRestart("Restart requested by worker");
         });
         child.on("close", (code, signal) => {
+            clearInterval(heartbeat);
             const exitDescriptor = describeExit(code, signal);
             writeLifecycleLog("Worker exited", { code, signal, exit: exitDescriptor });
             if (shuttingDown) {

package/dist/server/server/agent/agent-manager.d.ts

@@ -163,7 +163,6 @@ export interface AgentMetricsSnapshot {
 export declare class AgentManager {
     private readonly clients;
     private readonly providerEnabled;
-    private readonly providerDerivedFromId;
     private readonly agents;
     private readonly timelineStore;
     private readonly agentsAwaitingInitialSnapshotPersist;
@@ -337,6 +336,7 @@ export declare class AgentManager {
     private dispatchStream;
     private dispatch;
     private normalizeConfig;
+    private prepareSessionConfig;
     private applyDaemonAppendSystemPrompt;
     private buildLaunchContext;
     private requireAvailableClient;

package/dist/server/server/agent/agent-manager.js

@@ -10,9 +10,9 @@ import { InMemoryAgentTimelineStore, } from "./agent-timeline-store.js";
 import { AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS, AgentStreamCoalescer, } from "./agent-stream-coalescer.js";
 import { ForegroundRunState } from "./foreground-run-state.js";
 import { getAgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
-import { IMPORTABLE_PROVIDERS } from "./provider-registry.js";
 import { invokeRewindCapability } from "./rewind/rewind.js";
 import { isSystemInjectedEnvelope } from "./agent-prompt.js";
+import { stripInternalPaseoMcpServer, withRuntimePaseoMcpServer } from "./runtime-mcp-config.js";
 const RELOAD_SESSION_CLOSE_TIMEOUT_MS = 3000;
 const INTERRUPT_SESSION_TIMEOUT_MS = 2000;
 const STORED_AGENT_CAPABILITIES = {
@@ -54,7 +54,7 @@ function buildStoredAgentConfig(record) {
     }
     if (record.config.mcpServers != null)
         config.mcpServers = record.config.mcpServers;
-    return config;
+    return stripInternalPaseoMcpServer(config);
 }
 export { AGENT_LIFECYCLE_STATUSES };
 function resolveInitialAttention(input) {
@@ -126,7 +126,6 @@ export class AgentManager {
     constructor(options) {
         this.clients = new Map();
         this.providerEnabled = new Map();
-        this.providerDerivedFromId = new Map();
         this.agents = new Map();
         this.timelineStore = new InMemoryAgentTimelineStore();
         this.agentsAwaitingInitialSnapshotPersist = new Set();
@@ -166,7 +165,6 @@ export class AgentManager {
         for (const [provider, definition] of Object.entries(input.providerDefinitions)) {
             if (definition) {
                 this.providerEnabled.set(provider, definition.enabled);
-                this.providerDerivedFromId.set(provider, definition.derivedFromProviderId ?? null);
             }
         }
         for (const [provider, client] of Object.entries(input.clients)) {
@@ -303,15 +301,9 @@ export class AgentManager {
             .slice(0, limit);
     }
     isProviderImportable(provider, providerFilter) {
-        if (!IMPORTABLE_PROVIDERS.includes(provider)) {
-            return false;
-        }
         if (this.providerEnabled.get(provider) === false) {
             return false;
         }
-        if (this.providerDerivedFromId.get(provider) != null) {
-            return false;
-        }
         if (providerFilter && !providerFilter.has(provider)) {
             return false;
         }
@@ -427,27 +419,15 @@ export class AgentManager {
     }
     async createAgent(config, agentId, options) {
         const resolvedAgentId = validateAgentId(agentId ?? this.idFactory(), "createAgent");
-        const injectedConfig = this.mcpBaseUrl == null
-            ? config
-            : {
-                ...config,
-                mcpServers: {
-                    paseo: {
-                        type: "http",
-                        url: `${this.mcpBaseUrl}?callerAgentId=${resolvedAgentId}`,
-                    },
-                    ...config.mcpServers,
-                },
-            };
-        this.requireEnabledProvider(injectedConfig.provider);
-        const normalizedConfig = this.applyDaemonAppendSystemPrompt(await this.normalizeConfig(injectedConfig));
+        const { storedConfig, launchConfig } = await this.prepareSessionConfig(config, resolvedAgentId);
+        this.requireEnabledProvider(storedConfig.provider);
         const launchContext = this.buildLaunchContext(resolvedAgentId, options?.env);
         const client = await this.requireAvailableClient({
-            provider: normalizedConfig.provider,
+            provider: storedConfig.provider,
         });
         const createOptions = this.buildCreateSessionOptions(options);
-        const session = await client.createSession(normalizedConfig, launchContext, createOptions);
-        return this.registerSession(session, normalizedConfig, resolvedAgentId, {
+        const session = await client.createSession(launchConfig, launchContext, createOptions);
+        return this.registerSession(session, storedConfig, resolvedAgentId, {
             labels: options?.labels,
             workspaceId: options?.workspaceId,
             initialTitle: options?.initialTitle,
@@ -468,29 +448,15 @@ export class AgentManager {
             ...overrides,
             provider: handle.provider,
         };
-        const normalizedConfig = this.applyDaemonAppendSystemPrompt(await this.normalizeConfig(mergedConfig));
-        const resumeOverrides = { ...overrides };
-        let hasResumeOverrides = overrides !== undefined;
-        if (normalizedConfig.model !== mergedConfig.model) {
-            resumeOverrides.model = normalizedConfig.model;
-            hasResumeOverrides = true;
-        }
-        if (normalizedConfig.modeId !== mergedConfig.modeId) {
-            resumeOverrides.modeId = normalizedConfig.modeId;
-            hasResumeOverrides = true;
-        }
-        if (metadata.daemonAppendSystemPrompt !== normalizedConfig.daemonAppendSystemPrompt) {
-            resumeOverrides.daemonAppendSystemPrompt = normalizedConfig.daemonAppendSystemPrompt;
-            hasResumeOverrides = true;
-        }
+        const { storedConfig, launchConfig } = await this.prepareSessionConfig(mergedConfig, resolvedAgentId);
         const launchContext = this.buildLaunchContext(resolvedAgentId);
         const client = this.requireClient(handle.provider);
         const available = await client.isAvailable();
         if (!available) {
             throw new Error(`Provider '${handle.provider}' is not available. Please ensure the CLI is installed.`);
         }
-        const session = await client.resumeSession(handle, hasResumeOverrides ? resumeOverrides : undefined, launchContext);
-        return this.registerSession(session, normalizedConfig, resolvedAgentId, options);
+        const session = await client.resumeSession(handle, launchConfig, launchContext);
+        return this.registerSession(session, storedConfig, resolvedAgentId, options);
     }
     // Hot-reload an active agent session with config overrides. By default the
     // in-memory timeline is preserved (used for voice-mode toggles and similar
@@ -517,11 +483,11 @@ export class AgentManager {
             ...overrides,
             provider,
         };
-        const normalizedConfig = this.applyDaemonAppendSystemPrompt(await this.normalizeConfig(refreshConfig));
+        const { storedConfig, launchConfig } = await this.prepareSessionConfig(refreshConfig, agentId);
         const launchContext = this.buildLaunchContext(agentId);
         const session = handle
-            ? await client.resumeSession(handle, normalizedConfig, launchContext)
-            : await client.createSession(normalizedConfig, launchContext);
+            ? await client.resumeSession(handle, launchConfig, launchContext)
+            : await client.createSession(launchConfig, launchContext);
         this.agentStreamCoalescer.flushAndDiscard(agentId);
         // Remove the existing agent entry before swapping sessions
         this.agents.delete(agentId);
@@ -539,7 +505,7 @@ export class AgentManager {
             this.timelineStore.delete(agentId);
         }
         // Preserve existing labels and timeline during reload.
-        return this.registerSession(session, normalizedConfig, agentId, {
+        return this.registerSession(session, storedConfig, agentId, {
             labels: existing.labels,
             createdAt: existing.createdAt,
             updatedAt: existing.updatedAt,
@@ -2503,6 +2469,15 @@ export class AgentManager {
         }
         return normalized;
     }
+    async prepareSessionConfig(config, agentId) {
+        const storedConfig = await this.normalizeConfig(stripInternalPaseoMcpServer(config));
+        const launchConfig = this.applyDaemonAppendSystemPrompt(withRuntimePaseoMcpServer({
+            config: storedConfig,
+            agentId,
+            mcpBaseUrl: this.mcpBaseUrl,
+        }));
+        return { storedConfig, launchConfig };
+    }
     applyDaemonAppendSystemPrompt(config) {
         const daemonAppendSystemPrompt = this.appendSystemPrompt.trim();
         const next = { ...config };

package/dist/server/server/agent/prompt-attachments.js

@@ -45,6 +45,14 @@ export function renderPromptAttachmentAsText(attachment) {
             });
             return lines.join("\n");
         }
+        case "uploaded_file": {
+            return [
+                `Uploaded file: ${attachment.fileName}`,
+                `Path: ${attachment.path}`,
+                `MIME: ${attachment.mimeType}`,
+                `Size: ${attachment.size} bytes`,
+            ].join("\n");
+        }
         default:
             throw new Error("unreachable");
     }

package/dist/server/server/agent/provider-registry.d.ts

@@ -19,7 +19,6 @@ export interface ProviderDefinition extends AgentProviderDefinition {
     fetchModels: (options: ListModelsOptions) => Promise<AgentModelDefinition[]>;
     fetchModes: (options: ListModesOptions) => Promise<AgentMode[]>;
 }
-export { IMPORTABLE_PROVIDERS } from "@getpaseo/protocol/importable-providers";
 export interface BuildProviderRegistryOptions {
     runtimeSettings?: AgentProviderRuntimeSettingsMap;
     providerOverrides?: Record<string, ProviderOverride>;

package/dist/server/server/agent/provider-registry.js

@@ -14,7 +14,6 @@ function isNonEmptyStringArray(value) {
     return value.length > 0;
 }
 export { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition };
-export { IMPORTABLE_PROVIDERS } from "@getpaseo/protocol/importable-providers";
 const PROVIDER_CLIENT_FACTORIES = {
     claude: (logger, runtimeSettings) => new ClaudeAgentClient({
         logger,
@@ -34,9 +33,22 @@ const PROVIDER_CLIENT_FACTORIES = {
         env: runtimeSettings?.env,
     }),
     opencode: (logger, runtimeSettings) => new OpenCodeAgentClient(logger, runtimeSettings),
-    pi: (logger, runtimeSettings) => new PiRpcAgentClient({
+    pi: (logger, runtimeSettings, options) => new PiRpcAgentClient({
         logger,
         runtimeSettings,
+        providerParams: options?.providerParams,
+    }),
+    omp: (logger, runtimeSettings, options) => new PiRpcAgentClient({
+        logger,
+        runtimeSettings: mergeRuntimeSettings({
+            command: {
+                mode: "replace",
+                argv: ["omp"],
+            },
+        }, runtimeSettings),
+        providerParams: options?.providerParams ?? {
+            sessionDir: "~/.omp/agent/sessions",
+        },
     }),
     mock: (logger) => new MockLoadTestAgentClient(logger),
     "mock-slow": () => new MockSlowProviderClient(),
@@ -293,10 +305,12 @@ function buildResolvedBuiltinProviders(providerOverrides, runtimeSettings, optio
             profileModels: override?.models ?? [],
             additionalModels: override?.additionalModels ?? [],
             profileModelsAreAdditive: false,
-            enabled: override?.enabled !== false,
+            enabled: override?.enabled ?? definition.enabledByDefault ?? true,
             derivedFromProviderId: null,
+            providerParams: override?.params,
             createBaseClient: (logger) => factory(logger, mergedRuntimeSettings, {
                 workspaceGitService: options.workspaceGitService,
+                providerParams: override?.params,
             }),
         });
     }
@@ -330,6 +344,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
                 profileModelsAreAdditive: false,
                 enabled: override.enabled !== false,
                 derivedFromProviderId: null,
+                providerParams: override.params,
                 createBaseClient: (logger) => providerId === "cursor"
                     ? new CursorACPAgentClient({
                         logger,
@@ -356,6 +371,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
         const mergedRuntimeSettings = mergeRuntimeSettings(baseProvider.runtimeSettings, toRuntimeSettings(override));
         const baseDefinition = baseProvider.definition;
         const baseFactory = getProviderClientFactory(baseProviderId);
+        const providerParams = override.params ?? baseProvider.providerParams;
         resolvedProviders.set(providerId, {
             definition: createDerivedDefinition(providerId, baseDefinition, override),
             runtimeSettings: mergedRuntimeSettings,
@@ -364,7 +380,9 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
             profileModelsAreAdditive: false,
             enabled: override.enabled !== false,
             derivedFromProviderId: baseProviderId,
+            providerParams,
             createBaseClient: (logger) => baseFactory(logger, mergedRuntimeSettings, {
+                providerParams,
                 customProvider: {
                     id: providerId,
                     label: override.label ?? providerId,

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -34,6 +34,14 @@ const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2000;
 const CODEX_PROVIDER = "codex";
 const CODEX_IMAGE_ATTACHMENT_DIR = "paseo-attachments";
+// Codex treats most app-server client names as the model-request originator.
+// This reserved Codex name is non-originating, so requests keep Codex's default
+// CLI identity instead of showing up as Paseo in provider usage logs.
+const CODEX_NON_ORIGINATING_APP_SERVER_CLIENT_INFO = {
+    name: "codex_app_server_daemon",
+    title: "Codex App Server Daemon",
+    version: "0.0.0",
+};
 const ASSISTANT_MESSAGE_BOUNDARY_MARKDOWN = "\n\n---\n\n";
 const CODEX_TOOL_THREAD_ITEM_TYPES = new Set([
     "commandExecution",
@@ -2093,11 +2101,7 @@ export function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
 }
 function buildCodexAppServerInitializeParams() {
     return {
-        clientInfo: {
-            name: "paseo",
-            title: "Paseo",
-            version: "0.0.0",
-        },
+        clientInfo: CODEX_NON_ORIGINATING_APP_SERVER_CLIENT_INFO,
         capabilities: {
             experimentalApi: true,
         },

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

@@ -76,6 +76,7 @@ export declare class TestOpenCodeClient {
     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

@@ -70,6 +70,7 @@ export class TestOpenCodeClient {
         this.sessionMessagesResponse = { data: [] };
         this.sessionPromptAsyncEvents = [idleEvent()];
         this.sessionPromptAsyncResponse = {};
+        this.sessionSummarizeEvents = [idleEvent()];
         this.sessionSummarizeResponse = { data: {} };
         this.sessionUpdateResponse = {};
         this.queuedEventStream = createQueuedEventStream();
@@ -182,6 +183,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 ResolveAgentCreateConfigInput, type ResolveAgentCreateConfigResult, type ListModelsOptions, type ListModesOptions, type ListPersistedAgentsOptions, type PersistedAgentDescriptor, 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;
@@ -133,6 +139,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 +197,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

@@ -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,