@codingame/monaco-vscode-api 17.2.1 → 18.0.0

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

@@ -1,19 +1,44 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { localize } from '../../../nls.js';
 import { Emitter, Event } from '../../../base/common/event.js';
 import { MainContext } from './extHost.protocol.js';
-import { Disposable } from './extHostTypes.js';
+import { Disposable, ProgressLocation } from './extHostTypes.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { INTERNAL_AUTH_PROVIDER_PREFIX } from '../../services/authentication/common/authentication.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
+import { URI } from '../../../base/common/uri.js';
+import { fetchDynamicRegistration, isAuthorizationTokenResponse, getClaimsFromJWT } from '../../../base/common/oauth.js';
+import { IExtHostWindow } from './extHostWindow.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { ILoggerService } from '../../../platform/log/common/log.service.js';
+import '../../../base/common/observableInternal/index.js';
+import { stringHash } from '../../../base/common/hash.js';
+import { DisposableStore } from '../../../base/common/lifecycle.js';
+import { IExtHostUrlsService } from './extHostUrls.js';
+import { encodeBase64, VSBuffer } from '../../../base/common/buffer.js';
+import { equals } from '../../../base/common/arrays.js';
+import { IExtHostProgress } from './extHostProgress.js';
+import { isCancellationError, CancellationError } from '../../../base/common/errors.js';
+import { raceCancellationError } from '../../../base/common/async.js';
+import { observableValue } from '../../../base/common/observableInternal/observables/observableValue.js';
+import { derivedOpts } from '../../../base/common/observableInternal/observables/derived.js';
+import { autorun } from '../../../base/common/observableInternal/reactions/autorun.js';
 
 const IExtHostAuthentication = ( createDecorator('IExtHostAuthentication'));
 let ExtHostAuthentication = class ExtHostAuthentication {
-    constructor(extHostRpc) {
+    constructor(extHostRpc, _initData, _extHostWindow, _extHostUrls, _extHostProgress, _extHostLoggerService) {
+        this._initData = _initData;
+        this._extHostWindow = _extHostWindow;
+        this._extHostUrls = _extHostUrls;
+        this._extHostProgress = _extHostProgress;
+        this._extHostLoggerService = _extHostLoggerService;
+        this._dynamicAuthProviderCtor = DynamicAuthProvider;
         this._authenticationProviders = ( new Map());
         this._onDidChangeSessions = ( new Emitter());
         this._getSessionTaskSingler = ( new TaskSingler());
+        this._onDidDynamicAuthProviderTokensChange = ( new Emitter());
         this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadAuthentication));
     }
     getExtensionScopedSessionsEvent(extensionId) {
@@ -50,7 +75,7 @@ let ExtHostAuthentication = class ExtHostAuthentication {
         }
         this._authenticationProviders.set(id, { label, provider, options: options ?? { supportsMultipleAccounts: false } });
         const listener = provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(id, e));
