@codingame/monaco-vscode-api 36.2.7 → 37.0.0

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

@@ -0,0 +1,61 @@
+
+import { truncate } from '../../../base/common/strings.js';
+import '../../../base/common/resources.js';
+import { URI } from '../../../base/common/uri.js';
+import { parseRequiredSessionUriFromChatUri, buildSubagentChatUri } from './state/sessionState.js';
+
+const CODEX_AGENT_PROVIDER_ID = "codex";
+const SUBAGENT_CHAT_TITLE_MAX_LENGTH = 60;
+function subagentChatTitle(taskDescription, agentDisplayName) {
+    const task = taskDescription?.trim();
+    if (task) {
+        return truncate(task, SUBAGENT_CHAT_TITLE_MAX_LENGTH);
+    }
+    return agentDisplayName?.trim() || "Subagent";
+}
+var SubagentChatSignal;
+(function(SubagentChatSignal) {
+    function toSpawnEvent(signal) {
+        if (signal.kind !== "subagent_started") {
+            return undefined;
+        }
+        let session;
+        try {
+            session = parseRequiredSessionUriFromChatUri(signal.chat);
+        } catch {
+            return undefined;
+        }
+        return {
+            session: ( URI.parse(session)),
+            chat: ( URI.parse(buildSubagentChatUri(session, signal.toolCallId))),
+            parent: {
+                chat: signal.chat,
+                toolCallId: signal.toolCallId
+            },
+            title: subagentChatTitle(signal.taskDescription, signal.agentDisplayName)
+        };
+    }
+    SubagentChatSignal.toSpawnEvent = toSpawnEvent;
+})(SubagentChatSignal || (SubagentChatSignal = {}));
+var AgentSession;
+(function(AgentSession) {
+    function uri(provider, rawSessionId) {
+        return ( URI.from({
+            scheme: provider,
+            path: `/${rawSessionId}`
+        }));
+    }
+    AgentSession.uri = uri;
+    function id(session) {
+        const parsed = typeof session === "string" ? ( URI.parse(session)) : session;
+        return parsed.path.substring(1);
+    }
+    AgentSession.id = id;
+    function provider(session) {
+        const parsed = typeof session === "string" ? ( URI.parse(session)) : session;
+        return parsed.scheme || undefined;
+    }
+    AgentSession.provider = provider;
+})(AgentSession || (AgentSession = {}));
+
+export { AgentSession, CODEX_AGENT_PROVIDER_ID, SubagentChatSignal, subagentChatTitle };

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

