@codingame/monaco-vscode-api 19.1.4 → 20.0.0

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

@@ -1,19 +1,34 @@
 import type * as vscode from "vscode";
 import { CancellationToken } from "../../../base/common/cancellation.js";
-import { Disposable } from "../../../base/common/lifecycle.js";
+import { Disposable, DisposableStore } from "../../../base/common/lifecycle.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
-import { IChatAgentRequest, IChatAgentResult } from "@codingame/monaco-vscode-9ebd6daf-8734-5a28-ad24-b238f5e5819d-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatAgentRequest, IChatAgentResult, IChatAgentResultTimings } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
 import { IChatRelatedFile, IChatRequestDraft } from "../../contrib/chat/common/chatEditingService.js";
 import { IChatFollowup, IChatUserActionEvent, IChatVoteAction } from "../../contrib/chat/common/chatService.js";
 import { ChatAgentLocation } from "../../contrib/chat/common/constants.js";
 import { Dto } from "../../services/extensions/common/proxyIdentifier.js";
-import { ExtHostChatAgentsShape2, IChatAgentCompletionItem, IChatAgentHistoryEntryDto, IMainContext } from "./extHost.protocol.js";
-import { ExtHostCommands } from "./extHostCommands.js";
+import { ExtHostChatAgentsShape2, IChatAgentCompletionItem, IChatAgentHistoryEntryDto, IChatAgentProgressShape, IMainContext } from "./extHost.protocol.js";
+import { CommandsConverter, ExtHostCommands } from "./extHostCommands.js";
 import { ExtHostDiagnostics } from "./extHostDiagnostics.js";
 import { ExtHostDocuments } from "./extHostDocuments.js";
 import { ExtHostLanguageModels } from "./extHostLanguageModels.js";
 import { ExtHostLanguageModelTools } from "./extHostLanguageModelTools.js";
