@codingame/monaco-vscode-chat-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/languageModelToolsService.js

@@ -1,29 +1,32 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { renderStringAsPlaintext } from 'vscode/vscode/vs/base/browser/markdownRenderer';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { CancellationError, isCancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
 import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localize } from 'vscode/vscode/vs/nls';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ChatToolInvocation } from '../common/chatProgressTypes/chatToolInvocation.js';
 import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
 
 let LanguageModelToolsService = class LanguageModelToolsService extends Disposable {
-    constructor(_extensionService, _contextKeyService, _chatService, _dialogService) {
+    constructor(_extensionService, _contextKeyService, _chatService, _dialogService, _telemetryService) {
         super();
         this._extensionService = _extensionService;
         this._contextKeyService = _contextKeyService;
         this._chatService = _chatService;
         this._dialogService = _dialogService;
-        this._onDidChangeTools = ( (new Emitter()));
+        this._telemetryService = _telemetryService;
+        this._onDidChangeTools = ( new Emitter());
         this.onDidChangeTools = this._onDidChangeTools.event;
-        this._onDidChangeToolsScheduler = ( (new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750)));
-        this._tools = ( (new Map()));
-        this._toolContextKeys = ( (new Set()));
+        this._onDidChangeToolsScheduler = ( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750));
+        this._tools = ( new Map());
+        this._toolContextKeys = ( new Set());
         this._register(this._contextKeyService.onDidChangeContext(e => {
             if (e.affectsSome(this._toolContextKeys)) {
                 this._onDidChangeToolsScheduler.schedule();
@@ -31,8 +34,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }));
     }
     registerToolData(toolData) {
-        if (( (this._tools.has(toolData.id)))) {
-            throw ( (new Error(`Tool "${toolData.id}" is already registered.`)));
+        if (( this._tools.has(toolData.id))) {
+            throw ( new Error(`Tool "${toolData.id}" is already registered.`));
         }
         this._tools.set(toolData.id, { data: toolData });
         this._onDidChangeToolsScheduler.schedule();
@@ -45,17 +48,17 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     }
     _refreshAllToolContextKeys() {
         this._toolContextKeys.clear();
-        for (const tool of ( (this._tools.values()))) {
+        for (const tool of ( this._tools.values())) {
             tool.data.when?.keys().forEach(key => this._toolContextKeys.add(key));
         }
     }
     registerToolImplementation(id, tool) {
         const entry = this._tools.get(id);
         if (!entry) {
-            throw ( (new Error(`Tool "${id}" was not contributed.`)));
+            throw ( new Error(`Tool "${id}" was not contributed.`));
         }
         if (entry.impl) {
-            throw ( (new Error(`Tool "${id}" already has an implementation.`)));
+            throw ( new Error(`Tool "${id}" already has an implementation.`));
         }
         entry.impl = tool;
         return toDisposable(() => {
@@ -63,7 +66,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         });
     }
     getTools() {
-        const toolDatas = ( (Iterable.map( (this._tools.values()), i => i.data)));
+        const toolDatas = ( Iterable.map(( this._tools.values()), i => i.data));
         return Iterable.filter(toolDatas, toolData => !toolData.when || this._contextKeyService.contextMatchesRules(toolData.when));
     }
     getTool(id) {
@@ -89,60 +92,78 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     async invokeTool(dto, countTokens, token) {
         let tool = this._tools.get(dto.toolId);
         if (!tool) {
-            throw ( (new Error(`Tool ${dto.toolId} was not contributed`)));
+            throw ( new Error(`Tool ${dto.toolId} was not contributed`));
         }
         if (!tool.impl) {
             await this._extensionService.activateByEvent(`onLanguageModelTool:${dto.toolId}`);
             tool = this._tools.get(dto.toolId);
             if (!tool?.impl) {
-                throw ( (new Error(`Tool ${dto.toolId} does not have an implementation registered.`)));
+                throw ( new Error(`Tool ${dto.toolId} does not have an implementation registered.`));
             }
         }
         let toolInvocation;
-        if (dto.context) {
-            const model = this._chatService.getSession(dto.context?.sessionId);
-            const request = model.getRequests().at(-1);
-            const prepared = tool.impl.prepareToolInvocation ?
-                await tool.impl.prepareToolInvocation(dto.parameters, token)
-                : undefined;
-            const defaultMessage = ( localize(3215, "Using {0}", `"${tool.data.displayName}"`));
-            const invocationMessage = prepared?.invocationMessage ?? defaultMessage;
-            toolInvocation = ( (new ChatToolInvocation(invocationMessage, prepared?.confirmationMessages)));
-            token.onCancellationRequested(() => {
-                toolInvocation.confirmed.complete(false);
-            });
-            model.acceptResponseProgress(request, toolInvocation);
-            if (prepared?.confirmationMessages) {
-                const userConfirmed = await toolInvocation.confirmed.p;
-                if (!userConfirmed) {
-                    throw ( (new CancellationError()));
+        try {
+            if (dto.context) {
+                const model = this._chatService.getSession(dto.context?.sessionId);
+                const request = model.getRequests().at(-1);
+                const prepared = tool.impl.prepareToolInvocation ?
+                    await tool.impl.prepareToolInvocation(dto.parameters, token)
+                    : undefined;
+                const defaultMessage = ( localize(4575, "Using {0}", `"${tool.data.displayName}"`));
+                const invocationMessage = prepared?.invocationMessage ?? defaultMessage;
+                toolInvocation = ( new ChatToolInvocation(invocationMessage, prepared?.confirmationMessages));
+                token.onCancellationRequested(() => {
+                    toolInvocation.confirmed.complete(false);
+                });
+                model.acceptResponseProgress(request, toolInvocation);
+                if (prepared?.confirmationMessages) {
+                    const userConfirmed = await toolInvocation.confirmed.p;
+                    if (!userConfirmed) {
+                        throw ( new CancellationError());
+                    }
                 }
             }
-        }
-        else {
-            const prepared = tool.impl.prepareToolInvocation ?
-                await tool.impl.prepareToolInvocation(dto.parameters, token)
-                : undefined;
-            if (prepared?.confirmationMessages) {
-                const result = await this._dialogService.confirm({ message: prepared.confirmationMessages.title, detail: renderStringAsPlaintext(prepared.confirmationMessages.message) });
-                if (!result.confirmed) {
-                    throw ( (new CancellationError()));
+            else {
+                const prepared = tool.impl.prepareToolInvocation ?
+                    await tool.impl.prepareToolInvocation(dto.parameters, token)
+                    : undefined;
+                if (prepared?.confirmationMessages) {
+                    const result = await this._dialogService.confirm({ message: prepared.confirmationMessages.title, detail: renderStringAsPlaintext(prepared.confirmationMessages.message) });
+                    if (!result.confirmed) {
+                        throw ( new CancellationError());
+                    }
                 }
             }
+            const result = await tool.impl.invoke(dto, countTokens, token);
+            this._telemetryService.publicLog2('languageModelToolInvoked', {
+                result: 'success',
+                chatSessionId: dto.context?.sessionId,
+                toolId: tool.data.id,
+                toolExtensionId: tool.data.extensionId?.value,
+            });
+            return result;
         }
-        try {
-            return await tool.impl.invoke(dto, countTokens, token);
+        catch (err) {
+            const result = isCancellationError(err) ? 'userCancelled' : 'error';
+            this._telemetryService.publicLog2('languageModelToolInvoked', {
+                result,
+                chatSessionId: dto.context?.sessionId,
+                toolId: tool.data.id,
+                toolExtensionId: tool.data.extensionId?.value,
+            });
+            throw err;
         }
         finally {
             toolInvocation?.isCompleteDeferred.complete();
         }
     }
 };
-LanguageModelToolsService = ( (__decorate([
-    ( (__param(0, IExtensionService))),
-    ( (__param(1, IContextKeyService))),
-    ( (__param(2, IChatService))),
-    ( (__param(3, IDialogService)))
-], LanguageModelToolsService)));
+LanguageModelToolsService = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IChatService)),
+    ( __param(3, IDialogService)),
+    ( __param(4, ITelemetryService))
+], LanguageModelToolsService));
 
 export { LanguageModelToolsService };

package/vscode/src/vs/workbench/contrib/chat/browser/media/chatViewSetup.css.js

@@ -0,0 +1,6 @@
+import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css';
+
+var css = ".chat-welcome-view .chat-setup-view{text-align:center;p{width:100%}.chat-features-container{background-color:var(--vscode-chat-requestBackground);border:1px solid var(--vscode-chat-requestBorder);border-radius:2px;text-align:initial}.chat-feature-container{align-items:center;display:flex;gap:6px;padding:5px 10px}.chat-feature-container .codicon[class*=codicon-]{font-size:16px}.codicon[class*=codicon-]{font-size:13px;line-height:1.4em;vertical-align:bottom}.button-container{padding-top:20px}.monaco-button-dropdown,.monaco-button-dropdown .monaco-text-button{width:100%}p>.monaco-button{display:inline-block;padding:4px 7px;text-align:center;width:100%}}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcomeHandler.d.ts

@@ -0,0 +1,7 @@
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchContribution } from "vscode/vscode/vs/workbench/common/contributions";
+export declare class ChatViewsWelcomeHandler implements IWorkbenchContribution {
+    private readonly logService;
+    static readonly ID = "workbench.contrib.chatViewsWelcomeHandler";
+    constructor(logService: ILogService);
+}

package/vscode/src/vs/workbench/contrib/chat/browser/viewsWelcome/{chatViewsWelcomeContributions.js → chatViewsWelcomeHandler.js}

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { localize } from 'vscode/vscode/vs/nls';
@@ -7,11 +8,12 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { checkProposedApiEnabled } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { ChatViewsWelcomeExtensions } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
 
 const chatViewsWelcomeExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'chatViewsWelcome',
     jsonSchema: {
-        description: ( localize(7675, 'Contributes a welcome message to a chat view')),
+        description: ( localize(4577, 'Contributes a welcome message to a chat view')),
         type: 'array',
         items: {
             additionalProperties: false,
@@ -19,22 +21,22 @@ const chatViewsWelcomeExtensionPoint = ExtensionsRegistry.registerExtensionPoint
             properties: {
                 icon: {
                     type: 'string',
-                    description: ( localize(7676, 'The icon for the welcome message.')),
+                    description: ( localize(4578, 'The icon for the welcome message.')),
                 },
                 title: {
                     type: 'string',
-                    description: ( localize(7677, 'The title of the welcome message.')),
+                    description: ( localize(4579, 'The title of the welcome message.')),
                 },
                 content: {
                     type: 'string',
                     description: ( localize(
-                        7678,
+                        4580,
                         'The content of the welcome message. The first command link will be rendered as a button.'
                     )),
                 },
                 when: {
                     type: 'string',
-                    description: ( localize(7679, 'Condition when the welcome message is shown.')),
+                    description: ( localize(4581, 'Condition when the welcome message is shown.')),
                 }
             }
         },
@@ -58,18 +60,16 @@ let ChatViewsWelcomeHandler = class ChatViewsWelcomeHandler {
                         ...providerDescriptor,
                         when,
                         icon: ThemeIcon.fromString(providerDescriptor.icon),
-                        content: ( (new MarkdownString(providerDescriptor.content, { isTrusted: true }))),
+                        content: ( new MarkdownString(providerDescriptor.content, { isTrusted: true })),
                     };
-                    ( (Registry.as(
-                        "workbench.registry.chat.viewsWelcome"
-                    ))).register(descriptor);
+                    ( Registry.as(ChatViewsWelcomeExtensions.ChatViewsWelcomeRegistry)).register(descriptor);
                 }
             }
         });
     }
 };
