@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

package/vscode/src/vs/platform/agentPlugins/common/pluginParsers.js

@@ -0,0 +1,551 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { cloneAndChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { isAbsolute } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { untildify } from '@codingame/monaco-vscode-api/vscode/vs/base/common/labels';
+import { joinPath, normalizePath, isEqualOrParent, basename, extname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
+
+var PluginFormat;
+(function(PluginFormat) {
+    PluginFormat[PluginFormat["Copilot"] = 0] = "Copilot";
+    PluginFormat[PluginFormat["Claude"] = 1] = "Claude";
+    PluginFormat[PluginFormat["OpenPlugin"] = 2] = "OpenPlugin";
+})(PluginFormat || (PluginFormat = {}));
+const COPILOT_FORMAT = {
+    format: PluginFormat.Copilot,
+    manifestPath: "plugin.json",
+    hookConfigPath: "hooks.json",
+    pluginRootToken: undefined,
+    pluginRootEnvVar: undefined,
+    parseHooks(hookUri, json, _pluginUri, workspaceRoot, userHome) {
+        return parseHooksJson(hookUri, json, workspaceRoot, userHome);
+    }
+};
+const CLAUDE_FORMAT = {
+    format: PluginFormat.Claude,
+    manifestPath: ".claude-plugin/plugin.json",
+    hookConfigPath: "hooks/hooks.json",
+    pluginRootToken: "${CLAUDE_PLUGIN_ROOT}",
+    pluginRootEnvVar: "CLAUDE_PLUGIN_ROOT",
+    parseHooks(hookUri, json, pluginUri, workspaceRoot, userHome) {
+        return interpolateHookPluginRoot(
+            hookUri,
+            json,
+            pluginUri,
+            workspaceRoot,
+            userHome,
+            "${CLAUDE_PLUGIN_ROOT}",
+            "CLAUDE_PLUGIN_ROOT"
+        );
+    }
+};
+const OPEN_PLUGIN_FORMAT = {
+    format: PluginFormat.OpenPlugin,
+    manifestPath: ".plugin/plugin.json",
+    hookConfigPath: "hooks/hooks.json",
+    pluginRootToken: "${PLUGIN_ROOT}",
+    pluginRootEnvVar: "PLUGIN_ROOT",
+    parseHooks(hookUri, json, pluginUri, workspaceRoot, userHome) {
+        return interpolateHookPluginRoot(
+            hookUri,
+            json,
+            pluginUri,
+            workspaceRoot,
+            userHome,
+            "${PLUGIN_ROOT}",
+            "PLUGIN_ROOT"
+        );
+    }
+};
+async function detectPluginFormat(pluginUri, fileService) {
+    if (await pathExists(joinPath(pluginUri, ".plugin", "plugin.json"), fileService)) {
+        return OPEN_PLUGIN_FORMAT;
+    }
+    const isInClaudeDirectory = pluginUri.path.split("/").includes(".claude");
+    if (isInClaudeDirectory || (await pathExists(joinPath(pluginUri, ".claude-plugin", "plugin.json"), fileService))) {
+        return CLAUDE_FORMAT;
+    }
+    return COPILOT_FORMAT;
+}
+const emptyComponentPathConfig = {
+    paths: [],
+    exclusive: false
+};
+function parseComponentPathConfig(raw) {
+    if (raw === undefined || raw === null) {
+        return emptyComponentPathConfig;
+    }
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        return trimmed ? {
+            paths: [trimmed],
+            exclusive: false
+        } : emptyComponentPathConfig;
+    }
+    if (Array.isArray(raw)) {
+        const paths = ( raw.filter(v => typeof v === "string").map(v => v.trim())).filter(v => v.length > 0);
+        return {
+            paths,
+            exclusive: false
+        };
+    }
+    if (typeof raw === "object") {
+        const obj = raw;
+        if (Array.isArray(obj["paths"])) {
+            const paths = ( obj["paths"].filter(v => typeof v === "string").map(v => v.trim())).filter(v => v.length > 0);
+            const exclusive = obj["exclusive"] === true;
+            return {
+                paths,
+                exclusive
+            };
+        }
+    }
+    return emptyComponentPathConfig;
+}
+function resolveComponentDirs(pluginUri, defaultDir, config) {
+    const dirs = [];
+    if (!config.exclusive) {
+        dirs.push(joinPath(pluginUri, defaultDir));
+    }
+    for (const p of config.paths) {
+        const resolved = normalizePath(joinPath(pluginUri, p));
+        if (isEqualOrParent(resolved, pluginUri)) {
+            dirs.push(resolved);
+        }
+    }
+    return dirs;
+}
+function resolveMcpServersMap(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return undefined;
+    }
+    const obj = raw;
+    return Object.hasOwn(obj, "mcpServers") ? obj.mcpServers : obj;
+}
+function normalizeMcpServerConfiguration(rawConfig) {
+    if (!rawConfig || typeof rawConfig !== "object") {
+        return undefined;
+    }
+    const candidate = rawConfig;
+    const type = typeof candidate["type"] === "string" ? candidate["type"] : undefined;
+    const command = typeof candidate["command"] === "string" ? candidate["command"] : undefined;
+    const url = typeof candidate["url"] === "string" ? candidate["url"] : undefined;
+    const args = Array.isArray(candidate["args"]) ? candidate["args"].filter(value => typeof value === "string") : undefined;
+    const env = candidate["env"] && typeof candidate["env"] === "object" ? Object.fromEntries(( Object.entries(candidate["env"]).filter(
+        ([, value]) => typeof value === "string" || typeof value === "number" || value === null
+    ).map(([key, value]) => [key, value]))) : undefined;
+    const envFile = typeof candidate["envFile"] === "string" ? candidate["envFile"] : undefined;
+    const cwd = typeof candidate["cwd"] === "string" ? candidate["cwd"] : undefined;
+    const headers = candidate["headers"] && typeof candidate["headers"] === "object" ? Object.fromEntries(( Object.entries(candidate["headers"]).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value]))) : undefined;
+    const dev = candidate["dev"] && typeof candidate["dev"] === "object" ? candidate["dev"] : undefined;
+    if (type === "ws") {
+        return undefined;
+    }
+    if (type === McpServerType.LOCAL || (!type && command)) {
+        if (!command) {
+            return undefined;
+        }
+        return {
+            type: McpServerType.LOCAL,
+            command,
+            args,
+            env,
+            envFile,
+            cwd,
+            dev
+        };
+    }
+    if (type === McpServerType.REMOTE || type === "sse" || (!type && url)) {
+        if (!url) {
+            return undefined;
+        }
+        return {
+            type: McpServerType.REMOTE,
+            url,
+            headers,
+            dev
+        };
+    }
+    return undefined;
+}
+const shellUnsafeChars = /[\s&|<>()^;!`"']/;
+function shellQuotePluginRootInCommand(command, fsPath, token) {
+    if (!command.includes(token)) {
+        return command;
+    }
+    if (!shellUnsafeChars.test(fsPath)) {
+        return command.replaceAll(token, fsPath);
+    }
+    const escapedToken = escapeRegExpCharacters(token);
+    const pattern = ( new RegExp(`(["']?)` + escapedToken + `([\\w./\\\\~:-]*)`, "g"));
+    return command.replace(pattern, (_match, leadingQuote, suffix) => {
+        const fullPath = fsPath + suffix;
+        if (leadingQuote) {
+            return leadingQuote + fullPath;
+        }
+        return "\"" + fullPath.replace(/"/g, "\\\"") + "\"";
+    });
+}
+function interpolateMcpPluginRoot(def, fsPath, token, envVar) {
+    const replace = s => s.replaceAll(token, fsPath);
+    const config = def.configuration;
+    let interpolated;
+    if (config.type === McpServerType.LOCAL) {
+        const local = {
+            ...config
+        };
+        local.command = replace(local.command);
+        if (local.args) {
+            local.args = ( local.args.map(replace));
+        }
+        if (local.cwd) {
+            local.cwd = replace(local.cwd);
+        }
+        local.env = {
+            ...local.env
+        };
+        for (const [k, v] of Object.entries(local.env)) {
+            if (typeof v === "string") {
+                local.env[k] = replace(v);
+            }
+        }
+        local.env[envVar] = fsPath;
+        if (local.envFile) {
+            local.envFile = replace(local.envFile);
+        }
+        interpolated = local;
+    } else {
+        const remote = {
+            ...config
+        };
+        remote.url = replace(remote.url);
+        if (remote.headers) {
+            remote.headers = Object.fromEntries(( Object.entries(remote.headers).map(([k, v]) => [k, replace(v)])));
+        }
+        interpolated = remote;
+    }
+    return {
+        name: def.name,
+        configuration: interpolated,
+        uri: def.uri
+    };
+}
+const BARE_ENV_VAR_RE = /\$\{(?![A-Za-z]+:)([A-Z_][A-Z0-9_]*)\}/g;
+function convertBareEnvVarsToVsCodeSyntax(def) {
+    return cloneAndChange(def, value => {
+        if (URI.isUri(value)) {
+            return value;
+        }
+        if (typeof value === "string") {
+            const replaced = value.replace(BARE_ENV_VAR_RE, "${env:$1}");
+            return replaced !== value ? replaced : undefined;
+        }
+        return undefined;
+    });
+}
+const HOOK_TYPE_MAP = {
+    "SessionStart": "SessionStart",
+    "SessionEnd": "SessionEnd",
+    "UserPromptSubmit": "UserPromptSubmit",
+    "PreToolUse": "PreToolUse",
+    "PostToolUse": "PostToolUse",
+    "PreCompact": "PreCompact",
+    "SubagentStart": "SubagentStart",
+    "SubagentStop": "SubagentStop",
+    "Stop": "Stop",
+    "ErrorOccurred": "ErrorOccurred",
+    "sessionStart": "SessionStart",
+    "sessionEnd": "SessionEnd",
+    "userPromptSubmitted": "UserPromptSubmit",
+    "preToolUse": "PreToolUse",
+    "postToolUse": "PostToolUse",
+    "agentStop": "Stop",
+    "subagentStop": "SubagentStop",
+    "errorOccurred": "ErrorOccurred"
+};
+function normalizeHookCommand(raw) {
+    if (raw.type !== undefined && raw.type !== "command") {
+        return undefined;
+    }
+    const hasCommand = typeof raw.command === "string" && raw.command.length > 0;
+    const hasBash = typeof raw.bash === "string" && raw.bash.length > 0;
+    const hasPowerShell = typeof raw.powershell === "string" && raw.powershell.length > 0;
+    const hasWindows = typeof raw.windows === "string" && raw.windows.length > 0;
+    const hasLinux = typeof raw.linux === "string" && raw.linux.length > 0;
+    const hasOsx = typeof raw.osx === "string" && raw.osx.length > 0;
+    if (!hasCommand && !hasBash && !hasPowerShell && !hasWindows && !hasLinux && !hasOsx) {
+        return undefined;
+    }
+    const windows = hasWindows ? raw.windows : (hasPowerShell ? raw.powershell : undefined);
+    const linux = hasLinux ? raw.linux : (hasBash ? raw.bash : undefined);
+    const osx = hasOsx ? raw.osx : (hasBash ? raw.bash : undefined);
+    const timeout = typeof raw.timeout === "number" ? raw.timeout : (typeof raw.timeoutSec === "number" ? raw.timeoutSec : undefined);
+    return {
+        ...(hasCommand && {
+            command: raw.command
+        }),
+        ...(windows && {
+            windows
+        }),
+        ...(linux && {
+            linux
+        }),
+        ...(osx && {
+            osx
+        }),
+        ...(typeof raw.env === "object" && raw.env !== null && {
+            env: raw.env
+        }),
+        ...(timeout !== undefined && {
+            timeout
+        })
+    };
+}
+function resolveHookCommand(raw, workspaceRoot, userHome) {
+    const normalized = normalizeHookCommand(raw);
+    if (!normalized) {
+        return undefined;
+    }
+    let cwdUri;
+    const rawCwd = typeof raw.cwd === "string" ? raw.cwd : undefined;
+    if (rawCwd) {
+        const expanded = untildify(rawCwd, userHome);
+        if (isAbsolute(expanded)) {
+            cwdUri = URI.file(expanded);
+        } else if (workspaceRoot) {
+            cwdUri = joinPath(workspaceRoot, expanded);
+        }
+    } else {
+        cwdUri = workspaceRoot;
+    }
+    return {
+        ...normalized,
+        cwd: cwdUri
+    };
+}
+function extractHookCommands(item, workspaceRoot, userHome) {
+    if (!item || typeof item !== "object") {
+        return [];
+    }
+    const itemObj = item;
+    const commands = [];
+    const nestedHooks = itemObj.hooks;
+    if (nestedHooks !== undefined && Array.isArray(nestedHooks)) {
+        for (const nested of nestedHooks) {
+            if (!nested || typeof nested !== "object") {
+                continue;
+            }
+            const resolved = resolveHookCommand(nested, workspaceRoot, userHome);
+            if (resolved) {
+                commands.push(resolved);
+            }
+        }
+    } else {
+        const resolved = resolveHookCommand(itemObj, workspaceRoot, userHome);
+        if (resolved) {
+            commands.push(resolved);
+        }
+    }
+    return commands;
+}
+function parseHooksJson(hookUri, json, workspaceRoot, userHome) {
+    if (!json || typeof json !== "object") {
+        return [];
+    }
+    const root = json;
+    if (root.disableAllHooks === true) {
+        return [];
+    }
+    const hooks = root.hooks;
+    if (!hooks || typeof hooks !== "object") {
+        return [];
+    }
+    const hooksObj = hooks;
+    const result = [];
+    for (const originalId of ( Object.keys(hooksObj))) {
+        const canonicalType = HOOK_TYPE_MAP[originalId];
+        if (!canonicalType) {
+            continue;
+        }
+        const hookArray = hooksObj[originalId];
+        if (!Array.isArray(hookArray)) {
+            continue;
+        }
+        const commands = [];
+        for (const item of hookArray) {
+            commands.push(...extractHookCommands(item, workspaceRoot, userHome));
+        }
+        if (commands.length > 0) {
+            result.push({
+                type: canonicalType,
+                commands,
+                uri: hookUri,
+                originalId
+            });
+        }
+    }
+    return result;
+}
+function interpolateHookPluginRoot(hookUri, json, pluginUri, workspaceRoot, userHome, token, envVar) {
+    const fsPath = pluginUri.fsPath;
+    const typedJson = json;
+    const mutateHookCommand = hook => {
+        for (const field of ["command", "windows", "linux", "osx"]) {
+            if (typeof hook[field] === "string") {
+                hook[field] = shellQuotePluginRootInCommand(hook[field], fsPath, token);
+            }
+        }
+        if (!hook.env || typeof hook.env !== "object") {
+            hook.env = {};
+        }
+        hook.env[envVar] = fsPath;
+    };
+    for (const lifecycle of ( Object.values(typedJson.hooks ?? {}))) {
+        if (!Array.isArray(lifecycle)) {
+            continue;
+        }
+        for (const lifecycleEntry of lifecycle) {
+            if (!lifecycleEntry || typeof lifecycleEntry !== "object") {
+                continue;
+            }
+            const entry = lifecycleEntry;
+            if (Array.isArray(entry.hooks)) {
+                for (const hook of entry.hooks) {
+                    mutateHookCommand(hook);
+                }
+            } else {
+                mutateHookCommand(entry);
+            }
+        }
+    }
+    const replacer = v => {
+        return typeof v === "string" ? v.replaceAll(token, pluginUri.fsPath) : undefined;
+    };
+    return parseHooksJson(hookUri, cloneAndChange(json, replacer), workspaceRoot, userHome);
+}
+async function pathExists(resource, fileService) {
+    try {
+        await fileService.resolve(resource);
+        return true;
+    } catch {
+        return false;
+    }
+}
+const COMMAND_FILE_SUFFIX = ".md";
+async function readSkills(pluginRoot, dirs, fileService) {
+    const seen = ( new Set());
+    const skills = [];
+    const addSkill = (name, skillMd) => {
+        if (!( seen.has(name))) {
+            seen.add(name);
+            skills.push({
+                uri: skillMd,
+                name
+            });
+        }
+    };
+    for (const dir of dirs) {
+        const skillMd = URI.joinPath(dir, "SKILL.md");
+        if (await pathExists(skillMd, fileService)) {
+            addSkill(basename(dir), skillMd);
+            continue;
+        }
+        let stat;
+        try {
+            stat = await fileService.resolve(dir);
+        } catch {
+            continue;
+        }
+        if (!stat.isDirectory || !stat.children) {
+            continue;
+        }
+        for (const child of stat.children) {
+            const childSkillMd = URI.joinPath(child.resource, "SKILL.md");
+            if (await pathExists(childSkillMd, fileService)) {
+                addSkill(basename(child.resource), childSkillMd);
+            }
+        }
+    }
+    if (skills.length === 0) {
+        const rootSkillMd = URI.joinPath(pluginRoot, "SKILL.md");
+        if (await pathExists(rootSkillMd, fileService)) {
+            addSkill(basename(pluginRoot), rootSkillMd);
+        }
+    }
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    return skills;
+}
+async function readMarkdownComponents(dirs, fileService) {
+    const seen = ( new Set());
+    const items = [];
+    const addItem = (name, uri) => {
+        if (!( seen.has(name))) {
+            seen.add(name);
+            items.push({
+                uri,
+                name
+            });
+        }
+    };
+    for (const dir of dirs) {
+        let stat;
+        try {
+            stat = await fileService.resolve(dir);
+        } catch {
+            continue;
+        }
+        if (stat.isFile && extname(dir).toLowerCase() === COMMAND_FILE_SUFFIX) {
+            addItem(basename(dir).slice(0, -COMMAND_FILE_SUFFIX.length), dir);
+            continue;
+        }
+        if (!stat.isDirectory || !stat.children) {
+            continue;
+        }
+        for (const child of stat.children) {
+            if (!child.isFile || extname(child.resource).toLowerCase() !== COMMAND_FILE_SUFFIX) {
+                continue;
+            }
+            addItem(
+                basename(child.resource).slice(0, -COMMAND_FILE_SUFFIX.length),
+                child.resource
+            );
+        }
+    }
+    items.sort((a, b) => a.name.localeCompare(b.name));
+    return items;
+}
+function parseMcpServerDefinitionMap(definitionURI, raw, pluginFsPath, formatConfig) {
+    const mcpServers = resolveMcpServersMap(raw);
+    if (!mcpServers) {
+        return [];
+    }
+    const definitions = [];
+    for (const [name, configValue] of Object.entries(mcpServers)) {
+        const configuration = normalizeMcpServerConfiguration(configValue);
+        if (!configuration) {
+            continue;
+        }
+        let def = {
+            name,
+            configuration,
+            uri: definitionURI
+        };
+        if (formatConfig.pluginRootToken && formatConfig.pluginRootEnvVar) {
+            def = interpolateMcpPluginRoot(
+                def,
+                pluginFsPath,
+                formatConfig.pluginRootToken,
+                formatConfig.pluginRootEnvVar
+            );
+        }
+        def = convertBareEnvVarsToVsCodeSyntax(def);
+        definitions.push(def);
+    }
+    return definitions;
+}
+
+export { PluginFormat, convertBareEnvVarsToVsCodeSyntax, detectPluginFormat, interpolateHookPluginRoot, interpolateMcpPluginRoot, normalizeMcpServerConfiguration, parseComponentPathConfig, parseMcpServerDefinitionMap, pathExists, readMarkdownComponents, readSkills, resolveComponentDirs, resolveMcpServersMap, shellQuotePluginRootInCommand };

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

@@ -0,0 +1,22 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service";
+import { IAgentNetworkFilterService } from "@codingame/monaco-vscode-api/vscode/vs/platform/networkFilter/common/networkFilterService.service";
+export declare class AgentNetworkFilterService extends Disposable implements IAgentNetworkFilterService {
+    private readonly configurationService;
+    private readonly terminalSandboxService;
+    readonly _serviceBrand: undefined;
+    private enabled;
+    private terminalSandboxEnabled;
+    private allowedPatterns;
+    private deniedPatterns;
+    private readonly domainCache;
+    private readonly onDidChangeEmitter;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    constructor(configurationService: IConfigurationService, terminalSandboxService: ITerminalSandboxService);
+    private readConfiguration;
+    private updateTerminalSandboxEnabled;
+    isUriAllowed(uri: URI): boolean;
+    formatError(uri: URI): string;
+}

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

@@ -0,0 +1,83 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+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 { AgentSandboxSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.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';
+
+let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposable {
+    constructor(configurationService, terminalSandboxService) {
+        super();
+        this.configurationService = configurationService;
+        this.terminalSandboxService = terminalSandboxService;
+        this.enabled = false;
+        this.terminalSandboxEnabled = false;
+        this.allowedPatterns = [];
+        this.deniedPatterns = [];
+        this.domainCache = ( new LRUCache(100));
+        this.onDidChangeEmitter = this._register(( new Emitter()));
+        this.onDidChange = this.onDidChangeEmitter.event;
+        this.readConfiguration();
+        void this.updateTerminalSandboxEnabled();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(AgentNetworkDomainSettingId.NetworkFilter) || e.affectsConfiguration(AgentNetworkDomainSettingId.AllowedNetworkDomains) || e.affectsConfiguration(AgentNetworkDomainSettingId.DeniedNetworkDomains)) {
+                this.readConfiguration();
+                this.onDidChangeEmitter.fire();
+            } else if (e.affectsConfiguration(AgentSandboxSettingId.AgentSandboxEnabled) || e.affectsConfiguration(AgentSandboxSettingId.DeprecatedAgentSandboxEnabled)) {
+                void this.updateTerminalSandboxEnabled();
+            }
+        }));
+    }
+    readConfiguration() {
+        const networkFilterEnabled = this.configurationService.getValue(AgentNetworkDomainSettingId.NetworkFilter) ?? false;
+        this.enabled = networkFilterEnabled || this.terminalSandboxEnabled;
+        this.allowedPatterns = this.configurationService.getValue(AgentNetworkDomainSettingId.AllowedNetworkDomains) ?? [];
+        this.deniedPatterns = this.configurationService.getValue(AgentNetworkDomainSettingId.DeniedNetworkDomains) ?? [];
+        this.domainCache.clear();
+    }
+    async updateTerminalSandboxEnabled() {
+        const enabled = await this.terminalSandboxService.isEnabled();
+        if (this.terminalSandboxEnabled === enabled) {
+            return;
+        }
+        this.terminalSandboxEnabled = enabled;
+        this.readConfiguration();
+        this.onDidChangeEmitter.fire();
+    }
+    isUriAllowed(uri) {
+        if (!this.enabled) {
+            return true;
+        }
+        if (uri.scheme === "file" || !uri.authority) {
+            return true;
+        }
+        const domain = extractDomainFromUri(uri);
+        if (!domain) {
+            return true;
+        }
+        let result = this.domainCache.get(domain);
+        if (result === undefined) {
+            result = isDomainAllowed(domain, this.allowedPatterns, this.deniedPatterns);
+            this.domainCache.set(domain, result);
+        }
+        return result;
+    }
+    formatError(uri) {
+        const domain = extractDomainFromUri(uri);
+        return localize(
+            2051,
+            "Access to {0} is blocked by network domain policy (see `{1}` and `{2}` settings).",
+            domain ?? uri.authority,
+            AgentNetworkDomainSettingId.AllowedNetworkDomains,
+            AgentNetworkDomainSettingId.DeniedNetworkDomains
+        );
+    }
+};
+AgentNetworkFilterService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITerminalSandboxService))], AgentNetworkFilterService));
+
+export { AgentNetworkFilterService };

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatAccessibilityService.js

@@ -117,7 +117,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             });
         }
         this.toasts.clearAndDisposeAll();
-        const title = widget?.viewModel?.model.title ? ( localize(4701, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4702, "Untitled Chat"));
+        const title = widget?.viewModel?.model.title ? ( localize(4704, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4705, "Untitled Chat"));
         const cts = ( new CancellationTokenSource());
         const disposable = toDisposable(() => cts.dispose(true));
         this.toasts.add(disposable);
@@ -125,7 +125,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             clicked
         } = await this._hostService.showToast({
             title,
-            body: ( localize(4703, "New chat response."))
+            body: ( localize(4706, "New chat response."))
         }, cts.token);
         this.toasts.deleteAndDispose(disposable);
         if (clicked) {