@codingame/monaco-vscode-api 28.4.1 → 29.0.0

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

@@ -377,6 +377,7 @@ class ChatAgentResponseStream {
                         kind: "usage",
                         promptTokens: usage.promptTokens,
                         completionTokens: usage.completionTokens,
+                        outputBuffer: usage.outputBuffer,
                         promptTokenDetails: usage.promptTokenDetails
                     };
                     _report(dto);
@@ -578,6 +579,7 @@ class ExtHostChatAgents2 extends Disposable {
             request,
             location,
             model,
+            request.modelConfiguration,
             this.getDiagnosticsWhenEnabled(detector.extension),
             tools,
             detector.extension,
@@ -685,6 +687,7 @@ class ExtHostChatAgents2 extends Disposable {
                 request,
                 location,
                 model,
+                request.modelConfiguration,
                 this.getDiagnosticsWhenEnabled(agent.extension),
                 tools,
                 agent.extension,
@@ -784,7 +787,7 @@ class ExtHostChatAgents2 extends Disposable {
         }
     }
     getDiagnosticsWhenEnabled(extension) {
-        if (!isProposedApiEnabled(extension, "chatReferenceDiagnostic")) {
+        if (!isProposedApiEnabled(extension)) {
             return [];
         }
         return this._diagnostics.getDiagnostics();
@@ -823,7 +826,7 @@ class ExtHostChatAgents2 extends Disposable {
                     }
                 }
             }
-            const editedFileEvents = isProposedApiEnabled(extension, "chatParticipantPrivate") ? h.request.editedFileEvents : undefined;
+            const editedFileEvents = isProposedApiEnabled(extension) ? h.request.editedFileEvents : undefined;
             const turn = new ChatRequestTurn(
                 h.request.message,
                 h.request.command,
@@ -896,7 +899,7 @@ class ExtHostChatAgents2 extends Disposable {
         const feedback = {
             result: ehResult,
             kind,
-            unhelpfulReason: isProposedApiEnabled(agent.extension, "chatParticipantAdditions") ? voteAction.reason : undefined
+            unhelpfulReason: isProposedApiEnabled(agent.extension) ? voteAction.reason : undefined
         };
         agent.acceptFeedback(( Object.freeze(feedback)));
     }
@@ -952,8 +955,10 @@ class ExtHostChatAgents2 extends Disposable {
         const history = await this.prepareHistoryTurns(agent.extension, agent.id, {
             history: context
         });
+        const sessionResource = context[0]?.request.sessionResource ? URI.revive(context[0].request.sessionResource) : undefined;
         return await agent.provideTitle({
             history,
+            sessionResource,
             yieldRequested: false
         }, token);
     }
@@ -965,8 +970,10 @@ class ExtHostChatAgents2 extends Disposable {
         const history = await this.prepareHistoryTurns(agent.extension, agent.id, {
             history: context
         });
+        const sessionResource = context[0]?.request.sessionResource ? URI.revive(context[0].request.sessionResource) : undefined;
         return await agent.provideSummary({
             history,
+            sessionResource,
             yieldRequested: false
         }, token);
     }
@@ -1154,7 +1161,7 @@ class ExtHostChatAgent {
                 checkProposedApiEnabled(that.extension, "chatParticipantAdditions");
                 return that._pauseStateEmitter.event;
             },
-            onDidPerformAction: !isProposedApiEnabled(this.extension, "chatParticipantAdditions") ? undefined : this._onDidPerformAction.event,
+            onDidPerformAction: !isProposedApiEnabled(this.extension) ? undefined : this._onDidPerformAction.event,
             dispose() {
                 disposed = true;
                 that._followupProvider = undefined;

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

@@ -1,4 +1,5 @@
 import type * as vscode from "vscode";
+import { VSBuffer } from "../../../base/common/buffer.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
 import { UriComponents } from "../../../base/common/uri.js";
@@ -11,6 +12,8 @@ export declare class ExtHostChatDebug extends Disposable implements ExtHostChatD
     private _nextHandle;
     /** Progress pipelines keyed by `${handle}:${sessionResource}` so multiple sessions can stream concurrently. */
     private readonly _activeProgress;
+    private readonly _onDidAddCoreEvent;
+    readonly onDidAddCoreEvent: import("../../../base/common/event.js").Event<vscode.ChatDebugEvent>;
     constructor(extHostRpc: IExtHostRpcService);
     private _progressKey;
     private _cleanupProgress;
@@ -18,5 +21,12 @@ export declare class ExtHostChatDebug extends Disposable implements ExtHostChatD
     $provideChatDebugLog(handle: number, sessionResource: UriComponents, token: CancellationToken): Promise<IChatDebugEventDto[] | undefined>;
     private _serializeEvent;
     $resolveChatDebugLogEvent(_handle: number, eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContentDto | undefined>;
+    private _deserializeEvent;
+    $onCoreDebugEvent(dto: IChatDebugEventDto): void;
+    $exportChatDebugLog(_handle: number, sessionResource: UriComponents, coreEventDtos: IChatDebugEventDto[], sessionTitle: string | undefined, token: CancellationToken): Promise<VSBuffer | undefined>;
+    $importChatDebugLog(_handle: number, data: VSBuffer, token: CancellationToken): Promise<{
+        uri: UriComponents;
+        sessionTitle?: string;
+    } | undefined>;
     dispose(): void;
 }

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

@@ -1,10 +1,11 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from '../../../base/common/buffer.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { URI } from '../../../base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
-import { ChatDebugSubagentStatus, ChatDebugToolCallResult, ChatDebugMessageContentType } from './extHostTypes.js';
+import { ChatDebugSubagentStatus, ChatDebugToolCallResult, ChatDebugHookResult, ChatDebugMessageContentType, ChatDebugAgentResponseEvent, ChatDebugMessageSection, ChatDebugUserMessageEvent, ChatDebugSubagentInvocationEvent, ChatDebugGenericEvent, ChatDebugModelTurnEvent, ChatDebugToolCallEvent } from './extHostTypes.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 
 let ExtHostChatDebug = class ExtHostChatDebug extends Disposable {
@@ -12,6 +13,11 @@ let ExtHostChatDebug = class ExtHostChatDebug extends Disposable {
         super();
         this._nextHandle = 0;
         this._activeProgress = ( new Map());
+        this._onDidAddCoreEvent = this._register(( new Emitter({
+            onWillAddFirstListener: () => this._proxy.$subscribeToCoreDebugEvents(),
+            onDidRemoveLastListener: () => this._proxy.$unsubscribeFromCoreDebugEvents()
+        })));
+        this.onDidAddCoreEvent = this._onDidAddCoreEvent.event;
         this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadChatDebug));
     }
     _progressKey(handle, sessionResource) {
@@ -270,10 +276,135 @@ let ExtHostChatDebug = class ExtHostChatDebug extends Disposable {
                     }))
                 };
             }
