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

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

@@ -0,0 +1,42 @@
+import { type StateAction } from "@codingame/monaco-vscode-xterm-common/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";
+/**
+ * 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";
+/**
+ * Compares two `MAJOR.MINOR.PATCH` SemVer strings.
+ *
+ * Returns a negative number if `a < b`, zero if `a === b`, and a positive
+ * number if `a > b`.
+ */
+export declare function compareProtocolVersions(a: string, b: string): number;
+/**
+ * Maps every action type to the protocol version that introduced it.
+ * Adding a new action to `StateAction` without adding it here is a compile error.
+ *
+ * Versions are SemVer `MAJOR.MINOR.PATCH` strings (see `PROTOCOL_VERSION`).
+ */
+export declare const ACTION_INTRODUCED_IN: {
+    readonly [K in StateAction["type"]]: string;
+};
+/**
+ * Returns whether the given action type is known to the specified protocol version.
+ */
+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.
+ *
+ * Versions are SemVer `MAJOR.MINOR.PATCH` strings (see `PROTOCOL_VERSION`).
+ */
+export declare const NOTIFICATION_INTRODUCED_IN: {
+    readonly [K in ProtocolNotification["type"]]: string;
+};
+/**
+ * Returns whether the given notification type is known to the specified protocol version.
+ */
+export declare function isNotificationKnownToVersion(notification: ProtocolNotification, clientVersion: string): boolean;

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

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

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

