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

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

@@ -1,8 +1,9 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IAhpJsonlLoggerOptions } from "../common/ahpJsonlLogger.js";
+import { AgentHostClientConnectionKind } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostTelemetry";
 import type { AhpServerNotification, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ProtocolMessage } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
-import type { IClientTransport } from "../common/state/sessionTransport.js";
+import type { IClientTransport } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionTransport";
 /**
  * A WebSocket client transport that connects to a remote agent host server.
  * Uses the native browser WebSocket API (available in Electron renderer).
@@ -11,6 +12,7 @@ import type { IClientTransport } from "../common/state/sessionTransport.js";
 export declare class WebSocketClientTransport extends Disposable implements IClientTransport {
     private readonly _address;
     private readonly _connectionToken;
+    readonly clientConnectionKind = AgentHostClientConnectionKind.DirectWebSocket;
     private readonly _onMessage;
     readonly onMessage: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ProtocolMessage>;
     private readonly _onClose;

package/vscode/src/vs/platform/agentHost/browser/webSocketClientTransport.js

@@ -5,6 +5,7 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { connectionTokenQueryName } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { AhpJsonlLogger, getAhpLogByteLength } from '../common/ahpJsonlLogger.js';
+import { AgentHostClientConnectionKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostTelemetry';
 import { MALFORMED_FRAMES_LOG_CAP, MALFORMED_FRAMES_FORCE_CLOSE_THRESHOLD } from '../common/transportConstants.js';
 
 let WebSocketClientTransport = class WebSocketClientTransport extends Disposable {
@@ -15,6 +16,7 @@ let WebSocketClientTransport = class WebSocketClientTransport extends Disposable
         super();
         this._address = _address;
         this._connectionToken = _connectionToken;
+        this.clientConnectionKind = AgentHostClientConnectionKind.DirectWebSocket;
         this._onMessage = this._register(( new Emitter()));
         this.onMessage = this._onMessage.event;
         this._onClose = this._register(( new Emitter()));

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

@@ -0,0 +1,9 @@
+import type { Implementation } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands";
+export declare enum AgentHostClientType {
+    EditorWindow = "editor_window",
+    AgentsWindow = "agents_window",
+    Unknown = "unknown"
+}
+export declare const editorWindowAgentHostClientInfo: Readonly<Implementation>;
+export declare const agentsWindowAgentHostClientInfo: Readonly<Implementation>;
+export declare function getAgentHostClientType(clientInfo: Implementation | undefined): AgentHostClientType;

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

@@ -0,0 +1,20 @@
+
+
+const EDITOR_WINDOW_CLIENT_NAME = "vscode-editor-window";
+const AGENTS_WINDOW_CLIENT_NAME = "vscode-agents-window";
+var AgentHostClientType;
+(function(AgentHostClientType) {
+    AgentHostClientType["EditorWindow"] = "editor_window";
+    AgentHostClientType["AgentsWindow"] = "agents_window";
+    AgentHostClientType["Unknown"] = "unknown";
+})(AgentHostClientType || (AgentHostClientType = {}));
+const editorWindowAgentHostClientInfo = ( Object.freeze({
+    name: EDITOR_WINDOW_CLIENT_NAME,
+    title: "VS Code"
+}));
+const agentsWindowAgentHostClientInfo = ( Object.freeze({
+    name: AGENTS_WINDOW_CLIENT_NAME,
+    title: "VS Code Agents Window"
+}));
+
+export { AgentHostClientType, agentsWindowAgentHostClientInfo, editorWindowAgentHostClientInfo };

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

@@ -0,0 +1,144 @@
+import { type ValidatorType } from "@codingame/monaco-vscode-api/vscode/vs/base/common/validation";
+import type { AgentHostDebugLogsArtifactKind, IAgentHostManagedSettingsDiagnostics, IAgentHostNetworkDiagnosticsInfo, IAgentHostNetworkFetchResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import type { InitializeResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands";
+import { AgentHostArtifactRemovalCapabilityMetaKey } from "./meta/agentHostArtifactRemovalMeta.js";
+export { supportsAgentHostArtifactRemoval } from "./meta/agentHostArtifactRemovalMeta.js";
+export declare const CollectAgentHostDebugLogsExtensionMethod = "vscode/collectAgentHostDebugLogs";
+export declare const GetAgentHostSessionStateFileExtensionMethod = "vscode/getAgentHostSessionStateFile";
+export declare const CreateAgentHostDetachedWorktreeExtensionMethod = "vscode/createAgentHostDetachedWorktree";
+export declare const ClaimAgentHostDetachedWorktreeExtensionMethod = "vscode/claimAgentHostDetachedWorktree";
+export declare const DeleteAgentHostDetachedWorktreeExtensionMethod = "vscode/deleteAgentHostDetachedWorktree";
+export declare const ReconcileAgentHostDetachedWorktreesExtensionMethod = "vscode/reconcileAgentHostDetachedWorktrees";
+export declare const ReadAgentHostDebugLogsChunkExtensionMethod = "vscode/readAgentHostDebugLogsChunk";
+export declare const SetAgentHostDetachedWorktreeArchivedExtensionMethod = "vscode/setAgentHostDetachedWorktreeArchived";
+export declare const RequestAgentHostWorkspaceTrustExtensionMethod = "vscode/requestWorkspaceTrust";
+export declare const RemoveSessionArtifactExtensionMethod = "vscode/removeSessionArtifact";
+declare const AgentHostChatStateFileCapabilityMetaKey = "vscode.getAgentHostSessionStateFile.chat";
+declare const AgentHostDetachedWorktreeCapabilityMetaKey = "vscode.detachedWorktrees";
+export interface IAgentHostExtensionInitializeResultMeta extends Record<string, unknown> {
+    readonly [AgentHostChatStateFileCapabilityMetaKey]?: true;
+    readonly [AgentHostDetachedWorktreeCapabilityMetaKey]?: true;
+    readonly [AgentHostArtifactRemovalCapabilityMetaKey]?: true;
+}
+export interface IAgentHostExtensionInitializeResult extends InitializeResult {
+    readonly _meta?: IAgentHostExtensionInitializeResultMeta;
+}
+export declare function getAgentHostExtensionInitializeResultMeta(artifactRemoval?: boolean): IAgentHostExtensionInitializeResultMeta;
+export declare function supportsAgentHostChatStateFile(result: IAgentHostExtensionInitializeResult | undefined): boolean;
+export declare function supportsAgentHostDetachedWorktrees(result: IAgentHostExtensionInitializeResult | undefined): boolean;
+export declare const collectAgentHostDebugLogsParamsValidator: import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").ValidatorBase<import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").vObjType<{
+    session: import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").Optional<import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").IValidator<string>>;
+    chat: import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").Optional<import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").IValidator<string>>;
+    kind: import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").ValidatorBase<"archive" | "directory">;
+}>>;
+export type CollectAgentHostDebugLogsParams = ValidatorType<typeof collectAgentHostDebugLogsParamsValidator>;
+export declare const removeSessionArtifactParamsValidator: import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").ValidatorBase<import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").vObjType<{
+    session: import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").ValidatorBase<string>;
+    artifactId: import("@codingame/monaco-vscode-api/vscode/vs/base/common/validation").ValidatorBase<string>;
+}>>;
+export interface IAgentHostExtensionCommandMap {
+    [RemoveSessionArtifactExtensionMethod]: {
+        params: ValidatorType<typeof removeSessionArtifactParamsValidator>;
+        result: void;
+    };
+    "shutdown": {
+        params: undefined;
+        result: void;
+    };
+    "getNetworkDiagnosticsInfo": {
+        params: undefined;
+        result: IAgentHostNetworkDiagnosticsInfo;
+    };
+    "getManagedSettingsDiagnostics": {
+        params: undefined;
+        result: readonly IAgentHostManagedSettingsDiagnostics[];
+    };
+    "diagnosticsFetch": {
+        params: {
+            url: string;
+        };
+        result: IAgentHostNetworkFetchResult;
+    };
+    [GetAgentHostSessionStateFileExtensionMethod]: {
+        params: {
+            session: string;
+            chat?: string;
+        };
+        result: {
+            resource?: string;
+        };
+    };
+    [CreateAgentHostDetachedWorktreeExtensionMethod]: {
+        params: {
+            session: string;
+            prompt: string;
+        };
+        result: {
+            handle: string;
+            resource: string;
+        };
+    };
+    [ClaimAgentHostDetachedWorktreeExtensionMethod]: {
+        params: {
+            handle: string;
+        };
+        result: void;
+    };
+    [SetAgentHostDetachedWorktreeArchivedExtensionMethod]: {
+        params: {
+            handle: string;
+            archived: boolean;
+        };
+        result: void;
+    };
+    [DeleteAgentHostDetachedWorktreeExtensionMethod]: {
+        params: {
+            handle: string;
+        };
+        result: void;
+    };
+    [ReconcileAgentHostDetachedWorktreesExtensionMethod]: {
+        params: {
+            scope: string;
+            activeHandles: string[];
+        };
+        result: void;
+    };
+    [CollectAgentHostDebugLogsExtensionMethod]: {
+        params: CollectAgentHostDebugLogsParams;
+        result: {
+            kind: AgentHostDebugLogsArtifactKind;
+            resource: string;
+            providerLogsIncluded: boolean;
+            size: number;
+            uncompressedSize: number;
+            entries: readonly {
+                path: string;
+                size: number;
+            }[];
+        };
+    };
+    [ReadAgentHostDebugLogsChunkExtensionMethod]: {
+        params: {
+            resource: string;
+            position: number;
+        };
+        /** `data` is base64; at most `AGENT_HOST_DEBUG_LOGS_CHUNK_BYTES` decoded bytes. */
+        result: {
+            data: string;
+            eof: boolean;
+        };
+    };
+}
+export interface IAgentHostWorkspaceTrustRequest {
+    readonly workspace: string;
+    readonly trustedParent?: string;
+}
+export interface IAgentHostExtensionServerCommandMap {
+    [RequestAgentHostWorkspaceTrustExtensionMethod]: {
+        params: IAgentHostWorkspaceTrustRequest;
+        result: {
+            trusted: boolean;
+        };
+    };
+}

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

