@codingame/monaco-vscode-api 34.1.3 → 35.0.1

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

@@ -3,16 +3,24 @@ import type { ResourceLabelFormatter } from "../../label/common/label.js";
 /**
  * The URI scheme for accessing files on a remote agent host.
  *
- * URIs encode the original scheme, authority, and path so that any
- * remote resource can be represented without assuming `file://`:
+ * The original file path is kept verbatim as the URI path so resource
+ * labels, language detection, and path comparisons see a real path. The
+ * original scheme, authority, and query are carried in a single
+ * url-safe-base64 `_ah` query parameter so any remote resource can be
+ * represented without assuming `file://`:
  *
  * ```
- * vscode-agent-host://[connectionAuthority]/[originalScheme]/[originalAuthority]/[originalPath]
+ * vscode-agent-host://[connectionAuthority][originalPath]?_ah=[meta]#[originalFragment]
  * ```
  *
- * For example, `file:///home/user/foo.ts` on remote `my-server` becomes:
+ * where `meta` is {@link IAgentHostUriMeta} as url-safe-base64-encoded
+ * JSON. Encoding the metadata as a single opaque parameter (rather than
+ * raw JSON) keeps the query a well-formed parameter list, so unrelated
+ * query parameters such as `vscodeLinkType` can coexist on the wrapped
+ * URI without corrupting the metadata. For example,
+ * `file:///home/user/foo.ts` on remote `my-server` becomes:
  * ```
- * vscode-agent-host://my-server/file//home/user/foo.ts
+ * vscode-agent-host://my-server/home/user/foo.ts?_ah=eyJzY2hlbWUiOiJmaWxlIn0
  * ```
  */
 export declare const AGENT_HOST_SCHEME = "vscode-agent-host";
@@ -51,8 +59,7 @@ export declare function normalizeRemoteAgentHostAddress(address: string): string
  */
 export declare function agentHostAuthority(address: string): string;
 /**
- * Label formatter for {@link AGENT_HOST_SCHEME} URIs. Strips the two
- * leading path segments (`/scheme/authority`) to display the original
- * file path.
+ * Label formatter for {@link AGENT_HOST_SCHEME} URIs. The URI path is
+ * already the original resource path, so the label is the path verbatim.
  */
 export declare const AGENT_HOST_LABEL_FORMATTER: ResourceLabelFormatter;

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

@@ -1,51 +1,62 @@
 
-import { encodeBase64, VSBuffer } from '../../../base/common/buffer.js';
+import { encodeBase64, VSBuffer, decodeBase64 } from '../../../base/common/buffer.js';
 import { Schemas } from '../../../base/common/network.js';
 import { URI } from '../../../base/common/uri.js';
 
 const AGENT_HOST_SCHEME = "vscode-agent-host";