@@ -1,41 +1,42 @@
-export { ActionType, type IActionEnvelope, type IActionOrigin, type IRootAgentsChangedAction, type IRootActiveSessionsChangedAction, type ISessionCreationFailedAction, type ISessionDeltaAction, type ISessionDiffsChangedAction, type ISessionErrorAction, type ISessionModelChangedAction, type ISessionReadyAction, type ISessionReasoningAction, type ISessionResponsePartAction, type ISessionToolCallCompleteAction, type ISessionToolCallConfirmedAction, type ISessionToolCallApprovedAction, type ISessionToolCallDeniedAction, type ISessionToolCallDeltaAction, type ISessionToolCallReadyAction, type ISessionToolCallResultConfirmedAction, type ISessionToolCallStartAction, type ISessionTitleChangedAction, type ISessionTurnCancelledAction, type ISessionTurnCompleteAction, type ISessionTurnStartedAction, type ISessionUsageAction, type ISessionServerToolsChangedAction, type ISessionActiveClientChangedAction, type ISessionActiveClientToolsChangedAction, type ISessionCustomizationsChangedAction, type ISessionCustomizationToggledAction, type ISessionPendingMessageSetAction, type ISessionPendingMessageRemovedAction, type ISessionQueuedMessagesReorderedAction, type ISessionInputRequestedAction, type ISessionInputCompletedAction, type ISessionIsReadChangedAction, type ISessionIsDoneChangedAction, type ISessionToolCallContentChangedAction, type IStateAction, } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
-export { NotificationType, AuthRequiredReason, type ISessionAddedNotification, type ISessionRemovedNotification, type IAuthRequiredNotification, } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
-import type { IRootAgentsChangedAction, IRootActiveSessionsChangedAction, ISessionDeltaAction, ISessionModelChangedAction, ISessionReasoningAction, ISessionResponsePartAction, ISessionToolCallApprovedAction, ISessionToolCallCompleteAction, ISessionToolCallConfirmedAction, ISessionToolCallDeniedAction, ISessionToolCallDeltaAction, ISessionToolCallReadyAction, ISessionToolCallResultConfirmedAction, ISessionToolCallStartAction, ISessionTitleChangedAction, ISessionTurnCancelledAction, ISessionTurnCompleteAction, ISessionTurnStartedAction, ISessionUsageAction, IStateAction, ISessionPendingMessageSetAction, ISessionPendingMessageRemovedAction, ISessionQueuedMessagesReorderedAction, ISessionIsReadChangedAction, ISessionIsDoneChangedAction } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
-import type { IProtocolNotification } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
-import type { IRootAction as IRootAction_, ISessionAction as ISessionAction_, IClientSessionAction as IClientSessionAction_, IServerSessionAction as IServerSessionAction_, ITerminalAction as ITerminalAction_, IClientTerminalAction as IClientTerminalAction_ } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
-export type IRootAction = IRootAction_;
-export type ISessionAction = ISessionAction_;
-export type IClientSessionAction = IClientSessionAction_;
-export type IServerSessionAction = IServerSessionAction_;
-export type ITerminalAction = ITerminalAction_;
-export type IClientTerminalAction = IClientTerminalAction_;
-export type IAgentsChangedAction = IRootAgentsChangedAction;
-export type IActiveSessionsChangedAction = IRootActiveSessionsChangedAction;
-export type ITurnStartedAction = ISessionTurnStartedAction;
-export type IDeltaAction = ISessionDeltaAction;
-export type IResponsePartAction = ISessionResponsePartAction;
-export type IToolCallStartAction = ISessionToolCallStartAction;
-export type IToolCallDeltaAction = ISessionToolCallDeltaAction;
-export type IToolCallReadyAction = ISessionToolCallReadyAction;
-export type IToolCallApprovedAction = ISessionToolCallApprovedAction;
-export type IToolCallDeniedAction = ISessionToolCallDeniedAction;
-export type IToolCallConfirmedAction = ISessionToolCallConfirmedAction;
-export type IToolCallCompleteAction = ISessionToolCallCompleteAction;
-export type IToolCallResultConfirmedAction = ISessionToolCallResultConfirmedAction;
-export type ITurnCompleteAction = ISessionTurnCompleteAction;
-export type ITurnCancelledAction = ISessionTurnCancelledAction;
-export type ITitleChangedAction = ISessionTitleChangedAction;
-export type IUsageAction = ISessionUsageAction;
-export type IReasoningAction = ISessionReasoningAction;
-export type IModelChangedAction = ISessionModelChangedAction;
-export type ICustomizationsChangedAction = import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions").ISessionCustomizationsChangedAction;
-export type ICustomizationToggledAction = import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions").ISessionCustomizationToggledAction;
-export type IPendingMessageSetAction = ISessionPendingMessageSetAction;
-export type IPendingMessageRemovedAction = ISessionPendingMessageRemovedAction;
-export type IQueuedMessagesReorderedAction = ISessionQueuedMessagesReorderedAction;
-export type IIsReadChangedAction = ISessionIsReadChangedAction;
-export type IIsDoneChangedAction = ISessionIsDoneChangedAction;
-export type INotification = IProtocolNotification;
-export declare function isRootAction(action: IStateAction): action is IRootAction;
-export declare function isSessionAction(action: IStateAction): action is ISessionAction;
-export declare function isTerminalAction(action: IStateAction): action is ITerminalAction;
+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-xterm-common/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-xterm-common/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 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 IAgentsChangedAction = RootAgentsChangedAction;
+export type IActiveSessionsChangedAction = RootActiveSessionsChangedAction;
+export type IRootConfigChangedAction = RootConfigChangedAction;
+export type ITurnStartedAction = SessionTurnStartedAction;
+export type IDeltaAction = SessionDeltaAction;
+export type IResponsePartAction = SessionResponsePartAction;
+export type IToolCallStartAction = SessionToolCallStartAction;
+export type IToolCallDeltaAction = SessionToolCallDeltaAction;
+export type IToolCallReadyAction = SessionToolCallReadyAction;
+export type IToolCallApprovedAction = SessionToolCallApprovedAction;
+export type IToolCallDeniedAction = SessionToolCallDeniedAction;
+export type IToolCallConfirmedAction = SessionToolCallConfirmedAction;
+export type IToolCallCompleteAction = SessionToolCallCompleteAction;
+export type IToolCallResultConfirmedAction = SessionToolCallResultConfirmedAction;
+export type ITurnCompleteAction = SessionTurnCompleteAction;
+export type ITurnCancelledAction = SessionTurnCancelledAction;
+export type ITitleChangedAction = SessionTitleChangedAction;
+export type IUsageAction = SessionUsageAction;
+export type IReasoningAction = SessionReasoningAction;
+export type IModelChangedAction = SessionModelChangedAction;
+export type ICustomizationsChangedAction = import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions").SessionCustomizationsChangedAction;
+export type ICustomizationToggledAction = import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions").SessionCustomizationToggledAction;
+export type IPendingMessageSetAction = SessionPendingMessageSetAction;
+export type IPendingMessageRemovedAction = SessionPendingMessageRemovedAction;
+export type IQueuedMessagesReorderedAction = SessionQueuedMessagesReorderedAction;
+export type IIsReadChangedAction = SessionIsReadChangedAction;
+export type IIsArchivedChangedAction = SessionIsArchivedChangedAction;
+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;

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