+export declare class ChatAgentResponseStream {
+    private readonly _extension;
+    private readonly _request;
+    private readonly _proxy;
+    private readonly _commandsConverter;
+    private readonly _sessionDisposables;
+    private _stopWatch;
+    private _isClosed;
+    private _firstProgress;
+    private _apiObject;
+    constructor(_extension: IExtensionDescription, _request: IChatAgentRequest, _proxy: IChatAgentProgressShape, _commandsConverter: CommandsConverter, _sessionDisposables: DisposableStore);
+    close(): void;
+    get timings(): IChatAgentResultTimings;
+    get apiObject(): vscode.ChatResponseStream;
+}
 export declare class ExtHostChatAgents2 extends Disposable implements ExtHostChatAgentsShape2 {
     private readonly _logService;
     private readonly _commands;
@@ -31,6 +46,8 @@ export declare class ExtHostChatAgents2 extends Disposable implements ExtHostCha
     private readonly _sessionDisposables;
     private readonly _completionDisposables;
     private readonly _inFlightRequests;
+    private readonly _onDidChangeChatRequestTools;
+    readonly onDidChangeChatRequestTools: import("../../../base/common/event.js").Event<vscode.ChatRequest>;
     private readonly _onDidDisposeChatSession;
     readonly onDidDisposeChatSession: import("../../../base/common/event.js").Event<string>;
     constructor(mainContext: IMainContext, _logService: ILogService, _commands: ExtHostCommands, _documents: ExtHostDocuments, _languageModels: ExtHostLanguageModels, _diagnostics: ExtHostDiagnostics, _tools: ExtHostLanguageModelTools);
@@ -49,6 +66,7 @@ export declare class ExtHostChatAgents2 extends Disposable implements ExtHostCha
     private _createRequest;
     private getModelForRequest;
     $setRequestPaused(handle: number, requestId: string, isPaused: boolean): Promise<void>;
+    $setRequestTools(requestId: string, tools: Pick<IChatAgentRequest, "userSelectedTools">): Promise<void>;
     $invokeAgent(handle: number, requestDto: Dto<IChatAgentRequest>, context: {
         history: IChatAgentHistoryEntryDto[];
     }, token: CancellationToken): Promise<IChatAgentResult | undefined>;

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

@@ -18,7 +18,7 @@ import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatResponseWarningPart, ChatResponseReferencePart, ChatTaskResult, ChatTask, ChatResponseProgressPart, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatPrepareToolInvocationPart as ChatPrepareToolInvocationPart$1, ChatResponsePart, ChatResponseConfirmationPart as ChatResponseConfirmationPart$1, ChatResponseNotebookEditPart as ChatResponseNotebookEditPart$1, ChatResponseTextEditPart as ChatResponseTextEditPart$1, ChatResponseCodeCitationPart as ChatResponseCodeCitationPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseFilesPart, ChatResponseCodeblockUriPart as ChatResponseCodeblockUriPart$1, ChatResponseMarkdownWithVulnerabilitiesPart as ChatResponseMarkdownWithVulnerabilitiesPart$1, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatRequestDraft, ChatAgentRequest, ChatLocation, Selection, Range, ChatAgentResult, ChatLanguageModelToolReference, ChatPromptReference, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, MarkdownString as MarkdownString$1 } from './extHostTypeConverters.js';
-import { MarkdownString, ChatResponseTextEditPart, ChatResponseNotebookEditPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseWarningPart as ChatResponseWarningPart$1, ChatResponseConfirmationPart, ChatResponseCodeCitationPart, ChatResponseMovePart, ChatResponseExtensionsPart, ChatResponseProgressPart2, ChatResponseReferencePart as ChatResponseReferencePart$1, ChatResponseAnchorPart, ChatPrepareToolInvocationPart, ChatResponseCommandButtonPart, ChatResponseFileTreePart, ChatResponseCodeblockUriPart, ChatResponseMarkdownPart, ChatRequestEditorData, ChatRequestNotebookData, LanguageModelError, ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ThemeIcon } from './extHostTypes.js';
+import { MarkdownString, ChatResponseTextEditPart, ChatResponseNotebookEditPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseWarningPart as ChatResponseWarningPart$1, ChatResponseConfirmationPart, ChatResponseCodeCitationPart, ChatResponseMovePart, ChatResponseExtensionsPart, ChatResponsePullRequestPart, ChatResponseProgressPart2, ChatResponseReferencePart as ChatResponseReferencePart$1, ChatResponseAnchorPart, ChatPrepareToolInvocationPart, ChatResponseCommandButtonPart, ChatResponseFileTreePart, ChatResponseCodeblockUriPart, ChatResponseMarkdownPart, ChatRequestEditorData, ChatRequestNotebookData, LanguageModelError, ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ThemeIcon } from './extHostTypes.js';
 
 class ChatAgentResponseStream {
     constructor(_extension, _request, _proxy, _commandsConverter, _sessionDisposables) {
@@ -97,6 +97,11 @@ class ChatAgentResponseStream {
                 }
             };
             this._apiObject = ( Object.freeze({
+                clearToPreviousToolInvocation(reason) {
+                    throwIfDone(this.markdown);
+                    send({ kind: 'clearToPreviousToolInvocation', reason: reason });
+                    return this;
+                },
                 markdown(value) {
                     throwIfDone(this.markdown);
                     const part = new ChatResponseMarkdownPart(value);
@@ -239,6 +244,7 @@ class ChatAgentResponseStream {
                         part instanceof ChatResponseCodeCitationPart ||
                         part instanceof ChatResponseMovePart ||
                         part instanceof ChatResponseExtensionsPart ||
+                        part instanceof ChatResponsePullRequestPart ||
                         part instanceof ChatResponseProgressPart2) {
                         checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
                     }
@@ -300,6 +306,8 @@ class ExtHostChatAgents2 extends Disposable {
         this._sessionDisposables = this._register(( new DisposableMap()));
         this._completionDisposables = this._register(( new DisposableMap()));
         this._inFlightRequests = ( new Set());
+        this._onDidChangeChatRequestTools = this._register(( new Emitter()));
+        this.onDidChangeChatRequestTools = this._onDidChangeChatRequestTools.event;
         this._onDidDisposeChatSession = this._register(( new Emitter()));
         this.onDidDisposeChatSession = this._onDidDisposeChatSession.event;
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatAgents2));
@@ -404,6 +412,17 @@ class ExtHostChatAgents2 extends Disposable {
         }
         agent.setChatRequestPauseState({ request: inFlight.extRequest, isPaused });
     }
+    async $setRequestTools(requestId, tools) {
+        const request = [...this._inFlightRequests].find(r => r.requestId === requestId);
+        if (!request) {
+            return;
+        }
+        request.extRequest.tools.clear();
+        for (const [k, v] of this.getToolsForRequest(request.extension, tools)) {
+            request.extRequest.tools.set(k, v);
+        }
+        this._onDidChangeChatRequestTools.fire(request.extRequest);
+    }
     async $invokeAgent(handle, requestDto, context, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
@@ -429,7 +448,7 @@ class ExtHostChatAgents2 extends Disposable {
             ));
             const model = await this.getModelForRequest(request, agent.extension);
             const extRequest = ChatAgentRequest.to(request, location, model, this.getDiagnosticsWhenEnabled(agent.extension), this.getToolsForRequest(agent.extension, request), agent.extension, this._logService);
-            inFlightRequest = { requestId: requestDto.requestId, extRequest };
+            inFlightRequest = { requestId: requestDto.requestId, extRequest, extension: agent.extension };
             this._inFlightRequests.add(inFlightRequest);
             const task = agent.invoke(extRequest, { history }, stream.apiObject, token);
             return await raceCancellationWithTimeout(1000, Promise.resolve(task).then((result) => {
@@ -440,7 +459,7 @@ class ExtHostChatAgents2 extends Disposable {
                     catch (err) {
                         const msg = `result.metadata MUST be JSON.stringify-able. Got error: ${err.message}`;
                         this._logService.error(`[${agent.extension.identifier.value}] [@${agent.id}] ${msg}`, agent.extension);
-                        return { errorDetails: { message: msg }, timings: stream?.timings, nextQuestion: result.nextQuestion };
+                        return { errorDetails: { message: msg }, timings: stream?.timings, nextQuestion: result.nextQuestion, };
                     }
                 }
                 let errorDetails;
@@ -453,7 +472,7 @@ class ExtHostChatAgents2 extends Disposable {
                 if (errorDetails?.responseIsRedacted || errorDetails?.isQuotaExceeded || errorDetails?.confirmationButtons) {
                     checkProposedApiEnabled(agent.extension, 'chatParticipantPrivate');
                 }
-                return { errorDetails, timings: stream?.timings, metadata: result?.metadata, nextQuestion: result?.nextQuestion };
+                return { errorDetails, timings: stream?.timings, metadata: result?.metadata, nextQuestion: result?.nextQuestion, details: result?.details };
             }), token);
         }
         catch (e) {
@@ -851,4 +870,4 @@ function raceCancellationWithTimeout(cancelWait, promise, token) {
     }));
 }
 
-export { ExtHostChatAgents2 };
+export { ChatAgentResponseStream, ExtHostChatAgents2 };

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

@@ -0,0 +1,14 @@
+import type * as vscode from "vscode";
+import { CancellationToken } from "../../../base/common/cancellation.js";
+import { ExtHostChatOutputRendererShape, IMainContext } from "./extHost.protocol.js";
+import { ExtHostWebviews } from "./extHostWebview.js";
+import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
+import { VSBuffer } from "../../../base/common/buffer.js";
+export declare class ExtHostChatOutputRenderer implements ExtHostChatOutputRendererShape {
+    private readonly webviews;
+    private readonly _proxy;
+    private readonly _renderers;
+    constructor(mainContext: IMainContext, webviews: ExtHostWebviews);
+    registerChatOutputRenderer(extension: IExtensionDescription, viewType: string, renderer: vscode.ChatOutputRenderer): vscode.Disposable;
+    $renderChatOutput(viewType: string, mime: string, valueData: VSBuffer, webviewHandle: string, token: CancellationToken): Promise<void>;
+}

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

@@ -0,0 +1,32 @@
+
+import { MainContext } from './extHost.protocol.js';
+import { Disposable } from './extHostTypes.js';
+
+class ExtHostChatOutputRenderer {
+    constructor(mainContext, webviews) {
+        this.webviews = webviews;
+        this._renderers = ( new Map());
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatOutputRenderer));
+    }
+    registerChatOutputRenderer(extension, viewType, renderer) {
+        if (( this._renderers.has(viewType))) {
+            throw ( new Error(`Chat output renderer already registered for: ${viewType}`));
+        }
+        this._renderers.set(viewType, { extension, renderer });
+        this._proxy.$registerChatOutputRenderer(viewType, extension.identifier, extension.extensionLocation);
+        return ( new Disposable(() => {
+            this._renderers.delete(viewType);
+            this._proxy.$unregisterChatOutputRenderer(viewType);
+        }));
+    }
+    async $renderChatOutput(viewType, mime, valueData, webviewHandle, token) {
+        const entry = this._renderers.get(viewType);
+        if (!entry) {
+            throw ( new Error(`No chat output renderer registered for: ${viewType}`));
+        }
+        const webview = this.webviews.createNewWebview(webviewHandle, {}, entry.extension);
+        return entry.renderer.renderChatOutput(( Object.freeze({ mime, value: valueData.buffer })), webview, {}, token);
+    }
+}
+
+export { ExtHostChatOutputRenderer };

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

