@codingame/monaco-vscode-api 31.0.1 → 32.0.0

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

@@ -0,0 +1,126 @@
+
+
+var PolicyState;
+(function (PolicyState) {
+    PolicyState["Enabled"] = "enabled";
+    PolicyState["Disabled"] = "disabled";
+    PolicyState["Unconfigured"] = "unconfigured";
+})(PolicyState || (PolicyState = {}));
+var PendingMessageKind;
+(function (PendingMessageKind) {
+    PendingMessageKind["Steering"] = "steering";
+    PendingMessageKind["Queued"] = "queued";
+})(PendingMessageKind || (PendingMessageKind = {}));
+var SessionLifecycle;
+(function (SessionLifecycle) {
+    SessionLifecycle["Creating"] = "creating";
+    SessionLifecycle["Ready"] = "ready";
+    SessionLifecycle["CreationFailed"] = "creationFailed";
+})(SessionLifecycle || (SessionLifecycle = {}));
+var SessionStatus;
+(function (SessionStatus) {
+    SessionStatus[SessionStatus["Idle"] = 1] = "Idle";
+    SessionStatus[SessionStatus["Error"] = 2] = "Error";
+    SessionStatus[SessionStatus["InProgress"] = 8] = "InProgress";
+    SessionStatus[SessionStatus["InputNeeded"] = 24] = "InputNeeded";
+    SessionStatus[SessionStatus["IsRead"] = 32] = "IsRead";
+    SessionStatus[SessionStatus["IsArchived"] = 64] = "IsArchived";
+})(SessionStatus || (SessionStatus = {}));
+var SessionInputResponseKind;
+(function (SessionInputResponseKind) {
+    SessionInputResponseKind["Accept"] = "accept";
+    SessionInputResponseKind["Decline"] = "decline";
+    SessionInputResponseKind["Cancel"] = "cancel";
+})(SessionInputResponseKind || (SessionInputResponseKind = {}));
+var SessionInputQuestionKind;
+(function (SessionInputQuestionKind) {
+    SessionInputQuestionKind["Text"] = "text";
+    SessionInputQuestionKind["Number"] = "number";
+    SessionInputQuestionKind["Integer"] = "integer";
+    SessionInputQuestionKind["Boolean"] = "boolean";
+    SessionInputQuestionKind["SingleSelect"] = "single-select";
+    SessionInputQuestionKind["MultiSelect"] = "multi-select";
+})(SessionInputQuestionKind || (SessionInputQuestionKind = {}));
+var SessionInputAnswerValueKind;
+(function (SessionInputAnswerValueKind) {
+    SessionInputAnswerValueKind["Text"] = "text";
+    SessionInputAnswerValueKind["Number"] = "number";
+    SessionInputAnswerValueKind["Boolean"] = "boolean";
+    SessionInputAnswerValueKind["Selected"] = "selected";
+    SessionInputAnswerValueKind["SelectedMany"] = "selected-many";
+})(SessionInputAnswerValueKind || (SessionInputAnswerValueKind = {}));
+var SessionInputAnswerState;
+(function (SessionInputAnswerState) {
+    SessionInputAnswerState["Draft"] = "draft";
+    SessionInputAnswerState["Submitted"] = "submitted";
+    SessionInputAnswerState["Skipped"] = "skipped";
+})(SessionInputAnswerState || (SessionInputAnswerState = {}));
+var TurnState;
+(function (TurnState) {
+    TurnState["Complete"] = "complete";
+    TurnState["Cancelled"] = "cancelled";
+    TurnState["Error"] = "error";
+})(TurnState || (TurnState = {}));
+var MessageAttachmentKind;
+(function (MessageAttachmentKind) {
+    MessageAttachmentKind["Simple"] = "simple";
+    MessageAttachmentKind["EmbeddedResource"] = "embeddedResource";
+    MessageAttachmentKind["Resource"] = "resource";
+})(MessageAttachmentKind || (MessageAttachmentKind = {}));
+var ResponsePartKind;
+(function (ResponsePartKind) {
+    ResponsePartKind["Markdown"] = "markdown";
+    ResponsePartKind["ContentRef"] = "contentRef";
+    ResponsePartKind["ToolCall"] = "toolCall";
+    ResponsePartKind["Reasoning"] = "reasoning";
+    ResponsePartKind["SystemNotification"] = "systemNotification";
+})(ResponsePartKind || (ResponsePartKind = {}));
+var ToolCallStatus;
+(function (ToolCallStatus) {
+    ToolCallStatus["Streaming"] = "streaming";
+    ToolCallStatus["PendingConfirmation"] = "pending-confirmation";
+    ToolCallStatus["Running"] = "running";
+    ToolCallStatus["PendingResultConfirmation"] = "pending-result-confirmation";
+    ToolCallStatus["Completed"] = "completed";
+    ToolCallStatus["Cancelled"] = "cancelled";
+})(ToolCallStatus || (ToolCallStatus = {}));
+var ToolCallConfirmationReason;
+(function (ToolCallConfirmationReason) {
+    ToolCallConfirmationReason["NotNeeded"] = "not-needed";
+    ToolCallConfirmationReason["UserAction"] = "user-action";
+    ToolCallConfirmationReason["Setting"] = "setting";
+})(ToolCallConfirmationReason || (ToolCallConfirmationReason = {}));
+var ToolCallCancellationReason;
+(function (ToolCallCancellationReason) {
+    ToolCallCancellationReason["Denied"] = "denied";
+    ToolCallCancellationReason["Skipped"] = "skipped";
+    ToolCallCancellationReason["ResultDenied"] = "result-denied";
+})(ToolCallCancellationReason || (ToolCallCancellationReason = {}));
+var ConfirmationOptionKind;
+(function (ConfirmationOptionKind) {
+    ConfirmationOptionKind["Approve"] = "approve";
+    ConfirmationOptionKind["Deny"] = "deny";
+})(ConfirmationOptionKind || (ConfirmationOptionKind = {}));
+var ToolResultContentType;
+(function (ToolResultContentType) {
+    ToolResultContentType["Text"] = "text";
+    ToolResultContentType["EmbeddedResource"] = "embeddedResource";
+    ToolResultContentType["Resource"] = "resource";
+    ToolResultContentType["FileEdit"] = "fileEdit";
+    ToolResultContentType["Terminal"] = "terminal";
+    ToolResultContentType["Subagent"] = "subagent";
+})(ToolResultContentType || (ToolResultContentType = {}));
+var CustomizationStatus;
+(function (CustomizationStatus) {
+    CustomizationStatus["Loading"] = "loading";
+    CustomizationStatus["Loaded"] = "loaded";
+    CustomizationStatus["Degraded"] = "degraded";
+    CustomizationStatus["Error"] = "error";
+})(CustomizationStatus || (CustomizationStatus = {}));
+var TerminalClaimKind;
+(function (TerminalClaimKind) {
+    TerminalClaimKind["Client"] = "client";
+    TerminalClaimKind["Session"] = "session";
+})(TerminalClaimKind || (TerminalClaimKind = {}));
+
+export { ConfirmationOptionKind, CustomizationStatus, MessageAttachmentKind, PendingMessageKind, PolicyState, ResponsePartKind, SessionInputAnswerState, SessionInputAnswerValueKind, SessionInputQuestionKind, SessionInputResponseKind, SessionLifecycle, SessionStatus, TerminalClaimKind, ToolCallCancellationReason, ToolCallConfirmationReason, ToolCallStatus, ToolResultContentType, TurnState };

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