@@ -1,24 +1,24 @@
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import type { IProtocolMessage, IAhpServerNotification, IJsonRpcNotification, IJsonRpcResponse, IJsonRpcRequest } from "./sessionProtocol.js";
+import type { ProtocolMessage, AhpServerNotification, JsonRpcNotification, JsonRpcResponse, JsonRpcRequest } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
 /**
  * A bidirectional transport for protocol messages. Implementations handle
  * serialization, framing, and connection management.
  */
 export interface IProtocolTransport extends IDisposable {
     /** Fires when a message is received from the remote end. */
-    readonly onMessage: Event<IProtocolMessage>;
+    readonly onMessage: Event<ProtocolMessage>;
     /** Fires when the transport connection closes. */
     readonly onClose: Event<void>;
     /**
      * Send a message to the remote end.
      *
      * Accepts:
-     * - `IProtocolMessage` — fully-typed client↔server messages.
-     * - `IAhpServerNotification` — server→client notifications.
-     * - `IJsonRpcResponse` — dynamically-constructed success/error responses.
+     * - `ProtocolMessage` — fully-typed client↔server messages.
+     * - `AhpServerNotification` — server→client notifications.
+     * - `JsonRpcResponse` — dynamically-constructed success/error responses.
      */
-    send(message: IProtocolMessage | IAhpServerNotification | IJsonRpcNotification | IJsonRpcResponse | IJsonRpcRequest): void;
+    send(message: ProtocolMessage | AhpServerNotification | JsonRpcNotification | JsonRpcResponse | JsonRpcRequest): void;
 }
 /**
  * A client-side transport that requires an explicit connection step

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

@@ -0,0 +1,15 @@
+/**
+ * Shared constants for agent-host protocol transports. Kept in a common
+ * module so browser, electron-browser, and sessions-layer transports all
+ * apply the same malformed-frame policy without duplicating values.
+ */
+/**
+ * Force-close the transport once more than this many malformed inbound
+ * frames have been observed. A handful of bad frames can be tolerated
+ * (e.g. a proxy momentarily corrupts a message), but a sustained stream
+ * almost always indicates a protocol mismatch or a broken relay, and is
+ * best surfaced as a hard disconnect so the reconnect loop can take over.
+ */
+export declare const MALFORMED_FRAMES_FORCE_CLOSE_THRESHOLD = 10;
+/** Cap warn-level logs per connection for malformed frames to avoid spam. */
+export declare const MALFORMED_FRAMES_LOG_CAP = 5;

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

@@ -0,0 +1,6 @@
+
+
+const MALFORMED_FRAMES_FORCE_CLOSE_THRESHOLD = 10;
+const MALFORMED_FRAMES_LOG_CAP = 5;
+
+export { MALFORMED_FRAMES_FORCE_CLOSE_THRESHOLD, MALFORMED_FRAMES_LOG_CAP };

package/vscode/src/vs/platform/agentPlugins/common/pluginParsers.d.ts

@@ -75,9 +75,10 @@ export declare function parseComponentPathConfig(raw: unknown): IComponentPathCo
 /**
  * Resolves the directories to scan for a given component type, combining
  * the default directory with any custom paths from the manifest config.
- * Paths that resolve outside the plugin root are silently ignored.
+ * Paths that resolve outside the boundary are silently ignored.
+ * @param boundaryUri The outermost directory that resolved paths must stay within. Defaults to {@link pluginUri}.
  */
-export declare function resolveComponentDirs(pluginUri: URI, defaultDir: string, config: IComponentPathConfig): readonly URI[];
+export declare function resolveComponentDirs(pluginUri: URI, defaultDir: string, config: IComponentPathConfig, boundaryUri?: URI): readonly URI[];
 /**
  * Extracts the MCP server map from a raw JSON value. Accepts both the
  * wrapped format `{ mcpServers: { … } }` and the flat format.
@@ -115,4 +116,4 @@ export declare function parseMcpServerDefinitionMap(definitionURI: URI, raw: unk
  * Parses a plugin directory to extract hooks, MCP servers, skills, and agents.
  * This is the main entry point for the agent host to discover plugin contents.
  */
-export declare function parsePlugin(pluginUri: URI, fileService: IFileService, workspaceRoot: URI | undefined, userHome: string): Promise<IParsedPlugin>;
+export declare function parsePlugin(pluginUri: URI, fileService: IFileService, workspaceRoot: URI | undefined, userHome: string, boundaryUri?: URI): Promise<IParsedPlugin>;

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

