@codingame/monaco-vscode-extensions-service-override 28.4.1 → 29.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadBrowsers.js

@@ -0,0 +1,147 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { IBrowserViewCDPService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserView.service';
+import { BrowserViewUri } from '../../../platform/browserView/common/browserViewUri.js';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { columnToEditorGroup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { BrowserEditorInput } from '../../contrib/browserView/common/browserEditorInput.js';
+
+let MainThreadBrowsers = class MainThreadBrowsers extends Disposable {
+    constructor(
+        extHostContext,
+        editorService,
+        cdpService,
+        editorGroupsService,
+        configurationService
+    ) {
+        super();
+        this.editorService = editorService;
+        this.cdpService = cdpService;
+        this.editorGroupsService = editorGroupsService;
+        this.configurationService = configurationService;
+        this._cdpSessions = this._register(( new DisposableMap()));
+        this._knownBrowsers = this._register(( new DisposableMap()));
+        this._lastActiveBrowserId = undefined;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostBrowsers));
+        this._register(this.editorService.onWillOpenEditor(e => {
+            if (e.editor instanceof BrowserEditorInput) {
+                this._track(e.editor);
+            }
+        }));
+        this._register(
+            this.editorService.onDidActiveEditorChange(() => this._syncActiveBrowserTab())
+        );
+        for (const input of this.editorService.editors) {
+            if (input instanceof BrowserEditorInput) {
+                this._track(input);
+            }
+        }
+        this._syncActiveBrowserTab();
+    }
+    async $openBrowserTab(url, viewColumn, options) {
+        const id = generateUuid();
+        const browserUri = BrowserViewUri.forId(id);
+        await this.editorService.openEditor({
+            resource: browserUri,
+            options: {
+                ...options,
+                viewState: {
+                    url
+                }
+            }
+        }, columnToEditorGroup(this.editorGroupsService, this.configurationService, viewColumn));
+        const known = this._knownBrowsers.get(id);
+        if (!known) {
+            throw ( new Error("Failed to open browser tab"));
+        }
+        return this._toDto(known.input);
+    }
+    async _syncActiveBrowserTab() {
+        const active = this.editorService.activeEditorPane?.input;
+        let activeId;
+        if (active instanceof BrowserEditorInput) {
+            this._track(active);
+            activeId = active.id;
+        }
+        if (this._lastActiveBrowserId !== activeId) {
+            this._lastActiveBrowserId = activeId;
+            this._proxy.$onDidChangeActiveBrowserTab(activeId);
+        }
+    }
+    _track(input) {
+        if (( this._knownBrowsers.has(input.id))) {
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        disposables.add(input.onDidChangeLabel(() => {
+            this._proxy.$onDidChangeBrowserTabState(this._toDto(input));
+        }));
+        disposables.add(input.onWillDispose(() => {
+            this._knownBrowsers.deleteAndDispose(input.id);
+        }));
+        disposables.add(toDisposable(() => {
+            this._proxy.$onDidCloseBrowserTab(input.id);
+        }));
+        this._knownBrowsers.set(input.id, {
+            input,
+            dispose: () => disposables.dispose()
+        });
+        this._proxy.$onDidOpenBrowserTab(this._toDto(input));
+    }
+    _toDto(input) {
+        return {
+            id: input.id,
+            url: input.url || "about:blank",
+            title: input.getTitle(),
+            favicon: input.favicon
+        };
+    }
+    async $startCDPSession(sessionId, browserId) {
+        const known = this._knownBrowsers.get(browserId);
+        if (!known) {
+            throw ( new Error(`Unknown browser id: ${browserId}`));
+        }
+        await known.input.resolve();
+        const groupId = await this.cdpService.createSessionGroup(browserId);
+        const disposables = ( new DisposableStore());
+        disposables.add(this.cdpService.onCDPMessage(groupId)(message => {
+            this._proxy.$onCDPSessionMessage(sessionId, message);
+        }));
+        disposables.add(this.cdpService.onDidDestroy(groupId)(() => {
+            this._cdpSessions.deleteAndDispose(sessionId);
+        }));
+        disposables.add(toDisposable(() => {
+            this.cdpService.destroySessionGroup(groupId).catch(() => {});
+            this._proxy.$onCDPSessionClosed(sessionId);
+        }));
+        this._cdpSessions.set(sessionId, {
+            groupId,
+            dispose: () => disposables.dispose()
+        });
+    }
+    async $closeCDPSession(sessionId) {
+        this._cdpSessions.deleteAndDispose(sessionId);
+    }
+    async $sendCDPMessage(sessionId, message) {
+        const session = this._cdpSessions.get(sessionId);
+        if (session) {
+            await this.cdpService.sendCDPMessage(session.groupId, message);
+        }
+    }
+    async $closeBrowserTab(browserId) {
+        const known = this._knownBrowsers.get(browserId);
+        if (!known) {
+            throw ( new Error(`Unknown browser id: ${browserId}`));
+        }
+        known.input.dispose();
+    }
+};
+MainThreadBrowsers = __decorate([extHostNamedCustomer(MainContext.MainThreadBrowsers), ( __param(1, IEditorService)), ( __param(2, IBrowserViewCDPService)), ( __param(3, IEditorGroupsService)), ( __param(4, IConfigurationService))], MainThreadBrowsers);
+
+export { MainThreadBrowsers };

package/vscode/src/vs/workbench/api/browser/mainThreadCLICommands.js

@@ -108,7 +108,7 @@ let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends Ex
         if (
         !this._extensionManifestPropertiesService.canExecuteOnWorkspace(manifest) && !(isWeb && this._extensionManifestPropertiesService.canExecuteOnWeb(manifest))) {
             this.logger.info(( localize(
-                2545,
+                2553,
                 "Cannot install the '{0}' extension because it is declared to not run in this setup.",
                 getExtensionId(manifest.publisher, manifest.name)
             )));

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js

@@ -25,6 +25,7 @@ import { ChatRequestAgentPart } from '@codingame/monaco-vscode-api/vscode/vs/wor
 import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
 import { getDynamicVariablesForWidget, getSelectedToolAndToolSetsForWidget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatVariables';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatSessionOptionsMap } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
@@ -32,6 +33,7 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { NotebookDto } from './mainThreadNotebookDto.js';
+import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { addDynamicVariableActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
 import { getAgentSessionProvider, AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
 
@@ -217,29 +219,12 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     const contributedSession = chatSession?.contributedChatSession;
                     let chatSessionContext;
                     if (contributedSession) {
-                        let chatSessionResource = contributedSession.chatSessionResource;
-                        let isUntitled = contributedSession.isUntitled;
-                        if (isUntitled) {
-                            const newItem = await this._chatSessionService.createNewChatSessionItem(contributedSession.chatSessionType, request, token);
-                            if (newItem) {
-                                chatSessionResource = newItem.resource;
-                                isUntitled = false;
-                                chatSession?.setContributedChatSession({
-                                    chatSessionType: contributedSession.chatSessionType,
-                                    chatSessionResource,
-                                    isUntitled: false,
-                                    initialSessionOptions: contributedSession.initialSessionOptions
-                                });
-                                this._chatSessionService.registerSessionResourceAlias(contributedSession.chatSessionResource, chatSessionResource);
-                            }
-                        }
+                        const chatSessionResource = contributedSession.chatSessionResource;
+                        const isUntitled = isUntitledChatSession(chatSessionResource);
                         chatSessionContext = {
                             chatSessionResource,
                             isUntitled,
-                            initialSessionOptions: contributedSession.initialSessionOptions?.map(o => ({
-                                optionId: o.optionId,
-                                value: typeof o.value === "string" ? o.value : o.value.id
-                            }))
+                            initialSessionOptions: ChatSessionOptionsMap.toStrValueArray(contributedSession.initialSessionOptions)
                         };
                     }
                     return (await this._proxy.$invokeAgent(handle, request, {
@@ -367,6 +352,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                         kind: "usage",
                         promptTokens: progress.promptTokens,
                         completionTokens: progress.completionTokens,
+                        outputBuffer: progress.outputBuffer,
                         promptTokenDetails: progress.promptTokenDetails
                     });
                 }

package/vscode/src/vs/workbench/api/browser/mainThreadChatDebug.d.ts

@@ -1,15 +1,22 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { IChatDebugEventDto, MainThreadChatDebugShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 export declare class MainThreadChatDebug extends Disposable implements MainThreadChatDebugShape {
     private readonly _chatDebugService;
+    private readonly _chatService;
     private readonly _proxy;
     private readonly _providerDisposables;
     private readonly _activeSessionResources;
-    constructor(extHostContext: IExtHostContext, _chatDebugService: IChatDebugService);
+    private readonly _coreEventForwarder;
+    constructor(extHostContext: IExtHostContext, _chatDebugService: IChatDebugService, _chatService: IChatService);
+    $subscribeToCoreDebugEvents(): void;
+    $unsubscribeFromCoreDebugEvents(): void;
     $registerChatDebugLogProvider(handle: number): void;
     $unregisterChatDebugLogProvider(handle: number): void;
     $acceptChatDebugEvent(handle: number, dto: IChatDebugEventDto): void;
+    private _serializeEvent;
     private _reviveEvent;
+    private _reviveResolvedContent;
 }

package/vscode/src/vs/workbench/api/browser/mainThreadChatDebug.js

@@ -1,19 +1,34 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { ChatDebugHookResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
 import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 
 let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
-    constructor(extHostContext, _chatDebugService) {
+    constructor(extHostContext, _chatDebugService, _chatService) {
         super();
         this._chatDebugService = _chatDebugService;
+        this._chatService = _chatService;
         this._providerDisposables = ( new Map());
         this._activeSessionResources = ( new Map());
+        this._coreEventForwarder = this._register(( new MutableDisposable()));
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatDebug));
     }
+    $subscribeToCoreDebugEvents() {
+        this._coreEventForwarder.value = this._chatDebugService.onDidAddEvent(event => {
+            if (this._chatDebugService.isCoreEvent(event)) {
+                this._proxy.$onCoreDebugEvent(this._serializeEvent(event));
+            }
+        });
+    }
+    $unsubscribeFromCoreDebugEvents() {
+        this._coreEventForwarder.clear();
+    }
     $registerChatDebugLogProvider(handle) {
         const disposables = ( new DisposableStore());
         this._providerDisposables.set(handle, disposables);
@@ -24,7 +39,25 @@ let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
                 return dtos?.map(dto => this._reviveEvent(dto, sessionResource));
             },
             resolveChatDebugLogEvent: async (eventId, token) => {
-                return this._proxy.$resolveChatDebugLogEvent(handle, eventId, token);
+                const dto = await this._proxy.$resolveChatDebugLogEvent(handle, eventId, token);
+                return dto ? this._reviveResolvedContent(dto) : undefined;
+            },
+            provideChatDebugLogExport: async (sessionResource, token) => {
+                const coreEventDtos = ( this._chatDebugService.getEvents(sessionResource).filter(e => this._chatDebugService.isCoreEvent(e)).map(e => this._serializeEvent(e)));
+                const sessionTitle = this._chatService.getSessionTitle(sessionResource);
+                const result = await this._proxy.$exportChatDebugLog(handle, sessionResource, coreEventDtos, sessionTitle, token);
+                return result?.buffer;
+            },
+            resolveChatDebugLogImport: async (data, token) => {
+                const result = await this._proxy.$importChatDebugLog(handle, VSBuffer.wrap(data), token);
+                if (!result) {
+                    return undefined;
+                }
+                const uri = URI.revive(result.uri);
+                if (result.sessionTitle) {
+                    this._chatDebugService.setImportedSessionTitle(uri, result.sessionTitle);
+                }
+                return uri;
             }
         }));
     }
@@ -42,6 +75,78 @@ let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
         const revived = this._reviveEvent(dto, sessionResource);
         this._chatDebugService.addProviderEvent(revived);
     }
+    _serializeEvent(event) {
+        const base = {
+            id: event.id,
+            sessionResource: event.sessionResource,
+            created: event.created.getTime(),
+            parentEventId: event.parentEventId
+        };
+        switch (event.kind) {
+        case "toolCall":
+            return {
+                ...base,
+                kind: "toolCall",
+                toolName: event.toolName,
+                toolCallId: event.toolCallId,
+                input: event.input,
+                output: event.output,
+                result: event.result,
+                durationInMillis: event.durationInMillis
+            };
+        case "modelTurn":
+            return {
+                ...base,
+                kind: "modelTurn",
+                model: event.model,
+                requestName: event.requestName,
+                inputTokens: event.inputTokens,
+                outputTokens: event.outputTokens,
+                totalTokens: event.totalTokens,
+                durationInMillis: event.durationInMillis
+            };
+        case "generic":
+            return {
+                ...base,
+                kind: "generic",
+                name: event.name,
+                details: event.details,
+                level: event.level,
+                category: event.category
+            };
+        case "subagentInvocation":
+            return {
+                ...base,
+                kind: "subagentInvocation",
+                agentName: event.agentName,
+                description: event.description,
+                status: event.status,
+                durationInMillis: event.durationInMillis,
+                toolCallCount: event.toolCallCount,
+                modelTurnCount: event.modelTurnCount
+            };
+        case "userMessage":
+            return {
+                ...base,
+                kind: "userMessage",
+                message: event.message,
+                sections: ( event.sections.map(s => ({
+                    name: s.name,
+                    content: s.content
+                })))
+            };
+        case "agentResponse":
+            return {
+                ...base,
+                kind: "agentResponse",
+                message: event.message,
+                sections: ( event.sections.map(s => ({
+                    name: s.name,
+                    content: s.content
+                })))
+            };
+        }
+    }
     _reviveEvent(dto, sessionResource) {
         const base = {
             id: dto.id,
@@ -108,7 +213,58 @@ let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
             };
         }
     }
