@rho-workspace/rho 0.5.2 → 0.5.4

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/acp-agent.d.ts

@@ -1,1982 +0,0 @@
-import { AgentApp, AuthenticateRequest, AvailableCommand, CancelNotification, ClientCapabilities, CompleteElicitationNotification, CreateElicitationRequest, CreateElicitationResponse, DisableProviderRequest, DisableProviderResponse, ForkSessionRequest, ForkSessionResponse, InitializeRequest, InitializeResponse, ListProvidersRequest, ListProvidersResponse, LlmProtocol, ListSessionsRequest, ListSessionsResponse, LoadSessionRequest, LoadSessionResponse, LogoutRequest, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ReadTextFileRequest, ReadTextFileResponse, SetProviderRequest, SetProviderResponse, RequestPermissionResponse, ResumeSessionRequest, ResumeSessionResponse, SessionConfigOption, SessionModeState, SessionNotification, SetSessionConfigOptionRequest, SetSessionConfigOptionResponse, SetSessionModeRequest, SetSessionModeResponse, CloseSessionRequest, CloseSessionResponse, DeleteSessionRequest, DeleteSessionResponse, WriteTextFileRequest, WriteTextFileResponse } from "@agentclientprotocol/sdk/unstable";
-import type { ForegroundEvents, TurnEvents, TurnOutcome } from "./turn-events.js";
-import { AgentInfo, CanUseTool, FastModeDisabledReason, FastModeState, ModelInfo, Options, PermissionMode, Query, SDKMessageOrigin, SDKPartialAssistantMessage, SDKUserMessage, Settings } from "@anthropic-ai/claude-agent-sdk";
-import { GoalRequest, GoalControlResponse, GoalSnapshot } from "./goal-extension.js";
-import { SessionTitles } from "./session-titles.js";
-import { AcpSessionNotification } from "./acp-subagents.js";
-import { NativeSubagent, NativeSubagentRuntime } from "./native-subagents.js";
-import * as sessionIndex from "./session-index/connection.js";
-import type { RenameSessionRequest, SessionIdRequest } from "./session-index/service.js";
-import type { ListSubscribeRequest, ListUnsubscribeRequest } from "./session-index/list-subscriptions.js";
-import { AsyncTaskRuntime } from "./async-tasks.js";
-import { type AuthStatus, type AuthStatusKind } from "./auth-status.js";
-import { ContentBlockParam } from "@anthropic-ai/sdk/resources";
-import { BetaContentBlock, BetaRawContentBlockDelta } from "@anthropic-ai/sdk/resources/beta.mjs";
-import { type AcpPermissionRequest } from "./permissions/presentation.js";
-import { SettingsManager } from "./settings.js";
-import { type SessionFailureState } from "./session-failure-extension.js";
-import { type ClaudeSubscriptionGuardState } from "./hide-claude-auth.js";
-import { type FileChangeReportTurnState, type NativeFileChangeReporter } from "./file-change-audit.js";
-import { ContextCompactionLifecycle } from "./context-compaction.js";
-import { TaskState } from "./tools.js";
-import { ToolCallFieldTracker } from "./tool-calls/field-tracker.js";
-import { ClientCapabilities as ToolCallClientCapabilities } from "./tool-calls/client-capabilities.js";
-import { Pushable } from "./utils.js";
-export { DEFAULT_AGENT_ID } from "./session-config-ids.js";
-import { MODE_CONFIG_ID } from "./session-mode.js";
-import { type SessionModelState } from "./session-model.js";
-import { type UltracodeOptionState } from "./session-ultracode.js";
-export { EFFORT_CONFIG_ID, settingsEffortForModel } from "./session-effort.js";
-export { applyAvailableModelsAllowlist, matchResumedModel, MODEL_CONFIG_ID, resolveModelPreference, } from "./session-model.js";
-/**
- * Logger interface for customizing logging output
- */
-export interface Logger {
-    log: (...args: any[]) => void;
-    error: (...args: any[]) => void;
-    /** Optional: a caller that supplies no `warn` gets its warnings on `error`. */
-    warn?: (...args: any[]) => void;
-}
-type AccumulatedUsage = {
-    inputTokens: number;
-    outputTokens: number;
-    cachedReadTokens: number;
-    cachedWriteTokens: number;
-};
-/** Per-model token tallies keyed by the model id the SDK reported them under
- *  (its resolved spelling, e.g. "claude-opus-5[1m]"). */
-type ModelTokenTally = Record<string, AccumulatedUsage>;
-/** The structured replacement for the text of a local command that Claude
- *  Code runs itself, such as `/usage` or `/mcp`. */
-type LocalCommandMarkdown = {
-    /** True when `produce` starts at turn activation. Otherwise it starts when
-     *  the command output arrives, so Claude Code has finished the command. */
-    startsAtActivation: boolean;
-    /** The replacement, or null to keep the original text of Claude Code.
-     *  `originalOutput` is that text. It is empty when `produce` starts at
-     *  turn activation. */
-    produce(query: Query, signal: AbortSignal, originalOutput: string): Promise<string | null>;
-    /** Runs once when the turn ends after it delivered the replacement. */
-    afterDelivery?(): void;
-};
-type AsyncTaskStopRequest = {
-    sessionId: string;
-    asyncTaskId: string;
-};
-type AsyncTaskStopResponse = {
-    stopped: boolean;
-};
-/** Request-level steering options. `promptRequired` is opt-in so existing Hosts
- *  keep the established idle fallback behavior. */
-type SteerMeta = {
-    [key: string]: unknown;
-    steering?: {
-        idleBehavior?: "promptRequired";
-    };
-};
-/** Params of a {@link STEER_METHOD} request. Shaped like the relevant subset of
- *  a `PromptRequest` so the same `promptToClaude` conversion applies. Delivery
- *  priority is deliberately NOT exposed here — it's an internal detail the agent
- *  chooses (see {@link STEER_PRIORITY}). */
-export type SteerRequest = {
-    sessionId: string;
-    prompt: PromptRequest["prompt"];
-    _meta?: SteerMeta | null;
-};
-/** Result of a {@link STEER_METHOD} request. The legacy `startedNewTurn` result
- *  remains the default idle behavior; `promptRequired` is returned only when the
- *  Host explicitly opts into the host-owned fallback in request `_meta`. */
-export type SteerResponse = {
-    outcome: "injected";
-} | {
-    outcome: "startedNewTurn";
-} | {
-    outcome: "promptRequired";
-    reason: "noRunningTurn";
-};
-/** One in-flight turn, started by `startTurn()`. A persistent per-session
- *  consumer (see `runConsumer`) drains the SDK query stream for the whole
- *  session and settles each Turn when that turn's outcome is known, so
- *  `startTurn()` itself holds no loop. Turns are processed FIFO: the SDK echoes
- *  queued user messages back in submission order, so `turnQueue[0]` is the turn
- *  currently running. */
-type Turn = {
-    /** uuid stamped on the pushed `SDKUserMessage`; the SDK echoes it back so the
-     *  consumer can match the replayed user message to this turn. It is also the
-     *  id of the user message the turn reports as inserted. */
-    promptUuid: string;
-    /** Where the turn reports how its prompt is answered (see {@link TurnEvents}). */
-    events: TurnEvents;
-    /** Set once `events.inserted` has been reported. A clear-context restart
-     *  activates the same turn again in the fresh session, which must not report
-     *  it twice. */
-    insertedReported?: boolean;
-    /** Tools surfaced during this turn, awaiting completion or an explicit
-     *  background handoff. Intersect with emittedToolCalls at settlement so
-     *  tool_result counts even when a presentation hook is still pending. */
-    foregroundToolCallIds?: Set<string>;
-    /** Closes the tool calls this turn left open when a cancel ended it. Both
-     *  the consumer and `cancelTurns` can settle a cancelled turn; they share
-     *  this one closing, so each call gets one report and both wait for all of
-     *  them before reporting the cancel. */
-    closingCancelledToolCalls?: Promise<void>;
-    /** Local-only slash commands (e.g. `/clear`) return a result without an echo,
-     *  so the consumer can't promote them via the replay; it falls back to
-     *  promoting the queue head when the result arrives. */
-    isLocalOnlyCommand: boolean;
-    /** Whitespace-normalized text this turn delivered as live `notice` updates
-     *  (SDK `informational` frames on the notice lane). A hook-blocked turn's
-     *  result repeats the block reason verbatim with zero output tokens; the
-     *  issue-#453 result-text fallback skips a result that only repeats one of
-     *  these, without the notice counting as the turn's answer. Recorded on the
-     *  queue head, not `activeTurn`: a UserPromptSubmit block arrives before
-     *  any echo, so the turn is only promoted when its result lands. */
-    noticeTexts?: string[];
-    /** Structured presentation for an exact /usage or /mcp command. The command
-     * still runs through the normal SDK turn so ordering, cancellation,
-     * persistence, and replay remain unchanged. A null result means the request
-     * failed and every output path must preserve Claude Code's original text. */
-    localCommand?: LocalCommandMarkdown;
-    localCommandMarkdown?: Promise<string | null>;
-    localCommandAbort?: AbortController;
-    /** The SDK can expose a local command through more than one message shape;
-     * publish the structured replacement at most once. */
-    localCommandDelivered?: boolean;
-    localCommandOriginalOutput?: string;
-    /** Optional native checkpoint preview requested by the ACP client for this
-     *  turn. The state is turn-owned so a late control response can never be
-     *  rebound to a newer prompt. */
-    fileChangeReport?: FileChangeReportTurnState;
-    /** Files that subagents of this turn edited with a file tool, collected only
-     *  when a report was requested (see {@link recordSubagentFileEdits}). */
-    editedPaths?: Set<string>;
-    /** Set once the deferred has been resolved/rejected, so the consumer never
-     *  settles a turn twice (idle + handoff + stream-end can all race). */
-    settled: boolean;
-    /** Set while the terminal checkpoint preview is in flight. The consumer can
-     *  observe another terminal signal during that bounded await; only the first
-     *  one may continue into settlement. */
-    settling?: boolean;
-    /** Outcome captured before the checkpoint preview await, so cancel() can
-     *  preserve its usage and metadata while atomically winning that race. */
-    settlingOutcome?: TurnOutcome;
-    /** Set when a `command_lifecycle` "started" frame arrives for this turn's
-     *  uuid (msg_lifecycle_v1 CLIs): the SDK dispatched the command into a turn.
-     *  Read by cancel() to seed the orphan's state — a started orphan's turn may
-     *  still emit a result, an undispatched one may be dropped without one. */
-    commandStarted?: boolean;
-    /** Set when a terminal `command_lifecycle` frame arrives for this turn's
-     *  uuid while the turn is still queued (msg_lifecycle_v1 CLIs). The command
-     *  is already finished SDK-side, so a later cancel() must not seed an
-     *  orphan entry for it — no terminal frame will ever come to drain it.
-     *  "completed"/"discarded"/"refused" leave nothing outstanding; "cancelled"
-     *  after a dispatch means the dead turn's result may still arrive (seeded
-     *  as a zombie) unless it already passed (`commandResultSeen`), and without
-     *  a dispatch means dropped (nothing coming). */
-    commandFinished?: "completed" | "discarded" | "cancelled" | "refused";
-    /** Set when a user-turn result arrives while this command is known
-     *  dispatched (`commandStarted`) with no terminal frame yet. Turns run
-     *  sequentially and frames arrive in stream order, so the turn this command
-     *  was dispatched into IS the turn that emitted that result — including
-     *  when the command was FOLDED into another turn (their shared result).
-     *  Read by cancel() and the force-cancel wedge path so neither seeds an
-     *  orphan entry for a result that has already passed: such an entry could
-     *  never be drained by its result and would swallow an unrelated later
-     *  echo-less one instead. */
-    commandResultSeen?: boolean;
-    /** Task ids of the background subagents launched while this turn was the
-     *  active one — including during its held-open drain window, so an agent
-     *  chain (a followup that launches another subagent) extends the hold.
-     *  A settled subagent that the SDK resumes while this turn is active (for
-     *  example through SendMessage) counts as a spawn of this turn.
-     *  A turn only waits on its OWN spawned subagents: a long-running agent
-     *  from an earlier turn must not stall every later prompt's settlement.
-     *  Known residual: task_started names no turn (its `parent_task_id`
-     *  names only a launching subagent), so a spawn made by a
-     *  PREVIOUS turn's followup chain while a later turn happens to be held
-     *  is attributed to the holder — extending that hold behind a foreign
-     *  chain. Bounded: the hold still ends at drain, hand-off, or cancel.
-     *  The set is also kept for a client with `backgroundSubagents`, but no
-     *  hold reads it there (see `deferredSettle`). */
-    spawnedTaskIds?: Set<string>;
-    /** Set instead of settling when the turn's terminal result arrives while
-     *  subagents it spawned are still live (`spawnedTaskIds` ∩
-     *  `session.liveBackgroundTasks`). The turn is held open — its
-     *  `session/prompt` stays pending — so the subagents' streamed output,
-     *  their permission requests (which would otherwise block on an RPC a
-     *  client that stops consuming at the prompt response never answers —
-     *  issue #866), and the model's task-notification followup summary all
-     *  land inside the turn.
-     *
-     *  An ACP v1 AIR client that declares `backgroundSubagents` gets no hold:
-     *  this field stays unset, and the turn settles at its result. AIR keeps
-     *  listening after the prompt response, so the subagent updates, their
-     *  permission requests and elicitations, and the followup summary go out
-     *  after it, with the same routing. A held turn hides the end of the
-     *  answer, and the next user message would steer into it. Consequences:
-     *  a followup result is an out-of-turn autonomous result; a steer with no
-     *  turn in flight starts a new turn; the file-change report of the turn
-     *  leaves out subagent edits after the result. Every other client keeps
-     *  the hold, so issue #866 stays fixed for it.
-     *
-     *  Idle cadence depends on the CLI. Through 2.1.269 the trailing idle is
-     *  NOT held for background agents (observed on 2.1.206: `idle` follows
-     *  the result immediately while the subagent still runs), so the hold
-     *  spans multiple idle cycles: user result → idle → (subagent works) →
-     *  task_notification → followup turn → idle. From 2.1.270 the CLI stays
-     *  `running` while background agents live (observed live: user result →
-     *  task_notification → followup turn → ONE idle), so the user result's
-     *  idle debt goes unpaid — swept at the next `running` transition.
-     *  The stored outcome (the result's stop reason and usage snapshot) is
-     *  what the turn settles with once its spawned subagents have settled —
-     *  at the followup's terminal result (the summary has streamed by then),
-     *  or at an idle with none of its subagents left (no followup came). A
-     *  cancel or the next turn's echo hand-off settles it earlier, so a
-     *  long-running subagent never holds the prompt hostage.
-     *
-     *  Accepted residuals. (1) A subagent that ends WITHOUT waking the model —
-     *  its task_notification lost or skipped (only the terminal task_updated
-     *  patch is guaranteed per transition) — leaves no followup result and no
-     *  further idle, so the held turn parks until `session/cancel` or the next
-     *  prompt (either settles it: the echo hand-off or ensureActiveTurn's
-     *  held-turn hand-off). Settling at the prune sites instead would preempt
-     *  the followup summary in the normal ordering (prunes precede the
-     *  notification), and a grace timer was judged not worth the machinery —
-     *  the same rescue contract as the adapter's other wedge classes (issue
-     *  #825's out-of-scope notes). (2) Drained-ness is judged by live-task
-     *  membership only: with parallel subagents, a notification that prunes
-     *  the last task during an earlier task's still-streaming followup lets
-     *  that followup's result settle the turn before the LAST task's summary
-     *  streams — degrading to post-turn delivery for it, never worse than the
-     *  pre-hold behavior (pending wakes are not countable: notifications can
-     *  batch into one followup). */
-    deferredSettle?: TurnOutcome;
-    /** Uuids of `steer()`-injected messages the SDK has not replayed back yet.
-     *
-     *  A steer is normally delivered at priority `now`. When it lands during
-     *  generation the CLI ABORTS the running cycle: it emits its own human-origin
-     *  `result` — indistinguishable from a turn's terminal one — and the steered
-     *  message runs as a SECOND cycle. When it lands during a foreground tool call
-     *  (CLI 2.1.286) the CLI moves the tool to the background instead and either
-     *  joins the steer into the running cycle (ONE result stamped with both
-     *  uuids) or still ends that cycle early and runs the steer as a second one.
-     *  Settling at an interrupted cycle's result would answer `session/prompt`
-     *  mid-work, so a steered turn's results only RECORD their outcome
-     *  (`steeredSettle`) until one provably answers the steer.
-     *
-     *  Two signals prove it. Exact: a result whose `user_message_uuids` names
-     *  one of `steeredUuids` consumed the steered message, so once no echo is
-     *  outstanding it is the turn's terminal result and the turn leaves the steer
-     *  lane to settle there like any other (this also retires an echo the CLI
-     *  never replayed). Fallback, for producers that don't stamp results: the
-     *  SDK's `idle` after a result recorded since the last echo (see
-     *  `steeredAwaitingResult`), the only signal spanning both cycles
-     *  (CLI 2.1.220).
-     *
-     *  A non-empty set at an idle means the steered cycle hasn't started — the CLI
-     *  replays a message only when it picks it up, always after the interrupted
-     *  cycle's result — so that idle is swallowed. Drained by the replay handler
-     *  and by stamped results.
-     *
-     *  Residual: a message the CLI drops unreplayed, with no stamped result naming
-     *  it, parks the turn until `session/cancel` or the next prompt (both settle
-     *  it). */
-    steeredEchoes?: Set<string>;
-    /** Every steer this turn has taken, echoed or not: a stamped result naming one
-     *  answers the steer even after its echo drained `steeredEchoes`. */
-    steeredUuids?: Set<string>;
-    /** Set when a steered echo drains and cleared when a result records
-     *  `steeredSettle`. `steeredSettle` can already hold the interrupted cycle's
-     *  outcome (or a held turn's, moved over by `steer()`) when the echo lands, so
-     *  while this is set the recorded outcome predates the steered work and an
-     *  idle must not settle on it. */
-    steeredAwaitingResult?: boolean;
-    /** What a steered turn settles with once its steered work has run: the outcome
-     *  of its latest result, so its usage covers every cycle the turn ran. */
-    steeredSettle?: TurnOutcome;
-    carriedUsage?: AccumulatedUsage;
-    /** `carriedUsage`'s per-model counterpart, so a turn that survives a
-     *  clear-context restart keeps the `_meta.quota` rows it earned pre-restart. */
-    carriedModelUsage?: ModelTokenTally;
-    resolve: (outcome: TurnOutcome) => void;
-    reject: (error: unknown) => void;
-    /** Settles once the turn has ended or failed. */
-    completion?: Promise<void>;
-};
-/** A permission or elicitation request that awaits user input. */
-type OpenUserInput = {
-    /** The subagent that asked: absent for the main conversation and for a
-     *  request that names no agent. */
-    agentID?: string;
-    /** Set by a cancel that comes while the request is open (see
-     *  `withPendingUserInput`). */
-    cancelled?: boolean;
-};
-export type Session = {
-    query: Query;
-    input: Pushable<SDKUserMessage>;
-    /** Set by a cancel. While it is set, the consumer treats what arrives as the
-     *  work the cancel stopped: it drops main-thread `assistant` and `user`
-     *  messages (streamed text still goes out), skips results, and starts no
-     *  model cycle. Two things still go out: a tool result for a tool call that
-     *  the client holds open, until the client is told that the work ended, and,
-     *  as the turn settles, a report that closes each tool call left without a
-     *  result. Cleared when the next prompt's turn activates,
-     *  or when Claude Code starts a model request that serves none of
-     *  {@link Session.cancelledPrompts} (see the `status` case of the
-     *  consumer), such as its follow-up after a background command finished. */
-    cancelled: boolean;
-    /** The prompts whose work the cancel stopped: the turns it settled as
-     *  cancelled, and their steers. Recorded when the cancel arrives, before the
-     *  orphan accounting, which can undercount a prompt that Claude Code had
-     *  already taken off its queue. */
-    cancelledPrompts?: Set<string>;
-    /** FIFO of in-flight prompts. The head is the turn the SDK is currently
-     *  processing; later entries are queued and will be echoed in order. */
-    turnQueue?: Turn[];
-    /** The turn whose messages the consumer is currently attributing output to
-     *  (the head of `turnQueue` once its user message has been echoed). */
-    activeTurn?: Turn | null;
-    /** Session-owned native checkpoint reporter. Turn state stays on each Turn. */
-    fileChangeReporter?: NativeFileChangeReporter;
-    /** Optimistic goal state published for a submitted `/goal` command whose
-     *  matching runtime update has not arrived yet. Runtime updates for the old
-     *  goal are suppressed until this command is echoed or completes, otherwise
-     *  a late old-goal update can overwrite a replacement that the runtime never
-     *  announces (the compatibility case the optimistic update exists for). */
-    pendingGoalUpdate?: {
-        commandUuid: string;
-        expected: GoalSnapshot | null;
-        previous: GoalSnapshot | null | undefined;
-        started: boolean;
-    };
-    /** Last goal snapshot sent to the ACP client, used to roll back an
-     *  optimistic `/goal` update when the command itself fails. */
-    lastPublishedGoal?: GoalSnapshot | null;
-    /** Last follow-up prompt sent to the ACP client (`null` after a clear), so an
-     *  unchanged prediction is not re-notified. Undefined until the first push. */
-    lastPublishedPromptSuggestion?: string | null;
-    /** Whether an arriving `prompt_suggestion` still answers the turn the user is
-     *  waiting on: set at a turn's result, cleared when the next prompt arrives.
-     *  A prediction the user outran — the next prompt was sent before the
-     *  prediction was read off the stream — follows a turn that is already
-     *  answered, so it is dropped instead of published mid-turn. */
-    promptSuggestionExpected?: boolean;
-    /** Count of result messages the consumer should treat as orphans and skip
-     *  (not promote/attribute to the current head). When cancel() settles+removes
-     *  a queued turn, that turn's user message was already pushed to the SDK, so
-     *  the SDK still runs it and emits a result with no uuid we can match. Because
-     *  the SDK processes input FIFO, those orphan results arrive (in submission
-     *  order) before the next live turn's, so skipping exactly this many leaves
-     *  the genuine head untouched. On CLIs with the interrupt receipt, orphans
-     *  the interrupt dropped (absent from `still_queued`) are uncounted as soon
-     *  as the receipt arrives (see cancel()). Reset to 0 on every activation as
-     *  a backstop against a dropped queued input this can't see (older CLIs, a
-     *  receipt lost to a failed control round-trip). Only used when the CLI does
-     *  NOT emit lifecycle frames (see `orphanCommands` for the msg_lifecycle_v1
-     *  lane); a count can't express command coalescing — N queued commands can
-     *  fold into ONE turn emitting one result, leaving a stale skip of N-1. */
-    pendingOrphanResults?: number;
-    /** UUIDs of cancelled-before-echo commands that can still emit Claude's
-     * empty user-interruption diagnostic. Interrupt receipts and command
-     * lifecycle frames remove commands that were dropped before dispatch; the
-     * next ordinary result clears any stale survivors. */
-    pendingEmptyInterruptionDiagnosticCommands?: Set<string>;
-    /** msg_lifecycle_v1 lane of the orphan accounting (see
-     *  `pendingOrphanResults` for the count lane): the uuids of cancelled queued
-     *  turns whose SDK-side command may still produce an unaccounted result,
-     *  keyed to what we know of its fate. "pending" = not seen dispatched; if
-     *  the SDK drops it (interrupt, `cancelled` before "started") no result
-     *  ever comes. "started" = dispatched into a turn whose result is still
-     *  coming; exactly one terminal lifecycle frame will follow. "zombie" = its
-     *  turn was aborted/failed after dispatch with no result seen since
-     *  (`cancelled` after "started"); no more lifecycle frames come, but the
-     *  dead turn's error result may still arrive. Entries are removed the
-     *  moment their result is covered: EVERY user-turn result covers ALL
-     *  started and zombie entries at once (turns run sequentially and frames
-     *  arrive in stream order, so at any result the started entries were
-     *  dispatched into — possibly folded into — the emitting turn, and any
-     *  zombie's late result has already passed or never existed), whether that
-     *  result was attributed to the active turn or skipped echo-less (see
-     *  recordResultForOrphanCommands / ensureActiveTurn). A command's own
-     *  terminal frame also drains its entry ("completed" is emitted after any
-     *  result its turn produced; a bare `cancelled` deletes a pending entry —
-     *  dropped without running — and zombifies a started one). An echo-less
-     *  result is an orphan's iff this map is non-empty (FIFO: orphan turns run
-     *  before any live turn's). Cleared on every activation, same self-heal as
-     *  the count (covers a lost frame, which can leak an entry — each state
-     *  bounds the damage to one wrong skip). */
-    orphanCommands?: Map<string, "pending" | "started" | "zombie">;
-    /** True once a `system`/init advertised the msg_lifecycle_v1 capability, so
-     *  cancel() routes orphan accounting to `orphanCommands` (exact, per-uuid)
-     *  instead of `pendingOrphanResults` (count, coalescing-blind). */
-    msgLifecycleV1?: boolean;
-    /** True once a `system`/init advertised the request_marker_lists_v1
-     *  capability: each `status: requesting` frame, which starts a model
-     *  request, then lists the prompts the request serves in
-     *  `user_message_uuids`, and leaves the field out for a request that serves
-     *  none, such as a cycle that Claude Code started on its own. */
-    requestMarkerListsV1?: boolean;
-    /** A main-thread model request started (`status: requesting`) since the
-     *  last result, so a model cycle runs. Read only with
-     *  {@link Session.requestMarkerListsV1}. */
-    modelRequestSinceResult?: boolean;
-    /** Latched from `system`/init `terminal_slash_commands` (CLI 2.1.232+):
-     *  names of advertised slash commands whose UX is bound to the CLI's own
-     *  terminal (e.g. /doctor, /color). ACP clients aren't that terminal, so
-     *  these are filtered out of `available_commands_update` payloads. */
-    terminalSlashCommands?: string[];
-    /** The uuids of the user messages this adapter pushed whose echo has not come
-     *  back yet. Claude Code stamps the echo with the same human origin as a
-     *  message typed in another client, so the uuid is what tells the two apart. */
-    sentUserUuids?: Set<string>;
-    /** The `/remote-control` command that is running, from its request to its
-     *  reply. Prompts wait for it, and a second command is refused meanwhile. */
-    remoteControlCommand?: Promise<void>;
-    /** The resolved SKILL.md paths of the skill commands, keyed by the cwd and
-     *  the command name. A `commands_changed` clears it, because the skill
-     *  files can have changed then. */
-    skillPaths?: Map<string, string | undefined>;
-    /** Serialized `system`/init `plugin_errors` last logged, so the per-turn
-     *  init re-emit logs a plugin load failure once, not every turn. */
-    loggedPluginErrors?: string;
-    /** The long-lived consumer task. Lazily started on the first `prompt()` and
-     *  kept alive for the session so between-turn/background messages are still
-     *  drained and forwarded. */
-    consumer?: Promise<void>;
-    /** Set once the SDK query stream has terminated (it ran to `done` or threw a
-     *  non-process error). The query iterator is not reusable afterward, so a
-     *  later `prompt()` rejects instead of enqueueing onto a dead stream and
-     *  hanging (or silently restarting a consumer that resolves `end_turn`
-     *  without ever reaching the model). */
-    queryClosed?: boolean;
-    /** Set when `teardownSession` starts (a `session/close` or the connection
-     *  closing), so a prompt that was still starting ends cancelled. */
-    tornDown?: boolean;
-    cwd: string;
-    /** Serialized snapshot of session-defining params (cwd, mcpServers, skills)
-     *  used to detect when loadSession/resumeSession is called with changed values. */
-    sessionFingerprint: string;
-    /** Original ACP parameters used to recreate this query with a new provider. */
-    creationParams?: NewSessionRequest;
-    settingsManager: SettingsManager;
-    /** Higher-priority programmatic settings passed to query(). Retained so
-     * model switches resolve effort from the same effective settings as the SDK. */
-    effortSettingsOverride?: Settings;
-    /** This session's title state and the turn-end logic that maintains it. */
-    titles: SessionTitles;
-    accumulatedUsage: AccumulatedUsage;
-    /** The active turn's spend broken out per model — the breakdown behind
-     *  `accumulatedUsage`, reported as `_meta.quota.model_usage` on the prompt
-     *  response. Accumulated and reset in lockstep with it. */
-    accumulatedModelUsage?: ModelTokenTally;
-    /** The last per-model reading seen on this query, autonomous cycles included.
-     *  `result.modelUsage` is a running total for the whole query() call rather
-     *  than a per-result figure, so consecutive readings are what a result's own
-     *  spend is derived from — this is not itself a turn tally. `undefined` on a
-     *  resumed session until its first result: the CLI continues the running
-     *  total from the totals the transcript saved (SDK 0.3.277+), so that first
-     *  reading is the baseline for later increments, not the first turn's spend
-     *  (see resumedFirstResultModelUsage). */
-    lastModelUsageReading?: ModelTokenTally;
-    modes: SessionModeState;
-    /** The mode the session left when it entered plan mode, if it is in plan. */
-    prePlanMode?: string;
-    models: SessionModelState;
-    modelInfos: ModelInfo[];
-    /** Prevents the model-specific Auto fallback from spamming the transcript. */
-    autoModeFallbackWarningShown?: boolean;
-    /** Initial mode fallback is reported after session/new, on the first prompt. */
-    autoModeFallbackWarningPending?: boolean;
-    configOptions: SessionConfigOption[];
-    /** Custom main-thread agent personas the user (or a plugin/project) has
-     *  configured, discovered via `supportedAgents()` with Claude Code's built-in
-     *  subagents filtered out. Empty when none are configured, in which case the
-     *  "agent" config option is omitted entirely. */
-    agents: AgentInfo[];
-    /** The currently selected main-thread agent name, or "default" for the
-     *  standard Claude Code agent (no `agent` flag applied). */
-    currentAgent: string;
-    /** Whether Fast mode is currently enabled for this session. Tracked as the
-     *  user's intent so it persists across model switches; the Fast mode config
-     *  option is only surfaced while the selected model supports it. */
-    fastModeEnabled: boolean;
-    /** Whether ultracode is turned on for this session. Tracked as the user's
-     *  intent, like `fastModeEnabled`: the CLI keeps the request across model
-     *  switches and applies it whenever the model supports ultracode, while the
-     *  config option is only surfaced on supporting models. */
-    ultracodeEnabled: boolean;
-    /** Whether dynamic workflows are enabled, learned from the CLI's
-     *  `get_settings` at session start; undefined when unknown. Combined with
-     *  the model's support to decide whether to show the ultracode option. */
-    ultracodeWorkflowsEnabled?: boolean;
-    /** The non-default effort the user picked through the ACP picker this
-     *  session. A pin lives at the SDK's flag layer, which overrides the CLI's
-     *  persisted effort (including the per-model `modelSettings` entries), so it
-     *  follows the session across model switches. Without a pin, opted-in clients
-     *  apply the settings-derived effort or concrete recommendation on each switch;
-     *  legacy clients leave resolution to the CLI. Cleared when the
-     *  user picks "Default" (the flag layer is cleared with it) or when a model
-     *  switch clamps the pin away. */
-    effortPinnedLevel?: string;
-    /** Last concrete effort successfully written to the SDK flag layer. This is
-     *  independent of user ownership: opted-in clients also apply automatic
-     *  recommendations and settings-derived values. */
-    appliedEffortLevel?: string;
-    /** Why the SDK currently can't serve Fast mode, when the reason is one worth
-     *  telling the user about (see {@link FAST_MODE_UNAVAILABLE_EXPLANATIONS} —
-     *  routine states like the SDK's own opt-in requirement normalize to
-     *  `undefined`). Refreshed from every `fast_mode_disabled_reason` the SDK
-     *  reports on `system`/init and user-turn `result`s; surfaced in the Fast mode
-     *  option's description so a toggle that snaps back off explains itself. */
-    fastModeDisabledReason?: FastModeDisabledReason;
-    abortController: AbortController;
-    /** Signal the consumer races `query.next()` against. Aborted by cancel()
-     *  (after a grace period) to force the active turn to settle "cancelled" when
-     *  the SDK is wedged and `query.next()` never yields again (issue #680).
-     *  Distinct from `abortController`: this only wakes the consumer; it does NOT
-     *  touch the SDK query/subprocess. The consumer re-arms it after each fire.
-     *  Undefined until the consumer is started by the first prompt. */
-    cancelController?: AbortController;
-    /** Pending grace-period timer that aborts `cancelController`. Cleared when the
-     *  active turn settles normally so the backstop never fires after a clean
-     *  cancel. */
-    forceCancelTimer?: ReturnType<typeof setTimeout>;
-    emitRawSDKMessages: boolean | SDKMessageFilter[];
-    /** Whether nested subagent text/thinking is forwarded to the ACP client.
-     *  Enabled by either the ACP capability or the pre-existing SDK option. */
-    forwardSubagentText: boolean;
-    /** The ACP permission and elicitation requests that await user input.
-     *  Parallel subagents can ask concurrently. Steering stays non-interrupting
-     *  while any request is open; the foreground work awaits the user while one
-     *  that blocks it is open (see {@link blocksForeground}). */
-    openUserInputs?: Set<OpenUserInput>;
-    /** Context window size of the session's current model, carried across
-     *  prompts so mid-stream usage_update notifications report a correct `size`
-     *  before the turn's first result message arrives. Seeded synchronously at
-     *  session creation and on model switches from the per-model cache or the
-     *  text heuristic (DEFAULT_CONTEXT_WINDOW when both miss), refined by a
-     *  background `getContextUsage` when that seed was a guess (see
-     *  `refreshContextWindowInBackground`), then confirmed — and the cache
-     *  populated — by each result's modelUsage. No awaited IPC is on these
-     *  paths (see the seeding call sites and `contextWindowCache`). */
-    contextWindowSize: number;
-    contextUsedTokens?: number;
-    /** Whether `contextWindowSize` came from an authoritative source (the
-     *  cross-session cache, a `result.modelUsage`, or the background
-     *  `getContextUsage`) rather than the text heuristic / default. Guards the
-     *  mid-stream `message_start` heuristic upgrade: an authoritative window that
-     *  happens to equal DEFAULT_CONTEXT_WINDOW must not be mistaken for "unseeded"
-     *  and clobbered by a "1m" text match. */
-    contextWindowAuthoritative: boolean;
-    /** Stable identifier of the LLM backend this session's query was created
-     *  against, derived from the routing-relevant vars of the exact `env` handed
-     *  to the SDK at query creation (see {@link providerCacheKeyFor}). The context
-     *  window is a property of (model id, backend) — the same resolved model id
-     *  can name different windows behind different base URLs, routing headers, or
-     *  credentials — so this scopes the module-global `contextWindowCache` per
-     *  backend. Captured from the query's own env (not re-resolved later) because
-     *  the process-wide provider config can change while a session is being
-     *  created, while the query stays baked to the env it was created with. */
-    providerCacheKey: string;
-    /** Accumulated task list for the session, keyed by task ID. Task IDs are
-     *  per-session, so this state must not be shared across sessions. */
-    taskState: TaskState;
-    /** Caches `tool_use` blocks by id so the matching `tool_result` can recover
-     *  the tool name/input when mapping it to a `tool_call_update`. Per-session
-     *  (tool_use ids are only unique within a session) and pruned at
-     *  `tool_result` time so a long-running session doesn't accumulate every
-     *  tool call for its whole lifetime. */
-    toolUseCache: ToolUseCache;
-    /** Tracks which tool_use ids we've already emitted a `tool_call` for, so the
-     *  second source to encounter a tool call sends a `tool_call_update` instead
-     *  of a duplicate `tool_call`. The SDK can invoke `canUseTool` (→ a permission
-     *  request, which emits the tool_call eagerly so the client has it before
-     *  being asked to approve it) either before or after the assistant message's
-     *  tool_use block streams; this set makes the two paths converge regardless of
-     *  order. Pruned at `tool_result` time alongside `toolUseCache`. */
-    emittedToolCalls: Set<string>;
-    /** The tool names of the tool uses whose result arrived, after
-     *  {@link toolUseCache} dropped them. An async task can name its tool call
-     *  after the result, and the async task runtime needs the tool name. The
-     *  oldest entries are dropped. */
-    resolvedToolNames?: Map<string, string>;
-    /** The open tool calls that Claude Code sent to the tool runner: a complete
-     *  assistant message holds their `tool_use`, or a permission request asked
-     *  for them. A streamed tool_use that never reached a complete message is
-     *  not here: Claude abandoned it before it ran. Pruned when the call ends;
-     *  the oldest entries are dropped. */
-    dispatchedToolCalls?: Set<string>;
-    /** The tool uses that the consumer reached in the stream, each with whether
-     *  it dropped it as output of the work a cancel stopped (`true`, see
-     *  `dropsStoppedWorkOutput`). The first sight of a tool use decides: its
-     *  streamed start, or its complete message. `canUseTool` and the v2 preview
-     *  hook read it (see `isStoppedWorkToolUse`). The oldest entries are
-     *  dropped. */
-    reachedToolUses?: Map<string, boolean>;
-    /** What waits for the consumer to reach each tool use (see
-     *  `isStoppedWorkToolUse`). */
-    toolUseWaiters?: Map<string, Set<() => void>>;
-    /** For each open tool call that a subagent made: the Agent/Task call that
-     *  started that subagent. When a cancel ends such a call, the report names
-     *  that parent as the call's other updates do, so that every client form
-     *  routes it with them. It also tells the calls of a background subagent,
-     *  which a cancel leaves open while the subagent keeps running. Pruned when
-     *  the call ends; the oldest entries are dropped. */
-    toolCallParents?: Map<string, string>;
-    /** The fields that the client holds for each open tool call, so that a
-     *  `tool_call_update` resends only the fields that changed. Created lazily
-     *  by {@link toolCallFieldsOf}. */
-    toolCallFields?: ToolCallFieldTracker;
-    /** ACP session affinity for calls emitted eagerly by permission handling. */
-    eagerToolCallSessions?: Map<string, string>;
-    /** ExitPlanMode denial that intentionally interrupts the current Claude
-     *  cycle. Correlated by tool-use id until the terminal result arrives. */
-    pendingExitPlanModeInterruption?: {
-        toolUseId: string;
-        toolResultSeen: boolean;
-    };
-    pendingExitPlanContextReset?: {
-        toolUseId: string;
-        plan: string;
-        mode: PermissionMode;
-    };
-    /** Registry of live background tasks, keyed by task id: populated at
-     *  `task_started`, pruned when the task settles (a `task_notification` or
-     *  a terminal `task_updated` patch), and reconciled against
-     *  `background_tasks_changed`'s replace-semantics payload so a lost
-     *  bookend can't leak an entry. One structure for both of its concerns so
-     *  a future terminal path can't prune one and not the other:
-     *
-     *  `parentToolUseId` — the tool_use id of the Agent/Task call that spawned
-     *  the task. For subagent tasks the SDK keys its registry by agent id, so
-     *  `task_started.task_id` IS the `agentID` that `canUseTool` later
-     *  receives. Lets the permission flow attribute a subagent's
-     *  eagerly-emitted `tool_call` (and the permission request itself) to its
-     *  parent tool call via `_meta.claudeCode.parentToolUseId`, matching the
-     *  streamed subagent path. Best-effort: a `canUseTool` that races ahead of
-     *  the consumer processing `task_started` omits the attribution from the
-     *  eager tool_call, and the streamed tool_use chunk's refining
-     *  `tool_call_update` — which carries the message-level
-     *  `parent_tool_use_id` — restores it for merging clients; that recovery
-     *  is what makes best-effort acceptable here.
-     *
-     *  `isSubagent` — whether the task is a Task/Agent-tool subagent
-     *  (`task_started` carried a `subagent_type`). Read by
-     *  `turnAwaitingSubagents` (with `spawnedTaskIds`) to decide whether a
-     *  turn's settlement is deferred (see `Turn.deferredSettle`), so the
-     *  subagents' post-result output and permission requests stay inside the
-     *  turn (issues #864/#866). A client with `backgroundSubagents` gets no
-     *  such hold. Its subagent requests keep this attribution after the
-     *  prompt response. Deliberately false for non-subagent background
-     *  tasks (e.g. a `run_in_background` dev server): those can outlive every
-     *  turn, and the model's contract with them is a wake-on-exit
-     *  notification, not a turn-scoped drain — a hold must NEVER wait on a
-     *  shell.
-     *
-     *  `endedPerLevel` — a `background_tasks_changed` payload did not include
-     *  this subagent entry. The level's universe is BACKGROUND tasks only, so
-     *  a live sync (foreground) subagent is legitimately absent — its entry is
-     *  kept for permission attribution — but a hold must stop waiting on the
-     *  id: an absent id can equally be a leaked async entry whose settle
-     *  bookends were lost, and waiting on it would park the hold forever.
-     *  Non-subagent entries are simply deleted instead (shells are always in
-     *  the level's universe). */
-    liveBackgroundTasks: Map<string, {
-        parentToolUseId?: string;
-        isSubagent: boolean;
-        /** The task's kind (`task_started.task_type`), such as `local_bash` or
-         *  `local_workflow`. Absent when Claude Code did not say. */
-        taskType?: string;
-        /** Whether the task runs in the background, so that the tool call that
-         *  spawned it does not wait on it (`task_started.is_backgrounded`, or a
-         *  later `task_updated` patch). Absent when Claude Code did not say. */
-        backgrounded?: boolean;
-        /** The subagent task whose agent launched this task
-         *  (`task_started.parent_task_id`), absent for one the main conversation
-         *  launched. */
-        parentTaskId?: string;
-        /** Absent-from-level lifecycle, one field so the illegal
-         *  armed-but-not-ended state is unrepresentable: undefined = live per
-         *  the level signal; "ended" = a level omitted the task (holds stop
-         *  waiting on it; attribution is kept); "sweep-armed" = a turn
-         *  activation saw it ended — the NEXT activation deletes it. The
-         *  one-activation grace exists for the absent-mark race (a level
-         *  payload built before a live async agent's registration): a
-         *  corrective inclusive level resets the field to undefined — one
-         *  assignment, disarming any in-flight sweep — if it arrives within a
-         *  full turn, keeping the agent's attribution; eager deletion would
-         *  be irreversible, since levels never ADD entries. A re-mark
-         *  preserves an in-flight arm (`??=`), keeping a continuously absent
-         *  entry on its two-activation clock. */
-        endedPerLevel?: "ended" | "sweep-armed";
-    }>;
-    /** Whether `session/cancel` also stops the session's background workflows
-     *  (see `stopBackgroundWorkflows`). Claude Code's interrupt kills background
-     *  subagents and workflows, unless the query declares
-     *  `perTaskStopAffordance`: then it spares both, and the client is expected
-     *  to stop each one itself. A client that can cancel one subagent gets the
-     *  declaration, but it has no control for a workflow unless it is AIR with
-     *  `asyncTasks` (`_session/async_task/stop`). So for such a client the
-     *  adapter stops the workflows after the interrupt, as the interrupt did
-     *  before. */
-    stopsWorkflowsOnCancel?: boolean;
-    /** The display terminals of the commands that went to the background and
-     *  still run, by the id of the command's task: the Bash tool call whose
-     *  terminal it is, and the subagent tool call that ran it, if any. The
-     *  terminal exits when the task ends, not at the tool result (see
-     *  `withRunningTerminal`). Only for a client that renders terminals and is
-     *  not AIR, which shows the command through its async tasks. */
-    backgroundTerminals?: Map<string, {
-        toolCallId: string;
-        parentToolUseId?: string;
-    }>;
-    /** The parent tool call of each subagent that a settle bookend removed from
-     *  `liveBackgroundTasks`. The SDK can resume such a subagent under the same
-     *  agent id without a new `task_started` (a running `task_updated` patch or
-     *  a SendMessage `resumedAgentId`). The resume signal puts the subagent back
-     *  into `liveBackgroundTasks` from this record, so the resuming turn holds
-     *  and its permission requests keep their attribution. With
-     *  `backgroundSubagents` the resuming turn does not hold, and the
-     *  attribution stays the same. Bounded by
-     *  `MAX_RESUMABLE_SUBAGENTS`, oldest first. */
-    resumableSubagents?: Map<string, {
-        parentToolUseId?: string;
-    }>;
-    /** The latest `run_id` seen on each task's events, so a late frame of an
-     *  earlier run is dropped (see `isLateTaskRun`). Run ids are per CLI
-     *  process, as is a session. Bounded by `MAX_TASK_RUN_IDS`, oldest first. */
-    taskRunIds?: Map<string, string>;
-    /** Native ACP subagent sessions negotiated through PR #1992. Records are
-     *  retained for the parent session lifetime so late child output cannot be
-     *  rebound to another task after the SDK prunes its live-task registry. */
-    nativeSubagentsByTaskId?: Map<string, NativeSubagent>;
-    /** Resolves the spawning Agent/Task tool use carried by child messages to
-     *  the corresponding native ACP child session. */
-    nativeSubagentTaskIdByToolUseId?: Map<string, string>;
-    /** Captures the ACP session in which an Agent/Task tool call was made. This
-     *  supplies the immediate parent for nested `task_started` notifications.
-     *  Their `parent_task_id` (SDK 0.3.292+) names the launching subagent too;
-     *  only {@link blocksForeground} reads it so far. */
-    nativeSubagentParentByToolUseId?: Map<string, string>;
-    /** Session-owned lifecycle controller shared by the consumer, cancel, reset,
-     *  and teardown paths. */
-    nativeSubagentRuntime?: NativeSubagentRuntime;
-    /** Child-aware delivery closure paired with {@link nativeSubagentRuntime}. */
-    nativeSubagentDeliver?: (notification: AcpSessionNotification) => Promise<void>;
-    /** The consumer's `closeCancelledToolCalls`, for `cancelTurns`, which settles
-     *  a held or settling turn itself. */
-    closeCancelledToolCalls?: (turn: Turn) => Promise<void>;
-    /** Session-owned async task controller. Prompt cancellation intentionally
-     *  does not finish it because background work may outlive a prompt. */
-    asyncTaskRuntime?: AsyncTaskRuntime;
-    /** The consumer's compaction lifecycle, exposed so the PostCompact hook can
-     *  hand it the retained summary. */
-    contextCompaction?: ContextCompactionLifecycle;
-    /** Whether any top-level assistant text reached the client since the last
-     *  stretch boundary. Set as a side effect of sending in the consumer's
-     *  `sendUpdate`, never at an emission site; read at the terminal `result`
-     *  to tell a turn whose answer was already delivered from one that only
-     *  ever carried it on `result` (issue #453). Session-level (not
-     *  consumer-scoped) so cancel()'s inline settle can clear it.
-     *
-     *  The CURRENT boundary set — a new clear site must be added here: the
-     *  result case's `finally` (user-turn results), settleActive's wasHeld
-     *  clear (every held-turn settle lane: drain settle, both hand-offs,
-     *  stream-done), failActive, the force-cancel backstop, the idle
-     *  cancelled-settle, the autonomous-result close (only with no turn
-     *  active OR queued — see its queued-turn guard), and cancel()'s inline
-     *  mirror.
-     *
-     *  Deliberately NOT reset on turn activation: activation can fire
-     *  mid-message (see the echo hand-off), so a flag cleared there would
-     *  forget text that already streamed and the result text would be emitted
-     *  a second time. Neither the consolidated `assistant` message nor a
-     *  `stream_event` carries `origin`, so an autonomous cycle's prose is
-     *  indistinguishable from a user turn's here and sets the flag too; the
-     *  autonomous-result close normally ends that stretch so a replayed
-     *  prompt behind it still delivers, and only in the racing window (a
-     *  turn already active or queued when the autonomous result lands) does
-     *  the replayed turn stay silent rather than risk a duplicate. */
-    emittedAssistantText: boolean;
-    /** The most recent `session_state_changed` state the consumer processed.
-     *  Read by cancel() to decide whether the interrupt will produce a
-     *  trailing idle worth pre-counting: interrupting a RUNNING cycle yields
-     *  one; interrupting an already-idle session (the common held-turn shape)
-     *  yields none, and a pre-counted debt that never drains would mask one
-     *  future issue-#825 detection. */
-    lastSessionState?: "idle" | "running" | "requires_action";
-    /** How many trailing `session_state_changed: idle` messages are already
-     *  accounted for: every result is followed by one (user-turn results that
-     *  terminate a turn — settle, reject, or orphan skip — and autonomous
-     *  cycles alike), as is a cancelled turn settled by the next turn's echo
-     *  hand-off or by cancel()'s inline settle of a held turn whose interrupt
-     *  pre-empts a running cycle — the reason this lives on the Session:
-     *  cancel() must be able to record the debt. The idle handler absorbs
-     *  owed idles; an idle that arrives when NONE is owed while the active
-     *  turn is still unsettled means the SDK ended the turn without ever
-     *  emitting its result, so the turn will never settle on its own (issue
-     *  #825). Stream-level debt, deliberately NOT reset per turn: a lagged
-     *  idle can arrive after the next turn has already activated (issue
-     *  #773), and the debt is what attributes it to the turn that owed it.
-     *  Over-counting (an idle the SDK never emits) is benign: the counter
-     *  just absorbs one future idle, and detection degrades to the status quo
-     *  rather than misfiring. */
-    owedTrailingIdles: number;
-    /** Maps the ACP `messageId` we expose to clients (see `messageIdForGrouping`)
-     *  to the SDK message uuid that the Agent SDK's rewind/resume APIs key on
-     *  (`Query.rewindFiles` takes a user-message uuid; `resumeSessionAt` takes an
-     *  `SDKAssistantMessage.uuid`). For assistant turns the two differ — the ACP
-     *  id is the Anthropic API message id (`msg_…`), available at `message_start`
-     *  so streamed chunks can carry it, while the uuid only arrives on the
-     *  consolidated message — so a client can only ask to rewind/fork by the id it
-     *  was given, and we need this table to translate it back.
-     *
-     *  Populated as a byproduct of the message loop (the consolidated message
-     *  carries both ids) and of `replaySessionHistory` on load, so no extra
-     *  `getSessionMessages` read is needed at rewind time. Last-write-wins
-     *  naturally yields the turn-boundary uuid when one `msg_…` spans several
-     *  content-block messages.
-     *
-     *  `unstable_forkSession` reads it to find the fork point without a read of
-     *  the transcript. The map lives until the session closes. */
-    messageIdToUuid: Map<string, string>;
-    /** Durable-for-this-consumer failure state shared with session/load replay.
-     *  Keeping it on the Session lets replay seed a failure that the persistent
-     *  consumer can later clear with the same id and a higher revision. */
-    sessionFailureState: SessionFailureState;
-    /** State of the `--hide-claude-auth` subscription guard for this session.
-     *  Built on the first guarded turn; most sessions never need it. */
-    claudeSubscriptionGuard?: ClaudeSubscriptionGuardState;
-    /** Identity kind of the account this session was created on. The CLI probe
-     *  compares its own read against it to notice that the credential behind the
-     *  cached account was swapped. Undefined when the account carried no
-     *  identity signal, which is "nothing to compare", not a match. */
-    accountKind?: AuthStatusKind;
-    /** Set under `--hide-claude-auth` when the CLI reported a sign-out during
-     *  this session. The query is closed and the account it cached at
-     *  `initialize` now describes a credential that no longer works, so the next
-     *  turn recreates the query before it runs. */
-    needsSignOutRespawn?: boolean;
-    /** The in-flight recreation, so turns that arrive together share one. */
-    signOutRespawn?: Promise<void>;
-} & sessionIndex.SessionIndexFields;
-/** Compute a stable fingerprint of the session-defining params so we can
- *  detect when a loadSession/resumeSession call requires tearing down and
- *  recreating the underlying Query process. Every option classified in
- *  {@link OPTION_REBUILDS_SESSION} is covered, so a warm resume never silently
- *  keeps stale values. MCP servers are sorted by name, and skills are
- *  normalized as a set, so ordering differences don't trigger unnecessary
- *  recreations. */
-export declare function computeSessionFingerprint(params: {
-    cwd: string;
-    mcpServers?: NewSessionRequest["mcpServers"];
-    additionalDirectories?: NewSessionRequest["additionalDirectories"];
-    systemPrompt?: NewSessionRequest["systemPrompt"];
-    _meta?: NewSessionRequest["_meta"];
-}): string;
-export type SDKMessageFilter = {
-    type: string;
-    subtype?: string;
-    origin?: SDKMessageOrigin["kind"];
-};
-/**
- * Extra metadata that can be given when creating a new session.
- */
-export type NewSessionMeta = {
-    claudeCode?: {
-        /**
-         * Options forwarded to Claude Code when starting a new session.
-         * Those parameters will be ignored and managed by ACP:
-         *   - cwd
-         *   - includePartialMessages
-         *   - permissionMode
-         *   - canUseTool
-         *   - executable
-         * Those parameters will be used and updated to work with ACP:
-         *   - hooks (merged with ACP's hooks)
-         *   - mcpServers (merged with ACP's mcpServers)
-         *   - disallowedTools (merged with ACP's disallowedTools)
-         *   - tools (passed through; defaults to claude_code preset if not provided)
-         *   - allowDangerouslySkipPermissions (set to `false` to remove bypassPermissions
-         *     from this session; repeat it on session/load. `true` cannot override root)
-         */
-        options?: Options;
-        /**
-         * When set, raw SDK messages are emitted as extNotification("_claude/sdkMessage", message)
-         * in addition to normal processing.
-         * - true: emit all messages
-         * - false/undefined: emit nothing (default)
-         * - SDKMessageFilter[]: emit only messages matching at least one filter
-         */
-        emitRawSDKMessages?: boolean | SDKMessageFilter[];
-    };
-    additionalRoots?: string[];
-};
-/**
- * Extra metadata for 'gateway' authentication requests.
- */
-type GatewayAuthMeta = {
-    /**
-     * These parameters are mapped to environment variables to:
-     * - Redirect API calls via baseUrl
-     * - Inject custom headers
-     * - Bypass the default Claude login requirement
-     *
-     * Both members are optional in the type because the payload arrives
-     * unvalidated from the client. `authenticate` rejects a request that lacks a
-     * usable `baseUrl`.
-     */
-    gateway?: {
-        baseUrl?: string;
-        headers?: Record<string, string>;
-    };
-};
-type GatewayAuthRequest = AuthenticateRequest & {
-    _meta?: GatewayAuthMeta;
-};
-/**
- * Resolved, non-secret + secret routing config for the `main` provider. This is
- * the shared shape produced by both `providers/set` and the legacy gateway auth
- * path, and consumed by {@link createEnvForProvider}. `null` means the provider
- * is unconfigured (no client-managed routing in effect).
- */
-type ProviderConfig = {
-    apiType: LlmProtocol;
-    baseUrl: string;
-    headers: Record<string, string>;
-    /** Present only for `apiType === "vertex"`. */
-    vertex?: {
-        projectId: string;
-        region: string;
-    };
-    /**
-     * Model ids an `anthropic` or `bedrock` gateway listed when it was set via
-     * `providers/set`; the model picker offers only these. Absent when the
-     * listing failed or the config came from elsewhere (gateway `authenticate`),
-     * so nothing is narrowed.
-     */
-    listedModels?: string[];
-    /**
-     * The cross-region prefix of the model ids a `bedrock` gateway
-     * listed (`eu` for `eu.anthropic.claude-sonnet-5`), passed to the CLI as
-     * `ANTHROPIC_BEDROCK_REGION_PREFIX` so it calls the models under that prefix.
-     */
-    bedrockRegionPrefix?: string;
-};
-export type { ToolUpdateMeta } from "./tool-calls/renderer.js";
-export type ToolUseCache = {
-    [key: string]: {
-        type: "tool_use" | "server_tool_use" | "mcp_tool_use";
-        id: string;
-        name: string;
-        input: unknown;
-    };
-};
-type StreamedToolInput = {
-    id: string;
-    name: string;
-    partialJson: string;
-    inString: boolean;
-    escaped: boolean;
-    objectDepth: number;
-    arrayDepth: number;
-    /** Offset of the most recent comma at the top level of the input object
-     *  (-1 before the first). Everything before it is a complete field. */
-    lastTopLevelComma: number;
-    /** The comma offset the last emitted refinement was sliced at (-1 before the
-     *  first), so a field boundary only triggers one recovery attempt. */
-    emittedThroughComma: number;
-};
-export type StreamedToolInputCache = Map<string, Map<number, StreamedToolInput>>;
-export declare function claudeCliPath(): Promise<string>;
-/**
- * Return user-message content with local-command and injected-context marker
- * tags removed, or `null` if nothing meaningful remains (caller should skip
- * the message). Preserves real prose that's mixed in alongside the markers —
- * e.g. a message like `<command-name>…</command-name>hi` becomes `hi`, and
- * `hi<system-reminder>…</system-reminder>` becomes `hi`.
- */
-export declare function stripLocalCommandMetadata(content: unknown): unknown | null;
-export declare function isLocalCommandMetadata(content: unknown): boolean;
-/**
- * True for the synthetic assistant message the CLI injects into the transcript
- * when a turn fails authentication (e.g. "Not logged in · Please run /login",
- * "Session expired. Please run /login to sign in again."). The `/login`
- * instruction is Claude Code TUI-specific and meaningless to ACP clients
- * (issue #863). The live prompt loop suppresses the text and fails the turn
- * with `authRequired` so the client can run its own auth flow; replay must
- * skip it too — both for parity with what the client saw live and because the
- * message stays in the transcript forever, so it would resurface on every
- * session/load even after the user has logged back in.
- *
- * Takes the API message (`message.message`), which replay only knows as
- * `unknown`. The persisted record's structured `error: "authentication_failed"`
- * marker is stripped by `getSessionMessages`, so the synthetic model + text is
- * all both paths have to match on.
- */
-export declare function isSyntheticLoginMessage(apiMessage: unknown): boolean;
-/**
- * True for a transcript message delivered to the model from another agent,
- * session or channel. Since SDK 0.3.284 `getSessionMessages` returns these as
- * `is_meta` user messages whose content is the full harness framing (envelope
- * XML plus the "not typed by your user" preamble). The live prompt loop never
- * renders them, so replay skips them too rather than presenting them as text
- * the user typed. Other `is_meta` messages (compact summaries) are kept.
- *
- * `is_meta` and `origin` are runtime fields not declared on `SessionMessage`.
- */
-export declare function isReplayHiddenMetaMessage(message: unknown): boolean;
-/**
- * Client-facing surface the agent calls back into. This is the subset of ACP
- * client methods the agent actually uses, expressed as a narrow interface so
- * tests can supply lightweight mocks. In production it is backed by
- * {@link ClientConnection} over the SDK's typed `AgentContext`.
- */
-export interface AcpClient {
-    sessionUpdate(params: AcpSessionNotification): Promise<void>;
-    /** `signal`, when aborted, sends `$/cancel_request` for the in-flight
-     *  permission request so the client can dismiss its prompt (and settle our
-     *  await) instead of leaving the dialog open after the turn was cancelled. */
-    requestPermission(params: AcpPermissionRequest, signal?: AbortSignal): Promise<RequestPermissionResponse>;
-    readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse>;
-    writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse>;
-    /** `signal`, when aborted, sends `$/cancel_request` for the in-flight
-     *  elicitation so the client can dismiss its prompt and settle our await. */
-    createElicitation(params: CreateElicitationRequest, signal?: AbortSignal): Promise<CreateElicitationResponse>;
-    completeElicitation(params: CompleteElicitationNotification): Promise<void>;
-    /** Send a custom (extension) notification, e.g. `_claude/sdkMessage`. */
-    extNotification(method: string, params: Record<string, unknown>): Promise<void>;
-}
-export declare class ClaudeAcpAgent {
-    sessions: {
-        [key: string]: Session;
-    };
-    client: AcpClient;
-    clientCapabilities?: ClientCapabilities;
-    /** The tool call report choices, read once from {@link clientCapabilities} in `initialize`. */
-    private toolCallCapabilities;
-    logger: Logger;
-    private readonly sessionModes;
-    gatewayAuthRequest?: GatewayAuthRequest;
-    /** Set while ACP overrides the agent's native provider configuration. */
-    providerConfig?: ProviderConfig;
-    /** Serializes provider changes while every open query is recreated between turns. */
-    private providerUpdate;
-    private readonly exitPlan;
-    /** Last auth identity reported to the client, connection-scoped like
-     *  `authenticate`/`logout`. Undefined means "not determined yet". */
-    currentAuthStatus?: AuthStatus;
-    private authStatusSettings?;
-    private authStatusHelper?;
-    /** In-flight `claude auth status --json` probe, shared by every caller so
-     *  a concurrent `initialize` and start-of-prompt read never spawn two CLI
-     *  processes. */
-    private cliAuthProbe;
-    /** Counts auth-affecting events (`authenticate`, `logout`) on this
-     *  connection. A probe records it at start and publishes only if it has not
-     *  moved, so a slow read can never overwrite a newer login or logout. */
-    private authEpoch;
-    /** Keeps the "session account told us nothing" note to one line per process
-     *  instead of one per session. */
-    private loggedUninformativeAccount;
-    /** Same, for the "client provider override active" note. */
-    private loggedOverriddenAccount;
-    /** Same, for the "the CLI probe timed out" warning: a wedged CLI stays wedged
-     *  and would otherwise warn once per probe, i.e. once per user prompt. */
-    private loggedProbeTimeout;
-    /** Grace period before a `session/cancel` forces a wedged prompt loop to
-     *  return "cancelled". See {@link DEFAULT_FORCE_CANCEL_GRACE_MS}. Mutable so
-     *  tests can shrink it. */
-    forceCancelGraceMs: number;
-    /** How long `canUseTool` or a hook waits for the consumer to reach a tool
-     *  use (see `isStoppedWorkToolUse`). Mutable so tests can shrink it. */
-    toolUseWaitMs: number;
-    /**
-     * The connection serves ACP v2 (`src/v2/`). The agent still speaks v1
-     * types, except for the tool call content that v2 needs and v1 cannot
-     * express: see {@link ToolCallClientCapabilities.v2}.
-     */
-    private readonly v2;
-    /**
-     * The subagent replay of each session's last load, until
-     * {@link publishCurrentSubagentStates} sends its children's current states.
-     */
-    private readonly replayedSubagents;
-    /**
-     * AIR's draft: the model that the last load of each session replayed to each
-     * child session, as the model id and the entry that went out. See
-     * {@link publishReplayedChildModels}.
-     */
-    private readonly replayedChildModels;
-    /** See the `foreground` constructor option. */
-    private readonly foregroundEvents?;
-    /**
-     * The foreground work of each session while it runs, by the session id that
-     * the client knows, on every connection: only the `foreground` option
-     * reports it. A clear-context restart replaces the Claude Code session
-     * behind that id and moves the running turn to it, so the work belongs to the
-     * id, not to a {@link Session}.
-     */
-    private readonly foregroundWork;
-    /** The session index (docs/air-extensions.md, "Session index"). */
-    private readonly sessionIndex;
-    /**
-     * Whether a turn ends at its result while background subagents that it
-     * spawned or resumed still run. Only an ACP v1 AIR client that declares
-     * `backgroundSubagents` gets this. Every other client keeps the hold of
-     * `Turn.deferredSettle`.
-     */
-    private endsTurnsWithLiveSubagents;
-    constructor(client: AcpClient, logger?: Logger, options?: {
-        v2?: boolean;
-        /**
-         * Where the agent reports a session's foreground work (see
-         * {@link ForegroundEvents}), called each time work starts in the session
-         * `sessionId`. Without it, nothing reports the work, which the agent
-         * still tracks: a v1 client has no session state, and learns that a turn
-         * ended from its prompt response.
-         */
-        foreground?: (sessionId: string) => ForegroundEvents;
-    });
-    initialize(request: InitializeRequest): Promise<InitializeResponse>;
-    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
-    /**
-     * Start the CLI of a loaded session, and replay the history while the CLI
-     * starts. The CLI start takes most of the load time, and the replay needs
-     * only the transcript and the {@link ReplayState}. An invalid `cwd` fails
-     * before the first update. A failed CLI start stops the replay.
-     */
-    private createSessionWhileReplaying;
-    /**
-     * Copies the session's transcript into a new session, then starts that
-     * session, so the client can prompt it as soon as the response arrives, as
-     * the schema requires of a fork. It starts like a resumed session: from the
-     * copied transcript, with the model and the permission mode it records. A
-     * later load or resume with the same settings reuses it.
-     */
-    unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse>;
-    /** Runs `fork`, the handler of a `session/fork` request of `sourceId`,
-     *  with its forks held back from the session list (see
-     *  {@link sessionIndex.SessionIndexConnection.forking}). */
-    forking<T>(sourceId: string, fork: () => Promise<T>): Promise<T>;
-    resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
-    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
-    /**
-     * One page of the sessions, newest first. The cursor is the offset of the
-     * page. The SDK then orders the transcripts by their modification time and
-     * reads the start and the end only of the transcripts of the page.
-     */
-    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
-    /** A stored session title as this client shows it (see
-     *  {@link sessionIndex.SessionIndexConnection.clientTitle}). */
-    clientTitle(title: string): string;
-    /** `_session/list/subscribe`, `_session/list/unsubscribe`, `_session/rename`,
-     *  `_session/archive`, `_session/unarchive`. */
-    subscribeSessionList(params: ListSubscribeRequest): Promise<import("./session-index/list-subscriptions.js").ListSubscribeResponse>;
-    unsubscribeSessionList(params: ListUnsubscribeRequest): Promise<{
-        [x: string]: never;
-    }>;
-    renameSessionTitle(params: RenameSessionRequest): Promise<{
-        [x: string]: never;
-    }>;
-    archiveSession(params: SessionIdRequest): Promise<{
-        [x: string]: never;
-    }>;
-    unarchiveSession(params: SessionIdRequest): Promise<{
-        [x: string]: never;
-    }>;
-    /**
-     * `authenticate` — the legacy gateway methods store a provider override that
-     * every later session reads. Validate the payload here, with the same base
-     * URL rule as `providers/set`. An unchecked payload either throws a
-     * `TypeError` deep in session creation, or installs an empty base URL that
-     * silently turns the `--hide-claude-auth` subscription guard off.
-     *
-     * A call that carries no gateway payload at all keeps its historical
-     * meaning: it installs no override and succeeds. That has always been a
-     * no-op here, and a client that probes the method this way must keep
-     * working. Only a payload that IS present has to be usable.
-     */
-    authenticate(_params: AuthenticateRequest): Promise<void>;
-    /**
-     * Stores `next` and pushes it to the client.
-     *
-     * A push goes out only when the payload changed. The identity is read on many
-     * occasions — each session create, each guarded turn, the start of each user
-     * prompt — and almost all of them see the same login. Clients replace their
-     * whole state on each update and tolerate duplicates, so a repeat is
-     * harmless, but it is also pure noise; {@link sameAuthStatus} drops it.
-     *
-     * What the agent owes is truth — a stale or uninformative source must not
-     * reach here at all (see the epoch check in the probe and the guards at
-     * session create).
-     */
-    setAuthStatus(next: AuthStatus | undefined): void;
-    /**
-     * Report the identity behind a session's `AccountInfo`.
-     *
-     * `AccountInfo` is richer than the CLI probe (it is what the live query
-     * actually authenticates with). Called before the `--hide-claude-auth` guard
-     * may refuse the session or the turn: that flag blocks the *use* of a
-     * subscription, it does not make the state secret, and a refusal is when the
-     * client most needs to know the account it was refused for.
-     *
-     * Two cases skip it:
-     *
-     * - ACP gateway *authentication* (`gatewayAuthRequest`): the gateway, not
-     *   this account, is the agent-owned identity — already reported as
-     *   `kind: "gateway"` by `authenticate`.
-     * - A client-driven provider override (`providers/set`): the session then
-     *   routes through the client's endpoint and `AccountInfo` describes that
-     *   route (e.g. `apiProvider: "gateway"`), which is NOT agent-owned state.
-     *   `authStatus` reports the agent's own login only, so the CLI probe —
-     *   which reads the credential store the override never touches — stays
-     *   authoritative.
-     *
-     * An account with no identity signal (e.g. `{apiProvider: "firstParty"}`
-     * under an apiKeyHelper) means "nothing to add", not "logged out" — keep
-     * what the CLI probe already established instead of overwriting it.
-     */
-    private useAuthStatusSettings;
-    private publishSessionAccountIdentity;
-    /** Shares one in-flight `claude auth status --json` run between callers. The
-     *  promise is released once settled so a later call re-probes instead of
-     *  replaying a stale verdict. `fresh` forces a new run even when one is in
-     *  flight — `logout` needs a read that started after the credentials were
-     *  cleared. */
-    private probeCliAuthStatus;
-    /** Never rejects: an unavailable CLI means "not reported", not an error. */
-    private runCliAuthProbe;
-    /**
-     * Feed the completed probe to the `--hide-claude-auth` guard.
-     *
-     * The account cached at `initialize` is the guard's fact, and the CLI can
-     * swap the credential behind it between two turns (a Console key removed and
-     * a claude.ai login put in its place) without any turn failing. A read that
-     * reports a different kind of identity than the session was created on
-     * proves that fact stale.
-     *
-     * The probe decides nothing, and it interrupts nothing. Since the read is
-     * fired at the start of every user prompt, it usually lands in the middle of
-     * the turn it belongs to; all it may do there is set a flag. The turn runs to
-     * its end on the query it started on, the NEXT prompt consumes the flag and
-     * recreates the query, the new `initialize` reports the real account, and the
-     * creation guard judges it. So a probe can never refuse or abort a turn, and
-     * a wrong read costs one query recreation, not a false refusal.
-     */
-    private markSessionsWhoseAccountKindChanged;
-    unstable_listProviders(_params: ListProvidersRequest): Promise<ListProvidersResponse>;
-    /**
-     * `providers/set` — replace the full configuration for the `main` provider.
-     * Rejects unknown IDs, unsupported protocols, and empty/invalid base URLs with
-     * `invalid_params`. Config is process-scoped and applies to sessions created or
-     * loaded after this call.
-     */
-    unstable_setProvider(params: SetProviderRequest): Promise<SetProviderResponse>;
-    /**
-     * `providers/disable` ends ACP ownership of the single mutually exclusive
-     * backend slot and restores the agent's native routing state.
-     */
-    unstable_disableProvider(params: DisableProviderRequest): Promise<DisableProviderResponse>;
-    /**
-     * The model ids the gateway in `config` lists, read before `providers/set`
-     * returns so the sessions it recreates already offer only those, and for
-     * `bedrock` the region prefix picked from them. Setting the same gateway
-     * again reuses the previous listing. `vertex` gateways are not listed.
-     * Throws a {@link GatewayListingError} when the listing fails.
-     */
-    private listProviderModels;
-    resolveProviderConfig(): ProviderConfig | null;
-    private defaultProviderConfig;
-    logout(_params: LogoutRequest): Promise<void>;
-    /** The structured replacement for a prompt that is exactly `/usage` or a
-     *  `/mcp` command. Claude Code runs the command, and the replacement takes
-     *  the place of its text. Claude Code refuses a `/mcp` reconnect, enable,
-     *  or disable in SDK mode. The `/mcp` producer runs them through the SDK
-     *  control API when the text arrives, so the action stays in the turn. */
-    private localCommandMarkdown;
-    /**
-     * Serves an ACP v1 `session/prompt`, which answers when the turn ends. The
-     * outcome of a turn is field for field a v1 prompt response.
-     */
-    prompt(params: PromptRequest): Promise<PromptResponse>;
-    /**
-     * Starts a turn for a prompt. Resolves once the prompt is queued for Claude
-     * Code, and rejects only when the prompt is refused before that. From then
-     * on, `events` reports how the turn goes (see {@link TurnEvents}), possibly
-     * before this resolves.
-     */
-    startTurn(params: PromptRequest, events: TurnEvents): Promise<void>;
-    /** Connects Remote Control (again, if it is already on) or disconnects it. */
-    private runRemoteControlCommand;
-    /** `--hide-claude-auth` applies only to the CLI's own login. A provider
-     *  override (`providers/set` or gateway `authenticate`) routes traffic away
-     *  from it, so the subscription guard is off while one is active. */
-    private claudeSubscriptionGuardActive;
-    /** Record that the account cached at `initialize` is wrong, and — unless the
-     *  caller defers it — end the query.
-     *
-     *  Only under `--hide-claude-auth`. That cached account is this
-     *  integration's source of truth, and two things prove it wrong: a sign-out
-     *  during the session, and a CLI probe that finds a different identity. In
-     *  both cases the credential behind the cached account is gone, and whatever
-     *  replaces it is invisible until a new `initialize` runs. The flag makes
-     *  the next prompt recreate the query, so the creation guard decides on the
-     *  real account.
-     *
-     *  `endQuery` says whether the query dies now. A sign-out has already killed
-     *  the turn, so its stream is closed at once. A probe has killed nothing: it
-     *  runs beside a turn that is still producing output, and closing there would
-     *  abort a turn the user is watching. It therefore leaves the stream alone
-     *  and lets the recreation at the next prompt close it (`recreateSignedOutQuery`
-     *  closes it too, and both are idempotent).
-     *
-     *  Idempotent: one sign-out reaches this twice (the synthetic login message
-     *  and the turn's error-shaped result), and the second call must not close
-     *  a stream the first one already closed. Closing settles the queued turns
-     *  through the consumer's end-of-stream path, which rejects each one. */
-    private markSessionForSignOutRespawn;
-    /** Recreate the query of a signed-out session, keeping the ACP session id and
-     *  resuming the Claude session so the history survives. Returns the session
-     *  the caller must go on with: the new one, or the argument when no
-     *  recreation is due.
-     *
-     *  When the CLI never persisted that conversation — the first turn was the
-     *  one that signed out — the resume cannot succeed, so a fresh query starts
-     *  under the same id. The session then keeps working, with an empty history.
-     *
-     *  The recreation runs the full creation guard, so a subscription account is
-     *  refused with the subscription reason, a still-signed-out account with the
-     *  plain sign-out error, and an accepted credential proceeds. A refusal keeps
-     *  the old husk in the session map, so the client can sign in and retry on
-     *  the same session instead of meeting "Session not found".
-     *
-     *  Returns `undefined`, not a resolved promise, when no recreation is due:
-     *  the callers enqueue their turn in one synchronous section, and an extra
-     *  microtask there would let the caller observe a half-built turn.
-     *
-     *  A live turn also postpones it. A probe marks the session without ending
-     *  the query, so a turn can still be running when the mark is read — by a
-     *  `steer` injecting into it, say. Recreating there would close the stream
-     *  under the turn and kill output the user is watching, so the flag waits for
-     *  the next turn boundary. A sign-out is not affected: it closed the stream
-     *  when it marked the session, and a closed stream recreates immediately. */
-    private respawnSignedOutSession;
-    private awaitSignOutRespawn;
-    private recreateSignedOutQuery;
-    /**
-     * Starts a new query for the session `sessionId`, which ran on this
-     * connection and whose query is gone: it resumes the stored conversation.
-     * `resume` names the Claude session, which shares the ACP session id, so the
-     * new query continues the same conversation under the same id. Claude Code
-     * writes the conversation at the first prompt, so resuming a session that was
-     * never prompted fails with `resourceNotFound`, and keeps failing. Such a
-     * session starts a fresh query under the same id instead: it has no history
-     * to lose, and the client keeps a session it can use.
-     */
-    private recreateLiveSession;
-    /** Run the `--hide-claude-auth` guard before a turn starts. The returned
-     *  promise rejects with the `authRequired` error when a claude.ai
-     *  subscription would pay, or when the account holds no credential this
-     *  integration accepts. Every entry point that starts a turn must await it,
-     *  so the refusal reaches the client instead of a detached promise.
-     *
-     *  Returns `undefined`, not a resolved promise, while the guard is off: the
-     *  callers run in the same synchronous section as the turn they enqueue, and
-     *  an extra microtask there would let the caller observe a half-built turn. */
-    private runClaudeSubscriptionGuard;
-    goal(params: GoalRequest): Promise<GoalControlResponse>;
-    private publishGoal;
-    /**
-     * Publishes the follow-up prompt the CLI predicted for the next turn, or
-     * `null` to clear the one the client holds. Only AIR renders it, so only AIR
-     * gets the key; see `docs/air-extensions.md`.
-     */
-    private publishPromptSuggestion;
-    private publishTaskPlan;
-    private publishGoalFromPrompt;
-    private publishRuntimeGoal;
-    /** Steer the session per the ACP steering wire protocol: inject a follow-up
-     *  message into the turn that is currently running. If that turn already
-     *  settled, the established default starts a new detached turn; Hosts may opt
-     *  into the host-owned `promptRequired` fallback through request `_meta`.
-     *
-     *  When a turn is in flight this injects (returns `injected`): unlike
-     *  `prompt()`, it does NOT create a Turn or enqueue on `turnQueue`; it pushes
-     *  an `SDKUserMessage` onto the same streaming input, which the SDK routes
-     *  into the in-flight turn. The injected message's echo carries a uuid that
-     *  matches no queued turn, so the consumer drops it as an unrelated replay
-     *  without promoting/settling anything. It is normally delivered at priority
-     *  `now` so it pre-empts the current generation (interrupting a single-shot
-     *  response, or slotting in between a multi-step turn's tool calls). While a
-     *  permission or elicitation is awaiting user input it uses `later`, because
-     *  interrupting that SDK callback cancels the ACP request and can strand the
-     *  prompt (IJAI-1191). The steered message's own output streams via
-     *  `session/update`, not this response.
-     *
-     *  Pre-empting generation means ABORTING: the interrupted cycle emits a
-     *  `result` of its own and the steered message runs as a second one. A steer
-     *  during a foreground tool call moves that tool (Bash, Agent, MCP) to the
-     *  background instead, and may join the running cycle (CLI 2.1.286). Either
-     *  way the turn is marked (`Turn.steeredEchoes`) to settle only once a result
-     *  answers the steer.
-     *
-     *  When the session is idle, the opt-in path returns `promptRequired` WITHOUT
-     *  calling `prompt()`, pushing SDK input, or mutating `turnQueue`: the content
-     *  stays Host-owned so the Host can submit it through a standard
-     *  `session/prompt`. Without the opt-in, the existing detached `prompt()` and
-     *  `startedNewTurn` result are preserved for compatibility. */
-    steer(params: SteerRequest): Promise<SteerResponse>;
-    stopAsyncTask(params: AsyncTaskStopRequest): Promise<AsyncTaskStopResponse>;
-    /** Lazily start the per-session consumer that drains the SDK query stream for
-     *  the session's whole life. Idempotent: only the first `prompt()` starts it. */
-    private ensureConsumer;
-    /** The single, long-lived consumer of the SDK query stream for a session. It
-     *  forwards every message as ACP `sessionUpdate`s (so background/between-turn
-     *  output streams live, not just while a prompt is awaiting) and settles each
-     *  Turn's deferred when that turn ends. Replaces the per-prompt message loop;
-     *  `params` only carries the (session-invariant) `sessionId`. */
-    private runConsumer;
-    /** Route one orphaned command into the session's orphan-accounting lane:
-     *  the per-uuid map on msg_lifecycle_v1 CLIs (drained by the command's own
-     *  terminal lifecycle frame and the echo-less-result skip), the plain count
-     *  elsewhere (the count lane can't express per-command states, so `state`
-     *  only matters on the map lane). Both orphan-producing paths — cancel()'s
-     *  queued-turn sweep and the consumer's force-cancel wedge path — must seed
-     *  through here so the lane split stays a single mechanism.
-     *
-     *  Known window: `msgLifecycleV1` is only learnable from the stream's first
-     *  `system`/init (the control-channel initialize carries no capabilities),
-     *  so a cancel that beats that drain seeds the COUNT lane on a
-     *  lifecycle-capable CLI — where command coalescing can leave the count
-     *  stale by N-1 (the pre-map bug, confined to this sub-second window and
-     *  still healed by the next activation's reset). Structural until the SDK
-     *  exposes capabilities before the stream starts. */
-    private trackOrphanCommand;
-    /** Ask Claude Code to drop user messages it still has queued, so that a
-     *  prompt a cancel settled is not run after all. Claude Code keeps queued
-     *  messages through an interrupt and runs them next (the receipt's
-     *  `still_queued`), unless they are cancelled first with
-     *  `cancel_async_message`: a no-op for a message it already dequeued, which
-     *  then still runs, as an orphan (see `orphanCommands`).
-     *
-     *  Not awaited: the SDK writes control requests in call order, so the drops
-     *  reach Claude Code before a request sent after them, and a wedged CLI must
-     *  not hold up the cancel. The orphan accounting needs no update here: a
-     *  dropped message gets a `cancelled` lifecycle frame and is missing from the
-     *  interrupt receipt's `still_queued`, which both already account for. The
-     *  SDK implements the request as `Query.cancelAsyncMessage` without typing
-     *  it, so it is looked up, and a CLI that lacks it rejects the request. */
-    private dropQueuedMessages;
-    cancel(params: CancelNotification): Promise<void>;
-    /**
-     * Cancels the current work of the subagent child session `sessionId`, which
-     * its `cancel` capability permits on the subagents RFD form, without
-     * cancelling its parent (see `NativeSubagentRuntime.cancelChild`). Returns
-     * false when no session has such a child.
-     */
-    private cancelChildSession;
-    /**
-     * Stops each background workflow of the session that still runs, after the
-     * interrupt of a `session/cancel` spared it (see
-     * `Session.stopsWorkflowsOnCancel`). Claude Code reports each one
-     * `stopped`, along with the commands inside it, and starts no model cycle
-     * for it, as when the interrupt killed it. Every background workflow is
-     * stopped, whoever launched it, because the interrupt killed them all.
-     */
-    private stopBackgroundWorkflows;
-    /** Cancel the session's turns and interrupt the SDK query. With
-     *  `awaitInterrupt: false` the interrupt is sent, but its reply is not
-     *  awaited. `teardownSession` uses that: it closes the query right after, and
-     *  the reply can queue behind a slow control request, such as the background
-     *  `getContextUsage` of a fresh session. */
-    private cancelTurns;
-    /** Release a query that was spawned but never registered as a session. */
-    private discardUnregisteredQuery;
-    /** Mark a session's SDK query stream as permanently ended and release the
-     *  resources tied to it: drop the consumer handle, dispose the settings
-     *  watchers, end the input stream, and close the query (which terminates the
-     *  subprocess). The query iterator is not revivable, so `prompt()`/`cancel()`
-     *  consult `queryClosed` and fail/short-circuit instead of acting on a dead
-     *  stream. Idempotent (guarded by `queryClosed`), so the consumer's done/error
-     *  paths and a later `teardownSession` can all call it without double-releasing.
-     *
-     *  Deliberately does NOT abort `session.abortController`: that controller may be
-     *  CLIENT-supplied (`_meta.claudeCode.options.abortController`) and reused, so
-     *  aborting it on a spontaneous stream end would cancel the client's own work
-     *  or make a sibling session born aborted. `query.close()` already terminates
-     *  the subprocess; aborting the signal belongs in `teardownSession` (explicit
-     *  destroy), not here. Also does NOT remove the session from the map — that is
-     *  `teardownSession`'s job — so prompt() can still answer with a clear "session
-     *  ended" error after an unexpected stream close. The leftover session object
-     *  is a lightweight husk (its heavy resources are released here) and is evicted
-     *  on the next closeSession/deleteSession or when the connection's `dispose()`
-     *  runs. */
-    private closeQueryStream;
-    /** Cleanly tear down a session: cancel in-flight work, release stream
-     *  resources, and remove it from the session map. Returns once the turns it
-     *  cancels have ended, so their end (a v1 `session/prompt` response, a v2
-     *  `idle` state) goes out before the caller answers: ACP v2's
-     *  `session/close` cancels "as if `session/cancel` had been called", then
-     *  frees the session. A wedged consumer holds it at most
-     *  {@link TEARDOWN_TURN_END_TIMEOUT_MS}. */
-    private teardownSession;
-    /** Tear down all active sessions. Called when the ACP connection closes. */
-    dispose(): Promise<void>;
-    /** Idempotent: a session that is not loaded here is already closed. */
-    closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse>;
-    /** Per client: see {@link sessionIndex.SessionIndexConnection.deleteSession}. */
-    deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse>;
-    setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
-    setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
-    private replaySessionHistory;
-    readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse>;
-    writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse>;
-    /** Runs `request`, a request that `requestSessionId` sends for the session
-     *  `ownerSessionId`. When that is a subagent's child session, the child
-     *  reports that it awaits the user while the request is open (the RFD form,
-     *  see `NativeSubagentRuntime.awaitingUser`). `signal` aborts when Claude
-     *  Code withdraws the request. */
-    private withChildAwaitingUser;
-    /** Mark a client request of the subagent `agentID` (absent for the main
-     *  conversation) as awaiting user input for exactly the lifetime of its
-     *  promise (see `Session.openUserInputs`). Steering consults the open
-     *  requests synchronously, so a message arriving while any permission or
-     *  elicitation card is open uses non-interrupting SDK delivery.
-     *
-     *  `signal` aborts when Claude Code withdraws the request, which is not an
-     *  answer. Example: the user cancels while a permission request is open.
-     *  Claude Code's interrupt withdraws it as it stops the work, and the work
-     *  ends `idle cancelled` right after. The end of the request then reports
-     *  no `running`: the client would see `requires_action`, `running`, `idle
-     *  cancelled`. A withdrawal without a cancel means that something else
-     *  answered the request in the user's place, such as a `PermissionRequest`
-     *  hook, and the work goes on, so the end reports `running`. */
-    private withPendingUserInput;
-    /** Report whether the session's foreground work awaits the user: exactly
-     *  while a permission request or question that blocks it is open (see
-     *  {@link blocksForeground}). A request does not say which prompt it is for,
-     *  and Claude Code can ask for a queued prompt before the consumer activates
-     *  it, so a request is not tied to the work that was running when it
-     *  opened. Called when a request opens or closes, when a turn activates, and
-     *  when a task registers or moves to the background.
-     *
-     *  When the last request ends, the work reports `running` again, unless a
-     *  cancel withdrew that request (`withdrawnByCancel`, see
-     *  {@link withPendingUserInput}): the work is being stopped, and reports its
-     *  end next. */
-    private syncAwaitingUser;
-    /** The foreground state of the session `sessionId` now, as v2's
-     *  `state_update` names it: `idle` while no work runs, `requires_action`
-     *  while the work awaits the user (see {@link syncAwaitingUser}), and
-     *  `running` otherwise. */
-    foregroundState(sessionId: string): "idle" | "running" | "requires_action";
-    /** Make `owner` the foreground work of the session `sessionId` (see
-     *  {@link ForegroundEvents}): it reports `running`, then waits at once if a
-     *  request is open. If work already runs, it goes on under `owner` and
-     *  reports nothing new: a turn takes over a cycle that Claude Code started on
-     *  its own, and only the owner's end ends the work. */
-    private startForeground;
-    /** End the foreground work of the session `sessionId` with `outcome`, or as
-     *  failed with `error`, if `owner` is that work. */
-    private endForeground;
-    /** Start a model cycle that Claude Code started on its own as the foreground
-     *  work (see {@link ForegroundEvents}) when `message` is its first output:
-     *  model output of the main conversation (not a subagent's) while no work
-     *  runs. That includes a turn that v1 holds for its background subagents,
-     *  whose work ended at its result, so its follow-up is a cycle. Output of
-     *  the work a cancel stopped starts nothing (see Session.cancelled). */
-    private startAutonomousCycle;
-    /** Whether the client has been told that the session's work ended: on v2 by
-     *  an idle state, so no foreground work is open, including a cycle that
-     *  Claude Code started on its own; on v1 by the response to the turn's
-     *  prompt, so no turn is active. v1 reports nothing for a cycle, so its end
-     *  is its result or idle: until then, Claude Code's results for the cycle's
-     *  tool calls still reach the client after a cancel. */
-    private workEndReported;
-    /** Whether the consumer drops what it reaches now as output of the work a
-     *  cancel stopped: the client has been told that the work ended, and the
-     *  window after the cancel is still open (see Session.cancelled). */
-    private dropsStoppedWorkOutput;
-    /**
-     * Whether the tool use `toolUseId`, which reaches `canUseTool` or a hook, is
-     * output of the work a cancel stopped that the consumer dropped (see
-     * `dropsStoppedWorkOutput`). Example: Claude Code runs a prompt that the
-     * cancel abandoned, and it asks to run a command. The consumer drops the
-     * tool use and its result, so a tool call shown for it would never end, and
-     * the client would keep it open (issue #1061).
-     *
-     * Claude Code calls `canUseTool` and hooks on its control channel, after it
-     * streamed the tool use, and the consumer can lag behind. So the session can
-     * still look cancelled while the consumer has the next prompt's echo, which
-     * ends the window, still ahead of the tool use. While a cancel's window may
-     * be open, this waits until the consumer reaches the tool use, for at most
-     * {@link toolUseWaitMs} or until `signal` aborts: the stream never shows
-     * some tool uses, such as SandboxNetworkAccess's. Without a cancel nothing
-     * is dropped, so it answers at once. It returns a promise only when it
-     * waits, so a permission request without a cancel goes out as soon as
-     * before.
-     */
-    private isStoppedWorkToolUse;
-    /** Waits until the consumer reaches the tool use `toolUseId` (see
-     *  `isStoppedWorkToolUse`), then says whether it dropped it. */
-    private reachedInStream;
-    /** End the session's model cycle that Claude Code started on its own, if one
-     *  runs. */
-    private endAutonomousCycle;
-    /** Whether a model cycle that Claude Code started on its own is the session's
-     *  foreground work. A turn that took a cycle over owns the work from then on. */
-    private runsAutonomousCycle;
-    /** The ACP turn that owns a root request of the session now, if any. A
-     *  model cycle that Claude Code started on its own owns no turn. A turn that
-     *  took a cycle over owns it. A queued turn owns the request too, because
-     *  Claude Code can ask for a queued prompt before the consumer reaches its
-     *  echo (see `recordForegroundToolCall`). The ExitPlanMode request and the
-     *  result of its interruption use this one rule, so an offered
-     *  clear-context option always has a turn to continue. */
-    private requestOwnerTurn;
-    /** Forward a permission request to the client, wiring the tool call's
-     *  `signal` through as a `cancellationSignal`. When the turn is cancelled
-     *  while the client's prompt is still open the signal aborts, the SDK sends
-     *  `$/cancel_request`, and our local abort race settles even if the client
-     *  ignores it. A `cancelled` outcome, request rejection, and local abort all
-     *  surface the same "Tool use aborted" the callers already expect. */
-    private requestPermissionFromClient;
-    /** Send the client an elicitation for a callback of Claude Code. When the
-     *  callback's `signal` aborts, the SDK sends `$/cancel_request` and keeps
-     *  waiting for the client's reply, which a client that ignores the cancel
-     *  never sends. So the call also rejects at once on the abort, as
-     *  {@link requestPermissionFromClient} does for a permission request. Left
-     *  open, the request would stay in `openUserInputs` (see
-     *  {@link withPendingUserInput}), which keeps steering non-interrupting, and
-     *  a child's `openRequests` would not drop. */
-    private elicitFromClient;
-    /** Emit the `tool_call` a permission request references if it hasn't been sent
-     *  yet, so the client has the tool call before being asked to approve it. The
-     *  matching streamed tool_use chunk later refines it with a `tool_call_update`
-     *  instead of emitting a duplicate (see `emittedToolCalls`). Built via the same
-     *  `toolCallNotification` helper as the streamed path so the two are identical.
-     *  Tools the stream renders as a plan (TodoWrite) or suppresses (Task*) are
-     *  emitted too: a permission request referencing a tool call the client has
-     *  never seen can trip strict clients (issue #851), so the reference must
-     *  always resolve. Since the streamed path never completes those calls, they
-     *  are resolved at tool_result time instead (see `toAcpNotifications`).
-     *  `parentToolUseId` attributes a subagent's tool call to the Agent/Task call
-     *  that spawned it, matching the streamed path's `_meta`. */
-    private ensureToolCallEmitted;
-    /**
-     * The owner of a tool use that Claude Code reports outside the stream, in
-     * `canUseTool` or a hook, for the subagent `agentID` or the root session.
-     * `parentToolUseId` is the Agent/Task tool call that spawned the subagent,
-     * as the streamed subagent path stamps it in `_meta.claudeCode` (see
-     * `liveBackgroundTasks`). `toolCallSessionId` is the session of an eagerly
-     * emitted tool call and of its requests: the subagent's child session once
-     * it is announced, else the root session. In the rare SDK ordering where
-     * the callback beats the spawning Agent/Task frame, the root keeps it; the
-     * later frame announces the child with its correct nested lineage.
-     */
-    private toolUseOwner;
-    /**
-     * The models of the session `sessionId`, for the `model` option of its
-     * subagents: the entries of the session's own `model` option.
-     */
-    private subagentModels;
-    private subagentConfigurationHook;
-    /**
-     * The PreToolUse hook of a v2 connection, for Edit and Write: the tool call
-     * shows the exact patch of the change before the tool runs.
-     *
-     * A v2 diff cannot hold the input's snippet, so without it an auto-approved
-     * Edit or Write would show its change only once it is done. Claude Code runs
-     * the tool only after the hook returns, so the file is as it was before the
-     * change, as for the approval patch of a permission request (which runs
-     * after this hook, and shows the same patch). The hook makes no permission
-     * decision, and a failure only leaves the preview out.
-     */
-    private fileChangePreviewHook;
-    private previewFileChange;
-    canUseTool(sessionId: string): CanUseTool;
-    /**
-     * Handle elicitation requests that originate from MCP servers by forwarding
-     * them to the client over ACP. Modes the client did not advertise (or
-     * requests we can't represent) are declined.
-     */
-    private handleMcpElicitation;
-    /**
-     * Present the built-in AskUserQuestion tool's questions as an ACP form
-     * elicitation and return the answers as the tool's `updatedInput`. Called from
-     * `canUseTool` since that is where the SDK routes the tool's permission check.
-     * The elicitation goes to `requestSessionId`, a subagent's child session for
-     * a question it asks, and blocks the turn of `sessionId`.
-     */
-    private handleAskUserQuestion;
-    /**
-     * Handle `request_user_dialog` control requests — blocking dialogs the CLI
-     * asks the host to render. Only kinds declared in `supportedDialogKinds`
-     * are ever emitted; everything unexpected is answered `cancelled` (the
-     * required answer for unrecognized kinds), which applies the dialog's
-     * default behavior CLI-side. Today the only declared kind is the
-     * refusal-fallback consent prompt, rendered as an ACP form elicitation.
-     */
-    private handleUserDialog;
-    /**
-     * The slash commands of the session `sessionId`, as `available_commands_update`
-     * lists them. The SDK reads them from Claude Code's initialization, which
-     * session setup already awaited. Empty when the session does not exist.
-     */
-    availableCommands(sessionId: string): Promise<AvailableCommand[]>;
-    private sendAvailableCommandsUpdate;
-    /**
-     * The work that follows a session setup response: the session's commands,
-     * the current states of the subagents a load replayed, and MCP server
-     * authentication. A v2 client gets the commands in the setup response itself,
-     * and the subagent states from the v2 surface once it has sent its own
-     * response (`src/v2/agent.ts`), so it gets neither here.
-     */
-    private afterSetupResponse;
-    /**
-     * Sends the current state of each subagent that the last load of
-     * `sessionId` replayed (see {@link RfdSubagentReplay.currentStates}). Run it
-     * only after the load response: before it, the client treats subagent states
-     * as history.
-     */
-    publishCurrentSubagentStates(sessionId: string): Promise<void>;
-    /**
-     * AIR's draft: a load replays while the CLI starts, so the replay can lack
-     * the session's model list and send a child's model as its id. After the
-     * load response the list is known, and each replayed child whose model the
-     * list maps to another entry gets that entry. The replay already ended the
-     * child, and AIR's draft allows no other update after a child's end, but it
-     * takes this more exact snapshot of the same configuration.
-     */
-    private publishReplayedChildModels;
-    private updateConfigOption;
-    /**
-     * Refine a heuristic context window with `getContextUsage().rawMaxTokens`,
-     * without blocking the caller. The text heuristic misses natively-1M models
-     * whose picker rows carry no "1m" token (e.g. `sonnet`, and since CLI
-     * 2.1.283 `opus`/`default`), so those would otherwise show 200k until the
-     * first result's modelUsage arrives.
-     *
-     * Never awaited: SDK control requests are serialized, so awaiting here
-     * would delay session/new or a model switch (~15s on older CLIs, issues
-     * #886/#880; ~0.5s on 2.1.283). Requests the `summary` detail instead of
-     * the default `full` breakdown, which issues one `messages/count_tokens`
-     * call per category (~18 for a bare session) and hit rate limits on every
-     * model switch; `summary` answers locally with the same `rawMaxTokens`.
-     *
-     * Does not write `contextWindowCache` (that stays keyed to the
-     * `result.modelUsage` spellings) — a later result still overwrites this.
-     */
-    private refreshContextWindowInBackground;
-    private applyConfigOptionValue;
-    /** Reconcile adapter model state after the SDK switched the session's
-     *  model out from under us — a refusal fallback, or any switch reported by
-     *  the PostModelSwitch hook that the adapter didn't drive (e.g. a `/model`
-     *  command typed as a prompt). The SDK already made the switch, so this
-     *  must NOT call `query.setModel` — it only updates our bookkeeping
-     *  (currentModelId, context window, mode clamping, effort/Fast-mode
-     *  options) via the same `applyConfigOptionValue` path a user-driven model
-     *  change takes, then notifies the client. */
-    private syncModelAfterExternalSwitch;
-    /** Replace the Fast mode option in `session.configOptions` so it reflects
-     *  `enabled` (and the client's current boolean-capability). A no-op when the
-     *  option isn't present, so callers must confirm the current model surfaces
-     *  it first. */
-    private refreshFastModeOption;
-    /** Toggle Fast mode for a session: push the SDK flag, record the user's
-     *  intent, and refresh the Fast mode config option in place. Only reached
-     *  once the option exists (i.e. the current model supports fast mode), so the
-     *  option is guaranteed to be present in `configOptions`. */
-    private applyFastMode;
-    /** Turn ultracode on or off for a session. Sends an explicit boolean, which
-     *  leaves the effort level alone (`null` would reset the flag layer instead).
-     *  The SDK flag is applied first so a rejected request leaves the session
-     *  state and option untouched. */
-    private applyUltracode;
-    /** Reconcile the session's Fast mode toggle with an SDK-reported
-     *  `fast_mode_state` (delivered on `system`/init and on user-turn `result`s).
-     *  The SDK can flip fast mode independently of the user — e.g. back to `on`
-     *  once a rate-limit `cooldown` clears — so we mirror definitive on/off
-     *  changes into the config option and notify the client.
-     *
-     *  Guards, in order:
-     *   - absent state: nothing to reconcile.
-     *   - no Fast mode option: the current model doesn't support fast mode, so the
-     *     reported state reflects capability, not the user's intent. Leave the
-     *     retained setting untouched so it's correct when a supporting model is
-     *     reselected (the source of the earlier intent-clobber bug was mutating it
-     *     here).
-     *   - `cooldown`: a transient suspension of an already-enabled fast mode.
-     *     Leave the toggle as-is rather than flapping it — and never let a stray
-     *     cooldown spuriously enable a toggle the user has off.
-     *
-     *  `reason` is the SDK's `fast_mode_disabled_reason`, reported alongside the
-     *  state. Only explainable reasons are retained (see
-     *  {@link normalizeFastModeDisabledReason}), so the comparison below tracks
-     *  exactly what the user can see: a routine `sdk_opt_in_required` report on
-     *  every turn's result can't churn the option, while a real blocker updates
-     *  the description even when the toggle's own value is unchanged. */
-    private syncFastModeState;
-    private getOrCreateSession;
-    /**
-     * Ensures the requested `cwd` is an absolute path that points at an existing
-     * directory before we create a session. Throws an `invalidParams` error with
-     * an actionable message so clients (e.g. Zed) can surface it to the user
-     * instead of failing later with an opaque SDK error.
-     */
-    private validateCwd;
-    /** Whether the session forwards the text and the thinking of a subagent. */
-    private forwardsSubagentText;
-    private createSession;
-    /**
-     * Provider routing is baked into the environment of each SDK Query. Wait for
-     * all submitted turns to settle, close every query, then resume each Claude
-     * session with the same ID so subsequent turns inherit the new environment.
-     */
-    private enqueueProviderUpdate;
-    /** Tell a capable client when a non-auth error ends a session during a provider switch. */
-    private reportSessionLostOnProviderUpdate;
-}
-export declare const BUILTIN_AGENT_NAMES: Set<string>;
-/** Discover user/plugin/project-configured main-thread agents, excluding the
- *  built-in subagents and the reserved "default" sentinel. Returns an empty
- *  list if discovery fails so a flaky control request never blocks session
- *  creation. */
-export declare function discoverCustomAgents(q: Query): Promise<AgentInfo[]>;
-/** Stable ids for the session config options surfaced via `configOptions`.
- *  Centralized so the option declarations in `buildConfigOptions` and the
- *  handlers in `setSessionConfigOption`/`applyConfigOptionValue` reference the
- *  same identifiers and can't drift apart. */
-export { MODE_CONFIG_ID };
-export declare const AGENT_CONFIG_ID = "agent";
-export declare const FAST_MODE_CONFIG_ID = "fast";
-/** Select-fallback values used when the client has not opted into boolean
- *  config options (see {@link createFastModeConfigOption}). */
-export declare const FAST_MODE_ON = "on";
-export declare const FAST_MODE_OFF = "off";
-/** Map the SDK's tri-state `fast_mode_state` onto the boolean config toggle.
- *  `cooldown` (fast mode temporarily suspended after a rate limit, per the SDK
- *  docs) keeps the toggle on so it reflects the user's intent — only an
- *  explicit `off` clears it. */
-export declare function fastModeStateEnabled(state: FastModeState): boolean;
-/** Normalize an SDK-reported `fast_mode_disabled_reason` to the one we retain:
- *  a reason we have an explanation for, else `undefined`. Keeping only
- *  explainable reasons means state comparisons (see `syncFastModeState`) track
- *  exactly what the user can see, so routine reports like
- *  `sdk_opt_in_required` never churn the config option. */
-export declare function normalizeFastModeDisabledReason(reason: FastModeDisabledReason | undefined): FastModeDisabledReason | undefined;
-/** Whether the Client advertised support for boolean session config options
- *  (`session.configOptions.boolean`). Agents MUST only send `type: "boolean"`
- *  config options to Clients that opt in; otherwise we fall back to a `select`.
- *  See https://agentclientprotocol.com/rfds/boolean-config-option. */
-export declare function clientSupportsBooleanConfigOptions(clientCapabilities?: ClientCapabilities | null): boolean;
-/** Whether the Client advertised the AIR `recommendedValue` capability for
- *  select-style model and effort options. Missing or malformed AIR metadata
- *  retains the legacy `default` entries. */
-export declare function clientSupportsRecommendedConfigValue(clientCapabilities?: ClientCapabilities | null): boolean;
-/** Build the Fast mode config option. When the Client supports boolean config
- *  options we expose a native `type: "boolean"` toggle; otherwise we degrade to
- *  a two-value `select` ("on"/"off") so older Clients still get a usable
- *  control.
- *
- *  `disabledReason` (the SDK's `fast_mode_disabled_reason`) is folded into the
- *  description while the toggle reads off, so a user whose account or provider
- *  can't serve Fast mode sees why instead of a switch that silently refuses to
- *  stay on. Ignored while enabled: a reason reported alongside an `on`/`cooldown`
- *  state isn't blocking anything right now. */
-export declare function createFastModeConfigOption(enabled: boolean, useBooleanOption: boolean, disabledReason?: FastModeDisabledReason): SessionConfigOption;
-/** Resolve the requested Fast mode value from a `session/set_config_option`
- *  request. Accepts a native boolean (boolean-capable Clients) or the
- *  "on"/"off" select-fallback strings. */
-export declare function resolveFastModeEnabled(params: SetSessionConfigOptionRequest): boolean;
-/** Per-model Fast mode state threaded into {@link buildConfigOptions}. The
- *  option is only surfaced when the current model `supported`s fast mode. */
-export type FastModeOptionState = {
-    supported: boolean;
-    enabled: boolean;
-    /** Whether the Client opted into boolean config options. */
-    useBooleanOption: boolean;
-    /** Latest explainable `fast_mode_disabled_reason`, folded into the option's
-     *  description while the toggle reads off. */
-    disabledReason?: FastModeDisabledReason;
-};
-export type ConfigOptionPresentation = {
-    /** Replace ambiguous `default` rows with concrete values and advertise the
-     *  SDK/adapter recommendation as `_meta.jetbrains.air.recommendedValue`. */
-    useRecommendedValue: boolean;
-};
-export declare function buildConfigOptions(modes: SessionModeState, models: SessionModelState, modelInfos: ModelInfo[], currentEffortLevel?: string, agents?: AgentInfo[], currentAgent?: string, fastMode?: FastModeOptionState, presentation?: ConfigOptionPresentation, ultracode?: UltracodeOptionState): SessionConfigOption[];
-export declare function promptToClaude(prompt: PromptRequest): SDKUserMessage;
-/**
- * Resolves the ACP `messageId` for a Claude SDK message (live) or a persisted
- * transcript message (replay) so chunk grouping is identical in both views.
- *
- * Assistant turns are keyed by the Anthropic API message id (`message.id`),
- * which is identical at `message_start`, on the consolidated assistant message,
- * and in the persisted transcript — unlike the per-`stream_event` uuid, which is
- * unique per event and never persisted. User messages have no API id, but they
- * are never streamed, so their (stable) SDK uuid is used instead. ACP message
- * ids are opaque strings, so no particular format is required.
- */
-export declare function messageIdForGrouping(message: {
-    type?: string;
-    uuid?: string | null;
-    message?: unknown;
-}): string | undefined;
-export declare function toAcpNotifications(content: string | ContentBlockParam[] | BetaContentBlock[] | BetaRawContentBlockDelta[], role: "assistant" | "user", sessionId: string, toolUseCache: ToolUseCache, client: AcpClient, logger: Logger, options?: {
-    registerHooks?: boolean;
-    clientCapabilities?: ClientCapabilities;
-    toolCallCapabilities?: ToolCallClientCapabilities;
-    parentToolUseId?: string | null;
-    cwd?: string;
-    taskState?: TaskState;
-    emittedToolCalls?: Set<string>;
-    inputComplete?: boolean;
-    toolCallFields?: ToolCallFieldTracker;
-    messageId?: string;
-    toolUseResult?: unknown;
-    toolResultMeta?: unknown;
-    cancelled?: boolean;
-    replay?: boolean;
-}): SessionNotification[];
-export declare function streamEventToAcpNotifications(message: SDKPartialAssistantMessage, sessionId: string, toolUseCache: ToolUseCache, client: AcpClient, logger: Logger, options?: {
-    clientCapabilities?: ClientCapabilities;
-    toolCallCapabilities?: ToolCallClientCapabilities;
-    cwd?: string;
-    taskState?: TaskState;
-    emittedToolCalls?: Set<string>;
-    toolCallFields?: ToolCallFieldTracker;
-    messageId?: string;
-    streamedToolInputs?: StreamedToolInputCache;
-}): SessionNotification[];
-/** Run a `session/prompt` while honoring `$/cancel_request` for it. ACP clients
- *  normally stop a turn with the `session/cancel` notification, but `signal`
- *  (the prompt request's abort signal) also fires when the client sends the
- *  generic `$/cancel_request` for this prompt — the protocol's complementary
- *  cancellation fallback. Route that to the same `agent.cancel` path so a client
- *  using only the generic mechanism still stops the turn (and the prompt
- *  resolves "cancelled" instead of running to completion).
- *
- *  The listener is scoped to this call: once the prompt settles it is removed,
- *  so a later teardown-time abort of the (per-request) signal can't cancel a
- *  subsequent turn. `signal` also aborts on connection close, in which case
- *  cancelling the in-flight turn is the desired behavior anyway. */
-export declare function runPromptWithCancellation(agent: Pick<ClaudeAcpAgent, "prompt" | "cancel" | "logger">, params: PromptRequest, signal: AbortSignal): Promise<PromptResponse>;
-/**
- * The ACP v1 surface of the adapter, for one connection.
- *
- * The agent of the connection is created when the connection opens, from the
- * connection-scoped peer handle (`connection.client`), which stays valid for
- * the whole connection. Connect handlers run before the connection processes
- * any inbound message, so every handler below sees the agent. `onAgent`
- * receives it for the owner of the process (shutdown).
- */
-export declare function v1AgentApp(logger: Logger | undefined, onAgent: (agent: ClaudeAcpAgent) => void): AgentApp;
-/** Serves ACP v1 on stdio. */
-export declare function runAcp(logger?: Logger): {
-    connection: import("@agentclientprotocol/sdk/unstable").AgentConnection;
-    agent: ClaudeAcpAgent;
-};
-//# sourceMappingURL=acp-agent.d.ts.map