@getpaseo/server 0.1.83 → 0.1.85

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

@@ -0,0 +1,45 @@
+export const MOCK_SLOW_PROVIDER_ID = "mock-slow";
+const CAPABILITIES = {
+    supportsStreaming: false,
+    supportsSessionPersistence: false,
+    supportsDynamicModes: false,
+    supportsMcpServers: false,
+    supportsReasoningStream: false,
+    supportsToolInvocations: false,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
+};
+function neverResolves() {
+    return new Promise(() => { });
+}
+export class MockSlowProviderClient {
+    constructor() {
+        this.provider = MOCK_SLOW_PROVIDER_ID;
+        this.capabilities = CAPABILITIES;
+    }
+    async isAvailable() {
+        return true;
+    }
+    listModels(_options) {
+        return neverResolves();
+    }
+    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.",
+        };
+    }
+    createSession(_config, _launchContext) {
+        throw new Error("Mock slow provider is dev-only; sessions are not supported.");
+    }
+    resumeSession(_handle, _overrides, _launchContext) {
+        throw new Error("Mock slow provider is dev-only; sessions are not supported.");
+    }
+}
+//# sourceMappingURL=mock-slow-provider.js.map

package/dist/server/server/agent/providers/opencode/tool-call-detail-parser.js

@@ -164,6 +164,23 @@ function deriveOpencodeTaskDetail(input, output, error) {
         actions: [],
     };
 }
