@kortix/sdk 0.11.0 → 0.12.1

package/dist/react/use-session.js

@@ -21,10 +21,9 @@ import { useQuery, useQueryClient } from '@tanstack/react-query';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { getClient, RuntimeNotReadyError } from '../core/runtime/client.js';
 import { commitSessionRewind, messagesBeforeRewind, reconcileCommittedSessionRewind, } from '../core/session/rewind.js';
-import { createSessionRuntimePolicy, } from '../core/session/runtime-transport.js';
 import { useOpenCodeCompactionStore } from '../browser/stores/opencode-compaction-store.js';
 import { useOpenCodePendingStore } from '../browser/stores/opencode-pending-store.js';
-import { setOpenCodeHealth, setSandboxStatus } from '../browser/stores/sandbox-connection-store.js';
+import { setOpenCodeHealth, setSandboxStatus, } from '../browser/stores/sandbox-connection-store.js';
 import { getSandboxUrlForExternalId } from '../browser/stores/server-store.js';
 import { useSyncStore } from '../browser/stores/sync-store.js';
 import { beginSessionPromptObservation, endSessionPromptObservation, } from '../browser/session-sync/session-sync-registry.js';
@@ -35,8 +34,6 @@ import { BillingError, parseBillingError } from '../core/http/api/errors.js';
 import { formatOpenCodeRuntimeError } from '../core/http/opencode-errors.js';
 import { extractGatewayErrorDetails } from '../core/turns/errors.js';
 import { useCanonicalOpenCodeSession } from './use-canonical-opencode-session.js';
-import { useAcpSessionRuntime } from './use-acp-session-runtime.js';
-import { resolveSessionBusy } from './session-busy.js';
 import { useOpenCodeEventStream } from './use-opencode-events/index.js';
 import { formatModelString } from './use-opencode-local.js';
 import { useProjectConfig } from './use-project-config.js';
@@ -47,7 +44,7 @@ import { useRuntimePhase } from './use-runtime-phase.js';
 import { clearStartStash, readStartStash } from './session-start-stash.js';
 import { useSessionPicks } from './use-session-picks.js';
 import { useSessionSync } from './use-session-sync.js';
-import { readAcpSessionTitle, refreshSessionTitleQueryUntilResolved, syncAcpSessionTitleQuery, } from './session-title-sync.js';
+import { reconcileHydratedSessionTitle } from './session-title-sync.js';
 import { useVisibleAgents } from './use-visible-agents.js';
 import { rejectQuestion as rejectQuestionApi, replyToPermission, replyToQuestion, useAbortOpenCodeSession, useExecuteOpenCodeCommand, useSendOpenCodeMessage, } from './use-opencode-sessions/index.js';
 import { unwrap } from './use-opencode-sessions/shared.js';
@@ -69,12 +66,93 @@ export function shouldRetrySessionStart(failureCount, error, sessionId) {
     }
     return !isSessionStartError(error) && failureCount < 3;
 }
+/**
+ * Gap between `/start` polls. The server long-polls each tick, so this is the
+ * pause between holds, not the latency to observe `ready`.
+ */
+export const SESSION_START_POLL_MS = 1_500;
+/**
+ * Should the `/start` boot poll fire again, given the last tick's outcome?
+ * `false` = stop: a terminal stage, or a terminal client error that no amount
+ * of polling can fix. Everything else keeps polling — including a `null`
+ * payload from a transient transport failure, since the box is still coming up.
+ */
+export function shouldPollSessionStart(error, data) {
+    if (isSessionStartError(error))
+        return false;
+    const stage = data?.stage;
+    return stage === 'ready' || stage === 'failed' || stage === 'stopped'
+        ? false
+        : SESSION_START_POLL_MS;
+}
+/**
+ * TanStack Query pauses interval fetches while the document is hidden unless
+ * this option is true. Session readiness must continue because it gates the
+ * runtime switch, event stream, and queued-prompt replay.
+ */
+export const SESSION_START_POLL_OPTIONS = {
+    refetchInterval: (query) => shouldPollSessionStart(query.state.error, query.state.data),
+    refetchIntervalInBackground: true,
+};
 // `getClient()` (packages/sdk/src/opencode/client.ts) throws a
 // `RuntimeNotReadyError` with this exact message when the sandbox url hasn't
 // been resolved yet (session still starting). The string match is kept as a
 // fallback for callers that re-wrap the original error (losing the
 // `instanceof` chain) but still preserve its message.
 const RUNTIME_NOT_READY_MARKER = 'Server URL not ready';