@@ -0,0 +1,66 @@
+import { IConfigurationService } from "../../configuration/common/configuration.service.js";
+import { IAgentHostConfigurationSync } from "../../configuration/common/configurationRegistry.js";
+import { AgentHostResourceIdentity } from "./agentHostResourceService.js";
+/**
+ * Resolves the *globally-scoped* value of `settingId`, ignoring any workspace or
+ * folder value.
+ *
+ * The agent host root config is shared by every window connected to a host, so
+ * forwarding a workspace value would let one window's workspace settings leak
+ * into unrelated windows on a last-writer-wins basis. Resolution order mirrors
+ * the platform's own precedence for the layers we keep — policy overrides
+ * everything, then user (local merged with remote), then application.
+ *
+ * A layer whose value does not conform to the setting's declared `type` is
+ * skipped, so a malformed `settings.json` entry falls through to the next layer
+ * and ultimately to the registered default rather than being mirrored verbatim.
+ * This mirrors how `AgentConfigurationService.getEffectiveValue` skips layers
+ * that fail schema validation on the host side.
+ */
+export declare function getGlobalConfigurationValue<T>(configurationService: IConfigurationService, settingId: string): T | undefined;
+/**
+ * Inspects the configured application-wide value of `settingId`, excluding the
+ * registered default and workspace/folder layers.
+ */
+export declare function inspectValue<T>(configurationService: IConfigurationService, settingId: string): readonly [
+    value: T,
+    source: "policyValue" | "userValue" | "applicationValue"
+] | undefined;
+/**
+ * A setting that declares {@link IAgentHostConfigurationSync}, paired with the
+ * setting id it was declared on.
+ */
+export interface IAgentHostConfigurationSyncEntry {
+    readonly settingId: string;
+    readonly sync: IAgentHostConfigurationSync;
+}
+export declare enum AgentHostConfigurationSyncTarget {
+    Local = 0,
+    RemoteExtensionHost = 1,
+    Remote = 2
+}
+export declare function getAgentHostConfigurationSyncTarget(identity: AgentHostResourceIdentity): AgentHostConfigurationSyncTarget;
+/**
+ * Returns every setting that declares agent-host mirroring and applies to a host
+ * of this target kind.
+ */
+export declare function getAgentHostConfigurationSyncEntries(target: AgentHostConfigurationSyncTarget): IAgentHostConfigurationSyncEntry[];
+/**
+ * Reads the current globally-scoped value for `entry` and maps it through the
+ * entry's transform, producing the single-key patch to merge into the agent
+ * host's root config.
+ */
+export declare function resolveAgentHostConfigurationSyncValue(configurationService: IConfigurationService, entry: IAgentHostConfigurationSyncEntry): unknown;
+/**
+ * Renders a mirrored value for logging, redacting anything that could carry
+ * user content. Mirrored settings are registry-driven and may hold paths or
+ * arbitrary strings, so only closed-set values (booleans, numbers, and declared
+ * enum members) are printed verbatim.
+ */
+export declare function formatAgentHostConfigurationSyncValueForLog(settingId: string, value: unknown): string;
+/**
+ * Builds the full root-config patch mirroring every applicable setting. Used on
+ * connect and reconnect, where the host may be a freshly restarted process that
+ * has none of these values.
+ */
+export declare function resolveAgentHostConfigurationSyncPatch(configurationService: IConfigurationService, target: AgentHostConfigurationSyncTarget): Record<string, unknown>;

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

