@codingame/monaco-vscode-api 28.4.1 → 29.1.0

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

@@ -0,0 +1,153 @@
+import type { Event } from "../../../../base/common/event.js";
+import type { IDisposable } from "../../../../base/common/lifecycle.js";
+/**
+ * CDP error codes following JSON-RPC 2.0 conventions
+ */
+export declare const CDPErrorCode: {
+    /** Method not found */
+    readonly MethodNotFound: -32601;
+    /** Invalid params */
+    readonly InvalidParams: -32602;
+    /** Internal error */
+    readonly InternalError: -32603;
+    /** Server error (generic) */
+    readonly ServerError: -32000;
+};
+/**
+ * Base CDP error class with error code
+ */
+export declare class CDPError extends Error {
+    readonly code: number;
+    constructor(message: string, code: number);
+}
+/**
+ * Error thrown when a CDP method is not found
+ */
+export declare class CDPMethodNotFoundError extends CDPError {
+    constructor(method: string);
+}
+/**
+ * Error thrown when CDP params are invalid
+ */
+export declare class CDPInvalidParamsError extends CDPError {
+    constructor(message: string);
+}
+/**
+ * Error thrown for internal CDP errors
+ */
+export declare class CDPInternalError extends CDPError {
+    constructor(message: string);
+}
+/**
+ * Error thrown for generic CDP server errors
+ */
+export declare class CDPServerError extends CDPError {
+    constructor(message: string);
+}
+/**
+ * CDP message types
+ */
+export interface CDPRequest {
+    id: number;
+    method: string;
+    params?: unknown;
+    sessionId?: string;
+}
+export interface CDPResponse {
+    id: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+    sessionId?: string;
+}
+export interface CDPEvent {
+    method: string;
+    params: unknown;
+    sessionId?: string;
+}
+export interface CDPTargetInfo {
+    targetId: string;
+    type: string;
+    title: string;
+    url: string;
+    attached: boolean;
+    canAccessOpener: boolean;
+    browserContextId?: string;
+}
+export interface CDPBrowserVersion {
+    protocolVersion: string;
+    product: string;
+    revision: string;
+    userAgent: string;
+    jsVersion: string;
+}
+export interface CDPWindowBounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    windowState: string;
+}
+/**
+ * A debuggable CDP target (e.g., a browser view).
+ * Targets can be attached to by CDP clients.
+ */
+export interface ICDPTarget {
+    /** Get target info for CDP protocol. Initializes the target if needed. */
+    getTargetInfo(): Promise<CDPTargetInfo>;
+    /** Attach to receive events and send commands. Initializes if needed. Dispose to detach. */
+    attach(): Promise<ICDPConnection>;
+}
+/**
+ * Service interface for managing CDP targets and browser contexts.
+ */
+export interface ICDPBrowserTarget extends ICDPTarget {
+    /** Event fired when a target is created */
+    readonly onTargetCreated: Event<ICDPTarget>;
+    /** Event fired when a target is about to be destroyed */
+    readonly onTargetDestroyed: Event<ICDPTarget>;
+    /** Get browser version info for CDP Browser.getVersion */
+    getVersion(): CDPBrowserVersion;
+    /** Get the window ID and bounds for a target */
+    getWindowForTarget(target: ICDPTarget): {
+        windowId: number;
+        bounds: CDPWindowBounds;
+    };
+    /** Get all available targets */
+    getTargets(): IterableIterator<ICDPTarget>;
+    /** Create a new target in the specified browser context */
+    createTarget(url: string, browserContextId?: string, windowId?: number): Promise<ICDPTarget>;
+    /** Activate a target (bring to foreground) */
+    activateTarget(target: ICDPTarget): Promise<void>;
+    /** Close a target */
+    closeTarget(target: ICDPTarget): Promise<boolean>;
+    /** Get all browser context IDs */
+    getBrowserContexts(): string[];
+    /** Create a new isolated browser context */
+    createBrowserContext(): Promise<string>;
+    /** Dispose a browser context and all its targets */
+    disposeBrowserContext(browserContextId: string): Promise<void>;
+}
+/**
+ * A bidirectional CDP connection that can send commands and receive events.
+ * Returned by ICDPTarget.attach() for low-level connections, and also
+ * implemented by CDPBrowserProxy for the full protocol-aware connection.
+ */
+export interface ICDPConnection extends IDisposable {
+    /** The session ID for this connection */
+    readonly sessionId: string;
+    /** Event fired when the connection receives a CDP event */
+    readonly onEvent: Event<CDPEvent>;
+    /** Event fired when the connection is closed */
+    readonly onClose: Event<void>;
+    /**
+     * Send a CDP command and await the result.
+     * @param method The CDP method to call
+     * @param params Optional parameters for the method
+     * @param sessionId Optional session ID for targeting a specific session
+     * @returns Promise resolving to the result or rejecting with a CDPError
+     */
+    sendCommand(method: string, params?: unknown, sessionId?: string): Promise<unknown>;
+}

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

