@codingame/monaco-vscode-api 26.2.2 → 27.0.0

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

@@ -369,6 +369,18 @@ class ChatAgentResponseStream {
                         _report(dto);
                     }
                     return this;
+                },
+                usage(usage) {
+                    throwIfDone(this.usage);
+                    checkProposedApiEnabled(that._extension, "chatParticipantAdditions");
+                    const dto = {
+                        kind: "usage",
+                        promptTokens: usage.promptTokens,
+                        completionTokens: usage.completionTokens,
+                        promptTokenDetails: usage.promptTokenDetails
+                    };
+                    _report(dto);
+                    return this;
                 }
             }));
         }
@@ -385,6 +397,9 @@ class ExtHostChatAgents2 extends Disposable {
     static {
         this._contributionsProviderIdPool = 0;
     }
+    get activeChatPanelSessionResource() {
+        return this._activeChatPanelSessionResource;
+    }
     constructor(
         mainContext,
         _logService,
@@ -414,6 +429,8 @@ class ExtHostChatAgents2 extends Disposable {
         this.onDidChangeChatRequestTools = this._onDidChangeChatRequestTools.event;
         this._onDidDisposeChatSession = this._register(( new Emitter()));
         this.onDidDisposeChatSession = this._onDidDisposeChatSession.event;
+        this._onDidChangeActiveChatPanelSessionResource = this._register(( new Emitter()));
+        this.onDidChangeActiveChatPanelSessionResource = this._onDidChangeActiveChatPanelSessionResource.event;
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatAgents2));
         _commands.registerArgumentProcessor({
             processArgument: arg => {
@@ -591,10 +608,10 @@ class ExtHostChatAgents2 extends Disposable {
         }
         this._onDidChangeChatRequestTools.fire(request.extRequest);
     }
-    $setYieldRequested(requestId) {
+    $setYieldRequested(requestId, value) {
         const request = [...this._inFlightRequests].find(r => r.requestId === requestId);
         if (request) {
-            request.yieldRequested = true;
+            request.yieldRequested = value;
         }
     }
     async $invokeAgent(handle, requestDto, context, token) {
@@ -652,7 +669,8 @@ class ExtHostChatAgents2 extends Disposable {
                         resource: URI.revive(context.chatSessionContext.chatSessionResource),
                         label: context.chatSessionContext.isUntitled ? "Untitled Session" : "Session"
                     },
-                    isUntitled: context.chatSessionContext.isUntitled
+                    isUntitled: context.chatSessionContext.isUntitled,
+                    initialSessionOptions: context.chatSessionContext.initialSessionOptions
                 };
             }
             const chatContext = {
@@ -697,8 +715,7 @@ class ExtHostChatAgents2 extends Disposable {
                     timings: stream?.timings,
                     metadata: result?.metadata,
                     nextQuestion: result?.nextQuestion,
-                    details: result?.details,
-                    usage: result?.usage
+                    details: result?.details
                 };
             }), token);
         } catch (e) {
@@ -796,6 +813,14 @@ class ExtHostChatAgents2 extends Disposable {
             this._onDidDisposeChatSession.fire(sessionId);
         }
     }
+    $acceptActiveChatSession(sessionResourceDto) {
+        const sessionResource = sessionResourceDto ? URI.revive(sessionResourceDto) : undefined;
+        if (this._activeChatPanelSessionResource?.toString() === sessionResource?.toString()) {
+            return;
+        }
+        this._activeChatPanelSessionResource = sessionResource;
+        this._onDidChangeActiveChatPanelSessionResource.fire(sessionResource);
+    }
     async $provideFollowups(requestDto, handle, result, context, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
@@ -1098,6 +1123,8 @@ class ExtHostChatAgent {
                 disposed = true;
                 that._followupProvider = undefined;
                 that._onDidReceiveFeedback.dispose();
+                that._onDidPerformAction.dispose();
+                that._pauseStateEmitter.dispose();
                 that._proxy.$unregisterAgent(that._handle);
             }
         };

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

@@ -26,7 +26,7 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
             throw ( new Error("Workspace context provider not found"));
         }
         const provider = entry.provider;
-        const result = (await provider.provideChatContext(token)) ?? [];
+        const result = (await provider.provideWorkspaceChatContext?.(token)) ?? (await provider.provideChatContext?.(token)) ?? [];
         return this._convertItems(handle, result);
     }
     async $provideExplicitChatContext(handle, token) {
@@ -36,7 +36,7 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
             throw ( new Error("Explicit context provider not found"));
         }
         const provider = entry.provider;
