@getpaseo/server 0.9.2 → 0.10.0

package/dist/server/server/agent/providers/opencode/v2/turns.d.ts

@@ -0,0 +1,40 @@
+import type { SessionInfo, SessionMessageInfo } from "@opencode/client";
+import type { AgentPromptInput, AgentRunOptions, AgentStreamEvent, SteerActiveTurnOptions, SteerResult } from "../../../agent-sdk-types.js";
+import type { V2Api } from "./api.js";
+interface TurnSnapshot {
+    info: SessionInfo;
+    history: SessionMessageInfo[];
+}
+interface TurnOptions {
+    client(): V2Api;
+    id: string;
+    cwd: string;
+    signal: AbortSignal;
+    emit(event: AgentStreamEvent): void;
+    reconcile(): Promise<TurnSnapshot>;
+    clearPermissions(): Promise<void>;
+}
+export declare class SessionTurns {
+    private readonly options;
+    private turn;
+    private stopping;
+    private stopFailed;
+    executionError: string | null;
+    constructor(options: TurnOptions);
+    get id(): string | undefined;
+    get hasStructuredOutput(): boolean;
+    fail(error: Error): void;
+    startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{
+        turnId: `${string}-${string}-${string}-${string}-${string}`;
+    }>;
+    private submit;
+    private dispatch;
+    private finish;
+    private readExecutionError;
+    private promptInput;
+    steerActiveTurn(prompt: AgentPromptInput, options: SteerActiveTurnOptions): Promise<SteerResult>;
+    interrupt(): Promise<void>;
+    observeActiveTurn(): void;
+}
+export {};
+//# sourceMappingURL=turns.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/turns.js

