@axhub/genie 0.2.10 → 0.2.12

package/server/acp-runtime/index.js

@@ -1,13 +1,26 @@
 import { resolveWorkingDirectory } from '../utils/defaultWorkingDirectory.js';
 import { AcpClient } from './client.js';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import {
+  buildAcpCapabilities,
+  mergeAcpCapabilitySnapshots
+} from '../../shared/acpCapabilities.js';
 import {
   findAcpSessionRecord,
   touchAcpSessionRecord
 } from './session-store.js';
+import { mergeAgentCommandOverrides } from './command-overrides.js';
 
 const activeSessionClients = new Map();
+const warmProjectClients = new Map();
 const pendingSessionClientLoads = new Map();
-const DEFAULT_ACTIVE_SESSION_IDLE_TIMEOUT_MS = parseInt(process.env.ACP_SESSION_IDLE_TIMEOUT_MS, 10) || (5 * 60 * 1000);
+const capabilityProbeSnapshotCache = new Map();
+const capabilityProbeInFlight = new Map();
+const DEFAULT_ACTIVE_SESSION_IDLE_TIMEOUT_MS = parseInt(process.env.ACP_SESSION_IDLE_TIMEOUT_MS, 10) || (15 * 60 * 1000);
+const DEFAULT_CAPABILITY_PROBE_SETTLE_MS = parseInt(process.env.ACP_CAPABILITY_PROBE_SETTLE_MS, 10) || 120;
+const CAPABILITY_PROBE_POLL_MS = 10;
 
 function normalizeProvider(value) {
   return String(value || '').trim().toLowerCase();
@@ -22,7 +35,172 @@ function createActiveSessionKey(provider, sessionId) {
   return `${normalizedProvider}:${normalizedSessionId}`;
 }
 
+function createWarmProjectKey(provider, projectPath) {
+  const normalizedProvider = normalizeProvider(provider);
+  const normalizedProjectPath = String(projectPath || '').trim();
+  if (!normalizedProvider || !normalizedProjectPath) {
+    return null;
+  }
+  return `${normalizedProvider}:${normalizedProjectPath}`;
+}
+
+function createCapabilityProbeCacheKey(provider, projectPath) {
+  const normalizedProvider = normalizeProvider(provider);
+  const normalizedProjectPath = String(projectPath || '').trim();
+  if (!normalizedProvider) {
+    return null;
+  }
+
+  return `${normalizedProvider}:${normalizedProjectPath || 'global'}`;
+}
+
+function cloneJsonValue(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  return JSON.parse(JSON.stringify(value));
+}
+
+function isForceRefreshOption(options = {}) {
+  return options.force === true || String(options.force || '').toLowerCase() === 'true';
+}
+
+function readCapabilityProbeCache(provider, projectPath) {
+  const key = createCapabilityProbeCacheKey(provider, projectPath);
+  if (!key) {
+    return null;
+  }
+
+  const cached = capabilityProbeSnapshotCache.get(key);
+  if (!cached?.snapshot) {
+    return null;
+  }
+
+  const updatedAtMs = Date.parse(cached.snapshot.updatedAt || '');
+  const ttl = Number(cached.snapshot.ttl || 0);
+  if (!Number.isFinite(updatedAtMs) || !Number.isFinite(ttl) || ttl <= 0) {
+    capabilityProbeSnapshotCache.delete(key);
+    return null;
+  }
+
+  if (Date.now() - updatedAtMs >= ttl) {
+    capabilityProbeSnapshotCache.delete(key);
+    return null;
+  }
+
+  return cloneJsonValue(cached.snapshot);
+}
+
+function writeCapabilityProbeCache(provider, projectPath, snapshot) {
+  const key = createCapabilityProbeCacheKey(provider, projectPath);
+  if (!key || !snapshot) {
+    return null;
+  }
+
+  const cloned = cloneJsonValue(snapshot);
+  capabilityProbeSnapshotCache.set(key, {
+    snapshot: cloned
+  });
+  return cloneJsonValue(cloned);
+}
+
+function deleteCapabilityProbeCache(provider, projectPath) {
+  const key = createCapabilityProbeCacheKey(provider, projectPath);
+  if (key) {
+    capabilityProbeSnapshotCache.delete(key);
+  }
+}
+
+function hasConfiguredAgentCommandOverride(provider, options = {}) {
+  const overrides = mergeAgentCommandOverrides(
+    process.env.AXHUB_ACP_COMMAND_OVERRIDES,
+    options.agentCommandOverrides
+  );
+  return Boolean(overrides[normalizeProvider(provider)]);
+}
+
+async function hasGeminiOauthCredentials() {
+  const geminiDir = path.join(os.homedir(), '.gemini');
+
+  try {
+    const content = await fs.readFile(path.join(geminiDir, 'oauth_creds.json'), 'utf8');
+    const credentials = JSON.parse(content);
+    if (credentials?.access_token || credentials?.refresh_token || credentials?.token) {
+      return true;
+    }
+  } catch {
+  }
+
+  try {
+    const content = await fs.readFile(path.join(geminiDir, 'google_accounts.json'), 'utf8');
+    const accounts = JSON.parse(content);
+    return typeof accounts?.active === 'string' && accounts.active.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export function shouldSkipGeminiAutomaticAcpStartup(provider, options = {}) {
+  if (normalizeProvider(provider) !== 'gemini') {
+    return false;
+  }
+
+  return !hasConfiguredAgentCommandOverride(provider, options);
+}
+
+async function shouldBlockGeminiPromptStartup(provider, options = {}) {
+  if (normalizeProvider(provider) !== 'gemini') {
+    return false;
+  }
+
+  if (hasConfiguredAgentCommandOverride(provider, options)) {
+    return false;
+  }
+
+  return !(await hasGeminiOauthCredentials());
+}
+
+function buildSkippedGeminiCapabilityProbeSnapshot(projectPath) {
+  const snapshot = buildAcpCapabilities({
+    provider: 'gemini',
+    source: 'auth-unavailable'
+  });
+  snapshot.metadata = {
+    ...(snapshot.metadata || {}),
+    probeSkipped: true,
+    authenticated: false,
+    authError: 'Skipped automatic Gemini ACP startup to avoid repeated OAuth browser launches.'
+  };
+  writeCapabilityProbeCache('gemini', projectPath, snapshot);
+  return snapshot;
+}
+
+function unregisterWarmProjectClient(provider, projectPath, client = null) {
+  const key = createWarmProjectKey(provider, projectPath);
+  if (!key) {
+    return null;
+  }
+
+  const entry = warmProjectClients.get(key);
+  if (!entry) {
+    return null;
+  }
+
+  if (client && entry.client !== client) {
+    return null;
+  }
+
+  if (entry.idleTimer) {
+    clearTimeout(entry.idleTimer);
+  }
+
+  warmProjectClients.delete(key);
+  return entry.client;
+}
+
 function registerActiveClient(provider, sessionId, client) {
+  const normalizedProvider = normalizeProvider(provider);
   const key = createActiveSessionKey(provider, sessionId);
   if (!key) {
     return null;
@@ -45,6 +223,7 @@ function registerActiveClient(provider, sessionId, client) {
   entry.lastUsedAt = Date.now();
   entry.idleTimer = null;
   activeSessionClients.set(key, entry);
+  unregisterWarmProjectClient(normalizedProvider, client?.projectPath, client);
   return entry;
 }
 
@@ -55,6 +234,78 @@ export function resolveDefaultModel(agentKey, requestedModel) {
   return normalizedRequestedModel || null;
 }
 
+export function createCapabilityProbeWriter(provider) {
+  let snapshot = buildAcpCapabilities({ provider, source: 'probe' });
+  let sessionId = null;
+
+  return {
+    send(payload) {
+      if (!payload || typeof payload !== 'object') {
+        return;
+      }
+
+      if (typeof payload.sessionId === 'string' && payload.sessionId.trim()) {
+        sessionId = payload.sessionId.trim();
+      }
+
+      if (payload.capabilitySnapshot) {
+        snapshot = mergeAcpCapabilitySnapshots(snapshot, payload.capabilitySnapshot);
+      }
+
+      if (payload.type === 'session-created') {
+        snapshot = mergeAcpCapabilitySnapshots(snapshot, buildAcpCapabilities({
+          configOptions: payload.configOptions,
+          modeState: payload.modes,
+          tokenUsage: payload.tokenUsage,
+          availableCommands: payload.availableCommands,
+          provider: payload.provider || provider,
+          source: 'probe'
+        }));
+      }
+
+      if (payload.type === 'conversation-event' && payload.event) {
+        const event = payload.event;
+        if (event.kind === 'mode_update') {
+          snapshot = mergeAcpCapabilitySnapshots(snapshot, buildAcpCapabilities({
+            modeState: event.payload,
+            provider: event.provider || provider,
+            source: 'probe'
+          }));
+        } else if (event.kind === 'config_option_update') {
+          snapshot = mergeAcpCapabilitySnapshots(snapshot, buildAcpCapabilities({
+            configOptions: event.payload?.configOptions,
+            provider: event.provider || provider,
+            source: 'probe'
+          }));
+        } else if (event.kind === 'usage_update') {
+          snapshot = mergeAcpCapabilitySnapshots(snapshot, buildAcpCapabilities({
+            tokenUsage: event.payload,
+            provider: event.provider || provider,
+            source: 'probe'
+          }));
+        } else if (event.kind === 'available_commands_update') {
+          snapshot = mergeAcpCapabilitySnapshots(snapshot, buildAcpCapabilities({
+            availableCommands: event.payload?.availableCommands,
+            provider: event.provider || provider,
+            source: 'probe'
+          }));
+        }
+      }
+    },
+    setSessionId(nextSessionId) {
+      if (typeof nextSessionId === 'string' && nextSessionId.trim()) {
+        sessionId = nextSessionId.trim();
+      }
+    },
+    getSessionId() {
+      return sessionId;
+    },
+    getSnapshot() {
+      return snapshot;
+    }
+  };
+}
+
 function truncateSessionSummary(text, maxLength = 50) {
   const normalizedText = typeof text === 'string' ? text.trim() : '';
   if (!normalizedText) {
@@ -104,6 +355,38 @@ export function deriveSessionSummaryFromPrompt(command) {
   return truncateSessionSummary(extractVisibleUserPrompt(command));
 }
 
+function hasProbeAvailableCommands(snapshot) {
+  return Array.isArray(snapshot?.metadata?.availableCommands) && snapshot.metadata.availableCommands.length > 0;
+}
+
+function resolveCapabilityProbeSettleMs(options = {}) {
+  const explicit = Number(options.probeSettleMs ?? options.capabilityProbeSettleMs);
+  if (Number.isFinite(explicit) && explicit >= 0) {
+    return explicit;
+  }
+
+  return DEFAULT_CAPABILITY_PROBE_SETTLE_MS;
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForCapabilityProbeSettle(writer, options = {}) {
+  const settleMs = resolveCapabilityProbeSettleMs(options);
+  if (settleMs <= 0 || hasProbeAvailableCommands(writer.getSnapshot())) {
+    return;
+  }
+
+  const deadline = Date.now() + settleMs;
+  while (Date.now() < deadline) {
+    await delay(Math.min(CAPABILITY_PROBE_POLL_MS, Math.max(0, deadline - Date.now())));
+    if (hasProbeAvailableCommands(writer.getSnapshot())) {
+      return;
+    }
+  }
+}
+
 function unregisterActiveClient(provider, sessionId, client = null) {
   const key = createActiveSessionKey(provider, sessionId);
   if (!key) {
@@ -132,6 +415,26 @@ function getActiveClient(provider, sessionId) {
   return key ? activeSessionClients.get(key)?.client || null : null;
 }
 
+function takeWarmProjectClient(provider, projectPath) {
+  const key = createWarmProjectKey(provider, projectPath);
+  if (!key) {
+    return null;
+  }
+
+  const entry = warmProjectClients.get(key);
+  if (!entry) {
+    return null;
+  }
+
+  if (entry.idleTimer) {
+    clearTimeout(entry.idleTimer);
+  }
+
+  warmProjectClients.delete(key);
+  entry.lastUsedAt = Date.now();
+  return entry.client;
+}
+
 async function disposeActiveClient(provider, sessionId, client = null) {
   const resolvedClient = unregisterActiveClient(provider, sessionId, client) || client;
   if (resolvedClient) {
@@ -139,6 +442,22 @@ async function disposeActiveClient(provider, sessionId, client = null) {
   }
 }
 
+export async function disposeManagedAgentClient({ provider, sessionId = null, projectPath = null, client = null } = {}) {
+  let resolvedClient = null;
+  if (sessionId) {
+    resolvedClient = unregisterActiveClient(provider, sessionId, client);
+  }
+
+  if (projectPath) {
+    resolvedClient = unregisterWarmProjectClient(provider, projectPath, client) || resolvedClient;
+  }
+
+  resolvedClient = resolvedClient || client;
+  if (resolvedClient) {
+    await resolvedClient.dispose().catch(() => {});
+  }
+}
+
 function scheduleActiveClientCleanup(provider, sessionId, metadata = {}) {
   if (DEFAULT_ACTIVE_SESSION_IDLE_TIMEOUT_MS <= 0) {
     return;
@@ -177,6 +496,130 @@ function scheduleActiveClientCleanup(provider, sessionId, metadata = {}) {
   entry.idleTimer.unref?.();
 }
 
+function scheduleWarmProjectClientCleanup(provider, projectPath) {
+  if (DEFAULT_ACTIVE_SESSION_IDLE_TIMEOUT_MS <= 0) {
+    return;
+  }
+
+  const key = createWarmProjectKey(provider, projectPath);
+  const entry = key ? warmProjectClients.get(key) : null;
+  if (!entry) {
+    return;
+  }
+
+  if (entry.idleTimer) {
+    clearTimeout(entry.idleTimer);
+  }
+
+  entry.lastUsedAt = Date.now();
+  entry.idleTimer = setTimeout(() => {
+    void (async () => {
+      const warmClient = unregisterWarmProjectClient(provider, projectPath, entry.client);
+      if (!warmClient) {
+        return;
+      }
+
+      await warmClient.dispose().catch(() => {});
+    })();
+  }, DEFAULT_ACTIVE_SESSION_IDLE_TIMEOUT_MS);
+
+  entry.idleTimer.unref?.();
+}
+
+export function hasReusableCapabilitySnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object') {
+    return false;
+  }
+
+  const capabilities = snapshot.capabilities && typeof snapshot.capabilities === 'object'
+    ? snapshot.capabilities
+    : {};
+  const hasCapability = Object.values(capabilities).some(Boolean);
+  const hasCommands = Array.isArray(snapshot.metadata?.availableCommands) && snapshot.metadata.availableCommands.length > 0;
+  const hasTokenUsage = Boolean(snapshot.metadata?.tokenUsage);
+
+  return hasCapability || hasCommands || hasTokenUsage;
+}
+
+export function retainProjectAgentClient({ provider, projectPath, client } = {}) {
+  const normalizedProvider = normalizeProvider(provider);
+  const key = createWarmProjectKey(normalizedProvider, projectPath);
+  if (!key || !client) {
+    return false;
+  }
+
+  const existing = warmProjectClients.get(key);
+  if (existing?.idleTimer) {
+    clearTimeout(existing.idleTimer);
+  }
+
+  warmProjectClients.set(key, {
+    client,
+    idleTimer: null,
+    lastUsedAt: Date.now()
+  });
+  scheduleWarmProjectClientCleanup(normalizedProvider, projectPath);
+  return true;
+}
+
+export function retainSessionAgentClient({ provider, sessionId, client, metadata = {} } = {}) {
+  const normalizedProvider = normalizeProvider(provider);
+  const normalizedSessionId = String(sessionId || client?.sessionId || '').trim();
+  if (!normalizedProvider || !normalizedSessionId || !client) {
+    return false;
+  }
+
+  registerActiveClient(normalizedProvider, normalizedSessionId, client);
+  scheduleActiveClientCleanup(normalizedProvider, normalizedSessionId, {
+    projectPath: client.projectPath || metadata.projectPath || null,
+    model: client.model || metadata.model || null,
+    agentCommand: metadata.agentCommand || null
+  });
+  return true;
+}
+
+export async function getOrStartAgentClient({ agentKey, provider, writer, projectPath, options = {}, sessionId = null } = {}) {
+  const normalizedAgent = normalizeProvider(agentKey || provider || options.provider);
+  const normalizedSessionId = String(sessionId || options.sessionId || '').trim();
+
+  if (normalizedSessionId) {
+    const activeClient = getActiveClient(normalizedAgent, normalizedSessionId);
+    if (activeClient) {
+      registerActiveClient(normalizedAgent, normalizedSessionId, activeClient);
+      if (writer) {
+        activeClient.attachWriter(writer);
+      }
+      return {
+        client: activeClient,
+        reused: 'session'
+      };
+    }
+  }
+
+  const warmClient = takeWarmProjectClient(normalizedAgent, projectPath);
+  if (warmClient) {
+    if (writer) {
+      warmClient.attachWriter(writer);
+    }
+    return {
+      client: warmClient,
+      reused: 'project'
+    };
+  }
+
+  const client = createClient({
+    normalizedAgent,
+    writer,
+    projectPath,
+    options
+  });
+  await client.start();
+  return {
+    client,
+    reused: false
+  };
+}
+
 async function resolveProjectPath(options = {}) {
   const explicitProjectPath = resolveWorkingDirectory({
     cwd: options.cwd,
@@ -202,9 +645,17 @@ function createClient({ normalizedAgent, writer, projectPath, options = {} }) {
     agentKey: normalizedAgent,
     writer,
     projectPath,
-    agentCommandOverrides: options.agentCommandOverrides,
+    agentCommandOverrides: mergeAgentCommandOverrides(
+      process.env.AXHUB_ACP_COMMAND_OVERRIDES,
+      options.agentCommandOverrides
+    ),
     model: resolveDefaultModel(normalizedAgent, options.model),
-    permissionMode: options.permissionMode || 'default'
+    permissionMode: options.permissionMode || 'default',
+    modeId: options.modeId || options.mode || null,
+    thoughtLevel: options.thoughtLevel || options.sessionConfigOptions?.thought_level || null,
+    startTimeoutMs: options.startTimeoutMs,
+    sessionTimeoutMs: options.sessionTimeoutMs,
+    promptTimeoutMs: options.promptTimeoutMs
   });
 }
 
@@ -222,21 +673,29 @@ async function createOrResumeClient({ normalizedAgent, options = {}, projectPath
   }
 
   const clientPromise = (async () => {
-    const client = createClient({
-      normalizedAgent,
+    const { client } = await getOrStartAgentClient({
+      agentKey: normalizedAgent,
       writer,
       projectPath,
-      options
+      options,
+      sessionId: requestedSessionId
     });
 
     try {
-      await client.start();
-
       if (requestedSessionId) {
         try {
-          await client.loadSession(requestedSessionId);
-        } catch (error) {
-          console.warn(`[ACP:${normalizedAgent}] Unable to resume session ${requestedSessionId}: ${error.message}`);
+          if (client.canResumeSession()) {
+            try {
+              await client.resumeSession(requestedSessionId);
+            } catch (error) {
+              console.warn(`[ACP:${normalizedAgent}] Unable to resume session ${requestedSessionId} with session/resume: ${error.message}`);
+              await client.loadSession(requestedSessionId);
+            }
+          } else {
+            await client.loadSession(requestedSessionId);
+          }
+        } catch (loadError) {
+          console.warn(`[ACP:${normalizedAgent}] Unable to resume session ${requestedSessionId}: ${loadError.message}`);
           await client.createSession();
           client.emitSystemNotice(`Unable to resume session ${requestedSessionId}; started a new session instead.`);
         }
@@ -248,7 +707,12 @@ async function createOrResumeClient({ normalizedAgent, options = {}, projectPath
       writer?.setSessionId?.(client.sessionId);
       return client;
     } catch (error) {
-      await client.close().catch(() => {});
+      await disposeManagedAgentClient({
+        provider: normalizedAgent,
+        sessionId: client.sessionId || requestedSessionId || null,
+        projectPath,
+        client
+      });
       throw error;
     }
   })();
@@ -273,9 +737,16 @@ export async function executeAgentPrompt({ agentKey, command, options = {}, writ
     agentKey: normalizedAgent,
     provider: normalizedAgent
   });
+  if (await shouldBlockGeminiPromptStartup(normalizedAgent, options)) {
+    throw new Error('Gemini CLI is not authenticated. Configure a Gemini ACP command override or sign in before sending Gemini prompts.');
+  }
+
   const resolvedModel = resolveDefaultModel(normalizedAgent, options.model);
   const agentCommand = options.agentCommand || null;
   const sessionSummary = deriveSessionSummaryFromPrompt(command);
+  const clientRequestId = typeof options.clientRequestId === 'string' && options.clientRequestId.trim()
+    ? options.clientRequestId.trim()
+    : null;
   let sessionRecord = null;
   let client = null;
 
@@ -293,7 +764,9 @@ export async function executeAgentPrompt({ agentKey, command, options = {}, writ
       await client.configureForTurn({
         writer,
         permissionMode: options.permissionMode || 'default',
-        model: resolvedModel
+        model: resolvedModel,
+        modeId: options.modeId || options.mode || null,
+        thoughtLevel: options.thoughtLevel || options.sessionConfigOptions?.thought_level || null
       });
       writer?.setSessionId?.(client.sessionId);
 
@@ -313,7 +786,7 @@ export async function executeAgentPrompt({ agentKey, command, options = {}, writ
       return client.sendPrompt(command, {
         images: options.images || [],
         resourceLinks: options.resourceLinks || [],
-        clientRequestId: options.clientRequestId || null
+        clientRequestId
       });
     });
 
@@ -364,6 +837,88 @@ export async function executeAgentPrompt({ agentKey, command, options = {}, writ
   }
 }
 
+export async function probeAgentCapabilities(agentKey, options = {}) {
+  const normalizedAgent = normalizeProvider(agentKey || options.provider);
+  const projectPath = await resolveProjectPath({
+    ...options,
+    agentKey: normalizedAgent,
+    provider: normalizedAgent
+  });
+  const force = isForceRefreshOption(options);
+  if (shouldSkipGeminiAutomaticAcpStartup(normalizedAgent, options)) {
+    return buildSkippedGeminiCapabilityProbeSnapshot(projectPath);
+  }
+
+  if (!force) {
+    const cachedSnapshot = readCapabilityProbeCache(normalizedAgent, projectPath);
+    if (cachedSnapshot) {
+      if (normalizedAgent === 'gemini' && cachedSnapshot.source === 'auth-unavailable') {
+        deleteCapabilityProbeCache(normalizedAgent, projectPath);
+      } else {
+        return cachedSnapshot;
+      }
+    }
+
+    const cacheKey = createCapabilityProbeCacheKey(normalizedAgent, projectPath);
+    if (cacheKey && capabilityProbeInFlight.has(cacheKey)) {
+      return capabilityProbeInFlight.get(cacheKey);
+    }
+  }
+
+  const cacheKey = createCapabilityProbeCacheKey(normalizedAgent, projectPath);
+  const probePromise = (async () => {
+    const writer = createCapabilityProbeWriter(normalizedAgent);
+    const { client } = await getOrStartAgentClient({
+      agentKey: normalizedAgent,
+      writer,
+      projectPath,
+      options
+    });
+
+    try {
+      await client.createSession();
+      await waitForCapabilityProbeSettle(writer, options);
+      const snapshot = writer.getSnapshot();
+      if (hasReusableCapabilitySnapshot(snapshot)) {
+        writeCapabilityProbeCache(normalizedAgent, projectPath, snapshot);
+        retainProjectAgentClient({
+          provider: normalizedAgent,
+          projectPath,
+          client
+        });
+      } else {
+        await client.close().catch(() => {});
+      }
+      return snapshot;
+    } catch (error) {
+      await disposeManagedAgentClient({
+        provider: normalizedAgent,
+        sessionId: client.sessionId || null,
+        projectPath,
+        client
+      });
+      throw error;
+    }
+  })();
+
+  if (!force && cacheKey) {
+    capabilityProbeInFlight.set(cacheKey, probePromise);
+  }
+
+  try {
+    return await probePromise;
+  } finally {
+    if (cacheKey) {
+      capabilityProbeInFlight.delete(cacheKey);
+    }
+  }
+}
+
+export function resetCapabilityProbeCacheForTests() {
+  capabilityProbeSnapshotCache.clear();
+  capabilityProbeInFlight.clear();
+}
+
 export async function abortAgentSession(agentKey, sessionId) {
   const normalizedAgent = normalizeProvider(agentKey);
   const client = getActiveClient(normalizedAgent, sessionId);
@@ -372,7 +927,7 @@ export async function abortAgentSession(agentKey, sessionId) {
     return false;
   }
 
-  const cancelled = await client.cancel(sessionId);
+  const cancelled = await client.cancel(sessionId, { disposeOnTimeout: true });
   if (cancelled) {
     await touchAcpSessionRecord({
       provider: normalizedAgent,
@@ -439,7 +994,8 @@ export async function setAgentSessionMode(agentKey, sessionId, modeId, { writer
 
 export function isAgentSessionActive(agentKey, sessionId) {
   const key = createActiveSessionKey(agentKey, sessionId);
-  return key ? activeSessionClients.has(key) : false;
+  const client = key ? activeSessionClients.get(key)?.client : null;
+  return Boolean(client?.isPromptInFlight);
 }
 
 export function getActiveAgentSessions(agentKey = null) {
@@ -460,3 +1016,7 @@ export function getActiveAgentSessions(agentKey = null) {
 export function resolveAgentPermission(requestId, decision = {}) {
   return AcpClient.resolvePermissionRequest(requestId, decision);
 }
+
+export function resolveAgentElicitation(requestId, decision = {}) {
+  return AcpClient.resolveElicitationRequest(requestId, decision);
+}