-        const result = (await provider.provideChatContext(token)) ?? [];
+        const result = (await provider.provideExplicitChatContext?.(token)) ?? (await provider.provideChatContext?.(token)) ?? [];
         return this._convertItems(handle, result);
     }
     async $resolveExplicitChatContext(handle, context, token) {
@@ -49,7 +49,12 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
         if (!extItem) {
             throw ( new Error("Chat context item not found"));
         }
-        return this._doResolve(provider.resolveChatContext.bind(provider), context, extItem, token);
+        return this._doResolve(
+            (provider.resolveExplicitChatContext ?? provider.resolveChatContext)?.bind(provider),
+            context,
+            extItem,
+            token
+        );
     }
     async $provideResourceChatContext(handle, options, token) {
         const entry = this._providers.get(handle);
@@ -57,17 +62,23 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
             throw ( new Error("Resource context provider not found"));
         }
         const provider = entry.provider;
-        const result = await provider.provideChatContext({
+        const result = (await provider.provideResourceChatContext?.({
+            resource: URI.revive(options.resource)
+        }, token)) ?? (await provider.provideChatContext?.({
             resource: URI.revive(options.resource)
-        }, token);
+        }, token));
         if (!result) {
             return undefined;
         }
+        if (result.label === undefined && result.resourceUri === undefined) {
+            throw ( new Error("ChatContextItem must have either a label or a resourceUri"));
+        }
         const itemHandle = this._addTrackedItem(handle, result);
         const item = {
             handle: itemHandle,
             icon: result.icon,
             label: result.label,
+            resourceUri: result.resourceUri,
             modelDescription: result.modelDescription,
             tooltip: result.tooltip ? MarkdownString.from(result.tooltip) : undefined,
             value: options.withValue ? result.value : undefined,
@@ -76,7 +87,7 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
             } : undefined
         };
         if (options.withValue && !item.value) {
-            const resolved = await provider.resolveChatContext(result, token);
+            const resolved = await (provider.resolveResourceChatContext ?? provider.resolveChatContext)?.bind(provider)(result, token);
             item.value = resolved?.value;
             item.tooltip = resolved?.tooltip ? MarkdownString.from(resolved.tooltip) : item.tooltip;
         }
@@ -92,7 +103,12 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
         if (!extItem) {
             throw ( new Error("Chat context item not found"));
         }
