@codingame/monaco-vscode-api 36.2.7 → 37.1.0

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

@@ -1,6 +1,16 @@
 import { Event } from "../../../base/common/event.js";
 import { IDisposable } from "../../../base/common/lifecycle.js";
+import type { AgentHostEndpointAddress, AgentHostServerType } from "./agentHostEndpointRegistry.js";
+import type { RemoteAgentHostLocationPreference } from "./remoteAgentHostLocationPreference.js";
 export type { IRelayMessage } from "./relayTransport.js";
+/**
+ * Lifecycle ownership of the remote agent host process backing a
+ * connection: `managed` means this desktop spawned it (and is relying on
+ * its `--idle-timeout` to self-clean-up when unused), `external` means it
+ * was already running (another editor window, or a previously spawned
+ * standalone) and this desktop merely attached to it.
+ */
+export type SSHAgentHostLifecycle = "managed" | "external";
 /**
  * IPC channel name for the main-process SSH service.
  */
@@ -36,7 +46,57 @@ export interface ISSHAgentHostConfig {
     readonly remoteAgentHostCommand?: string;
     /** When true, enables OpenSSH agent forwarding (auth-agent@openssh.com) for this connection. Requires {@link authMethod} to be Agent. */
     readonly agentForward?: boolean;
+    /**
+     * Whether this connect attempt was directly requested by the user (e.g.
+     * "Connect" from the workspace picker) as opposed to a silent background
+     * reconnect (e.g. on startup, or a scheduled auto-reconnect retry).
+     * Defaults to `true` when omitted, preserving today's picker-eligible
+     * behavior for every existing caller that doesn't set this explicitly.
+     *
+     * When explicitly `false` and {@link preferredAgentLocation} is unset,
+     * endpoint selection never shows the main↔renderer picker and never
+     * silently attaches to an `editor`-owned endpoint even if one is the
+     * only live endpoint — it deterministically reuses a live `standalone`
+     * endpoint when one exists, or spawns a new dedicated one otherwise.
+     * This keeps unattended reconnects from blocking on renderer UI or
+     * stealing a session out from under another open editor window.
+     */
+    readonly userInitiated?: boolean;
+    /**
+     * The renderer's previously stored {@link IRemoteAgentHostLocationPreferenceService}
+     * choice for this host's stable connection key (see
+     * {@link computeSSHConnectionKey}), threaded through so the main process
+     * can honor it without ever emitting an {@link ISSHEndpointSelectionRequest}.
+     * Takes priority over {@link userInitiated}: a stored `editor` preference
+     * lets even a silent/background reconnect (`userInitiated: false`) land on
+     * a live `editor`-owned endpoint (falling back to `dedicated` selection,
+     * without mutating the stored preference, if none is live), and a stored
+     * `dedicated` preference always selects a dedicated endpoint. When unset,
+     * behavior is unchanged: {@link userInitiated} alone governs whether the
+     * picker may be shown. Non-secret; safe to keep in the sanitized config.
+     */
+    readonly preferredAgentLocation?: RemoteAgentHostLocationPreference;
 }
+/**
+ * Compute the stable per-host key used to key in-flight SSH connections,
+ * the shared endpoint-selection request/candidates, and this host's
+ * persisted {@link RemoteAgentHostLocationPreference}. Uses the SSH config
+ * host alias when available (`ssh:<alias>`), falling back to
+ * `user@host:port` for config-less (explicit credential) connections. Both
+ * the node-side SSH service and the renderer-side preference lookup must
+ * use this exact key so a preference set on one path is honored by the
+ * other. `username`/`host`/`port` are optional since callers that only
+ * know a {@link ISSHAgentHostConfig.sshConfigHost sshConfigHost} alias
+ * up front (e.g. the renderer's `reconnect()`, before the main process has
+ * resolved the alias to a hostname) never reach the fallback branch that
+ * needs them.
+ */
+export declare function computeSSHConnectionKey(config: {
+    sshConfigHost?: string;
+    username?: string;
+    host?: string;
+    port?: number;
+}): string;
 /**
  * A sanitized view of the SSH config that omits secret material
  * (password, private key path). Exposed on active connections so
@@ -52,6 +112,18 @@ export interface ISSHAgentHostConnection extends IDisposable {
     readonly name: string;
     /** Fires when this SSH connection is closed or lost. */
     readonly onDidClose: Event<void>;
+    /**
+     * Kind of remote agent host process backing this connection, when known
+     * (registry-discovered connections only; unset for the legacy
+     * `remoteAgentHostCommand` override path).
+     */
+    readonly serverType?: AgentHostServerType;
+    /** Registry `instanceId` of the remote agent host backing this connection, when known. */
+    readonly instanceId?: string;
+    /** Whether this is the primary connection selected for this remote (see {@link ISSHConnectResult.primary}). */
+    readonly primary?: boolean;
+    /** Whether this desktop spawned (and therefore is relying on idle-timeout to clean up) the backing process, or merely attached to an already-running one. */
+    readonly lifecycle?: SSHAgentHostLifecycle;
 }
 /**
  * Serializable result from a successful SSH connect operation.
@@ -67,7 +139,39 @@ export interface ISSHConnectResult {
     readonly config: ISSHAgentHostConfigSanitized;
     /** SSH config host alias for reconnection on restart. */
     readonly sshConfigHost?: string;