@@ -0,0 +1,128 @@
+
+import { Schemas } from '../../../base/common/network.js';
+import { URI } from '../../../base/common/uri.js';
+import { Extensions, AgentHostConfigurationSyncScope } from '../../configuration/common/configurationRegistry.js';
+import { Registry } from '../../registry/common/platform.js';
+import { LOCAL_AGENT_HOST_RESOURCE_IDENTITY } from './agentHostResourceService.js';
+
+function getRegistry() {
+    return ( Registry.as(Extensions.Configuration));
+}
+function getPropertySchema(settingId) {
+    const registry = getRegistry();
+    return registry.getConfigurationProperties()[settingId] ?? registry.getExcludedConfigurationProperties()[settingId];
+}
+function matchesSchemaType(value, type) {
+    if (type === undefined) {
+        return true;
+    }
+    if (Array.isArray(type)) {
+        return ( type.some(candidate => matchesSchemaType(value, candidate)));
+    }
+    switch (type) {
+    case "boolean":
+        return typeof value === "boolean";
+    case "string":
+        return typeof value === "string";
+    case "number":
+        return typeof value === "number";
+    case "integer":
+        return typeof value === "number" && Number.isInteger(value);
+    case "array":
+        return Array.isArray(value);
+    case "object":
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    case "null":
+        return value === null;
+    default:
+        return true;
+    }
+}
+function getGlobalConfigurationValue(configurationService, settingId) {
+    const inspected = configurationService.inspect(settingId);
+    const property = getPropertySchema(settingId);
+    for (const value of [inspected.policyValue, inspected.userValue, inspected.applicationValue]) {
+        if (value !== undefined && matchesSchemaType(value, property?.type)) {
+            return value;
+        }
+    }
+    return inspected.defaultValue ?? property?.default;
+}
+function inspectValue(configurationService, settingId) {
+    const inspected = configurationService.inspect(settingId);
+    const property = getPropertySchema(settingId);
+    const values = [
+        ["policyValue", inspected.policyValue],
+        ["userValue", inspected.userValue],
+        ["applicationValue", inspected.applicationValue]
+    ];
+    for (const [source, value] of values) {
+        if (value !== undefined && matchesSchemaType(value, property?.type)) {
+            return [value, source];
+        }
+    }
+    return undefined;
+}
+var AgentHostConfigurationSyncTarget;
+(function(AgentHostConfigurationSyncTarget) {
+    AgentHostConfigurationSyncTarget[AgentHostConfigurationSyncTarget["Local"] = 0] = "Local";
+    AgentHostConfigurationSyncTarget[AgentHostConfigurationSyncTarget["RemoteExtensionHost"] = 1] = "RemoteExtensionHost";
+    AgentHostConfigurationSyncTarget[AgentHostConfigurationSyncTarget["Remote"] = 2] = "Remote";
+})(
+    AgentHostConfigurationSyncTarget || (AgentHostConfigurationSyncTarget = {})
+);
+function getAgentHostConfigurationSyncTarget(identity) {
+    if (identity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY) {
+        return AgentHostConfigurationSyncTarget.Local;
+    }
+    return ( URI.parse(identity)).scheme === Schemas.vscodeRemote ? AgentHostConfigurationSyncTarget.RemoteExtensionHost : AgentHostConfigurationSyncTarget.Remote;
+}
+function includesTarget(scope, target) {
+    switch (scope ?? AgentHostConfigurationSyncScope.All) {
+    case AgentHostConfigurationSyncScope.All:
+        return true;
+    case AgentHostConfigurationSyncScope.Local:
+        return target === AgentHostConfigurationSyncTarget.Local;
+    case AgentHostConfigurationSyncScope.Ambient:
+        return target === AgentHostConfigurationSyncTarget.Local || target === AgentHostConfigurationSyncTarget.RemoteExtensionHost;
+    }
+}
+function getAgentHostConfigurationSyncEntries(target) {
+    const entries = [];
+    for (const [settingId, sync] of getRegistry().getAgentHostSyncConfigurations()) {
+        if (!includesTarget(sync.scope, target)) {
+            continue;
+        }
+        entries.push({
+            settingId,
+            sync
+        });
+    }
+    return entries;
+}
+function resolveAgentHostConfigurationSyncValue(configurationService, entry) {
+    const value = getGlobalConfigurationValue(configurationService, entry.settingId);
+    return entry.sync.transform ? entry.sync.transform(value) : value;
+}
+function formatAgentHostConfigurationSyncValueForLog(settingId, value) {
+    if (typeof value === "boolean" || typeof value === "number") {
+        return String(value);
+    }
+    const property = getPropertySchema(settingId);
+    if (typeof value === "string" && property?.enum?.includes(value)) {
+        return value;
+    }
+    return `<${Array.isArray(value) ? "array" : typeof value}>`;
+}
+function resolveAgentHostConfigurationSyncPatch(configurationService, target) {
+    const patch = {};
+    for (const entry of getAgentHostConfigurationSyncEntries(target)) {
+        const value = resolveAgentHostConfigurationSyncValue(configurationService, entry);
+        if (value !== undefined) {
+            patch[entry.sync.key] = value;
+        }
+    }
+    return patch;
+}
+
+export { AgentHostConfigurationSyncTarget, formatAgentHostConfigurationSyncValueForLog, getAgentHostConfigurationSyncEntries, getAgentHostConfigurationSyncTarget, getGlobalConfigurationValue, inspectValue, resolveAgentHostConfigurationSyncPatch, resolveAgentHostConfigurationSyncValue };

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

@@ -1,5 +1,6 @@
 import type { URI } from "../../../base/common/uri.js";