-        return this._doResolve(provider.resolveChatContext.bind(provider), context, extItem, token);
+        return this._doResolve(
+            (provider.resolveResourceChatContext ?? provider.resolveChatContext)?.bind(provider),
+            context,
+            extItem,
+            token
+        );
     }
     async $executeChatContextItemCommand(itemHandle) {
         const extItem = this._globalItems.get(itemHandle);
@@ -168,21 +184,21 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
         if (provider.provideWorkspaceChatContext) {
             const workspaceProvider = {
                 onDidChangeWorkspaceChatContext: provider.onDidChangeWorkspaceChatContext,
-                provideChatContext: token => provider.provideWorkspaceChatContext(token)
+                provideWorkspaceChatContext: token => provider.provideWorkspaceChatContext(token)
             };
             disposables.push(this.registerChatWorkspaceContextProvider(id, workspaceProvider));
         }
         if (provider.provideChatContextExplicit) {
             const explicitProvider = {
-                provideChatContext: token => provider.provideChatContextExplicit(token),
-                resolveChatContext: provider.resolveChatContext ? (context, token) => provider.resolveChatContext(context, token) : context => context
+                provideExplicitChatContext: token => provider.provideChatContextExplicit(token),
+                resolveExplicitChatContext: provider.resolveChatContext ? (context, token) => provider.resolveChatContext(context, token) : context => context
             };
             disposables.push(this.registerChatExplicitContextProvider(id, explicitProvider));
         }
         if (provider.provideChatContextForResource && selector) {
             const resourceProvider = {
-                provideChatContext: (options, token) => provider.provideChatContextForResource(options, token),
-                resolveChatContext: provider.resolveChatContext ? (context, token) => provider.resolveChatContext(context, token) : context => context
+                provideResourceChatContext: (options, token) => provider.provideChatContextForResource(options, token),
+                resolveResourceChatContext: provider.resolveChatContext ? (context, token) => provider.resolveChatContext(context, token) : context => context
             };
             disposables.push(this.registerChatResourceContextProvider(selector, id, resourceProvider));
         }
@@ -215,11 +231,15 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
     _convertItems(handle, items) {
         const result = [];
         for (const item of items) {
+            if (item.label === undefined && item.resourceUri === undefined) {
+                throw ( new Error("ChatContextItem must have either a label or a resourceUri"));
+            }
             const itemHandle = this._addTrackedItem(handle, item);
             result.push({
                 handle: itemHandle,
                 icon: item.icon,
                 label: item.label,
+                resourceUri: item.resourceUri,
                 modelDescription: item.modelDescription,
                 tooltip: item.tooltip ? MarkdownString.from(item.tooltip) : undefined,
                 value: item.value,
@@ -237,6 +257,7 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
                 handle: context.handle,
                 icon: extResult.icon,
                 label: extResult.label,
+                resourceUri: extResult.resourceUri,
                 modelDescription: extResult.modelDescription,
                 tooltip: extResult.tooltip ? MarkdownString.from(extResult.tooltip) : undefined,
                 value: extResult.value,
@@ -252,7 +273,7 @@ let ExtHostChatContext = class ExtHostChatContext extends Disposable {
             return;
         }
         const provideWorkspaceContext = async () => {
-            const workspaceContexts = await provider.provideChatContext(CancellationToken.None);
+            const workspaceContexts = ((await provider.provideWorkspaceChatContext?.(CancellationToken.None)) ?? (await provider.provideChatContext?.(CancellationToken.None)));
             const resolvedContexts = this._convertItems(handle, workspaceContexts ?? []);
             return this._proxy.$updateWorkspaceContextItems(handle, resolvedContexts);
         };

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

@@ -0,0 +1,22 @@
+import type * as vscode from "vscode";
+import { CancellationToken } from "../../../base/common/cancellation.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { UriComponents } from "../../../base/common/uri.js";
+import { ExtHostChatDebugShape, IChatDebugEventDto, IChatDebugResolvedEventContentDto } from "./extHost.protocol.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
+export declare class ExtHostChatDebug extends Disposable implements ExtHostChatDebugShape {
+    _serviceBrand: undefined;
+    private readonly _proxy;
+    private _provider;
+    private _nextHandle;
+    /** Progress pipelines keyed by `${handle}:${sessionResource}` so multiple sessions can stream concurrently. */
+    private readonly _activeProgress;
+    constructor(extHostRpc: IExtHostRpcService);
+    private _progressKey;
+    private _cleanupProgress;
+    registerChatDebugLogProvider(provider: vscode.ChatDebugLogProvider): vscode.Disposable;
+    $provideChatDebugLog(handle: number, sessionResource: UriComponents, token: CancellationToken): Promise<IChatDebugEventDto[] | undefined>;
+    private _serializeEvent;
+    $resolveChatDebugLogEvent(_handle: number, eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContentDto | undefined>;
+    dispose(): void;
+}

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

@@ -0,0 +1,287 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.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 { IExtHostRpcService } from './extHostRpcService.js';
+
+let ExtHostChatDebug = class ExtHostChatDebug extends Disposable {
+    constructor(extHostRpc) {
+        super();
+        this._nextHandle = 0;
+        this._activeProgress = ( new Map());
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadChatDebug));
+    }
+    _progressKey(handle, sessionResource) {
+        return `${handle}:${( URI.revive(sessionResource).toString())}`;
+    }
+    _cleanupProgress(key) {
+        const store = this._activeProgress.get(key);
+        if (store) {
+            store.dispose();
+            this._activeProgress.delete(key);
+        }
+    }
+    registerChatDebugLogProvider(provider) {
+        if (this._provider) {
+            throw ( new Error("A ChatDebugLogProvider is already registered."));
+        }
+        this._provider = provider;
+        const handle = this._nextHandle++;
+        this._proxy.$registerChatDebugLogProvider(handle);
+        return toDisposable(() => {
+            this._provider = undefined;
+            for (const [key, store] of this._activeProgress) {
+                if (key.startsWith(`${handle}:`)) {
+                    store.dispose();
+                    this._activeProgress.delete(key);
+                }
+            }
+            this._proxy.$unregisterChatDebugLogProvider(handle);
+        });
+    }
+    async $provideChatDebugLog(handle, sessionResource, token) {
+        if (!this._provider) {
+            return undefined;
+        }
+        const key = this._progressKey(handle, sessionResource);
+        this._cleanupProgress(key);
+        const store = ( new DisposableStore());
+        this._activeProgress.set(key, store);
+        const emitter = store.add(( new Emitter()));
+        store.add(emitter.event(event => {
+            const dto = this._serializeEvent(event);
+            if (!dto.sessionResource) {
+                dto.sessionResource = sessionResource;
+            }
+            this._proxy.$acceptChatDebugEvent(handle, dto);
+        }));
+        store.add(token.onCancellationRequested(() => {
+            this._cleanupProgress(key);
+        }));
+        try {
+            const progress = {
+                report: value => emitter.fire(value)
+            };
+            const sessionUri = URI.revive(sessionResource);
+            const result = await this._provider.provideChatDebugLog(sessionUri, progress, token);
+            if (!result) {
+                return undefined;
+            }
+            return ( result.map(event => this._serializeEvent(event)));
+        } catch (err) {
+            this._cleanupProgress(key);
+            throw err;
+        }
+    }
+    _serializeEvent(event) {
+        const base = {
+            id: event.id,
+            sessionResource: event.sessionResource,
+            created: event.created.getTime(),
+            parentEventId: event.parentEventId
+        };
+        const kind = event._kind;
+        switch (kind) {
+        case "toolCall":
+            {
+                const e = event;
+                return {
+                    ...base,
+                    kind: "toolCall",
+                    toolName: e.toolName,
+                    toolCallId: e.toolCallId,
+                    input: e.input,
+                    output: e.output,
+                    result: e.result === ChatDebugToolCallResult.Success ? "success" : e.result === ChatDebugToolCallResult.Error ? "error" : undefined,
+                    durationInMillis: e.durationInMillis
+                };
+            }
+        case "modelTurn":
+            {
+                const e = event;
+                return {
+                    ...base,
+                    kind: "modelTurn",
+                    model: e.model,
+                    requestName: e.requestName,
+                    inputTokens: e.inputTokens,
+                    outputTokens: e.outputTokens,
+                    totalTokens: e.totalTokens,
+                    durationInMillis: e.durationInMillis
+                };
+            }
+        case "generic":
+            {
+                const e = event;
+                return {
+                    ...base,
+                    kind: "generic",
+                    name: e.name,
+                    details: e.details,
+                    level: e.level,
+                    category: e.category
+                };
+            }
+        case "subagentInvocation":
+            {
+                const e = event;
+                return {
+                    ...base,
+                    kind: "subagentInvocation",
+                    agentName: e.agentName,
+                    description: e.description,
+                    status: e.status === ChatDebugSubagentStatus.Running ? "running" : e.status === ChatDebugSubagentStatus.Completed ? "completed" : e.status === ChatDebugSubagentStatus.Failed ? "failed" : undefined,
+                    durationInMillis: e.durationInMillis,
+                    toolCallCount: e.toolCallCount,
+                    modelTurnCount: e.modelTurnCount
+                };
+            }
+        case "userMessage":
+            {
+                const e = event;
+                return {
+                    ...base,
+                    kind: "userMessage",
+                    message: e.message,
+                    sections: ( e.sections.map(s => ({
+                        name: s.name,
+                        content: s.content
+                    })))
+                };
+            }
+        case "agentResponse":
+            {
+                const e = event;
+                return {
+                    ...base,
+                    kind: "agentResponse",
+                    message: e.message,
+                    sections: ( e.sections.map(s => ({
+                        name: s.name,
+                        content: s.content
+                    })))
+                };
+            }
+        default:
+            {
+                const generic = event;
+                const rawName = generic.name;
+                const rawDetails = generic.details;
+                return {
+                    ...base,
+                    kind: "generic",
+                    name: typeof rawName === "string" ? rawName : "",
+                    details: typeof rawDetails === "string" ? rawDetails : undefined,
+                    level: generic.level ?? 1,
+                    category: generic.category
+                };
+            }
+        }
+    }
+    async $resolveChatDebugLogEvent(_handle, eventId, token) {
+        if (!this._provider?.resolveChatDebugLogEvent) {
+            return undefined;
+        }
+        const result = await this._provider.resolveChatDebugLogEvent(eventId, token);
+        if (!result) {
+            return undefined;
+        }
+        const kind = result._kind;
+        switch (kind) {
+        case "text":
+            return {
+                kind: "text",
+                value: result.value
+            };
+        case "messageContent":
+            {
+                const msg = result;
+                return {
+                    kind: "message",
+                    type: msg.type === ChatDebugMessageContentType.User ? "user" : "agent",
+                    message: msg.message,
+                    sections: ( msg.sections.map(s => ({
+                        name: s.name,
+                        content: s.content
+                    })))
+                };
+            }
+        case "userMessage":
+            {
+                const msg = result;
+                return {
+                    kind: "message",
+                    type: "user",
+                    message: msg.message,
+                    sections: ( msg.sections.map(s => ({
+                        name: s.name,
+                        content: s.content
+                    })))
+                };
+            }
+        case "agentResponse":
+            {
+                const msg = result;
+                return {
+                    kind: "message",
+                    type: "agent",
+                    message: msg.message,
+                    sections: ( msg.sections.map(s => ({
+                        name: s.name,
+                        content: s.content
+                    })))
+                };
+            }
+        case "toolCallContent":
+            {
+                const tc = result;
+                return {
+                    kind: "toolCall",
+                    toolName: tc.toolName,
+                    result: tc.result === ChatDebugToolCallResult.Success ? "success" : tc.result === ChatDebugToolCallResult.Error ? "error" : undefined,
+                    durationInMillis: tc.durationInMillis,
+                    input: tc.input,
+                    output: tc.output
+                };
+            }
+        case "modelTurnContent":
+            {
+                const mt = result;
+                return {
+                    kind: "modelTurn",
+                    requestName: mt.requestName,
+                    model: mt.model,
+                    status: mt.status,
+                    durationInMillis: mt.durationInMillis,
+                    timeToFirstTokenInMillis: mt.timeToFirstTokenInMillis,
+                    maxInputTokens: mt.maxInputTokens,
+                    maxOutputTokens: mt.maxOutputTokens,
+                    inputTokens: mt.inputTokens,
+                    outputTokens: mt.outputTokens,
+                    cachedTokens: mt.cachedTokens,
+                    totalTokens: mt.totalTokens,
+                    errorMessage: mt.errorMessage,
+                    sections: mt.sections?.map(s => ({
+                        name: s.name,
+                        content: s.content
+                    }))
+                };
+            }
+        default:
+            return undefined;
+        }
+    }
+    dispose() {
+        for (const store of ( this._activeProgress.values())) {
+            store.dispose();
+        }
+        this._activeProgress.clear();
+        super.dispose();
+    }
+};
+ExtHostChatDebug = ( __decorate([( __param(0, IExtHostRpcService))], ExtHostChatDebug));
+
+export { ExtHostChatDebug };

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

@@ -4,12 +4,13 @@ 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 { IChatSessionItem, IChatSessionProviderOptionItem } from "../../contrib/chat/common/chatSessionsService.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 { ExtHostCommands } from "./extHostCommands.js";
 import { ExtHostLanguageModels } from "./extHostLanguageModels.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
+import * as typeConvert from "./extHostTypeConverters.js";
 export declare class ExtHostChatSessions extends Disposable implements ExtHostChatSessionsShape {
     private readonly commands;
     private readonly _languageModels;
@@ -17,18 +18,10 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
     private readonly _logService;
     private static _sessionHandlePool;
     private readonly _proxy;
-    private _itemProviderHandlePool;
-    private readonly _chatSessionItemProviders;
     private _itemControllerHandlePool;
     private readonly _chatSessionItemControllers;
     private _contentProviderHandlePool;
     private readonly _chatSessionContentProviders;
-    /**
-     * Map of uri -> chat session items
-     *
-     * TODO: this isn't cleared/updated properly
-     */
-    private readonly _sessionItems;
     /**
      * Map of uri -> chat sessions infos
      */
@@ -41,9 +34,6 @@ 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;
-    private convertChatSessionStatus;
-    private convertChatSessionItem;
-    $provideChatSessionItems(handle: number, token: vscode.CancellationToken): Promise<IChatSessionItem[]>;
     $provideChatSessionContent(handle: number, sessionResourceComponents: UriComponents, token: CancellationToken): Promise<ChatSessionDto>;
     $provideHandleOptionsChange(handle: number, sessionResourceComponents: UriComponents, updates: ReadonlyArray<{
         optionId: string;
@@ -58,5 +48,7 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
     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>;
     $onDidChangeChatSessionItemState(controllerHandle: number, sessionResourceComponents: UriComponents, archived: boolean): void;
 }