@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/platform/agentHost/browser/agentHostProtocolClient.d.ts

@@ -1,603 +0,0 @@
-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 { 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 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 { 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 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 { 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 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. */
-    Reconnecting = "reconnecting",
-    /** 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 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 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;
-    /**
-     * Latest `initialize` response from the host. Captured at the end of
-     * {@link connect} and re-captured after a soft-reconnect that pulled
-     * a fresh snapshot. `undefined` before the handshake completes.
-     */
-    private readonly _initializeResult;
-    private readonly _subscriptionManager;
-    private readonly _onDidAction;
-    readonly onDidAction: Event<ActionEnvelope>;
-    private readonly _onDidNotification;
-    readonly onDidNotification: Event<import("../common/state/sessionActions.js").ProtocolNotification>;
-    private readonly _onMcpNotification;
-    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
-     * OTLP/JSON `ExportLogsServiceRequest` value verbatim; consumers
-     * decode it (see `iterateOtlpLogRecords`) and route the records to a
-     * registered logger or sink.
-     *
-     * Channel URIs are kept opaque on the wire so the same event covers
-     * every {@link TelemetryCapabilities.logs} URI the host advertises —
-     * subscribers should filter by `channel` if they care.
-     */
-    private readonly _onDidReceiveOtlpLogs;
-    readonly onDidReceiveOtlpLogs: Event<OtlpExportLogsParams>;
-    private readonly _onDidClose;
-    readonly onDidClose: Event<AgentHostTransportFailureReason | undefined>;
-    private readonly _onDidFatalClose;
-    readonly onDidFatalClose: Event<ProtocolError>;
-    private readonly _onDidChangeConnectionState;
-    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 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.
-     */
-    private _lastReadTime;
-    /**
-     * Liveness watchdog — see {@link _resetLivenessTimers}.
-     *
-     * {@link _pingTimer} fires after {@link PING_INTERVAL_MS} of inbound
-     * 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. 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
-     * their own.
-     */
-    private readonly _pingTimer;
-    private readonly _closeTimer;
-    /**
-     * Used to suppress watchdog-triggered closes when our own JS event loop
-     * has been pegged — in that case the silence is on our side, not the
-     * remote's, and tearing down the transport would just generate a useless
-     * reconnect cycle that aborts in-flight requests.
-     */
-    private readonly _loadEstimator;
-    private readonly _clientInfo;
-    private readonly _reconnectPolicy;
-    private readonly _resolveInitialAuthentication;
-    /**
-     * 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 _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. Exposed observably so callers can
-     * react as advertised capabilities (telemetry, `completionTriggerCharacters`,
-     * `terminalCommandPrefix`, ...) arrive.
-     */
-    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
-     * transport-level reconnect.
-     */
-    private _installTransport;
-    /**
-     * Transition to a new {@link ClientState}. Fires {@link onDidChangeConnectionState}
-     * only when the variant kind actually changes; in-place mutation of
-     * reconnect-state fields (e.g. swapping the gate on a failed retry) does
-     * NOT count as a transition and produces no event.
-     */
-    private _transitionTo;
-    private _newReconnectGate;
-    private _newReconnectState;
-    dispose(): void;
-    /**
-     * Connect to the remote agent host and perform the protocol handshake.
-     */
-    connect(): Promise<void>;
-    /**
-     * Externally signal that the transport has closed. Used by services
-     * managing a passive transport (SSH / dev-tunnels) when they observe
-     * a connection-loss IPC event independent of the transport's own
-     * onClose — without this, a single dropped IPC delivery on the
-     * transport's close channel leaves the client stranded in
-     * `Connected` until its watchdog fires (which can take hours when
-     * the renderer is backgrounded and `setTimeout` is throttled).
-     *
-     * Idempotent — no-op if already closed or mid-reconnect.
-     */
-    notifyTransportClosed(): void;
-    /**
-     * Called from the transport's `onClose` event. When a {@link _transportFactory}
-     * is configured we attempt to soft-reconnect rather than fire `onDidClose` —
-     * the protocol-level `reconnect` request lets the server replay missed
-     * actions and preserves the `clientId` so pending tool calls etc. are not
-     * cancelled by the host-side disconnect timeout. Without a factory
-     * (passive-transport SSH/relay path) we fall back to "close means closed"
-     * 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
-     * `snapshot` we reseat each named subscription with the fresh state and
-     * advance the server seq cursor accordingly.
-     */
-    private _applyReconnectResult;
-    /**
-     * Drain queued outgoing wire traffic after a successful soft reconnect:
-     *
-     * 1. Resend pending optimistic session actions that the server did NOT
-     *    echo back in the replay buffer (i.e. anything still on
-     *    {@link AgentSubscriptionManager.getPendingActions}).
-     * 2. Flush every message that {@link _sendNotification} queued onto the
-     *    outbox while the gate was engaged.
-     *
-     * Replays are deduped against the outbox by `clientSeq` so a session
-     * action that was both optimistic-tracked AND queued during the
-     * reconnect window only goes out once.
-     */
-    private _drainAfterReconnect;
-    get rootState(): IAgentSubscription<RootState>;
-    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 | ChatAction | TerminalAction | ClientChangesetAction | ClientAnnotationsAction | ClientAutomationAction | ClientAutomationRunAction | IRootConfigChangedAction): void;
-    /**
-     * Subscribe to state at a URI. Returns the current state snapshot.
-     *
-     * For stateless channels (e.g. `ahp-otlp:` telemetry channels) use
-     * {@link subscribeStateless} — calling this method on a stateless
-     * channel rejects because the server omits `snapshot` on the
-     * response.
-     */
-    subscribe(resource: URI): Promise<IStateSnapshot>;
-    /**
-     * Subscribe to a stateless channel — one for which the server does
-     * not maintain replayable state and therefore omits `snapshot` from
-     * the `subscribe` response. Used today for the host's OTLP telemetry
-     * channels (`ahp-otlp:`).
-     *
-     * Returns once the subscription is confirmed by the server.
-     * Subsequent notifications on the channel arrive via the relevant
-     * dispatch event (e.g. {@link onDidReceiveOtlpLogs} for log records).
-     */
-    subscribeStateless(resource: URI): Promise<void>;
-    /**
-     * Unsubscribe from state at a URI.
-     */
-    unsubscribe(resource: URI): void;
-    /**
-     * Dispatch a client action to the server. Returns the clientSeq used.
-     */
-    private dispatchAction;
-    /**
-     * 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
-     * watchdog supervision; safe to call from external code as well.
-     *
-     * The returned promise rejects with a {@link ProtocolError} if the
-     * connection closes before a response arrives.
-     */
-    ping(): Promise<void>;
-    /**
-     * Returns the trigger characters captured from the `initialize` handshake.
-     * Empty when the remote host did not announce any.
-     */
-    getCompletionTriggerCharacters(): Promise<readonly string[]>;
-    /**
-     * 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?: IAgentCreateChatRequestOptions): Promise<void>;
-    disposeChat(chat: URI): Promise<void>;
-    /**
-     * Create a new terminal on the remote agent host.
-     */
-    createTerminal(params: CreateTerminalParams): Promise<void>;
-    /**
-     * Dispose a terminal on the remote agent host.
-     */
-    disposeTerminal(terminal: URI): Promise<void>;
-    invokeChangesetOperation(params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult>;
-    /**
-     * Send a request on an `mcp://` AHP side channel. The agent-host
-     * routes by `params.channel` so we inject it automatically.
-     */
-    handleMcpRequest(channel: string, method: string, params: Record<string, unknown> | undefined): Promise<unknown>;
-    /**
-     * List all sessions from the remote agent host.
-     */
-    listSessions(): Promise<(IAgentSessionMetadata & {
-        readonly workingDirectory?: URI;
-    })[]>;
-    private _toClientUri;
-    /**
-     * 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
-     * the customization, but should not need to write them. Grants are
-     * 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.
-     */
-    resourceList(uri: URI): Promise<CommandMap["resourceList"]["result"]>;
-    /**
-     * Read the content of a resource on the remote host.
-     */
-    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"]>;
-    resourceMove(params: CommandMap["resourceMove"]["params"]): Promise<CommandMap["resourceMove"]["result"]>;
-    resourceResolve(params: CommandMap["resourceResolve"]["params"]): Promise<CommandMap["resourceResolve"]["result"]>;
-    resourceMkdir(params: CommandMap["resourceMkdir"]["params"]): Promise<CommandMap["resourceMkdir"]["result"]>;
-    createResourceWatch(params: CommandMap["createResourceWatch"]["params"]): Promise<CommandMap["createResourceWatch"]["result"]>;
-    /**
-     * Convenience wrapper used by {@link AHPFileSystemProvider.watch}:
-     * runs `createResourceWatch` + `subscribe` and returns a handle that
-     * surfaces `resourceWatch/changed` envelopes as
-     * {@link IFileChange}[] events. Disposing the handle unsubscribes
-     * the watch channel.
-     */
-    watchResource(params: CommandMap["createResourceWatch"]["params"]): Promise<IRemoteWatchHandle>;
-    /**
-     * Trigger the CLI-managed upgrade flow for this agent host using the
-     * method name advertised by the server (typically
-     * {@link VSCODE_UPGRADE_METHOD}). Callable before {@link connect} has
-     * completed — typically used when the host has just rejected our
-     * `initialize` with an `UnsupportedProtocolVersion` error. The
-     * transport stays open after the rejection, so the extension request
-     * rides over it without a special out-of-band path.
-     *
-     * The result mirrors the CLI's HTTP response: ok flag, whether the
-     * upgrade is needed / started, running/latest commits.
-     */
-    triggerVscodeUpgrade(method: string): Promise<IVscodeUpgradeResult>;
-    private _handleMessage;
-    private _handleFatalClose;
-    private _handleClose;
-    private _raceClose;
-    /**
-     * Handles reverse RPC requests from the server (e.g. resourceList,
-     * resourceRead). Thin wire adapter — dispatches each frame to
-     * {@link IAgentHostResourceService} (which owns gating, virtual reads,
-     * and the user-prompt flow) and translates results / errors back into
-     * JSON-RPC frames.
-     */
-    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 _effectiveTelemetryLevel;
-    /** Merge a patch into the agent host's root configuration. */
-    private _dispatchRootConfig;
-    private _updateDisableRepoInfoTelemetry;
-    private _updateTerminalAutoApproveEnabled;
-    private _updateTerminalAutoApproveRules;
-    private _updateManagedSettingsPermissions;
-    /**
-     * 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 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 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:
-     *
-     * 1. {@link _pingTimer} fires after {@link PING_INTERVAL_MS} of silence
-     *    and sends an application-level `ping` so the close timer has
-     *    something to time out on. Tolerates servers that don't implement
-     *    `ping` — the error response still resets both timers.
-     *
-     * 2. {@link _closeTimer} fires after {@link PING_INTERVAL_MS}+
-     *    {@link LIVENESS_TIMEOUT_MS} of continued silence and force-closes
-     *    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.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.
-     */
-    nextClientSeq(): number;
-}