@seawork/server 1.0.0

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

@@ -0,0 +1,1650 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Readable, Writable } from "node:stream";
+import { ClientSideConnection, PROTOCOL_VERSION, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { applyProviderEnv, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
+import { findExecutable } from "../../../utils/executable.js";
+import { spawnProcess } from "../../../utils/spawn.js";
+const DEFAULT_ACP_CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsDynamicModes: true,
+    supportsMcpServers: true,
+    supportsReasoningStream: true,
+    supportsToolInvocations: true,
+};
+const ACP_CLIENT_CAPABILITIES = {
+    fs: {
+        readTextFile: true,
+        writeTextFile: true,
+    },
+    terminal: true,
+};
+const COPILOT_AUTOPILOT_MODE = "https://agentclientprotocol.com/protocol/session-modes#autopilot";
+export function mapACPUsage(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    return {
+        inputTokens: usage.inputTokens ?? undefined,
+        outputTokens: usage.outputTokens ?? undefined,
+        cachedInputTokens: usage.cachedReadTokens ?? undefined,
+    };
+}
+export function deriveModesFromACP(fallbackModes, modeState, configOptions) {
+    if (modeState?.availableModes?.length) {
+        return {
+            modes: modeState.availableModes.map((mode) => ({
+                id: mode.id,
+                label: mode.name,
+                description: mode.description ?? undefined,
+            })),
+            currentModeId: modeState.currentModeId ?? null,
+        };
+    }
+    const modeOption = configOptions?.find((option) => option.type === "select" && option.category === "mode");
+    if (modeOption?.type === "select") {
+        const flatOptions = flattenSelectOptions(modeOption.options);
+        return {
+            modes: flatOptions.map((option) => ({
+                id: option.value,
+                label: option.name,
+                description: option.description ?? undefined,
+            })),
+            currentModeId: modeOption.currentValue,
+        };
+    }
+    return {
+        modes: fallbackModes,
+        currentModeId: null,
+    };
+}
+export function deriveModelDefinitionsFromACP(provider, models, configOptions) {
+    const thinkingOptions = deriveSelectorOptions(configOptions, "thought_level");
+    const defaultThinkingOptionId = thinkingOptions.find((option) => option.isDefault)?.id ?? null;
+    if (models?.availableModels?.length) {
+        return models.availableModels.map((model) => ({
+            provider,
+            id: model.modelId,
+            label: model.name,
+            description: model.description ?? undefined,
+            isDefault: model.modelId === models.currentModelId,
+            thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
+            defaultThinkingOptionId: defaultThinkingOptionId ?? undefined,
+        }));
+    }
+    const modelOptions = deriveSelectorOptions(configOptions, "model");
+    return modelOptions.map((option) => ({
+        provider,
+        id: option.id,
+        label: option.label,
+        description: option.description,
+        isDefault: option.isDefault,
+        thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
+        defaultThinkingOptionId: defaultThinkingOptionId ?? undefined,
+        metadata: option.metadata,
+    }));
+}
+export class ACPAgentClient {
+    constructor(options) {
+        this.provider = options.provider;
+        this.capabilities = options.capabilities ?? DEFAULT_ACP_CAPABILITIES;
+        this.logger = options.logger.child({ module: "agent", provider: options.provider });
+        this.runtimeSettings = options.runtimeSettings;
+        this.defaultCommand = options.defaultCommand;
+        this.defaultModes = options.defaultModes ?? [];
+        this.modelTransformer = options.modelTransformer;
+        this.sessionResponseTransformer = options.sessionResponseTransformer;
+        this.toolSnapshotTransformer = options.toolSnapshotTransformer;
+        this.thinkingOptionWriter = options.thinkingOptionWriter;
+        this.waitForInitialCommands = options.waitForInitialCommands ?? false;
+        this.initialCommandsWaitTimeoutMs = options.initialCommandsWaitTimeoutMs ?? 1500;
+    }
+    async createSession(config, launchContext) {
+        this.assertProvider(config);
+        const session = new ACPAgentSession({ ...config, provider: this.provider }, {
+            provider: this.provider,
+            logger: this.logger,
+            runtimeSettings: this.runtimeSettings,
+            defaultCommand: this.defaultCommand,
+            defaultModes: this.defaultModes,
+            modelTransformer: this.modelTransformer,
+            sessionResponseTransformer: this.sessionResponseTransformer,
+            toolSnapshotTransformer: this.toolSnapshotTransformer,
+            thinkingOptionWriter: this.thinkingOptionWriter,
+            capabilities: this.capabilities,
+            launchEnv: launchContext?.env,
+            waitForInitialCommands: this.waitForInitialCommands,
+            initialCommandsWaitTimeoutMs: this.initialCommandsWaitTimeoutMs,
+        });
+        await session.initializeNewSession();
+        return session;
+    }
+    async resumeSession(handle, overrides, launchContext) {
+        if (handle.provider !== this.provider) {
+            throw new Error(`Cannot resume ${handle.provider} handle with ${this.provider} provider`);
+        }
+        const storedConfig = coerceSessionConfigMetadata(handle.metadata);
+        const cwd = overrides?.cwd ?? storedConfig.cwd;
+        if (!cwd) {
+            throw new Error(`${this.provider} resume requires the original working directory`);
+        }
+        const mergedConfig = {
+            ...storedConfig,
+            ...overrides,
+            provider: this.provider,
+            cwd,
+        };
+        const session = new ACPAgentSession(mergedConfig, {
+            provider: this.provider,
+            logger: this.logger,
+            runtimeSettings: this.runtimeSettings,
+            defaultCommand: this.defaultCommand,
+            defaultModes: this.defaultModes,
+            modelTransformer: this.modelTransformer,
+            sessionResponseTransformer: this.sessionResponseTransformer,
+            toolSnapshotTransformer: this.toolSnapshotTransformer,
+            thinkingOptionWriter: this.thinkingOptionWriter,
+            capabilities: this.capabilities,
+            handle,
+            launchEnv: launchContext?.env,
+            waitForInitialCommands: this.waitForInitialCommands,
+            initialCommandsWaitTimeoutMs: this.initialCommandsWaitTimeoutMs,
+        });
+        await session.initializeResumedSession();
+        return session;
+    }
+    async listModels(options) {
+        const cwd = options?.cwd ?? process.cwd();
+        const probe = await this.spawnProcess(undefined);
+        try {
+            const response = await probe.connection.newSession({
+                cwd,
+                mcpServers: [],
+            });
+            const transformed = this.transformSessionResponse(response);
+            const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
+            return this.modelTransformer ? this.modelTransformer(models) : models;
+        }
+        finally {
+            await this.closeProbe(probe);
+        }
+    }
+    async listModes(options) {
+        const cwd = options?.cwd ?? process.cwd();
+        const probe = await this.spawnProcess(undefined);
+        try {
+            const response = await probe.connection.newSession({
+                cwd,
+                mcpServers: [],
+            });
+            const transformed = this.transformSessionResponse(response);
+            const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
+            return modeInfo.modes;
+        }
+        finally {
+            await this.closeProbe(probe);
+        }
+    }
+    async listPersistedAgents(options) {
+        const probe = await this.spawnProcess(undefined);
+        try {
+            if (!probe.initialize.agentCapabilities?.sessionCapabilities?.list) {
+                return [];
+            }
+            const sessions = [];
+            let cursor;
+            do {
+                const page = await probe.connection.listSessions({
+                    ...(cursor ? { cursor } : {}),
+                });
+                for (const session of page.sessions) {
+                    sessions.push({
+                        provider: this.provider,
+                        sessionId: session.sessionId,
+                        cwd: session.cwd,
+                        title: session.title ?? null,
+                        lastActivityAt: session.updatedAt ? new Date(session.updatedAt) : new Date(0),
+                        persistence: {
+                            provider: this.provider,
+                            sessionId: session.sessionId,
+                            nativeHandle: session.sessionId,
+                            metadata: {
+                                provider: this.provider,
+                                cwd: session.cwd,
+                                title: session.title ?? null,
+                            },
+                        },
+                        timeline: [],
+                    });
+                }
+                cursor = page.nextCursor ?? null;
+            } while (cursor && (!options?.limit || sessions.length < options.limit));
+            return typeof options?.limit === "number" ? sessions.slice(0, options.limit) : sessions;
+        }
+        finally {
+            await this.closeProbe(probe);
+        }
+    }
+    async isAvailable() {
+        try {
+            await this.resolveLaunchCommand();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async spawnProcess(launchEnv) {
+        const { command, args } = await this.resolveLaunchCommand();
+        const child = spawnProcess(command, args, {
+            cwd: process.cwd(),
+            env: {
+                ...applyProviderEnv(process.env, this.runtimeSettings),
+                ...(launchEnv ?? {}),
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stderrChunks = [];
+        child.stderr.on("data", (chunk) => {
+            stderrChunks.push(chunk.toString());
+        });
+        const spawnErrorPromise = new Promise((_, reject) => {
+            child.once("error", (error) => {
+                const stderr = stderrChunks.join("").trim();
+                reject(new Error(stderr ? `${String(error)}\n${stderr}` : String(error)));
+            });
+        });
+        if (!child.stdin || !child.stdout) {
+            throw new Error(`${this.provider} ACP process did not expose stdio pipes`);
+        }
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const connection = new ClientSideConnection(() => this.buildProbeClient(), stream);
+        const initialize = (await Promise.race([
+            connection.initialize({
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: ACP_CLIENT_CAPABILITIES,
+                clientInfo: { name: "Seawork", version: "dev" },
+            }),
+            spawnErrorPromise,
+        ]));
+        return { child, connection, initialize };
+    }
+    buildProbeClient() {
+        return {
+            async requestPermission() {
+                return { outcome: { outcome: "cancelled" } };
+            },
+            async sessionUpdate() { },
+            async readTextFile(params) {
+                const content = await fs.readFile(params.path, "utf8");
+                return { content };
+            },
+            async writeTextFile(params) {
+                await fs.mkdir(path.dirname(params.path), { recursive: true });
+                await fs.writeFile(params.path, params.content, "utf8");
+                return {};
+            },
+            async createTerminal() {
+                throw new Error("ACP model probe does not support terminal execution");
+            },
+        };
+    }
+    async closeProbe(probe) {
+        try {
+            if (probe.initialize.agentCapabilities?.sessionCapabilities?.close) {
+                // No active session to close here; ignore capability.
+            }
+        }
+        finally {
+            probe.child.kill("SIGTERM");
+            await waitForChildExit(probe.child, 2000);
+        }
+    }
+    async resolveLaunchCommand() {
+        const resolved = await findExecutable(this.defaultCommand[0]);
+        const prefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, () => {
+            if (!resolved) {
+                throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
+            }
+            return resolved;
+        });
+        return {
+            command: prefix.command,
+            args: [...prefix.args, ...this.defaultCommand.slice(1)],
+        };
+    }
+    assertProvider(config) {
+        if (config.provider !== this.provider) {
+            throw new Error(`Expected ${this.provider} config, received ${config.provider}`);
+        }
+    }
+    transformSessionResponse(response) {
+        return this.sessionResponseTransformer ? this.sessionResponseTransformer(response) : response;
+    }
+}
+export class ACPAgentSession {
+    constructor(config, options) {
+        this.subscribers = new Set();
+        this.pendingPermissions = new Map();
+        this.messageAssemblies = new Map();
+        this.toolCalls = new Map();
+        this.terminalEntries = new Map();
+        this.persistedHistory = [];
+        this.child = null;
+        this.connection = null;
+        this.agentCapabilities = null;
+        this.sessionId = null;
+        this.currentMode = null;
+        this.availableModels = [];
+        this.currentModel = null;
+        this.thinkingOptionId = null;
+        this.currentTitle = null;
+        this.lastActivityAt = null;
+        this.configOptions = [];
+        this.cachedCommands = [];
+        this.commandsReadyDeferred = null;
+        this.commandsReadySettled = false;
+        this.activeForegroundTurnId = null;
+        this.closed = false;
+        this.historyPending = false;
+        this.replayingHistory = false;
+        this.suppressUserEchoMessageId = null;
+        this.suppressUserEchoText = null;
+        this.bootstrapThreadEventPending = false;
+        this.provider = options.provider;
+        this.capabilities = options.capabilities;
+        this.logger = options.logger.child({ module: "agent", provider: options.provider });
+        this.runtimeSettings = options.runtimeSettings;
+        this.defaultCommand = options.defaultCommand;
+        this.defaultModes = options.defaultModes;
+        this.modelTransformer = options.modelTransformer;
+        this.sessionResponseTransformer = options.sessionResponseTransformer;
+        this.toolSnapshotTransformer = options.toolSnapshotTransformer;
+        this.thinkingOptionWriter = options.thinkingOptionWriter;
+        this.availableModes = options.defaultModes;
+        this.launchEnv = options.launchEnv;
+        this.initialHandle = options.handle;
+        this.config = { ...config, provider: options.provider };
+        this.currentMode = config.modeId ?? null;
+        this.currentModel = config.model ?? null;
+        this.thinkingOptionId = config.thinkingOptionId ?? null;
+        this.currentTitle = config.title ?? null;
+        this.waitForInitialCommands = options.waitForInitialCommands ?? false;
+        this.initialCommandsWaitTimeoutMs = options.initialCommandsWaitTimeoutMs ?? 1500;
+    }
+    get id() {
+        return this.sessionId;
+    }
+    async initializeNewSession() {
+        const spawned = await this.spawnProcess();
+        this.child = spawned.child;
+        this.connection = spawned.connection;
+        this.agentCapabilities = spawned.initialize.agentCapabilities ?? null;
+        const response = await this.connection.newSession({
+            cwd: this.config.cwd,
+            mcpServers: normalizeMcpServers(this.config.mcpServers),
+        });
+        this.sessionId = response.sessionId;
+        this.bootstrapThreadEventPending = true;
+        this.applySessionState(response);
+        await this.applyConfiguredOverrides();
+    }
+    async initializeResumedSession() {
+        const handle = this.initialHandle;
+        if (!handle) {
+            throw new Error("Resume requested without persistence handle");
+        }
+        const spawned = await this.spawnProcess();
+        this.child = spawned.child;
+        this.connection = spawned.connection;
+        this.agentCapabilities = spawned.initialize.agentCapabilities ?? null;
+        this.sessionId = handle.sessionId;
+        this.bootstrapThreadEventPending = true;
+        const sessionCapabilities = this.agentCapabilities?.sessionCapabilities;
+        if (this.agentCapabilities?.loadSession) {
+            this.replayingHistory = true;
+            const response = await this.connection.loadSession({
+                sessionId: handle.sessionId,
+                cwd: this.config.cwd,
+                mcpServers: normalizeMcpServers(this.config.mcpServers),
+            });
+            this.replayingHistory = false;
+            this.historyPending = this.persistedHistory.length > 0;
+            this.applySessionState(response);
+        }
+        else if (sessionCapabilities?.resume) {
+            const response = await this.connection.unstable_resumeSession({
+                sessionId: handle.sessionId,
+                cwd: this.config.cwd,
+                mcpServers: normalizeMcpServers(this.config.mcpServers),
+            });
+            this.applySessionState(response);
+        }
+        else {
+            throw new Error(`${this.provider} does not support ACP session resume`);
+        }
+        await this.applyConfiguredOverrides();
+    }
+    async run(prompt, options) {
+        const timeline = [];
+        let finalText = "";
+        let usage;
+        let turnId = null;
+        let settled = false;
+        let resolveCompletion;
+        let rejectCompletion;
+        const buffered = [];
+        const completion = new Promise((resolve, reject) => {
+            resolveCompletion = resolve;
+            rejectCompletion = reject;
+        });
+        const processEvent = (event) => {
+            if (settled) {
+                return;
+            }
+            if (turnId && "turnId" in event && event.turnId && event.turnId !== turnId) {
+                return;
+            }
+            if (event.type === "timeline") {
+                timeline.push(event.item);
+                if (event.item.type === "assistant_message") {
+                    finalText = event.item.text.startsWith(finalText)
+                        ? event.item.text
+                        : `${finalText}${event.item.text}`;
+                }
+                return;
+            }
+            if (event.type === "turn_completed") {
+                usage = event.usage;
+                settled = true;
+                resolveCompletion();
+                return;
+            }
+            if (event.type === "turn_failed") {
+                settled = true;
+                rejectCompletion(new Error(event.error));
+                return;
+            }
+            if (event.type === "turn_canceled") {
+                settled = true;
+                resolveCompletion();
+            }
+        };
+        const unsubscribe = this.subscribe((event) => {
+            if (!turnId) {
+                buffered.push(event);
+                return;
+            }
+            processEvent(event);
+        });
+        try {
+            const started = await this.startTurn(prompt, options);
+            turnId = started.turnId;
+            for (const event of buffered) {
+                processEvent(event);
+            }
+            if (!settled) {
+                await completion;
+            }
+        }
+        finally {
+            unsubscribe();
+        }
+        if (!this.sessionId) {
+            throw new Error("ACP session did not expose a session id");
+        }
+        return {
+            sessionId: this.sessionId,
+            finalText,
+            usage,
+            timeline,
+        };
+    }
+    async startTurn(prompt, _options) {
+        if (this.closed) {
+            throw new Error(`${this.provider} session is closed`);
+        }
+        if (!this.connection || !this.sessionId) {
+            throw new Error(`${this.provider} session is not initialized`);
+        }
+        if (this.activeForegroundTurnId) {
+            throw new Error("A foreground turn is already active");
+        }
+        const turnId = randomUUID();
+        const messageId = randomUUID();
+        this.activeForegroundTurnId = turnId;
+        this.suppressUserEchoMessageId = messageId;
+        this.suppressUserEchoText = extractPromptText(prompt);
+        this.emitBootstrapThreadEvent();
+        this.pushEvent({ type: "turn_started", provider: this.provider, turnId });
+        void this.connection
+            .prompt({
+            sessionId: this.sessionId,
+            messageId,
+            prompt: toACPContentBlocks(prompt),
+        })
+            .then((response) => {
+            this.handlePromptResponse(response, turnId);
+        })
+            .catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.finishTurn({
+                type: "turn_failed",
+                provider: this.provider,
+                error: message,
+                diagnostic: this.collectDiagnostic(message),
+                turnId,
+            });
+        });
+        return { turnId };
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        if (this.sessionId) {
+            callback({
+                type: "thread_started",
+                provider: this.provider,
+                sessionId: this.sessionId,
+            });
+        }
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    async *streamHistory() {
+        if (!this.historyPending || this.persistedHistory.length === 0) {
+            return;
+        }
+        const history = [...this.persistedHistory];
+        this.persistedHistory.length = 0;
+        this.historyPending = false;
+        for (const item of history) {
+            yield { type: "timeline", provider: this.provider, item };
+        }
+    }
+    async getRuntimeInfo() {
+        return {
+            provider: this.provider,
+            sessionId: this.sessionId,
+            model: this.currentModel,
+            thinkingOptionId: this.thinkingOptionId,
+            modeId: this.currentMode,
+            extra: {
+                title: this.currentTitle,
+                updatedAt: this.lastActivityAt,
+            },
+        };
+    }
+    async getAvailableModes() {
+        return [...this.availableModes];
+    }
+    async getCurrentMode() {
+        return this.currentMode;
+    }
+    ensureCommandsReadyDeferred() {
+        if (this.commandsReadyDeferred || this.commandsReadySettled || this.cachedCommands.length > 0) {
+            return;
+        }
+        let resolve;
+        const promise = new Promise((r) => {
+            resolve = r;
+        });
+        this.commandsReadyDeferred = { promise, resolve };
+    }
+    settleCommandsReady() {
+        if (this.commandsReadySettled) {
+            return;
+        }
+        this.commandsReadySettled = true;
+        this.commandsReadyDeferred?.resolve();
+        this.commandsReadyDeferred = null;
+    }
+    async waitForCommandsReady() {
+        const deferred = this.commandsReadyDeferred;
+        if (!deferred) {
+            return;
+        }
+        let timer = null;
+        try {
+            await Promise.race([
+                deferred.promise,
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, this.initialCommandsWaitTimeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
+    async listCommands() {
+        if (this.cachedCommands.length > 0) {
+            return this.cachedCommands;
+        }
+        if (!this.waitForInitialCommands || this.closed) {
+            return this.cachedCommands;
+        }
+        this.ensureCommandsReadyDeferred();
+        await this.waitForCommandsReady();
+        this.settleCommandsReady();
+        return this.cachedCommands;
+    }
+    async setMode(modeId) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        const modeExists = this.availableModes.some((mode) => mode.id === modeId);
+        if (!modeExists && this.availableModes.length > 0) {
+            throw new Error(`Unknown ${this.provider} mode '${modeId}'`);
+        }
+        if (this.availableModes.length > 0) {
+            await this.connection.setSessionMode({ sessionId: this.sessionId, modeId });
+            this.currentMode = modeId;
+            return;
+        }
+        const modeOption = this.getSelectConfigOption("mode");
+        if (!modeOption) {
+            throw new Error(`${this.provider} does not expose ACP mode switching`);
+        }
+        await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: modeOption.id,
+            value: modeId,
+        });
+        this.currentMode = modeId;
+    }
+    async setModel(modelId) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        if (!modelId) {
+            this.currentModel = null;
+            return;
+        }
+        const modelExists = this.availableModels.some((model) => model.id === modelId);
+        if (!modelExists && this.availableModels.length > 0) {
+            throw new Error(`Unknown ${this.provider} model '${modelId}'`);
+        }
+        if ("unstable_setSessionModel" in this.connection) {
+            try {
+                await this.connection.unstable_setSessionModel({
+                    sessionId: this.sessionId,
+                    modelId,
+                });
+                this.currentModel = modelId;
+                return;
+            }
+            catch {
+                // Fall through to config option path.
+            }
+        }
+        const modelOption = this.getSelectConfigOption("model");
+        if (!modelOption) {
+            throw new Error(`${this.provider} does not expose ACP model selection`);
+        }
+        await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: modelOption.id,
+            value: modelId,
+        });
+        this.currentModel = modelId;
+    }
+    async setThinkingOption(thinkingOptionId) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        if (!thinkingOptionId) {
+            this.thinkingOptionId = null;
+            return;
+        }
+        if (this.thinkingOptionWriter) {
+            await this.thinkingOptionWriter(this.connection, this.sessionId, thinkingOptionId);
+            this.thinkingOptionId = thinkingOptionId;
+            return;
+        }
+        const option = this.getSelectConfigOption("thought_level");
+        if (!option) {
+            throw new Error(`${this.provider} does not expose ACP thought-level selection`);
+        }
+        await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: option.id,
+            value: thinkingOptionId,
+        });
+        this.thinkingOptionId = thinkingOptionId;
+    }
+    getPendingPermissions() {
+        return Array.from(this.pendingPermissions.values(), (entry) => entry.request);
+    }
+    async respondToPermission(requestId, response) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            throw new Error(`No pending permission request with id '${requestId}'`);
+        }
+        this.pendingPermissions.delete(requestId);
+        const selectedOption = selectPermissionOption(pending.options, response);
+        pending.resolve(selectedOption
+            ? {
+                outcome: {
+                    outcome: "selected",
+                    optionId: selectedOption.optionId,
+                },
+            }
+            : { outcome: { outcome: "cancelled" } });
+        this.pushEvent({
+            type: "permission_resolved",
+            provider: this.provider,
+            requestId,
+            resolution: response,
+            turnId: pending.turnId ?? undefined,
+        });
+        if (response.behavior === "deny" && response.interrupt && this.connection && this.sessionId) {
+            await this.connection.cancel({ sessionId: this.sessionId });
+        }
+    }
+    describePersistence() {
+        if (!this.sessionId) {
+            return null;
+        }
+        return {
+            provider: this.provider,
+            sessionId: this.sessionId,
+            nativeHandle: this.sessionId,
+            metadata: {
+                ...this.config,
+                title: this.currentTitle,
+            },
+        };
+    }
+    async interrupt() {
+        if (!this.connection || !this.sessionId) {
+            return;
+        }
+        for (const pending of this.pendingPermissions.values()) {
+            pending.resolve({ outcome: { outcome: "cancelled" } });
+        }
+        this.pendingPermissions.clear();
+        if (this.activeForegroundTurnId) {
+            await this.connection.cancel({ sessionId: this.sessionId });
+        }
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.settleCommandsReady();
+        for (const pending of this.pendingPermissions.values()) {
+            pending.resolve({ outcome: { outcome: "cancelled" } });
+        }
+        this.pendingPermissions.clear();
+        if (this.connection && this.sessionId) {
+            try {
+                if (this.activeForegroundTurnId) {
+                    await this.connection.cancel({ sessionId: this.sessionId });
+                }
+            }
+            catch { }
+            try {
+                if (this.agentCapabilities?.sessionCapabilities?.close) {
+                    await this.connection.unstable_closeSession({ sessionId: this.sessionId });
+                }
+            }
+            catch (error) {
+                this.logger.debug({ err: error }, "ACP closeSession failed during shutdown");
+            }
+        }
+        for (const terminal of this.terminalEntries.values()) {
+            terminal.child.kill("SIGTERM");
+        }
+        this.terminalEntries.clear();
+        if (this.child) {
+            this.child.kill("SIGTERM");
+            await waitForChildExit(this.child, 2000);
+        }
+        this.subscribers.clear();
+        this.connection = null;
+        this.child = null;
+        this.activeForegroundTurnId = null;
+    }
+    async requestPermission(params) {
+        if (shouldAutoApprovePermissionRequest(this.provider, this.currentMode)) {
+            const selectedOption = selectPermissionOption(params.options, { behavior: "allow" });
+            return selectedOption
+                ? {
+                    outcome: {
+                        outcome: "selected",
+                        optionId: selectedOption.optionId,
+                    },
+                }
+                : { outcome: { outcome: "cancelled" } };
+        }
+        const requestId = randomUUID();
+        let toolSnapshot = this.toolCalls.get(params.toolCall.toolCallId) ??
+            mergeToolSnapshot(params.toolCall.toolCallId, params.toolCall);
+        if (this.toolSnapshotTransformer) {
+            toolSnapshot = this.toolSnapshotTransformer(toolSnapshot);
+        }
+        const request = mapPermissionRequest(this.provider, requestId, params, toolSnapshot);
+        const promise = new Promise((resolve, reject) => {
+            this.pendingPermissions.set(requestId, {
+                request,
+                options: params.options,
+                resolve,
+                reject,
+                turnId: this.activeForegroundTurnId,
+            });
+        });
+        this.pushEvent({
+            type: "permission_requested",
+            provider: this.provider,
+            request,
+            turnId: this.activeForegroundTurnId ?? undefined,
+        });
+        return promise;
+    }
+    async sessionUpdate(params) {
+        if (params.sessionId !== this.sessionId) {
+            return;
+        }
+        const events = this.translateSessionUpdate(params.update);
+        if (this.replayingHistory) {
+            for (const event of events) {
+                if (event.type === "timeline") {
+                    this.persistedHistory.push(event.item);
+                }
+            }
+            return;
+        }
+        for (const event of events) {
+            this.pushEvent(event);
+        }
+    }
+    async readTextFile(params) {
+        const raw = await fs.readFile(params.path, "utf8");
+        if (!params.line && !params.limit) {
+            return { content: raw };
+        }
+        const lines = raw.split(/\r?\n/);
+        const start = Math.max((params.line ?? 1) - 1, 0);
+        const end = params.limit ? start + params.limit : undefined;
+        return { content: lines.slice(start, end).join("\n") };
+    }
+    async writeTextFile(params) {
+        await fs.mkdir(path.dirname(params.path), { recursive: true });
+        await fs.writeFile(params.path, params.content, "utf8");
+        return {};
+    }
+    async createTerminal(params) {
+        const terminalId = randomUUID();
+        const env = Object.fromEntries((params.env ?? []).map((entry) => [entry.name, entry.value]));
+        const child = spawnProcess(params.command, params.args ?? [], {
+            cwd: params.cwd ?? this.config.cwd,
+            env: {
+                ...applyProviderEnv(process.env, this.runtimeSettings),
+                ...env,
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let resolveExit;
+        let rejectExit;
+        const waitForExit = new Promise((resolve, reject) => {
+            resolveExit = resolve;
+            rejectExit = reject;
+        });
+        const entry = {
+            id: terminalId,
+            child,
+            output: "",
+            truncated: false,
+            outputByteLimit: params.outputByteLimit ?? null,
+            exit: null,
+            waitForExit,
+            resolveExit,
+            rejectExit,
+        };
+        child.stdout.on("data", (chunk) => appendTerminalOutput(entry, chunk.toString()));
+        child.stderr.on("data", (chunk) => appendTerminalOutput(entry, chunk.toString()));
+        child.once("error", (error) => rejectExit(error instanceof Error ? error : new Error(String(error))));
+        child.once("exit", (code, signal) => {
+            const exit = { exitCode: code, signal };
+            entry.exit = exit;
+            resolveExit(exit);
+        });
+        this.terminalEntries.set(terminalId, entry);
+        return { terminalId };
+    }
+    async terminalOutput(params) {
+        const entry = this.getTerminalEntry(params.terminalId);
+        return {
+            output: entry.output,
+            truncated: entry.truncated,
+            exitStatus: entry.exit ?? undefined,
+        };
+    }
+    async waitForTerminalExit(params) {
+        const entry = this.getTerminalEntry(params.terminalId);
+        return entry.waitForExit;
+    }
+    async releaseTerminal(params) {
+        const entry = this.getTerminalEntry(params.terminalId);
+        if (!entry.exit) {
+            entry.child.kill("SIGTERM");
+        }
+        this.terminalEntries.delete(params.terminalId);
+    }
+    async killTerminal(params) {
+        const entry = this.getTerminalEntry(params.terminalId);
+        if (!entry.exit) {
+            entry.child.kill("SIGTERM");
+        }
+        return {};
+    }
+    async spawnProcess() {
+        const resolved = await findExecutable(this.defaultCommand[0]);
+        const prefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, () => {
+            if (!resolved) {
+                throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
+            }
+            return resolved;
+        });
+        const command = prefix.command;
+        const args = [...prefix.args, ...this.defaultCommand.slice(1)];
+        const child = spawnProcess(command, args, {
+            cwd: this.config.cwd,
+            env: {
+                ...applyProviderEnv(process.env, this.runtimeSettings),
+                ...(this.launchEnv ?? {}),
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stderrChunks = [];
+        child.stderr.on("data", (chunk) => {
+            stderrChunks.push(chunk.toString());
+        });
+        child.once("exit", (code, signal) => {
+            if (this.closed) {
+                return;
+            }
+            if (this.activeForegroundTurnId) {
+                this.synthesizeCanceledToolCalls();
+                this.finishTurn({
+                    type: "turn_failed",
+                    provider: this.provider,
+                    error: `ACP agent exited unexpectedly (${code ?? "null"}${signal ? `, ${signal}` : ""})`,
+                    diagnostic: stderrChunks.join("").trim() || undefined,
+                    turnId: this.activeForegroundTurnId,
+                });
+            }
+        });
+        if (!child.stdin || !child.stdout) {
+            throw new Error(`${this.provider} ACP process did not expose stdio pipes`);
+        }
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const connection = new ClientSideConnection(() => this, stream);
+        const initialize = await connection.initialize({
+            protocolVersion: PROTOCOL_VERSION,
+            clientCapabilities: ACP_CLIENT_CAPABILITIES,
+            clientInfo: { name: "Seawork", version: "dev" },
+        });
+        return { child, connection, initialize };
+    }
+    applySessionState(response) {
+        const transformed = this.sessionResponseTransformer
+            ? this.sessionResponseTransformer(response)
+            : response;
+        this.configOptions = transformed.configOptions ?? [];
+        const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, this.configOptions);
+        this.availableModes = modeInfo.modes;
+        this.availableModels = this.deriveAvailableModels(transformed.models);
+        this.currentMode = modeInfo.currentModeId ?? this.currentMode;
+        this.currentModel =
+            transformed.models?.currentModelId ?? deriveCurrentConfigValue(this.configOptions, "model");
+        this.thinkingOptionId =
+            deriveCurrentConfigValue(this.configOptions, "thought_level") ?? this.thinkingOptionId;
+    }
+    async applyConfiguredOverrides() {
+        if (this.config.modeId && this.config.modeId !== this.currentMode) {
+            await this.setMode(this.config.modeId);
+        }
+        if (this.config.model && this.config.model !== this.currentModel) {
+            await this.setModel(this.config.model);
+        }
+        if (this.config.thinkingOptionId && this.config.thinkingOptionId !== this.thinkingOptionId) {
+            await this.setThinkingOption(this.config.thinkingOptionId);
+        }
+    }
+    translateSessionUpdate(update) {
+        switch (update.sessionUpdate) {
+            case "user_message_chunk": {
+                const item = this.createMessageTimelineItem("user_message", update);
+                if (!item) {
+                    return [];
+                }
+                const shouldSuppress = this.suppressUserEchoMessageId &&
+                    update.messageId === this.suppressUserEchoMessageId &&
+                    this.suppressUserEchoText &&
+                    item.text === this.suppressUserEchoText;
+                if (shouldSuppress) {
+                    return [];
+                }
+                return [this.wrapTimeline(item)];
+            }
+            case "agent_message_chunk": {
+                const item = this.createMessageTimelineItem("assistant_message", update);
+                return item ? [this.wrapTimeline(item)] : [];
+            }
+            case "agent_thought_chunk": {
+                const item = this.createMessageTimelineItem("reasoning", update);
+                return item ? [this.wrapTimeline(item)] : [];
+            }
+            case "tool_call": {
+                let snapshot = mergeToolSnapshot(update.toolCallId, update);
+                if (this.toolSnapshotTransformer) {
+                    snapshot = this.toolSnapshotTransformer(snapshot);
+                }
+                this.toolCalls.set(update.toolCallId, snapshot);
+                return [this.wrapTimeline(mapToolSnapshotToTimeline(snapshot, this.terminalEntries))];
+            }
+            case "tool_call_update": {
+                const previous = this.toolCalls.get(update.toolCallId);
+                let snapshot = mergeToolSnapshot(update.toolCallId, update, previous);
+                if (this.toolSnapshotTransformer) {
+                    snapshot = this.toolSnapshotTransformer(snapshot);
+                }
+                this.toolCalls.set(update.toolCallId, snapshot);
+                return [this.wrapTimeline(mapToolSnapshotToTimeline(snapshot, this.terminalEntries))];
+            }
+            case "plan":
+                return [this.wrapTimeline(mapPlanToTimeline(update))];
+            case "current_mode_update":
+                this.handleCurrentModeUpdate(update);
+                return [];
+            case "config_option_update":
+                this.handleConfigOptionUpdate(update);
+                return [];
+            case "session_info_update":
+                this.handleSessionInfoUpdate(update);
+                return [];
+            case "usage_update":
+                this.handleUsageUpdate(update);
+                return [];
+            case "available_commands_update":
+                this.cachedCommands = update.availableCommands.map((command) => ({
+                    name: command.name,
+                    description: command.description,
+                    argumentHint: "",
+                }));
+                this.settleCommandsReady();
+                return [];
+            default:
+                return [];
+        }
+    }
+    createMessageTimelineItem(type, update) {
+        const chunkText = contentBlockToText(update.content);
+        if (!chunkText) {
+            return null;
+        }
+        const key = `${type}:${update.messageId ?? "default"}`;
+        const state = this.messageAssemblies.get(key) ?? { text: "" };
+        state.text += chunkText;
+        this.messageAssemblies.set(key, state);
+        if (type === "user_message") {
+            return { type: "user_message", text: state.text, messageId: update.messageId ?? undefined };
+        }
+        if (type === "assistant_message") {
+            return { type: "assistant_message", text: chunkText };
+        }
+        return { type: "reasoning", text: chunkText };
+    }
+    handleCurrentModeUpdate(update) {
+        this.currentMode = update.currentModeId;
+    }
+    handleConfigOptionUpdate(update) {
+        this.configOptions = update.configOptions;
+        const modeInfo = deriveModesFromACP(this.defaultModes, null, this.configOptions);
+        this.availableModes = modeInfo.modes;
+        this.availableModels = this.deriveAvailableModels(null);
+        this.currentMode = modeInfo.currentModeId ?? this.currentMode;
+        this.currentModel = deriveCurrentConfigValue(this.configOptions, "model") ?? this.currentModel;
+        this.thinkingOptionId =
+            deriveCurrentConfigValue(this.configOptions, "thought_level") ?? this.thinkingOptionId;
+    }
+    deriveAvailableModels(models) {
+        const availableModels = deriveModelDefinitionsFromACP(this.provider, models, this.configOptions);
+        return this.modelTransformer ? this.modelTransformer(availableModels) : availableModels;
+    }
+    handleSessionInfoUpdate(update) {
+        if ("title" in update) {
+            this.currentTitle = update.title ?? null;
+        }
+        if ("updatedAt" in update) {
+            this.lastActivityAt = update.updatedAt ?? null;
+        }
+    }
+    handleUsageUpdate(update) {
+        void update;
+    }
+    handlePromptResponse(response, turnId) {
+        this.currentTurnUsage = mapACPUsage(response.usage) ?? this.currentTurnUsage;
+        switch (response.stopReason) {
+            case "cancelled":
+                this.synthesizeCanceledToolCalls();
+                this.finishTurn({
+                    type: "turn_canceled",
+                    provider: this.provider,
+                    reason: "Interrupted",
+                    turnId,
+                });
+                break;
+            case "end_turn":
+            case "max_tokens":
+            case "max_turn_requests":
+            case "refusal":
+            default:
+                this.finishTurn({
+                    type: "turn_completed",
+                    provider: this.provider,
+                    usage: this.currentTurnUsage,
+                    turnId,
+                });
+                break;
+        }
+    }
+    wrapTimeline(item) {
+        return {
+            type: "timeline",
+            provider: this.provider,
+            item,
+            turnId: this.activeForegroundTurnId ?? undefined,
+        };
+    }
+    pushEvent(event) {
+        for (const subscriber of this.subscribers) {
+            subscriber(event);
+        }
+    }
+    finishTurn(event) {
+        this.activeForegroundTurnId = null;
+        this.suppressUserEchoMessageId = null;
+        this.suppressUserEchoText = null;
+        this.pushEvent(event);
+    }
+    emitBootstrapThreadEvent() {
+        if (!this.bootstrapThreadEventPending || !this.sessionId) {
+            return;
+        }
+        this.bootstrapThreadEventPending = false;
+        this.pushEvent({
+            type: "thread_started",
+            provider: this.provider,
+            sessionId: this.sessionId,
+        });
+    }
+    synthesizeCanceledToolCalls() {
+        for (const snapshot of this.toolCalls.values()) {
+            const mapped = mapToolSnapshotToTimeline(snapshot, this.terminalEntries);
+            if (mapped.status === "running") {
+                this.pushEvent(this.wrapTimeline({
+                    ...mapped,
+                    status: "canceled",
+                    error: null,
+                }));
+            }
+        }
+    }
+    collectDiagnostic(message) {
+        const parts = [message];
+        if (this.child?.exitCode != null) {
+            parts.push(`exitCode=${this.child.exitCode}`);
+        }
+        if (this.child?.signalCode) {
+            parts.push(`signal=${this.child.signalCode}`);
+        }
+        return parts.length > 0 ? parts.join(" | ") : undefined;
+    }
+    getSelectConfigOption(category) {
+        const option = this.configOptions.find((entry) => entry.type === "select" && entry.category === category);
+        return option ?? null;
+    }
+    getTerminalEntry(terminalId) {
+        const entry = this.terminalEntries.get(terminalId);
+        if (!entry) {
+            throw new Error(`Unknown terminal '${terminalId}'`);
+        }
+        return entry;
+    }
+}
+function flattenSelectOptions(options) {
+    const flattened = [];
+    for (const option of options) {
+        if ("value" in option) {
+            flattened.push(option);
+            continue;
+        }
+        for (const groupOption of option.options) {
+            flattened.push({ ...groupOption, group: option.group });
+        }
+    }
+    return flattened;
+}
+function deriveSelectorOptions(configOptions, category) {
+    const option = configOptions?.find((entry) => entry.type === "select" && entry.category === category);
+    if (!option) {
+        return [];
+    }
+    return flattenSelectOptions(option.options).map((value) => ({
+        id: value.value,
+        label: value.name,
+        description: value.description ?? undefined,
+        isDefault: value.value === option.currentValue,
+        metadata: value.group ? { group: value.group } : undefined,
+    }));
+}
+function deriveCurrentConfigValue(configOptions, category) {
+    const option = configOptions?.find((entry) => entry.type === "select" && entry.category === category);
+    return option?.currentValue ?? null;
+}
+function normalizeMcpServers(servers) {
+    if (!servers) {
+        return [];
+    }
+    return Object.entries(servers).map(([name, config]) => {
+        if (config.type === "stdio") {
+            return {
+                name,
+                command: config.command,
+                args: config.args ?? [],
+                env: Object.entries(config.env ?? {}).map(([envName, value]) => ({
+                    name: envName,
+                    value,
+                })),
+            };
+        }
+        if (config.type === "http") {
+            return {
+                type: "http",
+                name,
+                url: config.url,
+                headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
+                    name: headerName,
+                    value,
+                })),
+            };
+        }
+        return {
+            type: "sse",
+            name,
+            url: config.url,
+            headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
+                name: headerName,
+                value,
+            })),
+        };
+    });
+}
+function toACPContentBlocks(prompt) {
+    if (typeof prompt === "string") {
+        return [{ type: "text", text: prompt }];
+    }
+    return prompt.map((block) => {
+        if (block.type === "text") {
+            return { type: "text", text: block.text };
+        }
+        return {
+            type: "image",
+            data: block.data,
+            mimeType: block.mimeType,
+        };
+    });
+}
+function extractPromptText(prompt) {
+    if (typeof prompt === "string") {
+        return prompt;
+    }
+    return prompt
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+}
+function contentBlockToText(content) {
+    switch (content.type) {
+        case "text":
+            return content.text;
+        case "resource_link":
+            return content.title ?? content.uri;
+        case "resource":
+            return "text" in content.resource
+                ? content.resource.text
+                : `[resource:${content.resource.mimeType ?? "binary"}]`;
+        case "image":
+            return "[image]";
+        case "audio":
+            return "[audio]";
+        default:
+            return "";
+    }
+}
+function mergeToolSnapshot(toolCallId, update, previous) {
+    const isFull = "title" in update && typeof update.title === "string";
+    return {
+        toolCallId,
+        title: (update.title ?? previous?.title ?? toolCallId),
+        kind: update.kind ?? previous?.kind ?? null,
+        status: update.status ?? previous?.status ?? null,
+        content: update.content !== undefined ? update.content : (previous?.content ?? null),
+        locations: update.locations !== undefined ? update.locations : (previous?.locations ?? null),
+        rawInput: update.rawInput !== undefined ? update.rawInput : previous?.rawInput,
+        rawOutput: update.rawOutput !== undefined ? update.rawOutput : previous?.rawOutput,
+        ...(isFull ? {} : {}),
+    };
+}
+function mapPlanToTimeline(plan) {
+    return {
+        type: "todo",
+        items: plan.entries.map((entry) => ({
+            text: entry.content,
+            completed: entry.status === "completed",
+        })),
+    };
+}
+function mapToolSnapshotToTimeline(snapshot, terminals) {
+    const status = mapToolStatus(snapshot.status);
+    const detail = mapToolDetail(snapshot, terminals);
+    const base = {
+        type: "tool_call",
+        callId: snapshot.toolCallId,
+        name: snapshot.kind ?? snapshot.title,
+        detail,
+        metadata: {
+            kind: snapshot.kind ?? undefined,
+            title: snapshot.title,
+        },
+    };
+    if (status === "failed") {
+        return {
+            ...base,
+            status: "failed",
+            error: { message: readErrorMessage(snapshot.rawOutput) },
+        };
+    }
+    if (status === "completed") {
+        return {
+            ...base,
+            status: "completed",
+            error: null,
+        };
+    }
+    return {
+        ...base,
+        status: "running",
+        error: null,
+    };
+}
+function mapToolStatus(status) {
+    switch (status) {
+        case "completed":
+            return "completed";
+        case "failed":
+            return "failed";
+        case "pending":
+        case "in_progress":
+        default:
+            return "running";
+    }
+}
+function mapToolDetail(snapshot, terminals) {
+    const firstLocation = snapshot.locations?.[0]?.path;
+    const textContent = extractToolText(snapshot.content);
+    const diffContent = extractDiffContent(snapshot.content);
+    const terminalContent = extractTerminalContent(snapshot.content, terminals);
+    const rawInput = readRecord(snapshot.rawInput);
+    const rawOutput = readRecord(snapshot.rawOutput);
+    switch (snapshot.kind) {
+        case "read":
+            return {
+                type: "read",
+                filePath: firstLocation ?? readString(rawInput, ["path", "filePath", "file"]) ?? snapshot.title,
+                content: textContent ?? readString(rawOutput, ["content", "text"]),
+                offset: readNumber(rawInput, ["offset", "line"]),
+                limit: readNumber(rawInput, ["limit"]),
+            };
+        case "edit":
+        case "delete":
+            return {
+                type: "edit",
+                filePath: firstLocation ?? readString(rawInput, ["path", "filePath", "file"]) ?? snapshot.title,
+                oldString: diffContent?.oldText ?? readString(rawInput, ["oldText", "oldString"]),
+                newString: snapshot.kind === "delete"
+                    ? ""
+                    : (diffContent?.newText ?? readString(rawInput, ["newText", "newString"])),
+                unifiedDiff: textContent ?? undefined,
+            };
+        case "search":
+            return {
+                type: "search",
+                query: readString(rawInput, ["query", "pattern"]) ?? snapshot.title,
+                toolName: "search",
+                content: textContent ?? readString(rawOutput, ["content", "text"]),
+                filePaths: snapshot.locations?.map((location) => location.path),
+            };
+        case "execute":
+            return {
+                type: "shell",
+                command: terminalContent?.command ??
+                    buildShellCommand(rawInput) ??
+                    readString(rawInput, ["command"]) ??
+                    snapshot.title,
+                cwd: terminalContent?.cwd ?? readString(rawInput, ["cwd"]),
+                output: terminalContent?.output ?? textContent ?? readString(rawOutput, ["output", "text"]),
+                exitCode: terminalContent?.exitCode ?? readNumber(rawOutput, ["exitCode"]),
+            };
+        case "fetch":
+            return {
+                type: "fetch",
+                url: readString(rawInput, ["url"]) ?? snapshot.title,
+                prompt: readString(rawInput, ["prompt"]),
+                result: textContent ?? readString(rawOutput, ["result", "text", "content"]),
+                code: readNumber(rawOutput, ["status", "code"]),
+            };
+        case "think":
+            return {
+                type: "plain_text",
+                label: snapshot.title,
+                icon: "brain",
+                text: textContent ?? stringifyUnknown(snapshot.rawOutput),
+            };
+        case "switch_mode":
+            return {
+                type: "plain_text",
+                label: snapshot.title,
+                icon: "sparkles",
+                text: textContent ?? stringifyUnknown(snapshot.rawInput),
+            };
+        default:
+            if (terminalContent) {
+                return {
+                    type: "shell",
+                    command: terminalContent.command ?? snapshot.title,
+                    cwd: terminalContent.cwd,
+                    output: terminalContent.output,
+                    exitCode: terminalContent.exitCode,
+                };
+            }
+            if (textContent) {
+                return {
+                    type: "plain_text",
+                    label: snapshot.title,
+                    text: textContent,
+                    icon: "wrench",
+                };
+            }
+            return {
+                type: "unknown",
+                input: snapshot.rawInput ?? null,
+                output: snapshot.rawOutput ?? null,
+            };
+    }
+}
+function extractToolText(content) {
+    if (!content) {
+        return undefined;
+    }
+    const parts = [];
+    for (const item of content) {
+        if (item.type === "content") {
+            const text = contentBlockToText(item.content);
+            if (text) {
+                parts.push(text);
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join("\n") : undefined;
+}
+function extractDiffContent(content) {
+    const diff = content?.find((item) => item.type === "diff");
+    return diff ? { oldText: diff.oldText ?? undefined, newText: diff.newText } : null;
+}
+function extractTerminalContent(content, terminals) {
+    const terminal = content?.find((item) => item.type === "terminal");
+    if (!terminal) {
+        return undefined;
+    }
+    const entry = terminals.get(terminal.terminalId);
+    if (!entry) {
+        return undefined;
+    }
+    return {
+        output: entry.output,
+        exitCode: entry.exit?.exitCode ?? null,
+    };
+}
+function mapPermissionRequest(provider, requestId, params, snapshot) {
+    const kind = snapshot.kind === "switch_mode" ? "mode" : "tool";
+    return {
+        id: requestId,
+        provider,
+        name: snapshot.kind ?? snapshot.title,
+        kind,
+        title: params.toolCall.title ?? snapshot.title,
+        detail: mapToolDetail(snapshot, new Map()),
+        metadata: {
+            toolCallId: params.toolCall.toolCallId,
+            rawRequest: params,
+            options: params.options,
+        },
+    };
+}
+function shouldAutoApprovePermissionRequest(provider, currentMode) {
+    return provider === "copilot" && currentMode === COPILOT_AUTOPILOT_MODE;
+}
+function selectPermissionOption(options, response) {
+    const order = response.behavior === "allow"
+        ? ["allow_once", "allow_always"]
+        : ["reject_once", "reject_always"];
+    for (const kind of order) {
+        const match = options.find((option) => option.kind === kind);
+        if (match) {
+            return match;
+        }
+    }
+    return null;
+}
+function appendTerminalOutput(entry, chunk) {
+    entry.output += chunk;
+    const limit = entry.outputByteLimit;
+    if (!limit) {
+        return;
+    }
+    while (Buffer.byteLength(entry.output, "utf8") > limit && entry.output.length > 0) {
+        entry.output = entry.output.slice(1);
+        entry.truncated = true;
+    }
+}
+function readRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readString(record, keys) {
+    if (!record) {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readNumber(record, keys) {
+    if (!record) {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function buildShellCommand(record) {
+    if (!record) {
+        return undefined;
+    }
+    const command = readString(record, ["command"]);
+    const args = Array.isArray(record["args"])
+        ? record["args"].filter((value) => typeof value === "string")
+        : [];
+    if (!command) {
+        return undefined;
+    }
+    return args.length > 0 ? `${command} ${args.join(" ")}` : command;
+}
+function readErrorMessage(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    const record = readRecord(value);
+    return readString(record, ["message", "error"]) ?? "Tool call failed";
+}
+function stringifyUnknown(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function coerceSessionConfigMetadata(metadata) {
+    if (!metadata || typeof metadata !== "object") {
+        return {};
+    }
+    return metadata;
+}
+async function waitForChildExit(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+        return;
+    }
+    await Promise.race([
+        new Promise((resolve) => child.once("exit", () => resolve())),
+        new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+    ]);
+    if (child.exitCode === null && child.signalCode === null) {
+        child.kill("SIGKILL");
+    }
+}
+//# sourceMappingURL=acp-agent.js.map