@felan-ai/felan 0.28.4 → 0.30.0

package/dist/acp/session-registry.js

@@ -1,450 +1,242 @@
-import { RequestError, } from '@agentclientprotocol/sdk';
-import { SessionManager, } from '@felan-ai/agent-core';
-import { stat } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
-import { createLocalFelanRuntime, createLocalModelRuntime, getLocalAgentDir, } from '../runtime.js';
-import { createLocalSettingsManager } from '../settings.js';
-import { AcpPromptUpdateStream, AcpToolCallIdRegistry, prepareAcpPrompt, replayAcpSessionEntries, sanitizeAcpErrorMessage, toAcpPromptError, } from './session-updates.js';
-import { AcpSessionInteractions } from './interactions.js';
-const AUTHENTICATION_REFRESH_TIMEOUT_MS = 15_000;
-class AcpRuntimeCleanupError extends AggregateError {
-    constructor(errors, message) {
-        super(errors, message);
-        this.name = 'AcpRuntimeCleanupError';
-    }
-}
+import { RequestError } from '@agentclientprotocol/sdk';
+import { isAbsolute, resolve } from 'node:path';
+import { readMessageDisplay } from '@felan-ai/session-protocol';
+import { accepted, createDaemonClient, DaemonRequestError, readCurrentDaemonHistory, readDaemonHistory, waitForDaemonRun } from './daemon-session.js';
+import { ACP_UI_CAPABILITIES, AcpProtocolInteractions } from './protocol-interactions.js';
+import { AcpProtocolUpdates } from './protocol-updates.js';
+import { AcpToolCallIdRegistry, prepareAcpPrompt, sanitizeAcpErrorMessage } from './session-updates.js';
 export class AcpSessionRegistry {
-    #agentDir;
-    #createModelRuntime;
-    #modelRuntime;
-    #createRuntime;
-    #writeDiagnostic;
-    #openSession;
+    options;
     #sessions = new Map();
-    #loadingSessions = new Map();
-    #reservedSessionIds = new Set();
-    #closingSessionIds = new Set();
-    #pendingLifecycle = new Set();
-    #cleanupFailures = new Set();
-    #disposePromise;
+    #reserved = new Set();
+    #pending = new Set();
+    #writeDiagnostic;
+    #supportsForms = false;
+    #client;
+    #connecting;
+    #unsubscribe;
     #disposed = false;
-    #supportsFormElicitation = false;
+    #disposePromise;
     constructor(options = {}) {
-        this.#agentDir = resolve(options.agentDir ?? getLocalAgentDir());
-        this.#createRuntime = options.createRuntime ?? createLocalFelanRuntime;
+        this.options = options;
         this.#writeDiagnostic = options.writeDiagnostic ?? (() => { });
-        this.#openSession = options.openSession ?? openPersistedSession;
-        this.#createModelRuntime = options.createModelRuntime ?? createLocalModelRuntime;
     }
     initialize(capabilities) {
         this.#assertOpen();
-        this.#supportsFormElicitation = capabilities.elicitation?.form != null;
+        this.#supportsForms = capabilities.elicitation?.form != null;
     }
     newSession(params, client) {
         this.#assertOpen();
-        return this.#trackLifecycle(this.#newSession(params, client));
+        return this.#track(async () => {
+            const cwd = validateSessionRequest(params);
+            const daemon = await this.#connect();
+            const { sessionId } = accepted(await daemon.request('sessions.create', { cwd, requirePolicy: 'acp-strict' }));
+            await this.#attach(sessionId, cwd, client);
+            return { sessionId };
+        });
     }
