@codingame/monaco-vscode-api 30.0.1 → 31.0.1

package/vscode/src/vs/platform/agentHost/common/remoteAgentHostService.d.ts

@@ -0,0 +1,122 @@
+import { Event } from "../../../base/common/event.js";
+import type { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { IRemoteAgentHostService } from "./remoteAgentHostService.service.js";
+/** Connection status for a remote agent host. */
+export declare enum RemoteAgentHostConnectionStatus {
+    Connected = "connected",
+    Connecting = "connecting",
+    Disconnected = "disconnected"
+}
+/** Configuration key for the list of remote agent host addresses. */
+export declare const RemoteAgentHostsSettingId = "chat.remoteAgentHosts";
+/** Configuration key to enable remote agent host connections. */
+export declare const RemoteAgentHostsEnabledSettingId = "chat.remoteAgentHostsEnabled";
+export declare enum RemoteAgentHostEntryType {
+    WebSocket = "websocket",
+    SSH = "ssh",
+    Tunnel = "tunnel"
+}
+export interface IRemoteAgentHostWebSocketConnection {
+    readonly type: RemoteAgentHostEntryType.WebSocket;
+    readonly address: string;
+}
+export interface IRemoteAgentHostSSHConnection {
+    readonly type: RemoteAgentHostEntryType.SSH;
+    /**
+     * The WebSocket address used by the agent host protocol client to
+     * communicate with the remote agent host process. This is typically a
+     * forwarded local port (e.g. `localhost:4321`) established by the SSH
+     * tunnel — it is NOT the SSH hostname itself.
+     */
+    readonly address: string;
+    /**
+     * SSH config host alias (e.g. `myserver`). When set, the SSH tunnel is
+     * automatically re-established on startup using the user's SSH config.
+     * This takes precedence over {@link hostName} when constructing the
+     * VS Code Remote SSH authority.
+     */
+    readonly sshConfigHost?: string;
+    /**
+     * The actual SSH hostname or IP address of the remote machine
+     * (e.g. `myserver.example.com`). This is the host that the SSH
+     * client connects to, and is used to construct the VS Code Remote
+     * SSH authority when {@link sshConfigHost} is not available.
+     */
+    readonly hostName: string;
+    /** SSH username for the remote machine. */
+    readonly user?: string;
+    /** SSH port on the remote machine (default 22). */
+    readonly port?: number;
+}
+export interface IRemoteAgentHostTunnelConnection {
+    readonly type: RemoteAgentHostEntryType.Tunnel;
+    /** Dev tunnel ID. */
+    readonly tunnelId: string;
+    /** Dev tunnel cluster region. */
+    readonly clusterId: string;
+    /**
+     * User-defined display name for this tunnel (derived from tunnel tags).
+     * Used as the tunnel name in the VS Code Remote Tunnels authority
+     * (e.g. `tunnel+<label>`). Falls back to {@link tunnelId} if not set.
+     */
+    readonly label?: string;
+    /** Auth provider used to connect to this tunnel. */
+    readonly authProvider?: "github" | "microsoft";
+}
+export type RemoteAgentHostConnection = IRemoteAgentHostWebSocketConnection | IRemoteAgentHostSSHConnection | IRemoteAgentHostTunnelConnection;
+/** An entry in the {@link RemoteAgentHostsSettingId} setting. */
+export interface IRemoteAgentHostEntry {
+    readonly name: string;
+    readonly connectionToken?: string;
+    readonly connection: RemoteAgentHostConnection;
+}
+export declare function getEntryAddress(entry: IRemoteAgentHostEntry): string;
+export declare enum RemoteAgentHostInputValidationError {
+    Empty = "empty",
+    Invalid = "invalid"
+}
+export interface IParsedRemoteAgentHostInput {
+    readonly address: string;
+    readonly connectionToken?: string;
+    readonly suggestedName: string;
+}
+export type RemoteAgentHostInputParseResult = {
+    readonly parsed: IParsedRemoteAgentHostInput;
+    readonly error?: undefined;
+} | {
+    readonly parsed?: undefined;
+    readonly error: RemoteAgentHostInputValidationError;
+};
+/** Metadata about a single remote connection. */
+export interface IRemoteAgentHostConnectionInfo {
+    readonly address: string;
+    readonly name: string;
+    readonly clientId: string;
+    readonly defaultDirectory?: string;
+    readonly status: RemoteAgentHostConnectionStatus;
+}
+export declare class NullRemoteAgentHostService implements IRemoteAgentHostService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeConnections: Event<any>;
+    readonly connections: readonly IRemoteAgentHostConnectionInfo[];
+    readonly configuredEntries: readonly IRemoteAgentHostEntry[];
+    getConnection(): IAgentConnection | undefined;
+    addRemoteAgentHost(): Promise<IRemoteAgentHostConnectionInfo>;
+    removeRemoteAgentHost(_address: string): Promise<void>;
+    reconnect(_address: string): void;
+    addSSHConnection(): Promise<IRemoteAgentHostConnectionInfo>;
+    getEntryByAddress(): IRemoteAgentHostEntry | undefined;
+}
+export declare function parseRemoteAgentHostInput(input: string): RemoteAgentHostInputParseResult;
+/** Raw shape of entries persisted in the {@link RemoteAgentHostsSettingId} setting. */
+export interface IRawRemoteAgentHostEntry {
+    readonly address: string;
+    readonly name: string;
+    readonly connectionToken?: string;
+    readonly sshConfigHost?: string;
+    readonly sshHostName?: string;
+    readonly sshUser?: string;
+    readonly sshPort?: number;
+}
+export declare function rawEntryToEntry(raw: IRawRemoteAgentHostEntry): IRemoteAgentHostEntry | undefined;
+export declare function entryToRawEntry(entry: IRemoteAgentHostEntry): IRawRemoteAgentHostEntry | undefined;