-        this._proxy.$registerAuthenticationProvider(id, label, options?.supportsMultipleAccounts ?? false);
+        this._proxy.$registerAuthenticationProvider(id, label, options?.supportsMultipleAccounts ?? false, options?.supportedAuthorizationServers);
         return ( new Disposable(() => {
             listener.dispose();
             this._authenticationProviders.delete(id);
@@ -60,6 +85,7 @@ let ExtHostAuthentication = class ExtHostAuthentication {
     async $createSession(providerId, scopes, options) {
         const providerData = this._authenticationProviders.get(providerId);
         if (providerData) {
+            options.authorizationServer = URI.revive(options.authorizationServer);
             return await providerData.provider.createSession(scopes, options);
         }
         throw ( new Error(`Unable to find authentication provider with handle: ${providerId}`));
@@ -74,6 +100,7 @@ let ExtHostAuthentication = class ExtHostAuthentication {
     async $getSessions(providerId, scopes, options) {
         const providerData = this._authenticationProviders.get(providerId);
         if (providerData) {
+            options.authorizationServer = URI.revive(options.authorizationServer);
             return await providerData.provider.getSessions(scopes, options);
         }
         throw ( new Error(`Unable to find authentication provider with handle: ${providerId}`));
@@ -84,9 +111,49 @@ let ExtHostAuthentication = class ExtHostAuthentication {
         }
         return Promise.resolve();
     }
+    $onDidUnregisterAuthenticationProvider(id) {
+        const providerData = this._authenticationProviders.get(id);
+        if (providerData?.disposable) {
+            providerData.disposable.dispose();
+            this._authenticationProviders.delete(id);
+        }
+        return Promise.resolve();
+    }
+    async $registerDynamicAuthProvider(authorizationServerComponents, serverMetadata, resourceMetadata, clientId, initialTokens) {
+        if (!clientId) {
+            if (!serverMetadata.registration_endpoint) {
+                throw ( new Error('Server does not support dynamic registration'));
+            }
+            try {
+                const registration = await fetchDynamicRegistration(serverMetadata.registration_endpoint, this._initData.environment.appName);
+                clientId = registration.client_id;
+            }
+            catch (err) {
+                throw ( new Error(`Dynamic registration failed: ${err.message}`));
+            }
+        }
+        const provider = new this._dynamicAuthProviderCtor(this._extHostWindow, this._extHostUrls, this._initData, this._extHostProgress, this._extHostLoggerService, this._proxy, URI.revive(authorizationServerComponents), serverMetadata, resourceMetadata, clientId, this._onDidDynamicAuthProviderTokensChange, initialTokens || []);
+        const disposable = provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(provider.id, e));
+        this._authenticationProviders.set(provider.id, {
+            label: provider.label,
+            provider,
+            disposable: Disposable.from(provider, disposable),
+            options: { supportsMultipleAccounts: false }
+        });
+        await this._proxy.$registerDynamicAuthenticationProvider(provider.id, provider.label, provider.authorizationServer, provider.clientId);
+        return provider.id;
+    }
+    async $onDidChangeDynamicAuthProviderTokens(authProviderId, clientId, tokens) {
+        this._onDidDynamicAuthProviderTokensChange.fire({ authProviderId, clientId, tokens });
+    }
 };
 ExtHostAuthentication = ( __decorate([
-    ( __param(0, IExtHostRpcService))
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostInitDataService)),
+    ( __param(2, IExtHostWindow)),
+    ( __param(3, IExtHostUrlsService)),
+    ( __param(4, IExtHostProgress)),
+    ( __param(5, ILoggerService))
 ], ExtHostAuthentication));
 class TaskSingler {
     constructor() {
@@ -102,5 +169,428 @@ class TaskSingler {
         return promise;
     }
 }
+let DynamicAuthProvider = class DynamicAuthProvider {
+    constructor(_extHostWindow, _extHostUrls, _initData, _extHostProgress, loggerService, _proxy, authorizationServer, _serverMetadata, _resourceMetadata, clientId, onDidDynamicAuthProviderTokensChange, initialTokens) {
+        this._extHostWindow = _extHostWindow;
+        this._extHostUrls = _extHostUrls;
+        this._initData = _initData;
+        this._extHostProgress = _extHostProgress;
+        this._proxy = _proxy;
+        this.authorizationServer = authorizationServer;
+        this._serverMetadata = _serverMetadata;
+        this._resourceMetadata = _resourceMetadata;
+        this.clientId = clientId;
+        this._onDidChangeSessions = ( new Emitter());
+        this.onDidChangeSessions = this._onDidChangeSessions.event;
+        const stringifiedServer = ( authorizationServer.toString(true));
+        this.id = _resourceMetadata?.resource
+            ? stringifiedServer + ' ' + _resourceMetadata?.resource
+            : stringifiedServer;
+        this.label = _resourceMetadata?.resource_name ?? this.authorizationServer.authority;
+        this._logger = loggerService.createLogger(stringifiedServer, { name: this.label });
+        this._disposable = ( new DisposableStore());
+        this._disposable.add(this._onDidChangeSessions);
+        const scopedEvent = Event.chain(onDidDynamicAuthProviderTokensChange.event, $ => ( $
+            .filter(e => e.authProviderId === this.id && e.clientId === clientId)
+            .map(e => e.tokens)));
+        this._tokenStore = this._disposable.add(( new TokenStore({
+            onDidChange: scopedEvent,
+            set: (tokens) => _proxy.$setSessionsForDynamicAuthProvider(stringifiedServer, this.clientId, tokens),
+        }, initialTokens, this._logger)));
+        this._disposable.add(this._tokenStore.onDidChangeSessions(e => this._onDidChangeSessions.fire(e)));
+        this._createFlows = [{
+                label: ( localize(2574, "URL Handler")),
+                handler: (scopes, progress, token) => this._createWithUrlHandler(scopes, progress, token)
+            }];
+    }
+    async getSessions(scopes, _options) {
+        this._logger.info(`Getting sessions for scopes: ${scopes?.join(' ') ?? 'all'}`);
+        if (!scopes) {
+            return this._tokenStore.sessions;
+        }
+        const sortedScopes = [...scopes].sort();
+        const scopeStr = scopes.join(' ');
+        let sessions = this._tokenStore.sessions.filter(session => equals([...session.scopes].sort(), sortedScopes));
+        this._logger.info(`Found ${sessions.length} sessions for scopes: ${scopeStr}`);
+        if (sessions.length) {
+            const newTokens = [];
+            const removedTokens = [];
+            const tokenMap = ( new Map(( this._tokenStore.tokens.map(token => [token.access_token, token]))));
+            for (const session of sessions) {
+                const token = tokenMap.get(session.accessToken);
+                if (token && token.expires_in) {
+                    const now = Date.now();
+                    const expiresInMS = token.expires_in * 1000;
+                    if (now > token.created_at + expiresInMS - (5 * 60 * 1000)) {
+                        this._logger.info(`Token for session ${session.id} is about to expire, refreshing...`);
+                        removedTokens.push(token);
+                        if (!token.refresh_token) {
+                            this._logger.warn(`No refresh token available for scopes ${session.scopes.join(' ')}. Throwing away token.`);
+                            continue;
+                        }
+                        try {
+                            const newToken = await this.exchangeRefreshTokenForToken(token.refresh_token);
+                            if (newToken.scope !== scopeStr) {
+                                this._logger.warn(`Token scopes '${newToken.scope}' do not match requested scopes '${scopeStr}'. Overwriting token with what was requested...`);
+                                newToken.scope = scopeStr;
+                            }
+                            this._logger.info(`Successfully created a new token for scopes ${session.scopes.join(' ')}.`);
+                            newTokens.push(newToken);
+                        }
+                        catch (err) {
+                            this._logger.error(`Failed to refresh token: ${err}`);
+                        }
+                    }
+                }
+            }
+            if (newTokens.length || removedTokens.length) {
+                this._tokenStore.update({ added: newTokens, removed: removedTokens });
+                sessions = this._tokenStore.sessions.filter(session => equals([...session.scopes].sort(), sortedScopes));
+            }
+            this._logger.info(`Found ${sessions.length} sessions for scopes: ${scopeStr}`);
+            return sessions;
+        }
+        return [];
+    }
+    async createSession(scopes, _options) {
+        this._logger.info(`Creating session for scopes: ${scopes.join(' ')}`);
+        let token;
+        for (let i = 0; i < this._createFlows.length; i++) {
+            const { handler } = this._createFlows[i];
+            try {
+                token = await this._extHostProgress.withProgressFromSource({ label: this.label, id: this.id }, {
+                    location: ProgressLocation.Notification,
+                    title: ( localize(2575, "Authenticating to '{0}'", this.label)),
+                    cancellable: true
+                }, (progress, token) => handler(scopes, progress, token));
+                if (token) {
+                    break;
+                }
+            }
+            catch (err) {
+                const nextMode = this._createFlows[i + 1]?.label;
+                if (!nextMode) {
+                    break;
+                }
+                const message = isCancellationError(err)
+                    ? ( localize(
+                    2576,
+                    "Having trouble authenticating to '{0}'? Would you like to try a different way? ({1})",
+                    this.label,
+                    nextMode
+                ))
+                    : ( localize(
+                    2577,
+                    "You have not yet finished authenticating to '{0}'. Would you like to try a different way? ({1})",
+                    this.label,
+                    nextMode
+                ));
+                const result = await this._proxy.$showContinueNotification(message);
+                if (!result) {
+                    throw ( new CancellationError());
+                }
+                this._logger.error(`Failed to create token via flow '${nextMode}': ${err}`);
+            }
+        }
+        if (!token) {
+            throw ( new Error('Failed to create authentication token'));
+        }
+        if (token.scope !== scopes.join(' ')) {
+            this._logger.warn(`Token scopes '${token.scope}' do not match requested scopes '${scopes.join(' ')}'. Overwriting token with what was requested...`);
+            token.scope = scopes.join(' ');
+        }
+        this._tokenStore.update({ added: [{ ...token, created_at: Date.now() }], removed: [] });
+        const session = this._tokenStore.sessions.find(t => t.accessToken === token.access_token);
+        this._logger.info(`Created session for scopes: ${token.scope}`);
+        return session;
+    }
+    async removeSession(sessionId) {
+        this._logger.info(`Removing session with id: ${sessionId}`);
+        const session = this._tokenStore.sessions.find(session => session.id === sessionId);
+        if (!session) {
+            this._logger.error(`Session with id ${sessionId} not found`);
+            return;
+        }
+        const token = this._tokenStore.tokens.find(token => token.access_token === session.accessToken);
+        if (!token) {
+            this._logger.error(`Failed to retrieve token for removed session: ${session.id}`);
+            return;
+        }
+        this._tokenStore.update({ added: [], removed: [token] });
+        this._logger.info(`Removed token for session: ${session.id} with scopes: ${session.scopes.join(' ')}`);
+    }
+    dispose() {
+        this._disposable.dispose();
+    }
+    async _createWithUrlHandler(scopes, progress, token) {
+        const codeVerifier = this.generateRandomString(64);
+        const codeChallenge = await this.generateCodeChallenge(codeVerifier);
+        const nonce = this.generateRandomString(32);
+        const callbackUri = ( URI.parse(
+            `${this._initData.environment.appUriScheme}://dynamicauthprovider/${this.authorizationServer.authority}/authorize?nonce=${nonce}`
+        ));
+        let state;
+        try {
+            state = await this._extHostUrls.createAppUri(callbackUri);
+        }
+        catch (error) {
+            throw ( new Error(`Failed to create external URI: ${error}`));
+        }
+        const authorizationUrl = ( new URL(this._serverMetadata.authorization_endpoint));
+        authorizationUrl.searchParams.append('client_id', this.clientId);
+        authorizationUrl.searchParams.append('response_type', 'code');
+        authorizationUrl.searchParams.append('state', ( state.toString()));
+        authorizationUrl.searchParams.append('code_challenge', codeChallenge);
+        authorizationUrl.searchParams.append('code_challenge_method', 'S256');
+        const scopeString = scopes.join(' ');
+        if (scopeString) {
+            authorizationUrl.searchParams.append('scope', scopeString);
+        }
+        if (this._resourceMetadata?.resource) {
+            authorizationUrl.searchParams.append('resource', this._resourceMetadata.resource);
+        }
+        const redirectUri = 'https://vscode.dev/redirect';
+        authorizationUrl.searchParams.append('redirect_uri', redirectUri);
+        const promise = this.waitForAuthorizationCode(callbackUri);
+        this._logger.info(`Opening authorization URL for scopes: ${scopeString}`);
+        this._logger.trace(`Authorization URL: ${( authorizationUrl.toString())}`);
+        const opened = await this._extHostWindow.openUri(( authorizationUrl.toString()), {});
+        if (!opened) {
+            throw ( new CancellationError());
+        }
+        progress.report({
+            message: ( localize(2578, "Complete the authentication in the browser window that has opened.")),
+        });
+        let code;
+        try {
+            const response = await raceCancellationError(promise, token);
+            code = response.code;
+        }
+        catch (err) {
+            if (isCancellationError(err)) {
+                this._logger.info('Authorization code request was cancelled by the user.');
+                throw err;
+            }
+            this._logger.error(`Failed to receive authorization code: ${err}`);
+            throw ( new Error(`Failed to receive authorization code: ${err}`));
+        }
+        this._logger.info(`Authorization code received for scopes: ${scopeString}`);
+        const tokenResponse = await this.exchangeCodeForToken(code, codeVerifier, redirectUri);
+        return tokenResponse;
+    }
+    generateRandomString(length) {
+        const array = ( new Uint8Array(length));
+        crypto.getRandomValues(array);
+        return ( Array.from(array)
+            .map(b => ( b.toString(16)).padStart(2, '0')))
+            .join('')
+            .substring(0, length);
+    }
+    async generateCodeChallenge(codeVerifier) {
+        const encoder = ( new TextEncoder());
+        const data = encoder.encode(codeVerifier);
+        const digest = await crypto.subtle.digest('SHA-256', data);
+        return encodeBase64(VSBuffer.wrap(( new Uint8Array(digest))), false, false)
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+    async waitForAuthorizationCode(expectedState) {
+        const result = await this._proxy.$waitForUriHandler(expectedState);
+        const codeMatch = /[?&]code=([^&]+)/.exec(result.query || '');
+        if (!codeMatch || codeMatch.length < 2) {
+            throw ( new Error('Authentication failed: No authorization code received'));
+        }
+        return { code: codeMatch[1] };
+    }
+    async exchangeCodeForToken(code, codeVerifier, redirectUri) {
+        if (!this._serverMetadata.token_endpoint) {
+            throw ( new Error('Token endpoint not available in server metadata'));
+        }
+        const tokenRequest = ( new URLSearchParams());
+        tokenRequest.append('client_id', this.clientId);
+        tokenRequest.append('grant_type', 'authorization_code');
+        tokenRequest.append('code', code);
+        tokenRequest.append('redirect_uri', redirectUri);
+        tokenRequest.append('code_verifier', codeVerifier);
+        const response = await fetch(this._serverMetadata.token_endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json'
+            },
+            body: ( tokenRequest.toString())
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw ( new Error(
+                `Token exchange failed: ${response.status} ${response.statusText} - ${text}`
+            ));
+        }
+        const result = await response.json();
+        if (isAuthorizationTokenResponse(result)) {
+            return result;
+        }
+        throw ( new Error(`Invalid authorization token response: ${JSON.stringify(result)}`));
+    }
+    async exchangeRefreshTokenForToken(refreshToken) {
+        if (!this._serverMetadata.token_endpoint) {
+            throw ( new Error('Token endpoint not available in server metadata'));
+        }
+        const tokenRequest = ( new URLSearchParams());
+        tokenRequest.append('client_id', this.clientId);
+        tokenRequest.append('grant_type', 'refresh_token');
+        tokenRequest.append('refresh_token', refreshToken);
+        const response = await fetch(this._serverMetadata.token_endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json'
+            },
+            body: ( tokenRequest.toString())
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw ( new Error(
+                `Token exchange failed: ${response.status} ${response.statusText} - ${text}`
+            ));
+        }
+        const result = await response.json();
+        if (isAuthorizationTokenResponse(result)) {
+            return {
+                ...result,
+                created_at: Date.now(),
+            };
+        }
+        throw ( new Error(`Invalid authorization token response: ${JSON.stringify(result)}`));
+    }
+};
+DynamicAuthProvider = ( __decorate([
+    ( __param(0, IExtHostWindow)),
+    ( __param(1, IExtHostUrlsService)),
+    ( __param(2, IExtHostInitDataService)),
+    ( __param(3, IExtHostProgress)),
+    ( __param(4, ILoggerService))
+], DynamicAuthProvider));
+class TokenStore {
+    constructor(_persistence, initialTokens, _logger) {
+        this._persistence = _persistence;
+        this._logger = _logger;
+        this._onDidChangeSessions = ( new Emitter());
+        this.onDidChangeSessions = this._onDidChangeSessions.event;
+        this._disposable = ( new DisposableStore());
+        this._tokensObservable = observableValue('tokens', initialTokens);
+        this._sessionsObservable = derivedOpts({ equalsFn: (a, b) => equals(a, b, (a, b) => a.accessToken === b.accessToken) }, (reader) => ( this._tokensObservable.read(reader).map(t => this._getSessionFromToken(t))));
+        this._disposable.add(this._registerChangeEventAutorun());
+        this._disposable.add(this._persistence.onDidChange((tokens) => this._tokensObservable.set(tokens, undefined)));
+    }
+    get tokens() {
+        return this._tokensObservable.get();
+    }
+    get sessions() {
+        return this._sessionsObservable.get();
+    }
+    dispose() {
+        this._disposable.dispose();
+    }
+    update({ added, removed }) {
+        this._logger.trace(`Updating tokens: added ${added.length}, removed ${removed.length}`);
+        const currentTokens = [...this._tokensObservable.get()];
+        for (const token of removed) {
+            const index = currentTokens.findIndex(t => t.access_token === token.access_token);
+            if (index !== -1) {
+                currentTokens.splice(index, 1);
+            }
+        }
+        for (const token of added) {
+            const index = currentTokens.findIndex(t => t.access_token === token.access_token);
+            if (index === -1) {
+                currentTokens.push(token);
+            }
+            else {
+                currentTokens[index] = token;
+            }
+        }
+        if (added.length || removed.length) {
+            this._tokensObservable.set(currentTokens, undefined);
+            void this._persistence.set(currentTokens);
+        }
+        this._logger.trace(`Tokens updated: ${currentTokens.length} tokens stored.`);
+    }
+    _registerChangeEventAutorun() {
+        let previousSessions = [];
+        return autorun((reader) => {
+            this._logger.trace('Checking for session changes...');
+            const currentSessions = this._sessionsObservable.read(reader);
+            if (previousSessions === currentSessions) {
+                this._logger.trace('No session changes detected.');
+                return;
+            }
+            if (!currentSessions || currentSessions.length === 0) {
+                this._logger.trace('All sessions removed.');
+                if (previousSessions.length > 0) {
+                    this._onDidChangeSessions.fire({
+                        added: [],
+                        removed: previousSessions,
+                        changed: []
+                    });
+                    previousSessions = [];
+                }
+                return;
+            }
+            const added = [];
+            const removed = [];
+            for (const current of currentSessions) {
+                const exists = ( previousSessions.some(prev => prev.accessToken === current.accessToken));
+                if (!exists) {
+                    added.push(current);
+                }
+            }
+            for (const prev of previousSessions) {
+                const exists = ( currentSessions.some(current => current.accessToken === prev.accessToken));
+                if (!exists) {
+                    removed.push(prev);
+                }
+            }
+            if (added.length > 0 || removed.length > 0) {
+                this._logger.trace(`Sessions changed: added ${added.length}, removed ${removed.length}`);
+                this._onDidChangeSessions.fire({ added, removed, changed: [] });
+            }
+            previousSessions = currentSessions;
+        });
+    }
+    _getSessionFromToken(token) {
+        let claims;
+        if (token.id_token) {
+            try {
+                claims = getClaimsFromJWT(token.id_token);
+            }
+            catch (e) {
+            }
+        }
+        if (!claims) {
+            try {
+                claims = getClaimsFromJWT(token.access_token);
+            }
+            catch (e) {
+            }
+        }
+        const scopes = token.scope
+            ? token.scope.split(' ')
+            : claims?.scope
+                ? claims.scope.split(' ')
+                : [];
+        return {
+            id: ( stringHash(token.access_token, 0).toString()),
+            accessToken: token.access_token,
+            account: {
+                id: claims?.sub || 'unknown',
+                label: claims?.preferred_username || claims?.name || claims?.email || 'MCP',
+            },
+            scopes: scopes,
+            idToken: token.id_token
+        };
+    }
+}
 
-export { ExtHostAuthentication, IExtHostAuthentication };
+export { DynamicAuthProvider, ExtHostAuthentication, IExtHostAuthentication };

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

@@ -53,7 +53,6 @@ export declare class ExtHostChatAgents2 extends Disposable implements ExtHostCha
         history: IChatAgentHistoryEntryDto[];
     }, token: CancellationToken): Promise<IChatAgentResult | undefined>;
     private getDiagnosticsWhenEnabled;
-    private getTools2ForRequest;
     private getToolsForRequest;
     private prepareHistoryTurns;
     $releaseSession(sessionId: string): void;
@@ -64,5 +63,4 @@ export declare class ExtHostChatAgents2 extends Disposable implements ExtHostCha
     $acceptAction(handle: number, result: IChatAgentResult, event: IChatUserActionEvent): void;
     $invokeCompletionProvider(handle: number, query: string, token: CancellationToken): Promise<IChatAgentCompletionItem[]>;
     $provideChatTitle(handle: number, context: IChatAgentHistoryEntryDto[], token: CancellationToken): Promise<string | undefined>;
-    $provideSampleQuestions(handle: number, location: ChatAgentLocation, token: CancellationToken): Promise<IChatFollowup[] | undefined>;
 }