+const OpencodeEditInputSchema = z.union([
+    z
+        .object({
+        filePath: z.string(),
+        oldString: z.string().optional(),
+        newString: z.string().optional(),
+    })
+        .passthrough()
+        .transform((value) => ({
+        filePath: value.filePath,
+        oldString: nonEmptyString(value.oldString),
+        newString: nonEmptyString(value.newString),
+        unifiedDiff: undefined,
+    })),
+    ToolEditInputSchema,
+]);
+const OpencodeEditOutputSchema = z.union([z.string().transform(() => null), ToolEditOutputSchema]);
 const OpencodeKnownToolDetailSchema = z.union([
     toolDetailBranchByToolName("shell", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
     toolDetailBranchByToolName("bash", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
@@ -179,10 +196,10 @@ const OpencodeKnownToolDetailSchema = z.union([
     toolDetailBranchByToolName("write", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
     toolDetailBranchByToolName("write_file", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
     toolDetailBranchByToolName("create_file", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
-    toolDetailBranchByToolName("edit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
-    toolDetailBranchByToolName("apply_patch", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByToolName("edit", OpencodeEditInputSchema, OpencodeEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByToolName("apply_patch", OpencodeEditInputSchema, OpencodeEditOutputSchema, toEditToolDetail),
     toolDetailBranchByToolName("apply_patch", OpencodeApplyPatchTextInputSchema, z.unknown(), (input) => toEditToolDetail(input, null)),
-    toolDetailBranchByToolName("apply_diff", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByToolName("apply_diff", OpencodeEditInputSchema, OpencodeEditOutputSchema, toEditToolDetail),
     toolDetailBranchByToolName("search", ToolSearchInputSchema, z.unknown(), (input) => toSearchToolDetail({ input, toolName: "search" })),
     toolDetailBranchByToolName("grep", ToolSearchInputSchema, OpencodeGrepOutputSchema, (input, output) => toSearchToolDetail({ input, output, toolName: "grep" })),
     toolDetailBranchByToolName("glob", ToolSearchInputSchema, z.unknown(), (input, output) => {

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

@@ -1,8 +1,11 @@
 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 { 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 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 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";
+declare function resolveOpenCodeCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
+declare function isOpenCodeCreateConfigUnattended(input: Parameters<typeof isDefaultAgentCreateConfigUnattended>[0]): boolean;
 type OpenCodeAgentConfig = AgentSessionConfig & {
     provider: "opencode";
 };
@@ -98,6 +101,8 @@ interface OpenCodeAgentClientDeps {
 export declare class OpenCodeAgentClient implements AgentClient {
     readonly provider: "opencode";
     readonly capabilities: AgentCapabilityFlags;
+    readonly resolveCreateConfig: typeof resolveOpenCodeCreateConfig;
+    readonly isCreateConfigUnattended: typeof isOpenCodeCreateConfigUnattended;
     private readonly runtime;
     private readonly logger;
     private readonly runtimeSettings?;
@@ -108,9 +113,10 @@ export declare class OpenCodeAgentClient implements AgentClient {
     listModels(options: ListModelsOptions): Promise<AgentModelDefinition[]>;
     listModes(options: ListModesOptions): Promise<AgentMode[]>;
     listCommands(config: AgentSessionConfig): Promise<AgentSlashCommand[]>;
-    listFeatures(_config: AgentSessionConfig): Promise<AgentFeature[]>;
+    listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     listPersistedAgents(options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
     isAvailable(): Promise<boolean>;
+    shutdown(): Promise<void>;
     getDiagnostic(): Promise<{
         diagnostic: string;
     }>;
@@ -164,6 +170,7 @@ declare class OpenCodeAgentSession implements AgentSession {
     private readonly logger;
     private readonly modelContextWindowsByModelKey;
     private currentMode;
+    private autoAcceptEnabled;
     private pendingPermissions;
     private abortController;
     private pendingAbortPromise;
@@ -199,6 +206,7 @@ declare class OpenCodeAgentSession implements AgentSession {
     private deletedFromProvider;
     constructor(config: OpenCodeAgentConfig, client: OpencodeClient, sessionId: string, logger: Logger, modelContextWindowsByModelKey?: ReadonlyMap<string, number>, releaseServer?: () => void, persistSession?: boolean, agentId?: string | undefined);
     get id(): string | null;
+    get features(): AgentFeature[];
     getRuntimeInfo(): Promise<AgentRuntimeInfo>;
     setModel(modelId: string | null): Promise<void>;
     setThinkingOption(thinkingOptionId: string | null): Promise<void>;
@@ -228,6 +236,7 @@ declare class OpenCodeAgentSession implements AgentSession {
     getCurrentMode(): Promise<string | null>;
     listCommands(): Promise<AgentSlashCommand[]>;
     setMode(modeId: string): Promise<void>;
+    setFeature(featureId: string, value: unknown): Promise<void>;
     getPendingPermissions(): AgentPermissionRequest[];
     respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<void>;
     describePersistence(): AgentPersistenceHandle | null;

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

@@ -1,15 +1,15 @@
 import { homedir } from "node:os";
-import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import { z } from "zod";
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
-import { createProviderEnvSpec } from "../provider-launch-config.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";
 import { execCommand } from "../../../utils/spawn.js";
-import { buildToolCallDisplayModel } from "../../../shared/tool-call-display.js";
+import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
 import { OpenCodeServerManager } from "./opencode/server-manager.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
@@ -28,7 +28,8 @@ const OPENCODE_CAPABILITIES = {
     supportsRewindBoth: true,
 };
 const OPENCODE_BUILD_MODE_ID = "build";
-const OPENCODE_FULL_ACCESS_MODE_ID = "full-access";
+const OPENCODE_LEGACY_FULL_ACCESS_MODE_ID = "full-access";
+const OPENCODE_AUTO_ACCEPT_FEATURE_ID = "auto_accept";
 const OPENCODE_PERSISTED_SESSION_LIMIT = 200;
 const OPENCODE_PENDING_ABORT_START_TIMEOUT_MS = 10000;
 const OPENCODE_PERMISSION_ACTION_ALLOW_ONCE = "allow_once";
@@ -44,12 +45,51 @@ const DEFAULT_MODES = [
         label: "Plan",
         description: "Read-only planning mode that avoids file edits",
     },
-    {
-        id: OPENCODE_FULL_ACCESS_MODE_ID,
-        label: "Full Access",
-        description: "Automatically approves all tool permission prompts for the session",
-    },
 ];
+function isOpenCodeAutoAcceptEnabled(config) {
+    return config.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === true;
+}
+function withOpenCodeAutoAcceptFeature(featureValues, enabled) {
+    return {
+        ...featureValues,
+        [OPENCODE_AUTO_ACCEPT_FEATURE_ID]: enabled,
+    };
+}
+function resolveOpenCodeCreateConfig(input) {
+    const legacyFullAccess = input.requestedMode === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID;
+    const inheritsUnattended = input.requestedMode === undefined && input.parent?.isUnattended === true;
+    const requestedMode = legacyFullAccess ? OPENCODE_BUILD_MODE_ID : input.requestedMode;
+    const featureValues = legacyFullAccess ||
+        (inheritsUnattended && input.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === undefined)
+        ? withOpenCodeAutoAcceptFeature(input.featureValues, true)
+        : input.featureValues;
+    if (inheritsUnattended && requestedMode === undefined) {
+        return { modeId: OPENCODE_BUILD_MODE_ID, featureValues };
+    }
+    const resolved = resolveDefaultAgentCreateConfig({
+        ...input,
+        requestedMode,
+        featureValues,
+    });
+    return { ...resolved, featureValues };
+}
+function isOpenCodeCreateConfigUnattended(input) {
+    return (isDefaultAgentCreateConfigUnattended(input) ||
+        input.config.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === true ||
+        input.features?.some((feature) => feature.id === OPENCODE_AUTO_ACCEPT_FEATURE_ID &&
+            (feature.value === true || feature.value === "true")) === true);
+}
+function buildOpenCodeAutoAcceptFeature(config) {
+    return {
+        type: "toggle",
+        id: OPENCODE_AUTO_ACCEPT_FEATURE_ID,
+        label: "Auto Accept",
+        description: "Automatically approves OpenCode tool permission prompts.",
+        tooltip: "Auto accept permission prompts",
+        icon: "shield-check",
+        value: isOpenCodeAutoAcceptEnabled(config),
+    };
+}
 function buildOpenCodePermissionActions() {
     return [
         {
@@ -271,6 +311,14 @@ function isAlreadyPresentMcpError(error) {
     const normalized = toDiagnosticErrorMessage(error).toLowerCase();
     return MCP_ALREADY_PRESENT_ERROR_TOKENS.some((token) => normalized.includes(token));
 }
+function readOpenCodeMcpOperationError(data, name) {
+    const root = readOpenCodeRecord(data);
+    const entry = readOpenCodeRecord(root?.[name]);
+    if (!entry || entry.status !== "failed") {
+        return undefined;
+    }
+    return entry.error ?? `OpenCode reported MCP server '${name}' failed`;
+}
 function resolvePartDedupeKey(part, partType) {
     if (part.id.trim().length > 0) {
         return `${partType}:${part.id}`;
@@ -289,10 +337,23 @@ function normalizeOpenCodeModeId(modeId) {
 }
 function resolveOpenCodeRuntimeAgentId(modeId) {
     const normalizedModeId = normalizeOpenCodeModeId(modeId);
-    return normalizedModeId === OPENCODE_FULL_ACCESS_MODE_ID
+    return normalizedModeId === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID
         ? OPENCODE_BUILD_MODE_ID
         : normalizedModeId;
 }
+function normalizeOpenCodeConfig(config) {
+    if (normalizeOpenCodeModeId(config.modeId) !== OPENCODE_LEGACY_FULL_ACCESS_MODE_ID) {
+        return { ...config };
+    }
+    return {
+        ...config,
+        modeId: OPENCODE_BUILD_MODE_ID,
+        featureValues: {
+            ...config.featureValues,
+            [OPENCODE_AUTO_ACCEPT_FEATURE_ID]: true,
+        },
+    };
+}
 function isSelectableOpenCodeAgent(agent) {
     return (agent.mode === "primary" || agent.mode === "all") && agent.hidden !== true;
 }
@@ -307,6 +368,7 @@ function mapOpenCodeAgentToMode(agent) {
     return {
         id: agent.name,
         label: agent.name.charAt(0).toUpperCase() + agent.name.slice(1),
+        icon: "Bot",
         description: typeof agent.description === "string" && agent.description.trim().length > 0
             ? agent.description.trim()
             : DEFAULT_MODES.find((mode) => mode.id === agent.name)?.description,
@@ -316,6 +378,9 @@ function mapOpenCodeAgentToMode(agent) {
 function mergeOpenCodeModes(discoveredModes) {
     const modesById = new Map(DEFAULT_MODES.map((mode) => [mode.id, mode]));
     for (const mode of discoveredModes) {
+        if (mode.id === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID) {
+            continue;
+        }
         modesById.set(mode.id, mode);
     }
     return sortOpenCodeModes(Array.from(modesById.values()));
@@ -778,6 +843,8 @@ export class OpenCodeAgentClient {
     constructor(logger, runtimeSettings, deps = {}) {
         this.provider = "opencode";
         this.capabilities = OPENCODE_CAPABILITIES;
+        this.resolveCreateConfig = resolveOpenCodeCreateConfig;
+        this.isCreateConfigUnattended = isOpenCodeCreateConfigUnattended;
         this.modelContextWindows = new Map();
         this.logger = logger.child({ module: "agent", provider: "opencode" });
         this.runtimeSettings = runtimeSettings;
@@ -925,8 +992,8 @@ export class OpenCodeAgentClient {
             acquisition.release();
         }
     }
-    async listFeatures(_config) {
-        return [];
+    async listFeatures(config) {
+        return [buildOpenCodeAutoAcceptFeature(this.assertConfig(config))];
     }
     async listPersistedAgents(options) {
         const acquisition = await this.runtime.acquireServer({ force: false });
@@ -943,16 +1010,24 @@ export class OpenCodeAgentClient {
         }
     }
     async isAvailable() {
-        const command = this.runtimeSettings?.command;
-        if (command?.mode === "replace") {
-            return await isCommandAvailable(command.argv[0]);
-        }
-        return await isCommandAvailable("opencode");
+        const launch = await resolveProviderLaunch({
+            commandConfig: this.runtimeSettings?.command,
+            defaultBinary: "opencode",
+        });
+        const availability = await checkProviderLaunchAvailable(launch);
+        return availability.available;
+    }
+    async shutdown() {
+        await this.runtime.shutdown();
     }
     async getDiagnostic() {
         try {
-            const available = await this.isAvailable();
-            const resolvedBinary = await findExecutable("opencode");
+            const launch = await resolveProviderLaunch({
+                commandConfig: this.runtimeSettings?.command,
+                defaultBinary: "opencode",
+            });
+            const availability = await checkProviderLaunchAvailable(launch);
+            const available = availability.available;
             let serverStatus = "Not running";
             let modelsValue = "Not checked";
             let status = formatDiagnosticStatus(available);
@@ -964,9 +1039,12 @@ export class OpenCodeAgentClient {
                 serverStatus = `Unavailable (${toDiagnosticErrorMessage(error)})`;
             }
             let authValue = "Not checked";
-            if (resolvedBinary) {
+            const authCommand = availability.available
+                ? (availability.resolvedPath ?? launch.command)
+                : null;
+            if (authCommand) {
                 try {
-                    const { stdout, stderr } = await execCommand(resolvedBinary, ["auth", "list"], {
+                    const { stdout, stderr } = await execCommand(authCommand, [...launch.args, "auth", "list"], {
                         ...createProviderEnvSpec(),
                         timeout: 5000,
                     });
@@ -1003,14 +1081,7 @@ export class OpenCodeAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("OpenCode", [
-                    {
-                        label: "Binary",
-                        value: resolvedBinary ?? "not found",
-                    },
-                    {
-                        label: "Version",
-                        value: resolvedBinary ? await resolveBinaryVersion(resolvedBinary) : "unknown",
-                    },
+                    ...(await buildBinaryDiagnosticRows(launch, availability)),
                     { label: "Server", value: serverStatus },
                     { label: "Auth", value: authValue },
                     { label: "Models", value: modelsValue },
@@ -1028,7 +1099,7 @@ export class OpenCodeAgentClient {
         if (config.provider !== "opencode") {
             throw new Error(`OpenCodeAgentClient received config for provider '${config.provider}'`);
         }
-        return { ...config, provider: "opencode" };
+        return normalizeOpenCodeConfig({ ...config, provider: "opencode" });
     }
     async populateModelContextWindowCache(client, cwd) {
         const response = await client.provider.list({ directory: cwd });
@@ -1838,6 +1909,7 @@ class OpenCodeAgentSession {
         this.provider = "opencode";
         this.capabilities = OPENCODE_CAPABILITIES;
         this.currentMode = "default";
+        this.autoAcceptEnabled = false;
         this.pendingPermissions = new Map();
         this.abortController = null;
         this.pendingAbortPromise = null;
@@ -1873,6 +1945,7 @@ class OpenCodeAgentSession {
         this.logger = logger.child({ agentId: this.agentId });
         this.modelContextWindowsByModelKey = modelContextWindowsByModelKey;
         this.currentMode = normalizeOpenCodeModeId(config.modeId);
+        this.autoAcceptEnabled = isOpenCodeAutoAcceptEnabled(config);
         this.releaseServer = releaseServer ?? null;
         this.persistSession = persistSession;
         this.selectedModelContextWindowMaxTokens = this.resolveConfiguredModelContextWindowMaxTokens(config.model);
@@ -1881,6 +1954,9 @@ class OpenCodeAgentSession {
     get id() {
         return this.sessionId;
     }
+    get features() {
+        return [buildOpenCodeAutoAcceptFeature(this.config)];
+    }
     async getRuntimeInfo() {
         return {
             provider: "opencode",
@@ -2403,7 +2479,25 @@ class OpenCodeAgentSession {
         return await listOpenCodeCommandsFromSdk(this.client, this.config.cwd);
     }
     async setMode(modeId) {
-        this.currentMode = normalizeOpenCodeModeId(modeId);
+        const normalizedModeId = normalizeOpenCodeModeId(modeId);
+        if (normalizedModeId === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID) {
+            this.currentMode = OPENCODE_BUILD_MODE_ID;
+            await this.setFeature(OPENCODE_AUTO_ACCEPT_FEATURE_ID, true);
+            return;
+        }
+        this.currentMode = normalizedModeId;
+        this.config.modeId = normalizedModeId;
+    }
+    async setFeature(featureId, value) {
+        if (featureId !== OPENCODE_AUTO_ACCEPT_FEATURE_ID) {
+            throw new Error(`Unsupported OpenCode feature '${featureId}'`);
+        }
+        const enabled = value === true;
+        this.autoAcceptEnabled = enabled;
+        this.config.featureValues = {
+            ...this.config.featureValues,
+            [OPENCODE_AUTO_ACCEPT_FEATURE_ID]: enabled,
+        };
     }
     getPendingPermissions() {
         return Array.from(this.pendingPermissions.values());
@@ -2582,7 +2676,7 @@ class OpenCodeAgentSession {
     }
     async runMcpOperation(operation, name, run) {
         const response = await run();
-        const error = response.error;
+        const error = response.error ?? readOpenCodeMcpOperationError(response.data, name);
         if (!error) {
             return;
         }
@@ -2639,7 +2733,7 @@ class OpenCodeAgentSession {
         return events;
     }
     async tryAutoApproveToolPermission(request) {
-        if (this.currentMode !== OPENCODE_FULL_ACCESS_MODE_ID || request.kind !== "tool") {
+        if (!this.autoAcceptEnabled || request.kind !== "tool") {
             return false;
         }
         try {

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

@@ -1,6 +1,6 @@
 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 type { ProviderRuntimeSettings } from "../../provider-launch-config.js";
+import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 import type { PiRuntime, PiRuntimeSession } from "./runtime.js";
 import type { PiSessionState } from "./rpc-types.js";
 interface PiRpcAgentClientOptions {
@@ -25,6 +25,8 @@ export declare class PiRpcAgentSession implements AgentSession {
     private readonly subscribers;
     private readonly activeToolCalls;
     private readonly pendingExtensionUiRequests;
+    private activeAskUserDialog;
+    private pendingCombinedAskUserResponse;
     private activeTurnId;
     private lastKnownThinkingOptionId;
     currentLeafOverrideId: string | null | undefined;
@@ -72,6 +74,7 @@ export declare class PiRpcAgentSession implements AgentSession {
     private handleEntryCaptureMarker;
     private handleCommandResultMarker;
     private handleExtensionUiRequest;
+    private respondToCombinedAskUserFollowUp;
     private handleRuntimeEvent;
     private handleProcessExit;
     private handleSessionEvent;
@@ -100,7 +103,7 @@ export declare class PiRpcAgentClient implements AgentClient {
     }>;
     private prepareMcpConfig;
     private detectMcpAdapter;
-    private resolvePiBinary;
+    private resolvePiLaunch;
 }
 export {};
 //# sourceMappingURL=agent.d.ts.map