+        case "hookContent":
+            {
+                const hk = result;
+                return {
+                    kind: "hook",
+                    hookType: hk.hookType,
+                    command: hk.command,
+                    result: hk.result === ChatDebugHookResult.Success ? "success" : hk.result === ChatDebugHookResult.Error ? "error" : hk.result === ChatDebugHookResult.NonBlockingError ? "nonBlockingError" : undefined,
+                    durationInMillis: hk.durationInMillis,
+                    input: hk.input,
+                    output: hk.output,
+                    exitCode: hk.exitCode,
+                    errorMessage: hk.errorMessage
+                };
+            }
+        default:
+            return undefined;
+        }
+    }
+    _deserializeEvent(dto) {
+        const created = ( new Date(dto.created));
+        const sessionResource = dto.sessionResource ? URI.revive(dto.sessionResource) : undefined;
+        switch (dto.kind) {
+        case "toolCall":
+            {
+                const evt = ( new ChatDebugToolCallEvent(dto.toolName, created));
+                evt.id = dto.id;
+                evt.sessionResource = sessionResource;
+                evt.parentEventId = dto.parentEventId;
+                evt.toolCallId = dto.toolCallId;
+                evt.input = dto.input;
+                evt.output = dto.output;
+                evt.result = dto.result === "success" ? ChatDebugToolCallResult.Success : dto.result === "error" ? ChatDebugToolCallResult.Error : undefined;
+                evt.durationInMillis = dto.durationInMillis;
+                return evt;
+            }
+        case "modelTurn":
+            {
+                const evt = ( new ChatDebugModelTurnEvent(created));
+                evt.id = dto.id;
+                evt.sessionResource = sessionResource;
+                evt.parentEventId = dto.parentEventId;
+                evt.model = dto.model;
+                evt.inputTokens = dto.inputTokens;
+                evt.outputTokens = dto.outputTokens;
+                evt.totalTokens = dto.totalTokens;
+                evt.durationInMillis = dto.durationInMillis;
+                return evt;
+            }
+        case "generic":
+            {
+                const evt = ( new ChatDebugGenericEvent(dto.name, dto.level, created));
+                evt.id = dto.id;
+                evt.sessionResource = sessionResource;
+                evt.parentEventId = dto.parentEventId;
+                evt.details = dto.details;
+                evt.category = dto.category;
+                return evt;
+            }
+        case "subagentInvocation":
+            {
+                const evt = ( new ChatDebugSubagentInvocationEvent(dto.agentName, created));
+                evt.id = dto.id;
+                evt.sessionResource = sessionResource;
+                evt.parentEventId = dto.parentEventId;
+                evt.description = dto.description;
+                evt.status = dto.status === "running" ? ChatDebugSubagentStatus.Running : dto.status === "completed" ? ChatDebugSubagentStatus.Completed : dto.status === "failed" ? ChatDebugSubagentStatus.Failed : undefined;
+                evt.durationInMillis = dto.durationInMillis;
+                evt.toolCallCount = dto.toolCallCount;
+                evt.modelTurnCount = dto.modelTurnCount;
+                return evt;
+            }
+        case "userMessage":
+            {
+                const evt = ( new ChatDebugUserMessageEvent(dto.message, created));
+                evt.id = dto.id;
+                evt.sessionResource = sessionResource;
+                evt.parentEventId = dto.parentEventId;
+                evt.sections = ( dto.sections.map(s => ( new ChatDebugMessageSection(s.name, s.content))));
+                return evt;
+            }
+        case "agentResponse":
+            {
+                const evt = ( new ChatDebugAgentResponseEvent(dto.message, created));
+                evt.id = dto.id;
+                evt.sessionResource = sessionResource;
+                evt.parentEventId = dto.parentEventId;
+                evt.sections = ( dto.sections.map(s => ( new ChatDebugMessageSection(s.name, s.content))));
+                return evt;
+            }
         default:
             return undefined;
         }
     }