@@ -0,0 +1,226 @@
+import { structuredOutput } from "./structured-output.js";
+import { randomUUID } from "node:crypto";
+import { toDiagnosticErrorMessage } from "../../diagnostic-utils.js";
+import { renderPromptAttachmentAsText } from "../../../prompt-attachments.js";
+import { usageFromV2 } from "./mapping.js";
+import { commands } from "./commands.js";
+export class SessionTurns {
+    constructor(options) {
+        this.options = options;
+        this.turn = null;
+        this.stopping = null;
+        this.stopFailed = false;
+        this.executionError = null;
+    }
+    get id() {
+        return this.turn?.id;
+    }
+    get hasStructuredOutput() {
+        return Boolean(this.turn?.output);
+    }
+    fail(error) {
+        const turn = this.turn;
+        this.turn = null;
+        if (turn)
+            this.options.emit({
+                type: "turn_failed",
+                provider: "opencode",
+                turnId: turn.id,
+                error: error.message,
+            });
+    }
+    async startTurn(prompt, options) {
+        await this.stopping;
+        if (this.options.signal.aborted)
+            throw new Error("OpenCode session is closed");
+        if (this.turn)
+            throw new Error("OpenCode session already has an active turn");
+        this.executionError = null;
+        const id = randomUUID();
+        const input = this.promptInput(prompt);
+        let accept;
+        const submitted = new Promise((resolve) => {
+            accept = resolve;
+        });
+        const output = options?.outputSchema === undefined ? undefined : structuredOutput(options.outputSchema);
+        const completion = this.submit(id, input, accept, options, output);
+        this.turn = { id, submitted, completion, output };
+        return { turnId: id };
+    }
+    async submit(id, input, accept, options, output) {
+        // Defer until startTurn publishes ownership, including for immediately resolved test transports.
+        await Promise.resolve();
+        this.options.emit({ type: "turn_started", provider: "opencode", turnId: id });
+        try {
+            await this.dispatch(input, options, output);
+            accept();
+            await this.finish(id);
+        }
+        catch (error) {
+            if (this.turn?.id === id) {
+                this.turn = null;
+                this.options.emit({
+                    type: "turn_failed",
+                    provider: "opencode",
+                    turnId: id,
+                    error: toDiagnosticErrorMessage(error),
+                });
+            }
+        }
+        finally {
+            accept();
+        }
+    }
+    async dispatch(input, options, output) {
+        const command = input.text.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/);
+        if (command?.[1] === "compact" || command?.[1] === "summarize") {
+            await this.options.client().session.compact({ sessionID: this.options.id });
+            return;
+        }
+        const selected = command
+            ? (await commands(this.options.client(), this.options.cwd)).find((item) => item.name === command[1])
+            : undefined;
+        if (selected && selected.kind !== "skill") {
+            await this.options.client().session.command({
+                sessionID: this.options.id,
+                name: selected.name,
+                text: command?.[2] ?? "",
+                files: input.files,
+            });
+            return;
+        }
+        await this.options.client().session.prompt({
+            sessionID: this.options.id,
+            ...input,
+            ...(selected?.kind === "skill"
+                ? {
+                    skills: [{ id: selected.name }],
+                    text: command?.[2] ?? `Use the ${selected.name} skill.`,
+                }
+                : {}),
+            metadata: {
+                ...(options?.clientMessageId ? { paseoClientMessageId: options.clientMessageId } : {}),
+                ...(output ? { paseoOutputSchema: output.schema } : {}),
+            },
+        });
+    }
+    async finish(id) {
+        await this.options
+            .client()
+            .session.wait({ sessionID: this.options.id }, { signal: this.options.signal });
+        const { info, history } = await this.options.reconcile();
+        if (this.turn?.id !== id)
+            return;
+        if (info.outcome !== "failed" && info.outcome !== "interrupted")
+            this.turn.output?.assert(history);
+        const failure = info.outcome === "failed" ? (this.executionError ?? (await this.readExecutionError())) : null;
+        if (this.turn?.id !== id)
+            return;
+        this.turn = null;
+        if (info.outcome === "interrupted")
+            this.options.emit({
+                type: "turn_canceled",
+                provider: "opencode",
+                turnId: id,
+                reason: "OpenCode interrupted execution",
+            });
+        else if (info.outcome === "failed")
+            this.options.emit({
+                type: "turn_failed",
+                provider: "opencode",
+                turnId: id,
+                error: failure ?? "OpenCode execution failed",
+            });
+        else
+            this.options.emit({
+                type: "turn_completed",
+                provider: "opencode",
+                turnId: id,
+                usage: usageFromV2(info),
+            });
+    }
+    async readExecutionError() {
+        let message = "OpenCode execution failed";
+        for await (const event of this.options
+            .client()
+            .session.log({ sessionID: this.options.id, follow: false }, { signal: this.options.signal })) {
+            if (event.type === "session.execution.failed")
+                message = event.data.error.message;
+        }
+        return message;
+    }
+    promptInput(prompt) {
+        if (typeof prompt === "string")
+            return { text: prompt, files: [] };
+        const text = [];
+        const files = [];
+        for (const part of prompt) {
+            if (part.type === "text")
+                text.push(part.text);
+            else if (part.type === "image")
+                files.push({ uri: `data:${part.mimeType};base64,${part.data}` });
+            else
+                text.push(renderPromptAttachmentAsText(part));
+        }
+        return { text: text.join("\n"), files };
+    }
+    async steerActiveTurn(prompt, options) {
+        if (this.turn?.id !== options.expectedTurnId || this.stopping)
+            return { status: "unavailable" };
+        await this.options.client().session.prompt({
+            sessionID: this.options.id,
+            ...this.promptInput(prompt),
+            delivery: "steer",
+            metadata: options.clientMessageId
+                ? { paseoClientMessageId: options.clientMessageId }
+                : undefined,
+        });
+        if (options.clearPendingPermissions)
+            await this.options.clearPermissions();
+        return { status: "accepted" };
+    }
+    async interrupt() {
+        if (!this.stopping || this.stopFailed) {
+            this.stopFailed = false;
+            const turn = this.turn;
+            const stop = (async () => {
+                // A stop sent before the queued prompt is accepted would interrupt an idle session.
+                await turn?.submitted;
+                await this.options.client().session.interrupt({ sessionID: this.options.id });
+                await turn?.completion;
+            })();
+            this.stopping = stop;
+            try {
+                await stop;
+                this.stopping = null;
+            }
+            catch (error) {
+                this.stopFailed = true;
+                throw error;
+            }
+        }
+        else
+            await this.stopping;
+    }
+    observeActiveTurn() {
+        if (this.turn)
+            return;
+        const id = randomUUID();
+        const completion = Promise.resolve()
+            .then(() => this.finish(id))
+            .catch((error) => {
+            if (this.turn?.id !== id)
+                return;
+            this.turn = null;
+            this.options.emit({
+                type: "turn_failed",
+                provider: "opencode",
+                turnId: id,
+                error: toDiagnosticErrorMessage(error),
+            });
+        });
+        this.turn = { id, submitted: Promise.resolve(), completion };
+        this.options.emit({ type: "turn_started", provider: "opencode", turnId: id });
+    }
+}
+//# sourceMappingURL=turns.js.map

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