package/vscode/src/vs/platform/agentHost/common/remoteAgentHostService.js

@@ -0,0 +1,104 @@
+
+import { Event } from '../../../base/common/event.js';
+import '../../../base/common/network.js';
+import { TUNNEL_ADDRESS_PREFIX } from './tunnelAgentHost.js';
+
+var RemoteAgentHostConnectionStatus;
+(function(RemoteAgentHostConnectionStatus) {
+    RemoteAgentHostConnectionStatus["Connected"] = "connected";
+    RemoteAgentHostConnectionStatus["Connecting"] = "connecting";
+    RemoteAgentHostConnectionStatus["Disconnected"] = "disconnected";
+})(RemoteAgentHostConnectionStatus || (RemoteAgentHostConnectionStatus = {}));
+const RemoteAgentHostsSettingId = "chat.remoteAgentHosts";
+const RemoteAgentHostsEnabledSettingId = "chat.remoteAgentHostsEnabled";
+var RemoteAgentHostEntryType;
+(function(RemoteAgentHostEntryType) {
+    RemoteAgentHostEntryType["WebSocket"] = "websocket";
+    RemoteAgentHostEntryType["SSH"] = "ssh";
+    RemoteAgentHostEntryType["Tunnel"] = "tunnel";
+})(RemoteAgentHostEntryType || (RemoteAgentHostEntryType = {}));
+function getEntryAddress(entry) {
+    switch (entry.connection.type) {
+    case RemoteAgentHostEntryType.WebSocket:
+    case RemoteAgentHostEntryType.SSH:
+        return entry.connection.address;
+    case RemoteAgentHostEntryType.Tunnel:
+        return `${TUNNEL_ADDRESS_PREFIX}${entry.connection.tunnelId}`;
+    }
+}
+var RemoteAgentHostInputValidationError;
+(function(RemoteAgentHostInputValidationError) {
+    RemoteAgentHostInputValidationError["Empty"] = "empty";
+    RemoteAgentHostInputValidationError["Invalid"] = "invalid";
+})(
+    RemoteAgentHostInputValidationError || (RemoteAgentHostInputValidationError = {})
+);
+class NullRemoteAgentHostService {
+    constructor() {
+        this.onDidChangeConnections = Event.None;
+        this.connections = [];
+        this.configuredEntries = [];
+    }
+    getConnection() {
+        return undefined;
+    }
+    async addRemoteAgentHost() {
+        throw ( new Error("Remote agent host connections are not supported in this environment."));
+    }
+    async removeRemoteAgentHost(_address) {}
+    reconnect(_address) {}
+    async addSSHConnection() {
+        throw ( new Error("Remote agent host connections are not supported in this environment."));
+    }
+    getEntryByAddress() {
+        return undefined;
+    }
+}
+function rawEntryToEntry(raw) {
+    if (raw.sshConfigHost || raw.sshHostName || raw.sshUser || raw.sshPort) {
+        return {
+            name: raw.name,
+            connectionToken: raw.connectionToken,
+            connection: {
+                type: RemoteAgentHostEntryType.SSH,
+                address: raw.address,
+                sshConfigHost: raw.sshConfigHost,
+                hostName: raw.sshHostName ?? raw.address,
+                user: raw.sshUser,
+                port: raw.sshPort
+            }
+        };
+    }
+    return {
+        name: raw.name,
+        connectionToken: raw.connectionToken,
+        connection: {
+            type: RemoteAgentHostEntryType.WebSocket,
+            address: raw.address
+        }
+    };
+}
+function entryToRawEntry(entry) {
+    switch (entry.connection.type) {
+    case RemoteAgentHostEntryType.SSH:
+        return {
+            address: entry.connection.address,
+            name: entry.name,
+            connectionToken: entry.connectionToken,
+            sshConfigHost: entry.connection.sshConfigHost,
+            sshHostName: entry.connection.hostName,
+            sshUser: entry.connection.user,
+            sshPort: entry.connection.port
+        };
+    case RemoteAgentHostEntryType.WebSocket:
+        return {
+            address: entry.connection.address,
+            name: entry.name,
+            connectionToken: entry.connectionToken
+        };
+    case RemoteAgentHostEntryType.Tunnel:
+        return undefined;
+    }
+}
+
+export { NullRemoteAgentHostService, RemoteAgentHostConnectionStatus, RemoteAgentHostEntryType, RemoteAgentHostInputValidationError, RemoteAgentHostsEnabledSettingId, RemoteAgentHostsSettingId, entryToRawEntry, getEntryAddress, rawEntryToEntry };