-import type { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import type { IAgentConnection } from "./agentService.js";
+import type { DefaultChangesetKind } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/changesetUri";
 /**
  * Chat-session resource scheme prefix for the window's ambient/local agent
  * host: `agent-host-<provider>`.
@@ -46,10 +47,24 @@ export interface IAgentHostConnectionInfo {
 }
 /**
  * The result of resolving a chat-session resource to its backing agent host:
- * the owning {@link IAgentConnection} and the canonical backend agent-session
- * URI (`<provider>:/<rawId>`) used for protocol operations on that connection.
+ * the owning {@link IAgentConnection}, its authority, and the canonical backend
+ * agent-session URI used for protocol operations on that connection.
  */
-export interface IAgentHostSessionResolution {
-    readonly connection: IAgentConnection;
+export interface IAgentHostSessionIdentity {
+    readonly connectionAuthority: string;
     readonly backendSession: URI;
+    readonly defaultChangesetKind?: DefaultChangesetKind;
+}
+export interface IAgentHostSessionResolution extends IAgentHostSessionIdentity {
+    readonly connection: IAgentConnection;
+}
+/** Provider-owned policy needed to resolve a workbench session resource back to its host. */
+export interface IAgentHostSessionResolutionPolicy {
+    readonly sessionSchemeAlias?: IAgentHostSessionSchemeAlias;
+    readonly defaultChangesetKind?: DefaultChangesetKind;
+}
+/** The UI and backend schemes for a session whose provider and host identities differ. */
+export interface IAgentHostSessionSchemeAlias {
+    readonly ui: string;
+    readonly backend: string;
 }

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

@@ -1,25 +1,29 @@
 import { Event } from "../../../base/common/event.js";
+import { IDisposable } from "../../../base/common/lifecycle.js";
 import { URI } from "../../../base/common/uri.js";
-import { IAgentHostConnectionInfo, IAgentHostSessionResolution } from "./agentHostConnectionsService.js";
-import { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { IAgentHostConnectionInfo, IAgentHostSessionResolutionPolicy, IAgentHostSessionIdentity, IAgentHostSessionResolution } from "./agentHostConnectionsService.js";
+import { IAgentConnection } from "./agentService.js";
 export declare const IAgentHostConnectionsService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostConnectionsService>;
 /**
-* A thin, read-only facade over the window's ambient agent host
+* A facade over the window's ambient agent host
 * (`IAgentHostService`) and the registry of remote agent hosts
 * (`IRemoteAgentHostService`), so consumers can enumerate and resolve
 * {@link IAgentConnection}s without branching on local-vs-remote or
-* fanning out over "1 ambient + N remote" themselves.
+* fanning out over "1 ambient + N remote" themselves. Session providers may
+* register declarative scheme/default-changeset policy so every consumer
+* resolves provider-specific session resources consistently.
 *
-* This service deliberately does NOT expose lifecycle/management operations:
+* This service deliberately does NOT expose connection lifecycle operations:
 * ambient-process concerns (restart, inspect, auth-pending) stay on
 * `IAgentHostService`, and remote-registry mutations (add/remove/reconnect/
-* upgrade) stay on `IRemoteAgentHostService`. This facade only answers
-* "which connections exist?" and "give me the connection for X".
+* upgrade) stay on `IRemoteAgentHostService`.
 */
 export interface IAgentHostConnectionsService {
     readonly _serviceBrand: undefined;
     /** Fires when the set of connections changes (ambient lifecycle or remotes added/removed). */
     readonly onDidChangeConnections: Event<void>;
+    /** Fires when connection or provider policy changes can alter session-resource resolution. */
+    readonly onDidChangeSessionResolution: Event<void>;
     /**
     * All known connections as `[ambient, ...remotes]`. The ambient entry is
     * always present with a live `connection`; only remote entries may have
@@ -42,6 +46,16 @@ export interface IAgentHostConnectionsService {
     */
     getConnectionByAddress(address: string): IAgentConnection | undefined;
     /**
+    * Registers provider-owned session resolution policy for a connection.
+    * At most one policy may be registered for an authority.
+    */
+    registerSessionResolutionPolicy(authority: string, policy: IAgentHostSessionResolutionPolicy): IDisposable;
+    /**
+    * Resolves an agent-host chat-session resource to its connection authority
+    * and backend session URI without requiring the host to be connected.
+    */
+    resolveSessionResourceIdentity(sessionResource: URI): IAgentHostSessionIdentity | undefined;
+    /**
     * Resolves an agent-host chat-session resource to its owning connection and
     * backend session URI. Handles both local schemes
     * (`agent-host-<provider>`) — backed by the ambient connection — and remote

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

@@ -0,0 +1,10 @@
+import { URI } from "../../../base/common/uri.js";
+/**
+ * URI scheme for synthetic built-in customizations that carry discovery and invocation metadata, but no readable file content.
+ */
+export declare const AGENT_BUILTIN_CUSTOMIZATION_SCHEME = "agent-builtin";
+/**
+ * Checks raw host URIs and client-wrapped Agent Host URIs for the built-in customization scheme.
+ */
+export declare function isAgentBuiltinCustomizationUri(resource: URI): boolean;
+export declare function hasReadableCustomizationContent(resource: URI): boolean;

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

@@ -0,0 +1,12 @@
+
+import { fromAgentHostUri } from './agentHostUri.js';
+
+const AGENT_BUILTIN_CUSTOMIZATION_SCHEME = 'agent-builtin';
+function isAgentBuiltinCustomizationUri(resource) {
+    return fromAgentHostUri(resource).scheme === AGENT_BUILTIN_CUSTOMIZATION_SCHEME;
+}
+function hasReadableCustomizationContent(resource) {
+    return !isAgentBuiltinCustomizationUri(resource);
+}
+
+export { AGENT_BUILTIN_CUSTOMIZATION_SCHEME, hasReadableCustomizationContent, isAgentBuiltinCustomizationUri };

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

@@ -0,0 +1,7 @@
+import { RawContextKey } from "../../contextkey/common/contextkey.js";
+/** Context key set by {@link IAgentHostEnablementService}. Use in `when` clauses to gate Agent Host UI. */
+export declare const AGENT_HOST_ENABLED_CONTEXT_KEY: RawContextKey<boolean>;
+/** Hidden setting that gates the current-harness indicator for existing Agent Host sessions in the main VS Code window. */
+export declare const AgentHostExistingSessionHarnessPickerEnabledSettingId = "chat.editor.agentHost.existingSessionHarnessPicker.enabled";
+/** Effective setting or experiment value for the existing-session harness indicator in the main VS Code window. */
+export declare const AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY: RawContextKey<boolean>;

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

@@ -0,0 +1,92 @@
+
+import { PolicyCategory } from '../../../base/common/policy.js';
+import { localize } from '../../../nls.js';
+import { Extensions } from '../../configuration/common/configurationRegistry.js';
+import { RawContextKey } from '../../contextkey/common/contextkey.js';
+import { Registry } from '../../registry/common/platform.js';
+
+const AGENT_HOST_ENABLED_CONTEXT_KEY = ( new RawContextKey("agentHostEnabled", false, {
+    type: "boolean",
+    description: ( localize(
+        1852,
+        "Whether Agent Host features are available and AI features are enabled in this window."
+    ))
+}));
+const AgentHostExistingSessionHarnessPickerEnabledSettingId = "chat.editor.agentHost.existingSessionHarnessPicker.enabled";
+const AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY = ( new RawContextKey("agentHostExistingSessionHarnessPickerEnabled", false, {
+    type: "boolean",
+    description: ( localize(
+        1853,
+        "Whether existing Agent Host sessions in the main VS Code window show the current harness as a disabled picker."
+    ))
+}));
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: "chatAgentHost",
+    title: ( localize(1854, "Chat Agent Host")),
+    type: "object",
+    properties: {
+        "chat.editor.preferCopilotHarness": {
+            type: "boolean",
+            description: ( localize(
+                1855,
+                "When enabled, uses the Agent Host Copilot SDK whenever the local harness would otherwise be selected for a new editor chat session. Claude and Codex selections are unaffected."
+            )),
+            default: false,
+            tags: ["experimental"],
+            experiment: {
+                mode: "startup"
+            },
+            policy: {
+                name: "ChatEditorPreferCopilotHarness",
+                category: PolicyCategory.InteractiveSession,
+                minimumVersion: "1.134",
+                localization: {
+                    description: {
+                        key: "chat.editor.preferCopilotHarness.policy",
+                        value: ( localize(
+                            1856,
+                            "Configure whether VS Code uses the Agent Host Copilot SDK instead of the local harness for new editor chat sessions."
+                        ))
+                    }
+                }
+            }
+        },
+        "chat.defaultToCopilotHarness": {
+            type: "boolean",
+            description: ( localize(
+                1857,
+                "When enabled, new editor and panel chat sessions default to the Agent Host Copilot SDK instead of the local harness."
+            )),
+            default: false,
+            tags: ["experimental"],
+            experiment: {
+                mode: "startup"
+            }
+        },
+        "chat.editor.localAgent.enabled": {
+            type: "boolean",
+            description: ( localize(
+                1858,
+                "When enabled, shows the VS Code local chat harness in the chat picker. This setting is ignored in virtual workspaces, where the local chat harness is always available."
+            )),
+            default: true,
+            tags: ["experimental"],
+            experiment: {
+                mode: "startup"
+            }
+        },
+        [AgentHostExistingSessionHarnessPickerEnabledSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                1859,
+                "When enabled, existing Agent Host sessions in the main VS Code window show the current harness as a disabled picker."
+            )),
+            default: false,
+            included: false,
+            tags: ["experimental"]
+        }
+    }
+});
+
+export { AGENT_HOST_ENABLED_CONTEXT_KEY, AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY, AgentHostExistingSessionHarnessPickerEnabledSettingId };

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

