@codingame/monaco-vscode-api 28.4.1 → 29.1.0

package/vscode/src/vs/workbench/api/common/extHost.protocol.d.ts

@@ -29,6 +29,7 @@ import { IAccessibilityInformation } from "../../../platform/accessibility/commo
 import { ILocalizedString } from "../../../platform/action/common/action.js";
 import { ConfigurationTarget, IConfigurationChange, IConfigurationData, IConfigurationOverrides } from "../../../platform/configuration/common/configuration.js";
 import { ConfigurationScope } from "../../../platform/configuration/common/configurationRegistry.js";
+import { IEditorOptions } from "../../../platform/editor/common/editor.js";
 import { IExtensionIdWithVersion } from "../../../platform/extensionManagement/common/extensionStorage.js";
 import { ExtensionIdentifier, IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import * as files from "../../../platform/files/common/files.js";
@@ -57,7 +58,7 @@ import { ChatResponseClearToPreviousToolInvocationReason, IChatContentInlineRefe
 import { IChatSessionItem, IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem } from "../../contrib/chat/common/chatSessionsService.js";
 import { IChatRequestVariableValue } from "../../contrib/chat/common/attachments/chatVariables.js";
 import { ChatAgentLocation } from "../../contrib/chat/common/constants.js";
-import { IChatMessage, IChatResponsePart, ILanguageModelChatInfoOptions, ILanguageModelChatMetadataAndIdentifier, ILanguageModelChatSelector } from "../../contrib/chat/common/languageModels.js";
+import { IChatMessage, IChatResponsePart, ILanguageModelChatInfoOptions, ILanguageModelChatMetadataAndIdentifier, ILanguageModelChatRequestOptions, ILanguageModelChatSelector } from "../../contrib/chat/common/languageModels.js";
 import { IPreparedToolInvocation, IStreamedToolInvocation, IToolInvocation, IToolInvocationPreparationContext, IToolInvocationStreamContext, IToolProgressStep, IToolResult, ToolDataSource } from "../../contrib/chat/common/tools/languageModelToolsService.js";
 import { IPromptFileContext, IPromptFileResource } from "../../contrib/chat/common/promptSyntax/service/promptsService.js";
 import { DebugConfigurationProviderTriggerKind, IAdapterDescriptor, IConfig, IDebugSessionReplMode, IDebugTestRunReference, IDebugVisualization, IDebugVisualizationContext, IDebugVisualizationTreeItem, MainThreadDebugVisualization } from "../../contrib/debug/common/debug.js";
@@ -94,6 +95,7 @@ import { IExtHostDocumentSaveDelegate } from "./extHostDocumentData.js";
 import { TerminalShellExecutionCommandLineConfidence } from "./extHostTypes.js";
 import * as tasks from "@codingame/monaco-vscode-extensions-service-override/vscode/vs/workbench/api/common/shared/tasks";
 import { PromptsType } from "../../contrib/chat/common/promptSyntax/promptTypes.js";
+import { CDPEvent, CDPRequest, CDPResponse } from "../../../platform/browserView/common/cdp/types.js";
 export type IconPathDto = UriComponents | {
     light: UriComponents;
     dark: UriComponents;
@@ -1179,6 +1181,27 @@ export interface ExtHostSpeechShape {
     $createKeywordRecognitionSession(handle: number, session: number): Promise<void>;
     $cancelKeywordRecognitionSession(session: number): Promise<void>;
 }
+export interface BrowserTabDto {
+    id: string;
+    url: string;
+    title: string;
+    favicon: string | undefined;
+}
+export interface MainThreadBrowsersShape extends IDisposable {
+    $openBrowserTab(url: string, viewColumn?: EditorGroupColumn, options?: IEditorOptions): Promise<BrowserTabDto>;
+    $closeBrowserTab(browserId: string): Promise<void>;
+    $startCDPSession(sessionId: string, browserId: string): Promise<void>;
+    $closeCDPSession(sessionId: string): Promise<void>;
+    $sendCDPMessage(sessionId: string, message: CDPRequest): Promise<void>;
+}
+export interface ExtHostBrowsersShape {
+    $onDidOpenBrowserTab(browser: BrowserTabDto): void;
+    $onDidCloseBrowserTab(browserId: string): void;
+    $onDidChangeActiveBrowserTab(browserId: string | undefined): void;
+    $onDidChangeBrowserTabState(browser: BrowserTabDto): void;
+    $onCDPSessionMessage(sessionId: string, message: CDPResponse | CDPEvent): void;
+    $onCDPSessionClosed(sessionId: string): void;
+}
 export interface MainThreadLanguageModelsShape extends IDisposable {
     $registerLanguageModelProvider(vendor: string): void;
     $onLMProviderChange(vendor: string): void;
@@ -1199,9 +1222,7 @@ export interface ExtHostLanguageModelsShape {
         to: ExtensionIdentifier;
         enabled: boolean;
     }[]): void;
-    $startChatRequest(modelId: string, requestId: number, from: ExtensionIdentifier | undefined, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: {
-        [name: string]: any;
-    }, token: CancellationToken): Promise<void>;
+    $startChatRequest(modelId: string, requestId: number, from: ExtensionIdentifier | undefined, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: ILanguageModelChatRequestOptions, token: CancellationToken): Promise<void>;
     $acceptResponsePart(requestId: number, chunk: SerializableObjectWithBuffers<IChatResponsePart | IChatResponsePart[]>): Promise<void>;
     $acceptResponseDone(requestId: number, error: SerializedError | undefined): Promise<void>;
     $provideTokenLength(modelId: string, value: string | IChatMessage, token: CancellationToken): Promise<number>;
@@ -1316,15 +1337,34 @@ export interface IChatDebugEventModelTurnContentDto {
     readonly errorMessage?: string;
     readonly sections?: readonly IChatDebugMessageSectionDto[];
 }
-export type IChatDebugResolvedEventContentDto = IChatDebugEventTextContentDto | IChatDebugEventMessageContentDto | IChatDebugEventToolCallContentDto | IChatDebugEventModelTurnContentDto;
+export interface IChatDebugEventHookContentDto {
+    readonly kind: "hook";
+    readonly hookType: string;
+    readonly command?: string;
+    readonly result?: "success" | "error" | "nonBlockingError";
+    readonly durationInMillis?: number;
+    readonly input?: string;
+    readonly output?: string;
+    readonly exitCode?: number;
+    readonly errorMessage?: string;
+}
+export type IChatDebugResolvedEventContentDto = IChatDebugEventTextContentDto | IChatDebugEventMessageContentDto | IChatDebugEventToolCallContentDto | IChatDebugEventModelTurnContentDto | IChatDebugEventHookContentDto;
 export interface ExtHostChatDebugShape {
     $provideChatDebugLog(handle: number, sessionResource: UriComponents, token: CancellationToken): Promise<IChatDebugEventDto[] | undefined>;
     $resolveChatDebugLogEvent(handle: number, eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContentDto | undefined>;
+    $exportChatDebugLog(handle: number, sessionResource: UriComponents, coreEvents: IChatDebugEventDto[], sessionTitle: string | undefined, token: CancellationToken): Promise<VSBuffer | undefined>;
+    $importChatDebugLog(handle: number, data: VSBuffer, token: CancellationToken): Promise<{
+        uri: UriComponents;
+        sessionTitle?: string;
+    } | undefined>;
+    $onCoreDebugEvent(event: IChatDebugEventDto): void;
 }
 export interface MainThreadChatDebugShape extends IDisposable {
     $registerChatDebugLogProvider(handle: number): void;
     $unregisterChatDebugLogProvider(handle: number): void;
     $acceptChatDebugEvent(handle: number, event: IChatDebugEventDto): void;
+    $subscribeToCoreDebugEvents(): void;
+    $unsubscribeFromCoreDebugEvents(): void;
 }
 export interface MainThreadEmbeddingsShape extends IDisposable {
     $registerEmbeddingProvider(handle: number, identifier: string): void;
@@ -1911,7 +1951,7 @@ export interface ExtHostCodeMapperShape {
     $mapCode(handle: number, request: ICodeMapperRequestDto, token: CancellationToken): Promise<ICodeMapperResult | null | undefined>;
 }
 export interface ExtHostCommandsShape {
-    $executeContributedCommand(id: string, ...args: any[]): Promise<unknown>;
+    $executeContributedCommand(id: string, ...args: unknown[]): Promise<unknown>;
     $getContributedCommandMetadata(): Promise<{
         [id: string]: string | ICommandMetadataDto;
     }>;
@@ -2220,7 +2260,7 @@ export interface ISuggestDataDto {
     [ISuggestDataDtoField.kindModifier]?: languages.CompletionItemTag[];
     [ISuggestDataDtoField.commandIdent]?: string;
     [ISuggestDataDtoField.commandId]?: string;
-    [ISuggestDataDtoField.commandArguments]?: any[];
+    [ISuggestDataDtoField.commandArguments]?: unknown[];
     x?: ChainedCacheId;
 }
 export declare enum ISuggestResultDtoField {
@@ -2297,6 +2337,7 @@ export interface IChatUsageDto {
     kind: "usage";
     promptTokens: number;
     completionTokens: number;
+    outputBuffer?: number;
     promptTokenDetails?: readonly {
         category: string;
         label: string;
@@ -3130,6 +3171,10 @@ export interface ExtHostMcpShape {
     $sendMessage(id: number, message: string): void;
     $waitForInitialCollectionProviders(): Promise<void>;
     $onDidChangeMcpServerDefinitions(servers: McpServerDefinition.Serialized[]): void;
+    $onDidChangeGatewayServers(gatewayId: string, servers: {
+        label: string;
+        address: UriComponents;
+    }[]): void;
 }
 export interface IMcpAuthenticationDetails {
     authorizationServer: UriComponents;
@@ -3165,7 +3210,10 @@ export interface MainThreadMcpShape {
     $getTokenForProviderId(id: number, providerId: string, scopes: string[], options?: IMcpAuthenticationOptions): Promise<string | undefined>;
     $logMcpAuthSetup(data: IAuthMetadataSource): void;
     $startMcpGateway(): Promise<{
-        address: UriComponents;
+        servers: {
+            label: string;
+            address: UriComponents;
+        }[];
         gatewayId: string;
     } | undefined>;
     $disposeMcpGateway(gatewayId: string): void;
@@ -3265,21 +3313,30 @@ export type IChatSessionHistoryItemDto = {
     parts: IChatProgressDto[];
     participant: string;
 };
-export interface ChatSessionOptionUpdateDto {
-    readonly optionId: string;
-    readonly value: string | IChatSessionProviderOptionItem | undefined;
+export type IChatSessionRequestHistoryItemDto = Extract<IChatSessionHistoryItemDto, {
+    type: "request";
+}>;
+export interface ChatSessionContentContextDto {
+    readonly initialSessionOptions?: ReadonlyArray<{
+        optionId: string;
+        value: string;
+    }>;
 }
-export interface ChatSessionOptionUpdateDto2 {
-    readonly optionId: string;
-    readonly value: string | IChatSessionProviderOptionItem;
+export interface IChatNewSessionRequestDto {
+    readonly prompt: string;
+    readonly command?: string;
+    readonly initialSessionOptions?: ReadonlyArray<{
+        optionId: string;
+        value: string;
+    }>;
 }
-export interface ChatSessionDto {
-    id: string;
+export interface IChatSessionDto {
     resource: UriComponents;
     title?: string;
     history: Array<IChatSessionHistoryItemDto>;
     hasActiveResponseCallback: boolean;
     hasRequestHandler: boolean;
+    hasForkHandler: boolean;
     supportsInterruption: boolean;
     options?: Record<string, string | IChatSessionProviderOptionItem>;
 }
@@ -3296,11 +3353,10 @@ export interface MainThreadChatSessionsShape extends IDisposable {
     $unregisterChatSessionItemController(controllerHandle: number): void;
     $updateChatSessionItems(controllerHandle: number, change: IChatSessionItemsChange): Promise<void>;
     $addOrUpdateChatSessionItem(controllerHandle: number, item: Dto<IChatSessionItem>): Promise<void>;
-    $onDidChangeChatSessionItems(controllerHandle: number): void;
     $onDidCommitChatSessionItem(controllerHandle: number, original: UriComponents, modified: UriComponents): void;
     $registerChatSessionContentProvider(handle: number, chatSessionScheme: string): void;
     $unregisterChatSessionContentProvider(handle: number): void;
-    $onDidChangeChatSessionOptions(handle: number, sessionResource: UriComponents, updates: ReadonlyArray<ChatSessionOptionUpdateDto2>): void;
+    $onDidChangeChatSessionOptions(handle: number, sessionResource: UriComponents, updates: Record<string, string | IChatSessionProviderOptionItem>): void;
     $onDidChangeChatSessionProviderOptions(handle: number): void;
     $handleProgressChunk(handle: number, sessionResource: UriComponents, requestId: string, chunks: (IChatProgressDto | [
         IChatProgressDto,
@@ -3312,14 +3368,15 @@ export interface MainThreadChatSessionsShape extends IDisposable {
 export interface ExtHostChatSessionsShape {
     $refreshChatSessionItems(providerHandle: number, token: CancellationToken): Promise<void>;
     $onDidChangeChatSessionItemState(providerHandle: number, sessionResource: UriComponents, archived: boolean): void;
-    $newChatSessionItem(controllerHandle: number, request: Dto<IChatAgentRequest>, token: CancellationToken): Promise<Dto<IChatSessionItem> | undefined>;
-    $provideChatSessionContent(providerHandle: number, sessionResource: UriComponents, token: CancellationToken): Promise<ChatSessionDto>;
+    $newChatSessionItem(controllerHandle: number, request: IChatNewSessionRequestDto, token: CancellationToken): Promise<Dto<IChatSessionItem> | undefined>;
+    $provideChatSessionContent(providerHandle: number, sessionResource: UriComponents, context: ChatSessionContentContextDto, token: CancellationToken): Promise<IChatSessionDto>;
     $interruptChatSessionActiveResponse(providerHandle: number, sessionResource: UriComponents, requestId: string): Promise<void>;
     $disposeChatSessionContent(providerHandle: number, sessionResource: UriComponents): Promise<void>;
     $invokeChatSessionRequestHandler(providerHandle: number, sessionResource: UriComponents, request: IChatAgentRequest, history: any[], token: CancellationToken): Promise<IChatAgentResult>;
     $provideChatSessionProviderOptions(providerHandle: number, token: CancellationToken): Promise<IChatSessionProviderOptions | undefined>;
     $invokeOptionGroupSearch(providerHandle: number, optionGroupId: string, query: string, token: CancellationToken): Promise<IChatSessionProviderOptionItem[]>;
-    $provideHandleOptionsChange(providerHandle: number, sessionResource: UriComponents, updates: ReadonlyArray<ChatSessionOptionUpdateDto>, token: CancellationToken): Promise<void>;
+    $provideHandleOptionsChange(providerHandle: number, sessionResource: UriComponents, updates: Record<string, string | IChatSessionProviderOptionItem | undefined>, token: CancellationToken): Promise<void>;
+    $forkChatSession(providerHandle: number, sessionResource: UriComponents, request: IChatSessionRequestHistoryItemDto | undefined, token: CancellationToken): Promise<Dto<IChatSessionItem>>;
 }
 export interface GitRefQueryDto {
     readonly contains?: string;
@@ -3338,18 +3395,36 @@ export interface GitRefDto {
     readonly type: GitRefTypeDto;
     readonly revision: string;
 }
+export interface GitChangeDto {
+    readonly uri: UriComponents;
+    readonly originalUri: UriComponents | undefined;
+    readonly modifiedUri: UriComponents | undefined;
+}
+export interface GitDiffChangeDto extends GitChangeDto {
+    readonly insertions: number;
+    readonly deletions: number;
+}
 export interface GitRepositoryStateDto {
     readonly HEAD?: GitBranchDto;
+    readonly mergeChanges: readonly GitChangeDto[];
+    readonly indexChanges: readonly GitChangeDto[];
+    readonly workingTreeChanges: readonly GitChangeDto[];
+    readonly untrackedChanges: readonly GitChangeDto[];
 }
 export interface GitBranchDto {
     readonly name?: string;
     readonly commit?: string;
     readonly type: GitRefTypeDto;
     readonly remote?: string;
+    readonly base?: GitBaseRefDto;
     readonly upstream?: GitUpstreamRefDto;
     readonly ahead?: number;
     readonly behind?: number;
 }
+export interface GitBaseRefDto {
+    readonly name: string;
+    readonly isProtected: boolean;
+}
 export interface GitUpstreamRefDto {
     readonly remote: string;
     readonly name: string;
@@ -3364,6 +3439,8 @@ export interface ExtHostGitExtensionShape {
     } | undefined>;
     $getRefs(handle: number, query: GitRefQueryDto, token?: CancellationToken): Promise<GitRefDto[]>;
     $getRepositoryState(handle: number): Promise<GitRepositoryStateDto | undefined>;
+    $diffBetweenWithStats(handle: number, ref1: string, ref2: string, path?: string): Promise<GitDiffChangeDto[]>;
+    $diffBetweenWithStats2(handle: number, ref: string, path?: string): Promise<GitDiffChangeDto[]>;
 }
 export declare const MainContext: {
     MainThreadAuthentication: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<MainThreadAuthenticationShape>;
@@ -3447,6 +3524,7 @@ export declare const MainContext: {
     MainThreadChatOutputRenderer: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<MainThreadChatOutputRendererShape>;
     MainThreadChatContext: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<MainThreadChatContextShape>;
     MainThreadChatDebug: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<MainThreadChatDebugShape>;
+    MainThreadBrowsers: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<MainThreadBrowsersShape>;
 };
 export declare const ExtHostContext: {
     ExtHostCodeMapper: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<ExtHostCodeMapperShape>;
@@ -3526,5 +3604,6 @@ export declare const ExtHostContext: {
     ExtHostDataChannels: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<ExtHostDataChannelsShape>;
     ExtHostChatSessions: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<ExtHostChatSessionsShape>;
     ExtHostGitExtension: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<ExtHostGitExtensionShape>;
+    ExtHostBrowsers: import("../../services/extensions/common/proxyIdentifier.js").ProxyIdentifier<ExtHostBrowsersShape>;
 };
 export {};

package/vscode/src/vs/workbench/api/common/extHost.protocol.js

@@ -201,7 +201,8 @@ const MainContext = {
     MainThreadChatSessions: ( createProxyIdentifier("MainThreadChatSessions")),
     MainThreadChatOutputRenderer: ( createProxyIdentifier("MainThreadChatOutputRenderer")),
     MainThreadChatContext: ( createProxyIdentifier("MainThreadChatContext")),
-    MainThreadChatDebug: ( createProxyIdentifier("MainThreadChatDebug"))
+    MainThreadChatDebug: ( createProxyIdentifier("MainThreadChatDebug")),
+    MainThreadBrowsers: ( createProxyIdentifier("MainThreadBrowsers"))
 };
 const ExtHostContext = {
     ExtHostCodeMapper: ( createProxyIdentifier("ExtHostCodeMapper")),
@@ -280,7 +281,8 @@ const ExtHostContext = {
     ExtHostMcp: ( createProxyIdentifier("ExtHostMcp")),
     ExtHostDataChannels: ( createProxyIdentifier("ExtHostDataChannels")),
     ExtHostChatSessions: ( createProxyIdentifier("ExtHostChatSessions")),
-    ExtHostGitExtension: ( createProxyIdentifier("ExtHostGitExtension"))
+    ExtHostGitExtension: ( createProxyIdentifier("ExtHostGitExtension")),
+    ExtHostBrowsers: ( createProxyIdentifier("ExtHostBrowsers"))
 };
 
 export { CandidatePortSource, CellOutputKind, ExtHostContext, ExtHostTestingResource, GitRefTypeDto, IAuthResourceMetadataSource, IAuthServerMetadataSource, ISuggestDataDtoField, ISuggestResultDtoField, MainContext, NotebookEditorRevealType, TabInputKind, TabModelOperationKind, TextEditorRevealType, WebviewEditorCapabilities, WebviewMessageArrayBufferViewType };

package/vscode/src/vs/workbench/api/common/extHostApiDeprecationService.d.ts

@@ -3,7 +3,9 @@ import { ILogService } from "../../../platform/log/common/log.service.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
 export interface IExtHostApiDeprecationService {
     readonly _serviceBrand: undefined;
-    report(apiId: string, extension: IExtensionDescription, migrationSuggestion: string): void;
+    report(apiId: string, extension: IExtensionDescription, migrationSuggestion: string, options?: {
+        usageId?: string;
+    }): void;
 }
 export declare const IExtHostApiDeprecationService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostApiDeprecationService>;
 export declare class ExtHostApiDeprecationService implements IExtHostApiDeprecationService {
@@ -12,7 +14,9 @@ export declare class ExtHostApiDeprecationService implements IExtHostApiDeprecat
     private readonly _reportedUsages;
     private readonly _telemetryShape;
     constructor(rpc: IExtHostRpcService, _extHostLogService: ILogService);
-    report(apiId: string, extension: IExtensionDescription, migrationSuggestion: string): void;
+    report(apiId: string, extension: IExtensionDescription, migrationSuggestion: string, options?: {
+        usageId?: string;
+    }): void;
     private getUsageKey;
 }
 export declare const NullApiDeprecationService: Readonly<{

package/vscode/src/vs/workbench/api/common/extHostApiDeprecationService.js

@@ -12,8 +12,8 @@ let ExtHostApiDeprecationService = class ExtHostApiDeprecationService {
         this._reportedUsages = ( new Set());
         this._telemetryShape = ( rpc.getProxy(MainContext.MainThreadTelemetry));
     }
-    report(apiId, extension, migrationSuggestion) {
-        const key = this.getUsageKey(apiId, extension);
+    report(apiId, extension, migrationSuggestion, options) {
+        const key = this.getUsageKey(apiId, extension, options?.usageId);
         if (( this._reportedUsages.has(key))) {
             return;
         }
@@ -23,11 +23,13 @@ let ExtHostApiDeprecationService = class ExtHostApiDeprecationService {
         }
         this._telemetryShape.$publicLog2("extHostDeprecatedApiUsage", {
             extensionId: extension.identifier.value,
-            apiId: apiId
+            apiId: apiId,
+            usageId: options?.usageId ?? ""
         });
     }
-    getUsageKey(apiId, extension) {
-        return `${apiId}-${extension.identifier.value}`;
+    getUsageKey(apiId, extension, usageId) {
+        const rootKey = `${apiId}-${extension.identifier.value}`;
+        return usageId ? `${rootKey}-${usageId}` : rootKey;
     }
 };
 ExtHostApiDeprecationService = ( __decorate([( __param(0, IExtHostRpcService)), ( __param(1, ILogService))], ExtHostApiDeprecationService));

package/vscode/src/vs/workbench/api/common/extHostAuthentication.js

@@ -372,7 +372,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         this._createFlows = [];
         if (_serverMetadata.authorization_endpoint) {
             this._createFlows.push({
-                label: ( localize(2733, "URL Handler")),
+                label: ( localize(2741, "URL Handler")),
                 handler: (scopes, progress, token) => this._createWithUrlHandler(scopes, progress, token)
             });
         }
@@ -451,7 +451,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
                     id: this.id
                 }, {
                     location: ProgressLocation.Notification,
-                    title: ( localize(2734, "Authenticating to '{0}'", this.label)),
+                    title: ( localize(2742, "Authenticating to '{0}'", this.label)),
                     cancellable: true
                 }, (progress, token) => handler(scopes, progress, token));
                 if (token) {
@@ -463,12 +463,12 @@ let DynamicAuthProvider = class DynamicAuthProvider {
                     break;
                 }
                 const message = isCancellationError(err) ? ( localize(
-                    2735,
+                    2743,
                     "Having trouble authenticating to '{0}'? Would you like to try a different way? ({1})",
                     this.label,
                     nextMode
                 )) : ( localize(
-                    2736,
+                    2744,
                     "You have not yet finished authenticating to '{0}'. Would you like to try a different way? ({1})",
                     this.label,
                     nextMode
@@ -567,7 +567,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             throw ( new CancellationError());
         }
         progress.report({
-            message: ( localize(2737, "Complete the authentication in the browser window that has opened."))
+            message: ( localize(2745, "Complete the authentication in the browser window that has opened."))
         });
         let code;
         try {

package/vscode/src/vs/workbench/api/common/extHostBrowsers.d.ts

@@ -0,0 +1,30 @@
+import { Event } from "../../../base/common/event.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import type * as vscode from "vscode";
+import { BrowserTabDto, ExtHostBrowsersShape, IMainContext } from "./extHost.protocol.js";
+import { CDPEvent, CDPResponse } from "../../../platform/browserView/common/cdp/types.js";
+export declare class ExtHostBrowsers extends Disposable implements ExtHostBrowsersShape {
+    private readonly _proxy;
+    private readonly _browserTabs;
+    private readonly _sessions;
+    private _activeBrowserTabId;
+    private readonly _onDidOpenBrowserTab;
+    readonly onDidOpenBrowserTab: Event<vscode.BrowserTab>;
+    private readonly _onDidCloseBrowserTab;
+    readonly onDidCloseBrowserTab: Event<vscode.BrowserTab>;
+    private readonly _onDidChangeActiveBrowserTab;
+    readonly onDidChangeActiveBrowserTab: Event<vscode.BrowserTab | undefined>;
+    private readonly _onDidChangeBrowserTabState;
+    readonly onDidChangeBrowserTabState: Event<vscode.BrowserTab>;
+    constructor(mainContext: IMainContext);
+    get browserTabs(): readonly vscode.BrowserTab[];
+    get activeBrowserTab(): vscode.BrowserTab | undefined;
+    openBrowserTab(url: string, options?: vscode.BrowserTabShowOptions): Promise<vscode.BrowserTab>;
+    private _getOrCreateTab;
+    $onDidOpenBrowserTab(dto: BrowserTabDto): void;
+    $onDidCloseBrowserTab(browserId: string): void;
+    $onDidChangeActiveBrowserTab(browserId: string | undefined): void;
+    $onDidChangeBrowserTabState(data: BrowserTabDto): void;
+    $onCDPSessionMessage(sessionId: string, message: CDPResponse | CDPEvent): void;
+    $onCDPSessionClosed(sessionId: string): void;
+}

package/vscode/src/vs/workbench/api/common/extHostBrowsers.js

@@ -0,0 +1,211 @@
+
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable, DisposableMap } from '../../../base/common/lifecycle.js';
+import { URI } from '../../../base/common/uri.js';
+import { Codicon } from '../../../base/common/codicons.js';
+import { MainContext } from './extHost.protocol.js';
+import { generateUuid } from '../../../base/common/uuid.js';
+import { ThemeIcon } from './extHostTypes.js';
+import { ViewColumn } from './extHostTypeConverters.js';
+
+class ExtHostBrowserTab {
+    constructor(id, _proxy, _sessions, data) {
+        this.id = id;
+        this._proxy = _proxy;
+        this._sessions = _sessions;
+        this._url = data.url;
+        this._title = data.title;
+        this._favicon = data.favicon;
+        const that = this;
+        this.value = {
+            get url() {
+                return that._url;
+            },
+            get title() {
+                return that._title;
+            },
+            get icon() {
+                return that._favicon ? ( URI.parse(that._favicon)) : new ThemeIcon(Codicon.globe.id);
+            },
+            startCDPSession() {
+                return that._startCDPSession();
+            },
+            close() {
+                return that._close();
+            }
+        };
+    }
+    update(data) {
+        let changed = false;
+        if (data.url !== this._url) {
+            this._url = data.url;
+            changed = true;
+        }
+        if (data.title !== this._title) {
+            this._title = data.title;
+            changed = true;
+        }
+        if (data.favicon !== this._favicon) {
+            this._favicon = data.favicon;
+            changed = true;
+        }
+        return changed;
+    }
+    async _startCDPSession() {
+        const sessionId = generateUuid();
+        await this._proxy.$startCDPSession(sessionId, this.id);
+        const session = ( new ExtHostBrowserCDPSession(sessionId, this._proxy));
+        this._sessions.set(sessionId, session);
+        return session.value;
+    }
+    async _close() {
+        await this._proxy.$closeBrowserTab(this.id);
+    }
+}
+class ExtHostBrowserCDPSession {
+    constructor(id, _proxy) {
+        this.id = id;
+        this._proxy = _proxy;
+        this._onDidReceiveMessage = ( new Emitter());
+        this._onDidClose = ( new Emitter());
+        this._closed = false;
+        const that = this;
+        this.value = {
+            get onDidReceiveMessage() {
+                return that._onDidReceiveMessage.event;
+            },
+            get onDidClose() {
+                return that._onDidClose.event;
+            },
+            sendMessage(message) {
+                return that._sendMessage(message);
+            },
+            close() {
+                return that._close();
+            }
+        };
+    }
+    dispose() {
+        this._onDidReceiveMessage.dispose();
+        this._onDidClose.dispose();
+    }
+    async _sendMessage(message) {
+        if (this._closed) {
+            throw ( new Error("Session is closed"));
+        }
+        if (!message || typeof message !== "object") {
+            throw ( new Error("Message must be an object"));
+        }
+        if (typeof message.id !== "number") {
+            throw ( new Error("Message must have a numeric id"));
+        }
+        if (typeof message.method !== "string") {
+            throw ( new Error("Message must have a method string"));
+        }
+        if (message.params !== undefined && typeof message.params !== "object") {
+            throw ( new Error("Message params must be an object"));
+        }
+        if (message.sessionId !== undefined && typeof message.sessionId !== "string") {
+            throw ( new Error("Message sessionId must be a string"));
+        }
+        await this._proxy.$sendCDPMessage(this.id, {
+            id: message.id,
+            method: message.method,
+            params: message.params,
+            sessionId: message.sessionId
+        });
+    }
+    async _close() {
+        this._closed = true;
+        await this._proxy.$closeCDPSession(this.id);
+    }
+    _acceptMessage(message) {
+        this._onDidReceiveMessage.fire(message);
+    }
+    _acceptClosed() {
+        this._closed = true;
+        this._onDidClose.fire();
+    }
+}
+class ExtHostBrowsers extends Disposable {
+    constructor(mainContext) {
+        super();
+        this._browserTabs = ( new Map());
+        this._sessions = this._register(( new DisposableMap()));
+        this._onDidOpenBrowserTab = this._register(( new Emitter()));
+        this.onDidOpenBrowserTab = this._onDidOpenBrowserTab.event;
+        this._onDidCloseBrowserTab = this._register(( new Emitter()));
+        this.onDidCloseBrowserTab = this._onDidCloseBrowserTab.event;
+        this._onDidChangeActiveBrowserTab = this._register(( new Emitter()));
+        this.onDidChangeActiveBrowserTab = this._onDidChangeActiveBrowserTab.event;
+        this._onDidChangeBrowserTabState = this._register(( new Emitter()));
+        this.onDidChangeBrowserTabState = this._onDidChangeBrowserTabState.event;
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadBrowsers));
+    }
+    get browserTabs() {
+        return ( [...( this._browserTabs.values())].map(t => t.value));
+    }
+    get activeBrowserTab() {
+        if (this._activeBrowserTabId) {
+            return this._browserTabs.get(this._activeBrowserTabId)?.value;
+        }
+        return undefined;
+    }
+    async openBrowserTab(url, options) {
+        const viewColumn = ViewColumn.from(options?.viewColumn);
+        const dto = await this._proxy.$openBrowserTab(url, viewColumn, {
+            preserveFocus: options?.preserveFocus,
+            inactive: options?.background
+        });
+        return this._getOrCreateTab(dto).value;
+    }
+    _getOrCreateTab(dto) {
+        let tab = this._browserTabs.get(dto.id);
+        if (!tab) {
+            tab = ( new ExtHostBrowserTab(dto.id, this._proxy, this._sessions, dto));
+            this._browserTabs.set(dto.id, tab);
+            this._onDidOpenBrowserTab.fire(tab.value);
+        } else {
+            tab.update(dto);
+        }
+        return tab;
+    }
+    $onDidOpenBrowserTab(dto) {
+        this._getOrCreateTab(dto);
+    }
+    $onDidCloseBrowserTab(browserId) {
+        const tab = this._browserTabs.get(browserId);
+        if (tab) {
+            this._browserTabs.delete(browserId);
+            if (this._activeBrowserTabId === browserId) {
+                this._activeBrowserTabId = undefined;
+            }
+            this._onDidCloseBrowserTab.fire(tab.value);
+        }
+    }
+    $onDidChangeActiveBrowserTab(browserId) {
+        this._activeBrowserTabId = browserId;
+        this._onDidChangeActiveBrowserTab.fire(this.activeBrowserTab);
+    }
+    $onDidChangeBrowserTabState(data) {
+        const tab = this._browserTabs.get(data.id);
+        if (tab && tab.update(data)) {
+            this._onDidChangeBrowserTabState.fire(tab.value);
+        }
+    }
+    $onCDPSessionMessage(sessionId, message) {
+        const session = this._sessions.get(sessionId);
+        if (session) {
+            session._acceptMessage(message);
+        }
+    }
+    $onCDPSessionClosed(sessionId) {
+        const session = this._sessions.get(sessionId);
+        if (session) {
+            session._acceptClosed();
+            this._sessions.deleteAndDispose(sessionId);
+        }
+    }
+}
+
+export { ExtHostBrowsers };