@@ -0,0 +1,91 @@
+import { Event } from "../../../base/common/event.js";
+export declare const IPlaywrightService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IPlaywrightService>;
+/**
+* A service for using Playwright to connect to and automate the integrated browser.
+*
+* Pages must be explicitly tracked via {@link startTrackingPage} (or implicitly via
+* {@link openPage}) before they can be interacted with.
+*/
+export interface IPlaywrightService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Fires when the set of tracked pages changes.
+    * The event value is the full list of currently tracked view IDs.
+    */
+    readonly onDidChangeTrackedPages: Event<readonly string[]>;
+    /**
+    * Start tracking an existing browser view so that agent
+    * tools can interact with it.
+    * @param viewId The browser view identifier.
+    */
+    startTrackingPage(viewId: string): Promise<void>;
+    /**
+    * Stop tracking a browser view.
+    * @param viewId The browser view identifier.
+    */
+    stopTrackingPage(viewId: string): Promise<void>;
+    /**
+    * Whether the given page is currently tracked by the service.
+    */
+    isPageTracked(viewId: string): Promise<boolean>;
+    /**
+    * Get the list of currently tracked page IDs.
+    */
+    getTrackedPages(): Promise<readonly string[]>;
+    /**
+    * Opens a new page in the browser and returns its associated view ID.
+    * The page is automatically added to the tracked pages.
+    * @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<{
+        pageId: string;
+        summary: string;
+    }>;
+    /**
+    * Gets a summary of the page's current state, including its DOM and visual representation.
+    * @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>;
+    /**
+    * 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 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>;
+    /**
+    * 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.
+    * @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, including a page summary.
+    */
+    invokeFunction(pageId: string, fnDef: string, ...args: unknown[]): Promise<{
+        result: unknown;
+        summary: string;
+    }>;
+    /**
+    * Responds to a file chooser dialog on the given page.
+    * @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<{
+        summary: string;
+    }>;
+    /**
+    * Responds to a dialog (alert, confirm, prompt) on the given page.
+    * @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<{
+        summary: string;
+    }>;
+}

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

@@ -69,6 +69,7 @@ export declare function getConfigValueInTarget<T>(configValue: IConfigurationVal
 export declare function isConfigured<T>(configValue: IConfigurationValue<T>): configValue is IConfigurationValue<T> & {
     value: T;
 };
+export declare function isDefaultOverriden(settingName: string): boolean;
 export interface IConfigurationUpdateOptions {
     /**
      * If `true`, do not notifies the error to user by showing the message box. Default is `false`.

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

@@ -1,6 +1,8 @@
 
 import { assertNever } from '../../../base/common/assert.js';
 import { URI } from '../../../base/common/uri.js';
+import { Registry } from '../../registry/common/platform.js';
+import { Extensions } from './configurationRegistry.js';
 
 function isConfigurationOverrides(obj) {
     const thing = obj;
@@ -66,6 +68,9 @@ function getConfigValueInTarget(configValue, scope) {
 function isConfigured(configValue) {
     return configValue.applicationValue !== undefined || configValue.userValue !== undefined || configValue.userLocalValue !== undefined || configValue.userRemoteValue !== undefined || configValue.workspaceValue !== undefined || configValue.workspaceFolderValue !== undefined;
 }
+function isDefaultOverriden(settingName) {
+    return ( ( Registry.as(Extensions.Configuration)).getConfigurationDefaultsOverrides().has(settingName));
+}
 function toValuesTree(properties, conflictReporter) {
     const root = Object.create(null);
     for (const key in properties) {
@@ -151,4 +156,4 @@ function getLanguageTagSettingPlainKey(settingKey) {
     return settingKey.replace(/^\[/, "").replace(/]$/g, "").replace(/\]\[/g, ", ");
 }
 
-export { ConfigurationTarget, ConfigurationTargetToString, addToValueTree, getConfigValueInTarget, getConfigurationValue, getLanguageTagSettingPlainKey, isConfigurationOverrides, isConfigurationUpdateOverrides, isConfigured, removeFromValueTree, toValuesTree };
+export { ConfigurationTarget, ConfigurationTargetToString, addToValueTree, getConfigValueInTarget, getConfigurationValue, getLanguageTagSettingPlainKey, isConfigurationOverrides, isConfigurationUpdateOverrides, isConfigured, isDefaultOverriden, removeFromValueTree, toValuesTree };

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(1801, "Default Language Configuration Overrides")),
+            title: ( localize(1806, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -283,7 +283,7 @@ class ConfigurationRegistry extends Disposable {
             type: "object",
             default: newDefaultOverride.value,
             description: ( localize(
-                1802,
+                1807,
                 "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(1803, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(1804, "This setting does not support per-language configuration.")),
+                description: ( localize(1808, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(1809, "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(1803, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(1804, "This setting does not support per-language configuration.")),
+            description: ( localize(1808, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(1809, "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(1805, "Cannot register an empty property");
+        return localize(1810, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return localize(
-            1806,
+            1811,
             "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(
-            1807,
+            1812,
             "Cannot register '{0}'. This property is already registered.",
             property
         );
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return localize(
-            1808,
+            1813,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,

package/vscode/src/vs/platform/contextkey/browser/contextKeyService.js

@@ -535,7 +535,7 @@ CommandsRegistry.registerCommand({
         return [...RawContextKey.all()].sort((a, b) => a.key.localeCompare(b.key));
     },
     metadata: {
-        description: ( localize(1809, "A command that returns information about context keys")),
+        description: ( localize(1814, "A command that returns information about context keys")),
         args: []
     }
 });

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

@@ -47,17 +47,17 @@ var ContextKeyExprType;
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = ( localize(1810, "Empty context key expression"));
+const errorEmptyString = ( localize(1815, "Empty context key expression"));
 const hintEmptyString = ( localize(
-    1811,
+    1816,
     "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively."
 ));
-const errorNoInAfterNot = ( localize(1812, "'in' after 'not'."));
-const errorClosingParenthesis = ( localize(1813, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localize(1814, "Unexpected token"));
-const hintUnexpectedToken = ( localize(1815, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localize(1816, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localize(1817, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(1817, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(1818, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(1819, "Unexpected token"));
+const hintUnexpectedToken = ( localize(1820, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(1821, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(1822, "Did you forget to put a context key?"));
 class Parser {
     static {
         this._parseError = ( new Error());
@@ -391,7 +391,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = ( localize(1818, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
+        const message = ( localize(1823, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({
@@ -479,7 +479,7 @@ function validateWhenClauses(whenClauses) {
         parser.parse(whenClause);
         if (parser.lexingErrors.length > 0) {
             return (parser.lexingErrors.map(se => ({
-                errorMessage: se.additionalInfo ? ( localize(1819, "Unexpected token. Hint: {0}", se.additionalInfo)) : ( localize(1820, "Unexpected token.")),
+                errorMessage: se.additionalInfo ? ( localize(1824, "Unexpected token. Hint: {0}", se.additionalInfo)) : ( localize(1825, "Unexpected token.")),
                 offset: se.offset,
                 length: se.lexeme.length
             })));

package/vscode/src/vs/platform/contextkey/common/contextkeys.js

@@ -3,16 +3,16 @@ import { isMacintosh, isLinux, isWindows, isWeb, isIOS, isMobile } from '../../.
 import { localize } from '../../../nls.js';
 import { RawContextKey } from './contextkey.js';
 
-const IsMacContext = ( new RawContextKey("isMac", isMacintosh, ( localize(1821, "Whether the operating system is macOS"))));
-const IsLinuxContext = ( new RawContextKey("isLinux", isLinux, ( localize(1822, "Whether the operating system is Linux"))));
-const IsWindowsContext = ( new RawContextKey("isWindows", isWindows, ( localize(1823, "Whether the operating system is Windows"))));
-const IsWebContext = ( new RawContextKey("isWeb", isWeb, ( localize(1824, "Whether the platform is a web browser"))));
-const IsMacNativeContext = ( new RawContextKey("isMacNative", isMacintosh && !isWeb, ( localize(1825, "Whether the operating system is macOS on a non-browser platform"))));
-const IsIOSContext = ( new RawContextKey("isIOS", isIOS, ( localize(1826, "Whether the operating system is iOS"))));
-const IsMobileContext = ( new RawContextKey("isMobile", isMobile, ( localize(1827, "Whether the platform is a mobile web browser"))));
+const IsMacContext = ( new RawContextKey("isMac", isMacintosh, ( localize(1826, "Whether the operating system is macOS"))));
+const IsLinuxContext = ( new RawContextKey("isLinux", isLinux, ( localize(1827, "Whether the operating system is Linux"))));
+const IsWindowsContext = ( new RawContextKey("isWindows", isWindows, ( localize(1828, "Whether the operating system is Windows"))));
+const IsWebContext = ( new RawContextKey("isWeb", isWeb, ( localize(1829, "Whether the platform is a web browser"))));
+const IsMacNativeContext = ( new RawContextKey("isMacNative", isMacintosh && !isWeb, ( localize(1830, "Whether the operating system is macOS on a non-browser platform"))));
+const IsIOSContext = ( new RawContextKey("isIOS", isIOS, ( localize(1831, "Whether the operating system is iOS"))));
+const IsMobileContext = ( new RawContextKey("isMobile", isMobile, ( localize(1832, "Whether the platform is a mobile web browser"))));
 const IsDevelopmentContext = ( new RawContextKey("isDevelopment", false, true));
-const ProductQualityContext = ( new RawContextKey("productQualityType", "", ( localize(1828, "Quality type of VS Code"))));
+const ProductQualityContext = ( new RawContextKey("productQualityType", "", ( localize(1833, "Quality type of VS Code"))));
 const InputFocusedContextKey = "inputFocus";
-const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localize(1829, "Whether keyboard focus is inside an input box"))));
+const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localize(1834, "Whether keyboard focus is inside an input box"))));
 
 export { InputFocusedContext, InputFocusedContextKey, IsDevelopmentContext, IsIOSContext, IsLinuxContext, IsMacContext, IsMacNativeContext, IsMobileContext, IsWebContext, IsWindowsContext, ProductQualityContext };

package/vscode/src/vs/platform/contextkey/common/scanner.js

@@ -30,18 +30,18 @@ var TokenType;
 function hintDidYouMean(...meant) {
     switch (meant.length) {
     case 1:
-        return localize(1830, "Did you mean {0}?", meant[0]);
+        return localize(1835, "Did you mean {0}?", meant[0]);
     case 2:
-        return localize(1831, "Did you mean {0} or {1}?", meant[0], meant[1]);
+        return localize(1836, "Did you mean {0} or {1}?", meant[0], meant[1]);
     case 3:
-        return localize(1832, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]);
+        return localize(1837, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]);
     default:
         return undefined;
     }
 }
-const hintDidYouForgetToOpenOrCloseQuote = ( localize(1833, "Did you forget to open or close the quote?"));
+const hintDidYouForgetToOpenOrCloseQuote = ( localize(1838, "Did you forget to open or close the quote?"));
 const hintDidYouForgetToEscapeSlash = ( localize(
-    1834,
+    1839,
     "Did you forget to escape the '/' (slash) character? Put two backslashes before it to escape, e.g., '\\\\/'."
 ));
 class Scanner {

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

@@ -31,12 +31,12 @@ class AbstractDialogHandler {
                 if (confirmationDialog.primaryButton) {
                     buttons.push(confirmationDialog.primaryButton);
                 } else {
-                    buttons.push(( localize(1835, "&&Yes")));
+                    buttons.push(( localize(1840, "&&Yes")));
                 }
                 if (confirmationDialog.cancelButton) {
                     buttons.push(confirmationDialog.cancelButton);
                 } else {
-                    buttons.push(( localize(1836, "Cancel")));
+                    buttons.push(( localize(1841, "Cancel")));
                 }
                 break;
             }
@@ -48,19 +48,19 @@ class AbstractDialogHandler {
                 }
                 if (promptDialog.cancelButton) {
                     if (promptDialog.cancelButton === true) {
-                        buttons.push(( localize(1836, "Cancel")));
+                        buttons.push(( localize(1841, "Cancel")));
                     } else if (typeof promptDialog.cancelButton === "string") {
                         buttons.push(promptDialog.cancelButton);
                     } else {
                         if (promptDialog.cancelButton.label) {
                             buttons.push(promptDialog.cancelButton.label);
                         } else {
-                            buttons.push(( localize(1836, "Cancel")));
+                            buttons.push(( localize(1841, "Cancel")));
                         }
                     }
                 }
                 if (buttons.length === 0) {
-                    buttons.push(( localize(1837, "&&OK")));
+                    buttons.push(( localize(1842, "&&OK")));
                 }
                 break;
             }
@@ -70,12 +70,12 @@ class AbstractDialogHandler {
                 if (inputDialog.primaryButton) {
                     buttons.push(inputDialog.primaryButton);
                 } else {
-                    buttons.push(( localize(1837, "&&OK")));
+                    buttons.push(( localize(1842, "&&OK")));
                 }
                 if (inputDialog.cancelButton) {
                     buttons.push(inputDialog.cancelButton);
                 } else {
-                    buttons.push(( localize(1836, "Cancel")));
+                    buttons.push(( localize(1841, "Cancel")));
                 }
                 break;
             }
@@ -122,10 +122,10 @@ function getFileNamesMessage(fileNamesOrResources) {
     )));
     if (fileNamesOrResources.length > MAX_CONFIRM_FILES) {
         if (fileNamesOrResources.length - MAX_CONFIRM_FILES === 1) {
-            message.push(( localize(1838, "...1 additional file not shown")));
+            message.push(( localize(1843, "...1 additional file not shown")));
         } else {
             message.push(( localize(
-                1839,
+                1844,
                 "...{0} additional files not shown",
                 fileNamesOrResources.length - MAX_CONFIRM_FILES
             )));

package/vscode/src/vs/platform/dnd/browser/dnd.js

@@ -192,7 +192,7 @@ async function extractFileListData(accessor, files) {
         if (file) {
             if (file.size > 100 * ByteSize.MB) {
                 dialogService.warn(( localize(
-                    1840,
+                    1845,
                     "File is too large to open as untitled editor. Please upload it first into the file explorer and then try again."
                 )));
                 continue;

package/vscode/src/vs/platform/download/common/download.service.d.ts

@@ -3,5 +3,5 @@ import { URI } from "../../../base/common/uri.js";
 export declare const IDownloadService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IDownloadService>;
 export interface IDownloadService {
     readonly _serviceBrand: undefined;
-    download(uri: URI, to: URI, cancellationToken?: CancellationToken): Promise<void>;
+    download(uri: URI, to: URI, callSite: string, cancellationToken?: CancellationToken): Promise<void>;
 }

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

@@ -267,6 +267,24 @@ export interface IModalEditorPartOptions {
      * Whether the modal editor should be maximized.
      */
     readonly maximized?: boolean;