@@ -3,7 +3,7 @@ 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 { joinPath, isEqualOrParent, normalizePath, 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';
@@ -106,14 +106,15 @@ function parseComponentPathConfig(raw) {
     }
     return emptyComponentPathConfig;
 }
-function resolveComponentDirs(pluginUri, defaultDir, config) {
+function resolveComponentDirs(pluginUri, defaultDir, config, boundaryUri) {
+    const boundary = (boundaryUri && isEqualOrParent(pluginUri, boundaryUri)) ? boundaryUri : pluginUri;
     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)) {
+        if (isEqualOrParent(resolved, boundary)) {
             dirs.push(resolved);
         }
     }

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

@@ -3,11 +3,12 @@ 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 const AgentNetworkFilterFetchWebToolName = "fetchWebTool";
 export declare class AgentNetworkFilterService extends Disposable implements IAgentNetworkFilterService {
     private readonly configurationService;
     private readonly terminalSandboxService;
     readonly _serviceBrand: undefined;
-    private enabled;
+    private networkFilterEnabled;
     private terminalSandboxEnabled;
     private allowedPatterns;
     private deniedPatterns;
@@ -17,6 +18,7 @@ export declare class AgentNetworkFilterService extends Disposable implements IAg
     constructor(configurationService: IConfigurationService, terminalSandboxService: ITerminalSandboxService);
     private readConfiguration;
     private updateTerminalSandboxEnabled;
-    isUriAllowed(uri: URI): boolean;
+    isUriAllowed(uri: URI, toolName?: string): boolean;
+    private shouldFilter;
     formatError(uri: URI): string;
 }

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

@@ -10,12 +10,13 @@ import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/
 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';
 
+const AgentNetworkFilterFetchWebToolName = "fetchWebTool";
 let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposable {
     constructor(configurationService, terminalSandboxService) {
         super();
         this.configurationService = configurationService;
         this.terminalSandboxService = terminalSandboxService;
-        this.enabled = false;
+        this.networkFilterEnabled = false;
         this.terminalSandboxEnabled = false;
         this.allowedPatterns = [];
         this.deniedPatterns = [];
@@ -35,13 +36,17 @@ let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposab
     }
     readConfiguration() {
         const networkFilterEnabled = this.configurationService.getValue(AgentNetworkDomainSettingId.NetworkFilter) ?? false;
-        this.enabled = networkFilterEnabled || this.terminalSandboxEnabled;
+        this.networkFilterEnabled = networkFilterEnabled;
         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();
+        const [isSandboxEnabled, isSandboxAllowNetworkEnabled] = await Promise.all([
+            this.terminalSandboxService.isEnabled(),
+            this.terminalSandboxService.isSandboxAllowNetworkEnabled()
+        ]);
+        const enabled = isSandboxEnabled && !isSandboxAllowNetworkEnabled;
         if (this.terminalSandboxEnabled === enabled) {
             return;
         }
@@ -49,8 +54,8 @@ let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposab
         this.readConfiguration();
         this.onDidChangeEmitter.fire();
     }
-    isUriAllowed(uri) {
-        if (!this.enabled) {
+    isUriAllowed(uri, toolName) {
+        if (!this.shouldFilter(toolName)) {
             return true;
         }
         if (uri.scheme === "file" || !uri.authority) {
@@ -67,10 +72,13 @@ let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposab
         }
         return result;
     }
+    shouldFilter(toolName) {
+        return this.networkFilterEnabled || (this.terminalSandboxEnabled && toolName === AgentNetworkFilterFetchWebToolName);
+    }
     formatError(uri) {
         const domain = extractDomainFromUri(uri);
         return localize(
-            2051,
+            2063,
             "Access to {0} is blocked by network domain policy (see `{1}` and `{2}` settings).",
             domain ?? uri.authority,
             AgentNetworkDomainSettingId.AllowedNetworkDomains,
@@ -80,4 +88,4 @@ let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposab
 };
 AgentNetworkFilterService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITerminalSandboxService))], AgentNetworkFilterService));
 
-export { AgentNetworkFilterService };
+export { AgentNetworkFilterFetchWebToolName, AgentNetworkFilterService };

