@codingame/monaco-vscode-chat-service-override 36.2.6 → 37.0.0

package/vscode/src/vs/platform/agentHost/browser/{remoteAgentHostProtocolClient.d.ts → agentHostProtocolClient.d.ts}

@@ -1,30 +1,44 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
-import { IAgentConnection, IAgentCreateChatOptions, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, AuthenticateParams, AuthenticateResult, IMcpNotification } from "../common/agentService.js";
+import { IAgentCreateChatRequestOptions, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, AuthenticateParams, AuthenticateResult, IMcpNotification } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent";
+import { IAgentConnection, IAgentHostManagedSettingsDiagnostics, IAgentHostNetworkDiagnosticsInfo, IAgentHostNetworkFetchResult, type AgentHostDebugLogsArtifactKind, type IAgentHostDebugLogsArtifact, type IAgentHostDebugLogsChunk } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
 import { type IRemoteWatchHandle } from "../common/agentHostFileSystemProvider.js";
 import { type IActiveSubscriptionInfo, type IAgentSubscription } from "../common/state/agentSubscription.js";
+import { type IAgentHostResourceUriMapper } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri";
+import { AgentHostResourceIdentity } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService";
 import { IAgentHostResourceService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService.service";
 import type { CommandMap } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/messages";
-import { type ActionEnvelope, type IRootConfigChangedAction, type SessionAction, type TerminalAction, type ClientAnnotationsAction } from "../common/state/sessionActions.js";
+import { type ActionEnvelope, type ChatAction, type ClientAnnotationsAction, type ClientAutomationAction, type ClientAutomationRunAction, type ClientChangesetAction, type IRootConfigChangedAction, type SessionAction, type TerminalAction } from "../common/state/sessionActions.js";
 import { StateComponents, type RootState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
-import { type IStateSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
+import { ProtocolError, type IStateSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
 import { type IVscodeUpgradeResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocolUpgrade";
-import { type IProtocolTransport } from "../common/state/sessionTransport.js";
-import { type CompletionsParams, type CompletionsResult, type CreateTerminalParams, type ResolveSessionConfigResult, type SessionConfigCompletionsResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { type AgentHostTransportFailureReason, type IProtocolTransport } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionTransport";
+import { ContentEncoding, type CompletionsParams, type CompletionsResult, type CreateTerminalParams, type ResolveSessionConfigResult, type SessionConfigCompletionsResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
 import type { InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands";
+import type { FetchAutomationRunsParams, FetchAutomationRunsResult, ListAutomationTriggerDefinitionsParams, ListAutomationTriggerDefinitionsResult, RunAutomationParams, RunAutomationResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/commands";
 import { ILoadEstimator } from "@codingame/monaco-vscode-api/vscode/vs/base/parts/ipc/common/ipc.net";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import type { OtlpExportLogsParams } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-otlp/notifications";
-import type { InitializeResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands";
+import type { Implementation, InitializeResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands";
+import { type IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { type IRemoteAgentHostReconnectPolicy } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/reconnectPolicy";
+import type { IRemoteAgentHostProtocolClient } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService";
+import { IWorkspaceTrustRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IWorkspaceTrustEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
 /**
- * High-level connection state of a {@link RemoteAgentHostProtocolClient}.
- * Exposed via {@link RemoteAgentHostProtocolClient.onDidChangeConnectionState}
+ * High-level connection state of an {@link AgentHostProtocolClient}.
+ * Exposed via {@link AgentHostProtocolClient.onDidChangeConnectionState}
  * so consumers can surface transient reconnect activity in the UI.
  */
 export declare enum AgentHostClientState {
     /** Initial handshake in progress. */
     Connecting = "connecting",
+    /** The host rejected the initial protocol version; upgrade remains available. */
+    Incompatible = "incompatible",
     /** Transport is open and handshake/reconnect has completed. */
     Connected = "connected",
     /** Transport closed unexpectedly; an automatic reconnect is in flight or scheduled. */
@@ -32,26 +46,49 @@ export declare enum AgentHostClientState {
     /** Client has been disposed or has given up reconnecting. Terminal state. */
     Closed = "closed"
 }
+/** Optional configuration for an {@link AgentHostProtocolClient}. */
+export interface IAgentHostProtocolClientOptions {
+    /** Estimator used to suppress watchdog closes while the local event loop is saturated. Defaults to the shared instance. */
+    readonly loadEstimator?: ILoadEstimator;
+    /** Stable client identity. Generated when omitted. */
+    readonly clientId?: string;
+    /** Client implementation metadata advertised during the handshake. */
+    readonly clientInfo?: Implementation;
+    /** How a dropped transport is restored. Defaults to {@link DEFAULT_RECONNECT_POLICY}. */
+    readonly reconnectPolicy?: IRemoteAgentHostReconnectPolicy;
+    /** Resolves authentication to restore immediately after every fresh initialize. */
+    readonly resolveInitialAuthentication?: () => Promise<AuthenticateParams | undefined>;
+}
+/** An initial authentication resolver failed after a successful initialize. */
+export declare class InitialAuthenticationError extends Error {
+    constructor(error: unknown);
+}
 /**
- * A protocol-level client for a single remote agent host connection.
- * Manages the WebSocket transport, handshake, subscriptions, action dispatch,
+ * A protocol-level client for a single agent host connection.
+ * Manages the transport, handshake, subscriptions, action dispatch,
  * and command/response correlation.
  *
  * Implements {@link IAgentConnection} so consumers can program against
  * a single interface regardless of whether the agent host is local or remote.
  */
-export declare class RemoteAgentHostProtocolClient extends Disposable implements IAgentConnection {
+export declare class AgentHostProtocolClient extends Disposable implements IAgentConnection, IRemoteAgentHostProtocolClient {
     private readonly _logService;
     private readonly _resourceService;
     private readonly _configurationService;
+    private readonly _telemetryService;
+    private readonly _workspaceTrustEnablementService;
+    private readonly _workspaceTrustManagementService;
+    private readonly _workspaceTrustRequestService;
     readonly _serviceBrand: undefined;
     private readonly _clientId;
     private readonly _address;
+    private readonly _resourceIdentity;
     private readonly _transportFactory;
     private _transport;
     /** Disposable holding the listeners attached to the current transport. */
     private readonly _transportListeners;
     private readonly _connectionAuthority;
+    readonly resourceUris: IAgentHostResourceUriMapper;
     private _serverSeq;
     private _nextClientSeq;
     private _defaultDirectory;
@@ -60,14 +97,14 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      * {@link connect} and re-captured after a soft-reconnect that pulled
      * a fresh snapshot. `undefined` before the handshake completes.
      */
-    private _initializeResult;
+    private readonly _initializeResult;
     private readonly _subscriptionManager;
     private readonly _onDidAction;
-    readonly onDidAction: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ActionEnvelope>;
+    readonly onDidAction: Event<ActionEnvelope>;
     private readonly _onDidNotification;
-    readonly onDidNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<import("../common/state/sessionActions.js").ProtocolNotification>;
+    readonly onDidNotification: Event<import("../common/state/sessionActions.js").ProtocolNotification>;
     private readonly _onMcpNotification;
-    readonly onMcpNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<IMcpNotification>;
+    readonly onMcpNotification: Event<IMcpNotification>;
     /**
      * Fires for every `otlp/exportLogs` notification the host sends on a
      * channel this client has subscribed to. Each payload is an
@@ -80,21 +117,62 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      * subscribers should filter by `channel` if they care.
      */
     private readonly _onDidReceiveOtlpLogs;
-    readonly onDidReceiveOtlpLogs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<OtlpExportLogsParams>;
+    readonly onDidReceiveOtlpLogs: Event<OtlpExportLogsParams>;
     private readonly _onDidClose;
-    readonly onDidClose: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    readonly onDidClose: Event<AgentHostTransportFailureReason | undefined>;
+    private readonly _onDidFatalClose;
+    readonly onDidFatalClose: Event<ProtocolError>;
     private readonly _onDidChangeConnectionState;
-    readonly onDidChangeConnectionState: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<AgentHostClientState>;
+    readonly onDidChangeConnectionState: Event<AgentHostClientState>;
+    private readonly _onDidScheduleReconnect;
+    readonly onDidScheduleReconnect: Event<void>;
     /**
      * Discriminated state union. Read via narrowing (`_state.kind === ...`);
      * reconnect-only fields like the gate/outbox/attempt counter are only
      * accessible while {@link _state.kind} is {@link AgentHostClientState.Reconnecting},
-     * and the close error is only accessible while it's {@link AgentHostClientState.Closed}.
+     * and protocol errors are only accessible while the state is
+     * {@link AgentHostClientState.Incompatible} or {@link AgentHostClientState.Closed}.
      */
     private _state;
     /** Pending JSON-RPC requests keyed by request id. */
     private readonly _pendingRequests;
+    private readonly _authentication;
     private _nextRequestId;
+    /**
+    /**
+     * Reverse requests awaiting a response, scoped to their incoming transport.
+     * An active count proves the host is waiting for client work rather than
+     * being silently dead.
+     */
+    private readonly _pendingReverseRequests;
+    /**
+     * Whether a liveness close has been deferred while the client was unable to
+     * receive traffic from the host.
+     */
+    private _livenessDeferred;
+    private _livenessDeferredSince;
+    /**
+     * Channels that owe a fresh snapshot because the host forgot this client
+     * (a host restart) and the fresh initialize did not carry their state.
+     * Entries persist across reconnect attempts until the channel is
+     * re-subscribed: a later `reconnect` resolves against the *new* host's
+     * sequence and can legitimately answer with a `replay`, which carries
+     * deltas only — so a channel dropped from this set before it was
+     * re-snapshotted would keep serving pre-restart state forever.
+     */
+    private readonly _subscriptionsAwaitingRestore;
+    /**
+     * Set while an authentication-restore pass is in flight, cleared only once
+     * the whole pass completes.
+     *
+     * Authentication state on the host is process-global and survives a
+     * transport drop, so an ordinary reconnect needs no re-authentication. But
+     * a drop *during* the restore pass leaves the host holding whichever
+     * credentials happened to arrive first, and the next reconnect usually
+     * resolves to a `replay` — which never re-runs authentication. This flag
+     * carries that debt forward so the next successful attempt finishes it.
+     */
+    private _authenticationRestorePending;
     /**
      * Timestamp of the most recent message of any kind received from the
      * server. Used only for diagnostic logging when the close timer fires.
@@ -107,9 +185,12 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      * silence and sends an application-level `ping` so we have something
      * to time out on. {@link _closeTimer} fires after another
      * {@link LIVENESS_TIMEOUT_MS} of continued silence and force-closes
-     * the transport so the renderer's reconnect logic kicks in. Both are
-     * reset on every received message, so busy connections generate no
-     * ping traffic at all.
+     * the transport so the renderer's reconnect logic kicks in. If the host
+     * has an unanswered reverse request or the local event loop has high load,
+     * both timers re-arm instead. Once the deferral clears, it grants a full
+     * liveness window before closing.
+     * Both are reset on every received message, so busy connections generate
+     * no ping traffic at all.
      *
      * Detects silently-dead transports (e.g. SSH/tunnel after laptop
      * sleep + network change) that don't produce a socket close event of
@@ -124,25 +205,29 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      * reconnect cycle that aborts in-flight requests.
      */
     private readonly _loadEstimator;
+    private readonly _clientInfo;
+    private readonly _reconnectPolicy;
+    private readonly _resolveInitialAuthentication;
     /**
-     * Comparison keys of customization URIs we have already granted implicit
-     * read access for on this connection. Dedupes repeat sends so we don't
-     * pile up grants per dispatch. Cleared with the connection.
+     * URIs we have already granted implicit read access for on this connection.
+     * Uses URI-aware comparison to dedupe repeat sends and is cleared with the connection.
      */
-    private readonly _grantedCustomizationUris;
+    private readonly _grantedImplicitReadUris;
+    private readonly _implicitReadGrants;
     get clientId(): string;
     get address(): string;
     get defaultDirectory(): string | undefined;
     get connectionState(): AgentHostClientState;
+    /** Deadline for the next scheduled reconnect attempt, if one is pending. */
+    get nextReconnectAt(): number | undefined;
     /**
      * The latest `initialize` response from the host, or `undefined` if
-     * the handshake has not completed yet. Callers read fields they care
-     * about (e.g. `telemetry`, `completionTriggerCharacters`,
-     * `defaultDirectory`) directly off this object — keeping the result
-     * intact avoids adding a new getter every time the protocol grows.
+     * the handshake has not completed yet. Exposed observably so callers can
+     * react as advertised capabilities (telemetry, `completionTriggerCharacters`,
+     * `terminalCommandPrefix`, ...) arrive.
      */
-    get initializeResult(): InitializeResult | undefined;
-    constructor(address: string, transportOrFactory: IProtocolTransport | (() => IProtocolTransport), loadEstimator: ILoadEstimator | undefined, _logService: ILogService, _resourceService: IAgentHostResourceService, _configurationService: IConfigurationService);
+    get initializeResult(): IObservable<InitializeResult | undefined>;
+    constructor(identity: AgentHostResourceIdentity, transportOrFactory: IProtocolTransport | (() => IProtocolTransport), options: IAgentHostProtocolClientOptions | undefined, _logService: ILogService, _resourceService: IAgentHostResourceService, _configurationService: IConfigurationService, _telemetryService: ITelemetryService, _workspaceTrustEnablementService: IWorkspaceTrustEnablementService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _workspaceTrustRequestService: IWorkspaceTrustRequestService);
     /**
      * Install a transport and wire listeners. Used both for the initial
      * transport and for replacements created by the factory during a
@@ -185,8 +270,58 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      * and let the service decide whether to spin up a fresh client.
      */
     private _handleTransportClose;
+    private _beginReconnectFromConnecting;
+    /**
+     * Reopens a terminal connection after its host has been explicitly restarted.
+     */
+    reconnectFromClosed(): boolean;
+    /**
+     * Skips the remaining backoff and retries immediately. Returns `false` when
+     * there is no pending retry to accelerate.
+     */
+    reconnectNow(): boolean;
     private _scheduleReconnect;
     private _attemptReconnect;
+    private _reconnectOrInitialize;
+    /**
+     * Record every active subscription the fresh initialize did not carry a
+     * snapshot for. The host forgot this client, so those channels still hold
+     * state produced by the previous host process and cannot be trusted until
+     * they have been re-subscribed. Rebuilt from scratch so a channel the
+     * host has since snapshotted stops being re-requested.
+     */
+    private _markSubscriptionsAwaitingRestore;
+    /**
+     * Re-subscribe every channel recorded by
+     * {@link _markSubscriptionsAwaitingRestore} so it is reseated with state
+     * from the current host process.
+     *
+     * A channel leaves the set once it has a fresh snapshot, the server
+     * reported it missing, or it is no longer subscribed. A dropped transport
+     * deliberately leaves the remaining entries in place so the next reconnect
+     * finishes the job — that reconnect may well be answered with a `replay`,
+     * which would otherwise never deliver the snapshot these channels need.
+     */
+    private _restoreSubscriptionsAwaitingRestore;
+    private _restoreAuthenticationAfterFreshInitialize;
+    private _clientMeta;
+    private _applyInitializeResult;
+    /**
+     * Push the renderer-owned config values the host mirrors (telemetry level,
+     * proxy discovery, migrate flag, …) as `RootConfigChanged` actions. Called on
+     * initial connect AND on reconnect: a reconnected host may be a freshly
+     * restarted process (or one that lost these values), and re-pushing is a cheap
+     * no-op when nothing changed. Without this, a value read early — like the
+     * migrate flag in `listSessions` — can be missing after a window reload.
+     *
+     * Most settings arrive here declaratively, via `agentHost` on their
+     * configuration schema. The explicit calls below cover the cases a single
+     * key-plus-transform can't express: values derived from several settings, and
+     * settings contributed by an extension rather than by core.
+     */
+    private _forwardClientConfig;
+    private _updateAutoApprovePolicyRestriction;
+    private _updateWorkspaceTrust;
     /**
      * Apply a `reconnect` RPC result to the subscription manager. On `replay`
      * we feed each missed envelope through the normal action path; on
@@ -199,7 +334,7 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      *
      * 1. Resend pending optimistic session actions that the server did NOT
      *    echo back in the replay buffer (i.e. anything still on
-     *    {@link AgentSubscriptionManager.getPendingSessionActions}).
+     *    {@link AgentSubscriptionManager.getPendingActions}).
      * 2. Flush every message that {@link _sendNotification} queued onto the
      *    outbox while the gate was engaged.
      *
@@ -212,8 +347,9 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
     getSubscription<T>(kind: StateComponents, resource: URI, owner: string): IReference<IAgentSubscription<T>>;
     getSubscriptionUnmanaged<T>(_kind: StateComponents, resource: URI): IAgentSubscription<T> | undefined;
     getInflightSessionCreate(resource: URI): Promise<unknown> | undefined;
+    trackSessionCreate(resource: URI, promise: Promise<unknown>): void;
     getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
-    dispatch(channel: string, action: SessionAction | TerminalAction | ClientAnnotationsAction | IRootConfigChangedAction): void;
+    dispatch(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientChangesetAction | ClientAnnotationsAction | ClientAutomationAction | ClientAutomationRunAction | IRootConfigChangedAction): void;
     /**
      * Subscribe to state at a URI. Returns the current state snapshot.
      *
@@ -246,9 +382,21 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      * Create a new session on the remote agent host.
      */
     createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    removeSessionArtifact(session: URI, artifactId: string): Promise<void>;
+    createDetachedWorktree(session: URI, prompt: string): Promise<{
+        handle: string;
+        worktree: URI;
+    }>;
+    setDetachedWorktreeArchived(handle: string, archived: boolean): Promise<void>;
+    claimDetachedWorktree(handle: string): Promise<void>;
+    deleteDetachedWorktree(handle: string): Promise<void>;
+    reconcileDetachedWorktrees(scope: string, activeHandles: readonly string[]): Promise<void>;
     resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<ResolveSessionConfigResult>;
     sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<SessionConfigCompletionsResult>;
     completions(params: CompletionsParams): Promise<CompletionsResult>;
+    listAutomationTriggerDefinitions(params: ListAutomationTriggerDefinitionsParams): Promise<ListAutomationTriggerDefinitionsResult>;
+    runAutomation(params: RunAutomationParams): Promise<RunAutomationResult>;
+    fetchAutomationRuns(params: FetchAutomationRunsParams): Promise<FetchAutomationRunsResult>;
     /**
      * Send an application-level ping and wait for the server's response.
      * Used by {@link _watchdogTick} to keep idle connections under
@@ -267,15 +415,34 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      * Authenticate with the remote agent host using a specific scheme.
      */
     authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
+    private _normalizeAuthenticationParams;
+    private _authenticationKey;
     /**
      * Gracefully shut down all sessions on the remote host.
      */
     shutdown(): Promise<void>;
+    /**
+     * List the endpoints the remote agent host suggests probing for connectivity.
+     */
+    getNetworkDiagnosticsInfo(): Promise<IAgentHostNetworkDiagnosticsInfo>;
+    getManagedSettingsDiagnostics(): Promise<readonly IAgentHostManagedSettingsDiagnostics[]>;
+    getSessionStateFile(session: URI, chat?: URI): Promise<URI | undefined>;
+    collectDebugLogs(session: URI | undefined, kind: AgentHostDebugLogsArtifactKind, chat?: URI): Promise<IAgentHostDebugLogsArtifact>;
+    /**
+     * Read one bounded slice of a debug-log artifact previously returned by
+     * {@link collectDebugLogs}. `resource` is the agent-host URI handed out by
+     * that call; it is unwrapped back to the host-local path here.
+     */
+    readDebugLogsChunk(resource: URI, position: number): Promise<IAgentHostDebugLogsChunk>;
+    /**
+     * Probe connectivity from the remote agent host to a single `url`.
+     */
+    diagnosticsFetch(url: string): Promise<IAgentHostNetworkFetchResult>;
     /**
      * Dispose a session on the remote agent host.
      */
     disposeSession(session: URI): Promise<void>;
-    createChat(session: URI, chat: URI, options?: IAgentCreateChatOptions): Promise<void>;
+    createChat(session: URI, chat: URI, options?: IAgentCreateChatRequestOptions): Promise<void>;
     disposeChat(chat: URI): Promise<void>;
     /**
      * Create a new terminal on the remote agent host.
@@ -294,15 +461,16 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
     /**
      * List all sessions from the remote agent host.
      */
-    listSessions(): Promise<IAgentSessionMetadata[]>;
-    private _toLocalProjectUri;
+    listSessions(): Promise<(IAgentSessionMetadata & {
+        readonly workingDirectory?: URI;
+    })[]>;
+    private _toClientUri;
     /**
-     * Inspect an outgoing client-dispatched action and grant implicit reads
-     * for any customization URIs it carries. Today this covers
-     * `SessionActiveClientSet`, which is the only client-dispatched
-     * action that ships customization URIs to the host.
+     * Inspect an outgoing client-dispatched action and grant implicit reads for
+     * resources that the host will need to read after receiving the action.
      */
     private _grantImplicitReadsForOutgoingAction;
+    private _grantImplicitReadsForMessage;
     /**
      * Register implicit read grants for each customization URI that we are
      * about to send to the host. The host needs to read these to materialize
@@ -310,6 +478,7 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      * deduped per connection and revoked when the connection closes.
      */
     private _grantImplicitReadsForCustomizations;
+    private _grantImplicitRead;
     /**
      * List the contents of a directory on the remote host's filesystem.
      */
@@ -317,7 +486,7 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
     /**
      * Read the content of a resource on the remote host.
      */
-    resourceRead(uri: URI): Promise<CommandMap["resourceRead"]["result"]>;
+    resourceRead(uri: URI, encoding?: ContentEncoding): Promise<CommandMap["resourceRead"]["result"]>;
     resourceWrite(params: CommandMap["resourceWrite"]["params"]): Promise<CommandMap["resourceWrite"]["result"]>;
     resourceCopy(params: CommandMap["resourceCopy"]["params"]): Promise<CommandMap["resourceCopy"]["result"]>;
     resourceDelete(params: CommandMap["resourceDelete"]["params"]): Promise<CommandMap["resourceDelete"]["result"]>;
@@ -347,6 +516,7 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      */
     triggerVscodeUpgrade(method: string): Promise<IVscodeUpgradeResult>;
     private _handleMessage;
+    private _handleFatalClose;
     private _handleClose;
     private _raceClose;
     /**
@@ -359,35 +529,40 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
     private _handleReverseRequest;
     /** Send a typed JSON-RPC notification for a protocol-defined method. */
     private _sendNotification;
+    private _sendExtensionNotification;
+    private _sendNotificationMessage;
     /** Send a typed JSON-RPC request for a protocol-defined method. */
     private _sendRequest;
     /** Send a JSON-RPC request for a VS Code extension method (not in the protocol spec). */
     private _sendExtensionRequest;
     private _updateTelemetryLevel;
-    private _updateSessionSyncEnabled;
+    private _effectiveTelemetryLevel;
+    /** Merge a patch into the agent host's root configuration. */
+    private _dispatchRootConfig;
+    private _updateDisableRepoInfoTelemetry;
     private _updateTerminalAutoApproveEnabled;
-    private _updateGlobalAutoApproveEnabled;
-    private _updateAutoReplyEnabled;
-    private _updateCodexEnabled;
     private _updateTerminalAutoApproveRules;
+    private _updateManagedSettingsPermissions;
     /**
-     * Common path for outgoing JSON-RPC requests: gate on any in-flight
-     * reconnect (unless explicitly bypassed for the `reconnect` RPC itself),
-     * assign an id, register the pending deferred, and write to the wire.
+     * Common path for outgoing JSON-RPC requests: queue pre-initialize traffic,
+     * gate on any in-flight reconnect (unless explicitly bypassed for the
+     * `reconnect` RPC itself), assign an id, register the pending deferred, and
+     * write to the wire.
      *
-     * The bypass option is the single special case that exists: the
-     * `reconnect` request is sent from inside `_attemptReconnect` while the
-     * gate is engaged, so it can't wait on its own resolution.
+     * The reconnect-gate bypass exists because the `reconnect` request is sent
+     * from inside `_attemptReconnect` while the gate is engaged, so it can't
+     * wait on its own resolution.
      */
     private _dispatchRequest;
+    private _createRequest;
     private _shouldLogFailedRequest;
     private _toProtocolError;
     private _rejectPendingRequests;
     /**
-     * Reset the liveness timers. Called once at construction (after the
-     * initial transport is installed), once on every received message
-     * (which is itself proof the remote is alive), and once after a
-     * successful soft reconnect.
+     * Reset the liveness timers. Called at construction for an already-open
+     * passive transport, after a successful client-transport initialization,
+     * once on every received message (which is itself proof the remote is
+     * alive), and once after a successful soft reconnect.
      *
      * Two timers cooperate:
      *
@@ -401,21 +576,26 @@ export declare class RemoteAgentHostProtocolClient extends Disposable implements
      *    the transport so the renderer's reconnect logic kicks in. Catches
      *    silently-dead transports (e.g. SSH/tunnel after laptop sleep +
      *    network change) that don't emit a socket close event of their own.
+     *    It defers while the host awaits a reverse-request response or the
+     *    local event loop has high load. Once either deferral clears, it grants
+     *    a fresh full liveness window.
      *
      * After laptop sleep + wake the JS event loop is paused, so a timer
      * armed before sleep fires immediately after wake. That's fine —
      * any inbound message processed during the wake catch-up resets it
      * before the close handler runs.
      *
-     * No-op while {@link _state.kind} is {@link AgentHostClientState.Reconnecting}
-     * or {@link AgentHostClientState.Closed}: the reconnect machinery
-     * owns scheduling in those states, and we don't want a stray inbound
-     * message during reconnect to re-arm the timers behind its back.
+     * No-op while {@link _state.kind} is {@link AgentHostClientState.Incompatible},
+     * {@link AgentHostClientState.Reconnecting}, or {@link AgentHostClientState.Closed}:
+     * the transport is not available for normal liveness traffic in those states.
+     * An inbound message also clears any deferred liveness state.
      */
     private _resetLivenessTimers;
     private _cancelLivenessTimers;
     private _onPingTimer;
+    /** Rechecks deferrals promptly, then force-closes only after a fresh liveness window expires. */
     private _onCloseTimer;
+    private _deferLivenessCheck;
     /**
      * Get the next client sequence number for optimistic dispatch.
      */