@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -0,0 +1,180 @@
+
+import { decodeBase64, VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { dirname, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { FileSystemProviderCapabilities, FilePermission, FileType, createFileSystemProviderError, FileSystemProviderErrorCode } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { ContentEncoding } from './state/protocol/commands.js';
+
+class AHPFileSystemProvider extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.capabilities = FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.FileReadWrite;
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._authorityToConnection = ( new Map());
+    }
+    registerAuthority(authority, connection) {
+        this._authorityToConnection.set(authority, connection);
+        return toDisposable(() => this._authorityToConnection.delete(authority));
+    }
+    watch() {
+        return Disposable.None;
+    }
+    async stat(resource) {
+        const path = resource.path;
+        if (path === "/" || path === "") {
+            return {
+                type: FileType.Directory,
+                mtime: 0,
+                ctime: 0,
+                size: 0,
+                permissions: FilePermission.Readonly
+            };
+        }
+        const decoded = this._decodeUri(resource);
+        if (decoded.scheme === "session-db") {
+            return {
+                type: FileType.File,
+                mtime: 0,
+                ctime: 0,
+                size: 0,
+                permissions: FilePermission.Readonly
+            };
+        }
+        if (decoded.path === "/" || decoded.path === "") {
+            return {
+                type: FileType.Directory,
+                mtime: 0,
+                ctime: 0,
+                size: 0,
+                permissions: FilePermission.Readonly
+            };
+        }
+        const parentUri = dirname(resource);
+        const name = basename(resource);
+        const entries = await this._listDirectory(resource.authority, parentUri);
+        const entry = entries.find(e => e.name === name);
+        if (!entry) {
+            throw createFileSystemProviderError(`File not found: ${path}`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        return {
+            type: entry.type === "directory" ? FileType.Directory : FileType.File,
+            mtime: 0,
+            ctime: 0,
+            size: 0,
+            permissions: FilePermission.Readonly
+        };
+    }
+    async readdir(resource) {
+        const entries = await this._listDirectory(resource.authority, resource);
+        return ( entries.map(e => [e.name, e.type === "directory" ? FileType.Directory : FileType.File]));
+    }
+    async readFile(resource) {
+        const connection = this._getConnection(resource.authority);
+        try {
+            const originalUri = this._decodeUri(resource);
+            const result = await connection.resourceRead(originalUri);
+            if (result.encoding === ContentEncoding.Base64) {
+                return decodeBase64(result.data).buffer;
+            }
+            return VSBuffer.fromString(result.data).buffer;
+        } catch (err) {
+            throw createFileSystemProviderError(
+                err instanceof Error ? err.message : String(err),
+                FileSystemProviderErrorCode.FileNotFound
+            );
+        }
+    }
+    async writeFile(resource, content, _opts) {
+        const connection = this._getConnection(resource.authority);
+        try {
+            const originalUri = this._decodeUri(resource);
+            await connection.resourceWrite({
+                uri: ( originalUri.toString()),
+                data: ( VSBuffer.wrap(content).toString()),
+                encoding: ContentEncoding.Utf8
+            });
+        } catch (err) {
+            throw createFileSystemProviderError(
+                err instanceof Error ? err.message : String(err),
+                FileSystemProviderErrorCode.NoPermissions
+            );
+        }
+    }
+    async mkdir() {
+        throw createFileSystemProviderError(
+            "mkdir not supported on remote filesystem",
+            FileSystemProviderErrorCode.NoPermissions
+        );
+    }
+    async delete(resource, opts) {
+        const connection = this._getConnection(resource.authority);
+        try {
+            const originalUri = this._decodeUri(resource);
+            await connection.resourceDelete({
+                uri: ( originalUri.toString()),
+                recursive: opts.recursive
+            });
+        } catch (err) {
+            throw createFileSystemProviderError(
+                err instanceof Error ? err.message : String(err),
+                FileSystemProviderErrorCode.NoPermissions
+            );
+        }
+    }
+    async rename(from, to, opts) {
+        const connection = this._getConnection(from.authority);
+        try {
+            const originalFrom = this._decodeUri(from);
+            const originalTo = this._decodeUri(to);
+            await connection.resourceMove({
+                source: ( originalFrom.toString()),
+                destination: ( originalTo.toString()),
+                failIfExists: !opts.overwrite
+            });
+        } catch (err) {
+            throw createFileSystemProviderError(
+                err instanceof Error ? err.message : String(err),
+                FileSystemProviderErrorCode.NoPermissions
+            );
+        }
+    }
+    _getConnection(authority) {
+        const connection = this._authorityToConnection.get(authority);
+        if (!connection) {
+            throw createFileSystemProviderError(
+                `No connection for authority: ${authority}`,
+                FileSystemProviderErrorCode.Unavailable
+            );
+        }
+        return connection;
+    }
+    async _listDirectory(authority, resource) {
+        const connection = this._getConnection(authority);
+        try {
+            const originalUri = this._decodeUri(resource);
+            const result = await connection.resourceList(originalUri);
+            return result.entries;
+        } catch (err) {
+            throw createFileSystemProviderError(
+                err instanceof Error ? err.message : String(err),
+                FileSystemProviderErrorCode.Unavailable
+            );
+        }
+    }
+}
+class AgentHostFileSystemProvider extends AHPFileSystemProvider {
+    _decodeUri(resource) {
+        return fromAgentHostUri(resource);
+    }
+}
+
+export { AHPFileSystemProvider, AgentHostFileSystemProvider };

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

@@ -1,8 +1,14 @@
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { IAuthorizationProtectedResourceMetadata } from "@codingame/monaco-vscode-api/vscode/vs/base/common/oauth";
+import { IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IAgentService } from "./agentService.service.js";
-import { AttachmentType, type IPendingMessage, type IToolCallResult, type PolicyState, type StringOrMarkdown } from "./state/sessionState.js";
+import type { ISyncedCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentPluginManager";
+import type { IAgentSubscription } from "./state/agentSubscription.js";
+import type { ICreateTerminalParams, IResolveSessionConfigResult, ISessionConfigCompletionsResult } from "./state/protocol/commands.js";
+import { IProtectedResourceMetadata, type IConfigSchema, type IFileEdit, type IModelSelection, type IToolDefinition } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { IActionEnvelope, INotification, ISessionAction, ITerminalAction } from "./state/sessionActions.js";
+import type { IResourceCopyParams, IResourceCopyResult, IResourceDeleteParams, IResourceDeleteResult, IResourceListResult, IResourceMoveParams, IResourceMoveResult, IResourceReadResult, IResourceWriteParams, IResourceWriteResult } from "./state/sessionProtocol.js";
+import { AttachmentType, ComponentToState, SessionInputResponseKind, SessionStatus, StateComponents, type ICustomizationRef, type IPendingMessage, type IRootState, type ISessionInputAnswer, type ISessionInputRequest, type IToolCallResult, type IToolResultContent, type PolicyState, type StringOrMarkdown } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
 export declare enum AgentHostIpcChannels {
     /** Channel for the agent host service on the main-process side */
     AgentHost = "agentHost",
@@ -11,15 +17,49 @@ export declare enum AgentHostIpcChannels {
     /** Channel for WebSocket client connection count (server process management only) */
     ConnectionTracker = "agentHostConnectionTracker"
 }
-/** Configuration key that controls whether the agent host process is spawned. */
+/** Configuration key that controls whether the local agent host process is spawned. */
 export declare const AgentHostEnabledSettingId = "chat.agentHost.enabled";
 /** Configuration key that controls whether per-host IPC traffic output channels are created. */
 export declare const AgentHostIpcLoggingSettingId = "chat.agentHost.ipcLoggingEnabled";
+/** Result of starting the agent host WebSocket server on-demand. */
+export interface IAgentHostSocketInfo {
+    readonly socketPath: string;
+}
+/**
+ * IPC service exposed on the {@link AgentHostIpcChannels.ConnectionTracker}
+ * channel. Used by the server process for lifetime management and by the
+ * shared process to request a local WebSocket listener on-demand.
+ */
+export interface IConnectionTrackerService {
+    readonly onDidChangeConnectionCount: Event<number>;
+    /**
+     * Request the agent host to start a WebSocket server on a local
+     * pipe/socket. Returns the socket path.
+     * If a server is already running, returns the existing info.
+     */
+    startWebSocketServer(): Promise<IAgentHostSocketInfo>;
+}
 export interface IAgentSessionMetadata {
     readonly session: URI;
     readonly startTime: number;
     readonly modifiedTime: number;
+    readonly project?: IAgentSessionProjectInfo;
     readonly summary?: string;
+    readonly status?: SessionStatus;
+    readonly model?: IModelSelection;
+    readonly workingDirectory?: URI;
+    readonly isRead?: boolean;
+    readonly isDone?: boolean;
+    readonly diffs?: readonly IFileEdit[];
+}
+export interface IAgentSessionProjectInfo {
+    readonly uri: URI;
+    readonly displayName: string;
+}
+export interface IAgentCreateSessionResult {
+    readonly session: URI;
+    readonly project?: IAgentSessionProjectInfo;
+    /** The resolved working directory, which may differ from the requested one (e.g. worktree). */
     readonly workingDirectory?: URI;
 }
 export type AgentProvider = string;
@@ -28,27 +68,6 @@ export interface IAgentDescriptor {
     readonly provider: AgentProvider;
     readonly displayName: string;
     readonly description: string;
-    /**
-     * Whether the renderer should push a GitHub auth token for this agent.
-     * @deprecated Use {@link IResourceMetadata.resources} from {@link IAgentService.getResourceMetadata} instead.
-     */
-    readonly requiresAuth: boolean;
-}
-/**
- * Describes the agent host as an OAuth 2.0 protected resource.
- * Uses {@link IAuthorizationProtectedResourceMetadata} from RFC 9728
- * to describe auth requirements, enabling clients to resolve tokens
- * using the standard VS Code authentication service.
- *
- * Returned from the server via {@link IAgentService.getResourceMetadata}.
- */
-export interface IResourceMetadata {
-    /**
-     * Protected resources the agent host requires authentication for.
-     * Each entry uses the standard RFC 9728 shape so clients can resolve
-     * tokens via {@link IAuthenticationService.getOrActivateProviderIdForServer}.
-     */
-    readonly resources: readonly IAuthorizationProtectedResourceMetadata[];
 }
 /**
  * Parameters for the `authenticate` command.
@@ -72,9 +91,33 @@ export interface IAuthenticateResult {
 }
 export interface IAgentCreateSessionConfig {
     readonly provider?: AgentProvider;
-    readonly model?: string;
+    readonly model?: IModelSelection;
     readonly session?: URI;
     readonly workingDirectory?: URI;
+    readonly config?: Record<string, string>;
+    /** Fork from an existing session at a specific turn. */
+    readonly fork?: {
+        readonly session: URI;
+        readonly turnIndex: number;
+        readonly turnId: string;
+        /**
+         * Maps old protocol turn IDs to new protocol turn IDs.
+         * Populated by the service layer after generating fresh UUIDs
+         * for the forked session's turns. Used by the agent to remap
+         * per-turn data (e.g. SDK event ID mappings) in the session database.
+         */
+        readonly turnIdMapping?: ReadonlyMap<string, string>;
+    };
+}
+export declare const AgentHostSessionConfigBranchNameHintKey = "branchNameHint";
+export interface IAgentResolveSessionConfigParams {
+    readonly provider?: AgentProvider;
+    readonly workingDirectory?: URI;
+    readonly config?: Record<string, string>;
+}
+export interface IAgentSessionConfigCompletionsParams extends IAgentResolveSessionConfigParams {
+    readonly property: string;
+    readonly query?: string;
 }
 /** Serializable attachment passed alongside a message to the agent host. */
 export interface IAgentAttachment {
@@ -102,11 +145,8 @@ export interface IAgentModelInfo {
     readonly name: string;
     readonly maxContextWindow: number;
     readonly supportsVision: boolean;
-    readonly supportsReasoningEffort: boolean;
-    readonly supportedReasoningEfforts?: readonly string[];
-    readonly defaultReasoningEffort?: string;
+    readonly configSchema?: IConfigSchema;
     readonly policyState?: PolicyState;
-    readonly billingMultiplier?: number;
 }
 interface IAgentProgressEventBase {
     readonly session: URI;
@@ -148,18 +188,36 @@ export interface IAgentToolStartEvent extends IAgentProgressEventBase {
     /** Human-readable display name for this tool. */
     readonly displayName: string;
     /** Message describing the tool invocation in progress (e.g., "Running `echo hello`"). */
-    readonly invocationMessage: string;
+    readonly invocationMessage: StringOrMarkdown;
     /** A representative input string for display in the UI (e.g., the shell command). */
     readonly toolInput?: string;
-    /** Hint for the renderer about how to display this tool (e.g., 'terminal' for shell commands). */
-    readonly toolKind?: "terminal";
+    /** Hint for the renderer about how to display this tool (e.g., 'terminal' for shell commands, 'subagent' for subagent-spawning tools). */
+    readonly toolKind?: "terminal" | "subagent";
     /** Language identifier for syntax highlighting (e.g., 'shellscript', 'powershell'). Used with toolKind 'terminal'. */
     readonly language?: string;
     /** Serialized JSON of the tool arguments, if available. */
     readonly toolArguments?: string;
+    /**
+     * For `toolKind === 'subagent'`, the internal name of the agent being
+     * spawned (e.g. 'explore'). Adapters are responsible for extracting this
+     * from their SDK-specific tool argument shape.
+     */
+    readonly subagentAgentName?: string;
+    /**
+     * For `toolKind === 'subagent'`, a human-readable description of the
+     * subagent's task. Adapters are responsible for extracting this from
+     * their SDK-specific tool argument shape.
+     */
+    readonly subagentDescription?: string;
     readonly mcpServerName?: string;
     readonly mcpToolName?: string;
     readonly parentToolCallId?: string;
+    /**
+     * If set, this tool is provided by a client and the identified client
+     * is responsible for executing it. Maps to `toolClientId` in the
+     * protocol `session/toolCallStart` action.
+     */
+    readonly toolClientId?: string;
 }
 /** A tool has finished executing (`tool.execution_complete`). */
 export interface IAgentToolCompleteEvent extends IAgentProgressEventBase {
@@ -205,17 +263,45 @@ export interface IAgentToolReadyEvent extends IAgentProgressEventBase {
     readonly toolInput?: string;
     /** Short title for the confirmation prompt. */
     readonly confirmationTitle?: StringOrMarkdown;
-    /** Kind of permission being requested (e.g. `'write'`, `'read'`). */
-    readonly permissionKind?: string;
+    /** Kind of permission being requested. */
+    readonly permissionKind?: "shell" | "write" | "mcp" | "read" | "url" | "custom-tool";
     /** File path associated with the permission request. */
     readonly permissionPath?: string;
+    /** File edits this tool call will perform, for preview before confirmation. */
+    readonly edits?: {
+        items: IFileEdit[];
+    };
 }
 /** Streaming reasoning/thinking content from the assistant. */
 export interface IAgentReasoningEvent extends IAgentProgressEventBase {
     readonly type: "reasoning";
     readonly content: string;
 }
-export type IAgentProgressEvent = IAgentDeltaEvent | IAgentMessageEvent | IAgentIdleEvent | IAgentToolStartEvent | IAgentToolReadyEvent | IAgentToolCompleteEvent | IAgentTitleChangedEvent | IAgentErrorEvent | IAgentUsageEvent | IAgentReasoningEvent;
+/** A steering message was consumed (sent to the model). */
+export interface IAgentSteeringConsumedEvent extends IAgentProgressEventBase {
+    readonly type: "steering_consumed";
+    readonly id: string;
+}
+/** The agent's ask_user tool is requesting user input. */
+export interface IAgentUserInputRequestEvent extends IAgentProgressEventBase {
+    readonly type: "user_input_request";
+    readonly request: ISessionInputRequest;
+}
+/** A subagent has been spawned by a tool call. */
+export interface IAgentSubagentStartedEvent extends IAgentProgressEventBase {
+    readonly type: "subagent_started";
+    readonly toolCallId: string;
+    readonly agentName: string;
+    readonly agentDisplayName: string;
+    readonly agentDescription?: string;
+}
+/** Partial content update for a running tool call (e.g. terminal URI available). */
+export interface IAgentToolContentChangedEvent extends IAgentProgressEventBase {
+    readonly type: "tool_content_changed";
+    readonly toolCallId: string;
+    readonly content: IToolResultContent[];
+}
+export type IAgentProgressEvent = IAgentDeltaEvent | IAgentMessageEvent | IAgentIdleEvent | IAgentToolStartEvent | IAgentToolReadyEvent | IAgentToolCompleteEvent | IAgentTitleChangedEvent | IAgentErrorEvent | IAgentUsageEvent | IAgentReasoningEvent | IAgentSteeringConsumedEvent | IAgentUserInputRequestEvent | IAgentSubagentStartedEvent | IAgentToolContentChangedEvent;
 export declare namespace AgentSession {
     /**
      * Creates a session URI from a provider name and raw session ID.
@@ -243,10 +329,14 @@ export interface IAgent {
     readonly id: AgentProvider;
     /** Fires when the provider streams progress for a session. */
     readonly onDidSessionProgress: Event<IAgentProgressEvent>;
-    /** Create a new session. Returns the session URI. */
-    createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    /** Create a new session. Returns server-owned session metadata. */
+    createSession(config?: IAgentCreateSessionConfig): Promise<IAgentCreateSessionResult>;
+    /** Resolve the dynamic configuration schema for creating a session. */
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<IResolveSessionConfigResult>;
+    /** Return dynamic completions for a session configuration property. */
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<ISessionConfigCompletionsResult>;
     /** Send a user message into an existing session. */
-    sendMessage(session: URI, prompt: string, attachments?: IAgentAttachment[]): Promise<void>;
+    sendMessage(session: URI, prompt: string, attachments?: IAgentAttachment[], turnId?: string): Promise<void>;
     /**
      * Called when the session's pending (steering) message changes.
      * The agent harness decides how to react — e.g. inject steering
@@ -257,42 +347,103 @@ export interface IAgent {
      */
     setPendingMessages?(session: URI, steeringMessage: IPendingMessage | undefined, queuedMessages: readonly IPendingMessage[]): void;
     /** Retrieve all session events/messages for reconstruction. */
-    getSessionMessages(session: URI): Promise<(IAgentMessageEvent | IAgentToolStartEvent | IAgentToolCompleteEvent)[]>;
+    getSessionMessages(session: URI): Promise<(IAgentMessageEvent | IAgentToolStartEvent | IAgentToolCompleteEvent | IAgentSubagentStartedEvent)[]>;
     /** Dispose a session, freeing resources. */
     disposeSession(session: URI): Promise<void>;
     /** Abort the current turn, stopping any in-flight processing. */
     abortSession(session: URI): Promise<void>;
     /** Change the model for an existing session. */
-    changeModel(session: URI, model: string): Promise<void>;
+    changeModel(session: URI, model: IModelSelection): Promise<void>;
     /** Respond to a pending permission request from the SDK. */
     respondToPermissionRequest(requestId: string, approved: boolean): void;
+    /** Respond to a pending user input request from the SDK's ask_user tool. */
+    respondToUserInputRequest(requestId: string, response: SessionInputResponseKind, answers?: Record<string, ISessionInputAnswer>): void;
     /** Return the descriptor for this agent. */
     getDescriptor(): IAgentDescriptor;
-    /** List available models from this provider. */
-    listModels(): Promise<IAgentModelInfo[]>;
+    /** Available models from this provider. */
+    readonly models: IObservable<readonly IAgentModelInfo[]>;
     /** List persisted sessions from this provider. */
     listSessions(): Promise<IAgentSessionMetadata[]>;
     /** Declare protected resources this agent requires auth for (RFC 9728). */
-    getProtectedResources(): IAuthorizationProtectedResourceMetadata[];
+    getProtectedResources(): IProtectedResourceMetadata[];
     /**
      * Authenticate for a specific resource. Returns true if accepted.
      * The `resource` matches {@link IAuthorizationProtectedResourceMetadata.resource}.
      */
     authenticate(resource: string, token: string): Promise<boolean>;
+    /**
+     * Truncate a session's history. If `turnId` is provided, keeps turns up to
+     * and including that turn. If omitted, all turns are removed.
+     * Optional — not all providers support truncation.
+     */
+    truncateSession?(session: URI, turnId?: string): Promise<void>;
+    /**
+     * Receives client-provided customization refs and syncs them (e.g. copies
+     * plugin files to local storage). Returns per-customization status with
+     * local plugin directories.
+     *
+     * The agent MAY defer a client restart until all active sessions are idle.
+     */
+    setClientCustomizations(clientId: string, customizations: ICustomizationRef[], progress?: (results: ISyncedCustomization[]) => void): Promise<ISyncedCustomization[]>;
+    /**
+     * Receives client-provided tool definitions to make available in a
+     * specific session. The agent registers these as custom tools so the
+     * LLM can call them; execution is routed back to the owning client.
+     *
+     * Always called on `activeClientChanged`, even with an empty array,
+     * to clear a previous client's tools.
+     *
+     * @param session The session URI this tool set applies to.
+     * @param clientId The client that owns these tools.
+     * @param tools The tool definitions (full replacement).
+     */
+    setClientTools(session: URI, clientId: string, tools: IToolDefinition[]): void;
+    /**
+     * Called when a client completes a client-provided tool call.
+     * Resolves the tool handler's deferred promise so the SDK can continue.
+     *
+     * @param session The session the tool call belongs to.
+     */
+    onClientToolCallComplete(session: URI, toolCallId: string, result: IToolCallResult): void;
+    /**
+     * Notifies the agent that a customization has been toggled on or off.
+     * The agent MAY restart its client before the next message is sent.
+     */
+    setCustomizationEnabled(uri: string, enabled: boolean): void;
     /** Gracefully shut down all sessions. */
     shutdown(): Promise<void>;
     /** Dispose this provider and all its resources. */
     dispose(): void;
 }
 /**
- * A concrete connection to an agent host - local utility process or remote
- * WebSocket. Extends the core protocol surface with a `clientId` used for
- * write-ahead reconciliation. Both {@link IAgentHostService} (local) and
- * per-connection objects from {@link IRemoteAgentHostService} (remote)
- * satisfy this contract.
+ * Consumer-facing connection to an agent host. Session handlers, terminal
+ * contributions, and other features program against this interface.
+ *
+ * Implementations wrap an {@link IAgentService} and layer subscription
+ * management and optimistic write-ahead on top.
  */
-export interface IAgentConnection extends IAgentService {
-    /** Unique identifier for this client connection, used as the origin in action envelopes. */
+export interface IAgentConnection {
+    readonly _serviceBrand: undefined;
     readonly clientId: string;
+    readonly rootState: IAgentSubscription<IRootState>;
+    getSubscription<T extends StateComponents>(kind: T, resource: URI): IReference<IAgentSubscription<ComponentToState[T]>>;
+    getSubscriptionUnmanaged<T extends StateComponents>(kind: T, resource: URI): IAgentSubscription<ComponentToState[T]> | undefined;
+    dispatch(action: ISessionAction | ITerminalAction): void;
+    readonly onDidNotification: Event<INotification>;
+    readonly onDidAction: Event<IActionEnvelope>;
+    authenticate(params: IAuthenticateParams): Promise<IAuthenticateResult>;
+    listSessions(): Promise<IAgentSessionMetadata[]>;
+    createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<IResolveSessionConfigResult>;
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<ISessionConfigCompletionsResult>;
+    disposeSession(session: URI): Promise<void>;
+    createTerminal(params: ICreateTerminalParams): Promise<void>;
+    disposeTerminal(terminal: URI): Promise<void>;
+    resourceList(uri: URI): Promise<IResourceListResult>;
+    resourceRead(uri: URI): Promise<IResourceReadResult>;
+    resourceWrite(params: IResourceWriteParams): Promise<IResourceWriteResult>;
+    resourceCopy(params: IResourceCopyParams): Promise<IResourceCopyResult>;
+    resourceDelete(params: IResourceDeleteParams): Promise<IResourceDeleteResult>;
+    resourceMove(params: IResourceMoveParams): Promise<IResourceMoveResult>;
 }
 export {};