package/vscode/src/vs/workbench/contrib/browserView/common/browserChatToolReferenceNames.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tool reference names for the integrated browser tools.
+ */
+export declare const BrowserChatToolReferenceName: {
+    readonly OpenBrowserPage: "openBrowserPage";
+    readonly ReadPage: "readPage";
+    readonly ScreenshotPage: "screenshotPage";
+    readonly NavigatePage: "navigatePage";
+    readonly ClickElement: "clickElement";
+    readonly TypeInPage: "typeInPage";
+    readonly HoverElement: "hoverElement";
+    readonly DragElement: "dragElement";
+    readonly HandleDialog: "handleDialog";
+    readonly RunPlaywrightCode: "runPlaywrightCode";
+};
+/**
+ * All browser-tool reference names as a flat list.
+ */
+export declare const browserChatToolReferenceNames: ("hoverElement" | "openBrowserPage" | "readPage" | "screenshotPage" | "navigatePage" | "clickElement" | "typeInPage" | "dragElement" | "handleDialog" | "runPlaywrightCode")[];

package/vscode/src/vs/workbench/contrib/browserView/common/browserChatToolReferenceNames.js

@@ -0,0 +1,17 @@
+
+
+const BrowserChatToolReferenceName = {
+    OpenBrowserPage: "openBrowserPage",
+    ReadPage: "readPage",
+    ScreenshotPage: "screenshotPage",
+    NavigatePage: "navigatePage",
+    ClickElement: "clickElement",
+    TypeInPage: "typeInPage",
+    HoverElement: "hoverElement",
+    DragElement: "dragElement",
+    HandleDialog: "handleDialog",
+    RunPlaywrightCode: "runPlaywrightCode"
+};
+const browserChatToolReferenceNames = ( Object.values(BrowserChatToolReferenceName));
+
+export { BrowserChatToolReferenceName, browserChatToolReferenceNames };

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(4704, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4705, "Untitled Chat"));
+        const title = widget?.viewModel?.model.title ? ( localize(4762, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4763, "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(4706, "New chat response."))
+            body: ( localize(4764, "New chat response."))
         }, cts.token);
         this.toasts.deleteAndDispose(disposable);
         if (clicked) {

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatResponseAccessibleView.d.ts

@@ -6,7 +6,7 @@ import { IAccessibleViewImplementation } from "@codingame/monaco-vscode-api/vsco
 import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { AccessibilityVerbositySettingId } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration";
-import { IChatExtensionsContent, IChatModifiedFilesConfirmationData, IChatPullRequestContent, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTerminalToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, IChatToolResourcesInvocationData, ILegacyChatTerminalToolInvocationData, IToolResultOutputDetailsSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatExtensionsContent, IChatModifiedFilesConfirmationData, IChatPullRequestContent, IChatSearchToolInvocationData, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTerminalToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, IChatToolResourcesInvocationData, ILegacyChatTerminalToolInvocationData, IToolResultOutputDetailsSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IToolResultInputOutputDetails, IToolResultOutputDetails } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { ChatTreeItem, IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 import { Location } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
@@ -17,7 +17,7 @@ export declare class ChatResponseAccessibleView implements IAccessibleViewImplem
     readonly when: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").RawContextKey<boolean>;
     getProvider(accessor: ServicesAccessor): ChatResponseAccessibleProvider | undefined;
 }
-type ToolSpecificData = IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData;
+type ToolSpecificData = IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData;
 type ResultDetails = Array<URI | Location> | IToolResultInputOutputDetails | IToolResultOutputDetails | IToolResultOutputDetailsSerialized;
 export declare const CHAT_ACCESSIBLE_VIEW_INCLUDE_THINKING_STORAGE_KEY = "chat.accessibleView.includeThinking";
 export declare function isThinkingContentIncludedInAccessibleView(storageService: IStorageService): boolean;

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

@@ -78,29 +78,29 @@ function getToolSpecificDataDescription(toolSpecificData) {
         {
             const parts = [];
             if (toolSpecificData.agentName) {
-                parts.push(( localize(4707, "Agent: {0}", toolSpecificData.agentName)));
+                parts.push(( localize(4765, "Agent: {0}", toolSpecificData.agentName)));
             }
             if (toolSpecificData.description) {
                 parts.push(toolSpecificData.description);
             }
             if (toolSpecificData.prompt) {
-                parts.push(( localize(4708, "Task: {0}", toolSpecificData.prompt)));
+                parts.push(( localize(4766, "Task: {0}", toolSpecificData.prompt)));
             }
             return parts.join(". ") || "";
         }
     case "extensions":
-        return toolSpecificData.extensions.length > 0 ? ( localize(4709, "Extensions: {0}", toolSpecificData.extensions.join(", "))) : "";
+        return toolSpecificData.extensions.length > 0 ? ( localize(4767, "Extensions: {0}", toolSpecificData.extensions.join(", "))) : "";
     case "todoList":
         {
             const todos = toolSpecificData.todoList;
             if (todos.length === 0) {
                 return "";
             }
-            const todoDescriptions = ( todos.map(t => ( localize(4710, "{0} ({1})", t.title, t.status))));
-            return localize(4711, "{0} items: {1}", todos.length, todoDescriptions.join("; "));
+            const todoDescriptions = ( todos.map(t => ( localize(4768, "{0} ({1})", t.title, t.status))));
+            return localize(4769, "{0} items: {1}", todos.length, todoDescriptions.join("; "));
         }
     case "pullRequest":
-        return localize(4712, "PR: {0} by {1}", toolSpecificData.title, toolSpecificData.author);
+        return localize(4770, "PR: {0} by {1}", toolSpecificData.title, toolSpecificData.author);
     case "input":
         return typeof toolSpecificData.rawInput === "string" ? toolSpecificData.rawInput : JSON.stringify(toolSpecificData.rawInput);
     case "resources":
@@ -116,13 +116,13 @@ function getToolSpecificDataDescription(toolSpecificData) {
                     return v.fsPath || v.path;
                 }
             })).join(", ");