@@ -0,0 +1,20 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+
+const CollectAgentHostDebugLogsExtensionMethod = 'vscode/collectAgentHostDebugLogs';
+const GetAgentHostSessionStateFileExtensionMethod = 'vscode/getAgentHostSessionStateFile';
+const CreateAgentHostDetachedWorktreeExtensionMethod = 'vscode/createAgentHostDetachedWorktree';
+const ClaimAgentHostDetachedWorktreeExtensionMethod = 'vscode/claimAgentHostDetachedWorktree';
+const DeleteAgentHostDetachedWorktreeExtensionMethod = 'vscode/deleteAgentHostDetachedWorktree';
+const ReconcileAgentHostDetachedWorktreesExtensionMethod = 'vscode/reconcileAgentHostDetachedWorktrees';
+const ReadAgentHostDebugLogsChunkExtensionMethod = 'vscode/readAgentHostDebugLogsChunk';
+const SetAgentHostDetachedWorktreeArchivedExtensionMethod = 'vscode/setAgentHostDetachedWorktreeArchived';
+const RequestAgentHostWorkspaceTrustExtensionMethod = 'vscode/requestWorkspaceTrust';
+const RemoveSessionArtifactExtensionMethod = 'vscode/removeSessionArtifact';
+const AgentHostChatStateFileCapabilityMetaKey = 'vscode.getAgentHostSessionStateFile.chat';
+function supportsAgentHostChatStateFile(result) {
+    const meta = result?._meta;
+    return meta?.[AgentHostChatStateFileCapabilityMetaKey] === true;
+}
+
+export { ClaimAgentHostDetachedWorktreeExtensionMethod, CollectAgentHostDebugLogsExtensionMethod, CreateAgentHostDetachedWorktreeExtensionMethod, DeleteAgentHostDetachedWorktreeExtensionMethod, GetAgentHostSessionStateFileExtensionMethod, ReadAgentHostDebugLogsChunkExtensionMethod, ReconcileAgentHostDetachedWorktreesExtensionMethod, RemoveSessionArtifactExtensionMethod, RequestAgentHostWorkspaceTrustExtensionMethod, SetAgentHostDetachedWorktreeArchivedExtensionMethod, supportsAgentHostChatStateFile };

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

