@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.0

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

@@ -1,11 +1,28 @@
 import { type StateAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
-import { type ProtocolNotification } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
+import type { ServerNotificationMap } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/messages";
 /**
  * The current protocol version that new code speaks.
  *
  * Formatted as a [SemVer](https://semver.org) `MAJOR.MINOR.PATCH` string.
  */
-export declare const PROTOCOL_VERSION = "0.1.0";
+export declare const PROTOCOL_VERSION = "0.3.0";
+/**
+ * Every protocol version a client built from this source tree is willing
+ * to negotiate via the `initialize` handshake. Ordered **most preferred
+ * first** so a server picking the first acceptable entry honors the
+ * client's preference (see [versioning](../../docs/specification/versioning.md)).
+ *
+ * The first entry MUST equal {@link PROTOCOL_VERSION} — the version
+ * "new code speaks" is by definition the most preferred one. Older
+ * versions may be appended if a client retains the ability to fall back
+ * to them; today only one version is advertised.
+ *
+ * Every generated client (Rust, Kotlin, Swift) re-exports this constant
+ * verbatim. The TypeScript client consumes it directly. The per-client
+ * `release-metadata.json` files are validated against this list by
+ * `scripts/verify-release-metadata.ts`.
+ */
+export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly string[];
 /**
  * Compares two `MAJOR.MINOR.PATCH` SemVer strings.
  *
@@ -27,16 +44,24 @@ export declare const ACTION_INTRODUCED_IN: {
  */
 export declare function isActionKnownToVersion(action: StateAction, clientVersion: string): boolean;
 /**
- * Maps every notification type to the protocol version that introduced it.
- * Adding a new notification to `ProtocolNotification` without adding it here
- * is a compile error.
+ * Server → client notification method names that are part of the AHP
+ * protocol surface. The set is a subset of {@link ServerNotificationMap}
+ * keys that excludes `action` (the action envelope) since action versions
+ * are tracked via {@link ACTION_INTRODUCED_IN}.
+ */
+export type ProtocolNotificationMethod = Exclude<keyof ServerNotificationMap, "action">;
+/**
+ * Maps every server → client protocol notification method to the protocol
+ * version that introduced it. Adding a new notification method to
+ * {@link ServerNotificationMap} without adding it here is a compile error.
  *
  * Versions are SemVer `MAJOR.MINOR.PATCH` strings (see `PROTOCOL_VERSION`).
  */
 export declare const NOTIFICATION_INTRODUCED_IN: {
-    readonly [K in ProtocolNotification["type"]]: string;
+    readonly [K in ProtocolNotificationMethod]: string;
 };
 /**
- * Returns whether the given notification type is known to the specified protocol version.
+ * Returns whether the given notification method is known to the specified
+ * protocol version.
  */
-export declare function isNotificationKnownToVersion(notification: ProtocolNotification, clientVersion: string): boolean;
+export declare function isNotificationKnownToVersion(method: ProtocolNotificationMethod, clientVersion: string): boolean;

package/vscode/src/vs/platform/agentHost/common/state/protocol/version/registry.js

@@ -1,7 +1,6 @@
 
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
-import '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
 
-const PROTOCOL_VERSION = "0.1.0";
+const PROTOCOL_VERSION = "0.3.0";
 
 export { PROTOCOL_VERSION };

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

@@ -1,14 +1,43 @@
-export { ActionType, type ActionEnvelope, type ActionOrigin, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type SessionCreationFailedAction, type SessionDeltaAction, type SessionDiffsChangedAction, type SessionErrorAction, type SessionModelChangedAction, type SessionReadyAction, type SessionReasoningAction, type SessionResponsePartAction, type SessionToolCallCompleteAction, type SessionToolCallConfirmedAction, type SessionToolCallApprovedAction, type SessionToolCallDeniedAction, type SessionToolCallDeltaAction, type SessionToolCallReadyAction, type SessionToolCallResultConfirmedAction, type SessionToolCallStartAction, type SessionTitleChangedAction, type SessionTurnCancelledAction, type SessionTurnCompleteAction, type SessionTurnStartedAction, type SessionUsageAction, type SessionServerToolsChangedAction, type SessionActiveClientChangedAction, type SessionActiveClientToolsChangedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionPendingMessageSetAction, type SessionPendingMessageRemovedAction, type SessionQueuedMessagesReorderedAction, type SessionInputRequestedAction, type SessionInputCompletedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionToolCallContentChangedAction, type StateAction, } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
-export { NotificationType, AuthRequiredReason, type SessionAddedNotification, type SessionRemovedNotification, type AuthRequiredNotification, } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
-import type { RootAgentsChangedAction, RootActiveSessionsChangedAction, SessionDeltaAction, SessionModelChangedAction, SessionReasoningAction, SessionResponsePartAction, SessionToolCallApprovedAction, SessionToolCallCompleteAction, SessionToolCallConfirmedAction, SessionToolCallDeniedAction, SessionToolCallDeltaAction, SessionToolCallReadyAction, SessionToolCallResultConfirmedAction, SessionToolCallStartAction, SessionTitleChangedAction, SessionTurnCancelledAction, SessionTurnCompleteAction, SessionTurnStartedAction, SessionUsageAction, StateAction, SessionPendingMessageSetAction, SessionPendingMessageRemovedAction, SessionQueuedMessagesReorderedAction, SessionIsReadChangedAction, SessionIsArchivedChangedAction, RootConfigChangedAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
-import type { ProtocolNotification } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
-import type { RootAction as IRootAction_, SessionAction as ISessionAction_, ClientSessionAction as IClientSessionAction_, ServerSessionAction as IServerSessionAction_, TerminalAction as ITerminalAction_, ClientTerminalAction as IClientTerminalAction_ } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+export { ActionType, type ActionEnvelope, type ActionOrigin, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type SessionCreationFailedAction, type SessionDeltaAction, type SessionErrorAction, type SessionModelChangedAction, type SessionReadyAction, type SessionReasoningAction, type SessionResponsePartAction, type SessionToolCallCompleteAction, type SessionToolCallConfirmedAction, type SessionToolCallApprovedAction, type SessionToolCallDeniedAction, type SessionToolCallDeltaAction, type SessionToolCallReadyAction, type SessionToolCallResultConfirmedAction, type SessionToolCallStartAction, type SessionTitleChangedAction, type SessionTurnCancelledAction, type SessionTurnCompleteAction, type SessionTurnStartedAction, type SessionUsageAction, type SessionAgentChangedAction, type SessionServerToolsChangedAction, type SessionActiveClientChangedAction, type SessionActiveClientToolsChangedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionPendingMessageSetAction, type SessionPendingMessageRemovedAction, type SessionQueuedMessagesReorderedAction, type SessionInputRequestedAction, type SessionInputCompletedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionToolCallContentChangedAction, type ChangesetStatusChangedAction, type ChangesetFileSetAction, type ChangesetFileRemovedAction, type ChangesetOperationsChangedAction, type ChangesetClearedAction, type ResourceWatchChangedAction, type StateAction, } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
+export { AuthRequiredReason, type SessionAddedParams, type SessionRemovedParams, type SessionSummaryChangedParams, type AuthRequiredParams, } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/notifications";
+/**
+ * String discriminants for the protocol notification methods that previously
+ * lived inside a `notification` wrapper. These values are the JSON-RPC method
+ * names sent over the wire by a channels-era server; they are also the `type`
+ * discriminant on {@link ProtocolNotification} variants.
+ */
+export declare const NotificationType: {
+    readonly SessionAdded: "root/sessionAdded";
+    readonly SessionRemoved: "root/sessionRemoved";
+    readonly SessionSummaryChanged: "root/sessionSummaryChanged";
+    readonly AuthRequired: "auth/required";
+};
+export type NotificationType = typeof NotificationType[keyof typeof NotificationType];
+import type { RootAgentsChangedAction, RootActiveSessionsChangedAction, SessionDeltaAction, SessionModelChangedAction, SessionAgentChangedAction, SessionReasoningAction, SessionResponsePartAction, SessionToolCallApprovedAction, SessionToolCallCompleteAction, SessionToolCallConfirmedAction, SessionToolCallDeniedAction, SessionToolCallDeltaAction, SessionToolCallReadyAction, SessionToolCallResultConfirmedAction, SessionToolCallStartAction, SessionTitleChangedAction, SessionTurnCancelledAction, SessionTurnCompleteAction, SessionTurnStartedAction, SessionUsageAction, StateAction, SessionPendingMessageSetAction, SessionPendingMessageRemovedAction, SessionQueuedMessagesReorderedAction, SessionIsReadChangedAction, SessionIsArchivedChangedAction, RootConfigChangedAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import type { SessionAddedParams, SessionRemovedParams, SessionSummaryChangedParams, AuthRequiredParams } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/notifications";
+import type { RootAction as IRootAction_, SessionAction as ISessionAction_, ClientSessionAction as IClientSessionAction_, ServerSessionAction as IServerSessionAction_, TerminalAction as ITerminalAction_, ClientTerminalAction as IClientTerminalAction_, ChangesetAction as IChangesetAction_ } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+/**
+ * Discriminated union of all server→client protocol notifications other than
+ * the action envelope. Each variant carries its protocol `method` so callers
+ * can switch on `type` the same way they did against the old `NotificationType`
+ * enum.
+ */
+export type ProtocolNotification = ({
+    type: "root/sessionAdded";
+} & SessionAddedParams) | ({
+    type: "root/sessionRemoved";
+} & SessionRemovedParams) | ({
+    type: "root/sessionSummaryChanged";
+} & SessionSummaryChangedParams) | ({
+    type: "auth/required";
+} & AuthRequiredParams);
 export type RootAction = IRootAction_;
 export type SessionAction = ISessionAction_;
 export type ClientSessionAction = IClientSessionAction_;
 export type ServerSessionAction = IServerSessionAction_;
 export type TerminalAction = ITerminalAction_;
 export type ClientTerminalAction = IClientTerminalAction_;
+export type ChangesetAction = IChangesetAction_;
 export type IAgentsChangedAction = RootAgentsChangedAction;
 export type IActiveSessionsChangedAction = RootActiveSessionsChangedAction;
 export type IRootConfigChangedAction = RootConfigChangedAction;
@@ -29,6 +58,7 @@ export type ITitleChangedAction = SessionTitleChangedAction;
 export type IUsageAction = SessionUsageAction;
 export type IReasoningAction = SessionReasoningAction;
 export type IModelChangedAction = SessionModelChangedAction;
+export type IAgentChangedAction = SessionAgentChangedAction;
 export type ICustomizationsChangedAction = import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions").SessionCustomizationsChangedAction;
 export type ICustomizationToggledAction = import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions").SessionCustomizationToggledAction;
 export type IPendingMessageSetAction = SessionPendingMessageSetAction;
@@ -40,3 +70,4 @@ export type INotification = ProtocolNotification;
 export declare function isRootAction(action: StateAction): action is RootAction;
 export declare function isSessionAction(action: StateAction): action is SessionAction;
 export declare function isTerminalAction(action: StateAction): action is TerminalAction;
+export declare function isChangesetAction(action: StateAction): action is ChangesetAction;

package/vscode/src/vs/platform/agentHost/common/state/sessionActions.js

@@ -1,9 +1,12 @@
 
-export { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
-export { AuthRequiredReason, NotificationType } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications';
+export { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+export { AuthRequiredReason } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
 
 function isSessionAction(action) {
     return action.type.startsWith('session/');
 }
+function isChangesetAction(action) {
+    return action.type.startsWith('changeset/');
+}
 
-export { isSessionAction };
+export { isChangesetAction, isSessionAction };

package/vscode/src/vs/platform/networkFilter/common/domainMatcher.d.ts

@@ -0,0 +1,50 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+/**
+ * Normalizes and validates a domain string.
+ *
+ * Strips user info, port, trailing dots, and trailing punctuation.
+ * Accepts bare wildcards (`*`) and wildcard prefixes (`*.example.com`).
+ *
+ * @param value The raw domain string to normalize.
+ * @param fromUrl Whether the value was extracted from a URL context (skips file-extension filtering).
+ * @returns The normalized domain string, or `undefined` if the input is invalid.
+ */
+export declare function normalizeDomain(value: string | undefined, fromUrl?: boolean): string | undefined;
+/**
+ * Extracts the domain portion from a pattern string.
+ * If the pattern contains `://`, it is parsed as a URI and the authority is returned.
+ * Otherwise, the trimmed pattern is returned as-is.
+ */
+export declare function extractDomainPattern(pattern: string): string;
+/**
+ * Checks whether a normalized domain matches a given allow/deny pattern.
+ * Supports exact matches, bare wildcards (`*`), and wildcard prefixes (`*.example.com`).
+ *
+ * @param domain A normalized domain (output of {@link normalizeDomain}).
+ * @param pattern An allow/deny pattern (may be a bare domain, URL, or wildcard).
+ * @returns `true` if the domain matches the pattern.
+ */
+export declare function matchesDomainPattern(domain: string, pattern: string): boolean;
+/**
+ * Extracts and normalizes a domain from a URI.
+ * Strips port numbers and trailing dots.
+ *
+ * @param uri The URI to extract the domain from.
+ * @returns The normalized domain, or `undefined` if no valid domain could be extracted.
+ */
+export declare function extractDomainFromUri(uri: URI): string | undefined;
+/**
+ * Determines whether a domain is allowed based on allow and deny lists.
+ *
+ * Rules:
+ * - If both lists are empty, the domain is denied (restrictive default).
+ * - Denied patterns take precedence: if the domain matches any denied pattern, it is blocked.
+ * - If only denied patterns are configured (allowed is empty), any non-denied domain is allowed.
+ * - If allowed patterns are configured, the domain must match at least one to be allowed.
+ *
+ * @param domain A normalized domain string.
+ * @param allowedPatterns Array of allowed domain patterns.
+ * @param deniedPatterns Array of denied domain patterns.
+ * @returns `true` if the domain is allowed, `false` if it is blocked.
+ */
+export declare function isDomainAllowed(domain: string, allowedPatterns: string[], deniedPatterns: string[]): boolean;

package/vscode/src/vs/platform/networkFilter/common/domainMatcher.js

@@ -0,0 +1,138 @@
+
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+
+const fileExtensionSuffixes = ( new Set([
+    "7z",
+    "bz2",
+    "cjs",
+    "class",
+    "cpp",
+    "cs",
+    "css",
+    "csv",
+    "dll",
+    "exe",
+    "gif",
+    "gz",
+    "ico",
+    "jar",
+    "env",
+    "java",
+    "jpeg",
+    "jpg",
+    "js",
+    "json",
+    "jsx",
+    "lock",
+    "log",
+    "md",
+    "mjs",
+    "pdf",
+    "php",
+    "png",
+    "py",
+    "rar",
+    "rs",
+    "so",
+    "sql",
+    "svg",
+    "tar",
+    "tgz",
+    "toml",
+    "ts",
+    "tsx",
+    "txt",
+    "wasm",
+    "webp",
+    "xml",
+    "yaml",
+    "yml",
+    "zip"
+]));
+const wellKnownDomainSuffixes = ( new Set(["ai", "cloud", "com", "dev", "io", "me", "net", "org", "tech"]));
+function normalizeDomain(value, fromUrl = false) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase().replace(/^[^@]+@/, "").replace(/:\d+$/, "").replace(/\.+$/, "");
+    if (!normalized || normalized.includes("/") || normalized === "." || normalized === "..") {
+        return undefined;
+    }
+    if (normalized === "*") {
+        return "*";
+    }
+    if (!/^\*?\.?[a-z0-9.;,)!?:-]+$/.test(normalized)) {
+        return undefined;
+    }
+    const stripped = normalized.replace(/[),;:!?]+$/, "");
+    if (!stripped) {
+        return undefined;
+    }
+    const domainToValidate = stripped.startsWith("*.") ? stripped.slice(2) : stripped;
+    if (!/^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?))*$/.test(domainToValidate)) {
+        return undefined;
+    }
+    const hasWildcardPrefix = stripped.startsWith("*.");
+    const host = hasWildcardPrefix ? stripped.slice(2) : stripped;
+    if (!host) {
+        return undefined;
+    }
+    if (!/^[a-z0-9.-]+$/.test(host)) {
+        return undefined;
+    }
+    if (!fromUrl) {
+        const lastLabel = host.slice(host.lastIndexOf(".") + 1);
+        if (( fileExtensionSuffixes.has(lastLabel))) {
+            return undefined;
+        }
+        if (!( wellKnownDomainSuffixes.has(lastLabel))) {
+            return undefined;
+        }
+    }
+    return hasWildcardPrefix ? `*.${host}` : host;
+}
+function extractDomainPattern(pattern) {
+    const trimmed = pattern.trim();
+    if (trimmed === "*") {
+        return trimmed;
+    }
+    if (!trimmed.includes("://")) {
+        return trimmed;
+    }
+    try {
+        return ( URI.parse(trimmed)).authority;
+    } catch {
+        return trimmed;
+    }
+}
+function matchesDomainPattern(domain, pattern) {
+    const normalizedPattern = normalizeDomain(extractDomainPattern(pattern), pattern.includes("://"));
+    if (!normalizedPattern) {
+        return false;
+    }
+    if (normalizedPattern === "*") {
+        return true;
+    }
+    if (normalizedPattern.startsWith("*.")) {
+        const suffix = normalizedPattern.slice(2);
+        return domain === suffix || domain.endsWith(`.${suffix}`);
+    }
+    return domain === normalizedPattern;
+}
+function extractDomainFromUri(uri) {
+    return normalizeDomain(uri.authority, true);
+}
+function isDomainAllowed(domain, allowedPatterns, deniedPatterns) {
+    if (allowedPatterns.length === 0 && deniedPatterns.length === 0) {
+        return false;
+    }
+    if (( deniedPatterns.some(pattern => matchesDomainPattern(domain, pattern)))) {
+        return false;
+    }
+    if (allowedPatterns.length === 0) {
+        return true;
+    }
+    return ( allowedPatterns.some(pattern => matchesDomainPattern(domain, pattern)));
+}
+
+export { extractDomainFromUri, extractDomainPattern, isDomainAllowed, matchesDomainPattern, normalizeDomain };

