@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/chatSessions.contribution.js

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { sep } from '../../../../../base/common/path.js';
-import { AsyncIterableProducer, raceCancellationError } from '../../../../../base/common/async.js';
+import { AsyncIterableProducer, raceCancellationError, DeferredPromise } from '../../../../../base/common/async.js';
 import { CancellationToken, CancellationTokenSource } from '../../../../../base/common/cancellation.js';
 import { Codicon } from '../../../../../base/common/codicons.js';
 import { Emitter, Event } from '../../../../../base/common/event.js';
@@ -20,6 +20,7 @@ import '../../../../../platform/instantiation/common/extensions.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { ILabelService } from '../../../../../platform/label/common/label.service.js';
 import { ILogService } from '../../../../../platform/log/common/log.service.js';
+import { IProgressService } from '../../../../../platform/progress/common/progress.service.js';
 import { Registry } from '../../../../../platform/registry/common/platform.js';
 import { isDark } from '../../../../../platform/theme/common/theme.js';
 import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
@@ -30,7 +31,7 @@ import { ExtensionsRegistry } from '../../../../services/extensions/common/exten
 import { ChatEditorInput } from '../widgetHosts/editor/chatEditorInput.js';
 import { IChatAgentService } from '../../common/participants/chatAgents.service.js';
 import { ChatContextKeys } from '../../common/actions/chatContextKeys.js';
-import { ChatSessionsExtensions, isSessionInProgressStatus, localChatSessionType, ChatSessionOptionsMap, ChatSessionStatus } from '../../common/chatSessionsService.js';
+import { SessionType, ChatSessionsExtensions, isSessionInProgressStatus, localChatSessionType, ChatSessionOptionsMap, ChatSessionStatus } from '../../common/chatSessionsService.js';
 import { IChatSessionsService } from '../../common/chatSessionsService.service.js';
 import { ChatAgentLocation, ChatModeKind } from '../../common/constants.js';
 import { CHAT_CATEGORY } from '../actions/chatActions.js';
@@ -41,6 +42,7 @@ import { toPromptFileVariableEntry, PromptFileVariableKind } from '../../common/
 import { IViewsService } from '../../../../services/views/common/viewsService.service.js';
 import { ChatViewId } from '../chat.js';
 import { AgentSessionProviders, getAgentSessionProviderName, getAgentSessionProvider } from '../agentSessions/agentSessions.js';
+import { IAgentHostImportConversationStore } from '../agentSessions/agentHost/agentHostImportConversationStore.service.js';
 import { isCancellationError, BugIndicatingError } from '../../../../../base/common/errors.js';
 import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.service.js';
 import { getChatSessionType, isUntitledChatSession, LocalChatSessionUri } from '../../common/model/chatUri.js';
@@ -52,45 +54,48 @@ import { OffsetRange } from '../../../../../editor/common/core/ranges/offsetRang
 import { ILanguageModelToolsService } from '../../common/tools/languageModelToolsService.service.js';
 import { ICustomizationHarnessService } from '../../common/customizationHarnessService.service.js';
 import { generateUuid } from '../../../../../base/common/uuid.js';