package/vscode/src/vs/platform/agentHost/common/remoteAgentHostService.service.d.ts

@@ -0,0 +1,54 @@
+import { Event } from "../../../base/common/event.js";
+import { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { IRemoteAgentHostConnectionInfo, IRemoteAgentHostEntry } from "./remoteAgentHostService.js";
+export declare const IRemoteAgentHostService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IRemoteAgentHostService>;
+/**
+* Manages connections to one or more remote agent host processes over
+* WebSocket. Each connection is identified by its address string and
+* exposed as an {@link IAgentConnection}, the same interface used for
+* the local agent host.
+*/
+export interface IRemoteAgentHostService {
+    readonly _serviceBrand: undefined;
+    /** Fires when a remote connection is established or lost. */
+    readonly onDidChangeConnections: Event<void>;
+    /** Currently connected remote addresses with metadata. */
+    readonly connections: readonly IRemoteAgentHostConnectionInfo[];
+    /** All configured remote agent host entries from settings, regardless of connection status. */
+    readonly configuredEntries: readonly IRemoteAgentHostEntry[];
+    /**
+    * Get a per-connection {@link IAgentConnection} for subscribing to
+    * state, dispatching actions, creating sessions, etc.
+    *
+    * Returns `undefined` if no active connection exists for the address.
+    */
+    getConnection(address: string): IAgentConnection | undefined;
+    /**
+    * Adds or updates a configured remote host and resolves once a connection
+    * to that host is available.
+    */
+    addRemoteAgentHost(entry: IRemoteAgentHostEntry): Promise<IRemoteAgentHostConnectionInfo>;
+    /**
+    * Removes a configured remote host entry by address.
+    * Disconnects any active connection and removes the entry from settings.
+    */
+    removeRemoteAgentHost(address: string): Promise<void>;
+    /**
+    * Forcefully reconnect to a configured remote host.
+    * Tears down any existing connection and starts a fresh connect attempt
+    * with reset backoff.
+    */
+    reconnect(address: string): void;
+    /**
+    * Register a pre-connected agent connection.
+    * Used by the SSH and tunnel services to inject relay-backed connections
+    * without going through the WebSocket connect flow.
+    */
+    addSSHConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection): Promise<IRemoteAgentHostConnectionInfo>;
+    /**
+    * Look up the {@link IRemoteAgentHostEntry} for a given address.
+    * Checks both configured entries from settings and dynamically
+    * registered entries (e.g. tunnel connections).
+    */
+    getEntryByAddress(address: string): IRemoteAgentHostEntry | undefined;
+}