package/vscode/src/vs/platform/networkFilter/common/networkFilterService.js

@@ -5,8 +5,8 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { LRUCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { extractDomainFromUri, isDomainAllowed } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/networkFilter/common/domainMatcher';
-import { AgentNetworkDomainSettingId } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/networkFilter/common/settings';
+import { extractDomainFromUri, isDomainAllowed } from './domainMatcher.js';
+import { AgentNetworkDomainSettingId } from './settings.js';
 
 let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposable {
     constructor(configurationService) {
@@ -57,7 +57,7 @@ let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposab
     formatError(uri) {
         const domain = extractDomainFromUri(uri);
         return localize(
-            2085,
+            2115,
             "Access to {0} is blocked by network domain policy (see `{1}` and `{2}` settings).",
             domain ?? uri.authority,
             AgentNetworkDomainSettingId.AllowedNetworkDomains,

package/vscode/src/vs/platform/networkFilter/common/settings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Setting IDs for agent network domain filtering.
+ */
+export declare enum AgentNetworkDomainSettingId {
+    NetworkFilter = "chat.agent.networkFilter",
+    AllowedNetworkDomains = "chat.agent.allowedNetworkDomains",
+    DeniedNetworkDomains = "chat.agent.deniedNetworkDomains",
+    DeprecatedSandboxAllowedNetworkDomains = "chat.agent.sandbox.allowedNetworkDomains",
+    DeprecatedSandboxDeniedNetworkDomains = "chat.agent.sandbox.deniedNetworkDomains",
+    DeprecatedOldAllowedNetworkDomains = "chat.agent.sandboxNetwork.allowedDomains",
+    DeprecatedOldDeniedNetworkDomains = "chat.agent.sandboxNetwork.deniedDomains"
+}

package/vscode/src/vs/platform/networkFilter/common/settings.js

@@ -0,0 +1,14 @@
+
+
+var AgentNetworkDomainSettingId;
+(function (AgentNetworkDomainSettingId) {
+    AgentNetworkDomainSettingId["NetworkFilter"] = "chat.agent.networkFilter";
+    AgentNetworkDomainSettingId["AllowedNetworkDomains"] = "chat.agent.allowedNetworkDomains";
+    AgentNetworkDomainSettingId["DeniedNetworkDomains"] = "chat.agent.deniedNetworkDomains";
+    AgentNetworkDomainSettingId["DeprecatedSandboxAllowedNetworkDomains"] = "chat.agent.sandbox.allowedNetworkDomains";
+    AgentNetworkDomainSettingId["DeprecatedSandboxDeniedNetworkDomains"] = "chat.agent.sandbox.deniedNetworkDomains";
+    AgentNetworkDomainSettingId["DeprecatedOldAllowedNetworkDomains"] = "chat.agent.sandboxNetwork.allowedDomains";
+    AgentNetworkDomainSettingId["DeprecatedOldDeniedNetworkDomains"] = "chat.agent.sandboxNetwork.deniedDomains";
+})(AgentNetworkDomainSettingId || (AgentNetworkDomainSettingId = {}));
+
+export { AgentNetworkDomainSettingId };

package/vscode/src/vs/platform/sandbox/browser/sandboxHelperService.d.ts

@@ -1,6 +1,9 @@
-import { ISandboxDependencyStatus } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService";
+import { ISandboxDependencyStatus, type IWindowsMxcConfig, IWindowsMxcFilesystemPolicy, type IWindowsMxcPolicyContainment, type IWindowsMxcSandboxPolicy } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService";
 import { ISandboxHelperService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service";
 export declare class NullSandboxHelperService implements ISandboxHelperService {
     readonly _serviceBrand: undefined;
     checkSandboxDependencies(): Promise<ISandboxDependencyStatus>;
+    getWindowsMxcFilesystemPolicy(): Promise<IWindowsMxcFilesystemPolicy | undefined>;
+    getWindowsMxcEnvironment(): Promise<string[] | undefined>;
+    buildWindowsMxcSandboxPayload(_commandLine: string, _policy: IWindowsMxcSandboxPolicy, _workingDirectory?: string, _containerName?: string, _containment?: IWindowsMxcPolicyContainment): Promise<IWindowsMxcConfig | undefined>;
 }

package/vscode/src/vs/platform/sandbox/browser/sandboxHelperService.js

@@ -9,6 +9,15 @@ class NullSandboxHelperService {
             socatInstalled: true
         };
     }
+    async getWindowsMxcFilesystemPolicy() {
+        return undefined;
+    }
+    async getWindowsMxcEnvironment() {
+        return undefined;
+    }
+    async buildWindowsMxcSandboxPayload(_commandLine, _policy, _workingDirectory, _containerName, _containment) {
+        return undefined;
+    }
 }
 
 export { NullSandboxHelperService };

package/vscode/src/vs/platform/sandbox/common/sandboxHelperIpc.d.ts

@@ -0,0 +1,21 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IChannel, IServerChannel } from "@codingame/monaco-vscode-api/vscode/vs/base/parts/ipc/common/ipc";
+import { ISandboxDependencyStatus, type IWindowsMxcConfig, IWindowsMxcFilesystemPolicy, type IWindowsMxcPolicyContainment, type IWindowsMxcSandboxPolicy } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService";
+import { ISandboxHelperService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service";
+export declare const SANDBOX_HELPER_CHANNEL_NAME = "sandboxHelper";
+export declare class SandboxHelperChannel implements IServerChannel {
+    private readonly service;
+    constructor(service: ISandboxHelperService);
+    listen<T>(_context: unknown, _event: string): Event<T>;
+    call<T>(_context: unknown, command: string, _arg?: unknown, _cancellationToken?: CancellationToken): Promise<T>;
+}
+export declare class SandboxHelperChannelClient implements ISandboxHelperService {
+    private readonly channel;
+    readonly _serviceBrand: undefined;
+    constructor(channel: IChannel);
+    checkSandboxDependencies(): Promise<ISandboxDependencyStatus | undefined>;
+    getWindowsMxcFilesystemPolicy(): Promise<IWindowsMxcFilesystemPolicy | undefined>;
+    getWindowsMxcEnvironment(): Promise<string[] | undefined>;
+    buildWindowsMxcSandboxPayload(commandLine: string, policy: IWindowsMxcSandboxPolicy, workingDirectory?: string, containerName?: string, containment?: IWindowsMxcPolicyContainment): Promise<IWindowsMxcConfig | undefined>;
+}

package/vscode/src/vs/platform/sandbox/common/sandboxHelperIpc.js

@@ -0,0 +1,28 @@
+
+
+const SANDBOX_HELPER_CHANNEL_NAME = "sandboxHelper";
+class SandboxHelperChannelClient {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    checkSandboxDependencies() {
+        return this.channel.call("checkSandboxDependencies");
+    }
+    getWindowsMxcFilesystemPolicy() {
+        return this.channel.call("getWindowsMxcFilesystemPolicy");
+    }
+    getWindowsMxcEnvironment() {
+        return this.channel.call("getWindowsMxcEnvironment");
+    }
+    buildWindowsMxcSandboxPayload(commandLine, policy, workingDirectory, containerName, containment) {
+        return this.channel.call("buildWindowsMxcSandboxPayload", {
+            commandLine,
+            policy,
+            workingDirectory,
+            containerName,
+            containment
+        });
+    }
+}
+
+export { SANDBOX_HELPER_CHANNEL_NAME, SandboxHelperChannelClient };

package/vscode/src/vs/platform/sandbox/common/terminalSandboxCommandRules.d.ts

@@ -0,0 +1,31 @@
+import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ITerminalSandboxCommand } from "./terminalSandboxService.js";
+export interface ITerminalSandboxCommandRuleContext {
+    readonly os: OperatingSystem;
+}
+export interface ITerminalSandboxCommandRule<T> {
+    readonly keywords: readonly string[];
+    readonly value: T;
+    readonly subcommands?: readonly string[];
+    readonly optionsWithValue?: ReadonlySet<string>;
+    /** Context-wide guard for rules, such as OS-specific sandbox capabilities. */
+    readonly condition?: (context: ITerminalSandboxCommandRuleContext) => boolean;
+    /** Command-specific guard for argument-sensitive rules. */
+    readonly when?: (command: ITerminalSandboxCommand) => boolean;
+}
+/**
+ * Git global options that consume the following argument. These need to be
+ * skipped when finding the subcommand so `git -C repo commit` matches `commit`
+ * instead of treating `repo` as the subcommand.
+ */
+export declare const gitGlobalOptionsWithValue: Set<string>;
+export declare function matchesTerminalSandboxCommandRule<T>(command: ITerminalSandboxCommand, rule: ITerminalSandboxCommandRule<T>, context?: ITerminalSandboxCommandRuleContext): boolean;
+/**
+ * Returns the first non-option argument, treating it as the command's subcommand.
+ * Options are skipped, and options listed in `optionsWithValue` also skip the
+ * following argument so global option values are not mistaken for subcommands.
+ *
+ * For example, with `-C` in `optionsWithValue`, `git -C repo commit` returns
+ * `commit` instead of `repo`.
+ */
+export declare function getCommandSubcommand(args: readonly string[], optionsWithValue?: ReadonlySet<string>): string | undefined;

package/vscode/src/vs/platform/sandbox/common/terminalSandboxCommandRules.js

@@ -0,0 +1,49 @@
+
+
+const gitGlobalOptionsWithValue = ( new Set([
+    "-C",
+    "-c",
+    "--config-env",
+    "--exec-path",
+    "--git-dir",
+    "--html-path",
+    "--info-path",
+    "--man-path",
+    "--namespace",
+    "--super-prefix",
+    "--work-tree"
+]));
+function matchesTerminalSandboxCommandRule(command, rule, context) {
+    if (!rule.keywords.includes(command.keyword.toLowerCase())) {
+        return false;
+    }
+    if (rule.condition && (!context || !rule.condition(context))) {
+        return false;
+    }
+    if (rule.subcommands) {
+        const subcommand = getCommandSubcommand(command.args, rule.optionsWithValue);
+        if (subcommand === undefined || !rule.subcommands.includes(subcommand)) {
+            return false;
+        }
+    }
+    return rule.when?.(command) ?? true;
+}
+function getCommandSubcommand(args, optionsWithValue) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--") {
+            return undefined;
+        }
+        if (arg.startsWith("-")) {
+            const option = arg.includes("=") ? arg.substring(0, arg.indexOf("=")) : arg;
+            if (!arg.includes("=") && optionsWithValue?.has(option)) {
+                i++;
+            }
+            continue;
+        }
+        return arg.toLowerCase();
+    }
+    return undefined;
+}
+
+export { getCommandSubcommand, gitGlobalOptionsWithValue, matchesTerminalSandboxCommandRule };