+    $onCoreDebugEvent(dto) {
+        const event = this._deserializeEvent(dto);
+        if (event) {
+            this._onDidAddCoreEvent.fire(event);
+        }
+    }
+    async $exportChatDebugLog(_handle, sessionResource, coreEventDtos, sessionTitle, token) {
+        if (!this._provider?.provideChatDebugLogExport) {
+            return undefined;
+        }
+        const sessionUri = URI.revive(sessionResource);
+        const coreEvents = ( coreEventDtos.map(dto => this._deserializeEvent(dto))).filter(e => e !== undefined);
+        const options = {
+            coreEvents,
+            sessionTitle
+        };
+        const result = await this._provider.provideChatDebugLogExport(sessionUri, options, token);
+        if (!result) {
+            return undefined;
+        }
+        return VSBuffer.wrap(result);
+    }
+    async $importChatDebugLog(_handle, data, token) {
+        if (!this._provider?.resolveChatDebugLogImport) {
+            return undefined;
+        }
+        const result = await this._provider.resolveChatDebugLogImport(data.buffer, token);
+        if (!result) {
+            return undefined;
+        }
+        return {
+            uri: result.uri,
+            sessionTitle: result.sessionTitle
+        };
+    }
     dispose() {
         for (const store of ( this._activeProgress.values())) {
             store.dispose();

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

@@ -6,7 +6,7 @@ import { IExtensionDescription } from "../../../platform/extensions/common/exten
 import { ILogService } from "../../../platform/log/common/log.service.js";
 import { IChatSessionProviderOptionItem } from "../../contrib/chat/common/chatSessionsService.js";
 import { IChatAgentRequest, IChatAgentResult } from "../../contrib/chat/common/participants/chatAgents.js";
-import { ChatSessionDto, ExtHostChatSessionsShape, IChatSessionProviderOptions } from "./extHost.protocol.js";
+import { ChatSessionContentContextDto, IChatSessionDto, ExtHostChatSessionsShape, IChatSessionRequestHistoryItemDto, IChatSessionProviderOptions, IChatNewSessionRequestDto } from "./extHost.protocol.js";
 import { ExtHostCommands } from "./extHostCommands.js";
 import { ExtHostLanguageModels } from "./extHostLanguageModels.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
@@ -16,7 +16,6 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
     private readonly _languageModels;
     private readonly _extHostRpc;
     private readonly _logService;
-    private static _sessionHandlePool;
     private readonly _proxy;
     private _itemControllerHandlePool;
     private readonly _chatSessionItemControllers;
@@ -34,21 +33,21 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
     registerChatSessionItemProvider(extension: IExtensionDescription, chatSessionType: string, provider: vscode.ChatSessionItemProvider): vscode.Disposable;
     createChatSessionItemController(extension: IExtensionDescription, id: string, refreshHandler: (token: vscode.CancellationToken) => Thenable<void>): vscode.ChatSessionItemController;
     registerChatSessionContentProvider(extension: IExtensionDescription, chatSessionScheme: string, chatParticipant: vscode.ChatParticipant, provider: vscode.ChatSessionContentProvider, capabilities?: vscode.ChatSessionCapabilities): vscode.Disposable;
-    $provideChatSessionContent(handle: number, sessionResourceComponents: UriComponents, token: CancellationToken): Promise<ChatSessionDto>;
-    $provideHandleOptionsChange(handle: number, sessionResourceComponents: UriComponents, updates: ReadonlyArray<{
-        optionId: string;
-        value: string | IChatSessionProviderOptionItem | undefined;
-    }>, token: CancellationToken): Promise<void>;
+    $provideChatSessionContent(handle: number, sessionResourceComponents: UriComponents, context: ChatSessionContentContextDto, token: CancellationToken): Promise<IChatSessionDto>;
+    $provideHandleOptionsChange(handle: number, sessionResourceComponents: UriComponents, updates: Record<string, string | IChatSessionProviderOptionItem | undefined>, token: CancellationToken): Promise<void>;
     $provideChatSessionProviderOptions(handle: number, token: CancellationToken): Promise<IChatSessionProviderOptions | undefined>;
     $interruptChatSessionActiveResponse(providerHandle: number, sessionResource: UriComponents, requestId: string): Promise<void>;
     $disposeChatSessionContent(providerHandle: number, sessionResource: UriComponents): Promise<void>;
     $invokeChatSessionRequestHandler(handle: number, sessionResource: UriComponents, request: IChatAgentRequest, history: any[], token: CancellationToken): Promise<IChatAgentResult>;
+    $forkChatSession(handle: number, sessionResourceComponents: UriComponents, request: IChatSessionRequestHistoryItemDto | undefined, token: CancellationToken): Promise<ReturnType<typeof typeConvert.ChatSessionItem.from>>;
+    private convertRequestDtoToRequestTurn;
+    private getChatSessionItemController;
     private getModelForRequest;
     private convertRequestTurn;
     private convertReferenceToVariable;
     private convertResponseTurn;
     $invokeOptionGroupSearch(providerHandle: number, optionGroupId: string, query: string, token: CancellationToken): Promise<IChatSessionProviderOptionItem[]>;
     $refreshChatSessionItems(handle: number, token: CancellationToken): Promise<void>;
-    $newChatSessionItem(handle: number, request: IChatAgentRequest, token: CancellationToken): Promise<ReturnType<typeof typeConvert.ChatSessionItem.from> | undefined>;
+    $newChatSessionItem(handle: number, request: IChatNewSessionRequestDto, token: CancellationToken): Promise<ReturnType<typeof typeConvert.ChatSessionItem.from> | undefined>;
     $onDidChangeChatSessionItemState(controllerHandle: number, sessionResourceComponents: UriComponents, archived: boolean): void;
 }

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

@@ -8,11 +8,10 @@ import { Disposable, DisposableStore, toDisposable } from '../../../base/common/
 import { ResourceSet, ResourceMap } from '../../../base/common/map.js';
 import { MarshalledId } from '../../../base/common/marshallingIds.js';
 import { equals } from '../../../base/common/objects.js';
-import { basename } from '../../../base/common/resources.js';
 import { URI } from '../../../base/common/uri.js';
 import { SymbolKind, SymbolKinds } from '../../../editor/common/languages.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
-import { IDiagnosticVariableEntryFilterData, PromptFileVariableKind } from '../../contrib/chat/common/attachments/chatVariableEntries.js';
+import { IDiagnosticVariableEntryFilterData, PromptFileVariableKind, toPromptFileVariableEntry } from '../../contrib/chat/common/attachments/chatVariableEntries.js';
 import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatAgentResponseStream } from './extHostChatAgents2.js';