package/vscode/src/vs/platform/agentHost/common/remoteAgentHostService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const IRemoteAgentHostService = ( createDecorator("remoteAgentHostService"));
+
+export { IRemoteAgentHostService };

package/vscode/src/vs/platform/agentHost/common/sshRemoteAgentHost.d.ts

@@ -0,0 +1,88 @@
+import { Event } from "../../../base/common/event.js";
+import { IDisposable } from "../../../base/common/lifecycle.js";
+/**
+ * IPC channel name for the main-process SSH service.
+ */
+export declare const SSH_REMOTE_AGENT_HOST_CHANNEL = "sshRemoteAgentHost";
+export declare enum SSHAuthMethod {
+    /** Use the local SSH agent for key-based auth. */
+    Agent = "agent",
+    /** Authenticate with an explicit private key file. */
+    KeyFile = "keyFile",
+    /** Authenticate with a password. */
+    Password = "password"
+}
+export interface ISSHAgentHostConfig {
+    /** Remote hostname or IP. */
+    readonly host: string;
+    /** SSH port (default 22). */
+    readonly port?: number;
+    /** Username on the remote machine. */
+    readonly username: string;
+    /** Authentication method. */
+    readonly authMethod: SSHAuthMethod;
+    /** Path to the private key file (when {@link authMethod} is KeyFile). */
+    readonly privateKeyPath?: string;
+    /** Password string (when {@link authMethod} is Password). */
+    readonly password?: string;
+    /** Display name for this connection. */
+    readonly name: string;
+    /** SSH config host alias (e.g. "robfast2") for reconnection on restart. */
+    readonly sshConfigHost?: string;
+    /** Dev override: custom command to start the remote agent host instead of the default CLI. */
+    readonly remoteAgentHostCommand?: string;
+}
+/**
+ * A sanitized view of the SSH config that omits secret material
+ * (password, private key path). Exposed on active connections so
+ * consumers can inspect connection metadata without accessing credentials.
+ */
+export type ISSHAgentHostConfigSanitized = Omit<ISSHAgentHostConfig, "password" | "privateKeyPath">;
+export interface ISSHAgentHostConnection extends IDisposable {
+    /** The SSH config used to establish this connection (secrets stripped). */
+    readonly config: ISSHAgentHostConfigSanitized;
+    /** The connection address (e.g. `ssh:myhost` or `user@host:22`) registered with IRemoteAgentHostService. */
+    readonly localAddress: string;
+    /** The display name. */
+    readonly name: string;
+    /** Fires when this SSH connection is closed or lost. */
+    readonly onDidClose: Event<void>;
+}
+/**
+ * Serializable result from a successful SSH connect operation.
+ * Returned over IPC from the main process.
+ */
+export interface ISSHConnectResult {
+    /** Unique identifier for this connection's relay channel. */
+    readonly connectionId: string;
+    /** Display-friendly address (e.g. "ssh:robfast2"). */
+    readonly address: string;
+    readonly name: string;
+    readonly connectionToken: string | undefined;
+    readonly config: ISSHAgentHostConfigSanitized;
+    /** SSH config host alias for reconnection on restart. */
+    readonly sshConfigHost?: string;
+}
+/**
+ * Resolved SSH configuration for a host, obtained from `ssh -G`.
+ */
+export interface ISSHResolvedConfig {
+    readonly hostname: string;
+    readonly user: string | undefined;
+    readonly port: number;
+    readonly identityFile: string[];
+    readonly forwardAgent: boolean;
+}
+export interface ISSHConnectProgress {
+    readonly connectionKey: string;
+    readonly message: string;
+}
+/**
+ * A message relayed from a remote agent host through the SSH tunnel.
+ * The shared process acts as a WebSocket proxy, forwarding JSON messages
+ * bidirectionally between the SSH channel and the renderer via IPC.
+ */
+export interface ISSHRelayMessage {
+    readonly connectionId: string;
+    readonly data: string;
+}