-            return localize(4713, "Resources: {0}", paths);
+            return localize(4771, "Resources: {0}", paths);
         }
     case "simpleToolInvocation":
         {
             const inputText = toolSpecificData.input;
             const outputText = toolSpecificData.output;
-            return localize(4714, "Input: {0}, Output: {1}", inputText, outputText);
+            return localize(4772, "Input: {0}, Output: {1}", inputText, outputText);
         }
     case "modifiedFilesConfirmation":
         {
@@ -130,7 +130,7 @@ function getToolSpecificDataDescription(toolSpecificData) {
                 return "";
             }
             return localize(
-                4715,
+                4773,
                 "Modified files: {0}",
                 ( toolSpecificData.modifiedFiles.map(file => {
                     const revivedUri = URI.revive(file.uri);
@@ -165,12 +165,12 @@ function getResultDetailsDescription(resultDetails) {
     }
     if (isOutputDetailsSerialized(resultDetails)) {
         return {
-            input: ( localize(4716, "{0} data", resultDetails.output.mimeType))
+            input: ( localize(4774, "{0} data", resultDetails.output.mimeType))
         };
     }
     if (isToolResultOutputDetails(resultDetails)) {
         return {
-            input: ( localize(4716, "{0} data", resultDetails.output.mimeType))
+            input: ( localize(4774, "{0} data", resultDetails.output.mimeType))
         };
     }
     return {};
@@ -194,13 +194,13 @@ function getToolInvocationA11yDescription(
     if (isComplete && resultDetails) {
         const details = getResultDetailsDescription(resultDetails);
         if (details.isError) {
-            parts.unshift(( localize(4717, "Errored")));
+            parts.unshift(( localize(4775, "Errored")));
         }
         if (details.input && !toolDataDesc) {
-            parts.push(( localize(4718, "Input: {0}", details.input)));
+            parts.push(( localize(4776, "Input: {0}", details.input)));
         }
         if (details.files && details.files.length > 0) {
-            parts.push(( localize(4719, "Files: {0}", details.files.join(", "))));
+            parts.push(( localize(4777, "Files: {0}", details.files.join(", "))));
         }
     }
     return parts.join(". ");
@@ -262,7 +262,7 @@ class ChatResponseAccessibleProvider extends Disposable {
                     const thinkingValue = Array.isArray(part.value) ? part.value.join("") : (part.value || "");
                     const trimmed = thinkingValue.trim();
                     if (trimmed) {
-                        contentParts.push(( localize(4720, "Thinking: {0}", trimmed)));
+                        contentParts.push(( localize(4778, "Thinking: {0}", trimmed)));
                     }
                     break;
                 }
@@ -338,7 +338,7 @@ class ChatResponseAccessibleProvider extends Disposable {
                         contentParts.push(toolContent);
                     } else if (state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
                         const postApprovalDetails = isToolResultInputOutputDetails(state.resultDetails) ? state.resultDetails.input : isToolResultOutputDetails(state.resultDetails) ? undefined : toolContentToA11yString(state.contentForModel);
-                        contentParts.push(( localize(4721, "Approve results of {0}? Result: ", part.toolId)) + (postApprovalDetails ?? ""));
+                        contentParts.push(( localize(4779, "Approve results of {0}? Result: ", part.toolId)) + (postApprovalDetails ?? ""));
                     } else {
                         const resultDetails = IChatToolInvocation.resultDetails(part);
                         const isComplete = IChatToolInvocation.isComplete(part);

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatAccessibilityActions.js

@@ -22,11 +22,11 @@ class AnnounceChatConfirmationAction extends Action2 {
         super({
             id: ACTION_ID_FOCUS_CHAT_CONFIRMATION,
             title: {
-                value: ( localize(4722, "Focus Chat Confirmation")),
+                value: ( localize(4780, "Focus Chat Confirmation")),
                 original: "Focus Chat Confirmation"
             },
             category: {
-                value: ( localize(4723, "Chat")),
+                value: ( localize(4781, "Chat")),
                 original: "Chat"
             },
             precondition: ChatContextKeys.enabled,
@@ -42,30 +42,34 @@ class AnnounceChatConfirmationAction extends Action2 {
         const chatWidgetService = accessor.get(IChatWidgetService);
         const pendingWidget = chatWidgetService.getAllWidgets().find(widget => widget.viewModel?.model.requestNeedsInput.get());
         if (!pendingWidget) {
-            alert(( localize(4724, "No active chat session found.")));
+            alert(( localize(4782, "No active chat session found.")));
             return;
         }
         const viewModel = pendingWidget.viewModel;
         if (!viewModel) {
-            alert(( localize(4725, "Chat interface not ready.")));
+            alert(( localize(4783, "Chat interface not ready.")));
             return;
         }
         let firstConfirmationElement;
         const lastResponse = viewModel.getItems()[viewModel.getItems().length - 1];
         if (isResponseVM(lastResponse)) {
-            const confirmationWidgets = pendingWidget.domNode.querySelectorAll(".chat-confirmation-widget-container");
+            pendingWidget.reveal(lastResponse);
+            const confirmationWidgets = pendingWidget.domNode.querySelectorAll(".chat-confirmation-widget-container[tabindex]");
             if (confirmationWidgets.length > 0) {
-                firstConfirmationElement = confirmationWidgets[0];
+                firstConfirmationElement = confirmationWidgets[confirmationWidgets.length - 1];
             }
         }
         if (firstConfirmationElement) {
             if (firstConfirmationElement.contains(pendingWidget.domNode.ownerDocument.activeElement)) {
                 pendingWidget.focusInput();
             } else {
+                firstConfirmationElement.scrollIntoView({
+                    block: "nearest"
+                });
                 firstConfirmationElement.focus();
             }
         } else {
-            alert(( localize(4726, "No chat confirmation required")));
+            alert(( localize(4784, "No chat confirmation required")));
         }
     }
 }
@@ -74,11 +78,11 @@ class ToggleThinkingContentAccessibleViewAction extends Action2 {
         super({
             id: ACTION_ID_TOGGLE_THINKING_CONTENT_ACCESSIBLE_VIEW,
             title: {
-                value: ( localize(4727, "Toggle Thinking Content in Accessible View")),
+                value: ( localize(4785, "Toggle Thinking Content in Accessible View")),
                 original: "Toggle Thinking Content in Accessible View"
             },
             category: {
-                value: ( localize(4723, "Chat")),
+                value: ( localize(4781, "Chat")),
                 original: "Chat"
             },
             precondition: ChatContextKeys.enabled,
@@ -100,7 +104,7 @@ class ToggleThinkingContentAccessibleViewAction extends Action2 {
             StorageScope.PROFILE,
             StorageTarget.USER
         );
-        alert(updatedValue ? ( localize(4728, "Thinking content will be included in the accessible view.")) : ( localize(4729, "Thinking content will be hidden from the accessible view.")));
+        alert(updatedValue ? ( localize(4786, "Thinking content will be included in the accessible view.")) : ( localize(4787, "Thinking content will be hidden from the accessible view.")));
     }
 }
 function registerChatAccessibilityActions() {