-    async #newSession(params, client) {
-        const request = await validateSessionRequest(params);
-        const toolCallIds = new AcpToolCallIdRegistry();
-        const { runtime, interactions } = await this.#createSession(request.cwd, client, toolCallIds);
-        try {
-            const sessionId = runtime.session.sessionManager.getSessionId();
-            this.#assertOpen();
-            if (this.#sessions.has(sessionId)
-                || this.#reservedSessionIds.has(sessionId)
-                || this.#closingSessionIds.has(sessionId)) {
-                throw RequestError.internalError({ sessionId }, 'A duplicate session ID was created');
+    async loadSession(params, client) {
+        this.#assertOpen();
+        if (this.#sessions.has(params.sessionId) || this.#reserved.has(params.sessionId))
+            throw RequestError.invalidParams({ sessionId: params.sessionId }, 'Session is already active or loading');
+        this.#reserved.add(params.sessionId);
+        return this.#track(async () => {
+            try {
+                await this.#connect();
+                await this.#attach(params.sessionId, validateSessionRequest(params), client);
+                return {};
             }
-            this.#sessions.set(sessionId, {
-                runtime,
-                interactions,
-                client,
-                cancelRequested: false,
-                closed: false,
-                nextPromptTurn: 0,
-                toolCallIds,
-            });
-            return { sessionId };
-        }
-        catch (error) {
-            interactions.close();
-            return disposeRuntimeAfterFailure(runtime, error, 'Failed to discard an unregistered ACP session');
-        }
+            finally {
+                this.#reserved.delete(params.sessionId);
+            }
+        });
     }