@@ -0,0 +1,21 @@
+import { IObservable } from "../../../base/common/observable.js";
+export declare const IAgentHostEnablementService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostEnablementService>;
+export interface IAgentHostEnablementService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Whether Agent Host features are available and AI features are enabled in this window.
+    */
+    readonly enabled: IObservable<boolean>;
+    /**
+    * Whether an enterprise has mandated the Copilot SDK sandbox floor through managed settings
+    * (`sandbox.enabled`). The runtime owns composing and enforcing that floor; VS Code reads it
+    * only to retire the legacy local harness for governed users, since the sandbox is implemented
+    * by the Agent Host.
+    *
+    * A user- or workspace-level sandbox opt-in is not an enterprise decision and does not set
+    * this. Existing local chat sessions keep working; only the harness used for *new* chats is
+    * affected, and virtual workspaces are exempt.
+    */
+    readonly managedSandboxEnforced: IObservable<boolean>;
+    readonly managedSandboxAllowsBypass: IObservable<boolean>;
+}

package/vscode/src/vs/platform/agentHost/common/agentHostEnablementService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const IAgentHostEnablementService = ( createDecorator("agentHostEnablementService"));
+
+export { IAgentHostEnablementService };

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

@@ -0,0 +1,97 @@
+/**
+ * Schema version for the shared local agent-host endpoint registry under
+ * `<userDataPath>/agent-host/local-endpoint/`. Each running agent host owns
+ * one immutable entry file at `entries/<sha256hex>.json`; readers additionally
+ * merge any legacy `metadata.json` array left by older builds (read-only). This
+ * schema is shared with the Rust CLI
+ * (`cli/src/tunnels/agent_host_registry.rs`); field renames or removals MUST be
+ * coordinated across both languages.
+ *
+ * Version 1 was the editor-only, socket-path-only schema
+ * (`ILocalAgentHostEndpointMetadata` in `node/localAgentHostMetadata.ts`).
+ * Version 2 generalizes the registry to hold both editor (socket/pipe) and
+ * standalone CLI (TCP) endpoints so every locally running agent host is
+ * discoverable from one place. Changing the on-disk container (one file per
+ * instance vs. the historical single shared array) did not change this
+ * serialized entry shape or `AGENT_HOST_ENDPOINT_REGISTRY_SCHEMA_VERSION`.
+ */
+export declare const AGENT_HOST_ENDPOINT_REGISTRY_SCHEMA_VERSION = 2;
+/**
+ * Kind of process that owns an agent host endpoint. Controls
+ * ownership/default-selection policy on the client; it is not by itself a
+ * measure of trust or of registry identity (see {@link IAgentHostEndpointIdentity}).
+ */
+export type AgentHostServerType = "editor" | "standalone";
+/**
+ * How to physically connect to an endpoint. Editor endpoints are always a
+ * Unix domain socket or Windows named pipe; the standalone Rust CLI
+ * currently only ever publishes a TCP endpoint.
+ */
+export type AgentHostEndpointAddress = {
+    readonly type: "socket";
+    readonly path: string;
+} | {
+    readonly type: "tcp";
+    readonly host: string;
+    readonly port: number;
+};
+/**
+ * One entry of the shared local agent-host endpoint registry. Each live
+ * agent host serializes exactly one of these as its own
+ * `entries/<sha256hex>.json` file; a legacy `metadata.json` (and the
+ * `code agent endpoints` SSH inventory) instead carries a JSON array of them.
+ */
+export interface IAgentHostEndpointMetadata {
+    readonly schemaVersion: typeof AGENT_HOST_ENDPOINT_REGISTRY_SCHEMA_VERSION;
+    readonly type: AgentHostServerType;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly protocolVersion: string;
+    readonly connectionToken: string;
+    readonly endpoint: AgentHostEndpointAddress;
+    readonly quality?: string;
+    readonly tunnelName?: string;
+}
+/**
+ * The subset of {@link IAgentHostEndpointMetadata} that identifies a unique
+ * registry entry/owner: `(type, pid, instanceId)`. `instanceId` makes
+ * identity safe across PID reuse and rapid process replacement; `pid` alone
+ * is not a safe key because operating systems recycle PIDs.
+ */
+export interface IAgentHostEndpointIdentity {
+    readonly type: AgentHostServerType;
+    readonly pid: number;
+    readonly instanceId: string;
+}
+/**
+ * Structurally validates one raw registry entry and returns it typed, or
+ * `undefined` if it is malformed or its `schemaVersion` is not the one this
+ * build understands. Every field is treated as untrusted input.
+ */
+export declare function parseAgentHostEndpointMetadataEntry(raw: unknown): IAgentHostEndpointMetadata | undefined;
+/**
+ * Parses an array-shaped registry payload (`AgentHostEndpointMetadata[]`) —
+ * a legacy `metadata.json` file or the `code agent endpoints` SSH inventory.
+ * Every entry is validated independently: malformed entries and entries with
+ * an unsupported `schemaVersion` are dropped rather than failing the entire
+ * read. A non-array top-level value yields an empty registry.
+ */
+export declare function parseAgentHostEndpointRegistry(raw: unknown): IAgentHostEndpointMetadata[];
+/** Stable string key for `(type, pid, instanceId)`, suitable for use as a Map key. */
+export declare function getAgentHostEndpointIdentityKey(identity: IAgentHostEndpointIdentity): string;
+/**
+ * Canonical UTF-8 input hashed to derive an identity's `<sha256hex>.json` entry
+ * file name. The `\0` separators are unambiguous (no field contains NUL) and the
+ * encoding is shared byte-for-byte with the Rust CLI; it MUST NOT change without
+ * a coordinated update on both sides.
+ */
+export declare function getAgentHostEndpointIdentityHashInput(identity: IAgentHostEndpointIdentity): string;
+export declare function isSameAgentHostEndpointIdentity(a: IAgentHostEndpointIdentity, b: IAgentHostEndpointIdentity): boolean;
+/**
+ * Deduplicates entries by `(type, pid, instanceId)`. If a duplicate identity
+ * appears more than once (for example a legacy `metadata.json` entry and a
+ * newer per-instance entry file both describe the same owner), the entry
+ * encountered later in `entries` wins, since it is presumed to be the most
+ * recently written copy.
+ */
+export declare function dedupeAgentHostEndpointMetadata(entries: readonly IAgentHostEndpointMetadata[]): IAgentHostEndpointMetadata[];

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