-ChatViewsWelcomeHandler = ( (__decorate([
-    ( (__param(0, ILogService)))
-], ChatViewsWelcomeHandler)));
+ChatViewsWelcomeHandler = ( __decorate([
+    ( __param(0, ILogService))
+], ChatViewsWelcomeHandler));
 
 export { ChatViewsWelcomeHandler };

package/vscode/src/vs/workbench/contrib/chat/common/chatCodeMapperService.d.ts

@@ -0,0 +1,44 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { DocumentContextItem, TextEdit } from "vscode/vscode/vs/editor/common/languages";
+import { IChatAgentResult } from "vscode/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { ICodeMapperService } from "vscode/vscode/vs/workbench/contrib/chat/common/chatCodeMapperService.service";
+import { IChatResponseModel } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatContentReference } from "vscode/vscode/vs/workbench/contrib/chat/common/chatService";
+export interface ICodeMapperResponse {
+    textEdit: (resource: URI, textEdit: TextEdit[]) => void;
+}
+export interface ICodeMapperCodeBlock {
+    readonly code: string;
+    readonly resource: URI;
+    readonly markdownBeforeBlock?: string;
+}
+export interface ConversationRequest {
+    readonly type: "request";
+    readonly message: string;
+}
+export interface ConversationResponse {
+    readonly type: "response";
+    readonly message: string;
+    readonly result?: IChatAgentResult;
+    readonly references?: DocumentContextItem[];
+}
+export interface ICodeMapperRequest {
+    readonly codeBlocks: ICodeMapperCodeBlock[];
+    readonly conversation: (ConversationResponse | ConversationRequest)[];
+}
+export interface ICodeMapperResult {
+    readonly errorMessage?: string;
+}
+export interface ICodeMapperProvider {
+    mapCode(request: ICodeMapperRequest, response: ICodeMapperResponse, token: CancellationToken): Promise<ICodeMapperResult | undefined>;
+}
+export declare class CodeMapperService implements ICodeMapperService {
+    _serviceBrand: undefined;
+    private readonly providers;
+    registerCodeMapperProvider(handle: number, provider: ICodeMapperProvider): IDisposable;
+    mapCode(request: ICodeMapperRequest, response: ICodeMapperResponse, token: CancellationToken): Promise<ICodeMapperResult | undefined>;
+    mapCodeFromResponse(responseModel: IChatResponseModel, response: ICodeMapperResponse, token: CancellationToken): Promise<ICodeMapperResult | undefined>;
+}
+export declare function getReferencesAsDocumentContext(res: readonly IChatContentReference[]): DocumentContextItem[];