+/** The error body, wherever the transport parked it. */
+function errorBody(error) {
+    if (!error || typeof error !== 'object')
+        return null;
+    const holder = error;
+    for (const key of ['data', 'details', 'body']) {
+        const candidate = holder[key];
+        if (candidate && typeof candidate === 'object')
+            return candidate;
+    }
+    return holder;
+}
+function errorBodyMessage(error) {
+    const body = errorBody(error);
+    for (const key of ['message', 'error']) {
+        const value = body?.[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return null;
+}
+/**
+ * The connector profiles a `CONNECTOR_AUTHORIZATION_REQUIRED` refusal names, or
+ * null when this is not that refusal.
+ *
+ * Keyed on the CODE, never on the message: the prose is for humans and changes.
+ * A refusal that names no profile still returns null — a connector prompt that
+ * cannot say which connector is worse than the generic error it replaced.
+ */
+function connectorRefusalProfiles(error) {
+    const body = errorBody(error);
+    if (body?.code !== 'CONNECTOR_AUTHORIZATION_REQUIRED')
+        return null;
+    const listed = [body.connector_profiles, body.connectorProfiles].find(Array.isArray);
+    const profiles = [];
+    for (const entry of listed ?? []) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const profile = entry;
+        const strategy = profile.authorization_strategy ?? profile.authorizationStrategy;
+        if (typeof profile.id !== 'string' || typeof profile.slug !== 'string')
+            continue;
+        if (strategy !== 'project' && strategy !== 'user')
+            continue;
+        profiles.push({
+            id: profile.id,
+            slug: profile.slug,
+            name: typeof profile.name === 'string' && profile.name ? profile.name : profile.slug,
+            authorization_strategy: strategy,
+        });
+    }
+    return profiles.length > 0 ? profiles : null;
+}
 /** Classify a thrown/rejected error from a send or a permission/question reply
  * into a `KortixSendError`. Pure — safe to unit test without a runtime. */
 export function classifySendError(error) {
@@ -89,10 +167,15 @@ export function classifySendError(error) {
     if (error && typeof error === 'object') {
         const parsed = parseBillingError(error);
         if (parsed instanceof BillingError) {
+            return { kind: 'billing', message: parsed.message, billing: parsed, cause: error };
+        }
+        const connectors = connectorRefusalProfiles(error);
+        if (connectors) {
             return {
-                kind: 'billing',
-                message: parsed.message,
-                billing: parsed,
+                kind: 'connector',
+                message: errorBodyMessage(error) ??
+                    'Connect the required connector profiles before continuing this session.',
+                connectors,
                 cause: error,
             };
         }
@@ -138,25 +221,24 @@ export function sendStateOnStart(text) {
 export function sendStateOnError(error) {
     return { pending: null, sendError: classifySendError(error) };
 }
-/**
- * Keep the REST compatibility transcript reconciler active after
- * `promptAsync()` accepts a prompt.
- *
- * The runtime can accept the prompt before the browser receives its first SSE
- * status event. Without this optimistic busy state, the 10-second liveness
- * reconciliation never starts. The transcript can then stay at the user
- * message even though the agent completed the turn.
- */
-export function beginRestPromptObservation(sessionId) {
-    beginSessionPromptObservation(sessionId);
+export function beginRestPromptObservation(sessionId, runtimeScope) {
+    beginSessionPromptObservation(sessionId, runtimeScope);
     useSyncStore.getState().setStatus(sessionId, { type: 'busy' });
 }
-/** Clear the optimistic REST busy state when the prompt never starts or stops. */
-export function endRestPromptObservation(sessionId) {
-    endSessionPromptObservation(sessionId);
+export function endRestPromptObservation(sessionId, runtimeScope) {
+    endSessionPromptObservation(sessionId, runtimeScope);
     useSyncStore.getState().setStatus(sessionId, { type: 'idle' });
 }
-/** Stage a reversible OpenCode rollback on one canonical session. */
+export async function sendRestPromptWithObservation(sessionId, runtimeScope, sendPrompt) {
+    beginRestPromptObservation(sessionId, runtimeScope);
+    try {
+        await sendPrompt();
+    }
+    catch (error) {
+        endRestPromptObservation(sessionId, runtimeScope);
+        throw error;
+    }
+}
 export async function rewindOpenCodeSession(sessionId, messageId) {
     if (!messageId)
         throw new Error('Session rewind requires a message id');
@@ -165,7 +247,6 @@ export async function rewindOpenCodeSession(sessionId, messageId) {
         messageID: messageId,
     }));
 }
-/** Restore a staged OpenCode rollback before a replacement prompt commits it. */
 export async function restoreOpenCodeSessionRewind(sessionId) {
     unwrap(await getClient().session.unrevert({ sessionID: sessionId }));
 }
@@ -228,7 +309,7 @@ const DISABLED_CHAT_ENGINE_SYNC = {
 export function useSession(projectId, sessionId, options = {}) {
     const queryClient = useQueryClient();
     const titleRefreshAbortRef = useRef(null);
-    const { waitMs = 15_000, replayStartStash = true, enabled = true, chatEngine = true, initialOpenCodeSessionId = null, runtimeTransport: runtimeTransportOverride, } = options;
+    const { waitMs = 15_000, replayStartStash = true, enabled = true, chatEngine = true, initialOpenCodeSessionId = null, } = options;
     // 1. Drive /start until the runtime is ready (the server long-polls each tick).
     const start = useQuery({
         queryKey: sessionStartKey(projectId, sessionId),
@@ -238,12 +319,7 @@ export function useSession(projectId, sessionId, options = {}) {
         retryDelay: (failureCount, error) => isSessionStartError(error) && error.status === 404
             ? FRESH_START_404_RETRY_DELAY_MS
             : Math.min(1000 * 2 ** failureCount, 5000),
-        refetchInterval: (q) => {
-            if (isSessionStartError(q.state.error))
-                return false;
-            const stage = q.state.data?.stage;
-            return stage === 'ready' || stage === 'failed' || stage === 'stopped' ? false : 1500;
-        },
+        ...SESSION_START_POLL_OPTIONS,
     });
     const startData = start.data ?? null;
     const startError = isSessionStartError(start.error) ? start.error : null;
@@ -251,9 +327,6 @@ export function useSession(projectId, sessionId, options = {}) {
     const sandbox = startData?.sandbox ?? null;
     const startReady = stage === 'ready';
     const terminal = stage === 'failed' || stage === 'stopped';
-    const runtimePolicy = createSessionRuntimePolicy(startData?.runtime_transport, runtimeTransportOverride);
-    const runtimeTransport = runtimePolicy.transport;
-    const usesAcp = runtimePolicy.useAcp;
     // 2. Point the SDK's runtime at this session's sandbox once ready. Track WHICH
     // sandbox we switched to (not a bare bool) so navigating between sessions (this
     // hook instance is reused) re-gates instead of binding the new session to the
@@ -287,7 +360,7 @@ export function useSession(projectId, sessionId, options = {}) {
     // 4. Open the live SSE stream. This was a provider component (OpenCodeEvent
     // StreamProvider); calling the underlying hook here means the host mounts
     // nothing. It self-gates on the connection store's healthy flag (seeded above).
-    useOpenCodeEventStream({ enabled: runtimePolicy.streamOpenCodeEvents });
+    useOpenCodeEventStream({ enabled: switched });
     // 5. Resolve the canonical OpenCode root id (server-owned; /start hands it over)
     // and sync messages off it.
     const canonicalSession = useCanonicalOpenCodeSession({
@@ -295,22 +368,10 @@ export function useSession(projectId, sessionId, options = {}) {
         sessionId,
         pinFromStart: startData?.opencode_session_id ?? null,
         initialPin: initialOpenCodeSessionId,
-        listRuntimeSessions: runtimePolicy.listOpenCodeSessions,
+        listRuntimeSessions: switched,
     });
     const { rootSessionId } = canonicalSession;
     const ocSessionId = rootSessionId ?? '';
-    const runtimeUrl = sandbox?.external_id ? getSandboxUrlForExternalId(sandbox.external_id) : null;
-    const acpRuntime = useAcpSessionRuntime({
-        runtimeUrl,
-        sessionId: rootSessionId,
-        enabled: enabled && switched && usesAcp,
-    });
-    const acpSessionTitle = readAcpSessionTitle(acpRuntime.projection.sessionInfo);
-    useEffect(() => {
-        if (!usesAcp || !acpSessionTitle)
-            return;
-        syncAcpSessionTitleQuery(queryClient, projectId, sessionId, { title: acpSessionTitle });
-    }, [queryClient, projectId, sessionId, usesAcp, acpSessionTitle]);
     useEffect(() => () => {
         titleRefreshAbortRef.current?.abort();
         titleRefreshAbortRef.current = null;
@@ -320,29 +381,17 @@ export function useSession(projectId, sessionId, options = {}) {
     // is off — `useSessionSync('')` fetches/polls nothing (its effects no-op on
     // a falsy/non-canonical session id) — and use a fixed, type-stable empty
     // result instead of whatever it happens to return for that starved call.
-    const rawSync = useSessionSync(chatEngine && runtimePolicy.syncOpenCodeMessages ? ocSessionId : '');
-    const acpSync = useMemo(() => ({
-        messages: acpRuntime.projection.messages,
-        status: acpRuntime.projection.status,
-        isBusy: acpRuntime.projection.status.type !== 'idle',
-        isLoading: !acpRuntime.ready,
-        diffs: [],
-        todos: acpRuntime.projection.todos,
-        hasOlder: false,
-        isLoadingOlder: false,
-        loadOlder: async () => { },
-    }), [acpRuntime.projection, acpRuntime.ready]);
-    const sync = !chatEngine ? DISABLED_CHAT_ENGINE_SYNC : usesAcp ? acpSync : rawSync;
+    const rawSync = useSessionSync(chatEngine ? ocSessionId : '', {
+        kortixSessionScope: `${projectId}/${sessionId}`,
+        networkEnabled: switched,
+    });
+    const sync = chatEngine ? rawSync : DISABLED_CHAT_ENGINE_SYNC;
     const runtimePhase = useRuntimePhase();
     const [restRewind, setRestRewind] = useState(null);
     const [rewindPending, setRewindPending] = useState(false);
     const [rewindError, setRewindError] = useState(null);
-    const rewindMessageId = usesAcp
-        ? (acpRuntime.rewindState?.messageId ?? null)
-        : restRewind?.staged
-            ? restRewind.messageId
-            : null;
-    const messages = useMemo(() => usesAcp ? sync.messages : messagesBeforeRewind(sync.messages, restRewind?.messageId ?? null), [usesAcp, sync.messages, restRewind?.messageId]);
+    const rewindMessageId = restRewind?.staged ? restRewind.messageId : null;
+    const messages = useMemo(() => messagesBeforeRewind(sync.messages, restRewind?.messageId ?? null), [sync.messages, restRewind?.messageId]);
     useEffect(() => {
         setRestRewind(null);
         setRewindPending(false);
@@ -350,7 +399,7 @@ export function useSession(projectId, sessionId, options = {}) {
     }, [sessionId, ocSessionId]);
     useEffect(() => {
         setRestRewind((current) => reconcileCommittedSessionRewind(sync.messages, current));
-    }, [restRewind, sync.messages]);
+    }, [sync.messages]);
     // 5b. Self-heal a missed `question.asked` SSE event (a `question` tool part
     // rendering as running with nothing in the pending store) — see
     // `useQuestionSelfHeal` for why this is distinct from the SSE reconnect-gap
@@ -358,24 +407,21 @@ export function useSession(projectId, sessionId, options = {}) {
     // is off — see that option's jsdoc: a host mounting its own chat surface
     // already runs its own copy of this poller for the same session.
     useQuestionSelfHeal(ocSessionId, sync.messages, {
-        enabled: !usesAcp && chatEngine && !!ocSessionId,
+        enabled: switched && chatEngine && !!ocSessionId,
     });
     usePermissionSelfHeal(ocSessionId, sync.messages, {
-        enabled: !usesAcp && chatEngine && !!ocSessionId,
+        enabled: switched && chatEngine && !!ocSessionId,
     });
     // 6. Interactive prompts live in the pending store (the SSE writes them there,
     // keyed by request id carrying sessionID). useSessionSync does NOT surface them.
     const questionMap = useOpenCodePendingStore((s) => s.questions);
     const permissionMap = useOpenCodePendingStore((s) => s.permissions);
-    const isCompacting = useOpenCodeCompactionStore((state) => !usesAcp && Boolean(state.compactingBySession[ocSessionId]));
+    const isCompacting = useOpenCodeCompactionStore((state) => switched && Boolean(state.compactingBySession[ocSessionId]));
     const removeQuestion = useOpenCodePendingStore((s) => s.removeQuestion);
     const removePermission = useOpenCodePendingStore((s) => s.removePermission);
-    const questions = useMemo(() => usesAcp
-        ? acpRuntime.projection.questions
-        : Object.values(questionMap).filter((q) => q.sessionID === ocSessionId), [usesAcp, acpRuntime.projection.questions, questionMap, ocSessionId]);
-    const permissions = useMemo(() => usesAcp
-        ? acpRuntime.projection.permissions
-        : Object.values(permissionMap).filter((p) => p.sessionID === ocSessionId), [usesAcp, acpRuntime.projection.permissions, permissionMap, ocSessionId]);
+    const questions = useMemo(() => switched ? Object.values(questionMap).filter((q) => q.sessionID === ocSessionId) : [], [questionMap, ocSessionId, switched]);
+    const permissions = useMemo(() => switched ? Object.values(permissionMap).filter((p) => p.sessionID === ocSessionId) : [], [permissionMap, ocSessionId, switched]);
+    const runtimeActionReady = switched && !!rootSessionId;
     // 7. Server-side capabilities + per-session picks (all pre-runtime — no sandbox).
     const models = useProjectModels(projectId);
     const agents = useVisibleAgents({ projectId });
@@ -389,6 +435,21 @@ export function useSession(projectId, sessionId, options = {}) {
     // lands (count grows) — robust to server-normalized text where a text-equality
     // match would clear too early or never (wedging the composer). 30s backstop.
     const userMsgCount = useMemo(() => messages.filter((m) => m.info.role === 'user').length, [messages]);
+    useEffect(() => {
+        if (!chatEngine || userMsgCount <= 0)
+            return;
+        titleRefreshAbortRef.current?.abort();
+        const controller = new AbortController();
+        titleRefreshAbortRef.current = controller;
+        void reconcileHydratedSessionTitle(queryClient, projectId, sessionId, userMsgCount, {
+            signal: controller.signal,
+        }).finally(() => {
+            if (titleRefreshAbortRef.current === controller) {
+                titleRefreshAbortRef.current = null;
+            }
+        });
+        return () => controller.abort();
+    }, [chatEngine, projectId, queryClient, sessionId, userMsgCount]);
     const [sendState, setSendState] = useState(IDLE_SEND_STATE);
     const pending = sendState.pending;
     const pendingBaseCount = useRef(0);
@@ -404,82 +465,41 @@ export function useSession(projectId, sessionId, options = {}) {
         return () => clearTimeout(t);
     }, [pending]);
     const sendParts = async (parts, override) => {
-        if (!ocSessionId)
+        if (!runtimeActionReady)
             throw new RuntimeNotReadyError();
-        titleRefreshAbortRef.current?.abort();
-        const titleRefreshAbort = new AbortController();
-        titleRefreshAbortRef.current = titleRefreshAbort;
-        void refreshSessionTitleQueryUntilResolved(queryClient, projectId, sessionId, {
-            signal: titleRefreshAbort.signal,
-        }).finally(() => {
-            if (titleRefreshAbortRef.current === titleRefreshAbort) {
-                titleRefreshAbortRef.current = null;
-            }
-        });
         const model = override?.model ?? picks.model;
         const agent = override?.agent ?? picks.agent;
         const variant = override?.variant;
-        if (usesAcp) {
-            const acpParts = parts.map((part) => {
-                if (part.type === 'text') {
-                    return { type: 'text', text: part.text };
-                }
-                if (part.type === 'agent') {
-                    return { type: 'text', text: `@${part.name}` };
-                }
-                return {
-                    type: 'resource_link',
-                    uri: part.url,
-                    name: part.filename,
-                    mimeType: part.mime,
-                };
-            });
-            await acpRuntime.send(acpParts, {
-                model: model ? formatModelString(model) : null,
-                agent,
-            });
-            return;
-        }
         const opts = {
             ...(model ? { model } : {}),
             ...(agent ? { agent } : {}),
             ...(variant ? { variant } : {}),
             ...(override?.directory ? { directory: override.directory } : {}),
         };
-        await sendMutation.mutateAsync({
+        await sendRestPromptWithObservation(ocSessionId, sandbox?.external_id ?? undefined, () => sendMutation.mutateAsync({
             sessionId: ocSessionId,
             parts,
             ...(Object.keys(opts).length ? { options: opts } : {}),
-        });
+        }));
         setRestRewind(commitSessionRewind);
     };
     const send = (text, override) => {
-        if (!ocSessionId)
+        if (!runtimeActionReady)
             return;
         pendingBaseCount.current = userMsgCount;
-        if (!usesAcp)
-            beginRestPromptObservation(ocSessionId);
         setSendState(sendStateOnStart(text));
         void sendParts([{ type: 'text', text }], override).catch((error) => {
-            if (!usesAcp)
-                endRestPromptObservation(ocSessionId);
             setSendState(sendStateOnError(error));
         });
     };
     // Run a project slash-command (server-side `/command`), distinct from a prompt.
     const runCommand = (command, args, options = {}) => {
-        if (!ocSessionId)
+        if (!runtimeActionReady)
             return Promise.resolve();
-        if (usesAcp) {
-            return acpRuntime.runCommand(command, args, {
-                model: options.model ? formatModelString(options.model) : null,
-                agent: options.agent,
-            });
-        }
         return commandMutation.mutateAsync(buildSessionCommandInput(ocSessionId, command, args, options));
     };
     const rewind = async (messageId) => {
-        if (!ocSessionId)
+        if (!runtimeActionReady)
             throw new RuntimeNotReadyError();
         if (!messageId)
             throw new Error('Session rewind requires a message id');
@@ -489,13 +509,8 @@ export function useSession(projectId, sessionId, options = {}) {
         setRewindPending(true);
         setRewindError(null);
         try {
-            if (usesAcp) {
-                await acpRuntime.rewind(messageId);
-            }
-            else {
-                await rewindOpenCodeSession(ocSessionId, messageId);
-                setRestRewind({ messageId, staged: true });
-            }
+            await rewindOpenCodeSession(ocSessionId, messageId);
+            setRestRewind({ messageId, staged: true });
         }
         catch (error) {
             const classified = classifySendError(error);
@@ -507,20 +522,15 @@ export function useSession(projectId, sessionId, options = {}) {
         }
     };
     const restoreRewind = async () => {
-        if (!ocSessionId)
+        if (!runtimeActionReady)
             throw new RuntimeNotReadyError();
         if (!rewindMessageId || rewindPending)
             return;
         setRewindPending(true);
         setRewindError(null);
         try {
-            if (usesAcp) {
-                await acpRuntime.restoreRewind();
-            }
-            else {
-                await restoreOpenCodeSessionRewind(ocSessionId);
-                setRestRewind(null);
-            }
+            await restoreOpenCodeSessionRewind(ocSessionId);
+            setRestRewind(null);
         }
         catch (error) {
             const classified = classifySendError(error);
@@ -533,49 +543,15 @@ export function useSession(projectId, sessionId, options = {}) {
     };
     // The one true cancel: abort the run AND drop any pending prompt + open prompts.
     const cancel = () => {
-        if (ocSessionId) {
-            if (usesAcp)
-                void acpRuntime.cancel();
-            else {
-                endRestPromptObservation(ocSessionId);
-                abortMutation.mutate(ocSessionId);
-            }
+        if (runtimeActionReady) {
+            endRestPromptObservation(ocSessionId);
+            abortMutation.mutate(ocSessionId);
         }
         questions.forEach((q) => removeQuestion(q.id));
         permissions.forEach((p) => removePermission(p.id));
         setSendState(IDLE_SEND_STATE);
     };
-    const answerSessionQuestion = async (requestId, answers) => {
-        if (!usesAcp)
-            return answerQuestion(requestId, answers);
-        try {
-            await acpRuntime.answerQuestion(requestId, answers);
-        }
-        catch (error) {
-            throw classifySendError(error);
-        }
-    };
-    const rejectSessionQuestion = async (requestId) => {
-        if (!usesAcp)
-            return rejectQuestion(requestId);
-        try {
-            await acpRuntime.rejectQuestion(requestId);
-        }
-        catch (error) {
-            throw classifySendError(error);
-        }
-    };
-    const answerSessionPermission = async (requestId, reply, message) => {
-        if (!usesAcp)
-            return answerPermission(requestId, reply, message);
-        try {
-            await acpRuntime.answerPermission(requestId, reply);
-        }
-        catch (error) {
-            throw classifySendError(error);
-        }
-    };
-    const runtimeSessionError = usesAcp ? acpRuntime.error : canonicalSession.error;
+    const runtimeSessionError = canonicalSession.error;
     const phase = terminal || startError || runtimeSessionError ? 'error' : switched ? 'ready' : 'starting';
     // 10. Replay the new-session hand-off once ready + thread empty (exactly once).
     // Force-disabled when `chatEngine` is off: this reads `sync.isLoading`/
@@ -599,11 +575,7 @@ export function useSession(projectId, sessionId, options = {}) {
             picks.setModel(stash.model);
         if (stash.agent)
             picks.setAgent(stash.agent);
-        send(stash.prompt, {
-            model: stash.model,
-            agent: stash.agent,
-            variant: stash.variant,
-        });
+        send(stash.prompt, { model: stash.model, agent: stash.agent, variant: stash.variant });
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [phase, sync.isLoading, sync.messages.length, sessionId, replayStartStash, chatEngine]);
     return {
@@ -611,10 +583,7 @@ export function useSession(projectId, sessionId, options = {}) {
         sessionId,
         /** Canonical OpenCode root id, or null while resolving. */
         opencodeSessionId: rootSessionId ?? null,
-        /** Server-selected SDK client transport. */
-        runtimeTransport,
-        /** Runtime sessions available for legacy deep-link selection.
-         * ACP exposes only the canonical session during this canary. */
+        runtimeTransport: 'rest',
         runtimeSessions: canonicalSession.sessions,
         runtimeSessionsLoading: canonicalSession.isLoading,
         runtimeSessionsListed: canonicalSession.listed,
@@ -643,12 +612,7 @@ export function useSession(projectId, sessionId, options = {}) {
         startError,
         /** Granular boot phase (connecting|booting|ready|unreachable) for detailed UI. */
         runtimePhase,
-        isBusy: resolveSessionBusy({
-            syncBusy: sync.isBusy,
-            hasPendingText: !!pending,
-            usesAcp,
-            acpSending: acpRuntime.sending,
-        }),
+        isBusy: sync.isBusy || !!pending,
         isCompacting,
         isLoading: sync.isLoading,
         isError: terminal || !!startError || !!runtimeSessionError,
@@ -659,15 +623,12 @@ export function useSession(projectId, sessionId, options = {}) {
         /** Pending optimistic message text, or null. */
         pending,
         /** True while the current `send` mutation is in flight. */
-        isSending: usesAcp ? acpRuntime.sending : sendMutation.isPending,
+        isSending: sendMutation.isPending,
         /** Last `send` failure, typed (billing / runtime-not-ready / runtime-error),
          * or null. Reset on every new `send` call. */
         sendError: sendState.sendError,
-        /** Selected user message while a reversible history rewind is staged. */
         rewindMessageId,
-        /** True while the runtime stages or restores a history rewind. */
         rewindPending,
-        /** Last history rewind failure, or null. */
         rewindError,
         // server-side capabilities (pre-runtime)
         models,
@@ -677,22 +638,19 @@ export function useSession(projectId, sessionId, options = {}) {
         picks,
         // actions
         send,
-        /** Send text and file prompt parts through the selected SDK transport. */
         sendParts,
-        /** Rewind this canonical session to one user message. */
         rewind,
-        /** Restore the removed path before a replacement prompt commits it. */
         restoreRewind,
         cancel,
         runCommand,
         /** Answer an agent question through the server and drop it from pending
          * state on success; throws a `KortixSendError` and leaves it pending on
          * failure. */
-        answerQuestion: answerSessionQuestion,
+        answerQuestion,
         /** Reject an agent question through the server (see `answerQuestion`). */
-        rejectQuestion: rejectSessionQuestion,
+        rejectQuestion,
         /** Answer an agent permission request through the server (see `answerQuestion`). */
-        answerPermission: answerSessionPermission,
+        answerPermission,
         /** @deprecated Drops the question from local state WITHOUT replying to the
          * server — the agent run stays blocked waiting on it. Use `answerQuestion`
          * / `rejectQuestion` instead. */