+    /**
+     * Kind of remote agent host process backing this connection
+     * (`editor` or `standalone`), when discovered through the shared
+     * endpoint registry. Unset for the legacy `remoteAgentHostCommand`
+     * override path, which bypasses registry discovery entirely.
+     */
+    readonly serverType?: AgentHostServerType;
+    /** Registry `instanceId` of the remote agent host backing this connection, when known. */
+    readonly instanceId?: string;
+    /**
+     * Whether this connection is the primary one for this remote: the one
+     * chosen (explicitly, or by deterministic reuse/spawn) to back the
+     * editor's own remote session. Every successful `connect()`/`reconnect()`
+     * result today is primary; this field exists so future consumers can
+     * distinguish it without relying on absence-of-alternative.
+     */
+    readonly primary?: boolean;
+    /**
+     * Whether this desktop spawned the backing remote agent host process
+     * (`managed`, relies on `--idle-timeout` for cleanup) or merely attached
+     * to an already-running one (`external`, e.g. another editor window or a
+     * previously spawned standalone — never killed on disconnect).
+     */
+    readonly lifecycle?: SSHAgentHostLifecycle;
 }
+/**
+ * How OpenSSH should react to an unknown or changed host key. `ssh -G`
+ * canonicalizes `yes` to `true` and `no`/`off` to `false`, which the resolved
+ * config parser normalizes back to this policy representation.
+ */
+export type SSHStrictHostKeyChecking = "ask" | "accept-new" | "yes" | "no" | "off";
+/** Narrow an arbitrary `ssh -G` value to a {@link SSHStrictHostKeyChecking}. */
+export declare function isSSHStrictHostKeyChecking(value: string): value is SSHStrictHostKeyChecking;
 /**
  * Resolved SSH configuration for a host, obtained from `ssh -G`.
  */