+    /**
+     * Minimum width of the modal editor part in pixels.
+     */
+    readonly minWidth?: number;
+    /**
+     * Size of the modal editor part unless it is maximized.
+     */
+    readonly size?: {
+        readonly width: number;
+        readonly height: number;
+    };
+    /**
+     * Position of the modal editor part unless it is maximized.
+     */
+    readonly position?: {
+        readonly left: number;
+        readonly top: number;
+    };
     /**
      * The navigation context for navigating between items
      * within this modal editor. Pass `undefined` to clear.

package/vscode/src/vs/platform/environment/common/argv.d.ts

@@ -16,6 +16,7 @@ export interface NativeParsedArgs {
         };
     };
     "serve-web"?: INativeCliOptions;
+    "agent-host"?: INativeCliOptions;
     chat?: {
         _: string[];
         "add-file"?: string[];
@@ -76,6 +77,8 @@ export interface NativeParsedArgs {
     "inspect-brk-search"?: string;
     "inspect-ptyhost"?: string;
     "inspect-brk-ptyhost"?: string;
+    "inspect-agenthost"?: string;
+    "inspect-brk-agenthost"?: string;
     "inspect-sharedprocess"?: string;
     "inspect-brk-sharedprocess"?: string;
     "disable-extensions"?: boolean;
@@ -97,6 +100,7 @@ export interface NativeParsedArgs {
     "disable-telemetry"?: boolean;
     "export-default-configuration"?: string;
     "export-policy-data"?: string;
+    "export-default-keybindings"?: string;
     "install-source"?: string;
     "add-mcp"?: string[];
     "disable-updates"?: boolean;
@@ -111,6 +115,7 @@ export interface NativeParsedArgs {
     "file-write"?: boolean;
     "file-chmod"?: boolean;
     "enable-smoke-test-driver"?: boolean;
+    "skip-sessions-welcome"?: boolean;
     "remote"?: string;
     "force"?: boolean;
     "do-not-sync"?: boolean;

package/vscode/src/vs/platform/environment/common/environment.service.d.ts

@@ -67,4 +67,5 @@ export interface INativeEnvironmentService extends IEnvironmentService {
     useInMemorySecretStorage?: boolean;
     crossOriginIsolated?: boolean;
     exportPolicyData?: string;
+    exportDefaultKeybindings?: string;
 }

package/vscode/src/vs/platform/environment/common/environmentService.d.ts

@@ -72,6 +72,7 @@ export declare abstract class AbstractNativeEnvironmentService implements INativ
     get agentSessionsWorkspace(): URI;
     get editSessionId(): string | undefined;
     get exportPolicyData(): string | undefined;
+    get exportDefaultKeybindings(): string | undefined;
     get continueOn(): string | undefined;
     set continueOn(value: string | undefined);
     get args(): NativeParsedArgs;