@codingame/monaco-vscode-api 23.3.0 → 24.1.0

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

@@ -5,7 +5,7 @@ import { CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { toErrorMessage } from '../../../base/common/errorMessage.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Iterable } from '../../../base/common/iterator.js';
-import { toDisposable, Disposable, DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
+import { toDisposable, Disposable, DisposableResourceMap, DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
 import { revive } from '../../../base/common/marshalling.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { assertType } from '../../../base/common/types.js';
@@ -14,6 +14,7 @@ import { generateUuid } from '../../../base/common/uuid.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { isChatViewTitleActionContext } from '../../contrib/chat/common/chatActions.js';
 import { ChatAgentVoteDirection } from '../../contrib/chat/common/chatService.js';
+import { LocalChatSessionUri } from '../../contrib/chat/common/chatUri.js';
 import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { MainContext } from './extHost.protocol.js';
@@ -232,12 +233,14 @@ class ChatAgentResponseStream {
                     throwIfDone(this.externalEdit);
                     const resources = Array.isArray(target) ? target : [target];
                     const operationId = taskHandlePool++;
-                    await send({ kind: 'externalEdits', start: true, resources }, operationId);
+                    const undoStopId = generateUuid();
+                    await send({ kind: 'externalEdits', start: true, resources, undoStopId }, operationId);
                     try {
-                        return await callback();
+                        await callback();
+                        return undoStopId;
                     }
                     finally {
-                        await send({ kind: 'externalEdits', start: false, resources }, operationId);
+                        await send({ kind: 'externalEdits', start: false, resources, undoStopId }, operationId);
                     }
                 },
                 confirmation(title, message, data, buttons) {
@@ -307,7 +310,7 @@ class ChatAgentResponseStream {
                     }
                     else if (part instanceof ChatResponseExternalEditPart) {
                         const p = this.externalEdit(part.uris, part.callback);
-                        p.then(() => part.didGetApplied());
+                        p.then((value) => part.didGetApplied(value));
                         return this;
                     }
                     else {
@@ -325,18 +328,21 @@ class ExtHostChatAgents2 extends Disposable {
     static { this._idPool = 0; }
     static { this._participantDetectionProviderIdPool = 0; }
     static { this._relatedFilesProviderIdPool = 0; }
-    constructor(mainContext, _logService, _commands, _documents, _languageModels, _diagnostics, _tools) {
+    static { this._customAgentsProviderIdPool = 0; }
+    constructor(mainContext, _logService, _commands, _documents, _editorsAndDocuments, _languageModels, _diagnostics, _tools) {
         super();
         this._logService = _logService;
         this._commands = _commands;
         this._documents = _documents;
+        this._editorsAndDocuments = _editorsAndDocuments;
         this._languageModels = _languageModels;
         this._diagnostics = _diagnostics;
         this._tools = _tools;
         this._agents = ( new Map());
         this._participantDetectionProviders = ( new Map());
         this._relatedFilesProviders = ( new Map());
-        this._sessionDisposables = this._register(( new DisposableMap()));
+        this._customAgentsProviders = ( new Map());
+        this._sessionDisposables = this._register(( new DisposableResourceMap()));
         this._completionDisposables = this._register(( new DisposableMap()));
         this._inFlightRequests = ( new Set());
         this._onDidChangeChatRequestTools = this._register(( new Emitter()));
@@ -388,6 +394,22 @@ class ExtHostChatAgents2 extends Disposable {
             this._proxy.$unregisterRelatedFilesProvider(handle);
         });
     }
+    registerCustomAgentsProvider(extension, provider) {
+        const handle = ExtHostChatAgents2._customAgentsProviderIdPool++;
+        this._customAgentsProviders.set(handle, { extension, provider });
+        this._proxy.$registerCustomAgentsProvider(handle, extension.identifier);
+        const disposables = ( new DisposableStore());
+        if (provider.onDidChangeCustomAgents) {
+            disposables.add(provider.onDidChangeCustomAgents(() => {
+                this._proxy.$onDidChangeCustomAgents(handle);
+            }));
+        }
+        disposables.add(toDisposable(() => {
+            this._customAgentsProviders.delete(handle);
+            this._proxy.$unregisterCustomAgentsProvider(handle);
+        }));
+        return disposables;
+    }
     async $provideRelatedFiles(handle, request, token) {
         const provider = this._relatedFilesProviders.get(handle);
         if (!provider) {
@@ -396,6 +418,13 @@ class ExtHostChatAgents2 extends Disposable {
         const extRequestDraft = ChatRequestDraft.to(request);
         return (await provider.provider.provideRelatedFiles(extRequestDraft, token)) ?? undefined;
     }
+    async $provideCustomAgents(handle, options, token) {
+        const providerData = this._customAgentsProviders.get(handle);
+        if (!providerData) {
+            return Promise.resolve(undefined);
+        }
+        return (await providerData.provider.provideCustomAgents(options, token)) ?? undefined;
+    }
     async $detectChatParticipant(handle, requestDto, context, options, token) {
         const detector = this._participantDetectionProviders.get(handle);
         if (!detector) {
@@ -412,7 +441,8 @@ class ExtHostChatAgents2 extends Disposable {
         let location;
         if (request.locationData?.type === ChatAgentLocation.EditorInline) {
             const document = this._documents.getDocument(request.locationData.document);
-            location = new ChatRequestEditorData(document, Selection.to(request.locationData.selection), Range.to(request.locationData.wholeRange));
+            const editor = this._editorsAndDocuments.getEditor(request.locationData.id);
+            location = new ChatRequestEditorData(editor.value, document, Selection.to(request.locationData.selection), Range.to(request.locationData.wholeRange));
         }
         else if (request.locationData?.type === ChatAgentLocation.Notebook) {
             const cell = this._documents.getDocument(request.locationData.sessionInputUri);
@@ -456,10 +486,10 @@ class ExtHostChatAgents2 extends Disposable {
         let inFlightRequest;
         try {
             const { request, location, history } = await this._createRequest(requestDto, context, agent.extension);
-            let sessionDisposables = this._sessionDisposables.get(request.sessionId);
+            let sessionDisposables = this._sessionDisposables.get(request.sessionResource);
             if (!sessionDisposables) {
                 sessionDisposables = ( new DisposableStore());
-                this._sessionDisposables.set(request.sessionId, sessionDisposables);
+                this._sessionDisposables.set(request.sessionResource, sessionDisposables);
             }
             stream = ( new ChatAgentResponseStream(
                 agent.extension,
@@ -482,11 +512,7 @@ class ExtHostChatAgents2 extends Disposable {
                     isUntitled: context.chatSessionContext.isUntitled,
                 };
             }
-            const chatContext = {
-                history,
-                chatSessionContext,
-                chatSummary: context.chatSummary
-            };
+            const chatContext = { history, chatSessionContext };
             const task = agent.invoke(extRequest, chatContext, stream.apiObject, token);
             return await raceCancellationWithTimeout(1000, Promise.resolve(task).then((result) => {
                 if (result?.metadata) {
@@ -570,16 +596,20 @@ class ExtHostChatAgents2 extends Disposable {
                 }
             }
             const editedFileEvents = isProposedApiEnabled(extension, 'chatParticipantPrivate') ? h.request.editedFileEvents : undefined;
-            const turn = new ChatRequestTurn(h.request.message, h.request.command, varsWithoutTools, h.request.agentId, toolReferences, editedFileEvents);
+            const turn = new ChatRequestTurn(h.request.message, h.request.command, varsWithoutTools, h.request.agentId, toolReferences, editedFileEvents, h.request.requestId);
             res.push(turn);
             const parts = coalesce(( h.response.map(r => ChatResponsePart.toContent(r, this._commands.converter))));
             res.push(new ChatResponseTurn(parts, result, h.request.agentId, h.request.command));
         }
         return res;
     }
-    $releaseSession(sessionId) {
-        this._sessionDisposables.deleteAndDispose(sessionId);
-        this._onDidDisposeChatSession.fire(sessionId);
+    $releaseSession(sessionResourceDto) {
+        const sessionResource = URI.revive(sessionResourceDto);
+        this._sessionDisposables.deleteAndDispose(sessionResource);
+        const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
+        if (sessionId) {
+            this._onDidDisposeChatSession.fire(sessionId);
+        }
     }
     async $provideFollowups(requestDto, handle, result, context, token) {
         const agent = this._agents.get(handle);
@@ -756,7 +786,6 @@ class ExtHostChatAgent {
                     helpTextPrefix: (!this._helpTextPrefix || typeof this._helpTextPrefix === 'string') ? this._helpTextPrefix : MarkdownString$1.from(this._helpTextPrefix),
                     helpTextPostfix: (!this._helpTextPostfix || typeof this._helpTextPostfix === 'string') ? this._helpTextPostfix : MarkdownString$1.from(this._helpTextPostfix),
                     supportIssueReporting: this._supportIssueReporting,
-                    requester: this._requester,
                     additionalWelcomeMessage: (!this._additionalWelcomeMessage || typeof this._additionalWelcomeMessage === 'string') ? this._additionalWelcomeMessage : MarkdownString$1.from(this._additionalWelcomeMessage),
                 });
                 updateScheduled = false;
@@ -868,13 +897,6 @@ class ExtHostChatAgent {
             onDidPerformAction: !isProposedApiEnabled(this.extension, 'chatParticipantAdditions')
                 ? undefined
                 : this._onDidPerformAction.event,
-            set requester(v) {
-                that._requester = v;
-                updateMetadataSoon();
-            },
-            get requester() {
-                return that._requester;
-            },
             dispose() {
                 disposed = true;
                 that._followupProvider = undefined;

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

@@ -3,8 +3,9 @@ import { CancellationToken } from "../../../base/common/cancellation.js";
 import { UriComponents } from "../../../base/common/uri.js";
 import { ExtHostChatContextShape } from "./extHost.protocol.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
-import { IChatContextItem } from "../../services/chat/common/chatContext.js";
-export declare class ExtHostChatContext implements ExtHostChatContextShape {
+import { IChatContextItem } from "../../contrib/chat/common/chatContext.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+export declare class ExtHostChatContext extends Disposable implements ExtHostChatContextShape {
     _serviceBrand: undefined;
     private _proxy;
     private _handlePool;
@@ -13,10 +14,15 @@ export declare class ExtHostChatContext implements ExtHostChatContextShape {
     private _items;
     constructor(extHostRpc: IExtHostRpcService);
     $provideChatContext(handle: number, token: CancellationToken): Promise<IChatContextItem[]>;
+    private _addTrackedItem;
     $provideChatContextForResource(handle: number, options: {
         resource: UriComponents;
+        withValue: boolean;
     }, token: CancellationToken): Promise<IChatContextItem | undefined>;
+    private _doResolve;
     $resolveChatContext(handle: number, context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
-    registerChatContextProvider(selector: vscode.DocumentSelector, id: string, provider: vscode.ChatContextProvider): vscode.Disposable;
+    registerChatContextProvider(selector: vscode.DocumentSelector | undefined, id: string, provider: vscode.ChatContextProvider): vscode.Disposable;
+    private _listenForWorkspaceContextChanges;
     private _getProvider;
+    dispose(): void;
 }

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

@@ -1,12 +1,15 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
 import { URI } from '../../../base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
 import { DocumentSelector } from './extHostTypeConverters.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
+import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
 
-let ExtHostChatContext = class ExtHostChatContext {
+let ExtHostChatContext = class ExtHostChatContext extends Disposable {
     constructor(extHostRpc) {
+        super();
         this._handlePool = 0;
         this._providers = ( new Map());
         this._itemPool = 0;
@@ -22,11 +25,7 @@ let ExtHostChatContext = class ExtHostChatContext {
         const result = (await provider.provideChatContextExplicit(token)) ?? [];
         const items = [];
         for (const item of result) {
-            const itemHandle = this._itemPool++;
-            if (!( this._items.has(handle))) {
-                this._items.set(handle, ( new Map()));
-            }
-            this._items.get(handle).set(itemHandle, item);
+            const itemHandle = this._addTrackedItem(handle, item);
             items.push({
                 handle: itemHandle,
                 icon: item.icon,
@@ -37,33 +36,38 @@ let ExtHostChatContext = class ExtHostChatContext {
         }
         return items;
     }
+    _addTrackedItem(handle, item) {
+        const itemHandle = this._itemPool++;
+        if (!( this._items.has(handle))) {
+            this._items.set(handle, ( new Map()));
+        }
+        this._items.get(handle).set(itemHandle, item);
+        return itemHandle;
+    }
     async $provideChatContextForResource(handle, options, token) {
         const provider = this._getProvider(handle);
         if (!provider.provideChatContextForResource) {
             throw ( new Error('provideChatContextForResource not implemented'));
         }
-        let result = await provider.provideChatContextForResource({ resource: URI.revive(options.resource) }, token);
-        if (result && (result.value === undefined)) {
-            result = await provider.resolveChatContext(result, token);
+        const result = await provider.provideChatContextForResource({ resource: URI.revive(options.resource) }, token);
+        if (!result) {
+            return undefined;
         }
-        const item = result ? {
-            handle: this._itemPool++,
+        const itemHandle = this._addTrackedItem(handle, result);
+        const item = {
+            handle: itemHandle,
             icon: result.icon,
             label: result.label,
             modelDescription: result.modelDescription,
-            value: result.value
-        } : undefined;
+            value: options.withValue ? result.value : undefined
+        };
+        if (options.withValue && !item.value && provider.resolveChatContext) {
+            const resolved = await provider.resolveChatContext(result, token);
+            item.value = resolved?.value;
+        }
         return item;
     }
-    async $resolveChatContext(handle, context, token) {
-        const provider = this._getProvider(handle);
-        if (!provider.resolveChatContext) {
-            throw ( new Error('resolveChatContext not implemented'));
-        }
-        const extItem = this._items.get(handle)?.get(context.handle);
-        if (!extItem) {
-            throw ( new Error('Chat context item not found'));
-        }
+    async _doResolve(provider, context, extItem, token) {
         const extResult = await provider.resolveChatContext(extItem, token);
         const result = extResult ?? context;
         return {
@@ -74,22 +78,63 @@ let ExtHostChatContext = class ExtHostChatContext {
             value: result.value
         };
     }
+    async $resolveChatContext(handle, context, token) {
+        const provider = this._getProvider(handle);
+        if (!provider.resolveChatContext) {
+            throw ( new Error('resolveChatContext not implemented'));
+        }
+        const extItem = this._items.get(handle)?.get(context.handle);
+        if (!extItem) {
+            throw ( new Error('Chat context item not found'));
+        }
+        return this._doResolve(provider, context, extItem, token);
+    }
     registerChatContextProvider(selector, id, provider) {
         const handle = this._handlePool++;
-        this._providers.set(handle, provider);
-        this._proxy.$registerChatContextProvider(handle, `${id}`, DocumentSelector.from(selector), {}, { supportsResource: !!provider.provideChatContextForResource, supportsResolve: !!provider.resolveChatContext });
+        const disposables = ( new DisposableStore());
+        this._listenForWorkspaceContextChanges(handle, provider, disposables);
+        this._providers.set(handle, { provider, disposables });
+        this._proxy.$registerChatContextProvider(handle, `${id}`, selector ? DocumentSelector.from(selector) : undefined, {}, { supportsResource: !!provider.provideChatContextForResource, supportsResolve: !!provider.resolveChatContext });
         return {
             dispose: () => {
                 this._providers.delete(handle);
                 this._proxy.$unregisterChatContextProvider(handle);
+                disposables.dispose();
             }
         };
     }
+    _listenForWorkspaceContextChanges(handle, provider, disposables) {
+        if (!provider.onDidChangeWorkspaceChatContext || !provider.provideWorkspaceChatContext) {
+            return;
+        }
+        disposables.add(provider.onDidChangeWorkspaceChatContext(async () => {
+            const workspaceContexts = await provider.provideWorkspaceChatContext(CancellationToken.None);
+            const resolvedContexts = [];
+            for (const item of workspaceContexts ?? []) {
+                const contextItem = {
+                    icon: item.icon,
+                    label: item.label,
+                    modelDescription: item.modelDescription,
+                    value: item.value,
+                    handle: this._itemPool++
+                };
+                const resolved = await this._doResolve(provider, contextItem, item, CancellationToken.None);
+                resolvedContexts.push(resolved);
+            }
+            this._proxy.$updateWorkspaceContextItems(handle, resolvedContexts);
+        }));
+    }
     _getProvider(handle) {
         if (!( this._providers.has(handle))) {
             throw ( new Error('Chat context provider not found'));
         }
-        return this._providers.get(handle);
+        return this._providers.get(handle).provider;
+    }
+    dispose() {
+        super.dispose();
+        for (const { disposables } of ( this._providers.values())) {
+            disposables.dispose();
+        }
     }
 };
 ExtHostChatContext = ( __decorate([

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

@@ -4,8 +4,8 @@ import { Disposable } from "../../../base/common/lifecycle.js";
 import { UriComponents } from "../../../base/common/uri.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-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
-import { IChatSessionItem } from "../../contrib/chat/common/chatSessionsService.js";
+import { IChatAgentRequest, IChatAgentResult } from "../../contrib/chat/common/chatAgents.js";
+import { IChatSessionItem, IChatSessionProviderOptionItem } from "../../contrib/chat/common/chatSessionsService.js";
 import { ChatSessionDto, ExtHostChatSessionsShape, IChatSessionProviderOptions } from "./extHost.protocol.js";
 import { ExtHostCommands } from "./extHostCommands.js";
 import { ExtHostLanguageModels } from "./extHostLanguageModels.js";
@@ -44,7 +44,7 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
     $provideChatSessionContent(handle: number, sessionResourceComponents: UriComponents, token: CancellationToken): Promise<ChatSessionDto>;
     $provideHandleOptionsChange(handle: number, sessionResourceComponents: UriComponents, updates: ReadonlyArray<{
         optionId: string;
-        value: string | undefined;
+        value: string | IChatSessionProviderOptionItem | undefined;
     }>, token: CancellationToken): Promise<void>;
     $provideChatSessionProviderOptions(handle: number, token: CancellationToken): Promise<IChatSessionProviderOptions | undefined>;
     $interruptChatSessionActiveResponse(providerHandle: number, sessionResource: UriComponents, requestId: string): Promise<void>;

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

@@ -14,8 +14,12 @@ 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 { MarkdownString, ChatAgentRequest, Location, ChatResponsePart } from './extHostTypeConverters.js';
-import { Disposable as Disposable$1, ChatRequestTurn } from './extHostTypes.js';
+import { MarkdownString, ChatAgentRequest, Location, Diagnostic, ChatResponsePart } from './extHostTypeConverters.js';
+import { Disposable as Disposable$1, ChatRequestTurn, ChatReferenceDiagnostic } from './extHostTypes.js';
+import { IDiagnosticVariableEntryFilterData, PromptFileVariableKind } from '../../contrib/chat/common/chatVariableEntries.js';
+import { basename } from '../../../base/common/resources.js';
+import { SymbolKinds, SymbolKind } from '../../../editor/common/languages.js';
+import { Location as Location$1 } from './extHostTypes/location.js';
 
 var ExtHostChatSessions_1;
 class ExtHostChatSession {
@@ -102,6 +106,11 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         const disposables = ( new DisposableStore());
         this._chatSessionContentProviders.set(handle, { provider, extension, capabilities, disposable: disposables });
         this._proxy.$registerChatSessionContentProvider(handle, chatSessionScheme);
+        if (provider.onDidChangeChatSessionOptions) {
+            disposables.add(provider.onDidChangeChatSessionOptions(evt => {
+                this._proxy.$onDidChangeChatSessionOptions(handle, evt.resource, evt.updates);
+            }));
+        }
         return new Disposable$1(() => {
             this._chatSessionContentProviders.delete(handle);
             disposables.dispose();
@@ -125,7 +134,6 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
     }
     convertChatSessionItem(sessionType, sessionContent) {
         return {
-            id: ( sessionContent.resource.toString()),
             resource: sessionContent.resource,
             label: sessionContent.label,
             description: sessionContent.description ? MarkdownString.from(sessionContent.description) : undefined,
@@ -135,10 +143,13 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                 startTime: sessionContent.timing?.startTime ?? 0,
                 endTime: sessionContent.timing?.endTime
             },
-            statistics: sessionContent.statistics ? {
-                insertions: sessionContent.statistics?.insertions ?? 0,
-                deletions: sessionContent.statistics?.deletions ?? 0
-            } : undefined
+            changes: sessionContent.changes instanceof Array
+                ? sessionContent.changes :
+                (sessionContent.changes && {
+                    files: sessionContent.changes?.files ?? 0,
+                    insertions: sessionContent.changes?.insertions ?? 0,
+                    deletions: sessionContent.changes?.deletions ?? 0,
+                }),
         };
     }
     async $provideNewChatSessionItem(handle, options, token) {
@@ -198,7 +209,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         const sessionId = ExtHostChatSessions_1._sessionHandlePool++;
         const id = ( sessionResource.toString());
         const chatSession = ( new ExtHostChatSession(session, provider.extension, {
-            sessionId: `${id}.${sessionId}`,
+            sessionResource,
             requestId: 'ongoing',
             agentId: id,
             message: '',
@@ -249,7 +260,11 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             return;
         }
         try {
-            await provider.provider.provideHandleOptionsChange(sessionResource, updates, token);
+            const updatesToSend = ( updates.map(update => ({
+                optionId: update.optionId,
+                value: update.value === undefined ? undefined : (typeof update.value === 'string' ? update.value : update.value.id)
+            })));
+            await provider.provider.provideHandleOptionsChange(sessionResource, updatesToSend, token);
         }
         catch (error) {
             this._logService.error(`Error calling provideHandleOptionsChange for handle ${handle}, sessionResource ${sessionResource}:`, error);
@@ -320,6 +335,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         const variables = ( turn.references.map(ref => this.convertReferenceToVariable(ref)));
         return {
             type: 'request',
+            id: turn.id,
             prompt: turn.prompt,
             participant: turn.participant,
             command: turn.command,
@@ -331,14 +347,52 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             ? Location.from(ref.value)
             : ref.value;
         const range = ref.range ? { start: ref.range[0], endExclusive: ref.range[1] } : undefined;
+        if (value && value instanceof ChatReferenceDiagnostic && Array.isArray(value.diagnostics) && value.diagnostics.length && value.diagnostics[0][1].length) {
+            const marker = Diagnostic.from(value.diagnostics[0][1][0]);
+            const refValue = {
+                filterRange: { startLineNumber: marker.startLineNumber, startColumn: marker.startColumn, endLineNumber: marker.endLineNumber, endColumn: marker.endColumn },
+                filterSeverity: marker.severity,
+                filterUri: value.diagnostics[0][0],
+                problemMessage: value.diagnostics[0][1][0].message
+            };
+            return IDiagnosticVariableEntryFilterData.toEntry(refValue);
+        }
+        if (Location$1.isLocation(ref.value) && ref.name.startsWith(`sym:`)) {
+            const loc = Location.from(ref.value);
+            return {
+                id: ref.id,
+                name: ref.name,
+                fullName: ref.name.substring(4),
+                value: { uri: ref.value.uri, range: loc.range },
+                symbolKind: SymbolKind.Property,
+                icon: SymbolKinds.toIcon(SymbolKind.Property),
+                kind: 'symbol',
+                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,
+            };
+        }
         const isFile = URI.isUri(value) || (value && typeof value === 'object' && 'uri' in value);
+        const isFolder = isFile && URI.isUri(value) && value.path.endsWith('/');
         return {
             id: ref.id,
-            name: ref.id,
+            name: ref.name,
             value,
             modelDescription: ref.modelDescription,
             range,
-            kind: isFile ? 'file' : 'generic'
+            kind: isFolder ? 'directory' : isFile ? 'file' : 'generic'
         };
     }
     convertResponseTurn(turn, sessionDisposables) {

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

@@ -80,8 +80,7 @@ class ExtHostEditorInsets {
                 this.onDidDispose = onDidDispose.event;
             }
             dispose() {
-                if (( that._insets.has(handle))) {
-                    that._insets.delete(handle);
+                if (that._insets.delete(handle)) {
                     that._proxy.$disposeEditorInset(handle);
                     onDidDispose.fire();
                     onDidDispose.dispose();

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

@@ -3,6 +3,7 @@ import { MainContext } from './extHost.protocol.js';
 import { NotebookEdit, TextEdit } from './extHostTypeConverters.js';
 import { URI } from '../../../base/common/uri.js';
 import { asArray } from '../../../base/common/arrays.js';
+import { LocalChatSessionUri } from '../../contrib/chat/common/chatUri.js';
 
 class ExtHostCodeMapper {
     static { this._providerHandlePool = 0; }
@@ -35,7 +36,7 @@ class ExtHostCodeMapper {
             location: internalRequest.location,
             chatRequestId: internalRequest.chatRequestId,
             chatRequestModel: internalRequest.chatRequestModel,
-            chatSessionId: internalRequest.chatSessionId,
+            chatSessionId: internalRequest.chatSessionResource ? LocalChatSessionUri.parseLocalSessionId(URI.revive(internalRequest.chatSessionResource)) : undefined,
             codeBlocks: ( internalRequest.codeBlocks.map(block => {
                 return {
                     code: block.code,

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

@@ -24,22 +24,25 @@ function lookUp(tree, key) {
         }
         return node;
     }
+    return undefined;
 }
 function isUri(thing) {
     return thing instanceof URI;
 }
 function isResourceLanguage(thing) {
-    return thing
+    return isObject(thing)
         && thing.uri instanceof URI
-        && (thing.languageId && typeof thing.languageId === 'string');
+        && !!thing.languageId
+        && typeof thing.languageId === 'string';
 }
 function isLanguage(thing) {
-    return thing
+    return isObject(thing)
         && !thing.uri
-        && (thing.languageId && typeof thing.languageId === 'string');
+        && !!thing.languageId
+        && typeof thing.languageId === 'string';
 }
 function isWorkspaceFolder(thing) {
-    return thing
+    return isObject(thing)
         && thing.uri instanceof URI
         && (!thing.name || typeof thing.name === 'string')
         && (!thing.index || typeof thing.index === 'number');

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-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
+import { EditorGroupColumn } from "../../services/editor/common/editorGroupColumn.js";
 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/extHostDiagnostics.d.ts

@@ -26,7 +26,7 @@ export declare class DiagnosticCollection implements vscode.DiagnosticCollection
     ]>): void;
     delete(uri: vscode.Uri): void;
     clear(): void;
-    forEach(callback: (uri: URI, diagnostics: ReadonlyArray<vscode.Diagnostic>, collection: DiagnosticCollection) => any, thisArg?: any): void;
+    forEach(callback: (uri: URI, diagnostics: ReadonlyArray<vscode.Diagnostic>, collection: DiagnosticCollection) => unknown, thisArg?: unknown): void;
     [Symbol.iterator](): IterableIterator<[
         uri: vscode.Uri,
         diagnostics: readonly vscode.Diagnostic[]

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

@@ -109,7 +109,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            2653,
+                            2667,
                             "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(2654, "Cannot load test runner."))));
+            throw ( new Error(( localize(2668, "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(
-                2655,
+                2669,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));