+const AGENT_HOST_META_PARAM = "_ah";
 function toAgentHostUri(originalUri, connectionAuthority) {
     if (connectionAuthority === "local" && originalUri.scheme === Schemas.file) {
         return originalUri;
     }
-    const originalAuthority = originalUri.authority || "";
+    const meta = {
+        scheme: originalUri.scheme,
+        ...(originalUri.authority ? {
+            authority: originalUri.authority
+        } : {}),
+        ...(originalUri.query ? {
+            query: originalUri.query
+        } : {})
+    };
+    const params = ( new URLSearchParams());
+    params.set(
+        AGENT_HOST_META_PARAM,
+        encodeBase64(VSBuffer.fromString(JSON.stringify(meta)), false, true)
+    );
     return ( URI.from({
         scheme: AGENT_HOST_SCHEME,
         authority: connectionAuthority,
-        path: `/${originalUri.scheme}/${originalAuthority || "-"}${originalUri.path}`
+        path: originalUri.path || "/",
+        query: ( params.toString()),
+        fragment: originalUri.fragment
     }));
 }
 function fromAgentHostUri(agentHostUri) {
     if (agentHostUri.scheme !== AGENT_HOST_SCHEME) {
         return agentHostUri;
     }
-    const path = agentHostUri.path;
-    const schemeEnd = path.indexOf("/", 1);
-    if (schemeEnd === -1) {
-        return ( URI.from({
-            scheme: "file",
-            path
-        }));
+    let meta;
+    const encoded = agentHostUri.query ? ( new URLSearchParams(agentHostUri.query)).get(AGENT_HOST_META_PARAM) : null;
+    if (encoded) {
+        try {
+            meta = JSON.parse(( decodeBase64(encoded).toString()));
+        } catch {
+            meta = undefined;
+        }
     }
-    const originalScheme = path.substring(1, schemeEnd);
-    const authorityEnd = path.indexOf("/", schemeEnd + 1);
-    if (authorityEnd === -1) {
-        const originalAuthority = path.substring(schemeEnd + 1);
+    if (!meta || typeof meta.scheme !== "string") {
         return ( URI.from({
-            scheme: originalScheme,
-            authority: originalAuthority,
-            path: "/"
+            scheme: Schemas.file,
+            path: agentHostUri.path,
+            fragment: agentHostUri.fragment
         }));
     }
-    let originalAuthority = path.substring(schemeEnd + 1, authorityEnd);
-    if (originalAuthority === "-") {
-        originalAuthority = "";
-    }
-    const originalPath = path.substring(authorityEnd);
     return ( URI.from({
-        scheme: originalScheme,
-        authority: originalAuthority || undefined,
-        path: originalPath
+        scheme: meta.scheme,
+        authority: meta.authority || undefined,
+        path: agentHostUri.path,
+        query: meta.query || "",
+        fragment: agentHostUri.fragment
     }));
 }
 function normalizeRemoteAgentHostAddress(address) {
@@ -68,8 +79,7 @@ const AGENT_HOST_LABEL_FORMATTER = {
     scheme: AGENT_HOST_SCHEME,
     formatting: {
         label: "${path}",
-        separator: "/",
-        stripPathSegments: 2
+        separator: "/"
     }
 };
 

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

@@ -0,0 +1,38 @@
+import type { ToolDefinition, URI } from "./state/sessionState.js";
+/**
+ * Server-side host for the agent host's **server tools** — tools that the
+ * agent host owns and executes in-process (against a session's own state
+ * channels) rather than round-tripping to the workbench. Providers (Copilot,
+ * Claude) implement nothing here; they consume this host to discover the
+ * server tools, advertise them on a session, and execute them by name.
+ *
+ * The set of server tools is open-ended: each group of tools (feedback
+ * "comments" is the first) is contributed to the host at startup, so providers
+ * never hard-code any specific tool — they read {@link definitions} /
+ * {@link toolNames} and route through {@link executeTool}.
+ *
+ * `sessionUri` is the session's protocol URI.
+ */
+export interface IAgentServerToolHost {
+    /** Every server tool definition across the contributed groups. */
+    readonly definitions: readonly ToolDefinition[];
+    /** Names of every server tool across the contributed groups. */
+    readonly toolNames: readonly string[];
+    /** Advertises all server tools on the session's `serverTools`. */
+    advertise(sessionUri: URI): void;
+    /**
+     * Whether {@link toolName} must be confirmed by the user before it runs.
+     * Providers exclude such tools from their server-tool auto-approve lists so
+     * the call surfaces a confirmation instead of executing silently. Returns
+     * `false` for unknown tools and for tools that are auto-approved.
+     */
+    requiresConfirmation(toolName: string): boolean;
+    /**
+     * Executes a server tool against the session's state, dispatching any
+     * resulting actions, and returns the textual tool result for the agent.
+     *
+     * @throws if {@link toolName} is not a known server tool or the arguments
+     * are invalid.
+     */
+    executeTool(sessionUri: URI, toolName: string, rawArgs: unknown): string;
+}

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

@@ -1,11 +1,10 @@
 import { Event } from "../../../base/common/event.js";
 import { IObservable } from "../../../base/common/observable.js";
 import { URI } from "../../../base/common/uri.js";
-import { AuthenticateParams, AuthenticateResult, IAgentHostAuthTokenRequest, IAgentSessionMetadata, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, type IAgentConnection, type IAgentHostInspectInfo, type IAgentHostSocketInfo } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { AuthenticateParams, AuthenticateResult, IAgentHostAuthTokenRequest, IAgentSessionMetadata, IAgentCreateSessionConfig, IAgentCreateChatOptions, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IMcpNotification, type IAgentConnection, type IAgentHostInspectInfo, type IAgentHostSocketInfo } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
 import { ResolveSessionConfigResult, SessionConfigCompletionsResult, CompletionsParams, CompletionsResult, CreateTerminalParams, InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "./state/protocol/commands.js";
-import { ActionEnvelope, INotification, SessionAction, TerminalAction, IRootConfigChangedAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
-import { ResourceListResult, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceMoveParams, ResourceMoveResult, ResourceResolveParams, ResourceResolveResult, ResourceMkdirParams, ResourceMkdirResult, CreateResourceWatchParams, CreateResourceWatchResult, ResourceWatchState } from "./state/sessionProtocol.js";
-import { Snapshot as IStateSnapshot } from "./state/sessionState.js";
+import { ActionEnvelope, INotification, SessionAction, ChatAction, TerminalAction, ClientAnnotationsAction, IRootConfigChangedAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
+import { IStateSnapshot, ResourceListResult, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceMoveParams, ResourceMoveResult, ResourceResolveParams, ResourceResolveResult, ResourceMkdirParams, ResourceMkdirResult, CreateResourceWatchParams, CreateResourceWatchResult, ResourceWatchState } from "./state/sessionProtocol.js";
 export declare const IAgentService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentService>;
 /**
 * Service contract for communicating with the agent host process. Methods here
@@ -30,6 +29,15 @@ export interface IAgentService {
     listSessions(): Promise<IAgentSessionMetadata[]>;
     /** Create a new session. Returns the session URI. */
     createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    /**
+    * Create an additional chat within an existing session. Spins up the
+    * backing chat in the harness (sharing the session's session) and
+    * registers the chat in the session's catalog so subscribers observe a
+    * `session/chatAdded` action. The `chat` URI is the client-chosen channel.
+    */
+    createChat(session: URI, chat: URI, options?: IAgentCreateChatOptions): Promise<void>;
+    /** Dispose an additional chat created via {@link createChat}. */
+    disposeChat(session: URI, chat: URI): Promise<void>;
     /** Resolve the dynamic configuration schema for creating a session. */
     resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<ResolveSessionConfigResult>;
     /** Return dynamic completions for a session configuration property. */
@@ -61,6 +69,32 @@ export interface IAgentService {
     disposeTerminal(terminal: URI): Promise<void>;
     /** Invoke a server-defined changeset operation. */
     invokeChangesetOperation(params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult>;
+    /**
+    * Routes a request received on an `mcp://` AHP side channel to the
+    * MCP server implementation owned by the appropriate agent. The
+    * channel URI shape is `mcp://<providerId>/<sessionId>/<serverName>`
+    * (the latter two segments URL-encoded), matching the
+    * {@link McpServerCustomization.channel | channel} the agent host
+    * advertises while the server is in
+    * {@link McpServerStatus.Ready | `Ready`}.
+    *
+    * `method` is the raw MCP JSON-RPC method (e.g. `tools/list`,
+    * `tools/call`, `resources/read`); `params` are the JSON-RPC params
+    * (still carrying the routing envelope's `channel` field, which the
+    * agent may ignore). Rejects with an `Error` whose message begins
+    * with `Method not found` when the channel is unknown or the agent
+    * doesn't recognise the method — the protocol server translates that
+    * into a JSON-RPC `-32601`.
+    */
+    handleMcpRequest(channel: string, method: string, params: Record<string, unknown> | undefined): Promise<unknown>;
+    /**
+    * Aggregated stream of MCP notifications across every agent. The
+    * protocol server subscribes once and broadcasts each notification as
+    * a JSON-RPC notification to all connected clients (the routing
+    * envelope's `channel` field is sufficient for client-side dispatch,
+    * so no per-subscription fanout is required).
+    */
+    readonly onMcpNotification: Event<IMcpNotification>;
     /** Gracefully shut down all sessions and the underlying client. */
     shutdown(): Promise<void>;
     /**
@@ -108,7 +142,7 @@ export interface IAgentService {
     * rather than {@link URI} objects so that authority-less scheme URIs
     * like `ahp-root://` survive the wire format without normalization.
     */
-    dispatchAction(channel: string, action: SessionAction | TerminalAction | IRootConfigChangedAction, clientId: string, clientSeq: number): void;
+    dispatchAction(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientAnnotationsAction | IRootConfigChangedAction, clientId: string, clientSeq: number): void;
     /**
     * List the contents of a directory on the agent host's filesystem.
     * Used by the client to drive a remote folder picker before session creation.

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

@@ -1,6 +1,6 @@
 import { Event } from "../../../base/common/event.js";
 import type { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
-import type { IVscodeUpgradeResult } from "./state/protocolUpgrade.js";
+import { type IVscodeUpgradeResult } from "./state/protocolUpgrade.js";
 import { IRemoteAgentHostService } from "./remoteAgentHostService.service.js";
 /**
  * Connection status for a remote agent host.
@@ -138,6 +138,12 @@ export interface IRemoteAgentHostEntry {
 }
 export declare function getEntryAddress(entry: IRemoteAgentHostEntry): string;
 export declare function remoteAgentHostLogOutputChannelId(address: string): string;
+/**
+ * Output channel id for the local agent host process logger (forwarded
+ * from the utility process via `RemoteLoggerChannelClient`). Matches the
+ * logger id registered in `agentHostMain.ts`.
+ */
+export declare const AGENT_HOST_LOG_OUTPUT_CHANNEL_ID = "agenthost";
 export declare enum RemoteAgentHostInputValidationError {
     Empty = "empty",
     Invalid = "invalid"
@@ -168,6 +174,7 @@ export declare class NullRemoteAgentHostService implements IRemoteAgentHostServi
     readonly connections: readonly IRemoteAgentHostConnectionInfo[];
     readonly configuredEntries: readonly IRemoteAgentHostEntry[];
     getConnection(): IAgentConnection | undefined;
+    getConnectionByAuthority(): IAgentConnection | undefined;
     addRemoteAgentHost(): Promise<IRemoteAgentHostConnectionInfo>;
     removeRemoteAgentHost(_address: string): Promise<void>;
     reconnect(_address: string): void;
@@ -186,7 +193,6 @@ export interface IRawRemoteAgentHostEntry {
     readonly sshHostName?: string;
     readonly sshUser?: string;
     readonly sshPort?: number;
-    readonly wslDistro?: string;
 }
 export declare function rawEntryToEntry(raw: IRawRemoteAgentHostEntry): IRemoteAgentHostEntry | undefined;
 export declare function entryToRawEntry(entry: IRemoteAgentHostEntry): IRawRemoteAgentHostEntry | undefined;

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

@@ -2,6 +2,7 @@
 import { Event } from '../../../base/common/event.js';
 import '../../../base/common/network.js';
 import { ProtocolError, AHP_UNSUPPORTED_PROTOCOL_VERSION } from './state/sessionProtocol.js';
+import { readUnsupportedProtocolVersionErrorMeta } from './state/protocolUpgrade.js';
 import { TUNNEL_ADDRESS_PREFIX } from './tunnelAgentHost.js';
 
 var RemoteAgentHostConnectionStatus;
@@ -49,7 +50,7 @@ var RemoteAgentHostConnectionStatus;
         if (err instanceof ProtocolError && err.code === AHP_UNSUPPORTED_PROTOCOL_VERSION) {
             const data = err.data;
             const offeredByServer = Array.isArray(data?.supportedVersions) ? data.supportedVersions : undefined;
-            const vscodeUpgradeMethod = typeof data?._meta?.vscodeUpgradeMethod === "string" ? data._meta.vscodeUpgradeMethod : undefined;
+            const vscodeUpgradeMethod = readUnsupportedProtocolVersionErrorMeta(err.data)?.vscodeUpgradeMethod;
             return incompatible(err.message, supportedByClient, offeredByServer, vscodeUpgradeMethod);
         }
         return undefined;
@@ -78,6 +79,7 @@ function getEntryAddress(entry) {
 function remoteAgentHostLogOutputChannelId(address) {
     return `agentHost.otlp.${address}`;
 }
+const AGENT_HOST_LOG_OUTPUT_CHANNEL_ID = "agenthost";
 var RemoteAgentHostInputValidationError;
 (function(RemoteAgentHostInputValidationError) {
     RemoteAgentHostInputValidationError["Empty"] = "empty";
@@ -94,6 +96,9 @@ class NullRemoteAgentHostService {
     getConnection() {
         return undefined;
     }
+    getConnectionByAuthority() {
+        return undefined;
+    }
     async addRemoteAgentHost() {
         throw ( new Error("Remote agent host connections are not supported in this environment."));
     }
@@ -111,17 +116,6 @@ class NullRemoteAgentHostService {
     }
 }
 function rawEntryToEntry(raw) {
-    if (raw.wslDistro) {
-        return {
-            name: raw.name,
-            connectionToken: raw.connectionToken,
-            connection: {
-                type: RemoteAgentHostEntryType.WSL,
-                address: raw.address,
-                distro: raw.wslDistro
-            }
-        };
-    }
     if (raw.sshConfigHost || raw.sshHostName || raw.sshUser || raw.sshPort) {
         return {
             name: raw.name,
@@ -157,22 +151,16 @@ function entryToRawEntry(entry) {
             sshUser: entry.connection.user,
             sshPort: entry.connection.port
         };
-    case RemoteAgentHostEntryType.WSL:
-        return {
-            address: entry.connection.address,
-            name: entry.name,
-            connectionToken: entry.connectionToken,
-            wslDistro: entry.connection.distro
-        };
     case RemoteAgentHostEntryType.WebSocket:
         return {
             address: entry.connection.address,
             name: entry.name,
             connectionToken: entry.connectionToken
         };
+    case RemoteAgentHostEntryType.WSL:
     case RemoteAgentHostEntryType.Tunnel:
         return undefined;
     }
 }
 
-export { NullRemoteAgentHostService, RemoteAgentHostConnectionStatus, RemoteAgentHostEntryType, RemoteAgentHostInputValidationError, RemoteAgentHostsEnabledSettingId, RemoteAgentHostsSettingId, entryToRawEntry, getEntryAddress, rawEntryToEntry, remoteAgentHostLogOutputChannelId };
+export { AGENT_HOST_LOG_OUTPUT_CHANNEL_ID, NullRemoteAgentHostService, RemoteAgentHostConnectionStatus, RemoteAgentHostEntryType, RemoteAgentHostInputValidationError, RemoteAgentHostsEnabledSettingId, RemoteAgentHostsSettingId, entryToRawEntry, getEntryAddress, rawEntryToEntry, remoteAgentHostLogOutputChannelId };

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

@@ -26,6 +26,15 @@ export interface IRemoteAgentHostService {
     */
     getConnection(address: string): IAgentConnection | undefined;
     /**
+    * Get a per-connection {@link IAgentConnection} by its sanitized
+    * connection authority (as produced by `agentHostAuthority`), rather than
+    * its raw address. Useful for callers that only have the authority
+    * component of a remote session URI scheme (`remote-<authority>-<provider>`).
+    *
+    * Returns `undefined` if no active connection matches the authority.
+    */
+    getConnectionByAuthority(authority: string): IAgentConnection | undefined;
+    /**
     * Adds or updates a configured remote host and resolves once a connection
     * to that host is available.
     */

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

@@ -1,4 +1,4 @@
-import { type StateAction, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type RootTerminalsChangedAction, type RootConfigChangedAction, type SessionReadyAction, type SessionCreationFailedAction, type SessionTurnStartedAction, type SessionDeltaAction, type SessionResponsePartAction, type SessionToolCallStartAction, type SessionToolCallDeltaAction, type SessionToolCallReadyAction, type SessionToolCallConfirmedAction, type SessionToolCallCompleteAction, type SessionToolCallResultConfirmedAction, type SessionToolCallContentChangedAction, type SessionTurnCompleteAction, type SessionTurnCancelledAction, type SessionErrorAction, type SessionTitleChangedAction, type SessionUsageAction, type SessionReasoningAction, type SessionModelChangedAction, type SessionAgentChangedAction, type SessionServerToolsChangedAction, type SessionActiveClientChangedAction, type SessionActiveClientToolsChangedAction, type SessionPendingMessageSetAction, type SessionPendingMessageRemovedAction, type SessionQueuedMessagesReorderedAction, type SessionInputRequestedAction, type SessionInputAnswerChangedAction, type SessionInputCompletedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionCustomizationUpdatedAction, type SessionCustomizationRemovedAction, type SessionMcpServerStateChangedAction, type SessionTruncatedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionActivityChangedAction, type SessionChangesetsChangedAction, type SessionConfigChangedAction, type SessionMetaChangedAction, type ChangesetStatusChangedAction, type ChangesetFileSetAction, type ChangesetFileRemovedAction, type ChangesetOperationsChangedAction, type ChangesetOperationStatusChangedAction, type ChangesetClearedAction, type TerminalDataAction, type TerminalInputAction, type TerminalResizedAction, type TerminalClaimedAction, type TerminalTitleChangedAction, type TerminalCwdChangedAction, type TerminalExitedAction, type TerminalClearedAction, type TerminalCommandDetectionAvailableAction, type TerminalCommandExecutedAction, type TerminalCommandFinishedAction, type ResourceWatchChangedAction } from "./actions.js";
+import { type StateAction, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type RootTerminalsChangedAction, type RootConfigChangedAction, type SessionReadyAction, type SessionCreationFailedAction, type SessionChatAddedAction, type SessionChatRemovedAction, type SessionChatUpdatedAction, type SessionDefaultChatChangedAction, type SessionTitleChangedAction, type SessionServerToolsChangedAction, type SessionActiveClientSetAction, type SessionActiveClientRemovedAction, type SessionInputNeededSetAction, type SessionInputNeededRemovedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionCustomizationUpdatedAction, type SessionCustomizationRemovedAction, type SessionMcpServerStateChangedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionActivityChangedAction, type SessionChangesetsChangedAction, type SessionConfigChangedAction, type SessionMetaChangedAction, type ChatTurnStartedAction, type ChatDeltaAction, type ChatResponsePartAction, type ChatToolCallStartAction, type ChatToolCallDeltaAction, type ChatToolCallReadyAction, type ChatToolCallConfirmedAction, type ChatToolCallCompleteAction, type ChatToolCallResultConfirmedAction, type ChatToolCallContentChangedAction, type ChatTurnCompleteAction, type ChatTurnCancelledAction, type ChatErrorAction, type ChatActivityChangedAction, type ChatUsageAction, type ChatReasoningAction, type ChatPendingMessageSetAction, type ChatPendingMessageRemovedAction, type ChatQueuedMessagesReorderedAction, type ChatDraftChangedAction, type ChatInputRequestedAction, type ChatInputAnswerChangedAction, type ChatInputCompletedAction, type ChatTruncatedAction, type ChangesetStatusChangedAction, type ChangesetFileSetAction, type ChangesetFileRemovedAction, type ChangesetContentChangedAction, type ChangesetOperationsChangedAction, type ChangesetOperationStatusChangedAction, type ChangesetClearedAction, type AnnotationsSetAction, type AnnotationsUpdatedAction, type AnnotationsRemovedAction, type AnnotationsEntrySetAction, type AnnotationsEntryRemovedAction, type TerminalDataAction, type TerminalInputAction, type TerminalResizedAction, type TerminalClaimedAction, type TerminalTitleChangedAction, type TerminalCwdChangedAction, type TerminalExitedAction, type TerminalClearedAction, type TerminalCommandDetectionAvailableAction, type TerminalCommandExecutedAction, type TerminalCommandFinishedAction, type ResourceWatchChangedAction } from "./actions.js";
 /** Union of all root-scoped actions. */
 export type RootAction = RootAgentsChangedAction | RootActiveSessionsChangedAction | RootTerminalsChangedAction | RootConfigChangedAction;
 /** Union of root actions that clients may dispatch. */
@@ -6,11 +6,17 @@ export type ClientRootAction = RootConfigChangedAction;
 /** Union of root actions that only the server may produce. */
 export type ServerRootAction = RootAgentsChangedAction | RootActiveSessionsChangedAction | RootTerminalsChangedAction;
 /** Union of all session-scoped actions. */
-export type SessionAction = SessionReadyAction | SessionCreationFailedAction | SessionTurnStartedAction | SessionDeltaAction | SessionResponsePartAction | SessionToolCallStartAction | SessionToolCallDeltaAction | SessionToolCallReadyAction | SessionToolCallConfirmedAction | SessionToolCallCompleteAction | SessionToolCallResultConfirmedAction | SessionToolCallContentChangedAction | SessionTurnCompleteAction | SessionTurnCancelledAction | SessionErrorAction | SessionTitleChangedAction | SessionUsageAction | SessionReasoningAction | SessionModelChangedAction | SessionAgentChangedAction | SessionServerToolsChangedAction | SessionActiveClientChangedAction | SessionActiveClientToolsChangedAction | SessionPendingMessageSetAction | SessionPendingMessageRemovedAction | SessionQueuedMessagesReorderedAction | SessionInputRequestedAction | SessionInputAnswerChangedAction | SessionInputCompletedAction | SessionCustomizationsChangedAction | SessionCustomizationToggledAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionTruncatedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionConfigChangedAction | SessionMetaChangedAction;
+export type SessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionDefaultChatChangedAction | SessionTitleChangedAction | SessionServerToolsChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationToggledAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionConfigChangedAction | SessionMetaChangedAction;
 /** Union of session actions that clients may dispatch. */
-export type ClientSessionAction = SessionTurnStartedAction | SessionToolCallConfirmedAction | SessionToolCallCompleteAction | SessionToolCallResultConfirmedAction | SessionToolCallContentChangedAction | SessionTurnCancelledAction | SessionTitleChangedAction | SessionModelChangedAction | SessionAgentChangedAction | SessionActiveClientChangedAction | SessionActiveClientToolsChangedAction | SessionPendingMessageSetAction | SessionPendingMessageRemovedAction | SessionQueuedMessagesReorderedAction | SessionInputAnswerChangedAction | SessionInputCompletedAction | SessionCustomizationToggledAction | SessionTruncatedAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionConfigChangedAction;
+export type ClientSessionAction = SessionTitleChangedAction | SessionActiveClientSetAction | SessionActiveClientRemovedAction | SessionCustomizationToggledAction | SessionIsReadChangedAction | SessionIsArchivedChangedAction | SessionConfigChangedAction;
 /** Union of session actions that only the server may produce. */
-export type ServerSessionAction = SessionReadyAction | SessionCreationFailedAction | SessionDeltaAction | SessionResponsePartAction | SessionToolCallStartAction | SessionToolCallDeltaAction | SessionToolCallReadyAction | SessionTurnCompleteAction | SessionErrorAction | SessionUsageAction | SessionReasoningAction | SessionServerToolsChangedAction | SessionInputRequestedAction | SessionCustomizationsChangedAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionMetaChangedAction;
+export type ServerSessionAction = SessionReadyAction | SessionCreationFailedAction | SessionChatAddedAction | SessionChatRemovedAction | SessionChatUpdatedAction | SessionDefaultChatChangedAction | SessionServerToolsChangedAction | SessionInputNeededSetAction | SessionInputNeededRemovedAction | SessionCustomizationsChangedAction | SessionCustomizationUpdatedAction | SessionCustomizationRemovedAction | SessionMcpServerStateChangedAction | SessionActivityChangedAction | SessionChangesetsChangedAction | SessionMetaChangedAction;
+/** Union of all chat-scoped actions. */
+export type ChatAction = ChatTurnStartedAction | ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatTurnCompleteAction | ChatTurnCancelledAction | ChatErrorAction | ChatActivityChangedAction | ChatUsageAction | ChatReasoningAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputRequestedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction;
+/** Union of chat actions that clients may dispatch. */
+export type ClientChatAction = ChatTurnStartedAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatTurnCancelledAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction | ChatTruncatedAction;
+/** Union of chat actions that only the server may produce. */
+export type ServerChatAction = ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatTurnCompleteAction | ChatErrorAction | ChatActivityChangedAction | ChatUsageAction | ChatReasoningAction | ChatInputRequestedAction;
 /** Union of all terminal-scoped actions. */
 export type TerminalAction = TerminalDataAction | TerminalInputAction | TerminalResizedAction | TerminalClaimedAction | TerminalTitleChangedAction | TerminalCwdChangedAction | TerminalExitedAction | TerminalClearedAction | TerminalCommandDetectionAvailableAction | TerminalCommandExecutedAction | TerminalCommandFinishedAction;
 /** Union of terminal actions that clients may dispatch. */
@@ -18,11 +24,17 @@ export type ClientTerminalAction = TerminalInputAction | TerminalResizedAction |
 /** Union of terminal actions that only the server may produce. */
 export type ServerTerminalAction = TerminalDataAction | TerminalCwdChangedAction | TerminalExitedAction | TerminalCommandDetectionAvailableAction | TerminalCommandExecutedAction | TerminalCommandFinishedAction;
 /** Union of all changeset-scoped actions. */
-export type ChangesetAction = ChangesetStatusChangedAction | ChangesetFileSetAction | ChangesetFileRemovedAction | ChangesetOperationsChangedAction | ChangesetOperationStatusChangedAction | ChangesetClearedAction;
+export type ChangesetAction = ChangesetStatusChangedAction | ChangesetFileSetAction | ChangesetFileRemovedAction | ChangesetContentChangedAction | ChangesetOperationsChangedAction | ChangesetOperationStatusChangedAction | ChangesetClearedAction;
 /** Union of changeset actions that clients may dispatch. */
 export type ClientChangesetAction = never;
 /** Union of changeset actions that only the server may produce. */
-export type ServerChangesetAction = ChangesetStatusChangedAction | ChangesetFileSetAction | ChangesetFileRemovedAction | ChangesetOperationsChangedAction | ChangesetOperationStatusChangedAction | ChangesetClearedAction;
+export type ServerChangesetAction = ChangesetStatusChangedAction | ChangesetFileSetAction | ChangesetFileRemovedAction | ChangesetContentChangedAction | ChangesetOperationsChangedAction | ChangesetOperationStatusChangedAction | ChangesetClearedAction;
+/** Union of all annotations-scoped actions. */
+export type AnnotationsAction = AnnotationsSetAction | AnnotationsUpdatedAction | AnnotationsRemovedAction | AnnotationsEntrySetAction | AnnotationsEntryRemovedAction;
+/** Union of annotations actions that clients may dispatch. */
+export type ClientAnnotationsAction = AnnotationsSetAction | AnnotationsUpdatedAction | AnnotationsRemovedAction | AnnotationsEntrySetAction | AnnotationsEntryRemovedAction;
+/** Union of annotations actions that only the server may produce. */
+export type ServerAnnotationsAction = never;
 /** Union of all resource-watch-scoped actions. */
 export type ResourceWatchAction = ResourceWatchChangedAction;
 /** Union of resource-watch actions that clients may dispatch. */

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

@@ -1,6 +1,8 @@
 export * from "./common/actions.js";
 export * from "./channels-root/actions.js";
 export * from "./channels-session/actions.js";
+export * from "./channels-chat/actions.js";
 export * from "./channels-terminal/actions.js";
 export * from "./channels-changeset/actions.js";
+export * from "./channels-annotations/actions.js";
 export * from "./channels-resource-watch/actions.js";

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

@@ -0,0 +1,131 @@
+import { ActionType } from "../common/actions.js";
+import type { URI, TextRange } from "../common/state.js";
+import type { AnnotationEntry, Annotation } from "./state.js";
+/**
+ * Upsert an {@link Annotation} in the annotations channel — adds a new
+ * annotation, or replaces an existing one identified by
+ * {@link Annotation.id}.
+ *
+ * Dispatched by a client to create an annotation (together with its
+ * mandatory first entry) or to re-anchor / resolve an existing one; the
+ * dispatching client assigns the {@link Annotation.id} and the id of any
+ * new entry. When replacing, the full annotation payload (including its
+ * {@link Annotation.entries | entries} list) is substituted; producers
+ * SHOULD prefer {@link AnnotationsEntrySetAction} for per-entry edits, and
+ * {@link AnnotationsUpdatedAction} to resolve / re-anchor an existing
+ * annotation, to keep wire updates small.
+ *
+ * @category Annotations Actions
+ * @version 3
+ * @clientDispatchable
+ */
+export interface AnnotationsSetAction {
+    type: ActionType.AnnotationsSet;
+    /** The new or replacement annotation. MUST contain at least one entry. */
+    annotation: Annotation;
+}
+/**
+ * Partially update an existing {@link Annotation}'s own properties — a narrow
+ * alternative to {@link AnnotationsSetAction} for the common case of resolving
+ * / re-opening or re-anchoring an annotation without resending its
+ * {@link Annotation.entries | entries}.
+ *
+ * Targets one annotation by its {@link annotationId}. Only the fields present
+ * on the action are written; omitted fields leave the corresponding
+ * {@link Annotation} property unchanged. The annotation's
+ * {@link Annotation.entries | entries}, {@link Annotation.id | id}, and
+ * {@link Annotation._meta | _meta} are never touched — dispatch
+ * {@link AnnotationsSetAction} to replace those, to clear {@link range}
+ * (re-anchor to the whole file), or {@link AnnotationsEntrySetAction} /
+ * {@link AnnotationsEntryRemovedAction} to edit individual entries.
+ *
+ * If {@link annotationId} does not match any current annotation the action is
+ * a no-op.
+ *
+ * @category Annotations Actions
+ * @version 4
+ * @clientDispatchable
+ */
+export interface AnnotationsUpdatedAction {
+    type: ActionType.AnnotationsUpdated;
+    /** The {@link Annotation.id} of the annotation to update. */
+    annotationId: string;
+    /**
+     * Re-anchors the annotation to the file versions this turn produced.
+     * Matches a {@link Turn.id} on the owning session. Omit to leave the
+     * current {@link Annotation.turnId} unchanged.
+     */
+    turnId?: string;
+    /**
+     * Re-anchors the annotation to this file. Omit to leave the current
+     * {@link Annotation.resource} unchanged.
+     */
+    resource?: URI;
+    /**
+     * Narrows the annotation to this range within {@link resource}. Omit to
+     * leave the current {@link Annotation.range} unchanged; this action cannot
+     * clear an existing range — dispatch {@link AnnotationsSetAction} to
+     * re-anchor to the whole file.
+     */
+    range?: TextRange;
+    /**
+     * Marks the annotation resolved (`true`) or re-opens it (`false`). Omit to
+     * leave the current {@link Annotation.resolved} state unchanged.
+     */
+    resolved?: boolean;
+}
+/**
+ * Remove an {@link Annotation} from the channel by its id.
+ *
+ * Dispatched to delete an entire annotation and every entry it contains.
+ * Because the protocol forbids empty annotations, a client that wants to
+ * remove the last remaining entry dispatches this action — collapsing the
+ * annotation — rather than {@link AnnotationsEntryRemovedAction}.
+ *
+ * @category Annotations Actions
+ * @version 3
+ * @clientDispatchable
+ */
+export interface AnnotationsRemovedAction {
+    type: ActionType.AnnotationsRemoved;
+    /** The {@link Annotation.id} of the annotation to remove. */
+    annotationId: string;
+}
+/**
+ * Upsert an {@link AnnotationEntry} within an existing annotation — adds a
+ * new entry, or replaces one identified by {@link AnnotationEntry.id}. The
+ * dispatching client assigns the {@link AnnotationEntry.id} of a new entry.
+ * If {@link annotationId} does not match any current annotation the action
+ * is a no-op.
+ *
+ * @category Annotations Actions
+ * @version 3
+ * @clientDispatchable
+ */
+export interface AnnotationsEntrySetAction {
+    type: ActionType.AnnotationsEntrySet;
+    /** The {@link Annotation.id} the entry belongs to. */
+    annotationId: string;
+    /** The new or replacement entry. */
+    entry: AnnotationEntry;
+}
+/**
+ * Remove a single {@link AnnotationEntry} from an annotation without
+ * collapsing the annotation itself. Used when more than one entry remains —
+ * to remove the last entry a client dispatches {@link AnnotationsRemovedAction}
+ * instead, since the protocol forbids empty annotations.
+ *
+ * If either {@link annotationId} or {@link entryId} does not match the
+ * current state the action is a no-op.
+ *
+ * @category Annotations Actions
+ * @version 3
+ * @clientDispatchable
+ */
+export interface AnnotationsEntryRemovedAction {
+    type: ActionType.AnnotationsEntryRemoved;
+    /** The {@link Annotation.id} the entry belongs to. */
+    annotationId: string;
+    /** The {@link AnnotationEntry.id} to remove. */
+    entryId: string;
+}