-    loadSession(params, client) {
+    async #connect() {
         this.#assertOpen();
-        if (this.#sessions.has(params.sessionId)) {
-            throw RequestError.invalidParams({ sessionId: params.sessionId }, 'Session is already active');
-        }
-        if (this.#reservedSessionIds.has(params.sessionId)) {
-            throw RequestError.invalidParams({ sessionId: params.sessionId }, 'Session is already loading');
-        }
-        if (this.#closingSessionIds.has(params.sessionId)) {
-            throw RequestError.invalidParams({ sessionId: params.sessionId }, 'Session is closing');
-        }
-        this.#reservedSessionIds.add(params.sessionId);
-        return this.#trackLifecycle(this.#loadSession(params, client));
+        if (!this.#client) {
+            this.#client = await createDaemonClient(this.options, 'acp', this.#supportsForms
+                ? ['tool_approval', 'select', 'confirm', 'input', 'editor', 'form', 'dependency'] : ['tool_approval'], this.#supportsForms ? [...ACP_UI_CAPABILITIES] : ACP_UI_CAPABILITIES.filter(capability => capability !== 'ui.action'));
+            this.#unsubscribe = this.#client.subscribe(() => this.#observe());
+            this.#connecting = this.#client.connect();
+        }
+        else if (this.#client.status !== 'ready')
+            this.#connecting = this.#client.connect();
+        await this.#connecting;
+        this.#assertOpen();
+        return this.#client;
     }
-    async #loadSession(params, client) {
+    async #attach(sessionId, cwd, client) {
+        const daemon = this.#client;
         let active;
         try {
-            const request = await validateSessionRequest(params);
-            const { cwd } = request;
-            const sessionManager = await this.#openSession(params.sessionId, cwd, this.#agentDir);
-            if (!sessionManager || sessionManager.getSessionId() !== params.sessionId) {
-                throw RequestError.resourceNotFound(params.sessionId);
-            }
-            if (!pathsEqual(sessionManager.getCwd(), cwd)) {
-                throw RequestError.invalidParams({ sessionId: params.sessionId, cwd }, 'Session cwd does not match the persisted session');
-            }
-            const toolCallIds = new AcpToolCallIdRegistry();
-            const { runtime, interactions } = await this.#createSession(cwd, client, toolCallIds, sessionManager);
-            if (runtime.session.sessionManager.getSessionId() !== params.sessionId) {
-                interactions.close();
-                return disposeRuntimeAfterFailure(runtime, RequestError.internalError({ sessionId: params.sessionId }, 'Felan Code runtime opened a different session'), 'Failed to discard a mismatched ACP session');
-            }
-            if (this.#sessions.has(params.sessionId)) {
-                interactions.close();
-                return disposeRuntimeAfterFailure(runtime, RequestError.invalidParams({ sessionId: params.sessionId }, 'Session is already active'), 'Failed to discard a duplicate ACP session');
-            }
-            const createdActive = {
-                runtime,
-                interactions,
-                client,
-                cancelRequested: false,
-                closed: false,
-                nextPromptTurn: 0,
-                toolCallIds,
-            };
-            active = createdActive;
-            this.#loadingSessions.set(params.sessionId, createdActive);
-            await replayAcpSessionEntries(params.sessionId, cwd, runtime.session.sessionManager.getBranch(), client, () => this.#loadingSessions.get(params.sessionId) === createdActive && !createdActive.closed, createdActive.toolCallIds);
-            if (this.#loadingSessions.get(params.sessionId) !== createdActive || createdActive.closed) {
-                throw RequestError.requestCancelled({ sessionId: params.sessionId }, 'Session closed while loading');
-            }
-            this.#loadingSessions.delete(params.sessionId);
-            this.#sessions.set(params.sessionId, createdActive);
-            return {};
+            const { snapshot } = accepted(await daemon.attach(sessionId, { requirePolicy: 'acp-strict' }));
+            this.#assertOpen();
+            if (!pathsEqual(snapshot.cwd, cwd))
+                throw RequestError.invalidParams({ sessionId, cwd }, 'Session cwd does not match the persisted session');
+            const ids = new AcpToolCallIdRegistry();
+            const lifetime = new AbortController();
+            const updates = new AcpProtocolUpdates(sessionId, cwd, client, ids, () => !lifetime.signal.aborted && !this.#disposed);
+            active = { sessionId, updates, lifetime, ready: false, cancelRequested: false,
+                interactions: new AcpProtocolInteractions(daemon, sessionId, client, updates, this.#supportsForms, error => this.#writeDiagnostic(sanitizeAcpErrorMessage(error)), () => [...this.#sessions.values()].find(session => session.ready && !session.lifetime.signal.aborted)?.sessionId === sessionId) };
+            this.#sessions.set(sessionId, active);
+            await updates.replay(await readDaemonHistory(daemon, sessionId, snapshot));
+            if (lifetime.signal.aborted)
+                throw new Error('Session detached while loading');
+            active.ready = true;
+            this.#observe();
+            await updates.flush();
         }
         catch (error) {
-            if (active !== undefined) {
-                if (this.#loadingSessions.get(params.sessionId) === active) {
-                    this.#loadingSessions.delete(params.sessionId);
-                }
-                try {
-                    await closeActiveSession(active);
-                }
-                catch (cleanupError) {
-                    throw new AcpRuntimeCleanupError([error, cleanupError], 'ACP session load and cleanup both failed');
-                }
+            if (active) {
+                active.lifetime.abort();
+                active.interactions.close();
+                this.#sessions.delete(sessionId);
             }
+            if (daemon.getAttachment(sessionId))
+                await daemon.detach(sessionId).catch(() => { });
             throw error;
         }
-        finally {
-            this.#reservedSessionIds.delete(params.sessionId);
+    }
+    #observe() {
+        for (const active of this.#sessions.values()) {
+            if (!active.ready || active.lifetime.signal.aborted)
+                continue;
+            const attachment = this.#client?.getAttachment(active.sessionId);
+            if (attachment?.state.status === 'live' && attachment.state.snapshot)
+                active.updates.observe(attachment.state.snapshot);
+            active.interactions.reconcile();
         }
     }
-    async prompt(params, client) {
+    async prompt(params, _client) {
         const active = this.#require(params.sessionId);
-        if (active.activePrompt) {
+        if (!active.ready)
+            throw RequestError.invalidRequest({ sessionId: params.sessionId }, 'Session is still loading');
+        if (active.activePrompt)
             throw RequestError.invalidRequest({ sessionId: params.sessionId }, 'Only one prompt may run per session');
-        }
-        const preparedPrompt = prepareAcpPrompt(params.prompt);
-        active.client = client;
+        const prompt = prepareAcpPrompt(params.prompt);
         active.cancelRequested = false;
-        active.interactions.beginPrompt(client);
-        active.nextPromptTurn += 1;
-        const running = this.#runPrompt(active, params, preparedPrompt, active.nextPromptTurn);
+        const running = this.#runPrompt(active, prompt.text);
         active.activePrompt = running;
         try {
             return await running;
         }
+        catch (error) {
+            throw toAcpDaemonError(error);
+        }
         finally {
-            if (active.activePrompt === running)
+            if (active.activePrompt === running) {
                 delete active.activePrompt;
+                delete active.runId;
+            }
         }
     }
+    async #runPrompt(active, text) {
+        const daemon = this.#client;
+        const { runId } = accepted(await daemon.request('prompt', { text }, { session: active.sessionId }));
+        active.runId = runId;
+        if (active.cancelRequested)
+            accepted(await daemon.request('cancel', { runId }, { session: active.sessionId }));
+        await waitForDaemonRun(daemon, active.sessionId, runId, active.lifetime.signal);
+        const { snapshot } = await readCurrentDaemonHistory(daemon, active.sessionId, active.lifetime.signal);
+        active.updates.observe(snapshot);
+        await active.updates.flush();
+        if (active.cancelRequested)
+            return { stopReason: 'cancelled' };
+        return { stopReason: stopReason(snapshot) };
+    }
     async cancel(sessionId) {
         const active = this.#sessions.get(sessionId);
-        if (!active || active.closed)
+        if (!active || active.lifetime.signal.aborted)
             return;
         active.cancelRequested = true;
-        active.interactions.cancelPending();
-        await active.runtime.session.abort();
+        const runId = active.runId ?? this.#client?.getAttachment(sessionId)?.state.snapshot?.run.id;
+        if (runId) {
+            try {
+                accepted(await this.#client.request('cancel', { runId }, { session: sessionId }));
+            }
+            catch (error) {
+                throw toAcpDaemonError(error);
+            }
+        }
     }
     closeSession(params) {
-        this.#assertOpen();
-        if (this.#loadingSessions.has(params.sessionId)) {
-            throw RequestError.invalidRequest({ sessionId: params.sessionId }, 'Session is still loading');
-        }
-        const active = this.#sessions.get(params.sessionId);
-        if (!active)
-            throw RequestError.resourceNotFound(params.sessionId);
+        const active = this.#require(params.sessionId);
         this.#sessions.delete(params.sessionId);
-        this.#closingSessionIds.add(params.sessionId);
-        return this.#trackLifecycle(this.#closeSession(params.sessionId, active));
+        active.lifetime.abort();
+        active.interactions.close();
+        this.#observe();
+        return this.#track(async () => { accepted(await this.#client.detach(params.sessionId)); return {}; });
     }
     dispose() {
-        if (this.#disposePromise !== undefined)
+        if (this.#disposePromise)
             return this.#disposePromise;
         this.#disposed = true;
-        this.#disposePromise = this.#performDispose();
-        return this.#disposePromise;
-    }
-    async #performDispose() {
-        const active = [...this.#sessions.values(), ...this.#loadingSessions.values()];
-        this.#sessions.clear();
-        this.#loadingSessions.clear();
-        const pendingLifecycle = [...this.#pendingLifecycle];
-        const results = await Promise.allSettled(active.map(closeActiveSession));
-        await Promise.all(pendingLifecycle);
-        const failures = new Set(this.#cleanupFailures);
-        for (const result of results) {
-            if (result.status === 'rejected')
-                failures.add(result.reason);
+        this.#unsubscribe?.();
+        for (const active of this.#sessions.values()) {
+            active.lifetime.abort();
+            active.interactions.close();
         }
-        if (failures.size > 0)
-            throw new AggregateError(failures, 'Failed to close ACP sessions');
-    }
-    #getModelRuntime() {
-        this.#modelRuntime ??= this.#createModelRuntime(this.#agentDir);
-        return this.#modelRuntime;
-    }
-    async #createSession(cwd, client, toolCallIds, sessionManager) {
-        const interactions = new AcpSessionInteractions({
-            client,
-            supportsFormElicitation: this.#supportsFormElicitation,
-            toolCallIds,
-        });
-        let runtime;
-        try {
-            this.#assertOpen();
-            const modelRuntime = await this.#getModelRuntime();
-            this.#assertOpen();
-            await requireConfiguredAuthentication(modelRuntime);
-            this.#assertOpen();
-            runtime = await this.#createRuntime({
-                cwd,
-                agentDir: this.#agentDir,
-                modelRuntime,
-                inlineExtensions: [interactions.inlineExtension],
-                ...(interactions.uiContext === undefined
-                    ? {}
-                    : { subagentUiContext: interactions.uiContext }),
-                ...(sessionManager === undefined ? {} : { sessionManager }),
-            });
-            this.#assertOpen();
-            for (const diagnostic of runtime.diagnostics) {
-                if (diagnostic.type !== 'info') {
-                    this.#writeDiagnostic(sanitizeAcpErrorMessage(diagnostic.message));
-                }
-            }
-            const errors = runtime.diagnostics.filter(({ type }) => type === 'error');
-            if (errors.length > 0) {
-                throw RequestError.internalError({ diagnostics: errors.map(({ message }) => sanitizeAcpErrorMessage(message)) }, 'Felan Code runtime could not start');
-            }
-            interactions.bindSession(runtime.session.sessionManager.getSessionId());
-            await runtime.session.bindExtensions(interactions.uiContext === undefined
-                ? { mode: 'rpc' }
-                : { mode: 'rpc', uiContext: interactions.uiContext });
-            this.#assertOpen();
-            return { runtime, interactions };
-        }
-        catch (error) {
-            interactions.close();
-            if (runtime === undefined)
-                throw error;
-            return disposeRuntimeAfterFailure(runtime, error, 'Felan Code runtime startup cleanup failed');
-        }
-    }
-    async #runPrompt(active, params, prompt, turn) {
-        const updates = new AcpPromptUpdateStream({
-            sessionId: params.sessionId,
-            cwd: active.runtime.cwd,
-            turn,
-            client: active.client,
-            isActive: () => !active.closed && this.#sessions.get(params.sessionId) === active,
-            toolCallIds: active.toolCallIds,
-        });
-        const unsubscribe = active.runtime.session.subscribe((event) => updates.handle(event));
-        updates.emitPrompt(prompt.blocks);
-        let promptError;
-        let postPreflightAbort;
-        try {
-            await active.runtime.session.prompt(prompt.text, {
-                expandPromptTemplates: false,
-                source: 'rpc',
-                preflightResult: (accepted) => {
-                    if (!accepted || (!active.cancelRequested && !active.closed))
-                        return;
-                    postPreflightAbort ??= Promise.resolve().then(() => active.runtime.session.abort());
-                },
-            });
-        }
-        catch (error) {
-            promptError = error;
-        }
-        finally {
-            unsubscribe();
-        }
-        if (postPreflightAbort !== undefined) {
-            try {
-                await postPreflightAbort;
-            }
-            catch (error) {
-                promptError ??= error;
-            }
-        }
-        const cancelled = active.cancelRequested || active.closed;
-        updates.finish(cancelled);
-        try {
-            await updates.flush();
-        }
-        catch (error) {
-            if (!active.cancelRequested && !active.closed)
-                throw toAcpPromptError(error);
-        }
-        if (active.cancelRequested || active.closed)
-            return { stopReason: 'cancelled' };
-        if (promptError !== undefined)
-            throw toAcpPromptError(promptError);
-        return { stopReason: stopReason(active.runtime.session, false) };
+        this.#sessions.clear();
+        // Closing only the connection preserves admitted runs and durable pending interactions.
+        this.#client?.close();
+        this.#disposePromise = Promise.resolve();
+        return this.#disposePromise;
     }
-    #require(sessionId) {
-        if (this.#loadingSessions.has(sessionId)) {
-            throw RequestError.invalidRequest({ sessionId }, 'Session is still loading');
-        }
-        const active = this.#sessions.get(sessionId);
-        if (!active || active.closed)
-            throw RequestError.resourceNotFound(sessionId);
+    #require(session) {
+        this.#assertOpen();
+        const active = this.#sessions.get(session);
+        if (!active)
+            throw RequestError.resourceNotFound(session);
         return active;
     }
-    #assertOpen() {
-        if (this.#disposed)
-            throw RequestError.internalError(undefined, 'ACP server is closed');
-    }
-    async #closeSession(sessionId, active) {
-        await closeActiveSession(active);
-        this.#closingSessionIds.delete(sessionId);
-        return {};
-    }
-    #trackLifecycle(operation) {
-        const settled = operation.then(() => { }, (error) => {
-            if (error instanceof AcpRuntimeCleanupError)
-                this.#cleanupFailures.add(error);
-        });
-        this.#pendingLifecycle.add(settled);
-        void settled.then(() => this.#pendingLifecycle.delete(settled));
-        return operation;
+    #assertOpen() { if (this.#disposed)
+        throw RequestError.internalError(undefined, 'ACP server is closed'); }
+    #track(operation) {
+        const pending = operation().catch(error => { throw toAcpDaemonError(error); });
+        this.#pending.add(pending);
+        void pending.then(() => this.#pending.delete(pending), () => this.#pending.delete(pending));
+        return pending;
     }
 }
-async function requireConfiguredAuthentication(modelRuntime) {
-    try {
-        const providers = modelRuntime.getProviders();
-        if (providers.some(({ id }) => modelRuntime.hasConfiguredAuth(id)))
-            return;
-        const signal = AbortSignal.timeout(AUTHENTICATION_REFRESH_TIMEOUT_MS);
-        await modelRuntime.refresh({
-            allowNetwork: false,
-            signal,
-        });
-        if (modelRuntime.getProviders().some(({ id }) => modelRuntime.hasConfiguredAuth(id)))
-            return;
-        throw RequestError.authRequired(undefined, 'Configure a model provider before creating a session');
-    }
-    catch (error) {
-        if (error instanceof RequestError)
-            throw error;
-        throw RequestError.internalError(undefined, sanitizeAcpErrorMessage(error));
-    }
-}
-async function validateSessionRequest(params) {
-    if (!isAbsolute(params.cwd)) {
+function validateSessionRequest(params) {
+    if (!isAbsolute(params.cwd))
         throw RequestError.invalidParams({ cwd: params.cwd }, 'cwd must be an absolute path');
-    }
-    const cwd = resolve(params.cwd);
-    let metadata;
-    try {
-        metadata = await stat(cwd);
-    }
-    catch {
-        throw RequestError.resourceNotFound(cwd);
-    }
-    if (!metadata.isDirectory()) {
-        throw RequestError.invalidParams({ cwd }, 'cwd must be a directory');
-    }
-    if ((params.additionalDirectories?.length ?? 0) > 0) {
-        throw RequestError.invalidParams({ additionalDirectories: params.additionalDirectories }, 'Additional directories are not supported');
-    }
-    return { cwd };
+    if (params.additionalDirectories?.length)
+        throw RequestError.invalidParams(undefined, 'Additional directories are not supported');
+    return resolve(params.cwd);
 }
-async function openPersistedSession(sessionId, cwd, agentDir) {
-    const settings = createLocalSettingsManager(cwd, agentDir);
-    const sessionDir = settings.getSessionDir() ?? join(agentDir, 'sessions');
-    const sessions = await SessionManager.list(cwd, sessionDir);
-    const match = sessions.find(({ id }) => id === sessionId);
-    return match ? SessionManager.open(match.path, sessionDir) : undefined;
-}
-function closeActiveSession(active) {
-    active.closePromise ??= performCloseActiveSession(active);
-    return active.closePromise;
-}
-async function performCloseActiveSession(active) {
-    active.closed = true;
-    active.cancelRequested = true;
-    active.interactions.close();
-    const failures = [];
-    try {
-        await active.runtime.session.abort();
-    }
-    catch (error) {
-        failures.push(error);
-    }
-    if (active.activePrompt) {
-        await active.activePrompt.catch(() => { });
-    }
-    try {
-        await active.runtime.dispose();
-    }
-    catch (error) {
-        failures.push(error);
-    }
-    if (failures.length > 0) {
-        throw new AcpRuntimeCleanupError(failures, 'Failed to clean up an ACP session');
-    }
+function pathsEqual(left, right) {
+    return process.platform === 'win32' ? resolve(left).toLowerCase() === resolve(right).toLowerCase() : resolve(left) === resolve(right);
 }
-function stopReason(session, cancelled) {
-    if (cancelled)
+function stopReason(snapshot) {
+    if (snapshot.run.state === 'interrupted')
         return 'cancelled';
-    const assistant = [...session.messages].reverse().find(({ role }) => role === 'assistant');
-    if (!assistant || assistant.role !== 'assistant')
+    const message = [...snapshot.history.entries].reverse().find(message => message.role === 'assistant');
+    const display = readMessageDisplay(message?.details);
+    if (display?.kind !== 'assistant')
         return 'end_turn';
-    if (assistant.stopReason === 'aborted')
+    if (display.stopReason === 'aborted')
         return 'cancelled';
-    if (assistant.stopReason === 'length')
+    if (display.stopReason === 'length')
         return 'max_tokens';
-    if (assistant.rawStopReason?.toLowerCase().includes('refusal'))
-        return 'refusal';
-    if (assistant.stopReason === 'error') {
-        throw RequestError.internalError(undefined, sanitizeAcpErrorMessage(assistant.errorMessage ?? 'Model request failed'));
-    }
+    if (display.stopReason === 'error')
+        throw RequestError.internalError(undefined, sanitizeAcpErrorMessage(display.errorMessage ?? 'Model request failed'));
     return 'end_turn';
 }
-async function disposeRuntimeAfterFailure(runtime, error, message) {
-    try {
-        await runtime.dispose();
-    }
-    catch (cleanupError) {
-        throw new AcpRuntimeCleanupError([error, cleanupError], message);
-    }
-    throw error;
-}
-function pathsEqual(left, right) {
-    const normalizedLeft = resolve(left);
-    const normalizedRight = resolve(right);
-    return process.platform === 'win32'
-        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
-        : normalizedLeft === normalizedRight;
+function toAcpDaemonError(error) {
+    if (error instanceof RequestError)
+        return error;
+    if (error instanceof DaemonRequestError) {
+        const data = { code: error.code, outcome: error.outcome, retryable: error.retryable };
+        const message = sanitizeAcpErrorMessage(error.message);
+        if (error.code === 'auth_required' || error.code === 'authentication_required')
+            return RequestError.authRequired(data, message);
+        if (error.code === 'not_found')
+            return RequestError.resourceNotFound('session');
+        if (['busy', 'invalid_request', 'legacy_session'].includes(error.code))
+            return RequestError.invalidRequest(data, message);
+        return RequestError.internalError(data, message);
+    }
+    return RequestError.internalError(undefined, sanitizeAcpErrorMessage(error));
 }
 //# sourceMappingURL=session-registry.js.map