@@ -129,6 +129,8 @@ export declare class OpenCodeAgentClient implements AgentClient {
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext, options?: AgentCreateSessionOptions): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     private applySessionPermissionRules;
+    private connectServer;
+    private toServerConnection;
     private acquireServer;
     private bindBridgeSession;
     fetchCatalog(options: FetchCatalogOptions, context?: ProviderRefreshContext): Promise<ProviderCatalog>;
@@ -195,15 +197,24 @@ interface OpenCodeSubAgentActivityState {
     childSessionId?: string;
 }
 export declare function translateOpenCodeEvent(event: OpenCodeEvent, state: OpenCodeEventTranslationState): AgentStreamEvent[];
+/** One OpenCode server generation a session talks to. */
+interface OpenCodeServerConnection {
+    client: OpencodeClient;
+    events: OpenCodeEventSource;
+    url: string;
+    release: () => Promise<void>;
+}
 declare class OpenCodeAgentSession implements AgentSession {
-    private readonly events;
     private readonly agentId?;
-    private readonly serverUrl?;
     private readonly externallyDriven;
     readonly provider: "opencode";
     readonly capabilities: AgentCapabilityFlags;
     private readonly config;
-    private readonly client;
+    private server;
+    /** Connects to the server generation that is current now. */
+    private readonly connectServer;
+    private serverExited;
+    private reconnection;
     private readonly sessionId;
     private readonly logger;
     private readonly modelContextWindowsByModelKey;
@@ -213,8 +224,7 @@ declare class OpenCodeAgentSession implements AgentSession {
     private abortController;
     private accumulatedUsage;
     private sessionTotalCostUsd;
-    private mcpConfigured;
-    private mcpSetupPromise;
+    private mcpSetup;
     private messageRoles;
     private pendingUserMessageText;
     private pendingClientMessageId;
@@ -252,7 +262,6 @@ declare class OpenCodeAgentSession implements AgentSession {
     private childHydrationCompleted;
     private readonly unrelatedSessionIds;
     private selectedModelContextWindowMaxTokens;
-    private releaseServer;
     private releaseBridge;
     private ingress;
     private gapRepairRevision;
@@ -261,7 +270,17 @@ declare class OpenCodeAgentSession implements AgentSession {
     private closed;
     private readonly persistSession;
     private deletedFromProvider;
-    constructor(config: OpenCodeAgentConfig, client: OpencodeClient, sessionId: string, logger: Logger, modelContextWindowsByModelKey?: ReadonlyMap<string, number>, events?: OpenCodeEventSource, releaseServer?: () => Promise<void>, persistSession?: boolean, agentId?: string | undefined, serverUrl?: string | undefined, externallyDriven?: boolean, releaseBridge?: () => void);
+    constructor(config: OpenCodeAgentConfig, client: OpencodeClient, sessionId: string, logger: Logger, modelContextWindowsByModelKey?: ReadonlyMap<string, number>, events?: OpenCodeEventSource, releaseServer?: () => Promise<void>, persistSession?: boolean, agentId?: string | undefined, serverUrl?: string, externallyDriven?: boolean, releaseBridge?: () => void, connectServer?: () => Promise<OpenCodeServerConnection>);
+    private get client();
+    private get events();
+    private subscribeServerEvents;
+    /**
+     * The OpenCode session outlives the server process that served it, and Paseo starts the
+     * next server on a new port. Move to the current server before talking to OpenCode again,
+     * so the session does not keep calling a port nothing listens on.
+     */
+    private reconnectIfServerExited;
+    private reconnect;
     get id(): string | null;
     private get activeForegroundTurnId();
     get features(): AgentFeature[];

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

@@ -912,7 +912,7 @@ function buildOpenCodeReplayTimelineEvents(message) {
     }
     if (info.role === "user") {
         const text = parts
-            .filter((part) => part.type === "text")
+            .filter((part) => part.type === "text" && isUserAuthoredOpenCodeText(part))
             .map((part) => part.text)
             .join("");
         return text
@@ -1001,12 +1001,9 @@ export class OpenCodeAgentClient {
     }
     async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.acquireServer(openCodeConfig, launchContext);
-        const { url } = acquisition.server;
-        const client = this.createOpenCodeClient({
-            baseUrl: url,
-            directory: openCodeConfig.cwd,
-        });
+        const connectServer = this.connectServer.bind(this, openCodeConfig, launchContext);
+        const connection = await connectServer();
+        const { client } = connection;
         // OpenCode stores permission rules on the session, so they are set here and on resume
         // rather than sent with each prompt, which drops them.
         const permission = buildOpenCodePermissionRules(openCodeConfig.providerOptions, openCodeConfig.toolPolicy);
@@ -1027,10 +1024,10 @@ export class OpenCodeAgentClient {
             }
             await this.populateModelContextWindowCache(client, openCodeConfig.cwd);
             const unbindBridge = this.bindBridgeSession(session.id, launchContext);
-            return new OpenCodeAgentSession(openCodeConfig, client, session.id, this.logger, new Map(this.modelContextWindows), acquisition.events, acquisition.release, options?.persistSession, launchContext?.agentId, url, false, unbindBridge);
+            return new OpenCodeAgentSession(openCodeConfig, client, session.id, this.logger, new Map(this.modelContextWindows), connection.events, connection.release, options?.persistSession, launchContext?.agentId, connection.url, false, unbindBridge, connectServer);
         }
         catch (error) {
-            await acquisition.release();
+            await connection.release();
             throw error;
         }
     }
@@ -1051,20 +1048,19 @@ export class OpenCodeAgentClient {
         const registeredAcquisition = registeredServerUrl
             ? this.serverManager.acquireExisting(registeredServerUrl)
             : null;
-        const acquisition = registeredAcquisition ?? (await this.acquireServer(openCodeConfig, launchContext));
-        const { url } = acquisition.server;
-        const client = this.createOpenCodeClient({
-            baseUrl: url,
-            directory: openCodeConfig.cwd,
-        });
+        const connectServer = this.connectServer.bind(this, openCodeConfig, launchContext);
+        const connection = registeredAcquisition
+            ? this.toServerConnection(registeredAcquisition, openCodeConfig.cwd)
+            : await connectServer();
+        const { client } = connection;
         try {
             await this.applySessionPermissionRules(client, openCodeConfig, handle.sessionId);
             await this.populateModelContextWindowCache(client, openCodeConfig.cwd);
             const unbindBridge = this.bindBridgeSession(handle.sessionId, launchContext);
-            return new OpenCodeAgentSession(openCodeConfig, client, handle.sessionId, this.logger, new Map(this.modelContextWindows), acquisition.events, acquisition.release, undefined, launchContext?.agentId, url, registeredAcquisition !== null, unbindBridge);
+            return new OpenCodeAgentSession(openCodeConfig, client, handle.sessionId, this.logger, new Map(this.modelContextWindows), connection.events, connection.release, undefined, launchContext?.agentId, connection.url, registeredAcquisition !== null, unbindBridge, connectServer);
         }
         catch (error) {
-            await acquisition.release();
+            await connection.release();
             throw error;
         }
     }
@@ -1077,6 +1073,18 @@ export class OpenCodeAgentClient {
             throw new Error(`Failed to apply OpenCode session permission rules: ${toDiagnosticErrorMessage(response.error)}`);
         }
     }
+    async connectServer(config, launchContext) {
+        const acquisition = await this.acquireServer(config, launchContext);
+        return this.toServerConnection(acquisition, config.cwd);
+    }
+    toServerConnection(acquisition, directory) {
+        return {
+            client: this.createOpenCodeClient({ baseUrl: acquisition.server.url, directory }),
+            events: acquisition.events,
+            url: acquisition.server.url,
+            release: acquisition.release,
+        };
+    }
     acquireServer(config, launchContext) {
         if (!this.bridge || requiresDedicatedOpenCodeServer(config, launchContext)) {
             return launchContext?.env
@@ -1997,9 +2005,15 @@ function shouldSuppressOpenCodeAssistantPart(part, messageRole, state) {
         part.type === "text" &&
         messageRole !== "user");
 }
+// OpenCode marks text it adds to a user message itself with `synthetic` and hides it from its own UI.
+function isUserAuthoredOpenCodeText(part) {
+    return part.synthetic !== true;
+}
 function appendOpenCodeTextPart(part, messageRole, state, events) {
     if (messageRole === "user") {
-        if (!part.text || state.emittedUserMessageIds?.has(part.messageID)) {
+        if (!part.text ||
+            !isUserAuthoredOpenCodeText(part) ||
+            state.emittedUserMessageIds?.has(part.messageID)) {
             return;
         }
         state.emittedUserMessageIds?.add(part.messageID);
@@ -2376,20 +2390,19 @@ async function listOpenCodeChildSessions(client, sessionId, directory, signal) {
     return readOpenCodeChildSessionInfosFromResponse(sessionIdResponse) ?? [];
 }
 class OpenCodeAgentSession {
-    constructor(config, client, sessionId, logger, modelContextWindowsByModelKey = new Map(), events = EMPTY_OPENCODE_EVENT_SOURCE, releaseServer, persistSession = true, agentId, serverUrl, externallyDriven = false, releaseBridge) {
-        this.events = events;
+    constructor(config, client, sessionId, logger, modelContextWindowsByModelKey = new Map(), events = EMPTY_OPENCODE_EVENT_SOURCE, releaseServer = async () => undefined, persistSession = true, agentId, serverUrl, externallyDriven = false, releaseBridge, connectServer) {
         this.agentId = agentId;
-        this.serverUrl = serverUrl;
         this.externallyDriven = externallyDriven;
         this.provider = "opencode";
         this.capabilities = OPENCODE_CAPABILITIES;
+        this.serverExited = false;
+        this.reconnection = null;
         this.currentMode = null;
         this.autoAcceptEnabled = false;
         this.pendingPermissions = new Map();
         this.abortController = null;
         this.accumulatedUsage = {};
-        this.mcpConfigured = false;
-        this.mcpSetupPromise = null;
+        this.mcpSetup = null;
         this.messageRoles = new Map();
         this.pendingUserMessageText = null;
         this.pendingClientMessageId = null;
@@ -2433,19 +2446,30 @@ class OpenCodeAgentSession {
         this.closed = false;
         this.deletedFromProvider = false;
         this.config = config;
-        this.client = client;
+        this.server = { client, events, url: serverUrl ?? "", release: releaseServer };
+        this.connectServer = connectServer ?? null;
         this.sessionId = sessionId;
         this.logger = logger.child({ agentId: this.agentId });
         this.modelContextWindowsByModelKey = modelContextWindowsByModelKey;
         this.currentMode = normalizeOpenCodeModeId(config.modeId);
         this.autoAcceptEnabled = !config.toolPolicy && isOpenCodeAutoAcceptEnabled(config);
-        this.releaseServer = releaseServer ?? null;
         this.releaseBridge = releaseBridge ?? null;
         this.persistSession = persistSession;
         this.selectedModelContextWindowMaxTokens = this.resolveConfiguredModelContextWindowMaxTokens(config.model);
+        this.subscribeServerEvents();
+    }
+    get client() {
+        return this.server.client;
+    }
+    get events() {
+        return this.server.events;
+    }
+    subscribeServerEvents() {
         this.unsubscribeEvents = this.events.subscribe((input) => {
-            if ("type" in input && input.type === "server-exited")
+            if ("type" in input && input.type === "server-exited") {
                 this.recoveryAbortController.abort(input.error);
+                this.serverExited = true;
+            }
             this.ingress = this.ingress
                 .then(() => this.consumeEventSourceInput(input))
                 .catch((error) => {
@@ -2453,6 +2477,43 @@ class OpenCodeAgentSession {
             });
         });
     }
+    /**
+     * The OpenCode session outlives the server process that served it, and Paseo starts the
+     * next server on a new port. Move to the current server before talking to OpenCode again,
+     * so the session does not keep calling a port nothing listens on.
+     */
+    async reconnectIfServerExited() {
+        if (!this.serverExited || !this.connectServer)
+            return;
+        this.reconnection ?? (this.reconnection = this.reconnect(this.connectServer).finally(() => {
+            this.reconnection = null;
+        }));
+        await this.reconnection;
+    }
+    async reconnect(connectServer) {
+        const exited = this.server;
+        const next = await connectServer();
+        if (this.closed) {
+            await next.release();
+            return;
+        }
+        this.unsubscribeEvents?.();
+        this.unsubscribeEvents = null;
+        // Let the exited server's queued events, including its exit, settle while no turn is
+        // running, so none of them can fail a turn started on the new server.
+        await this.ingress;
+        if (this.closed) {
+            await next.release();
+            return;
+        }
+        this.server = next;
+        this.serverExited = false;
+        this.recoveryAbortController = new AbortController();
+        this.mcpSetup = null;
+        this.subscribeServerEvents();
+        this.logger.info({ sessionId: this.sessionId, previousUrl: exited.url, url: next.url }, "OpenCode session moved to the current server after its server exited");
+        await exited.release();
+    }
     get id() {
         return this.sessionId;
     }
@@ -2580,6 +2641,7 @@ class OpenCodeAgentSession {
         }
     }
     async revertBoth(input) {
+        await this.reconnectIfServerExited();
         await revertOpenCodeConversationAndFiles({
             client: this.client,
             sessionId: this.sessionId,
@@ -2680,6 +2742,7 @@ class OpenCodeAgentSession {
         if (this.turnState.status === "running") {
             throw new Error("A foreground turn is already active");
         }
+        await this.reconnectIfServerExited();
         try {
             await this.awaitRunnerQuiescence();
         }
@@ -3094,8 +3157,8 @@ class OpenCodeAgentSession {
             if (event.event.cwd) {
                 this.childSessionCwds.set(event.event.id, event.event.cwd);
             }
-            if (this.serverUrl) {
-                registerOpenCodeChildSessionServerUrl(event.event.id, this.serverUrl);
+            if (this.server.url) {
+                registerOpenCodeChildSessionServerUrl(event.event.id, this.server.url);
             }
         }
         else if (event.event.type === "remove") {
@@ -3574,6 +3637,7 @@ class OpenCodeAgentSession {
         }, msg);
     }
     async *streamHistory() {
+        await this.reconnectIfServerExited();
         const sessionResponse = await this.client.session.get({
             sessionID: this.sessionId,
             directory: this.config.cwd,
@@ -3596,6 +3660,7 @@ class OpenCodeAgentSession {
         if (this.availableModesCache) {
             return this.availableModesCache;
         }
+        await this.reconnectIfServerExited();
         const response = await openCodeMetadataLimit(() => this.client.app.agents({
             directory: this.config.cwd,
         }));
@@ -3608,6 +3673,7 @@ class OpenCodeAgentSession {
         return this.currentMode;
     }
     async listCommands() {
+        await this.reconnectIfServerExited();
         return await listOpenCodeCommandsFromSdk(this.client, this.config.cwd);
     }
     async setMode(modeId) {
@@ -3714,8 +3780,7 @@ class OpenCodeAgentSession {
         finally {
             this.releaseBridge?.();
             this.releaseBridge = null;
-            await this.releaseServer?.();
-            this.releaseServer = null;
+            await this.server.release();
         }
     }
     async deleteProviderSessionIfEphemeral() {
@@ -3778,23 +3843,18 @@ class OpenCodeAgentSession {
         return { providerID: "opencode", modelID: model };
     }
     async ensureMcpServersConfigured() {
-        if (this.mcpConfigured) {
-            return;
-        }
         const mcpServers = this.config.mcpServers;
         if (!mcpServers || Object.keys(mcpServers).length === 0) {
-            this.mcpConfigured = true;
             return;
         }
-        if (!this.mcpSetupPromise) {
-            this.mcpSetupPromise = this.configureMcpServers(mcpServers);
-        }
+        const setup = (this.mcpSetup ?? (this.mcpSetup = this.configureMcpServers(mcpServers)));
         try {
-            await this.mcpSetupPromise;
-            this.mcpConfigured = true;
+            await setup;
         }
         catch (error) {
-            this.mcpSetupPromise = null;
+            if (this.mcpSetup === setup) {
+                this.mcpSetup = null;
+            }
             throw error;
         }
     }

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

@@ -38,8 +38,7 @@ export declare class PiRpcAgentSession implements AgentSession {
     private readonly subscribers;
     private readonly activeToolCalls;
     private readonly pendingExtensionUiRequests;
-    private activeAskUserDialog;
-    private pendingCombinedAskUserResponse;
+    private readonly extensionHost;
     private activeTurnId;
     private activeClientMessageId;
     private activeAssistantMessageId;
@@ -52,8 +51,8 @@ export declare class PiRpcAgentSession implements AgentSession {
     private readonly pendingPromptResults;
     private readonly pendingSteerSubmissions;
     currentLeafOverrideId: string | null | undefined;
-    private readonly capturedUserEntries;
-    private readonly capturedUserEntriesById;
+    private readonly contextUserEntries;
+    private readonly treeUserEntriesById;
     private readonly pendingExtensionResults;
     private outOfBandCompactionEmit;
     private outOfBandCompactionStarted;
@@ -64,6 +63,8 @@ export declare class PiRpcAgentSession implements AgentSession {
     private readonly logger;
     private readonly usagePoller;
     private closed;
+    private readonly closeController;
+    private readonly pendingExtensionHydrations;
     private interruptingTurn;
     constructor(options: PiRpcAgentSessionOptions);
     private readonly runtimeSession;
@@ -100,6 +101,7 @@ export declare class PiRpcAgentSession implements AgentSession {
     setModel(modelId: string | null): Promise<void>;
     setThinkingOption(thinkingOptionId: string | null): Promise<void>;
     private emit;
+    private emitExtensionOutput;
     private currentTurnIdForEvent;
     private completeNoTurnPrompt;
     private completePromptIfHandledWithoutTurn;
@@ -119,7 +121,6 @@ export declare class PiRpcAgentSession implements AgentSession {
     private handleEntryCaptureMarker;
     private handleCommandResultMarker;
     private handleExtensionUiRequest;
-    private respondToCombinedAskUserFollowUp;
     private handleCommandOutput;
     private handleRuntimeEvent;
     private handleProcessExit;
@@ -131,7 +132,6 @@ export declare class PiRpcAgentSession implements AgentSession {
     private handleMessageStart;
     private handleMessageEnd;
     private emitToolCallEvent;
-    private mapToolDetail;
     private completeTurn;
     private refreshState;
     private refreshAfterTurn;