@@ -0,0 +1,35 @@
+import type * as vscode from "vscode";
+import { CancellationToken } from "../../../base/common/cancellation.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
+import { ILogService } from "../../../platform/log/common/log.service.js";
+import { IChatAgentRequest, IChatAgentResult } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatSessionItem } from "../../contrib/chat/common/chatSessionsService.js";
+import { ChatSessionDto, ExtHostChatSessionsShape } from "./extHost.protocol.js";
+import { ExtHostCommands } from "./extHostCommands.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
+import { ExtHostLanguageModels } from "./extHostLanguageModels.js";
+export declare class ExtHostChatSessions extends Disposable implements ExtHostChatSessionsShape {
+    private readonly commands;
+    private readonly _languageModels;
+    private readonly _extHostRpc;
+    private readonly _logService;
+    private readonly _proxy;
+    private readonly _chatSessionItemProviders;
+    private readonly _chatSessionContentProviders;
+    private _nextChatSessionItemProviderHandle;
+    private _nextChatSessionContentProviderHandle;
+    private _sessionMap;
+    private static _sessionHandlePool;
+    constructor(commands: ExtHostCommands, _languageModels: ExtHostLanguageModels, _extHostRpc: IExtHostRpcService, _logService: ILogService);
+    registerChatSessionItemProvider(extension: IExtensionDescription, chatSessionType: string, provider: vscode.ChatSessionItemProvider): vscode.Disposable;
+    registerChatSessionContentProvider(extension: IExtensionDescription, chatSessionType: string, provider: vscode.ChatSessionContentProvider): vscode.Disposable;
+    showChatSession(_extension: IExtensionDescription, chatSessionType: string, sessionId: string, options: vscode.ChatSessionShowOptions | undefined): Promise<void>;
+    $provideChatSessionItems(handle: number, token: vscode.CancellationToken): Promise<IChatSessionItem[]>;
+    private readonly _extHostChatSessions;
+    $provideChatSessionContent(handle: number, id: string, token: CancellationToken): Promise<ChatSessionDto>;
+    $interruptChatSessionActiveResponse(providerHandle: number, sessionId: string, requestId: string): Promise<void>;
+    $disposeChatSessionContent(providerHandle: number, sessionId: string): Promise<void>;
+    $invokeChatSessionRequestHandler(handle: number, id: string, request: IChatAgentRequest, history: any[], token: CancellationToken): Promise<IChatAgentResult>;
+    private getModelForRequest;
+}

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