package/vscode/src/vs/workbench/contrib/chat/common/chatCodeMapperService.js

@@ -1,3 +1,5 @@
+
+import { CharCode } from 'vscode/vscode/vs/base/common/charCode';
 import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
 import { splitLinesIncludeSeparators } from 'vscode/vscode/vs/base/common/strings';
 import { isString } from 'vscode/vscode/vs/base/common/types';
@@ -114,7 +116,7 @@ function iterateLinesOrUris(responseModel) {
 }
 function isLineIncomplete(line) {
     const lastChar = line.charCodeAt(line.length - 1);
-    return lastChar !== 10  && lastChar !== 13 ;
+    return lastChar !== CharCode.LineFeed && lastChar !== CharCode.CarriageReturn;
 }
 function getReferencesAsDocumentContext(res) {
     const map = ( new ResourceMap());

package/vscode/src/vs/workbench/contrib/chat/common/chatProgressTypes/chatToolInvocation.d.ts

@@ -0,0 +1,22 @@
+import { DeferredPromise } from "vscode/vscode/vs/base/common/async";
+import { IMarkdownString } from "vscode/vscode/vs/base/common/htmlContent";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "vscode/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IToolConfirmationMessages } from "vscode/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+export declare class ChatToolInvocation implements IChatToolInvocation {
+    readonly invocationMessage: string | IMarkdownString;
+    private _confirmationMessages;
+    readonly kind: "toolInvocation";
+    private _isComplete;
+    get isComplete(): boolean;
+    private _isCompleteDeferred;
+    get isCompleteDeferred(): DeferredPromise<void>;
+    private _isCanceled;
+    get isCanceled(): boolean | undefined;
+    private _confirmDeferred;
+    get confirmed(): DeferredPromise<boolean>;
+    private _isConfirmed;
+    get isConfirmed(): boolean | undefined;
+    constructor(invocationMessage: string | IMarkdownString, _confirmationMessages: IToolConfirmationMessages | undefined);
+    get confirmationMessages(): IToolConfirmationMessages | undefined;
+    toJSON(): IChatToolInvocationSerialized;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatProgressTypes/chatToolInvocation.js

@@ -1,3 +1,4 @@
+
 import { DeferredPromise } from 'vscode/vscode/vs/base/common/async';
 
 class ChatToolInvocation {

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceImpl.d.ts

@@ -0,0 +1,80 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { ChatAgentLocation } from "vscode/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatAgentService } from "vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
+import { ChatModel, IChatModel, IChatRequestModel, IChatRequestVariableData, IExportableChatData, ISerializableChatData } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IParsedChatRequest } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes";
+import { IChatCompleteResponse, IChatDetail, IChatSendRequestData, IChatSendRequestOptions, IChatTransferredSessionData, IChatUserActionEvent } from "vscode/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatService } from "vscode/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IChatSlashCommandService } from "vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service";
+import { IChatVariablesService } from "vscode/vscode/vs/workbench/contrib/chat/common/chatVariables.service";
+export declare class ChatService extends Disposable implements IChatService {
+    private readonly storageService;
+    private readonly logService;
+    private readonly extensionService;
+    private readonly instantiationService;
+    private readonly telemetryService;
+    private readonly workspaceContextService;
+    private readonly chatSlashCommandService;
+    private readonly chatVariablesService;
+    private readonly chatAgentService;
+    private readonly configurationService;
+    _serviceBrand: undefined;
+    private readonly _sessionModels;
+    private readonly _pendingRequests;
+    private _persistedSessions;
+    private _deletedChatIds;
+    private _transferredSessionData;
+    get transferredSessionData(): IChatTransferredSessionData | undefined;
+    private readonly _onDidPerformUserAction;
+    readonly onDidPerformUserAction: Event<IChatUserActionEvent>;
+    private readonly _onDidDisposeSession;
+    readonly onDidDisposeSession: Event<{
+        sessionId: string;
+        reason: "initializationFailed" | "cleared";
+    }>;
+    private readonly _sessionFollowupCancelTokens;
+    private readonly _chatServiceTelemetry;
+    constructor(storageService: IStorageService, logService: ILogService, extensionService: IExtensionService, instantiationService: IInstantiationService, telemetryService: ITelemetryService, workspaceContextService: IWorkspaceContextService, chatSlashCommandService: IChatSlashCommandService, chatVariablesService: IChatVariablesService, chatAgentService: IChatAgentService, configurationService: IConfigurationService);
+    isEnabled(location: ChatAgentLocation): boolean;
+    private saveState;
+    private syncEmptyWindowChats;
+    notifyUserAction(action: IChatUserActionEvent): void;
+    setChatSessionTitle(sessionId: string, title: string): void;
+    private trace;
+    private error;
+    private deserializeChats;
+    private getTransferredSessionData;
+    getHistory(): IChatDetail[];
+    removeHistoryEntry(sessionId: string): void;
+    clearAllHistoryEntries(): void;
+    startSession(location: ChatAgentLocation, token: CancellationToken): ChatModel;
+    private _startSession;
+    private initializeSession;
+    getSession(sessionId: string): IChatModel | undefined;
+    getOrRestoreSession(sessionId: string): ChatModel | undefined;
+    loadSessionFromContent(data: IExportableChatData | ISerializableChatData): IChatModel | undefined;
+    resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
+    sendRequest(sessionId: string, request: string, options?: IChatSendRequestOptions): Promise<IChatSendRequestData | undefined>;
+    private parseChatRequest;
+    private refreshFollowupsCancellationToken;
+    private _sendRequestAsync;
+    private attachmentKindsForTelemetry;
+    private getHistoryEntriesFromModel;
+    removeRequest(sessionId: string, requestId: string): Promise<void>;
+    adoptRequest(sessionId: string, request: IChatRequestModel): Promise<void>;
+    addCompleteRequest(sessionId: string, message: IParsedChatRequest | string, variableData: IChatRequestVariableData | undefined, attempt: number | undefined, response: IChatCompleteResponse): Promise<void>;
+    cancelCurrentRequestForSession(sessionId: string): void;
+    clearSession(sessionId: string): void;
+    hasSessions(): boolean;
+    transferChatSession(transferredSessionData: IChatTransferredSessionData, toWorkspace: URI): void;
+}