@@ -78,6 +182,16 @@ export interface ISSHResolvedConfig {
     readonly identityFile: string[];
     readonly identityAgent: string | undefined;
     readonly forwardAgent: boolean;
+    /**
+     * `UserKnownHostsFile` paths, in priority order. `ssh -G` emits these as a
+     * single space-separated list, so this is already split. Typically
+     * `~/.ssh/known_hosts` and `~/.ssh/known_hosts2`.
+     */
+    readonly userKnownHostsFiles: string[];
+    /** `GlobalKnownHostsFile` paths, e.g. `/etc/ssh/ssh_known_hosts`. */
+    readonly globalKnownHostsFiles: string[];
+    /** Resolved and normalized `StrictHostKeyChecking`, when recognized. */
+    readonly strictHostKeyChecking: SSHStrictHostKeyChecking | undefined;
 }
 export interface ISSHConnectProgress {
     readonly connectionKey: string;
@@ -110,3 +224,132 @@ export interface ISSHKeyboardInteractiveRequest {
     readonly instructions: string;
     readonly prompts: readonly ISSHKeyboardInteractivePrompt[];
 }
+/**
+ * One live remote agent host endpoint the user could connect to, as
+ * surfaced by `code agent endpoints` on the remote machine. Deliberately
+ * excludes the raw {@link AgentHostEndpointAddress} details that aren't
+ * useful for disambiguation (e.g. a socket path) but keeps enough
+ * (server type, PID, quality, and a display form of the address) for the
+ * renderer to build a fully localized, accessible label without needing
+ * any pre-formatted string from the main process.
+ */
+export interface ISSHEndpointCandidate {
+    readonly type: AgentHostServerType;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly quality?: string;
+    readonly endpoint: AgentHostEndpointAddress;
+}
+/**
+ * Request from the main process for the renderer to choose which live
+ * remote agent host endpoint (or "start a new one") to connect to. Fired
+ * when the shared endpoint registry on the remote host contains at least
+ * one `editor`-owned entry, since in that case silent reuse could steal a
+ * session out from under another open editor window. The renderer is
+ * expected to respond with {@link ISSHRemoteAgentHostMainService.respondEndpointSelection}.
+ */
+export interface ISSHEndpointSelectionRequest {
+    readonly requestId: string;
+    readonly connectionKey: string;
+    /** Display-friendly host (e.g. SSH config alias or `user@host`). */
+    readonly displayHost: string;
+    /** Every live endpoint on the remote, both `editor`- and `standalone`-owned. */
+    readonly candidates: readonly ISSHEndpointCandidate[];
+}
+/**
+ * The renderer's answer to an {@link ISSHEndpointSelectionRequest}: either
+ * attach to one of the offered live candidates (identified by its identity
+ * triple, since PIDs alone are not stable across reuse), or spawn a new
+ * dedicated standalone agent host.
+ */
+export type ISSHEndpointSelection = {
+    readonly kind: "candidate";
+    readonly type: AgentHostServerType;
+    readonly pid: number;
+    readonly instanceId: string;
+} | {
+    readonly kind: "spawn";
+};
+/**
+ * What the user's `known_hosts` files say about a presented host key. Mirrors
+ * `KnownHostsMatch` in `../node/sshKnownHosts.js`, redeclared here because
+ * this common-layer module cannot import from `node`.
+ */
+export type SSHKnownHostsMatch = "match" | "mismatch" | "revoked" | "ca-only" | "unknown";
+/**
+ * Error name for a connect attempt refused because the server's host key was
+ * not trusted. Matching on the name (rather than `instanceof`) is deliberate:
+ * the error is raised in the shared process and inspected in the renderer, and
+ * only `name`/`message` survive IPC serialization.
+ */
+export declare const SSH_HOST_KEY_DENIED_ERROR_NAME = "SSHHostKeyDenied";
+/**
+ * Raised when host key verification refused the connection.
+ *
+ * The host key UI owns the conversation about *why* — either the user
+ * declined the prompt themselves, or a specific, actionable notification
+ * (with a "Forget Saved Host Key" action) is already on screen. Callers should
+ * therefore not add a generic "failed to connect" error on top; see
+ * {@link isSSHHostKeyDeniedError}.
+ */
+export declare class SSHHostKeyDeniedError extends Error {
+    constructor(displayHost: string);
+}
+/** Whether `error` is an {@link SSHHostKeyDeniedError}, including across IPC. */
+export declare function isSSHHostKeyDeniedError(error: unknown): boolean;
+/**
+ * Request from the shared process for the renderer to decide whether a
+ * server's host key should be trusted. Fired from ssh2's `hostVerifier` during
+ * key exchange — that is, *before* authentication — so declining guarantees no
+ * password or SSH agent access is ever exposed to an unverified server.
+ *
+ * The shared process only gathers evidence ({@link knownHostsMatch} and the
+ * fingerprint); the renderer owns the actual policy, since it holds the trust
+ * store and the UI. The renderer must answer via
+ * {@link ISSHRemoteAgentHostMainService.respondHostKeyVerification} with the
+ * same `requestId`, otherwise the connection stalls until the deadline.
+ *
+ * (`ISSHRemoteAgentHostMainService` is a misnomer inherited from its siblings:
+ * it and the WSL/tunnel equivalents are all registered in `sharedProcessMain`,
+ * so they run in the shared process, not the main process.)
+ */
+export interface ISSHHostKeyVerificationRequest {
+    readonly requestId: string;
+    readonly connectionKey: string;
+    /** Display-friendly host (e.g. SSH config alias or `user@host`). */
+    readonly displayHost: string;
+    /** Resolved hostname the key was presented for. */
+    readonly host: string;
+    readonly port: number;
+    /** Host key algorithm, e.g. `ssh-ed25519`. */
+    readonly keyType: string;
+    /** OpenSSH-style `SHA256:...` fingerprint, matching `ssh-keygen -lf`. */
+    readonly fingerprint: string;
+    /** What the user's `known_hosts` files say about this key. */
+    readonly knownHostsMatch: SSHKnownHostsMatch;
+    /** Resolved `StrictHostKeyChecking` from `ssh -G`, when recognized. */
+    readonly strictHostKeyChecking?: SSHStrictHostKeyChecking;
+    /**
+     * Whether the owning connect attempt was directly requested by the user.
+     * Background reconnects must never open a modal, so an unknown host key on
+     * a silent reconnect is declined rather than prompted for.
+     */
+    readonly userInitiated: boolean;
+}
+/**
+ * A host key proven to belong to an already-authenticated server, delivered
+ * via OpenSSH's `UpdateHostKeys` extension (`hostkeys-00@openssh.com`). ssh2
+ * completes the `hostkeys-prove-00@openssh.com` challenge and verifies the
+ * signatures before surfacing these, so they can be trusted without prompting
+ * — this is what lets a legitimate server key rotation be picked up silently
+ * instead of surfacing as a scary mismatch.
+ */
+export interface ISSHHostKeysAnnouncement {
+    readonly connectionKey: string;
+    readonly host: string;
+    readonly port: number;
+    readonly keys: readonly {
+        readonly keyType: string;
+        readonly fingerprint: string;
+    }[];
+}

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

@@ -1,6 +1,7 @@
 import { Event } from "../../../base/common/event.js";
 import { URI } from "../../../base/common/uri.js";
-import { ISSHConnectProgress, ISSHAgentHostConnection, ISSHAgentHostConfig, ISSHResolvedConfig, type IRelayMessage, type ISSHConnectResult, type ISSHKeyboardInteractiveRequest } from "./sshRemoteAgentHost.js";
+import { RemoteAgentHostLocationPreference } from "./remoteAgentHostLocationPreference.js";
+import { ISSHConnectProgress, ISSHAgentHostConnection, ISSHAgentHostConfig, ISSHResolvedConfig, type IRelayMessage, type ISSHConnectResult, type ISSHEndpointSelection, type ISSHEndpointSelectionRequest, type ISSHHostKeysAnnouncement, type ISSHHostKeyVerificationRequest, type ISSHKeyboardInteractiveRequest } from "./sshRemoteAgentHost.js";
 export declare const ISSHRemoteAgentHostService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ISSHRemoteAgentHostService>;
 /**
 * Manages SSH connections that bootstrap a remote agent host process.
@@ -25,15 +26,15 @@ export interface ISSHRemoteAgentHostService {
     * 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}
+    * 5. Waits for {@link IRemoteAgentHostService} to complete the protocol handshake
     *
     * 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}.
+    * Tears down the SSH tunnel, stops the remote agent host, and removes its
+    * persisted SSH entry.
     */
     disconnect(host: string): Promise<void>;
     /** List SSH config host aliases (excluding wildcards). */
@@ -54,9 +55,14 @@ export interface ISSHRemoteAgentHostService {
     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.
+    * Resolves once the service-owned protocol connection is ready.
+    *
+    * @param userInitiated See {@link ISSHAgentHostConfig.userInitiated}.
+    * Defaults to `true` (picker-eligible) when omitted; background/auto
+    * reconnect callers must pass `false` explicitly to guarantee no picker
+    * ever opens and no `editor` endpoint is ever silently chosen.
     */
-    reconnect(sshConfigHost: string, name: string): Promise<ISSHAgentHostConnection>;
+    reconnect(sshConfigHost: string, name: string, userInitiated?: boolean): Promise<ISSHAgentHostConnection>;
 }
 /**
 * Main-process service that performs the actual SSH work.
@@ -80,7 +86,7 @@ export interface ISSHRemoteAgentHostMainService {
     * Fires when the SSH server requests keyboard-interactive auth (typically
     * a password prompt). The renderer must answer via {@link respondKeyboardInteractive}
     * with the same `requestId`, otherwise the auth attempt will hang until the
-    * SSH `readyTimeout` elapses.
+    * SSH handshake deadline elapses.
     */
     readonly onDidRequestKeyboardInteractive: Event<ISSHKeyboardInteractiveRequest>;
     /**
@@ -96,6 +102,51 @@ export interface ISSHRemoteAgentHostMainService {
     */
     respondKeyboardInteractive(requestId: string, responses: readonly string[] | undefined): Promise<void>;
     /**
+    * Fires when connect() discovers at least one live `editor`-owned
+    * endpoint on the remote and needs the renderer to choose which
+    * live endpoint (or "spawn new") to connect to. The renderer must
+    * answer via {@link respondEndpointSelection} with the same `requestId`.
+    */
+    readonly onDidRequestEndpointSelection: Event<ISSHEndpointSelectionRequest>;
+    /**
+    * Fires when a previously requested endpoint selection is no longer
+    * needed (e.g. the owning connect attempt failed or was aborted). The
+    * renderer should dismiss any picker UI it opened for `requestId`.
+    */
+    readonly onDidCancelEndpointSelection: Event<string>;
+    /**
+    * Provide the user's answer to a previously fired endpoint-selection
+    * request. Pass `undefined` when the user cancels the picker; this
+    * aborts the owning connect attempt with a cancellation error.
+    */
+    respondEndpointSelection(requestId: string, selection: ISSHEndpointSelection | undefined): Promise<void>;
+    /**
+    * Fires when a server presents a host key during key exchange and the
+    * renderer must decide whether to trust it. Answering is mandatory: until
+    * {@link respondHostKeyVerification} is called with the same `requestId`,
+    * the SSH handshake is suspended.
+    */
+    readonly onDidRequestHostKeyVerification: Event<ISSHHostKeyVerificationRequest>;
+    /**
+    * Fires when a previously requested host key verification is no longer
+    * needed (e.g. the owning connect attempt failed or was aborted). The
+    * renderer should dismiss any UI it opened for `requestId`.
+    */
+    readonly onDidCancelHostKeyVerification: Event<string>;
+    /**
+    * Provide the user's trust decision for a previously fired host key
+    * verification request. Passing `false` fails the key exchange, which
+    * tears the connection down before any authentication is attempted.
+    */
+    respondHostKeyVerification(requestId: string, trusted: boolean): Promise<void>;
+    /**
+    * Fires when a server announces its full set of host keys over an
+    * already-authenticated connection. See {@link ISSHHostKeysAnnouncement} —
+    * these keys are cryptographically proven, so consumers can persist them
+    * without prompting.
+    */
+    readonly onDidAnnounceHostKeys: Event<ISSHHostKeysAnnouncement>;
+    /**
     * Bootstrap a remote agent host over SSH. Returns serializable
     * connection info for the renderer to register.
     */
@@ -123,6 +174,12 @@ export interface ISSHRemoteAgentHostMainService {
     * 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.
+    *
+    * @param userInitiated See {@link ISSHAgentHostConfig.userInitiated}.
+    * Defaults to `true` (picker-eligible) when omitted.
+    * @param preferredAgentLocation See {@link ISSHAgentHostConfig.preferredAgentLocation}.
+    * The renderer computes this from its stored preference for this host's
+    * {@link computeSSHConnectionKey stable key} before calling reconnect.
     */
-    reconnect(sshConfigHost: string, name: string, remoteAgentHostCommand?: string, agentForward?: boolean): Promise<ISSHConnectResult>;
+    reconnect(sshConfigHost: string, name: string, remoteAgentHostCommand?: string, agentForward?: boolean, userInitiated?: boolean, preferredAgentLocation?: RemoteAgentHostLocationPreference): Promise<ISSHConnectResult>;
 }

package/vscode/src/vs/platform/agentHost/common/state/legacyProtocolCompatibility.d.ts

@@ -0,0 +1,30 @@
+import { type ActionEnvelope, type ChatErrorAction, type StateAction } from "./protocol/actions.js";
+import { type ChatState, type ErrorInfo, type Turn } from "./protocol/state.js";
+interface ILegacyChatErrorAction extends Omit<ChatErrorAction, "part"> {
+    readonly error: ErrorInfo;
+}
+type CompatibleTurn = Turn | (Turn & {
+    readonly error: ErrorInfo;
+});
+type CompatibleActionEnvelope = Omit<ActionEnvelope, "action"> & {
+    readonly action: StateAction | ILegacyChatErrorAction;
+};
+/**
+ * Reads the top-level error field emitted by AHP hosts before durable error
+ * response parts were introduced.
+ */
+export declare function readLegacyTurnError(turn: CompatibleTurn): ErrorInfo | undefined;
+/**
+ * Moves a legacy completed-turn error into its durable response-part position.
+ */
+export declare function normalizeLegacyTurnError(turn: CompatibleTurn): Turn;
+/**
+ * Normalizes legacy completed-turn errors in a chat snapshot.
+ */
+export declare function normalizeLegacyChatStateErrors(state: ChatState): ChatState;
+/**
+ * Normalizes legacy error payloads before a server action reaches reducers or
+ * action observers.
+ */
+export declare function normalizeLegacyActionEnvelope(envelope: CompatibleActionEnvelope): ActionEnvelope;
+export {};

package/vscode/src/vs/platform/agentHost/common/state/legacyProtocolCompatibility.js

@@ -0,0 +1,95 @@
+
+import { hasKey } from '../../../../base/common/types.js';
+import { ActionType } from './protocol/common/actions.js';
+import './protocol/channels-root/state.js';
+import './protocol/channels-session/state.js';
+import { TurnState, ResponsePartKind } from './protocol/channels-chat/state.js';
+import './protocol/channels-terminal/state.js';
+import './protocol/channels-changeset/state.js';
+import './protocol/channels-resource-watch/state.js';
+import './protocol/channels-automation/state.js';
+import './protocol/channels-automation-run/state.js';
+
+function readLegacyTurnError(turn) {
+    if (!hasKey(turn, {
+        error: true
+    })) {
+        return undefined;
+    }
+    return turn.error;
+}
+function normalizeLegacyTurnError(turn) {
+    if (turn.state !== TurnState.Error || !hasKey(turn, {
+        error: true
+    })) {
+        return turn;
+    }
+    const {
+        error,
+        ...normalizedTurn
+    } = turn;
+    const finalPart = turn.responseParts[turn.responseParts.length - 1];
+    return {
+        ...normalizedTurn,
+        responseParts: finalPart?.kind === ResponsePartKind.Error ? turn.responseParts : [...turn.responseParts, {
+            kind: ResponsePartKind.Error,
+            error
+        }]
+    };
+}
+function normalizeLegacyChatStateErrors(state) {
+    const turns = ( state.turns.map(normalizeLegacyTurnError));
+    return ( turns.some((turn, index) => turn !== state.turns[index])) ? {
+        ...state,
+        turns
+    } : state;
+}
+function normalizeLegacyActionEnvelope(envelope) {
+    const action = envelope.action;
+    switch (action.type) {
+    case ActionType.ChatError:
+        if (hasKey(action, {
+            error: true
+        })) {
+            const {
+                error,
+                ...normalizedAction
+            } = action;
+            return {
+                ...envelope,
+                action: {
+                    ...normalizedAction,
+                    part: {
+                        kind: ResponsePartKind.Error,
+                        error
+                    }
+                }
+            };
+        }
+        return {
+            ...envelope,
+            action
+        };
+    case ActionType.ChatTurnsLoaded:
+        {
+            const turns = ( action.turns.map(normalizeLegacyTurnError));
+            return ( turns.some((turn, index) => turn !== action.turns[index])) ? {
+                ...envelope,
+                action: {
+                    ...action,
+                    turns
+                }
+            } : {
+                ...envelope,
+                action
+            };
+        }
+    default:
+        return {
+            ...envelope,
+            action
+        };
+    }
+}
+
+export { normalizeLegacyActionEnvelope, normalizeLegacyChatStateErrors, normalizeLegacyTurnError, readLegacyTurnError };

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

@@ -1,4 +1,4 @@
-import { type StateAction, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type RootTerminalsChangedAction, type RootConfigChangedAction, type SessionReadyAction, type SessionCreationFailedAction, type SessionChatAddedAction, type SessionChatRemovedAction, type SessionChatUpdatedAction, type SessionDefaultChatChangedAction, type SessionTitleChangedAction, type SessionServerToolsChangedAction, type SessionActiveClientSetAction, type SessionActiveClientRemovedAction, type SessionInputNeededSetAction, type SessionInputNeededRemovedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionCustomizationUpdatedAction, type SessionCustomizationRemovedAction, type SessionMcpServerStateChangedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionActivityChangedAction, type SessionChangesetsChangedAction, type SessionConfigChangedAction, type SessionMetaChangedAction, type ChatTurnStartedAction, type ChatDeltaAction, type ChatResponsePartAction, type ChatToolCallStartAction, type ChatToolCallDeltaAction, type ChatToolCallReadyAction, type ChatToolCallConfirmedAction, type ChatToolCallCompleteAction, type ChatToolCallResultConfirmedAction, type ChatToolCallContentChangedAction, type ChatTurnCompleteAction, type ChatTurnCancelledAction, type ChatErrorAction, type ChatActivityChangedAction, type ChatUsageAction, type ChatReasoningAction, type ChatPendingMessageSetAction, type ChatPendingMessageRemovedAction, type ChatQueuedMessagesReorderedAction, type ChatDraftChangedAction, type ChatInputRequestedAction, type ChatInputAnswerChangedAction, type ChatInputCompletedAction, type ChatTruncatedAction, type ChangesetStatusChangedAction, type ChangesetFileSetAction, type ChangesetFileRemovedAction, type ChangesetContentChangedAction, type ChangesetOperationsChangedAction, type ChangesetOperationStatusChangedAction, type ChangesetClearedAction, type AnnotationsSetAction, type AnnotationsUpdatedAction, type AnnotationsRemovedAction, type AnnotationsEntrySetAction, type AnnotationsEntryRemovedAction, type TerminalDataAction, type TerminalInputAction, type TerminalResizedAction, type TerminalClaimedAction, type TerminalTitleChangedAction, type TerminalCwdChangedAction, type TerminalExitedAction, type TerminalClearedAction, type TerminalCommandDetectionAvailableAction, type TerminalCommandExecutedAction, type TerminalCommandFinishedAction, type ResourceWatchChangedAction } from "./actions.js";
+import { type StateAction, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type RootTerminalsChangedAction, type RootConfigChangedAction, type SessionReadyAction, type SessionCreationFailedAction, type SessionChatAddedAction, type SessionChatRemovedAction, type SessionChatUpdatedAction, type SessionDefaultChatChangedAction, type SessionTitleChangedAction, type SessionServerToolsChangedAction, type SessionActiveClientSetAction, type SessionActiveClientRemovedAction, type SessionWorkingDirectorySetAction, type SessionWorkingDirectoryRemovedAction, type SessionWorkingDirectoryReplacedAction, type SessionInputNeededSetAction, type SessionInputNeededRemovedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionCustomizationUpdatedAction, type SessionCustomizationRemovedAction, type SessionMcpServerStateChangedAction, type SessionMcpServerStartRequestedAction, type SessionMcpServerStopRequestedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionActivityChangedAction, type SessionChangesetsChangedAction, type SessionConfigChangedAction, type SessionMetaChangedAction, type ChatTurnStartedAction, type ChatDeltaAction, type ChatResponsePartAction, type ChatToolCallStartAction, type ChatToolCallDeltaAction, type ChatToolCallReadyAction, type ChatToolCallConfirmedAction, type ChatToolCallCompleteAction, type ChatToolCallResultConfirmedAction, type ChatToolCallContentChangedAction, type ChatToolCallAuthRequiredAction, type ChatToolCallAuthResolvedAction, type ChatTurnCompleteAction, type ChatTurnCancelledAction, type ChatErrorAction, type ChatTurnResumeAction, type ChatActivityChangedAction, type ChatWorkingDirectorySetAction, type ChatWorkingDirectoryRemovedAction, type ChatUsageAction, type ChatReasoningAction, type ChatPendingMessageSetAction, type ChatPendingMessageRemovedAction, type ChatQueuedMessagesReorderedAction, type ChatDraftChangedAction, type ChatInputRequestedAction, type ChatInputAnswerChangedAction, type ChatInputCompletedAction, type ChatTruncatedAction, type ChatTurnsLoadedAction, type ChangesetStatusChangedAction, type ChangesetFileSetAction, type ChangesetFileRemovedAction, type ChangesetFilesReviewChangedAction, type ChangesetContentChangedAction, type ChangesetOperationsChangedAction, type ChangesetOperationStatusChangedAction, type ChangesetClearedAction, type AnnotationsSetAction, type AnnotationsUpdatedAction, type AnnotationsRemovedAction, type AnnotationsEntrySetAction, type AnnotationsEntryRemovedAction, type TerminalDataAction, type TerminalInputAction, type TerminalResizedAction, type TerminalClaimedAction, type TerminalTitleChangedAction, type TerminalCwdChangedAction, type TerminalExitedAction, type TerminalClearedAction, type TerminalCommandDetectionAvailableAction, type TerminalCommandExecutedAction, type TerminalCommandFinishedAction, type ResourceWatchChangedAction, type AutomationCreateRequestedAction, type AutomationUpdateRequestedAction, type AutomationSetAction, type AutomationRemovedAction, type AutomationRunLifecycleChangedAction, type AutomationRunSessionSetAction, type AutomationRunSessionRemovedAction, type AutomationRunPrimarySessionChangedAction, type AutomationRunCancelRequestedAction } from "./actions.js";
 /** Union of all root-scoped actions. */
 export type RootAction = RootAgentsChangedAction | RootActiveSessionsChangedAction | RootTerminalsChangedAction | RootConfigChangedAction;
 /** Union of root actions that clients may dispatch. */
@@ -6,17 +6,17 @@ export type ClientRootAction = RootConfigChangedAction;
 /** Union of root actions that only the server may produce. */
 export type ServerRootAction = RootAgentsChangedAction | RootActiveSessionsChangedAction | RootTerminalsChangedAction;
 /** Union of all session-scoped actions. */
-export type SessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionDefaultChatChangedAction | SessionTitleChangedAction | SessionServerToolsChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationToggledAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionConfigChangedAction | SessionMetaChangedAction;
+export type SessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionDefaultChatChangedAction | SessionTitleChangedAction | SessionServerToolsChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionWorkingDirectorySetAction | SessionWorkingDirectoryRemovedAction | SessionWorkingDirectoryReplacedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationToggledAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionMcpServerStartRequestedAction | SessionMcpServerStopRequestedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionConfigChangedAction | SessionMetaChangedAction;
 /** Union of session actions that clients may dispatch. */
-export type ClientSessionAction = SessionTitleChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionCustomizationToggledAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionConfigChangedAction;
+export type ClientSessionAction = SessionTitleChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionWorkingDirectorySetAction | SessionWorkingDirectoryRemovedAction | SessionWorkingDirectoryReplacedAction | SessionCustomizationToggledAction | SessionMcpServerStartRequestedAction | SessionMcpServerStopRequestedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionConfigChangedAction;
 /** Union of session actions that only the server may produce. */
 export type ServerSessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionDefaultChatChangedAction | SessionServerToolsChangedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionMetaChangedAction;
 /** Union of all chat-scoped actions. */
-export type ChatAction = ChatTurnStartedAction | ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatTurnCompleteAction | ChatTurnCancelledAction | ChatErrorAction | ChatActivityChangedAction | ChatUsageAction | ChatReasoningAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputRequestedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction;
+export type ChatAction = ChatTurnStartedAction | ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatToolCallAuthRequiredAction | ChatToolCallAuthResolvedAction | ChatTurnCompleteAction | ChatTurnCancelledAction | ChatErrorAction | ChatTurnResumeAction | ChatActivityChangedAction | ChatWorkingDirectorySetAction | ChatWorkingDirectoryRemovedAction | ChatUsageAction | ChatReasoningAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputRequestedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction | ChatTurnsLoadedAction;
 /** Union of chat actions that clients may dispatch. */
-export type ClientChatAction = ChatTurnStartedAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatTurnCancelledAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction;
+export type ClientChatAction = ChatTurnStartedAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatTurnCancelledAction | ChatTurnResumeAction | ChatWorkingDirectorySetAction | ChatWorkingDirectoryRemovedAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction;
 /** Union of chat actions that only the server may produce. */
-export type ServerChatAction = ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatTurnCompleteAction | ChatErrorAction | ChatActivityChangedAction | ChatUsageAction | ChatReasoningAction | ChatInputRequestedAction;
+export type ServerChatAction = ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallAuthRequiredAction | ChatToolCallAuthResolvedAction | ChatTurnCompleteAction | ChatErrorAction | ChatActivityChangedAction | ChatUsageAction | ChatReasoningAction | ChatInputRequestedAction | ChatTurnsLoadedAction;
 /** Union of all terminal-scoped actions. */
 export type TerminalAction = TerminalDataAction | TerminalInputAction | TerminalResizedAction | TerminalClaimedAction | TerminalTitleChangedAction | TerminalCwdChangedAction | TerminalExitedAction | TerminalClearedAction | TerminalCommandDetectionAvailableAction | TerminalCommandExecutedAction | TerminalCommandFinishedAction;
 /** Union of terminal actions that clients may dispatch. */
@@ -24,9 +24,9 @@ export type ClientTerminalAction = TerminalInputAction | TerminalResizedAction |
 /** Union of terminal actions that only the server may produce. */
 export type ServerTerminalAction = TerminalDataAction | TerminalCwdChangedAction | TerminalExitedAction | TerminalCommandDetectionAvailableAction | TerminalCommandExecutedAction | TerminalCommandFinishedAction;
 /** Union of all changeset-scoped actions. */
-export type ChangesetAction = ChangesetStatusChangedAction | ChangesetFileSetAction | ChangesetFileRemovedAction | ChangesetContentChangedAction | ChangesetOperationsChangedAction | ChangesetOperationStatusChangedAction | ChangesetClearedAction;
+export type ChangesetAction = ChangesetStatusChangedAction | ChangesetFileSetAction | ChangesetFileRemovedAction | ChangesetFilesReviewChangedAction | ChangesetContentChangedAction | ChangesetOperationsChangedAction | ChangesetOperationStatusChangedAction | ChangesetClearedAction;
 /** Union of changeset actions that clients may dispatch. */
-export type ClientChangesetAction = never;
+export type ClientChangesetAction = ChangesetFilesReviewChangedAction;
 /** Union of changeset actions that only the server may produce. */
 export type ServerChangesetAction = ChangesetStatusChangedAction | ChangesetFileSetAction | ChangesetFileRemovedAction | ChangesetContentChangedAction | ChangesetOperationsChangedAction | ChangesetOperationStatusChangedAction | ChangesetClearedAction;
 /** Union of all annotations-scoped actions. */
@@ -41,6 +41,18 @@ export type ResourceWatchAction = ResourceWatchChangedAction;
 export type ClientResourceWatchAction = never;
 /** Union of resource-watch actions that only the server may produce. */
 export type ServerResourceWatchAction = ResourceWatchChangedAction;
+/** Union of all automation-scoped actions. */
+export type AutomationAction = AutomationCreateRequestedAction | AutomationUpdateRequestedAction | AutomationSetAction | AutomationRemovedAction;
+/** Union of automation actions that clients may dispatch. */
+export type ClientAutomationAction = AutomationCreateRequestedAction | AutomationUpdateRequestedAction | AutomationRemovedAction;
+/** Union of automation actions that only the server may produce. */
+export type ServerAutomationAction = AutomationSetAction;
+/** Union of all automation-run-scoped actions. */
+export type AutomationRunAction = AutomationRunLifecycleChangedAction | AutomationRunSessionSetAction | AutomationRunSessionRemovedAction | AutomationRunPrimarySessionChangedAction | AutomationRunCancelRequestedAction;
+/** Union of automation-run actions that clients may dispatch. */
+export type ClientAutomationRunAction = AutomationRunCancelRequestedAction;
+/** Union of automation-run actions that only the server may produce. */
+export type ServerAutomationRunAction = AutomationRunLifecycleChangedAction | AutomationRunSessionSetAction | AutomationRunSessionRemovedAction | AutomationRunPrimarySessionChangedAction;
 /**
  * Exhaustive map indicating which action types may be dispatched by clients.
  * Adding a new action to StateAction without adding it here is a compile error.

package/vscode/src/vs/platform/agentHost/common/state/protocol/actions.d.ts

@@ -6,3 +6,5 @@ export * from "./channels-terminal/actions.js";
 export * from "./channels-changeset/actions.js";
 export * from "./channels-annotations/actions.js";
 export * from "./channels-resource-watch/actions.js";
+export * from "./channels-automation/actions.js";
+export * from "./channels-automation-run/actions.js";

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-annotations/actions.d.ts

@@ -1,6 +1,6 @@
 import { ActionType } from "../common/actions.js";
 import type { URI, TextRange } from "../common/state.js";
-import type { AnnotationEntry, Annotation } from "./state.js";
+import type { AnnotationEntry, Annotation, AnnotationOrigin } from "./state.js";
 /**
  * Upsert an {@link Annotation} in the annotations channel — adds a new
  * annotation, or replaces an existing one identified by
@@ -50,12 +50,8 @@ export interface AnnotationsUpdatedAction {
     type: ActionType.AnnotationsUpdated;
     /** The {@link Annotation.id} of the annotation to update. */
     annotationId: string;
-    /**
-     * Re-anchors the annotation to the file versions this turn produced.
-     * Matches a {@link Turn.id} on the owning session. Omit to leave the
-     * current {@link Annotation.turnId} unchanged.
-     */
-    turnId?: string;
+    /** Replaces the annotation's provenance. Omit to leave it unchanged. */
+    origin?: AnnotationOrigin;
     /**
      * Re-anchors the annotation to this file. Omit to leave the current
      * {@link Annotation.resource} unchanged.