+import { AGENT_HOST_ENABLED_CONTEXT_KEY } from '../../../../../platform/agentHost/common/agentHostEnablementService.js';
+import { AgentHostCodexAgentEnabledSettingId, CodexPreferAgentHostEditorSettingId } from '../../../../../platform/agentHost/common/agentService.js';
+import { IsSessionsWindowContext } from '../../../../common/contextkeys.js';
 import { observableFromEvent } from '../../../../../base/common/observableInternal/observables/observableFromEvent.js';
 import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
 
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatSessions",
     jsonSchema: {
-        description: ( localize(7180, "Contributes chat session integrations to the chat widget.")),
+        description: ( localize(8409, "Contributes chat session integrations to the chat widget.")),
         type: "array",
         items: {
             type: "object",
             additionalProperties: false,
             properties: {
                 type: {
-                    description: ( localize(7181, "Unique identifier for the type of chat session.")),
+                    description: ( localize(8410, "Unique identifier for the type of chat session.")),
                     type: "string"
                 },
                 name: {
                     description: ( localize(
-                        7182,
+                        8411,
                         "Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 displayName: {
-                    description: ( localize(7183, "A longer name for this item which is used for display in menus.")),
+                    description: ( localize(8412, "A longer name for this item which is used for display in menus.")),
                     type: "string"
                 },
                 description: {
-                    description: ( localize(7184, "Description of the chat session for use in menus and tooltips.")),
+                    description: ( localize(8413, "Description of the chat session for use in menus and tooltips.")),
                     type: "string"
                 },
                 when: {
-                    description: ( localize(7185, "Condition which must be true to show this item.")),
+                    description: ( localize(8414, "Condition which must be true to show this item.")),
                     type: "string"
                 },
                 icon: {
                     description: ( localize(
-                        7186,
+                        8415,
                         "Icon identifier (codicon ID) for the chat session editor tab. For example, \"{0}\" or \"{1}\".",
                         "$(github)",
                         "$(cloud)"
@@ -101,22 +106,22 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(7187, "Icon path when a light theme is used")),
+                                description: ( localize(8416, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(7188, "Icon path when a dark theme is used")),
+                                description: ( localize(8417, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
                     }]
                 },
                 order: {
-                    description: ( localize(7189, "Order in which this item should be displayed.")),
+                    description: ( localize(8418, "Order in which this item should be displayed.")),
                     type: "integer"
                 },
                 alternativeIds: {
-                    description: ( localize(7190, "Alternative identifiers for backward compatibility.")),
+                    description: ( localize(8419, "Alternative identifiers for backward compatibility.")),
                     type: "array",
                     items: {
                         type: "string"
@@ -124,95 +129,95 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 welcomeTitle: {
                     description: ( localize(
-                        7191,
+                        8420,
                         "Title text to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeMessage: {
                     description: ( localize(
-                        7192,
+                        8421,
                         "Message text (supports markdown) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeTips: {
                     description: ( localize(
-                        7193,
+                        8422,
                         "Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 inputPlaceholder: {
                     description: ( localize(
-                        7194,
+                        8423,
                         "Placeholder text to display in the chat input box for this session type."
                     )),
                     type: "string"
                 },
                 capabilities: {
-                    description: ( localize(7195, "Optional capabilities for this chat session.")),
+                    description: ( localize(8424, "Optional capabilities for this chat session.")),
                     type: "object",
                     additionalProperties: false,
                     properties: {
                         supportsFileAttachments: {
                             description: ( localize(
-                                7196,
+                                8425,
                                 "Whether this chat session supports attaching files or file references."
                             )),
                             type: "boolean"
                         },
                         supportsToolAttachments: {
                             description: ( localize(
-                                7197,
+                                8426,
                                 "Whether this chat session supports attaching tools or tool references."
                             )),
                             type: "boolean"
                         },
                         supportsMCPAttachments: {
-                            description: ( localize(7198, "Whether this chat session supports attaching MCP resources.")),
+                            description: ( localize(8427, "Whether this chat session supports attaching MCP resources.")),
                             type: "boolean"
                         },
                         supportsImageAttachments: {
-                            description: ( localize(7199, "Whether this chat session supports attaching images.")),
+                            description: ( localize(8428, "Whether this chat session supports attaching images.")),
                             type: "boolean"
                         },
                         supportsSearchResultAttachments: {
-                            description: ( localize(7200, "Whether this chat session supports attaching search results.")),
+                            description: ( localize(8429, "Whether this chat session supports attaching search results.")),
                             type: "boolean"
                         },
                         supportsInstructionAttachments: {
-                            description: ( localize(7201, "Whether this chat session supports attaching instructions.")),
+                            description: ( localize(8430, "Whether this chat session supports attaching instructions.")),
                             type: "boolean"
                         },
                         supportsSourceControlAttachments: {
                             description: ( localize(
-                                7202,
+                                8431,
                                 "Whether this chat session supports attaching source control changes."
                             )),
                             type: "boolean"
                         },
                         supportsProblemAttachments: {
-                            description: ( localize(7203, "Whether this chat session supports attaching problems.")),
+                            description: ( localize(8432, "Whether this chat session supports attaching problems.")),
                             type: "boolean"
                         },
                         supportsSymbolAttachments: {
-                            description: ( localize(7204, "Whether this chat session supports attaching symbols.")),
+                            description: ( localize(8433, "Whether this chat session supports attaching symbols.")),
                             type: "boolean"
                         },
                         supportsPromptAttachments: {
-                            description: ( localize(7205, "Whether this chat session supports attaching prompts.")),
+                            description: ( localize(8434, "Whether this chat session supports attaching prompts.")),
                             type: "boolean"
                         },
                         supportsHandOffs: {
-                            description: ( localize(7206, "Whether this chat session supports hand-off prompts.")),
+                            description: ( localize(8435, "Whether this chat session supports hand-off prompts.")),
                             type: "boolean"
                         }
                     }
                 },
                 commands: {
                     markdownDescription: ( localize(
-                        7207,
+                        8436,
                         "Commands available for this chat session, which the user can invoke with a `/`."
                     )),
                     type: "array",
@@ -229,17 +234,17 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         properties: {
                             name: {
                                 description: ( localize(
-                                    7208,
+                                    8437,
                                     "A short name by which this command is referred to in the UI, e.g. `fix` or `explain` for commands that fix an issue or explain code. The name should be unique among the commands provided by this participant."
                                 )),
                                 type: "string"
                             },
                             description: {
-                                description: ( localize(7209, "A description of this command.")),
+                                description: ( localize(8438, "A description of this command.")),
                                 type: "string"
                             },
                             when: {
-                                description: ( localize(7210, "A condition which must be true to enable this command.")),
+                                description: ( localize(8439, "A condition which must be true to enable this command.")),
                                 type: "string"
                             }
                         }
@@ -247,7 +252,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 canDelegate: {
                     description: ( localize(
-                        7211,
+                        8440,
                         "Whether delegation is supported. Default is false. Note that enabling this is experimental and may not be respected at all times."
                     )),
                     type: "boolean",
@@ -255,14 +260,14 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 customAgentTarget: {
                     description: ( localize(
-                        7212,
+                        8441,
                         "When set, the chat session will show a filtered mode picker that prefers custom agents whose target property matches this value. Custom agents without a target property are still shown in all session types. This enables the use of standard agent/mode with contributed sessions."
                     )),
                     type: "string"
                 },
                 requiresCustomModels: {
                     description: ( localize(
-                        7213,
+                        8442,
                         "When set, the chat session will show a filtered model picker that prefers custom models. This enables the use of standard model picker with contributed sessions."
                     )),
                     type: "boolean",
@@ -270,7 +275,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 supportsAutoModel: {
                     description: ( localize(
-                        7214,
+                        8443,
                         "Whether the chat session supports the synthetic \"Auto\" model fallback. Defaults to false. When true and no models are available, the picker shows \"Auto\" instead of a \"No models available\" state."
                     )),
                     type: "boolean",
@@ -278,7 +283,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 requiresCopilotSignIn: {
                     description: ( localize(
-                        7215,
+                        8444,
                         "Whether the chat session relies on a GitHub Copilot account and so cannot be used until the user signs in. Defaults to false."
                     )),
                     type: "boolean",
@@ -286,7 +291,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 autoAttachReferences: {
                     description: ( localize(
-                        7216,
+                        8445,
                         "Whether to automatically attach instruction files to chat requests for this session type."
                     )),
                     type: "boolean",
@@ -294,7 +299,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 useRequestToPopulateBuiltInPickers: {
                     description: ( localize(
-                        7217,
+                        8446,
                         "Whether to use ChatRequestTurn2 to populate built-in pickers such as the Agent and Model pickers."
                     )),
                     type: "boolean",
@@ -310,6 +315,17 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
         }
     }
 });
+const codexExtensionHostAvailableWhen = ( ContextKeyExpr.and(( IsSessionsWindowContext.negate()), ( ContextKeyExpr.or(( AGENT_HOST_ENABLED_CONTEXT_KEY.negate()), ContextKeyExpr.not(`config.${AgentHostCodexAgentEnabledSettingId}`), ContextKeyExpr.not(`config.${CodexPreferAgentHostEditorSettingId}`)))));
+function applyCodexAgentHostPreference(contribution) {
+    if (contribution.type !== SessionType.Codex) {
+        return contribution;
+    }
+    const contributedWhen = contribution.when ? ContextKeyExpr.deserialize(contribution.when) : undefined;
+    return {
+        ...contribution,
+        when: ( ContextKeyExpr.and(contributedWhen, codexExtensionHostAvailableWhen))?.serialize()
+    };
+}
 class ContributedChatSessionData extends Disposable {
     getOption(optionId) {
         return this._optionsCache.get(optionId);
@@ -389,13 +405,14 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         this._sessions = ( new ResourceMap());
         this._resourceAliases = ( new ResourceMap());
         this._realResources = ( new ResourceMap());
+        this._pendingSessionResolutions = ( new Map());
         this._customizationsProviders = ( new Map());
         this._onDidChangeCustomizations = this._register(( new Emitter()));
         this.onDidChangeCustomizations = this._onDidChangeCustomizations.event;
         this._hasCanDelegateProvidersKey = ChatContextKeys.hasCanDelegateProviders.bindTo(this._contextKeyService);
         this._register(extensionPoint.setHandler(extensions => {
             for (const ext of extensions) {
-                if (!isProposedApiEnabled(ext.description)) {
+                if (!isProposedApiEnabled(ext.description, "chatSessionsProvider")) {
                     continue;
                 }
                 if (!Array.isArray(ext.value)) {
@@ -468,12 +485,39 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         return entry.controller.resolveChatSessionItem(resource, token);
     }
+    canSetChatSessionItemArchived(sessionResource) {
+        return typeof this._getChatSessionItemController(sessionResource)?.controller.setChatSessionItemArchived === "function";
+    }
+    setChatSessionItemArchived(sessionResource, archived) {
+        const controller = this._getChatSessionItemController(sessionResource)?.controller;
+        if (!controller?.setChatSessionItemArchived) {
+            throw ( new Error(`Session ${( sessionResource.toString())} does not support archiving`));
+        }
+        controller.setChatSessionItemArchived(sessionResource, archived);
+    }
+    canSetChatSessionItemRead(sessionResource) {
+        return typeof this._getChatSessionItemController(sessionResource)?.controller.setChatSessionItemRead === "function";
+    }
+    setChatSessionItemRead(sessionResource, isRead) {
+        const controller = this._getChatSessionItemController(sessionResource)?.controller;
+        if (!controller?.setChatSessionItemRead) {
+            throw ( new Error(`Session ${( sessionResource.toString())} does not own read state`));
+        }
+        controller.setChatSessionItemRead(sessionResource, isRead);
+    }
     async updateInProgressStatus(chatSessionType) {
+        const controller = this._itemControllers.get(chatSessionType)?.controller;
+        if (!controller) {
+            return;
+        }
         try {
             const items = [];
             for await (const result of this.getChatSessionItems([chatSessionType], CancellationToken.None)) {
                 items.push(...result.items);
             }
+            if (this._itemControllers.get(chatSessionType)?.controller !== controller) {
+                return;
+            }
             const inProgress = items.filter(
                 item => !item.archived && item.status && isSessionInProgressStatus(item.status)
             );
@@ -486,6 +530,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
     }
     registerContribution(contribution, ext) {
+        contribution = applyCodexAgentHostPreference(contribution);
         this._logService.trace(
             `[ChatSessionsService] registerContribution called for type='${contribution.type}', canDelegate=${contribution.canDelegate}, when='${contribution.when}', extension='${ext.identifier.value}'`
         );
@@ -602,7 +647,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openSessionWithPrompt.${contribution.type}`,
-                    title: ( localize2(7218, "New {0} with Prompt", contribution.displayName)),
+                    title: ( localize2(8447, "New {0} with Prompt", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -654,7 +699,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
-                    title: ( localize2(7219, "New {0} Session", contribution.displayName)),
+                    title: ( localize2(8448, "New {0} Session", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: true,
@@ -677,7 +722,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionSidebar.${contribution.type}`,
-                    title: ( localize2(7220, "New {0} Session", contribution.displayName)),
+                    title: ( localize2(8449, "New {0} Session", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -796,7 +841,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             isCore: false,
             isDynamic: true,
             slashCommands: contribution.commands ?? [],
-            locations: [ChatAgentLocation.Chat],
+            locations: contribution.locations ?? [ChatAgentLocation.Chat],
             modes: [ChatModeKind.Agent, ChatModeKind.Ask],
             disambiguation: [],
             metadata: {
@@ -874,11 +919,29 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             contribution,
             extension: undefined
         });
-        this._contributionDisposables.set(contribution.type, ( new DisposableStore()));
+        if (contribution.alternativeIds) {
+            for (const alternativeId of contribution.alternativeIds) {
+                this._alternativeIdMap.set(alternativeId, contribution.type);
+            }
+        }
+        const disposables = ( new DisposableStore());
+        this._contributionDisposables.set(contribution.type, disposables);
+        if (contribution.onDidChangeRequiresCopilotSignIn) {
+            disposables.add(
+                contribution.onDidChangeRequiresCopilotSignIn(() => this._onDidChangeAvailability.fire())
+            );
+        }
         this._updateHasCanDelegateProvidersContextKey();
         this._onDidChangeAvailability.fire();
         return toDisposable(() => {
             this._contributions.delete(contribution.type);
+            if (contribution.alternativeIds) {
+                for (const alternativeId of contribution.alternativeIds) {
+                    if (this._alternativeIdMap.get(alternativeId) === contribution.type) {
+                        this._alternativeIdMap.delete(alternativeId);
+                    }
+                }
+            }
             this._contributionDisposables.deleteAndDispose(contribution.type);
             this._updateHasCanDelegateProvidersContextKey();
             this._onDidChangeAvailability.fire();
@@ -948,6 +1011,16 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
         return this._contentProviders.get(resolvedType)?.resolveChatResponseUri?.(sessionResource, href, kind) ?? href;
     }
+    updateChatSessionMetadata(sessionResource, metadata) {
+        const sessionType = getChatSessionType(sessionResource);
+        const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
+        const provider = this._contentProviders.get(resolvedType);
+        if (!provider?.updateChatSessionMetadata) {
+            return false;
+        }
+        provider.updateChatSessionMetadata(sessionResource, metadata);
+        return true;
+    }
     async getChatInputCompletionTriggerCharacters(sessionType) {
         const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
         const provider = this._contentProviders.get(resolvedType);
@@ -1040,6 +1113,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             chatSessionType
         });
         disposables.add(controller.onDidChangeChatSessionItems(e => {
+            for (const sessionResource of e.removed ?? []) {
+                this._disposeSession(sessionResource);
+            }
             this._onDidChangeSessionItems.fire(e);
             this.updateInProgressStatus(chatSessionType);
         }));
@@ -1047,14 +1123,16 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             dispose: () => {
                 initialRefreshCts.cancel();
                 disposables.dispose();
-                const controller = this._itemControllers.get(chatSessionType);
-                if (controller) {
+                const registeredController = this._itemControllers.get(chatSessionType)?.controller;
+                if (registeredController === controller) {
                     this._itemControllers.delete(chatSessionType);
                     this._onDidChangeItemsProviders.fire({
                         chatSessionType
                     });
+                    if (this.inProgressMap.delete(chatSessionType)) {
+                        this._onDidChangeInProgress.fire();
+                    }
                 }
-                this.updateInProgressStatus(chatSessionType);
             }
         };
     }
@@ -1115,23 +1193,92 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         await controllerData.initialRefresh;
         return controllerData.controller.newChatSessionItem?.(request, token);
     }
+    notifySessionMaterialized(sessionResource) {
+        this._getChatSessionItemController(sessionResource)?.controller.notifySessionMaterialized?.(sessionResource);
+    }
     async deleteChatSessionItem(sessionResource, token) {
-        const sessionType = getChatSessionType(sessionResource);
-        const resolvedType = this._resolveToPrimaryType(sessionType) ?? sessionType;
-        const controllerData = this._itemControllers.get(resolvedType);
+        const controllerData = this._getChatSessionItemController(sessionResource);
         if (!controllerData?.controller.deleteChatSessionItem) {
             throw ( new Error(`Session ${( sessionResource.toString())} does not support deletion`));
         }
         await controllerData.initialRefresh;
-        return controllerData.controller.deleteChatSessionItem(sessionResource, token);
+        await controllerData.controller.deleteChatSessionItem(sessionResource, token);
+        this._disposeSession(sessionResource);
+    }
+    _disposeSession(sessionResource) {
+        const resolvedResource = this._resolveResource(sessionResource);
+        for (const resource of [sessionResource, resolvedResource]) {
+            const resourceKey = ( resource.toString());
+            const pendingSession = this._pendingSessionResolutions.get(resourceKey);
+            if (pendingSession) {
+                this._pendingSessionResolutions.delete(resourceKey);
+                pendingSession.cancellationTokenSource.cancel();
+            }
+        }
+        const sessionData = this._sessions.get(sessionResource) ?? this._sessions.get(resolvedResource);
+        if (sessionData) {
+            this._sessions.delete(sessionData.resource);
+            sessionData.dispose();
+            sessionData.session.dispose();
+        }
+    }
+    _getChatSessionItemController(sessionResource) {
+        const sessionType = getChatSessionType(sessionResource);
+        const resolvedType = this._resolveToPrimaryType(sessionType) ?? sessionType;
+        return this._itemControllers.get(resolvedType);
     }
     async getOrCreateChatSession(sessionResource, token) {
         {
             const existingSessionData = this._sessions.get(sessionResource);
             if (existingSessionData) {
+                this._logService.trace(
+                    `[ChatSessionsService] getOrCreateChatSession: cache hit for ${( sessionResource.toString())}`
+                );
                 return existingSessionData.session;
             }
         }
+        const resourceKey = ( sessionResource.toString());
+        let pendingSession = this._pendingSessionResolutions.get(resourceKey);
+        if (!pendingSession) {
+            const cancellationTokenSource = ( new CancellationTokenSource());
+            const promise = this._getOrCreateChatSession(sessionResource, cancellationTokenSource.token);
+            pendingSession = {
+                promise,
+                cancellationTokenSource,
+                waiterCount: 0
+            };
+            this._pendingSessionResolutions.set(resourceKey, pendingSession);
+            const clearPendingSession = () => {
+                if (this._pendingSessionResolutions.get(resourceKey) === pendingSession) {
+                    this._pendingSessionResolutions.delete(resourceKey);
+                }
+                cancellationTokenSource.dispose();
+            };
+            void promise.then(clearPendingSession, clearPendingSession);
+        }
+        return this._waitForPendingSessionResolution(resourceKey, pendingSession, token);
+    }
+    _waitForPendingSessionResolution(resourceKey, pendingSession, token) {
+        pendingSession.waiterCount++;
+        let released = false;
+        const release = () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            pendingSession.waiterCount--;
+            if (pendingSession.waiterCount === 0 && this._pendingSessionResolutions.get(resourceKey) === pendingSession) {
+                this._pendingSessionResolutions.delete(resourceKey);
+                pendingSession.cancellationTokenSource.cancel();
+            }
+        };
+        const cancellationListener = token.onCancellationRequested(release);
+        return raceCancellationError(pendingSession.promise, token).finally(() => {
+            cancellationListener.dispose();
+            release();
+        });
+    }
+    async _getOrCreateChatSession(sessionResource, token) {
         const sessionType = getChatSessionType(sessionResource);
         if (!(await raceCancellationError(this.canResolveChatSession(sessionType), token))) {
             throw Error(`Cannot find provider '${sessionType}'`);
@@ -1165,7 +1312,19 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 dispose: () => {}
             };
         } else {
-            session = await raceCancellationError(provider.provideChatSessionContent(sessionResource, token), token);
+            this._logService.trace(
+                `[ChatSessionsService] getOrCreateChatSession: resolving content from provider '${resolvedType}' for ${( sessionResource.toString())}`
+            );
+            const contentPromise = provider.provideChatSessionContent(sessionResource, token);
+            void contentPromise.then(session => {
+                if (token.isCancellationRequested) {
+                    session.dispose();
+                }
+            }, () => {});
+            session = await raceCancellationError(contentPromise, token);
+            this._logService.trace(
+                `[ChatSessionsService] getOrCreateChatSession: provider returned ${session.history.length} history item(s) for ${( sessionResource.toString())}`
+            );
         }
         if (session.options) {
             for (const [optionId, value] of session.options) {
@@ -1175,6 +1334,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         {
             const existingSessionData = this._sessions.get(sessionResource);
             if (existingSessionData) {
+                session.dispose();
                 return existingSessionData.session;
             }
         }
@@ -1191,6 +1351,30 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         return session;
     }
+    async getChatSessionHistory(sessionResource, token) {
+        const existing = this._sessions.get(this._resolveResource(sessionResource));
+        if (existing) {
+            return [...existing.session.history];
+        }
+        if (isUntitledChatSession(sessionResource)) {
+            return [];
+        }
+        const sessionType = getChatSessionType(sessionResource);
+        const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
+        if (!(await raceCancellationError(this.canResolveChatSession(resolvedType), token))) {
+            throw Error(`Cannot find provider '${resolvedType}'`);
+        }
+        const provider = this._contentProviders.get(resolvedType);
+        if (!provider) {
+            throw Error(`Cannot find provider '${resolvedType}'`);
+        }
+        const session = await raceCancellationError(provider.provideChatSessionContent(sessionResource, token), token);
+        try {
+            return [...session.history];
+        } finally {
+            session.dispose();
+        }
+    }
     hasAnySessionOptions(sessionResource) {
         const session = this._sessions.get(this._resolveResource(sessionResource));
         return !!session && !!session.options && session.options.size > 0;
@@ -1311,7 +1495,11 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
     }
     requiresCopilotSignInForSessionType(chatSessionType) {
         const contribution = this._contributions.get(chatSessionType)?.contribution;
-        return !!contribution?.requiresCopilotSignIn;
+        if (!contribution) {
+            return false;
+        }
+        const requires = contribution.requiresCopilotSignIn;
+        return typeof requires === "function" ? requires() : !!requires;
     }
     sessionSupportsFork(sessionResource) {
         const session =
@@ -1348,7 +1536,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionInPlace.${type}`,
-                title: ( localize2(7221, "New {0} Session", displayName)),
+                title: ( localize2(8450, "New {0} Session", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1362,11 +1550,13 @@ function registerNewSessionInPlaceAction(type, displayName) {
             if (chatSessionPosition !== ChatSessionPosition.Sidebar && chatSessionPosition !== ChatSessionPosition.Editor) {
                 throw ( new BugIndicatingError(`Invalid chat session position argument: ${chatSessionPosition}`));
             }
+            const activeEditor = accessor.get(IEditorGroupsService).activeGroup.activeEditor;
+            const replaceEditorForResource = activeEditor instanceof ChatEditorInput ? activeEditor.sessionResource : undefined;
             await openChatSession(accessor, {
                 type: type,
-                displayName: ( localize(7222, "Chat")),
+                displayName: ( localize(8451, "Chat")),
                 position: chatSessionPosition,
-                replaceEditor: true
+                replaceEditorForResource
             });
         }
     });
@@ -1376,7 +1566,7 @@ function registerNewSessionExternalAction(type, displayName, resolveCommandId) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionExternal.${type}`,
-                title: ( localize2(7223, "New {0} Session", displayName)),
+                title: ( localize2(8452, "New {0} Session", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1410,16 +1600,30 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
     const editorService = accessor.get(IEditorService);
     const customizationHarnessService = accessor.get(ICustomizationHarnessService);
     const toolsService = accessor.get(ILanguageModelToolsService);
+    const importConversationStore = accessor.get(IAgentHostImportConversationStore);
+    const progressService = accessor.get(IProgressService);
     const sessionResource = getResourceForNewChatSession(openOptions);
+    if (chatSendOptions?.importConversation && chatSendOptions.importConversation.turns.length > 0) {
+        importConversationStore.set(sessionResource, chatSendOptions.importConversation);
+    }
+    let sessionsListSuppression;
+    let transitionProgress;
     try {
         switch (openOptions.position) {
         case ChatSessionPosition.Sidebar:
             {
                 const view = await viewsService.openView(ChatViewId);
+                if (chatSendOptions?.importConversation) {
+                    sessionsListSuppression = view.beginSessionsListSuppression();
+                    transitionProgress = ( new DeferredPromise());
+                    progressService.withProgress({
+                        location: ChatViewId
+                    }, () => transitionProgress.p);
+                }
                 if (openOptions.type === AgentSessionProviders.Local) {
                     await view.startNewLocalSession();
                 } else {
-                    await view.loadSession(sessionResource);
+                    await view.loadSession(sessionResource, "explicitOverride");
                 }
                 view.focus();
                 break;
@@ -1429,25 +1633,39 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                 const options = {
                     override: ChatEditorInput.EditorID,
                     pinned: true,
+                    sessionTypeSelectionReason: "explicitOverride",
                     ...(openOptions.type === AgentSessionProviders.Local ? {
                         explicitSessionType: localChatSessionType
                     } : {}),
                     title: {
-                        fallback: ( localize(7224, "{0}", openOptions.displayName))
+                        fallback: ( localize(8453, "{0}", openOptions.displayName))
                     }
                 };
-                if (openOptions.replaceEditor) {
-                    const activeEditor = editorGroupService.activeGroup.activeEditor;
-                    if (!activeEditor || !(activeEditor instanceof ChatEditorInput)) {
-                        throw ( new Error("No active chat editor to replace"));
+                if (openOptions.replaceEditorForResource) {
+                    const sourceResource = openOptions.replaceEditorForResource;
+                    let replaced = false;
+                    for (const group of editorGroupService.groups) {
+                        const editor = group.editors.find(
+                            e => e instanceof ChatEditorInput && isEqual(e.sessionResource, sourceResource)
+                        );
+                        if (editor) {
+                            await editorService.replaceEditors([{
+                                editor,
+                                replacement: {
+                                    resource: sessionResource,
+                                    options
+                                }
+                            }], group);
+                            replaced = true;
+                            break;
+                        }
                     }
-                    await editorService.replaceEditors([{
-                        editor: activeEditor,
-                        replacement: {
+                    if (!replaced) {
+                        await editorService.openEditor({
                             resource: sessionResource,
                             options
-                        }
-                    }], editorGroupService.activeGroup);
+                        });
+                    }
                 } else {
                     await editorService.openEditor({
                         resource: sessionResource,
@@ -1467,6 +1685,8 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
             `Failed to open '${openOptions.type}' chat session with openOptions: ${JSON.stringify(openOptions)}`,
             e
         );
+        sessionsListSuppression?.dispose();
+        transitionProgress?.complete();
         return;
     }
     if (chatSendOptions) {
@@ -1491,28 +1711,34 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                 agentIdSilent: openOptions.type,
                 attachedContext
             });
-            if (result.kind === "sent" && result.newSessionResource && !isEqual(result.newSessionResource, sessionResource)) {
+            const newSessionResource = result.kind === "sent" || result.kind === "rejected" ? result.newSessionResource : undefined;
+            if (newSessionResource && !isEqual(newSessionResource, sessionResource)) {
                 switch (openOptions.position) {
                 case ChatSessionPosition.Sidebar:
                     {
                         const view = await viewsService.openView(ChatViewId);
-                        await view.loadSession(result.newSessionResource);
+                        await view.loadSession(newSessionResource);
                         break;
                     }
                 case ChatSessionPosition.Editor:
                     {
-                        const activeEditor = editorGroupService.activeGroup.activeEditor;
-                        if (activeEditor instanceof ChatEditorInput && isEqual(activeEditor.sessionResource, sessionResource)) {
-                            await editorService.replaceEditors([{
-                                editor: activeEditor,
-                                replacement: {
-                                    resource: result.newSessionResource,
-                                    options: {
-                                        override: ChatEditorInput.EditorID,
-                                        pinned: true
+                        for (const group of editorGroupService.groups) {
+                            const editor = group.editors.find(
+                                e => e instanceof ChatEditorInput && isEqual(e.sessionResource, sessionResource)
+                            );
+                            if (editor) {
+                                await editorService.replaceEditors([{
+                                    editor,
+                                    replacement: {
+                                        resource: newSessionResource,
+                                        options: {
+                                            override: ChatEditorInput.EditorID,
+                                            pinned: true
+                                        }
                                     }
-                                }
-                            }], editorGroupService.activeGroup);
+                                }], group);
+                                break;
+                            }
                         }
                         break;
                     }
@@ -1530,6 +1756,8 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
             );
         }
     }
+    sessionsListSuppression?.dispose();
+    transitionProgress?.complete();
 }
 function normalizeSessionOptions(options) {
     if (options instanceof Map) {
@@ -1544,8 +1772,8 @@ async function resolvePromptSlashCommand(prompt, sessionResource, customizationH
     const slashMatch = prompt.match(slashReg);
     if (slashMatch) {
         const slashCommand = await customizationHarnessService.resolvePromptSlashCommand(slashMatch[1], sessionResource, CancellationToken.None);
-        if (slashCommand) {
-            const parseResult = slashCommand.parsedPromptFile;
+        const parseResult = slashCommand?.parsedPromptFile;
+        if (parseResult) {
             const refs = parseResult.body?.variableReferences.map((
                 {
                     name,
@@ -1619,4 +1847,4 @@ function chatResponseStateToSessionStatus(state) {
     }
 }
 
-export { ChatSessionPosition, ChatSessionsService, chatResponseStateToSessionStatus, getResourceForNewChatSession, getSessionStatusForModel, openChatSession };
+export { ChatSessionPosition, ChatSessionsService, applyCodexAgentHostPreference, chatResponseStateToSessionStatus, getResourceForNewChatSession, getSessionStatusForModel, openChatSession };