+    _reviveResolvedContent(dto) {
+        switch (dto.kind) {
+        case "text":
+            return {
+                kind: "text",
+                value: dto.value
+            };
+        case "message":
+            return {
+                kind: "message",
+                type: dto.type,
+                message: dto.message,
+                sections: dto.sections
+            };
+        case "toolCall":
+            return {
+                kind: "toolCall",
+                toolName: dto.toolName,
+                result: dto.result,
+                durationInMillis: dto.durationInMillis,
+                input: dto.input,
+                output: dto.output
+            };
+        case "modelTurn":
+            return {
+                kind: "modelTurn",
+                requestName: dto.requestName,
+                model: dto.model,
+                status: dto.status,
+                durationInMillis: dto.durationInMillis,
+                inputTokens: dto.inputTokens,
+                outputTokens: dto.outputTokens,
+                cachedTokens: dto.cachedTokens,
+                totalTokens: dto.totalTokens,
+                errorMessage: dto.errorMessage,
+                sections: dto.sections
+            };
+        case "hook":
+            return {
+                kind: "hook",
+                hookType: dto.hookType,
+                command: dto.command,
+                result: dto.result === "success" ? ChatDebugHookResult.Success : dto.result === "error" ? ChatDebugHookResult.Error : dto.result === "nonBlockingError" ? ChatDebugHookResult.NonBlockingError : undefined,
+                durationInMillis: dto.durationInMillis,
+                input: dto.input,
+                output: dto.output,
+                exitCode: dto.exitCode,
+                errorMessage: dto.errorMessage
+            };
+        }
+    }
 };