@@ -1,4 +1,6 @@
-import { McpServerState, type McpServerStatus } from "./state/protocol/channels-session/state.js";
+import { URI } from "../../../base/common/uri.js";
+import { McpServerStatus, type CustomizationEnablement, type McpServerState, type TextRange } from "./state/protocol/state.js";
+import { CustomizationDisabledReason } from "./customizationEnablement.js";
 /**
  * A rich view of a single MCP server exposed by an agent host session.
  * Encapsulates the dispatch plumbing so consumers can present and toggle
@@ -8,8 +10,19 @@ export interface IAgentHostMcpServer {
     readonly id: string;
     readonly name: string;
     readonly enabled: boolean;
+    readonly enablement?: readonly CustomizationEnablement[];
+    readonly isPluginProvided?: boolean;
+    readonly isClientBundled?: boolean;
+    readonly owningPluginClientId?: string;
+    readonly disabledReason?: CustomizationDisabledReason;
     readonly status: McpServerStatus;
     readonly state: McpServerState;
+    readonly sourceUri?: URI;
+    readonly sourceRange?: TextRange;
     readonly logOutputChannelId?: string;
+    /** Starts or restarts the server. Providers that cannot control lifecycle may no-op. */
+    start(): Promise<void>;
+    /** Stops the server. Providers that cannot control lifecycle may no-op. */
+    stop(): Promise<void>;
     setEnabled(enabled: boolean): void;
 }