package/vscode/src/vs/platform/agentHost/common/sshRemoteAgentHost.service.d.ts

@@ -0,0 +1,89 @@
+import { Event } from "../../../base/common/event.js";
+import { ISSHConnectProgress, ISSHAgentHostConnection, ISSHAgentHostConfig, ISSHResolvedConfig, type ISSHConnectResult, type ISSHRelayMessage } from "./sshRemoteAgentHost.js";
+export declare const ISSHRemoteAgentHostService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ISSHRemoteAgentHostService>;
+/**
+* Manages SSH connections that bootstrap a remote agent host process.
+*
+* Each connection SSHs into a remote machine, ensures the VS Code CLI
+* is installed, starts `code agent-host`, and creates a WebSocket relay
+* over the SSH channel. Messages are forwarded between the renderer and
+* the remote agent host via IPC through the shared process.
+*/
+export interface ISSHRemoteAgentHostService {
+    readonly _serviceBrand: undefined;
+    /** Fires when the set of active SSH connections changes. */
+    readonly onDidChangeConnections: Event<void>;
+    /** Progress messages during connect. */
+    readonly onDidReportConnectProgress: Event<ISSHConnectProgress>;
+    /** Currently active SSH-bootstrapped connections. */
+    readonly connections: readonly ISSHAgentHostConnection[];
+    /**
+    * Bootstrap a remote agent host over SSH.
+    *
+    * 1. Opens an SSH connection to the remote host
+    * 2. Downloads and installs the VS Code CLI if needed
+    * 3. Starts `code agent-host`
+    * 4. Creates a WebSocket relay over the SSH channel
+    * 5. Registers the connection with {@link IRemoteAgentHostService}
+    *
+    * Resolves with the connection handle once the agent host is reachable.
+    */
+    connect(config: ISSHAgentHostConfig): Promise<ISSHAgentHostConnection>;
+    /**
+    * Disconnect an SSH-bootstrapped connection by host address.
+    * Tears down the SSH tunnel, stops the remote agent host, and
+    * removes the entry from {@link IRemoteAgentHostService}.
+    */
+    disconnect(host: string): Promise<void>;
+    /** List SSH config host aliases (excluding wildcards). */
+    listSSHConfigHosts(): Promise<string[]>;
+    /** Resolve full SSH config for a host via `ssh -G`. */
+    resolveSSHConfig(host: string): Promise<ISSHResolvedConfig>;
+    /**
+    * Re-establish an SSH tunnel on startup for a previously connected host.
+    * Returns the new local forwarded address and registers it.
+    */
+    reconnect(sshConfigHost: string, name: string): Promise<ISSHAgentHostConnection>;
+}
+/**
+* Main-process service that performs the actual SSH work.
+* The renderer calls this over IPC and handles registration
+* with {@link IRemoteAgentHostService} locally.
+*/
+export declare const ISSHRemoteAgentHostMainService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ISSHRemoteAgentHostMainService>;
+export interface ISSHRemoteAgentHostMainService {
+    readonly _serviceBrand: undefined;
+    /** Fires when the set of active SSH connections changes. */
+    readonly onDidChangeConnections: Event<void>;
+    /** Fires when a connection is closed from the shared process side. */
+    readonly onDidCloseConnection: Event<string>;
+    /** Progress messages during connect (e.g. "Installing CLI..."). */
+    readonly onDidReportConnectProgress: Event<ISSHConnectProgress>;
+    /** Fires when a message is received from a remote agent host via the SSH relay. */
+    readonly onDidRelayMessage: Event<ISSHRelayMessage>;
+    /** Fires when a relay connection to a remote agent host closes. */
+    readonly onDidRelayClose: Event<string>;
+    /**
+    * Bootstrap a remote agent host over SSH. Returns serializable
+    * connection info for the renderer to register.
+    */
+    connect(config: ISSHAgentHostConfig): Promise<ISSHConnectResult>;
+    /**
+    * Send a message to a remote agent host through the SSH relay.
+    */
+    relaySend(connectionId: string, message: string): Promise<void>;
+    /**
+    * Disconnect an SSH-bootstrapped connection by host address.
+    */
+    disconnect(host: string): Promise<void>;
+    /** List SSH config host aliases (excluding wildcards). */
+    listSSHConfigHosts(): Promise<string[]>;
+    /** Resolve full SSH config for a host via `ssh -G`. */
+    resolveSSHConfig(host: string): Promise<ISSHResolvedConfig>;
+    /**
+    * Re-establish an SSH tunnel for a previously connected host.
+    * Resolves the SSH config alias, connects, and returns fresh
+    * connection info with a new local forwarded port.
+    */
+    reconnect(sshConfigHost: string, name: string, remoteAgentHostCommand?: string): Promise<ISSHConnectResult>;
+}

