@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.1.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/agentHostCustomizationConfig.d.ts

@@ -0,0 +1,74 @@
+import { type Customization, type PluginCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+/**
+ * Well-known root-config keys used by the platform to configure agent-host
+ * customizations.
+ */
+export declare enum AgentHostConfigKey {
+    /** Host-owned Open Plugins available to remote sessions. */
+    Customizations = "customizations",
+    /**
+     * Absolute path to the shell executable for host-managed terminals.
+     * TODO: revisit magic key in config; refine into a dedicated typed channel. https://github.com/microsoft/vscode/issues/313812
+     */
+    DefaultShell = "defaultShell",
+    /**
+     * Experimentation flag for conditional Agent Host auth. When true, session
+     * types that are usable without GitHub remain available to signed-out users
+     * instead of forcing GitHub sign-in. The workbench forwards it here from the
+     * `chat.agentHost.allowSignedOutWhenUsable` VS Code setting; when unset the
+     * feature is dark (today's always-proxy behavior).
+     */
+    AllowSignedOutWhenUsable = "allowSignedOutWhenUsable",
+    /** Controls whether session-scoped file customizations come from local scan or SDK discovery. */
+    SessionCustomizationDiscoveryMode = "sessionCustomizationDiscoveryMode",
+    /**
+     * Optional GitHub Enterprise base URI (e.g. `https://ghe.example.com` for a
+     * GitHub Enterprise Server, or `https://tenant.ghe.com` for GitHub Enterprise
+     * Cloud). When set, the agent host computes its GitHub protected resources and
+     * REST/GraphQL endpoints from this base instead of github.com. Normally pushed
+     * by the local VS Code client from the workbench `github-enterprise.uri`
+     * setting; remote operators set it directly in the remote
+     * `agent-host-config.json`.
+     */
+    GithubEnterpriseUri = "githubEnterpriseUri"
+}
+export declare const SESSION_CUSTOMIZATION_DISCOVERY_MODES: readonly [
+    "scan",
+    "discover"
+];
+export type SessionCustomizationDiscoveryMode = typeof SESSION_CUSTOMIZATION_DISCOVERY_MODES[number];
+export declare const DEFAULT_SESSION_CUSTOMIZATION_DISCOVERY_MODE: SessionCustomizationDiscoveryMode;
+/**
+ * Persisted on-disk shape for a host-configured plugin. Kept stable across
+ * the customization protocol refactor so existing `agent-host-config.json`
+ * files keep working; entries are mapped to the new
+ * {@link Customization} shape at read time by
+ * {@link getAgentHostConfiguredCustomizations}.
+ */
+interface IPersistedCustomizationConfigEntry {
+    uri: string;
+    displayName: string;
+    description?: string;
+}
+export declare const agentHostCustomizationConfigSchema: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchema<{
+    customizations: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<IPersistedCustomizationConfigEntry[]>;
+    defaultShell: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<string>;
+    allowSignedOutWhenUsable: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    sessionCustomizationDiscoveryMode: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<"discover" | "scan">;
+    githubEnterpriseUri: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<string>;
+}>;
+export declare const defaultAgentHostCustomizationConfigValues: {
+    customizations: IPersistedCustomizationConfigEntry[];
+};
+/**
+ * Reads the persisted (legacy-shaped) plugin entries from the agent-host
+ * root config and lifts them into the new {@link Customization} container
+ * shape used by the rest of the platform.
+ */
+export declare function getAgentHostConfiguredCustomizations(values: Record<string, unknown> | undefined): readonly Customization[];
+/**
+ * Lifts a persisted plugin config entry into the new
+ * {@link Customization} container shape.
+ */
+export declare function toContainerCustomization(entry: IPersistedCustomizationConfigEntry): PluginCustomization;
+export {};

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

@@ -0,0 +1,90 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { createSchema, schemaProperty } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+
+var AgentHostConfigKey;
+(function(AgentHostConfigKey) {
+    AgentHostConfigKey["Customizations"] = "customizations";
+    AgentHostConfigKey["DefaultShell"] = "defaultShell";
+    AgentHostConfigKey["AllowSignedOutWhenUsable"] = "allowSignedOutWhenUsable";
+    AgentHostConfigKey["SessionCustomizationDiscoveryMode"] = "sessionCustomizationDiscoveryMode";
+    AgentHostConfigKey["GithubEnterpriseUri"] = "githubEnterpriseUri";
+})(AgentHostConfigKey || (AgentHostConfigKey = {}));
+const SESSION_CUSTOMIZATION_DISCOVERY_MODES = ["scan", "discover"];
+const DEFAULT_SESSION_CUSTOMIZATION_DISCOVERY_MODE = "discover";
+createSchema({
+    [AgentHostConfigKey.Customizations]: schemaProperty({
+        type: "array",
+        title: ( localize(1852, "Plugins")),
+        description: ( localize(
+            1853,
+            "Plugins configured on this agent host and available to remote sessions."
+        )),
+        default: [],
+        items: {
+            type: "object",
+            title: ( localize(1854, "Plugin")),
+            properties: {
+                uri: {
+                    type: "string",
+                    title: ( localize(1855, "Plugin URI"))
+                },
+                displayName: {
+                    type: "string",
+                    title: ( localize(1856, "Name"))
+                },
+                description: {
+                    type: "string",
+                    title: ( localize(1857, "Description"))
+                }
+            },
+            required: ["uri", "displayName"]
+        }
+    }),
+    [AgentHostConfigKey.DefaultShell]: schemaProperty({
+        type: "string",
+        title: ( localize(1858, "Default Shell")),
+        description: ( localize(
+            1859,
+            "Absolute path to the shell executable used by host-managed terminals. Normally pushed by the connected VS Code client from `terminal.integrated.agentHostProfile.<os>` (falling back to `terminal.integrated.defaultProfile.<os>`); when unset, the agent host falls back to the system shell. Only the path is supported; `args` and `env` from the workbench profile are not piped through yet. The workbench only pushes this for the local agent host — remote agent host operators should set this directly in the remote machine's `agent-host-config.json`."
+        ))
+    }),
+    [AgentHostConfigKey.AllowSignedOutWhenUsable]: schemaProperty({
+        type: "boolean",
+        title: ( localize(1860, "Allow Signed-Out Agent Host")),
+        description: ( localize(
+            1861,
+            "Experimental. When enabled, Agent Host sessions remain available while signed out as long as the selected agent has a usable model and authentication (for example Codex with ChatGPT authentication or Claude in native mode with your own Anthropic credentials). When disabled (the default), GitHub sign-in is required."
+        )),
+        default: false
+    }),
+    [AgentHostConfigKey.SessionCustomizationDiscoveryMode]: schemaProperty({
+        type: "string",
+        enum: [...SESSION_CUSTOMIZATION_DISCOVERY_MODES],
+        title: ( localize(1862, "Session Customization Discovery Mode")),
+        description: ( localize(
+            1863,
+            "Controls whether session-scoped customizations are populated from local file scanning or from Copilot SDK discovery."
+        )),
+        default: DEFAULT_SESSION_CUSTOMIZATION_DISCOVERY_MODE
+    }),
+    [AgentHostConfigKey.GithubEnterpriseUri]: schemaProperty({
+        type: "string",
+        title: ( localize(1864, "GitHub Enterprise URI")),
+        description: ( localize(
+            1865,
+            "Optional base URI of a GitHub Enterprise instance (for example \"https://ghe.example.com\" for GitHub Enterprise Server, or \"https://tenant.ghe.com\" for GitHub Enterprise Cloud). When set, the agent host authenticates and makes GitHub API calls against this instance instead of github.com. Normally pushed by the connected VS Code client from the `github-enterprise.uri` setting; remote agent host operators can set it directly in the remote `agent-host-config.json`."
+        ))
+    })
+});
+
+export { AgentHostConfigKey, DEFAULT_SESSION_CUSTOMIZATION_DISCOVERY_MODE, SESSION_CUSTOMIZATION_DISCOVERY_MODES };

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;