@@ -0,0 +1,222 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from '../../../base/common/arrays.js';
+import { CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { MarshalledId } from '../../../base/common/marshallingIds.js';
+import { ILogService } from '../../../platform/log/common/log.service.js';
+import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
+import { MainContext } from './extHost.protocol.js';
+import { ChatAgentResponseStream } from './extHostChatAgents2.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { ViewColumn, ChatResponsePart, ChatAgentRequest } from './extHostTypeConverters.js';
+import { Disposable as Disposable$1, ChatRequestTurn } from './extHostTypes.js';
+
+var ExtHostChatSessions_1;
+class ExtHostChatSession {
+    constructor(session, extension, request, proxy, commandsConverter, sessionDisposables) {
+        this.session = session;
+        this.extension = extension;
+        this.proxy = proxy;
+        this.commandsConverter = commandsConverter;
+        this.sessionDisposables = sessionDisposables;
+        this._stream = ( new ChatAgentResponseStream(extension, request, proxy, commandsConverter, sessionDisposables));
+    }
+    get activeResponseStream() {
+        return this._stream;
+    }
+    getActiveRequestStream(request) {
+        return ( new ChatAgentResponseStream(
+            this.extension,
+            request,
+            this.proxy,
+            this.commandsConverter,
+            this.sessionDisposables
+        ));
+    }
+}
+let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
+    static { ExtHostChatSessions_1 = this; }
+    static { this._sessionHandlePool = 0; }
+    constructor(commands, _languageModels, _extHostRpc, _logService) {
+        super();
+        this.commands = commands;
+        this._languageModels = _languageModels;
+        this._extHostRpc = _extHostRpc;
+        this._logService = _logService;
+        this._chatSessionItemProviders = ( new Map());
+        this._chatSessionContentProviders = ( new Map());
+        this._nextChatSessionItemProviderHandle = 0;
+        this._nextChatSessionContentProviderHandle = 0;
+        this._sessionMap = ( new Map());
+        this._extHostChatSessions = ( new Map());
+        this._proxy = ( this._extHostRpc.getProxy(MainContext.MainThreadChatSessions));
+        commands.registerArgumentProcessor({
+            processArgument: (arg) => {
+                if (arg && arg.$mid === MarshalledId.ChatSessionContext) {
+                    const id = arg.id;
+                    const sessionContent = this._sessionMap.get(id);
+                    if (sessionContent) {
+                        return sessionContent;
+                    }
+                    else {
+                        this._logService.warn(`No chat session found for ID: ${id}`);
+                        return arg;
+                    }
+                }
+                return arg;
+            }
+        });
+    }
+    registerChatSessionItemProvider(extension, chatSessionType, provider) {
+        const handle = this._nextChatSessionItemProviderHandle++;
+        const disposables = ( new DisposableStore());
+        this._chatSessionItemProviders.set(handle, { provider, extension, disposable: disposables });
+        this._proxy.$registerChatSessionItemProvider(handle, chatSessionType);
+        if (provider.onDidChangeChatSessionItems) {
+            disposables.add(provider.onDidChangeChatSessionItems(() => {
+                this._proxy.$onDidChangeChatSessionItems(chatSessionType);
+            }));
+        }
+        return {
+            dispose: () => {
+                this._chatSessionItemProviders.delete(handle);
+                disposables.dispose();
+                this._proxy.$unregisterChatSessionItemProvider(handle);
+            }
+        };
+    }
+    registerChatSessionContentProvider(extension, chatSessionType, provider) {
+        const handle = this._nextChatSessionContentProviderHandle++;
+        const disposables = ( new DisposableStore());
+        this._chatSessionContentProviders.set(handle, { provider, extension, disposable: disposables });
+        this._proxy.$registerChatSessionContentProvider(handle, chatSessionType);
+        return new Disposable$1(() => {
+            this._chatSessionContentProviders.delete(handle);
+            disposables.dispose();
+            this._proxy.$unregisterChatSessionContentProvider(handle);
+        });
+    }
+    async showChatSession(_extension, chatSessionType, sessionId, options) {
+        await this._proxy.$showChatSession(chatSessionType, sessionId, ViewColumn.from(options?.viewColumn));
+    }
+    async $provideChatSessionItems(handle, token) {
+        const entry = this._chatSessionItemProviders.get(handle);
+        if (!entry) {
+            this._logService.error(`No provider registered for handle ${handle}`);
+            return [];
+        }
+        const sessions = await entry.provider.provideChatSessionItems(token);
+        if (!sessions) {
+            return [];
+        }
+        const response = [];
+        for (const sessionContent of sessions) {
+            if (sessionContent.id) {
+                this._sessionMap.set(sessionContent.id, sessionContent);
+                response.push({
+                    id: sessionContent.id,
+                    label: sessionContent.label,
+                    iconPath: sessionContent.iconPath
+                });
+            }
+        }
+        return response;
+    }
+    async $provideChatSessionContent(handle, id, token) {
+        const provider = this._chatSessionContentProviders.get(handle);
+        if (!provider) {
+            throw ( new Error(`No provider for handle ${handle}`));
+        }
+        const session = await provider.provider.provideChatSessionContent(id, token);
+        const sessionDisposables = ( new DisposableStore());
+        const sessionId = ExtHostChatSessions_1._sessionHandlePool++;
+        const chatSession = ( new ExtHostChatSession(session, provider.extension, {
+            sessionId: `${id}.${sessionId}`,
+            requestId: 'ongoing',
+            agentId: id,
+            message: '',
+            variables: { variables: [] },
+            location: ChatAgentLocation.Panel,
+        }, {
+            $handleProgressChunk: (requestId, chunks) => {
+                return this._proxy.$handleProgressChunk(handle, id, requestId, chunks);
+            },
+            $handleAnchorResolve: (requestId, requestHandle, anchor) => {
+                this._proxy.$handleAnchorResolve(handle, id, requestId, requestHandle, anchor);
+            },
+        }, this.commands.converter, sessionDisposables));
+        const disposeCts = sessionDisposables.add(( new CancellationTokenSource()));
+        this._extHostChatSessions.set(`${handle}_${id}`, { sessionObj: chatSession, disposeCts });
+        if (session.activeResponseCallback) {
+            Promise.resolve(session.activeResponseCallback(chatSession.activeResponseStream.apiObject, disposeCts.token)).finally(() => {
+                this._proxy.$handleProgressComplete(handle, id, 'ongoing');
+            });
+        }
+        return {
+            id: sessionId + '',
+            hasActiveResponseCallback: !!session.activeResponseCallback,
+            hasRequestHandler: !!session.requestHandler,
+            history: ( session.history.map(turn => {
+                if (turn instanceof ChatRequestTurn) {
+                    return { type: 'request', prompt: turn.prompt };
+                }
+                else {
+                    const responseTurn = turn;
+                    const parts = coalesce(( responseTurn.response.map(
+                        r => ChatResponsePart.from(r, this.commands.converter, sessionDisposables)
+                    )));
+                    return {
+                        type: 'response',
+                        parts
+                    };
+                }
+            }))
+        };
+    }
+    async $interruptChatSessionActiveResponse(providerHandle, sessionId, requestId) {
+        const key = `${providerHandle}_${sessionId}`;
+        const entry = this._extHostChatSessions.get(key);
+        entry?.disposeCts.cancel();
+    }
+    async $disposeChatSessionContent(providerHandle, sessionId) {
+        const key = `${providerHandle}_${sessionId}`;
+        const entry = this._extHostChatSessions.get(key);
+        if (!entry) {
+            this._logService.warn(`No chat session found for ID: ${key}`);
+            return;
+        }
+        entry.disposeCts.cancel();
+        entry.sessionObj.sessionDisposables.dispose();
+        this._extHostChatSessions.delete(key);
+    }
+    async $invokeChatSessionRequestHandler(handle, id, request, history, token) {
+        const entry = this._extHostChatSessions.get(`${handle}_${id}`);
+        if (!entry || !entry.sessionObj.session.requestHandler) {
+            return {};
+        }
+        const chatRequest = ChatAgentRequest.to(request, undefined, await this.getModelForRequest(request, entry.sessionObj.extension), [], ( new Map()), entry.sessionObj.extension, this._logService);
+        const stream = entry.sessionObj.getActiveRequestStream(request);
+        await entry.sessionObj.session.requestHandler(chatRequest, { history: history }, stream.apiObject, token);
+        return {};
+    }
+    async getModelForRequest(request, extension) {
+        let model;
+        if (request.userSelectedModelId) {
+            model = await this._languageModels.getLanguageModelByIdentifier(extension, request.userSelectedModelId);
+        }
+        if (!model) {
+            model = await this._languageModels.getDefaultLanguageModel(extension);
+            if (!model) {
+                throw ( new Error('Language model unavailable'));
+            }
+        }
+        return model;
+    }
+};
+ExtHostChatSessions = ExtHostChatSessions_1 = ( __decorate([
+    ( __param(2, IExtHostRpcService)),
+    ( __param(3, ILogService))
+], ExtHostChatSessions));
+
+export { ExtHostChatSessions };

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