-MainThreadChatDebug = __decorate([extHostNamedCustomer(MainContext.MainThreadChatDebug), ( __param(1, IChatDebugService))], MainThreadChatDebug);
+MainThreadChatDebug = __decorate([extHostNamedCustomer(MainContext.MainThreadChatDebug), ( __param(1, IChatDebugService)), ( __param(2, IChatService))], MainThreadChatDebug);
 
 export { MainThreadChatDebug };

package/vscode/src/vs/workbench/api/browser/mainThreadChatSessions.d.ts

@@ -3,27 +3,30 @@ import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI, UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
 import { IChatContentInlineReference, IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
-import { IChatSession, IChatSessionHistoryItem, IChatSessionItem, IChatSessionProviderOptionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSession, IChatSessionHistoryItem, IChatSessionItem, IChatSessionProviderOptionItem, IChatSessionRequestHistoryItem, ReadonlyChatSessionOptionsMap } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
 import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
 import { IChatAgentRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+import { IChatArtifactsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service";
 import { IChatTodoListService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service";
 import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { Dto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
-import { ExtHostChatSessionsShape, IChatProgressDto, IChatSessionItemsChange, MainThreadChatSessionsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { ChatSessionContentContextDto, ExtHostChatSessionsShape, IChatProgressDto, IChatSessionItemsChange, MainThreadChatSessionsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 export declare class ObservableChatSession extends Disposable implements IChatSession {
     readonly sessionResource: URI;
     readonly providerHandle: number;
     readonly history: Array<IChatSessionHistoryItem>;
     title?: string;
     private _options?;
-    get options(): Record<string, string | IChatSessionProviderOptionItem> | undefined;
+    get options(): ReadonlyChatSessionOptionsMap | undefined;
     private readonly _progressObservable;
     private readonly _isCompleteObservable;
     private readonly _onWillDispose;
@@ -35,6 +38,7 @@ export declare class ObservableChatSession extends Disposable implements IChatSe
     private _initializationPromise?;
     interruptActiveResponseCallback?: () => Promise<boolean>;
     requestHandler?: (request: IChatAgentRequest, progress: (progress: IChatProgress[]) => void, history: any[], token: CancellationToken) => Promise<void>;
+    forkSession?: (request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken) => Promise<IChatSessionItem>;
     private readonly _proxy;
     private readonly _providerHandle;
     private readonly _logService;
@@ -42,7 +46,7 @@ export declare class ObservableChatSession extends Disposable implements IChatSe
     get progressObs(): IObservable<IChatProgress[]>;
     get isCompleteObs(): IObservable<boolean>;
     constructor(resource: URI, providerHandle: number, proxy: ExtHostChatSessionsShape, logService: ILogService, dialogService: IDialogService);
-    initialize(token: CancellationToken): Promise<void>;
+    initialize(token: CancellationToken, context: ChatSessionContentContextDto): Promise<void>;
     private _doInitializeContent;
     /**
      * Handle progress chunks coming from the extension host.
@@ -55,6 +59,7 @@ export declare class ObservableChatSession extends Disposable implements IChatSe
     handleProgressComplete(requestId: string): void;
     private _addProgress;
     private _markComplete;
+    private toRequestDto;
     dispose(): void;
 }
 export declare class MainThreadChatSessions extends Disposable implements MainThreadChatSessionsShape {
@@ -64,29 +69,32 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     private readonly _chatService;
     private readonly _chatWidgetService;
     private readonly _chatTodoListService;
+    private readonly _chatArtifactsService;
+    private readonly _chatDebugService;
     private readonly _dialogService;
     private readonly _editorService;
     private readonly editorGroupService;
     private readonly _logService;
+    private readonly _instantiationService;
     private readonly _itemControllerRegistrations;
     private readonly _contentProvidersRegistrations;
     private readonly _sessionTypeToHandle;
     private readonly _activeSessions;
     private readonly _sessionDisposables;
     private readonly _proxy;
-    constructor(_extHostContext: IExtHostContext, _agentSessionsService: IAgentSessionsService, _chatSessionsService: IChatSessionsService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _chatTodoListService: IChatTodoListService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService);
+    constructor(_extHostContext: IExtHostContext, _agentSessionsService: IAgentSessionsService, _chatSessionsService: IChatSessionsService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _chatTodoListService: IChatTodoListService, _chatArtifactsService: IChatArtifactsService, _chatDebugService: IChatDebugService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService, _instantiationService: IInstantiationService);
     private _getHandleForSessionType;
     $registerChatSessionItemController(handle: number, chatSessionType: string): void;
     private getController;
-    $onDidChangeChatSessionItems(handle: number): void;
     private _resolveSessionItem;
     $updateChatSessionItems(controllerHandle: number, change: IChatSessionItemsChange): Promise<void>;
     $addOrUpdateChatSessionItem(controllerHandle: number, item: Dto<IChatSessionItem>): Promise<void>;
-    $onDidChangeChatSessionOptions(handle: number, sessionResourceComponents: UriComponents, updates: ReadonlyArray<{
-        optionId: string;
-        value: string;
-    }>): void;
+    $onDidChangeChatSessionOptions(handle: number, sessionResourceComponents: UriComponents, updates: Record<string, string | IChatSessionProviderOptionItem>): void;
     $onDidCommitChatSessionItem(handle: number, originalComponents: UriComponents, modifiedCompoennts: UriComponents): Promise<void>;
+    /**
+     * Re-sends pending and in-flight requests from the original session on the committed session.
+     */
+    private _resendPendingRequests;
     private handleSessionModelOverrides;
     private _provideChatSessionContent;
     $unregisterChatSessionItemController(handle: number): void;
@@ -105,8 +113,5 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     /**
      * Notify the extension about option changes for a session
      */
-    notifyOptionsChange(handle: number, sessionResource: URI, updates: ReadonlyArray<{
-        optionId: string;
-        value: string | IChatSessionProviderOptionItem | undefined;
-    }>): Promise<void>;
+    notifyOptionsChange(handle: number, sessionResource: URI, updates: ReadonlyMap<string, string | IChatSessionProviderOptionItem | undefined>): Promise<void>;
 }