@@ -0,0 +1,40 @@
+export type { JsonRpcErrorResponse, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, JsonRpcSuccessResponse, } from "./protocol/messages.js";
+export type { AhpClientNotification, AhpNotification, AhpRequest, AhpResponse, AhpServerNotification, AhpSuccessResponse, CommandMap, ClientNotificationMap, NotificationMap, NotificationMethodParams, ProtocolMessage, ServerNotificationMap, } from "./protocol/messages.js";
+export type { CreateSessionParams, DirectoryEntry, DispatchActionParams, DisposeSessionParams, FetchTurnsParams, FetchTurnsResult, InitializeParams, InitializeResult, ListSessionsParams, ListSessionsResult, ReconnectParams, ReconnectReplayResult, ReconnectResult, ReconnectSnapshotResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListParams, ResourceListResult, ResourceMoveParams, ResourceMoveResult, ResourceReadParams, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, SubscribeParams, UnsubscribeParams, } from "./protocol/commands.js";
+export { ContentEncoding, ReconnectResultType } from "./protocol/commands.js";
+export { AhpErrorCodes, JsonRpcErrorCodes } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/errors";
+export type { AhpErrorCode, JsonRpcErrorCode } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/errors";
+export type { Snapshot as IStateSnapshot } from "./protocol/state.js";
+export declare const JSON_RPC_PARSE_ERROR: -32700;
+export declare const JSON_RPC_INTERNAL_ERROR: -32603;
+export declare const AHP_SESSION_NOT_FOUND: -32001;
+export declare const AHP_PROVIDER_NOT_FOUND: -32002;
+export declare const AHP_SESSION_ALREADY_EXISTS: -32003;
+export declare const AHP_TURN_IN_PROGRESS: -32004;
+export declare const AHP_UNSUPPORTED_PROTOCOL_VERSION: -32005;
+export declare const AHP_CONTENT_NOT_FOUND: -32006;
+export declare const AHP_AUTH_REQUIRED: -32007;
+import type { AhpRequest, AhpNotification, AhpSuccessResponse, ProtocolMessage, JsonRpcErrorResponse } from "./protocol/messages.js";
+export declare function isJsonRpcRequest(msg: ProtocolMessage): msg is AhpRequest;
+export declare function isJsonRpcNotification(msg: ProtocolMessage): msg is AhpNotification;
+export declare function isJsonRpcResponse(msg: ProtocolMessage): msg is AhpSuccessResponse | JsonRpcErrorResponse;
+/**
+ * Error with a JSON-RPC error code for protocol-level failures.
+ * Optionally carries a `data` payload for structured error details.
+ */
+export declare class ProtocolError extends Error {
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+/**
+ * VS Code-specific extension: set the auth token on the server.
+ * Not yet part of the official protocol.
+ */
+export interface ISetAuthTokenParams {
+    readonly token: string;
+}
+import type { INotification } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
+export interface INotificationBroadcastParams {
+    readonly notification: INotification;
+}

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

@@ -0,0 +1,22 @@
+
+export { ContentEncoding, ReconnectResultType } from './protocol/commands.js';
+
+const AHP_UNSUPPORTED_PROTOCOL_VERSION = -32005;
+function isJsonRpcRequest(msg) {
+    return 'method' in msg && 'id' in msg;
+}
+function isJsonRpcNotification(msg) {
+    return 'method' in msg && !('id' in msg);
+}
+function isJsonRpcResponse(msg) {
+    return 'id' in msg && !('method' in msg);
+}
+class ProtocolError extends Error {
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+
+export { AHP_UNSUPPORTED_PROTOCOL_VERSION, ProtocolError, isJsonRpcNotification, isJsonRpcRequest, isJsonRpcResponse };

package/vscode/src/vs/platform/browserView/common/browserView.d.ts

@@ -1,10 +1,10 @@
 import { Event } from "../../../base/common/event.js";
 import { VSBuffer } from "../../../base/common/buffer.js";
-import { UriComponents } from "../../../base/common/uri.js";
 export declare enum BrowserViewCommandId {
     Open = "workbench.action.browser.open",
     NewTab = "workbench.action.browser.newTab",
     QuickOpen = "workbench.action.browser.quickOpen",
+    OpenOrList = "workbench.action.browser.openOrList",
     CloseAll = "workbench.action.browser.closeAll",
     CloseAllInGroup = "workbench.action.browser.closeAllInGroup",
     GoBack = "workbench.action.browser.goBack",
@@ -75,6 +75,51 @@ export interface IBrowserViewCaptureScreenshotOptions {
         height: number;
     };
 }
+/**
+ * Identifies who owns a browser view's lifecycle.
+ * The owner is set at creation time and never changes.
+ */
+export interface IBrowserViewOwner {
+    /** The main code window ID that owns this view's lifecycle. */
+    readonly mainWindowId: number;
+    /** Optional session ID identifying the agent session that created this view. */
+    readonly sessionId?: string;
+}
+/**
+ * Summary information about a browser view, including its current state and
+ * ownership. Returned by the main service when listing or creating views.
+ */
+export interface IBrowserViewInfo {
+    readonly id: string;
+    readonly owner: IBrowserViewOwner;
+    readonly state: IBrowserViewState;
+}
+/**
+ * Editor opening hints passed from the main process to the workbench.
+ */
+export interface IBrowserViewOpenOptions {
+    readonly preserveFocus?: boolean;
+    readonly background?: boolean;
+    readonly pinned?: boolean;
+    /** The parent view ID. Used by the workbench to place the new tab in the same editor group. */
+    readonly parentViewId?: string;
+    /** When set, open in an auxiliary (new) window with these bounds. */
+    readonly auxiliaryWindow?: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    };
+}
+export interface IBrowserViewCreatedEvent {
+    readonly info: IBrowserViewInfo;
+    readonly openOptions?: IBrowserViewOpenOptions;
+}
+export interface IBrowserViewCreateOptions {
+    readonly owner: IBrowserViewOwner;
+    readonly scope: BrowserViewStorageScope;
+    readonly initialState?: Partial<IBrowserViewState>;
+}
 export interface IBrowserViewState {
     url: string;
     title: string;
@@ -90,6 +135,7 @@ export interface IBrowserViewState {
     certificateError: IBrowserViewCertificateError | undefined;
     storageScope: BrowserViewStorageScope;
     browserZoomIndex: number;
+    isElementSelectionActive: boolean;
 }
 export interface IBrowserViewNavigationEvent {
     url: string;
@@ -144,22 +190,6 @@ export interface IBrowserViewTitleChangeEvent {
 export interface IBrowserViewFaviconChangeEvent {
     favicon: string | undefined;
 }
-export declare enum BrowserNewPageLocation {
-    Foreground = "foreground",
-    Background = "background",
-    NewWindow = "newWindow"
-}
-export interface IBrowserViewNewPageRequest {
-    resource: UriComponents;
-    url: string;
-    location: BrowserNewPageLocation;
-    position?: {
-        x?: number;
-        y?: number;
-        width?: number;
-        height?: number;
-    };
-}
 export interface IBrowserViewFindInPageOptions {
     recompute?: boolean;
     forward?: boolean;
@@ -213,6 +243,10 @@ export declare function browserZoomAccessibilityLabel(zoomFactor: number): strin
  */
 export declare const browserViewIsolatedWorldId = 999;
 export interface IBrowserViewService {
+    /**
+     * Fires when a new browser view is created from an internal source (e.g. CDP or window.open).
+     */
+    onDidCreateBrowserView: Event<IBrowserViewCreatedEvent>;
     /**
      * Dynamic events that return an Event for a specific browser view ID.
      */
@@ -224,16 +258,21 @@ export interface IBrowserViewService {
     onDynamicDidKeyCommand(id: string): Event<IBrowserViewKeyDownEvent>;
     onDynamicDidChangeTitle(id: string): Event<IBrowserViewTitleChangeEvent>;
     onDynamicDidChangeFavicon(id: string): Event<IBrowserViewFaviconChangeEvent>;
-    onDynamicDidRequestNewPage(id: string): Event<IBrowserViewNewPageRequest>;
     onDynamicDidFindInPage(id: string): Event<IBrowserViewFindInPageResult>;
     onDynamicDidClose(id: string): Event<void>;
+    onDynamicDidSelectElement(id: string): Event<IElementData>;
+    onDynamicDidChangeElementSelectionActive(id: string): Event<boolean>;
+    /**
+     * Get all known browser views with their ownership and state information.
+     */
+    getBrowserViews(windowId?: number): Promise<IBrowserViewInfo[]>;
     /**
-     * Get or create a browser view instance
+     * Get or create a browser view instance. Does not fire `onDidCreateBrowserView`.
+     *
      * @param id The browser view identifier
-     * @param scope The storage scope for the browser view. Ignored if the view already exists.
-     * @param workspaceId Workspace identifier for session isolation. Only used if scope is 'workspace'.
+     * @param options Creation options. If a view with the given ID already exists, these options are ignored.
      */
-    getOrCreateBrowserView(id: string, scope: BrowserViewStorageScope, workspaceId?: string): Promise<IBrowserViewState>;
+    getOrCreateBrowserView(id: string, options: IBrowserViewCreateOptions): Promise<IBrowserViewState>;
     /**
      * Destroy a browser view instance
      * @param id The browser view identifier
@@ -373,24 +412,14 @@ export interface IBrowserViewService {
      */
     getConsoleLogs(id: string): Promise<string>;
     /**
-     * Start element inspection mode in a browser view. Sets up a CDP overlay that
-     * highlights elements on hover. When the user clicks an element, its data is
-     * returned and the overlay is removed.
-     * @param id The browser view identifier
-     * @param cancellationId An identifier that can be passed to {@link cancel} to abort
-     * @returns The inspected element data, or undefined if cancelled
-     */
-    getElementData(id: string, cancellationId: number): Promise<IElementData | undefined>;
-    /**
-     * Get element data for the currently focused element in the browser view.
+     * Toggle element selection mode in a browser view.
+     * Element selections are delivered via {@link onDynamicDidSelectElement}.
+     * State changes are delivered via {@link onDynamicDidChangeElementSelectionActive}.
+     *
      * @param id The browser view identifier
-     * @returns The focused element's data, or undefined if no element is focused
-     */
-    getFocusedElementData(id: string): Promise<IElementData | undefined>;
-    /**
-     * Cancel an in-progress request.
+     * @param enabled Whether to enable or disable. Omit to toggle.
      */
-    cancel(cancellationId: number): Promise<void>;
+    toggleElementSelection(id: string, enabled?: boolean): Promise<void>;
     /**
      * Update the keybinding accelerators used in browser view context menus.
      * @param keybindings A map of command ID to accelerator label

package/vscode/src/vs/platform/browserView/common/browserView.js

@@ -0,0 +1,57 @@
+
+import '../../../nls.js';
+
+var BrowserViewCommandId;
+(function(BrowserViewCommandId) {
+    BrowserViewCommandId["Open"] = "workbench.action.browser.open";
+    BrowserViewCommandId["NewTab"] = "workbench.action.browser.newTab";
+    BrowserViewCommandId["QuickOpen"] = "workbench.action.browser.quickOpen";
+    BrowserViewCommandId["OpenOrList"] = "workbench.action.browser.openOrList";
+    BrowserViewCommandId["CloseAll"] = "workbench.action.browser.closeAll";
+    BrowserViewCommandId["CloseAllInGroup"] = "workbench.action.browser.closeAllInGroup";
+    BrowserViewCommandId["GoBack"] = "workbench.action.browser.goBack";
+    BrowserViewCommandId["GoForward"] = "workbench.action.browser.goForward";
+    BrowserViewCommandId["Reload"] = "workbench.action.browser.reload";
+    BrowserViewCommandId["HardReload"] = "workbench.action.browser.hardReload";
+    BrowserViewCommandId["FocusUrlInput"] = "workbench.action.browser.focusUrlInput";
+    BrowserViewCommandId["OpenExternal"] = "workbench.action.browser.openExternal";
+    BrowserViewCommandId["OpenSettings"] = "workbench.action.browser.openSettings";
+    BrowserViewCommandId["AddElementToChat"] = "workbench.action.browser.addElementToChat";
+    BrowserViewCommandId["AddConsoleLogsToChat"] = "workbench.action.browser.addConsoleLogsToChat";
+    BrowserViewCommandId["ToggleDevTools"] = "workbench.action.browser.toggleDevTools";
+    BrowserViewCommandId["ClearGlobalStorage"] = "workbench.action.browser.clearGlobalStorage";
+    BrowserViewCommandId["ClearWorkspaceStorage"] = "workbench.action.browser.clearWorkspaceStorage";
+    BrowserViewCommandId["ClearEphemeralStorage"] = "workbench.action.browser.clearEphemeralStorage";
+    BrowserViewCommandId["ShowFind"] = "workbench.action.browser.showFind";
+    BrowserViewCommandId["HideFind"] = "workbench.action.browser.hideFind";
+    BrowserViewCommandId["FindNext"] = "workbench.action.browser.findNext";
+    BrowserViewCommandId["FindPrevious"] = "workbench.action.browser.findPrevious";
+})(BrowserViewCommandId || (BrowserViewCommandId = {}));
+var BrowserViewStorageScope;
+(function(BrowserViewStorageScope) {
+    BrowserViewStorageScope["Global"] = "global";
+    BrowserViewStorageScope["Workspace"] = "workspace";
+    BrowserViewStorageScope["Ephemeral"] = "ephemeral";
+})(BrowserViewStorageScope || (BrowserViewStorageScope = {}));
+const browserZoomFactors = [
+    0.25,
+    1 / 3,
+    0.5,
+    2 / 3,
+    0.75,
+    0.8,
+    0.9,
+    1,
+    1.1,
+    1.25,
+    1.5,
+    1.75,
+    2,
+    2.5,
+    3,
+    4,
+    5
+];
+const browserZoomDefaultIndex = browserZoomFactors.indexOf(1);
+
+export { BrowserViewCommandId, BrowserViewStorageScope, browserZoomDefaultIndex, browserZoomFactors };

package/vscode/src/vs/platform/browserView/common/browserViewTelemetry.d.ts

@@ -18,7 +18,8 @@ export type IntegratedBrowserOpenSource =
 /** Opened via the "New Tab" command from an existing tab. */
  | "newTabCommand"
 /** Opened via the localhost link opener when the `workbench.browser.openLocalhostLinks` setting
- * is enabled. This happens when clicking localhost links from the terminal, chat, or other sources. */
+ * is enabled. This happens when clicking localhost (e.g., `localhost`, `127.0.0.1`, `[::1]`) or all-interfaces
+ * links (e.g., `0.0.0.0`, `[::]`) from the terminal, chat, or other sources. */
  | "localhostLinkOpener"
 /** Opened when clicking a link inside the Integrated Browser that opens in a new focused editor
  * (e.g., links with target="_blank"). */

package/vscode/src/vs/platform/browserView/common/playwrightService.service.d.ts

@@ -4,6 +4,10 @@ export declare const IPlaywrightService: import("../../instantiation/common/inst
 /**
 * A service for using Playwright to connect to and automate the integrated browser.
 *
+* The service maintains a separate Playwright browser instance per session. Callers
+* must pass a {@link sessionId} to every method so operations are routed to the
+* correct instance. Page tracking is shared globally across all sessions.
+*
 * Pages must be explicitly tracked via {@link startTrackingPage} (or implicitly via
 * {@link openPage}) before they can be interacted with.
 */
@@ -36,28 +40,31 @@ export interface IPlaywrightService {
     /**
     * Opens a new page in the browser and returns its associated view ID.
     * The page is automatically added to the tracked pages.
+    * @param sessionId Identifies the session making the request.
     * @param url The URL to open in the new page.
     * @returns An object containing the new page's view ID and a summary of its initial state.
     */
-    openPage(url: string): Promise<{
+    openPage(sessionId: string, url: string): Promise<{
         pageId: string;
         summary: string;
     }>;
     /**
     * Gets a summary of the page's current state, including its DOM and visual representation.
+    * @param sessionId Identifies the session making the request.
     * @param pageId The browser view ID identifying the page to read.
     * @returns The summary of the page's current state.
     */
-    getSummary(pageId: string): Promise<string>;
+    getSummary(sessionId: string, pageId: string): Promise<string>;
     /**
     * Run a function with access to a Playwright page and return its raw result, or throw an error.
     * The first function argument is always the Playwright `page` object, and additional arguments can be passed after.
+    * @param sessionId Identifies the session making the request.
     * @param pageId The browser view ID identifying the page to operate on.
     * @param fnDef The function code to execute. Should contain the function definition but not its invocation, e.g. `async (page, arg1, arg2) => { ... }`.
     * @param args Additional arguments to pass to the function after the `page` object.
     * @returns The result of the function execution.
     */
-    invokeFunctionRaw<T>(pageId: string, fnDef: string, ...args: unknown[]): Promise<T>;
+    invokeFunctionRaw<T>(sessionId: string, pageId: string, fnDef: string, ...args: unknown[]): Promise<T>;
     /**
     * Run a function with access to a Playwright page and return a result for tool output, including error handling.
     * The first function argument is always the Playwright `page` object, and additional arguments can be passed after.
@@ -68,39 +75,49 @@ export interface IPlaywrightService {
     * {@link deferredResultId} that can be passed to {@link waitForDeferredResult} to resume waiting.
     * When {@link timeoutMs} is omitted the function runs to completion with no deferral.
     *
+    * @param sessionId Identifies the session making the request.
     * @param pageId The browser view ID identifying the page to operate on.
     * @param fnDef The function code to execute. Should contain the function definition but not its invocation, e.g. `async (page, arg1, arg2) => { ... }`.
     * @param args Additional arguments to pass to the function after the `page` object.
     * @param timeoutMs Maximum time (in ms) to wait for the function to complete before deferring. When omitted the call awaits indefinitely.
     * @returns The result of the function execution, including a page summary and optionally a deferredResultId if the call did not complete.
     */
-    invokeFunction(pageId: string, fnDef: string, args?: unknown[], timeoutMs?: number): Promise<IInvokeFunctionResult>;
+    invokeFunction(sessionId: string, pageId: string, fnDef: string, args?: unknown[], timeoutMs?: number): Promise<IInvokeFunctionResult>;
     /**
     * Continue waiting for a previously deferred function invocation.
     *
+    * @param sessionId Identifies the session making the request.
     * @param deferredResultId The ID returned from a timed-out {@link invokeFunction} call.
     * @param timeoutMs Maximum time (in ms) to wait before returning a deferred result again.
     * @returns The same shape as {@link invokeFunction}. If the result is still not
     * available after the timeout, {@link deferredResultId} is returned again.
     */
-    waitForDeferredResult(deferredResultId: string, timeoutMs: number): Promise<IInvokeFunctionResult>;
+    waitForDeferredResult(sessionId: string, deferredResultId: string, timeoutMs: number): Promise<IInvokeFunctionResult>;
     /**
     * Responds to a file chooser dialog on the given page.
+    * @param sessionId Identifies the session making the request.
     * @param pageId The browser view ID identifying the page.
     * @param files The list of files to select in the file chooser. Empty to dismiss the dialog without selecting files.
     * @returns An object with the page summary afterwards.
     */
-    replyToFileChooser(pageId: string, files: string[]): Promise<{
+    replyToFileChooser(sessionId: string, pageId: string, files: string[]): Promise<{
         summary: string;
     }>;
     /**
     * Responds to a dialog (alert, confirm, prompt) on the given page.
+    * @param sessionId Identifies the session making the request.
     * @param pageId The browser view ID identifying the page.
     * @param accept Whether to accept or dismiss the dialog.
     * @param promptText Optional text to enter into a prompt dialog.
     * @returns An object with the page summary afterwards.
     */
-    replyToDialog(pageId: string, accept: boolean, promptText?: string): Promise<{
+    replyToDialog(sessionId: string, pageId: string, accept: boolean, promptText?: string): Promise<{
         summary: string;
     }>;
+    /**
+    * Dispose a session's Playwright browser connection and release its resources.
+    * The session will be lazily recreated if needed.
+    * @param sessionId Identifies the session to dispose.
+    */
+    disposeSession(sessionId: string): Promise<void>;
 }

package/vscode/src/vs/platform/browserView/common/playwrightService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const IPlaywrightService = ( createDecorator("playwrightService"));
+
+export { IPlaywrightService };

package/vscode/src/vs/platform/configuration/common/configurationRegistry.d.ts

@@ -195,6 +195,20 @@ export interface IConfigurationPropertySchema extends IJSONSchema {
          */
         name?: string;
     };
+    /**
+     * When specified, provides configuration overrides for the Agents window.
+     */
+    agentsWindow?: {
+        /**
+         * Override default value for this setting in the Agents window.
+         */
+        default?: unknown;
+        /**
+         * When `true`, this setting is read-only in the Agents window
+         * and cannot be changed by the user.
+         */
+        readOnly?: boolean;
+    };
 }
 export interface IExtensionInfo {
     id: string;

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -82,7 +82,7 @@ class ConfigurationRegistry extends Disposable {
         this.configurationDefaultsOverrides = ( new Map());
         this.defaultLanguageConfigurationOverridesNode = {
             id: "defaultOverrides",
-            title: ( localize(1807, "Default Language Configuration Overrides")),
+            title: ( localize(1819, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -283,7 +283,7 @@ class ConfigurationRegistry extends Disposable {
             type: "object",
             default: newDefaultOverride.value,
             description: ( localize(
-                1808,
+                1820,
                 "Configure settings to be overridden for {0}.",
                 getLanguageTagSettingPlainKey(key)
             )),
@@ -601,8 +601,8 @@ class ConfigurationRegistry extends Disposable {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: "object",
-                description: ( localize(1809, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(1810, "This setting does not support per-language configuration.")),
+                description: ( localize(1821, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(1822, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -618,8 +618,8 @@ class ConfigurationRegistry extends Disposable {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: "object",
-            description: ( localize(1809, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(1810, "This setting does not support per-language configuration.")),
+            description: ( localize(1821, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(1822, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -694,25 +694,25 @@ const configurationRegistry = ( new ConfigurationRegistry());
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema, extensionId) {
     if (!property.trim()) {
-        return localize(1811, "Cannot register an empty property");
+        return localize(1823, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return localize(
-            1812,
+            1824,
             "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
             property
         );
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined && (!extensionId || !( EXTENSION_UNIFICATION_EXTENSION_IDS.has(extensionId.toLowerCase())))) {
         return localize(
-            1813,
+            1825,
             "Cannot register '{0}'. This property is already registered.",
             property
         );
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return localize(
-            1814,
+            1826,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,

package/vscode/src/vs/platform/configuration/common/configurations.d.ts

@@ -2,6 +2,7 @@ import { IStringDictionary } from "../../../base/common/collections.js";
 import { Event } from "../../../base/common/event.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
 import { ConfigurationModel } from "./configurationModels.js";
+import { IRegisteredConfigurationPropertySchema } from "./configurationRegistry.js";
 import { ILogService } from "../../log/common/log.service.js";
 import { IPolicyService } from "../../policy/common/policy.service.js";
 export declare class DefaultConfiguration extends Disposable {
@@ -20,6 +21,7 @@ export declare class DefaultConfiguration extends Disposable {
     protected getConfigurationDefaultOverrides(): IStringDictionary<unknown>;
     private resetConfigurationModel;
     private updateConfigurationModel;
+    protected getDefaultValue(_key: string, propertySchema: IRegisteredConfigurationPropertySchema): unknown;
 }
 export interface IPolicyConfiguration {
     readonly onDidChangeConfiguration: Event<ConfigurationModel>;