@@ -2,7 +2,7 @@ import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event"
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProvider, IFileSystemProviderWithFileRealpathCapability, IFileWriteOptions, IStat, IWatchOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
-import { type CreateResourceWatchParams, type ResourceCopyParams, type ResourceCopyResult, type ResourceDeleteParams, type ResourceDeleteResult, type ResourceListResult, type ResourceMkdirParams, type ResourceMkdirResult, type ResourceMoveParams, type ResourceMoveResult, type ResourceReadResult, type ResourceRequestParams, type ResourceRequestResult, type ResourceResolveParams, type ResourceResolveResult, type ResourceWriteParams, type ResourceWriteResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { ContentEncoding, type CreateResourceWatchParams, type ResourceCopyParams, type ResourceCopyResult, type ResourceDeleteParams, type ResourceDeleteResult, type ResourceListResult, type ResourceMkdirParams, type ResourceMkdirResult, type ResourceMoveParams, type ResourceMoveResult, type ResourceReadResult, type ResourceRequestParams, type ResourceRequestResult, type ResourceResolveParams, type ResourceResolveResult, type ResourceWriteParams, type ResourceWriteResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
 import { type ActionEnvelope } from "./state/sessionActions.js";
 /**
  * Interface for performing resource operations on a remote endpoint.
@@ -12,7 +12,7 @@ import { type ActionEnvelope } from "./state/sessionActions.js";
  */
 export interface IRemoteFilesystemConnection {
     resourceList(uri: URI): Promise<ResourceListResult>;
-    resourceRead(uri: URI): Promise<ResourceReadResult>;
+    resourceRead(uri: URI, encoding?: ContentEncoding): Promise<ResourceReadResult>;
     resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
     resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
     resourceMove(params: ResourceMoveParams): Promise<ResourceMoveResult>;
@@ -34,10 +34,8 @@ export interface IRemoteFilesystemConnection {
      * reports under the watched root. Disposing the handle unsubscribes
      * the watch (subject to the receiver's grace window).
      *
-     * Optional: implementations that do not have access to the AHP
-     * subscription machinery (e.g. raw IPC channels in
-     * {@link createAgentHostClientResourceConnection}) omit it; the FS
-     * provider degrades to a no-op `watch()` in that case.
+     * Optional: implementations without subscription machinery omit it; the
+     * filesystem provider degrades to a no-op `watch()` in that case.
      */
     watchResource?(params: CreateResourceWatchParams): Promise<IRemoteWatchHandle>;
 }
@@ -142,6 +140,16 @@ export declare abstract class AHPFileSystemProvider extends Disposable implement
     /** Encode a remote URI back into a provider URI with the given authority. */
     protected abstract _encodeUri(resource: URI, authority: string): URI;
     watch(resource: URI, opts: IWatchOptions): IDisposable;
+    /**
+     * Whether `resource` addresses a protocol `ContentRef` rather than an entry
+     * in the host's filesystem. See {@link toAgentHostContentUri}.
+     *
+     * The scheme check covers content refs minted before the marker existed,
+     * such as ones persisted in restored editor state. It can go once those
+     * have aged out — and the marker itself can go if `resourceResolve` grows
+     * a way for a host to report a resource as readable but not resolvable.
+     */
+    private _isContentRef;
     stat(resource: URI): Promise<IStat>;
     realpath(resource: URI): Promise<string>;
     readdir(resource: URI): Promise<[

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

@@ -5,14 +5,15 @@ import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/even
 import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { FileChangeType, FileSystemProviderCapabilities, FilePermission, FileType, FileSystemProviderErrorCode, createFileSystemProviderError } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
-import { fromAgentHostUri, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { isAgentHostContentRefUri, fromAgentHostUri, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { ContentEncoding } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/commands';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/commands';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands';
-import { AhpErrorCodes } from './state/protocol/common/errors.js';
+import { AhpErrorCodes } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/errors';
 import { ProtocolError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
 import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
-import '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
 import { ROOT_STATE_URI } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 
 async function createRemoteWatchHandle(primitives, params) {
@@ -198,21 +199,24 @@ class AHPFileSystemProvider extends Disposable {
         void reattach();
         return store;
     }
+    _isContentRef(resource, decoded) {
+        return isAgentHostContentRefUri(resource) || decoded.scheme === "session-db" || decoded.scheme === "git-blob";
+    }
     async stat(resource) {
         const path = resource.path;
-        if (path === "/" || path === "") {
+        const decoded = this._decodeUri(resource);
+        if (this._isContentRef(resource, decoded)) {
             return {
-                type: FileType.Directory,
+                type: FileType.File,
                 mtime: 0,
                 ctime: 0,
                 size: 0,
                 permissions: FilePermission.Readonly
             };
         }
-        const decoded = this._decodeUri(resource);
-        if (decoded.scheme === "session-db" || decoded.scheme === "git-blob") {
+        if (path === "/" || path === "") {
             return {
-                type: FileType.File,
+                type: FileType.Directory,
                 mtime: 0,
                 ctime: 0,
                 size: 0,
@@ -247,7 +251,7 @@ class AHPFileSystemProvider extends Disposable {
             return path;
         }
         const decoded = this._decodeUri(resource);
-        if (decoded.scheme === "session-db" || decoded.scheme === "git-blob" || decoded.path === "/" || decoded.path === "") {
+        if (this._isContentRef(resource, decoded) || decoded.path === "/" || decoded.path === "") {
             return path;
         }
         const connection = await this._getConnection(resource.authority);
@@ -266,7 +270,7 @@ class AHPFileSystemProvider extends Disposable {
         const connection = await this._getConnection(resource.authority);
         try {
             const originalUri = this._decodeUri(resource);
-            const result = await connection.resourceRead(originalUri);
+            const result = await connection.resourceRead(originalUri, ContentEncoding.Base64);
             if (result.encoding === ContentEncoding.Base64) {
                 return decodeBase64(result.data).buffer;
             }

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

@@ -1,5 +1,6 @@
 
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
@@ -12,7 +13,6 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 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';
 
 const SYNCED_CUSTOMIZATION_SCHEME = "vscode-synced-customization";
 

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

@@ -0,0 +1,47 @@
+/**
+ * Construction and validation of Copilot SDK managed permission rules.
+ *
+ * The SDK parses every rule it receives with a strict grammar, and a single
+ * malformed rule rejects the **entire** managed permissions document rather
+ * than just the offending entry. Because VS Code sends this document as part of
+ * session create/resume, an untranslatable rule derived from a user's settings
+ * would fail the session outright. Everything this bridge emits therefore goes
+ * through {@link buildManagedRule}, which returns `undefined` for anything the
+ * SDK would reject so the caller can drop it and continue.
+ *
+ * The grammar mirrored here is `parse_managed_rule` in the agent runtime
+ * (`src/runtime/src/permissions/managed.rs`).
+ */
+/**
+ * Rule families the SDK understands. Any other family is a parse error for the
+ * whole document, so there is deliberately no escape hatch for arbitrary tool
+ * names — see `parse_managed_rule`'s "Unsupported managed permission rule
+ * family" branch.
+ */
+export declare enum ManagedRuleFamily {
+    /** Shell/terminal commands. Matches `Bash` and `PowerShell` on the SDK side too. */
+    Shell = "Shell",
+    /** File reads. */
+    Read = "Read",
+    /** File writes. The SDK treats `Edit` as an alias. */
+    Write = "Write",
+    /** Network access, matched as a URL pattern. */
+    Domain = "Domain"
+}
+/**
+ * A rule with no argument, which matches **every** request in its family — the
+ * SDK's matchers return `true` as soon as the family matches and the argument is
+ * absent. This is the only correct way to express "all of X"; an argument of
+ * `*` is *not* a universal wildcard for {@link ManagedRuleFamily.Domain},
+ * because domain arguments are normalized as URL patterns whose only wildcard
+ * form is a `*.host` subdomain match.
+ */
+export declare function buildManagedFamilyRule(family: ManagedRuleFamily): string;
+/**
+ * Builds a single managed permission rule, or returns `undefined` when the
+ * argument cannot be expressed in the SDK grammar.
+ *
+ * Callers must treat `undefined` as "this restriction is not translatable" and
+ * skip it — never fall back to a broader rule, which would silently over-restrict.
+ */
+export declare function buildManagedRule(family: ManagedRuleFamily, argument: string): string | undefined;

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

@@ -0,0 +1,75 @@
+
+
+var ManagedRuleFamily;
+(function(ManagedRuleFamily) {
+    ManagedRuleFamily["Shell"] = "Shell";
+    ManagedRuleFamily["Read"] = "Read";
+    ManagedRuleFamily["Write"] = "Write";
+    ManagedRuleFamily["Domain"] = "Domain";
+})(ManagedRuleFamily || (ManagedRuleFamily = {}));
+function buildManagedFamilyRule(family) {
+    return family;
+}
+function buildManagedRule(family, argument) {
+    if (!argument.trim() || !isValidRuleArgument(argument)) {
+        return undefined;
+    }
+    switch (family) {
+    case ManagedRuleFamily.Shell:
+        return isValidShellArgument(argument) ? `${family}(${argument})` : undefined;
+    case ManagedRuleFamily.Read:
+    case ManagedRuleFamily.Write:
+        return isValidPathArgument(argument) ? `${family}(${normalizePathSeparators(argument)})` : undefined;
+    case ManagedRuleFamily.Domain:
+        return isValidDomainArgument(argument) ? `${family}(${argument})` : undefined;
+    }
+}
+function isValidRuleArgument(argument) {
+    return !argument.includes(")") && !argument.includes("\n");
+}
+function isValidShellArgument(argument) {
+    if (argument === "*") {
+        return true;
+    }
+    const prefix = argument.endsWith(" *") ? argument.slice(0, -2).trimEnd() : argument;
+    return prefix.length > 0;
+}
+function isValidPathArgument(argument) {
+    if (argument.startsWith("!")) {
+        return false;
+    }
+    let depth = 0;
+    for (const char of argument) {
+        if (char === "{") {
+            depth++;
+        } else if (char === "}") {
+            if (--depth < 0) {
+                return false;
+            }
+        }
+    }
+    return depth === 0;
+}
+function normalizePathSeparators(argument) {
+    return argument.replace(/\\/g, "/");
+}
+function isValidDomainArgument(argument) {
+    if (argument.includes("$(") || argument.includes("${") || argument.includes("`")) {
+        return false;
+    }
+    const hasScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(argument);
+    if (!hasScheme && argument.includes("//")) {
+        return false;
+    }
+    if (argument === "*") {
+        return false;
+    }
+    try {
+        const url = ( new URL(hasScheme ? argument : `https://${argument}`));
+        return url.hostname.length > 0;
+    } catch {
+        return false;
+    }
+}
+
+export { ManagedRuleFamily, buildManagedFamilyRule, buildManagedRule };

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

@@ -0,0 +1,68 @@
+/**
+ * Compatibility bridge from legacy VS Code settings to Copilot SDK managed
+ * settings.
+ *
+ * Scope and limits, all deliberate:
+ *
+ * - **Restrictions only.** Mappings may add `deny`, `ask`, or the bypass lock;
+ *   they never widen what a session may do. In particular no `allow` list is
+ *   contributed, even to narrow another rule's reach: the SDK's managed `allow`
+ *   is not a scoping hint, since a covered request resolves to `managed_allow`,
+ *   which the runtime treats as outright approval and returns without prompting.
+ *   The runtime also intersects allow lists only when more than one managed
+ *   source supplies one, so a lone list from VS Code would grant blanket
+ *   auto-approval and could relax an MDM policy rather than reinforce it.
+ * - **Global layers only.** Values are read from policy, user, and application;
+ *   workspace and folder values are ignored, because the agent host is shared by
+ *   every window connected to it and one workspace's settings must not leak into
+ *   another window's sessions.
+ * - **Only what survives translation.** A setting is mapped only when its VS
+ *   Code semantics can be expressed exactly in the SDK's rule grammar. Where
+ *   they cannot — a regular-expression terminal rule, an allow list that blocks
+ *   what it omits — the restriction is skipped rather than approximated, since a
+ *   near-miss silently changes what an administrator configured.
+ * - **One deliberate exception, erring more restrictive.**
+ *   `chat.tools.eligibleForAutoApproval` marks individual tools ineligible for
+ *   auto-approval, but the SDK grammar has no tool-name family ({@link
+ *   ManagedRuleFamily} is only `Shell`, `Read`, `Write`, and `Domain`, and an
+ *   unknown family rejects the whole document). Rather than skip a genuine
+ *   restriction, a policy that marks any tool ineligible maps onto the
+ *   family-agnostic bypass lock — coarser and more restrictive, since the lock
+ *   is session-wide and does not itself force per-request confirmation (only an
+ *   `ask` rule sets `managedApprovalRequired`). A policy that leaves every tool
+ *   eligible (all `true`, or empty) expresses no restriction and contributes
+ *   nothing. Replace this with a per-tool translation once the grammar gains a
+ *   tool-name family.
+ * - **Copilot sessions on a local host.** The renderer sends an empty
+ *   contribution to remote hosts, and other agents do not consume managed
+ *   settings, so restrictions bridged here do not reach them. Those agents
+ *   remain governed by the root-config path (see
+ *   `AgentHostAutoApprovePolicyRestrictedConfigKey`).
+ *
+ * New enterprise controls belong directly in the SDK's managed-settings
+ * contract; this table exists only so settings that predate it keep working.
+ */
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+/**
+ * The restrictions this bridge contributes to the Copilot SDK. There is
+ * deliberately no `allow` list — see the module comment.
+ */
+export interface IAgentHostManagedSettingsPermissions {
+    disableBypassPermissionsMode?: "disable";
+    deny?: string[];
+    ask?: string[];
+}
+export declare const AgentHostMapLegacySettingsToManagedSettingsSettingId = "chat.agentHost.copilot.mapLegacySettingsToManagedSettings";
+export declare const managedPermissionsConfigurationIds: string[];
+export declare function isManagedSettingsPermissions(value: unknown): value is IAgentHostManagedSettingsPermissions;
+/**
+ * Combines every mapping's contribution into the single document sent to the
+ * host, deduplicating rules that more than one setting produced.
+ *
+ * Contributing any rule at all makes the runtime's managed policy "active",
+ * which causes unmatched shell, read, write, URL and factory requests to require
+ * approval. That is broader than any individual mapping intends, but it errs
+ * toward prompting, and the alternative — an `allow` list — resolves to
+ * auto-approval. See the module comment.
+ */
+export declare function resolveManagedSettingsPermissions(configurationService: IConfigurationService): IAgentHostManagedSettingsPermissions;