@@ -6,7 +6,7 @@ import { ExtHostDocuments } from "./extHostDocuments.js";
 import { IExtensionStoragePaths } from "./extHostStoragePaths.js";
 import { ExtHostWebviews } from "./extHostWebview.js";
 import { ExtHostWebviewPanels } from "./extHostWebviewPanels.js";
-import { EditorGroupColumn } from "@codingame/monaco-vscode-2726569c-a06b-5f25-b851-14311bef12fa-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
+import { EditorGroupColumn } from "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
 import type * as vscode from "vscode";
 import * as extHostProtocol from "./extHost.protocol.js";
 export declare class ExtHostCustomEditors implements extHostProtocol.ExtHostCustomEditorsShape {

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

@@ -0,0 +1,15 @@
+import type * as vscode from "vscode";
+import { ExtHostDataChannelsShape } from "./extHost.protocol.js";
+import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
+export interface IExtHostDataChannels extends ExtHostDataChannelsShape {
+    readonly _serviceBrand: undefined;
+    createDataChannel<T>(extension: IExtensionDescription, channelId: string): vscode.DataChannel<T>;
+}
+export declare const IExtHostDataChannels: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostDataChannels>;
+export declare class ExtHostDataChannels implements IExtHostDataChannels {
+    readonly _serviceBrand: undefined;
+    private readonly _channels;
+    constructor();
+    createDataChannel<T>(extension: IExtensionDescription, channelId: string): vscode.DataChannel<T>;
+    $onDidReceiveData(channelId: string, data: any): void;
+}

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

@@ -0,0 +1,44 @@
+
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+
+const IExtHostDataChannels = ( createDecorator('IExtHostDataChannels'));
+class ExtHostDataChannels {
+    constructor() {
+        this._channels = ( new Map());
+    }
+    createDataChannel(extension, channelId) {
+        checkProposedApiEnabled(extension, 'dataChannels');
+        let channel = this._channels.get(channelId);
+        if (!channel) {
+            channel = ( new DataChannelImpl(channelId));
+            this._channels.set(channelId, channel);
+        }
+        return channel;
+    }
+    $onDidReceiveData(channelId, data) {
+        const channel = this._channels.get(channelId);
+        if (channel) {
+            channel._fireDidReceiveData(data);
+        }
+    }
+}
+class DataChannelImpl extends Disposable {
+    constructor(channelId) {
+        super();
+        this.channelId = channelId;
+        this._onDidReceiveData = ( new Emitter());
+        this.onDidReceiveData = this._onDidReceiveData.event;
+        this._register(this._onDidReceiveData);
+    }
+    _fireDidReceiveData(data) {
+        this._onDidReceiveData.fire({ data });
+    }
+    toString() {
+        return `DataChannel(${this.channelId})`;
+    }
+}
+
+export { ExtHostDataChannels, IExtHostDataChannels };

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

@@ -107,7 +107,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            2595,
+                            2622,
                             "Not showing {0} further errors and warnings.",
                             diagnostics.length - this._maxDiagnosticsPerFile
                         )),

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

@@ -540,7 +540,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     async _doHandleExtensionTests() {
         const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(2596, "Cannot load test runner."))));
+            throw ( new Error(( localize(2623, "Cannot load test runner."))));
         }
         const extensionDescription = (await this.getExtensionPathIndex()).findSubstr(extensionTestsLocationURI);
         const isESM = this._isESM(extensionDescription, extensionTestsLocationURI.path);
@@ -549,7 +549,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
         if (!testRunner || typeof testRunner.run !== 'function') {
             throw ( new Error(( localize(
-                2597,
+                2624,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));

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

@@ -541,7 +541,7 @@ class DocumentPasteEditProvider {
         return (edits.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                2598,
+                2625,
                 "Paste using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
@@ -1105,6 +1105,7 @@ class InlineCompletionAdapter {
                 : undefined,
             triggerKind: this.languageTriggerKindToVSCodeTriggerKind[context.triggerKind],
             requestUuid: context.requestUuid,
+            requestIssuedDateTime: context.requestIssuedDateTime,
         }, token);
         if (!result) {
             return undefined;
@@ -1685,7 +1686,7 @@ class DocumentDropEditAdapter {
         return (editsArray.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                2599,
+                2626,
                 "Drop using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),