@@ -21,7 +20,6 @@ import { ChatSessionItem, ChatAgentRequest, Location, Diagnostic, ChatResponsePa
 import { Disposable as Disposable$1, ChatRequestTurn, ChatReferenceDiagnostic } from './extHostTypes.js';
 import { Location as Location$1 } from './extHostTypes/location.js';
 
-var ExtHostChatSessions_1;
 class ChatSessionItemImpl {
     #label;
     #iconPath;
@@ -246,12 +244,6 @@ class ExtHostChatSession {
     }
 }
 let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
-    static {
-        ExtHostChatSessions_1 = this;
-    }
-    static {
-        this._sessionHandlePool = 0;
-    }
     constructor(commands, _languageModels, _extHostRpc, _logService) {
         super();
         this.commands = commands;
@@ -341,6 +333,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         const disposables = ( new DisposableStore());
         let isDisposed = false;
         let newChatSessionItemHandler;
+        let forkHandler;
         const onDidChangeChatSessionItemStateEmitter = disposables.add(( new Emitter()));
         const collection = ( new ChatSessionItemCollectionImpl(controllerHandle, this._proxy));
         const controller = ( Object.freeze({
@@ -371,6 +364,12 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             set newChatSessionItemHandler(handler) {
                 newChatSessionItemHandler = handler;
             },
+            get forkHandler() {
+                return forkHandler;
+            },
+            set forkHandler(handler) {
+                forkHandler = handler;
+            },
             dispose: () => {
                 isDisposed = true;
                 disposables.dispose();
@@ -402,7 +401,11 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         this._proxy.$registerChatSessionContentProvider(handle, chatSessionScheme);
         if (provider.onDidChangeChatSessionOptions) {
             disposables.add(provider.onDidChangeChatSessionOptions(evt => {
-                this._proxy.$onDidChangeChatSessionOptions(handle, evt.resource, evt.updates);
+                const updates = Object.create(null);
+                for (const update of evt.updates) {
+                    updates[update.optionId] = update.value;
+                }
+                this._proxy.$onDidChangeChatSessionOptions(handle, evt.resource, updates);
             }));
         }
         if (provider.onDidChangeChatSessionProviderOptions) {
@@ -416,18 +419,20 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             this._proxy.$unregisterChatSessionContentProvider(handle);
         });
     }
-    async $provideChatSessionContent(handle, sessionResourceComponents, token) {
+    async $provideChatSessionContent(handle, sessionResourceComponents, context, token) {
         const provider = this._chatSessionContentProviders.get(handle);
         if (!provider) {
             throw ( new Error(`No provider for handle ${handle}`));
         }
         const sessionResource = URI.revive(sessionResourceComponents);
-        const session = await provider.provider.provideChatSessionContent(sessionResource, token);
+        const session = await provider.provider.provideChatSessionContent(sessionResource, token, {
+            sessionOptions: context?.initialSessionOptions ?? []
+        });
         if (token.isCancellationRequested) {
             throw ( new CancellationError());
         }
+        const controllerData = this.getChatSessionItemController(sessionResource.scheme);
         const sessionDisposables = ( new DisposableStore());
-        const sessionId = ExtHostChatSessions_1._sessionHandlePool++;
         const id = ( sessionResource.toString());
         const chatSession = ( new ExtHostChatSession(session, provider.extension, {
             sessionResource,
@@ -462,11 +467,11 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             capabilities
         } = provider;
         return {
-            id: sessionId + "",
             resource: URI.revive(sessionResource),
             title: session.title,
             hasActiveResponseCallback: !!session.activeResponseCallback,
             hasRequestHandler: !!session.requestHandler,
+            hasForkHandler: !!controllerData?.controller.forkHandler || !!session.forkHandler,
             supportsInterruption: !!capabilities?.supportsInterruptions,
             options: session.options,
             history: ( session.history.map(turn => {
@@ -492,11 +497,11 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             return;
         }
         try {
-            const updatesToSend = ( updates.map(update => ({
-                optionId: update.optionId,
-                value: update.value === undefined ? undefined : (typeof update.value === "string" ? update.value : update.value.id)
+            const updatesToSend = ( Object.entries(updates).map(([optionId, value]) => ({
+                optionId,
+                value: value === undefined ? undefined : (typeof value === "string" ? value : value.id)
             })));
-            await provider.provider.provideHandleOptionsChange(sessionResource, updatesToSend, token);
+            provider.provider.provideHandleOptionsChange(sessionResource, updatesToSend, token);
         } catch (error) {
             this._logService.error(
                 `Error calling provideHandleOptionsChange for handle ${handle}, sessionResource ${sessionResource}:`,
@@ -561,6 +566,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             request,
             undefined,
             await this.getModelForRequest(request, entry.sessionObj.extension),
+            request.modelConfiguration,
             [],
             ( new Map()),
             entry.sessionObj.extension,
@@ -573,6 +579,47 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         }, stream.apiObject, token);
         return {};
     }
+    async $forkChatSession(handle, sessionResourceComponents, request, token) {
+        const sessionResource = URI.revive(sessionResourceComponents);
+        const entry = this._extHostChatSessions.get(sessionResource);
+        if (!entry) {
+            throw ( new Error(`No chat session found for resource ${( sessionResource.toString())}`));
+        }
+        const requestTurn = this.convertRequestDtoToRequestTurn(request);
+        const controllerData = this.getChatSessionItemController(sessionResource.scheme);
+        if (controllerData?.controller.forkHandler) {
+            const item = await controllerData.controller.forkHandler(sessionResource, requestTurn, token);
+            return ChatSessionItem.from(item);
+        }
+        if (!entry.sessionObj.session.forkHandler) {
+            throw ( new Error(`No fork handler for session ${( sessionResource.toString())}`));
+        }
+        const item = await entry.sessionObj.session.forkHandler(sessionResource, requestTurn, token);
+        return ChatSessionItem.from(item);
+    }
+    convertRequestDtoToRequestTurn(request) {
+        if (!request) {
+            return undefined;
+        }
+        return new ChatRequestTurn(
+            request.prompt,
+            request.command,
+            [],
+            request.participant,
+            [],
+            undefined,
+            request.id,
+            request.modelId
+        );
+    }
+    getChatSessionItemController(chatSessionType) {
+        for (const controllerData of ( this._chatSessionItemControllers.values())) {
+            if (controllerData.chatSessionType === chatSessionType) {
+                return controllerData;
+            }
+        }
+        return undefined;
+    }
     async getModelForRequest(request, extension) {
         let model;
         if (request.userSelectedModelId) {
@@ -637,17 +684,16 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                 range
             };
         }
-        if (URI.isUri(value) && ref.name.startsWith(`prompt:`) && ref.id.startsWith(PromptFileVariableKind.PromptFile) && ref.id.endsWith(( value.toString()))) {
-            return {
-                id: ref.id,
-                name: `prompt:${basename(value)}`,
-                value,
-                kind: "promptFile",
-                modelDescription: "Prompt instructions file",
-                isRoot: true,
-                automaticallyAdded: false,
-                range
-            };
+        if (URI.isUri(value) && ref.name.startsWith(`prompt:`)) {
+            if (ref.id.startsWith(PromptFileVariableKind.Instruction)) {
+                return toPromptFileVariableEntry(value, PromptFileVariableKind.Instruction);
+            }
+            if (ref.id.startsWith(PromptFileVariableKind.InstructionReference)) {
+                return toPromptFileVariableEntry(value, PromptFileVariableKind.InstructionReference);
+            }
+            if (ref.id.startsWith(PromptFileVariableKind.PromptFile)) {
+                return toPromptFileVariableEntry(value, PromptFileVariableKind.PromptFile);
+            }
         }
         const isFile = URI.isUri(value) || (value && typeof value === "object" && "uri" in value);
         const isFolder = isFile && URI.isUri(value) && value.path.endsWith("/");
@@ -707,10 +753,12 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         if (!handler) {
             return undefined;
         }
-        const model = await this.getModelForRequest(request, controllerData.extension);
-        const chatRequest = ChatAgentRequest.to(request, undefined, model, [], ( new Map()), controllerData.extension, this._logService);
         const item = await handler({
-            request: chatRequest
+            request: {
+                prompt: request.prompt,
+                command: request.command
+            },
+            sessionOptions: request.initialSessionOptions ?? []
         }, token);
         if (!item) {
             return undefined;
@@ -733,6 +781,6 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         controllerData.onDidChangeChatSessionItemStateEmitter.fire(item);
     }
 };
-ExtHostChatSessions = ExtHostChatSessions_1 = ( __decorate([( __param(2, IExtHostRpcService)), ( __param(3, ILogService))], ExtHostChatSessions));
+ExtHostChatSessions = ( __decorate([( __param(2, IExtHostRpcService)), ( __param(3, ILogService))], ExtHostChatSessions));
 
 export { ExtHostChatSessions };

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

@@ -52,7 +52,7 @@ export declare class CommandsConverter implements extHostTypeConverter.Command.I
     toInternal(command: vscode.Command, disposables: DisposableStore): ICommandDto;
     toInternal(command: vscode.Command | undefined, disposables: DisposableStore): ICommandDto | undefined;
     fromInternal(command: ICommandDto): vscode.Command | undefined;
-    getActualCommand(...args: any[]): vscode.Command | undefined;
+    getActualCommand(...args: unknown[]): vscode.Command | undefined;
     private _executeConvertedCommand;
 }
 export declare class ApiCommandArgument<V, O = V> {

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

@@ -16,5 +16,5 @@ export declare abstract class AbstractExtHostConsoleForwarder {
      */
     private _wrapConsoleMethod;
     private _handleConsoleCall;
-    protected abstract _nativeConsoleLogMessage(method: "log" | "info" | "warn" | "error" | "debug", original: (...args: any[]) => void, args: IArguments): void;
+    protected abstract _nativeConsoleLogMessage(method: "log" | "info" | "warn" | "error" | "debug", original: (...args: unknown[]) => void, args: unknown[]): void;
 }

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

@@ -21,9 +21,9 @@ let AbstractExtHostConsoleForwarder = class AbstractExtHostConsoleForwarder {
         const original = console[method];
         Object.defineProperty(console, method, {
             set: () => {},
-            get: () => (function() {
-                that._handleConsoleCall(method, severity, original, arguments);
-            })
+            get: () => (...args) => {
+                that._handleConsoleCall(method, severity, original, args);
+            }
         });
     }
     _handleConsoleCall(method, severity, original, args) {

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

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

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

@@ -377,7 +377,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             const that = this;
             let extension;
             let messagePassingProtocol;
-            const messagePort = isProposedApiEnabled(extensionDescription, "ipc") ? this._initData.messagePorts?.get(ExtensionIdentifier.toKey(extensionDescription.identifier)) : undefined;
+            const messagePort = isProposedApiEnabled(extensionDescription) ? this._initData.messagePorts?.get(ExtensionIdentifier.toKey(extensionDescription.identifier)) : undefined;
             return ( Object.freeze({
                 globalState,
                 workspaceState,
@@ -614,14 +614,14 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             extensionTestsLocationURI
         } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(2739, "Cannot load test runner."))));
+            throw ( new Error(( localize(2747, "Cannot load test runner."))));
         }
         const extensionDescription = (await this.getExtensionPathIndex()).findSubstr(extensionTestsLocationURI);
         const isESM = this._isESM(extensionDescription, extensionTestsLocationURI.path);
         const testRunner = await (isESM ? this._loadESMModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))) : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
         if (!testRunner || typeof testRunner.run !== "function") {
             throw ( new Error(( localize(
-                2740,
+                2748,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));

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

@@ -17,7 +17,7 @@ export declare class ExtHostConsumerFileSystem {
         isCaseSensitive?: boolean;
         isReadonly?: boolean | IMarkdownString;
     }): IDisposable;
-    getFileSystemProviderExtUri(scheme: string): IExtUri;
+    getFileSystemProviderExtUri(scheme: string): IExtUri | import("../../../base/common/resources.js").ExtUri;
 }
 export interface IExtHostConsumerFileSystem extends ExtHostConsumerFileSystem {
 }

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

@@ -3,7 +3,7 @@ import { Disposable } from "../../../base/common/lifecycle.js";
 import { UriComponents } from "../../../base/common/uri.js";
 import { IExtHostExtensionService } from "./extHostExtensionService.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
-import { ExtHostGitExtensionShape, GitRefDto, GitRefQueryDto, GitRepositoryStateDto } from "./extHost.protocol.js";
+import { ExtHostGitExtensionShape, GitDiffChangeDto, GitRefDto, GitRefQueryDto, GitRepositoryStateDto } from "./extHost.protocol.js";
 export interface IExtHostGitExtensionService extends ExtHostGitExtensionShape {
     readonly _serviceBrand: undefined;
 }
@@ -26,6 +26,10 @@ export declare class ExtHostGitExtensionService extends Disposable implements IE
     } | undefined>;
     $getRefs(handle: number, query: GitRefQueryDto, token?: vscode.CancellationToken): Promise<GitRefDto[]>;
     $getRepositoryState(handle: number): Promise<GitRepositoryStateDto | undefined>;
+    private _getRepositoryState;
+    private _getBranchBase;
+    $diffBetweenWithStats(handle: number, ref1: string, ref2: string, path?: string): Promise<GitDiffChangeDto[]>;
+    $diffBetweenWithStats2(handle: number, ref: string, path?: string): Promise<GitDiffChangeDto[]>;
     private _ensureGitApi;
     dispose(): void;
 }