@robota-sdk/agent-ui-web 0.0.0-stage → 3.0.0-beta.94

package/dist/node/index.d.cts

@@ -0,0 +1,715 @@
+import { IWireAgentDefinitionSummary, TClientMessage, TClientMessage as TClientMessage$1, TServerMessage, TServerMessage as TServerMessage$1 } from "@robota-sdk/agent-transport";
+import { TActionResponse } from "@robota-sdk/agent-interface-transport";
+import { IAskRequestEvent, IDiffLine, IGoalState, IPermissionRequestEvent, ISettingsSnapshot, IToolState, TDriverId, TPermissionResultValue, TSettingsPatch } from "@robota-sdk/agent-interface-session";
+import { IBackgroundTaskState, IExecutionDetailRecord, IExecutionWorkspaceEntry, IExecutionWorkspaceSnapshot } from "@robota-sdk/agent-interface-execution";
+import { TCommandUiIntent } from "@robota-sdk/agent-interface-command";
+import React$1, { ReactNode } from "react";
+//#region src/client/ws-session-client.d.ts
+type TConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+interface IWsSessionClientCallbacks {
+  onMessage: (msg: TServerMessage$1) => void;
+  onStatusChange: (status: TConnectionStatus) => void;
+  /**
+   * The connection is gone for good: the retries ran out without reaching the server again. The status
+   * stays `disconnected`; this is what tells a host the runtime is not coming back by itself.
+   */
+  onGiveUp?: () => void;
+}
+interface IWsSessionClient {
+  connect: () => void;
+  disconnect: () => void;
+  send: (msg: TClientMessage$1) => void;
+  status: () => TConnectionStatus;
+}
+declare function createWsSessionClient(url: string, callbacks: IWsSessionClientCallbacks): IWsSessionClient;
+//#endregion
+//#region src/hooks/prompt-state.d.ts
+/** A prompt awaiting the owner's answer, rendered by the UI (built from the server event payloads). */
+type TPendingPrompt = ({
+  readonly kind: 'permission';
+} & IPermissionRequestEvent) | ({
+  readonly kind: 'ask';
+} & IAskRequestEvent);
+/**
+ * Fold a server message into the pending-prompt list: append on `permission_request`/`ask_request`, remove on
+ * `prompt_resolved`. Any other message returns the list unchanged (referential-equality preserved). Duplicate
+ * ids are not re-appended (idempotent against a resend).
+ */
+declare function applyPromptEvent(prompts: readonly TPendingPrompt[], msg: TServerMessage): readonly TPendingPrompt[];
+/** Build the client message that answers a permission prompt. */
+declare function permissionResponse(id: string, result: TPermissionResultValue): TClientMessage;
+/** Build the client message that answers an ask prompt. */
+declare function askResponse(id: string, response: TActionResponse): TClientMessage;
+//#endregion
+//#region src/hooks/session-client-types.d.ts
+type TPersonalUsageReport = Extract<TServerMessage, {
+  type: 'personal_usage_report';
+}>['report'];
+type TStoredSessionUsageReport = Extract<TServerMessage, {
+  type: 'stored_session_usage_report';
+}>['report'];
+/** The commands and skills the session offers — what a `/` menu lists. */
+type TCommandCatalog = Omit<Extract<TServerMessage, {
+  type: 'commands';
+}>, 'type'>;
+/** The session's status beside the conversation: model, permission mode, effort, context. */
+type TSessionStatus = Extract<TServerMessage, {
+  type: 'session_status';
+}>['status'];
+/**
+ * #3282 §2 (part 2): the models a person may switch to, grouped by configured provider profile —
+ * what the model control's pop-up menu is built from. `null` until requested (`list-models`).
+ */
+type TModelListSnapshot = Omit<Extract<TServerMessage, {
+  type: 'model_list';
+}>, 'type' | 'requestId'>;
+/** The host's sessions in this workspace, which one is current, and the records it could not read. */
+type TSessionListing = Extract<TServerMessage, {
+  type: 'sessions';
+}>['listing'];
+/** Why the host did not list its sessions: it cannot (`not_available`), or listing failed. */
+type TSessionsError = Omit<Extract<TServerMessage, {
+  type: 'sessions_error';
+}>, 'type' | 'requestId'>;
+type TCurrentSessionUsageReport = Extract<TServerMessage, {
+  type: 'usage_report';
+}>['report'];
+/** #3282 §4c — the Project panel's reads. Each result crosses the wire unchanged from the session
+ *  method's own return value (see `wire-messages.ts`'s doc comment on `project_status`). */
+type TProjectStatusRead = Extract<TServerMessage, {
+  type: 'project_status';
+}>['result'];
+type TProjectDiffRead = Extract<TServerMessage, {
+  type: 'project_diff';
+}>['result'];
+type TProjectMemoryRead = Extract<TServerMessage, {
+  type: 'project_memory';
+}>['result'];
+interface IConversationMessage {
+  id: string;
+  role: 'user' | 'assistant';
+  content: string;
+  isStreaming?: boolean;
+  /** REMOTE-014 E5: the co-driving author of a user turn. */
+  author?: string;
+}
+/**
+ * The outcome of a slash command, shown in the conversation where it was typed — the TUI adds the
+ * same outcome to its transcript. `info` is a command this surface cannot carry out.
+ */
+interface ICommandOutputEntry {
+  id: string;
+  role: 'command';
+  name: string;
+  content: string;
+  tone: 'success' | 'error' | 'info';
+}
+/** The tool calls of one finished turn, kept in the conversation ahead of the reply they led to. */
+interface IToolGroupEntry {
+  id: string;
+  role: 'tools';
+  tools: readonly IActiveTool[];
+}
+/** One file an Edit/Write call touched during a turn, and the (latest) diff a click can open. */
+interface IChangedFileSummary {
+  path: string;
+  added: number;
+  removed: number;
+  diffLines: readonly IDiffLine[];
+}
+/** #3288: a turn that changed files ends with this compact summary row. */
+interface IChangedFilesEntry {
+  id: string;
+  role: 'changed-files';
+  files: readonly IChangedFileSummary[];
+}
+type TConversationEntry = IConversationMessage | ICommandOutputEntry | IToolGroupEntry | IChangedFilesEntry;
+interface IActiveTool {
+  id: string;
+  name: string;
+  status: 'running' | 'done' | 'error';
+  input?: string;
+  result?: IToolState['result'];
+  /** #3288: correlates this call across `tool_start`/`tool_end` — how a finished call is matched. */
+  executionId?: string;
+  /** #3288: a unified diff (Edit/Write), built server-side — the same one an approval prompt showed. */
+  diffLines?: readonly IDiffLine[];
+  /** #3288: the file `diffLines` concerns, workspace-relative when the server could make it so. */
+  diffFile?: string;
+  /** #3288: the tool's raw result payload (Shell output, Read content, …), already capped server-side. */
+  toolResultData?: string;
+  /** Admitted observations; opaque resource URIs do not authorize a client-side fetch. */
+  toolResultParts?: IToolState['toolResultParts'];
+  /** #3288: a workspace-relative display form of a path argument, additive to `input`/`firstArg`. */
+  displayPath?: string;
+  /** #3288: set when this call is a projected `/command` tool — render "Ran /<commandName>". */
+  commandName?: string;
+  /** #3288: true for an internal signal tool (e.g. goal-status) — never rendered as a call. */
+  internal?: boolean;
+}
+/**
+ * #3280 §2: a prompt the host queued behind the running turn — the server has already taken it, so it
+ * is not lost, but it will not run until the turn ends. `count` is the TOTAL number waiting (the shown
+ * `text` plus any behind it), matching the wire's `pendingCount`.
+ */
+interface IQueuedPrompt {
+  text: string;
+  count: number;
+}
+interface ISessionNotice {
+  id: string;
+  /**
+   * `session-change-refused`: the host refused a new or switch this surface asked for.
+   * `background-task-control-failed`: a Stop in the Agents panel did not take effect.
+   * `command-failed` (#3282 §2 part 2): a change made through a status control (model/mode/effort)
+   * failed — a plain notice rather than a conversation card, since the control's own label is where
+   * a successful change confirms itself and the label stays unchanged when it fails.
+   */
+  kind: 'session-error' | 'protocol-error' | 'session-change-refused' | 'background-task-control-failed' | 'command-failed';
+  message: string;
+  /**
+   * A `session-error` classified at the wire boundary (#3289 §3) — present only when the host could
+   * tell what kind of failure this was. `SessionNotices` maps it to one plain sentence and keeps
+   * `message` behind a "Details" disclosure; absent, it shows `message` as before.
+   */
+  code?: 'auth' | 'rate_limit' | 'model_unavailable' | 'network' | 'provider';
+  provider?: string;
+  retryAfterSeconds?: number;
+  /**
+   * For `code: 'model_unavailable'`, the model the failed request tried — captured when the notice
+   * was created (from the wire frame's own `model`, or `sessionStatus` at that moment), never read
+   * live off the CURRENT session status. The person may switch models before dismissing the notice,
+   * and a live read would then blame the new model for the old failure.
+   */
+  model?: string;
+}
+interface ISessionClientHandle {
+  connect: () => void;
+  disconnect: () => void;
+  send: (msg: TClientMessage$1) => void;
+}
+type TMakeSessionClient<TStatus extends string = TConnectionStatus> = (callbacks: {
+  onMessage: (msg: TServerMessage) => void;
+  onStatusChange: (status: TStatus) => void;
+}) => ISessionClientHandle;
+interface IWsSessionState<TStatus extends string = TConnectionStatus> {
+  status: TStatus;
+  /**
+   * Set by `useWsSession` once its reconnect retries give up (issue #3280 §5): the runtime is not
+   * coming back by itself. Cleared again once `status` reaches `connected`. Undefined for a reducer
+   * with no such concept (e.g. the WebRTC surface, which has its own `failed`/`refused` statuses).
+   */
+  connectionLost?: boolean;
+  messages: TConversationEntry[];
+  activeTools: IActiveTool[];
+  streamingText: string;
+  isThinking: boolean;
+  executionWorkspace: IExecutionWorkspaceSnapshot | null;
+  sessionName: string | null;
+  /** This connection's own driver id, learned from the server's first frame; null until then. */
+  ownDriverId: TDriverId | null;
+  /** Null until the session has answered; refreshed after every command. */
+  commandCatalog: TCommandCatalog | null;
+  /** Null until the session has answered; refreshed after every command and turn. */
+  sessionStatus: TSessionStatus | null;
+  /**
+   * #3282 §2 (part 2): the models the model control's pop-up menu offers. Null until requested — the
+   * menu asks for it when it opens (or refreshes it) rather than every surface fetching it eagerly.
+   */
+  modelList: TModelListSnapshot | null;
+  /** Ask the session for the current model list (a fresh `list-models` round trip). */
+  requestModelList: () => void;
+  /** Null until the host has answered; refreshed on connect, after a switch, a rename and a turn. */
+  sessionListing: TSessionListing | null;
+  /** Set when the host answered the latest listing request with an error instead. */
+  sessionsError: TSessionsError | null;
+  requestSessions: () => void;
+  /** Make another stored session current. A refusal arrives as a notice saying why. */
+  switchSession: (sessionId: string) => void;
+  /** Start a fresh session and make it current. */
+  newSession: () => void;
+  /** Rename a row in the list — current or not. A refusal arrives as a notice saying why. */
+  renameSessionInList: (sessionId: string, name: string) => void;
+  /** Delete a stored session for good. A refusal arrives as a notice saying why. */
+  deleteSession: (sessionId: string) => void;
+  /** Whether the session sidebar is shown; `/resume` opens it. */
+  sessionSidebarOpen: boolean;
+  setSessionSidebarOpen: (open: boolean) => void;
+  send: (msg: TClientMessage$1) => void;
+  /**
+   * #3282 §2 (part 2): run a command the SAME way `send({type:'command', ...})` does, but mark its
+   * outcome as controls-triggered — `useSessionClient` skips the conversation card for a change made
+   * this way (the control's own label confirms it instead), while a typed command keeps its card.
+   */
+  sendCommandSilently: (name: string, args?: string) => void;
+  pendingPrompts: readonly TPendingPrompt[];
+  /** #3280 §2: the prompt queued behind a running turn, or null when none is queued. */
+  queuedPrompt: IQueuedPrompt | null;
+  answerPermission: (id: string, result: TPermissionResultValue) => void;
+  answerAsk: (id: string, response: TActionResponse) => void;
+  personalUsageStatus: 'idle' | 'loading' | 'ready' | 'error';
+  personalUsageReport: TPersonalUsageReport | null;
+  personalUsageError: string | null;
+  requestPersonalUsage: (period: '7d' | '30d') => void;
+  storedSessionUsageStatus: 'idle' | 'loading' | 'ready' | 'error';
+  storedSessionUsageReport: TStoredSessionUsageReport | null;
+  storedSessionUsageSessionId: string | null;
+  storedSessionUsageError: string | null;
+  requestStoredSessionUsage: (sessionId: string) => void;
+  currentSessionUsageStatus: 'idle' | 'loading' | 'ready' | 'error';
+  currentSessionUsageReport: TCurrentSessionUsageReport | null;
+  requestCurrentSessionUsage: () => void;
+  sessionNotices: readonly ISessionNotice[];
+  dismissSessionNotice: (id: string) => void;
+  /** #3282 §4a: whether the Settings modal is shown. `/settings` and the gear button both open it. */
+  settingsOpen: boolean;
+  settingsStatus: 'idle' | 'loading' | 'ready' | 'error';
+  /** Null until the first `get-settings` reply arrives. */
+  settingsSnapshot: ISettingsSnapshot | null;
+  /** The plain message from the most recent failed read or write, if any. */
+  settingsError: string | null;
+  /** #3282 §4 part b-2: which section the screen should land on for the open in progress. */
+  settingsInitialSectionId: string | null;
+  /**
+   * Opens the screen and (re-)fetches its snapshot — the "reopen and see the new value" path.
+   * `sectionId` jumps straight to that section (e.g. `/plugin` → `'plugins'`, "Manage providers…"
+   * (#3282 §2/§4b) → `'providers'`); omitted opens on the screen's own default (General).
+   */
+  openSettings: (sectionId?: string) => void;
+  closeSettings: () => void;
+  /** A failed write leaves `settingsSnapshot` at its previous value; `settingsError` names why. */
+  updateSettings: (patch: TSettingsPatch) => void;
+  /** #3282 §4e: whether the Help sheet is shown. `/help` opens it instead of reaching the session. */
+  helpOpen: boolean;
+  openHelp: () => void;
+  closeHelp: () => void;
+  /** #3288 §1: the id of the execution-workspace entry open in the detail sheet, or null when closed. */
+  openEntryId: string | null;
+  executionDetailStatus: 'idle' | 'loading' | 'ready' | 'error';
+  executionDetailRecords: readonly IExecutionDetailRecord[];
+  executionDetailError: string | null;
+  /** True once the last page read had no further cursor — nothing more to load. */
+  executionDetailComplete: boolean;
+  openExecutionDetail: (entryId: string) => void;
+  loadMoreExecutionDetail: () => void;
+  closeExecutionDetail: () => void;
+  /** #3282 §4c — the Project panel's "Changes" section (git status). */
+  projectStatusState: 'idle' | 'loading' | 'ready' | 'error';
+  projectStatus: TProjectStatusRead | null;
+  requestProjectStatus: () => void;
+  /** #3282 §4c — the Project panel's "File diff" section, for the file `projectDiffPath` names. */
+  projectDiffState: 'idle' | 'loading' | 'ready' | 'error';
+  projectDiffPath: string | null;
+  projectDiff: TProjectDiffRead | null;
+  requestProjectDiff: (path: string) => void;
+  /** #3282 §4c — the Project panel's "Memory" section. */
+  projectMemoryState: 'idle' | 'loading' | 'ready' | 'error';
+  projectMemory: TProjectMemoryRead | null;
+  requestProjectMemory: () => void;
+  /**
+   * #3282 §4 part b-3: whether the agent switcher sheet is shown. `/agent` (bare) and this surface's
+   * own control both open it.
+   */
+  agentSwitcherOpen: boolean;
+  agentSwitcherStatus: 'idle' | 'loading' | 'ready' | 'error';
+  /** The available agents: name, one-line description, and where each is defined in plain words. */
+  agentDefinitions: readonly IWireAgentDefinitionSummary[];
+  /** The agent type `/agent <name>` (no prompt) currently selects — the checked row. */
+  currentAgentType: string | null;
+  /** The plain confirmation of the last selection's result, shown in the sheet — never a conversation card. */
+  agentSwitchMessage: string | null;
+  /** Opens the sheet and (re-)fetches its roster. */
+  openAgentSwitcher: () => void;
+  closeAgentSwitcher: () => void;
+  /** Runs the same path as `/agent <name>`. */
+  selectAgent: (agentType: string) => void;
+  /**
+   * #3282 §4 part b-3: the schedules shown in the Agents panel's "Scheduled" group — every
+   * `IBackgroundTaskState` of `kind: 'scheduled'`, refreshed on connect and after a write.
+   */
+  scheduledTasks: readonly IBackgroundTaskState<'scheduled'>[];
+  /** Runs the same path as `/schedule pause <id>` / `/schedule resume <id>`. */
+  pauseSchedule: (taskId: string) => void;
+  resumeSchedule: (taskId: string) => void;
+  /**
+   * Permanently stops a schedule — the same `cancel-background-task` write Stop already uses. A
+   * failure surfaces the same way a failed Stop does (#3288 §1's `background-task-control-failed`
+   * session notice) — no separate error state here.
+   */
+  deleteSchedule: (taskId: string) => void;
+}
+//#endregion
+//#region src/hooks/useSessionClient.d.ts
+declare function useSessionClient<TStatus extends string = TConnectionStatus>(makeClient: TMakeSessionClient<TStatus>): IWsSessionState<TStatus>;
+/** Connect to a `agent` sidecar over WebSocket (loopback / localhost path). */
+declare function useWsSession(url: string): IWsSessionState<TConnectionStatus> & {
+  connectionLost: boolean;
+};
+//#endregion
+//#region src/hooks/use-session-directory.d.ts
+/**
+ * Remember `sessionId` so the reload a desktop Reconnect triggers can switch back to it once the
+ * first session listing arrives (see {@link useSessionDirectoryState}). Best-effort: a host whose
+ * storage is unavailable simply lands on whatever session the daemon puts a fresh connection on, same
+ * as before this existed.
+ */
+declare function rememberSessionForRestore(namespace: string, sessionId: string): void;
+//#endregion
+//#region src/components/composer-attachments.d.ts
+/**
+ * One file the desktop host's native "Attach files" dialog returned (#3282 §4d). Kept in structural
+ * sync with `IPickedFile` in `apps/agent-gui-web/src/gui-host.ts` and
+ * `apps/agent-app/electron/sidecar.ts` — the three are not imported across the Electron/browser/
+ * presentation package boundaries, same as this codebase already does for the trust question.
+ */
+interface IPickedFile {
+  readonly path: string;
+  readonly name: string;
+  readonly size: number;
+}
+//#endregion
+//#region src/components/Composer.d.ts
+/** What a caller can do to the composer from outside it — currently just reclaiming focus. */
+interface IComposerHandle {
+  /** Focuses the message field — used to send focus back there once a docked prompt is answered. */
+  focus: () => void;
+}
+//#endregion
+//#region src/client/runtime-host.d.ts
+/** Runtime events delivered by a native host. Browser pages have no process to supervise. */
+type TClientRuntimeState = 'starting' | 'ready' | 'fatal';
+/** A folder decision must be shown before requesting the runtime endpoint. */
+interface IClientTrustQuestion {
+  readonly folder: string;
+  readonly loads: readonly string[];
+}
+type TClientTrustChoice = 'trust' | 'restricted' | 'quit';
+/**
+ * Browser-safe shape for a narrow native preload bridge. The native host implements validation,
+ * trust, process lifecycle, and endpoint ownership; the renderer receives only these operations.
+ */
+interface IClientRuntimeBridge {
+  readonly runtimeMode?: 'local' | 'remote';
+  getEndpoint(): Promise<string | null>;
+  signalReady(): void;
+  onState(listener: (state: TClientRuntimeState, detail?: string) => void): () => void;
+  restartRuntime(): Promise<void>;
+  trustQuestion(): Promise<IClientTrustQuestion | null>;
+  answerTrust(choice: TClientTrustChoice): Promise<{
+    error?: string;
+  }>;
+  pickFiles?(): Promise<readonly IPickedFile[]>;
+  getPathForFile?(file: File): string;
+  onOpenSettings?(listener: () => void): () => void;
+  openPath?(path: string): Promise<{
+    error?: string;
+  }>;
+}
+/** A React renderer can use this contract with either a desktop bridge or a browser endpoint. */
+interface IClientRuntimeHost {
+  readonly kind: 'desktop' | 'browser';
+  getEndpoint(): Promise<string | null>;
+  signalReady(): void;
+  onState(listener: (state: TClientRuntimeState, detail?: string) => void): () => void;
+  readonly restartRuntime?: () => Promise<void>;
+  readonly trustQuestion?: () => Promise<IClientTrustQuestion | null>;
+  readonly answerTrust?: (choice: TClientTrustChoice) => Promise<{
+    error?: string;
+  }>;
+  readonly pickFiles?: () => Promise<readonly IPickedFile[]>;
+  readonly getPathForFile?: (file: File) => string;
+  onOpenSettings(listener: () => void): () => void;
+  readonly openMemoryInEditor?: (path: string) => void;
+}
+interface IClientRuntimeEnvironment {
+  readonly bridge?: IClientRuntimeBridge;
+  readonly document: Pick<Document, 'querySelector'>;
+  readonly location: Pick<Location, 'search' | 'host' | 'protocol'>;
+}
+/** Resolve host capabilities without importing Electron or a Node CLI into the browser graph. */
+declare function resolveClientRuntimeHost(environment: IClientRuntimeEnvironment): IClientRuntimeHost;
+//#endregion
+//#region src/hooks/ui-intent-state.d.ts
+/** The GUI screen an intent opens, or null when this surface has none for it. */
+declare function guiScreenForUiIntent(intent: TCommandUiIntent): 'session-sidebar' | 'settings' | 'settings-plugins' | 'agent-switcher' | null;
+/**
+ * Describe one intent for this surface: a plain, honest sentence for a screen this HOST cannot back
+ * right now (a session picker with no session list), the `/theme` exclusion this intent defensively
+ * reuses, or an unrecognized future kind. Never called for `show-settings`, `show-plugin-manager` or
+ * `show-agent-switcher` — all three always have a screen now (#3282 §4a, §4 part b-2, §4 part b-3) —
+ * but their cases are left out of this switch rather than kept as dead branches that would claim
+ * otherwise; an unknown wire-level kind (a newer host) still yields an explicit notice naming the raw
+ * kind, so the "never a silent no-op" floor holds for future intents too.
+ */
+declare function describeUiIntentForGui(intent: TCommandUiIntent): string;
+//#endregion
+//#region src/components/ConversationView.d.ts
+interface IConversationViewProps {
+  messages: readonly TConversationEntry[];
+  activeTools: IActiveTool[];
+  streamingText: string;
+  isThinking: boolean;
+  /** This connection's own driver id (§3289 §3), threaded to every message it renders. */
+  ownDriverId: TDriverId | null;
+}
+declare function ConversationView({ messages, activeTools, streamingText, isThinking, ownDriverId }: IConversationViewProps): React$1.ReactElement;
+//#endregion
+//#region src/components/AgentActivityPanel.d.ts
+interface IAgentActivityPanelProps {
+  tasks: readonly IExecutionWorkspaceEntry[];
+  /** #3282 §4 part b-3: the "Scheduled" group — every `kind: 'scheduled'` background task. */
+  schedules?: readonly IBackgroundTaskState<'scheduled'>[];
+  /** #3282 §4 part b-3: the current goal (`/goal`), or null/absent when none is set. */
+  goal?: IGoalState | null;
+  onPauseSchedule?: (taskId: string) => void;
+  onResumeSchedule?: (taskId: string) => void;
+  onDeleteSchedule?: (taskId: string) => void;
+  onCancelGoal?: () => void;
+  className?: string;
+  /** #3288 §1: open a non-main-thread entry's detail sheet. */
+  onSelect?: (entry: IExecutionWorkspaceEntry) => void;
+  /** #3288 §1: the main thread entry was clicked — the conversation beside this panel is it. */
+  onReturnToConversation?: () => void;
+  /** #3288 §1: Stop was clicked on a running/queued entry. */
+  onStop?: (entry: IExecutionWorkspaceEntry) => void;
+  /** #3288 §1: the entry whose detail sheet is currently open, for a highlighted row. */
+  selectedEntryId?: string;
+}
+declare function AgentActivityPanel({ tasks, schedules, goal, onPauseSchedule, onResumeSchedule, onDeleteSchedule, onCancelGoal, className, onSelect, onReturnToConversation, onStop, selectedEntryId }: IAgentActivityPanelProps): React$1.ReactElement;
+//#endregion
+//#region src/components/AgentSwitcherSheet.d.ts
+/**
+ * #3282 §4 part b-3 — the agent switcher: `show-agent-switcher` (`/agent` with no args) opens this
+ * sheet instead of the surface's old "not available" line. It lists every agent this session can
+ * run — name, one-line description, and where each is defined in plain words — with the current one
+ * checked. Choosing a row runs the SAME path as typing `/agent <name>` (a plain `command`, wired in
+ * `useAgentSwitcherState`); the reply is this sheet's own confirmation line, never a conversation
+ * card (issue #3282 §4's decided design).
+ */
+declare function AgentSwitcherSheet({ state }: {
+  state: IWsSessionState;
+}): React$1.ReactElement | null;
+//#endregion
+//#region src/components/PermissionPrompt.d.ts
+/**
+ * Renders the owner's pending permission/ask prompts (REMOTE-007/009). Under local == remote the paired
+ * browser owner answers its OWN prompts; the first pending prompt is shown. A gated tool call blocks
+ * until answered, so this is on the critical path — not decorative.
+ *
+ * `modal` covers the page; `dock` sits above the composer, as desktop agent apps place a pending
+ * question next to where the answer is typed. Once armed and focused, its keys answer it: 1–9 picks
+ * an option, Esc cancels a question or denies a permission — but it never takes that focus away from
+ * a field the person is typing in (#3280 §1). A click on a button always answers at once. An ask whose
+ * request sets `allowFreeText` also shows a text field (masked when `masked` is set); Enter there
+ * submits it, and its own keys never reach the prompt's shortcuts (#3280 §3). The field's typed value
+ * lives only in `FreeTextField`, keyed by `prompt.id`: a cancelled or answered prompt's text can
+ * never reach the next prompt's render, masked or not, because the field is a fresh component
+ * instance rather than a value carried over in this component's own state (#3280 §3 follow-up).
+ */
+interface IPermissionPromptProps {
+  prompts: readonly TPendingPrompt[];
+  onAnswerPermission: (id: string, result: boolean) => void;
+  onAnswerAsk: (id: string, response: TActionResponse) => void;
+  /** This connection's own driver id (§3289 §3): a prompt raised by its own turn shows no requester. */
+  ownDriverId?: TDriverId | null;
+  layout?: 'modal' | 'dock';
+  /** How long a new prompt waits before its keys answer it; tests pass their own. */
+  armDelayMs?: number;
+  /**
+   * Called once an answer (click or key) leaves no prompt behind, if focus was inside this prompt at
+   * the time — so the caller can send it back to the field the person was typing in (the composer,
+   * for the `dock` layout). Not called when another prompt immediately follows: focus stays on the
+   * prompt for that one instead.
+   */
+  onFocusReturn?: () => void;
+}
+declare function PermissionPrompt({ prompts, onAnswerPermission, onAnswerAsk, ownDriverId, layout, armDelayMs, onFocusReturn }: IPermissionPromptProps): React$1.ReactElement | null;
+//#endregion
+//#region src/components/personal-usage-dashboard-types.d.ts
+type TPersonalUsageDashboardState = Pick<IWsSessionState, 'personalUsageStatus' | 'personalUsageReport' | 'personalUsageError' | 'requestPersonalUsage' | 'storedSessionUsageStatus' | 'storedSessionUsageReport' | 'storedSessionUsageSessionId' | 'storedSessionUsageError' | 'requestStoredSessionUsage' | 'currentSessionUsageStatus' | 'currentSessionUsageReport' | 'requestCurrentSessionUsage' | 'sessionListing'>;
+//#endregion
+//#region src/components/PersonalUsageDashboard.d.ts
+declare function PersonalUsageDashboard({ state }: {
+  state: TPersonalUsageDashboardState;
+}): React.ReactElement;
+//#endregion
+//#region src/components/SessionSurface.d.ts
+/**
+ * The full desktop layout over an `IWsSessionState`. `surface` is an optional label shown next to the
+ * mark (e.g. "app").
+ */
+declare function SessionSurface({ state, surface, personalUsageEnabled, onReconnect, pickFiles, getPathForFile, onOpenMemoryInEditor }: {
+  state: IWsSessionState;
+  surface?: string;
+  /** Desktop shells opt in; embedded/session-only surfaces keep their existing chat-only contract. */
+  personalUsageEnabled?: boolean;
+  /**
+   * Present only when the host can restart the runtime after the connection is lost for good (issue
+   * #3280 §5, the desktop app); absent in the browser, where the banner says how to reopen it instead.
+   */
+  onReconnect?: () => Promise<void>;
+  /** Forwarded to the composer's attach button — present only on the desktop app (#3282 §4d). */
+  pickFiles?: () => Promise<readonly IPickedFile[]>;
+  /** Forwarded to the composer's drag-and-drop — present only on the desktop app (#3282 §4d). */
+  getPathForFile?: (file: File) => string;
+  /**
+   * The Project panel's memory "Open in editor" action — present only when the host can open a file
+   * in an external editor (the desktop app, #3282 §4c). Absent in the browser, where the action
+   * itself is hidden (only shown "if the host supports it").
+   */
+  onOpenMemoryInEditor?: (path: string) => void;
+}): React.ReactElement;
+/**
+ * A centered chrome frame for the pre-session (loading) and fatal states — reused by app shells. Its
+ * content area is this page's `main` landmark (#3289 §3 review): nothing above `CenteredChrome`'s
+ * three call sites (starting, fatal, the trust question) supplies one, and none of the three ever
+ * render alongside `SessionSurface`'s own. `header` stays a sibling of `main`, not inside it, so it
+ * keeps its own implicit `banner` role.
+ */
+declare function CenteredChrome({ tone, children }: {
+  tone: 'muted' | 'fatal';
+  children: React.ReactNode;
+}): React.ReactElement;
+//#endregion
+//#region src/components/SessionSidebar.d.ts
+/**
+ * #3189 — this workspace's sessions on the left of the conversation, as in Claude Code Desktop:
+ * start a new one, or click another to make it current. Rows the host could not read are listed,
+ * disabled, so a damaged session never looks deleted. A refused switch comes back as a notice.
+ * A host that keeps several sessions live marks the rows running now and counts who else is on them.
+ *
+ * #3289 §1 — each row also carries a "More" menu (or right-click) with Rename (inline) and Delete
+ * (confirmed). Rename on the current row reuses the `/rename` command, which also updates the live
+ * session's own name and title bar; rename on any other row writes the stored record directly.
+ */
+declare function SessionSidebar({ state, brand, className }: {
+  state: IWsSessionState;
+  /** The app's name, shown at the top of the sidebar while it is open. */
+  brand?: React.ReactNode;
+  className?: string;
+}): React.ReactElement;
+//#endregion
+//#region src/components/SessionMonitor.d.ts
+interface ISessionMonitorProps {
+  /** WebSocket URL. Injected by the HTTP server via <meta name="ws-url">. */
+  wsUrl: string;
+  className?: string;
+}
+declare function SessionMonitor({ wsUrl, className }: ISessionMonitorProps): React$1.ReactElement;
+//#endregion
+//#region src/components/Dialog.d.ts
+/**
+ * The shared modal-shell primitive (#3282 §4a, coordinated with #3282 §2's model/mode controls,
+ * which also need a confirmation dialog). Whichever of the two lands first defines this file; the
+ * other rebases onto it rather than shipping a second copy.
+ *
+ * `role="dialog"` (or `"alertdialog"`, see `role` below), `aria-modal`, a labelled title, focus moved
+ * inside on open, a focus trap while open, Esc to close, and focus restored to whatever had it before
+ * the dialog opened. A backdrop click closes the dialog UNLESS `destructive` is set — a destructive
+ * dialog (e.g. "Remove this rule?") is dismissed only by an explicit choice, never an accidental
+ * outside click.
+ */
+interface IDialogProps {
+  open: boolean;
+  /** Called on Esc, a backdrop click (non-destructive only), or an explicit close control. */
+  onClose: () => void;
+  title: string;
+  children: React$1.ReactNode;
+  /** Disables backdrop-click-to-close for a dialog whose only correct exits are explicit buttons. */
+  destructive?: boolean;
+  /** Overrides the panel's own classes; the backdrop/overlay classes are never overridden. */
+  panelClassName?: string;
+  /** Id of an element describing the dialog, wired to `aria-describedby`. */
+  describedById?: string;
+  /**
+   * Overrides what focus returns to when the dialog closes (#3289 §1). Default behavior captures
+   * `document.activeElement` when the dialog opens — which fails for a caller whose opener element
+   * is removed from the DOM in the SAME update that opens this dialog (e.g. a menu item whose menu
+   * closes as this dialog opens): by the time this dialog's open-effect runs, the browser has already
+   * moved focus to `document.body`. Such a caller passes the stable element focus should return to.
+   */
+  restoreFocusTo?: HTMLElement | null;
+  /**
+   * #3282 §4e: `'alertdialog'` for a dialog that interrupts to demand a decision before anything else
+   * can happen (a destructive confirmation) — WAI-ARIA's distinction from a dialog the user can set
+   * aside. Default `'dialog'`.
+   */
+  role?: 'dialog' | 'alertdialog';
+}
+declare function Dialog({ open, onClose, title, children, destructive, panelClassName, describedById, restoreFocusTo, role }: IDialogProps): React$1.ReactElement | null;
+interface IConfirmDialogProps {
+  open: boolean;
+  title: string;
+  body: React$1.ReactNode;
+  confirmLabel: string;
+  cancelLabel?: string;
+  /** Styles the confirm button as destructive; the dialog itself also stops closing on a backdrop click. */
+  destructive?: boolean;
+  onConfirm: () => void;
+  onCancel: () => void;
+  /** Forwarded to `Dialog` — see its doc comment. */
+  restoreFocusTo?: HTMLElement | null;
+}
+/**
+ * A title, a body, Cancel focused by default, and a confirm button that can be styled destructive.
+ * #3282 §4e: `destructive` also picks the dialog's ARIA role — `"alertdialog"` when it is (an action
+ * that demands a decision before anything else, e.g. deleting a session), `"dialog"` otherwise.
+ */
+declare function ConfirmDialog({ open, title, body, confirmLabel, cancelLabel, destructive, onConfirm, onCancel, restoreFocusTo }: IConfirmDialogProps): React$1.ReactElement | null;
+//#endregion
+//#region src/components/SettingsScreen.d.ts
+/**
+ * A large modal sheet with a section sidebar on the left and content on the right (#3282 §4a) — the
+ * GUI's Settings screen, opened by the sidebar's gear button, the desktop app's ⌘, menu item, or
+ * `/settings` (its `show-settings` `ui_intent` calls `state.openSettings()`, wired in
+ * `useSessionClient`). Every change applies at once; there is no Save button. Esc and the Close
+ * button both close it and return focus to whatever opened it (`Dialog` owns that).
+ */
+declare function SettingsScreen({ state }: {
+  state: IWsSessionState;
+}): React$1.ReactElement | null;
+//#endregion
+//#region src/components/HelpSheet.d.ts
+/**
+ * The GUI's Help sheet (#3282 §4e), a `Dialog` opened by `/help` — client-only: `useSessionClient.ts`'s
+ * `send` catches `/help` before it ever reaches the session and opens this instead, so there is no
+ * round trip and nothing terminal-style to replace it with. It lists the same commands and skills the
+ * `/` menu offers (`commandMenuFor`, unfiltered by any query — an excluded command has no row here
+ * either, exactly like the menu), grouped the same way, plus the keyboard shortcuts this surface
+ * answers. The TUI keeps its own text `/help` output; this sheet is the GUI's alone.
+ */
+declare function HelpSheet({ open, onClose, catalog }: {
+  open: boolean;
+  onClose: () => void;
+  catalog: TCommandCatalog | null;
+}): React.ReactElement | null;
+//#endregion
+//#region src/components/Brand.d.ts
+/** Shared mark: a rounded face with two eyes, in the accent colour. */
+declare function ProductMark({ size }: {
+  size?: number;
+}): React.ReactElement;
+/** The mark and the wordmark, as the app's name in its chrome. */
+declare function ProductWordmark({ surface }: {
+  surface?: string;
+}): React.ReactElement;
+//#endregion
+//#region src/product-identity.d.ts
+/** Only the public identity needed by a browser surface; hosts resolve its values. */
+interface IWebProductIdentity {
+  readonly identity: {
+    readonly displayName: string;
+    readonly cliName: string;
+  };
+  readonly storage: {
+    readonly browserNamespace: string;
+  };
+}
+declare function ProductIdentityProvider({ value, children }: {
+  readonly value: IWebProductIdentity;
+  readonly children?: ReactNode;
+}): React.ReactElement;
+declare function useProductIdentity(): IWebProductIdentity;
+//#endregion
+export { AgentActivityPanel, AgentSwitcherSheet, CenteredChrome, ConfirmDialog, ConversationView, Dialog, HelpSheet, type IActiveTool, type IClientRuntimeBridge, type IClientRuntimeEnvironment, type IClientRuntimeHost, type IClientTrustQuestion, type ICommandOutputEntry, type IComposerHandle, type IConfirmDialogProps, type IConversationMessage, type IDialogProps, type IPickedFile, type ISessionClientHandle, type ISessionNotice, type IToolGroupEntry, type IWebProductIdentity, type IWsSessionClientCallbacks, type IWsSessionState, PermissionPrompt, PersonalUsageDashboard, ProductIdentityProvider, ProductMark, ProductWordmark, SessionMonitor, SessionSidebar, SessionSurface, SettingsScreen, type TClientRuntimeState, type TClientTrustChoice, type TConnectionStatus, type TConversationEntry, type TMakeSessionClient, type TPendingPrompt, type TPersonalUsageDashboardState, type TSessionListing, type TSessionsError, applyPromptEvent, askResponse, createWsSessionClient, describeUiIntentForGui, guiScreenForUiIntent, permissionResponse, rememberSessionForRestore, resolveClientRuntimeHost, useProductIdentity, useSessionClient, useWsSession };
+//# sourceMappingURL=index.d.cts.map