package/vscode/src/vs/platform/agentHost/common/sshRemoteAgentHost.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const ISSHRemoteAgentHostService = ( createDecorator("sshRemoteAgentHostService"));
+
+export { ISSHRemoteAgentHostService };

package/vscode/src/vs/platform/agentHost/common/state/protocol/action-origin.generated.d.ts

@@ -0,0 +1,22 @@
+import { type IStateAction, type IRootAgentsChangedAction, type IRootActiveSessionsChangedAction, type IRootTerminalsChangedAction, type ISessionReadyAction, type ISessionCreationFailedAction, type ISessionTurnStartedAction, type ISessionDeltaAction, type ISessionResponsePartAction, type ISessionToolCallStartAction, type ISessionToolCallDeltaAction, type ISessionToolCallReadyAction, type ISessionToolCallConfirmedAction, type ISessionToolCallCompleteAction, type ISessionToolCallResultConfirmedAction, type ISessionToolCallContentChangedAction, type ISessionTurnCompleteAction, type ISessionTurnCancelledAction, type ISessionErrorAction, type ISessionTitleChangedAction, type ISessionUsageAction, type ISessionReasoningAction, type ISessionModelChangedAction, type ISessionServerToolsChangedAction, type ISessionActiveClientChangedAction, type ISessionActiveClientToolsChangedAction, type ISessionPendingMessageSetAction, type ISessionPendingMessageRemovedAction, type ISessionQueuedMessagesReorderedAction, type ISessionInputRequestedAction, type ISessionInputAnswerChangedAction, type ISessionInputCompletedAction, type ISessionCustomizationsChangedAction, type ISessionCustomizationToggledAction, type ISessionTruncatedAction, type ISessionIsReadChangedAction, type ISessionIsDoneChangedAction, type ISessionDiffsChangedAction, type ISessionConfigChangedAction, type ITerminalDataAction, type ITerminalInputAction, type ITerminalResizedAction, type ITerminalClaimedAction, type ITerminalTitleChangedAction, type ITerminalCwdChangedAction, type ITerminalExitedAction, type ITerminalClearedAction, type ITerminalCommandDetectionAvailableAction, type ITerminalCommandExecutedAction, type ITerminalCommandFinishedAction } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+/** Union of all root-scoped actions. */
+export type IRootAction = IRootAgentsChangedAction | IRootActiveSessionsChangedAction | IRootTerminalsChangedAction;
+/** Union of all session-scoped actions. */
+export type ISessionAction = ISessionReadyAction | ISessionCreationFailedAction | ISessionTurnStartedAction | ISessionDeltaAction | ISessionResponsePartAction | ISessionToolCallStartAction | ISessionToolCallDeltaAction | ISessionToolCallReadyAction | ISessionToolCallConfirmedAction | ISessionToolCallCompleteAction | ISessionToolCallResultConfirmedAction | ISessionToolCallContentChangedAction | ISessionTurnCompleteAction | ISessionTurnCancelledAction | ISessionErrorAction | ISessionTitleChangedAction | ISessionUsageAction | ISessionReasoningAction | ISessionModelChangedAction | ISessionServerToolsChangedAction | ISessionActiveClientChangedAction | ISessionActiveClientToolsChangedAction | ISessionPendingMessageSetAction | ISessionPendingMessageRemovedAction | ISessionQueuedMessagesReorderedAction | ISessionInputRequestedAction | ISessionInputAnswerChangedAction | ISessionInputCompletedAction | ISessionCustomizationsChangedAction | ISessionCustomizationToggledAction | ISessionTruncatedAction | ISessionIsReadChangedAction | ISessionIsDoneChangedAction | ISessionDiffsChangedAction | ISessionConfigChangedAction;
+/** Union of session actions that clients may dispatch. */
+export type IClientSessionAction = ISessionTurnStartedAction | ISessionToolCallConfirmedAction | ISessionToolCallCompleteAction | ISessionToolCallResultConfirmedAction | ISessionToolCallContentChangedAction | ISessionTurnCancelledAction | ISessionTitleChangedAction | ISessionModelChangedAction | ISessionActiveClientChangedAction | ISessionActiveClientToolsChangedAction | ISessionPendingMessageSetAction | ISessionPendingMessageRemovedAction | ISessionQueuedMessagesReorderedAction | ISessionInputAnswerChangedAction | ISessionInputCompletedAction | ISessionCustomizationToggledAction | ISessionTruncatedAction | ISessionIsReadChangedAction | ISessionIsDoneChangedAction | ISessionConfigChangedAction;
+/** Union of session actions that only the server may produce. */
+export type IServerSessionAction = ISessionReadyAction | ISessionCreationFailedAction | ISessionDeltaAction | ISessionResponsePartAction | ISessionToolCallStartAction | ISessionToolCallDeltaAction | ISessionToolCallReadyAction | ISessionTurnCompleteAction | ISessionErrorAction | ISessionUsageAction | ISessionReasoningAction | ISessionServerToolsChangedAction | ISessionInputRequestedAction | ISessionCustomizationsChangedAction | ISessionDiffsChangedAction;
+/** Union of all terminal-scoped actions. */
+export type ITerminalAction = ITerminalDataAction | ITerminalInputAction | ITerminalResizedAction | ITerminalClaimedAction | ITerminalTitleChangedAction | ITerminalCwdChangedAction | ITerminalExitedAction | ITerminalClearedAction | ITerminalCommandDetectionAvailableAction | ITerminalCommandExecutedAction | ITerminalCommandFinishedAction;
+/** Union of terminal actions that clients may dispatch. */
+export type IClientTerminalAction = ITerminalInputAction | ITerminalResizedAction | ITerminalClaimedAction | ITerminalTitleChangedAction | ITerminalClearedAction;
+/** Union of terminal actions that only the server may produce. */
+export type IServerTerminalAction = ITerminalDataAction | ITerminalCwdChangedAction | ITerminalExitedAction | ITerminalCommandDetectionAvailableAction | ITerminalCommandExecutedAction | ITerminalCommandFinishedAction;
+/**
+ * Exhaustive map indicating which action types may be dispatched by clients.
+ * Adding a new action to IStateAction without adding it here is a compile error.
+ */
+export declare const IS_CLIENT_DISPATCHABLE: {
+    readonly [K in IStateAction["type"]]: boolean;
+};