@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatServiceImpl.js

@@ -1,15 +1,17 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { DeferredPromise, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { raceCancellationError, DeferredPromise, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
-import { ErrorNoTelemetry, BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { BugIndicatingError, ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { MarkdownString, createMarkdownCommandLink } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { Disposable, DisposableResourceMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, toDisposable, DisposableResourceMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
@@ -26,6 +28,7 @@ import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { isVirtualWorkspace } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/virtualWorkspace';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
 import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
@@ -34,22 +37,23 @@ import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/wor
 import { clearChatMarks, markChat, ChatPerfMark } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatPerf';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
 import { chatEditingSessionIsReady } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
-import { logChangesToStateModel, normalizeSerializableChatData, ChatModel, ChatRequestRemovalReason, ChatRequestModel, updateRanges, toChatHistoryContent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
+import { logChangesToStateModel, normalizeSerializableChatData, ChatModel, getRestoredChatRequestSource, ChatRequestModel, ChatRequestRemovalReason, updateRanges, toChatHistoryContent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
 import { ChatModelStore } from '../model/chatModelStore.js';
 import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, getPromptText, chatSubcommandLeader, chatAgentLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
 import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
 import { ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatMcpServersStarting, ChatStopCancellationNoopEventName, ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { ChatServiceTelemetry, ChatRequestTelemetry } from './chatServiceTelemetry.js';
-import { isAgentHostTarget, localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { isAgentHostTarget, localChatSessionType, isTerminalCommandPrompt } 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 { ChatSessionStore } from '../model/chatSessionStore.js';
 import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service';
 import { IChatTransferService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatTransferService.service';
 import { LocalChatSessionUri, getChatSessionType, chatSessionResourceToId, isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { isExplicitFileOrImageVariableEntry, IChatRequestVariableEntry, ChatRequestVariableSet, isPromptTextVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
-import { ChatAgentLocation, ChatModeKind, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatAgentLocation, ChatModeKind, ChatConfiguration, CustomizationMigrationHintMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { ModelSelectionReason } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/modelSelection';
 import { ToolAndToolSetEnablementMap } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { ChatSessionOperationLog } from '../model/chatSessionOperationLog.js';
@@ -57,13 +61,16 @@ import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING, TROUBLESHOOT_COMMAND_NAME, COPILOT_SKILL_URI_SCHEME, TROUBLESHOOT_SKILL_PATH } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { mergeHooks } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
 import { ComputeAutomaticInstructions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/computeAutomaticInstructions';
+import { CustomizationMigrationHintTarget } from '../promptSyntax/service/customizationMigrationService.js';
 import { findLast } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
 import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { getCustomizationMigrationHintDismissedStorageKey, AICustomizationManagementSection, AICustomizationManagementCommands } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
 const serializedChatKey = "interactive.sessions";
+const customizationMigrationHintShownStateKey = "customizationMigrationHintShown";
 function hasDraftInput(model) {
     const state = model.inputModel.state.get();
     if (!state) {
@@ -114,6 +121,28 @@ let CancellableRequest = class CancellableRequest {
 CancellableRequest = ( __decorate([( __param(4, ILanguageModelToolsService))], CancellableRequest));
 const EMPTY_REFERENCES = ( Object.freeze([]));
 const EMPTY_TOOL_ENABLEMENT_MAP = ToolAndToolSetEnablementMap.fromEntries([]);
+function backfillRestoredPickerState(stateToApply, savedState, defaultAgentModeId) {
+    if (!stateToApply || !savedState) {
+        return stateToApply;
+    }
+    const mode = (stateToApply.mode.id === defaultAgentModeId && savedState.mode.id !== defaultAgentModeId) ? savedState.mode : stateToApply.mode;
+    if (mode === stateToApply.mode) {
+        return stateToApply;
+    }
+    return {
+        ...stateToApply,
+        mode
+    };
+}
+function backfillTransferredModel(transferredState, historyModel) {
+    if (!transferredState || transferredState.selectedModel || !historyModel) {
+        return transferredState;
+    }
+    return {
+        ...transferredState,
+        selectedModel: historyModel
+    };
+}
 let ChatService = class ChatService extends Disposable {
     get transferredSessionResource() {
         return this._transferredSessionResource;
@@ -127,6 +156,17 @@ let ChatService = class ChatService extends Disposable {
     waitForModelDisposals() {
         return this._sessionModels.waitForModelDisposals();
     }
+    registerCustomizationMigrationHintProvider(provider) {
+        if (this._customizationMigrationHintProvider) {
+            throw ( new BugIndicatingError("A customization migration hint provider is already registered"));
+        }
+        this._customizationMigrationHintProvider = provider;
+        return toDisposable(() => {
+            if (this._customizationMigrationHintProvider === provider) {
+                this._customizationMigrationHintProvider = undefined;
+            }
+        });
+    }
     get isEmptyWindow() {
         const workspace = this.workspaceContextService.getWorkspace();
         return !workspace.configuration && workspace.folders.length === 0;
@@ -168,6 +208,7 @@ let ChatService = class ChatService extends Disposable {
         this.chatDebugService = chatDebugService;
         this._pendingRequests = this._register(( new DisposableResourceMap()));
         this._queuedRequestDeferreds = ( new Map());
+        this._syntheticPendingRequests = ( new WeakSet());
         this._inFlightUntitledMaterializations = ( new ResourceMap());
         this._saveModelsEnabled = true;
         this._onDidSubmitRequest = this._register(( new Emitter()));
@@ -203,7 +244,7 @@ let ChatService = class ChatService extends Disposable {
                         );
                         await this._chatSessionStore.storeSessions([model]);
                     }
-                } else if (!localSessionId && (model.getRequests().length > 0 || hasDraftInput(model))) {
+                } else if (!localSessionId && this.shouldStoreExternalSession(model) && (model.getRequests().length > 0 || hasDraftInput(model))) {
                     logChangesToStateModel(
                         model.inputModel,
                         `disposing external session ${model.sessionResource} with requests or draft input, storing metadata to storage`,
@@ -218,6 +259,8 @@ let ChatService = class ChatService extends Disposable {
         this._register(this._sessionModels.onDidDisposeModel(model => {
             clearChatMarks(model.sessionResource);
             this.chatDebugService.endSession(model.sessionResource);
+            this._sessionFollowupCancelTokens.get(model.sessionResource)?.cancel();
+            this._sessionFollowupCancelTokens.deleteAndDispose(model.sessionResource);
             this.chatSessionService.clearMaterializedSessionResource(model.sessionResource);
             this._onDidDisposeSession.fire({
                 sessionResources: [model.sessionResource],
@@ -242,6 +285,15 @@ let ChatService = class ChatService extends Disposable {
     get editingSessions() {
         return ( [...( this._sessionModels.values())].map(v => v.editingSession)).filter(isDefined);
     }
+    getPendingRequestSessionTypes() {
+        const sessionTypes = ( new Set(Array.from(( this._inFlightUntitledMaterializations.keys()), getChatSessionType)));
+        for (const model of ( this._sessionModels.values())) {
+            if (model.requestInProgress.get()) {
+                sessionTypes.add(getChatSessionType(model.sessionResource));
+            }
+        }
+        return Array.from(sessionTypes);
+    }
     isEnabled(location) {
         return this.chatAgentService.getContributedDefaultAgent(location) !== undefined;
     }
@@ -266,9 +318,7 @@ let ChatService = class ChatService extends Disposable {
             return;
         }
         const liveLocalChats = Array.from(( this._sessionModels.values())).filter(session => this.shouldStoreSession(session));
-        const liveNonLocalChats = Array.from(( this._sessionModels.values())).filter(
-            session => !LocalChatSessionUri.parseLocalSessionId(session.sessionResource)
-        );
+        const liveNonLocalChats = Array.from(( this._sessionModels.values())).filter(session => this.shouldStoreExternalSession(session));
         this._chatSessionStore.updateAndFlushIndexSync(liveLocalChats, liveNonLocalChats);
         this._chatSessionStore.storeSessions(liveLocalChats);
         this._chatSessionStore.storeSessionsMetadataOnly(liveNonLocalChats);
@@ -282,6 +332,12 @@ let ChatService = class ChatService extends Disposable {
         }
         return session.initialLocation === ChatAgentLocation.Chat && !session.isImported;
     }
+    shouldStoreExternalSession(session) {
+        if (LocalChatSessionUri.parseLocalSessionId(session.sessionResource)) {
+            return false;
+        }
+        return session.initialLocation === ChatAgentLocation.Chat;
+    }
     notifyUserAction(action) {
         this._chatServiceTelemetry.notifyUserAction(action);
         this._onDidPerformUserAction.fire(action);
@@ -424,7 +480,8 @@ let ChatService = class ChatService extends Disposable {
             location,
             sessionResource,
             canUseTools: options?.canUseTools ?? true,
-            disableBackgroundKeepAlive: options?.disableBackgroundKeepAlive
+            disableBackgroundKeepAlive: options?.disableBackgroundKeepAlive,
+            sessionTypeSelectionReason: options?.sessionTypeSelectionReason
         }, options?.debugOwner ?? "ChatService#startNewLocalSession");
     }
     _startSession(props) {
@@ -435,14 +492,18 @@ let ChatService = class ChatService extends Disposable {
             canUseTools,
             transferEditingSession,
             disableBackgroundKeepAlive,
-            inputState
+            inputState,
+            isReadOnly,
+            sessionTypeSelectionReason
         } = props;
         const model = this.instantiationService.createInstance(ChatModel, initialData, {
             initialLocation: location,
             canUseTools,
             resource: sessionResource,
             disableBackgroundKeepAlive,
-            inputState
+            inputState,
+            isReadOnly,
+            sessionTypeSelectionReason
         });
         if (location === ChatAgentLocation.Chat) {
             model.startEditingSession(true, transferEditingSession);
@@ -515,7 +576,7 @@ let ChatService = class ChatService extends Disposable {
         }
         return this._sessionModels.get(sessionResource)?.title ?? this._chatSessionStore.getMetadataForSessionSync(sessionResource)?.title;
     }
-    loadSessionFromData(data, debugOwner) {
+    loadSessionFromData(data, debugOwner, sessionTypeSelectionReason) {
         const sessionId = data.sessionId ?? generateUuid();
         const sessionResource = LocalChatSessionUri.forSession(sessionId);
         return this._sessionModels.acquireOrCreate({
@@ -525,27 +586,34 @@ let ChatService = class ChatService extends Disposable {
             },
             location: data.initialLocation ?? ChatAgentLocation.Chat,
             sessionResource,
-            canUseTools: true
+            canUseTools: true,
+            sessionTypeSelectionReason
         }, debugOwner ?? "ChatService#loadSessionFromData");
     }
-    async acquireOrLoadSession(sessionResource, location, token, debugOwner) {
+    async acquireOrLoadSession(sessionResource, location, token, debugOwner, sessionTypeSelectionReason) {
         if (LocalChatSessionUri.isLocalSession(sessionResource)) {
             return this.acquireOrRestoreLocalSession(sessionResource, debugOwner);
         } else {
-            return this.loadRemoteSession(sessionResource, location, token, debugOwner);
+            return this.loadRemoteSession(sessionResource, location, token, debugOwner, sessionTypeSelectionReason);
         }
     }
-    async loadRemoteSession(sessionResource, location, token, debugOwner) {
+    async loadRemoteSession(sessionResource, location, token, debugOwner, sessionTypeSelectionReason) {
+        this.trace("loadRemoteSession", `start ${( sessionResource.toString())}`);
         {
             const existingRef = this.acquireExistingSession(sessionResource, debugOwner);
             if (existingRef) {
+                this.trace("loadRemoteSession", `reused existing model for ${( sessionResource.toString())}`);
                 return existingRef;
             }
         }
-        if (!(await this.chatSessionService.canResolveChatSession(getChatSessionType(sessionResource)))) {
+        if (!(await raceCancellationError(
+            this.chatSessionService.canResolveChatSession(getChatSessionType(sessionResource)),
+            token
+        ))) {
             return undefined;
         }
         const providedSession = await this.chatSessionService.getOrCreateChatSession(sessionResource, token);
+        this.trace("loadRemoteSession", `session content resolved for ${( sessionResource.toString())} with ${providedSession.history.length} history item(s)`);
         {
             const existingRef = this.acquireExistingSession(sessionResource, debugOwner);
             if (existingRef) {
@@ -578,11 +646,15 @@ let ChatService = class ChatService extends Disposable {
             const modelMetadata = modelId ? this.languageModelsService.lookupLanguageModel(modelId) : undefined;
             const storedModelConfiguration = storedInputState?.selectedModel?.modelConfiguration ?? storedInputState?.modelConfiguration;
             const modelConfiguration = storedInputState?.selectedModel?.identifier === modelId ? storedModelConfiguration : undefined;
+            const storedSelectedModel = storedInputState?.selectedModel;
             const selectedModel = modelId && modelMetadata ? {
                 identifier: modelId,
                 metadata: modelMetadata,
                 modelConfiguration
-            } : undefined;
+            } : (modelId && storedSelectedModel && storedSelectedModel.identifier === modelId ? {
+                ...storedSelectedModel,
+                modelConfiguration
+            } : undefined);
             historySelectedModel = selectedModel?.identifier;
             historyDerivedModel = selectedModel;
             initialData = {
@@ -613,14 +685,25 @@ let ChatService = class ChatService extends Disposable {
             ...storedInputState,
             selectedModel: historyDerivedModel
         } : undefined;
+        const transferredInputState = providedSession.transferredState?.inputState;
+        const stateToApply = transferredInputState ? backfillTransferredModel(transferredInputState, historyDerivedModel) : restoredDraft;
+        const inputState = backfillRestoredPickerState(stateToApply, storedInputState, ChatMode.Agent.id);
         const modelRef = this._sessionModels.acquireOrCreate({
             initialData,
             location,
             sessionResource: sessionResource,
             canUseTools: false,
             transferEditingSession: providedSession.transferredState?.editingSession,
-            inputState: providedSession.transferredState?.inputState ?? restoredDraft
+            inputState,
+            isReadOnly: providedSession.isReadOnly,
+            sessionTypeSelectionReason
         }, debugOwner ?? "ChatService#loadRemoteSession");
+        if (modelId && !historySelectedModel) {
+            modelRef.object.inputModel.setIntendedModel({
+                modelId,
+                reason: ModelSelectionReason.SessionRestore
+            });
+        }
         logChangesToStateModel(
             modelRef.object.inputModel,
             `loadRemoteSession inputState source: session=${( sessionResource.toString())}, chatSessionType=${chatSessionType}, historyModelId=${modelId}, agentUri=${agentUri?.toString()}, historySelectedModel=${historySelectedModel}, transferredSelectedModel=${providedSession.transferredState?.inputState?.selectedModel?.identifier}, storedSelectedModel=${storedInputState?.selectedModel?.identifier}, finalSelectedModel=${modelRef.object.inputModel.state.get()?.selectedModel?.identifier}, hasTransferredInputState=${!!providedSession.transferredState?.inputState}, hasStoredInputState=${!!storedInputState}, hasInitialData=${!!initialData}`,
@@ -674,10 +757,21 @@ let ChatService = class ChatService extends Disposable {
             };
         };
         let lastRequest;
+        let lastResponseCompletedAt;
+        const completeLastResponse = (finishedNow = false) => {
+            if (Number.isFinite(lastResponseCompletedAt)) {
+                lastRequest?.response?.complete(lastResponseCompletedAt);
+            } else if (finishedNow) {
+                lastRequest?.response?.complete();
+            } else {
+                lastRequest?.response?.completeWithoutTimestamp();
+            }
+            lastResponseCompletedAt = undefined;
+        };
         for (const message of providedSession.history) {
             if (message.type === "request") {
                 if (lastRequest) {
-                    lastRequest.response?.complete();
+                    completeLastResponse();
                 }
                 const requestText = message.prompt;
                 const agent = message.participant ?
@@ -698,7 +792,8 @@ let ChatService = class ChatService extends Disposable {
                 undefined,
                 undefined,
                 false,
-                message.modelId, undefined, message.id, message.isSystemInitiated, message.systemInitiatedLabel);
+                message.modelId, undefined, message.id, message.isSystemInitiated, message.systemInitiatedLabel, undefined,
+                message.isTerminalRequest, message.timestamp ?? null, message.isHidden, message.origin, message.isRequestHidden, getRestoredChatRequestSource(message, requestText));
             } else {
                 if (lastRequest) {
                     for (const part of message.parts) {
@@ -714,12 +809,18 @@ let ChatService = class ChatService extends Disposable {
                             } : {})
                         });
                     }
+                    if (lastRequest.response && typeof message.elapsedMs === "number") {
+                        lastRequest.response.setElapsedMs(message.elapsedMs);
+                    }
+                    lastResponseCompletedAt = message.completedAt;
                 }
             }
         }
+        this.trace("loadRemoteSession", `history applied to model for ${( sessionResource.toString())}: ${model.getRequests().length} request(s)`);
         const hasProgressStreaming = providedSession.progressObs && providedSession.interruptActiveResponseCallback;
         if (hasProgressStreaming) {
             let lastProgressLength = 0;
+            let wasComplete;
             const cancellationListener = disposables.add(( new MutableDisposable()));
             const createCancellationListener = token => {
                 return token.onCancellationRequested(() => {
@@ -732,6 +833,7 @@ let ChatService = class ChatService extends Disposable {
             };
             const trackNewCancellableRequest = () => {
                 const cancellableRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined, undefined, undefined);
+                this._syntheticPendingRequests.add(cancellableRequest);
                 this._pendingRequests.set(model.sessionResource, cancellableRequest);
                 this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
                     action: "add",
@@ -751,14 +853,33 @@ let ChatService = class ChatService extends Disposable {
             if (providedSession.onDidStartServerRequest) {
                 disposables.add(providedSession.onDidStartServerRequest((
                     {
+                        id,
                         prompt,
                         variableData,
+                        timestamp,
                         isSystemInitiated,
-                        systemInitiatedLabel
+                        requestSource,
+                        isHidden,
+                        isRequestHidden,
+                        systemInitiatedLabel,
+                        isTerminalRequest,
+                        resume,
+                        origin
                     }
                 ) => {
+                    if (resume) {
+                        const request = model.getRequests().find(request => request.id === id);
+                        if (!request?.response) {
+                            throw ( new Error(`Cannot resume missing chat request: ${id}`));
+                        }
+                        request.response.reopen();
+                        lastRequest = request;
+                        lastProgressLength = 0;
+                        ensureCancellationTracking();
+                        return;
+                    }
                     if (lastRequest?.response && !lastRequest.response.isComplete) {
-                        lastRequest.response.complete();
+                        completeLastResponse(true);
                     }
                     const agent = this.chatAgentService.getAgent(chatSessionType);
                     const parsedRequest = parseAgentHostHistoryPrompt(prompt, agent);
@@ -773,15 +894,51 @@ let ChatService = class ChatService extends Disposable {
                     undefined,
                     undefined,
                     undefined,
-                    undefined,
-                    isSystemInitiated, systemInitiatedLabel);
+                    id, isSystemInitiated, systemInitiatedLabel, undefined,
+                    isTerminalRequest, timestamp, isHidden, origin, isRequestHidden, requestSource);
                     lastProgressLength = 0;
                     ensureCancellationTracking();
                 }));
             }
+            if (!this._isServerManagedQueue(model.sessionResource)) {
+                let dispatchingImmediateSteer = false;
+                const canImmediatelyDispatch = () => {
+                    if (!( model.getPendingRequests().some(r => r.kind === ChatRequestQueueKind.Steering))) {
+                        return false;
+                    }
+                    const pending = this._pendingRequests.get(model.sessionResource);
+                    return !pending || ( this._syntheticPendingRequests.has(pending));
+                };
+                disposables.add(model.onDidChangePendingRequests(() => {
+                    if (dispatchingImmediateSteer || !canImmediatelyDispatch()) {
+                        return;
+                    }
+                    dispatchingImmediateSteer = true;
+                    queueMicrotask(() => {
+                        dispatchingImmediateSteer = false;
+                        if (this._sessionModels.get(model.sessionResource) !== model || !canImmediatelyDispatch()) {
+                            return;
+                        }
+                        if (( this._pendingRequests.has(model.sessionResource))) {
+                            this._pendingRequests.deleteAndDispose(model.sessionResource);
+                        }
+                        this.processNextPendingRequest(model);
+                        this._pendingRequests.get(model.sessionResource)?.responseCompletePromise?.finally(() => {
+                            if (this._sessionModels.get(model.sessionResource) === model && !(providedSession.isCompleteObs?.get() ?? false)) {
+                                ensureCancellationTracking();
+                            }
+                        });
+                    });
+                }));
+            }
             disposables.add(autorun(reader => {
                 const progressArray = providedSession.progressObs?.read(reader) ?? [];
                 const isComplete = providedSession.isCompleteObs?.read(reader) ?? false;
+                const justCompleted = wasComplete === false && isComplete;
+                wasComplete = isComplete;
+                if (!isComplete) {
+                    ensureCancellationTracking();
+                }
                 if (lastRequest && progressArray.length > lastProgressLength) {
                     const newProgress = progressArray.slice(lastProgressLength);
                     for (const progress of newProgress) {
@@ -792,12 +949,13 @@ let ChatService = class ChatService extends Disposable {
                 if (isComplete && lastRequest) {
                     this._pendingRequests.deleteAndDispose(model.sessionResource);
                     cancellationListener.clear();
-                    lastRequest.response?.complete();
+                    completeLastResponse(justCompleted);
+                    this.processPendingRequests(model.sessionResource);
                 }
             }));
         } else {
             if (providedSession.isCompleteObs?.get()) {
-                lastRequest?.response?.complete();
+                completeLastResponse();
             }
             this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
                 action: "notCancelable",
@@ -806,16 +964,19 @@ let ChatService = class ChatService extends Disposable {
             });
             if (lastRequest && model.editingSession) {
                 await chatEditingSessionIsReady(model.editingSession);
-                lastRequest.response?.complete();
+                completeLastResponse();
             }
         }
         return modelRef;
     }
-    async resendRequest(request, options) {
+    async resendRequest(request, options, preserveRequestId = false) {
         const model = this._sessionModels.get(request.session.sessionResource);
         if (!model && model !== request.session) {
             throw ( new Error(`Unknown session: ${request.session.sessionResource}`));
         }
+        if (model.isReadOnly.get()) {
+            return;
+        }
         const cts = this._pendingRequests.get(request.session.sessionResource);
         if (cts) {
             this.trace(
@@ -827,8 +988,16 @@ let ChatService = class ChatService extends Disposable {
         const location = options?.location ?? model.initialLocation;
         const attempt = options?.attempt ?? 0;
         const enableCommandDetection = !options?.noCommandDetection;
-        const defaultAgent = this.chatAgentService.getDefaultAgent(location, options?.modeInfo?.kind);
-        model.removeRequest(request.id, ChatRequestRemovalReason.Resend);
+        const requestedAgentId = options?.agentId ?? options?.agentIdSilent;
+        const requestedAgent = requestedAgentId ? this.chatAgentService.getAgent(requestedAgentId) : undefined;
+        if (requestedAgentId && !requestedAgent) {
+            throw ( new Error("Unknown agent: " + requestedAgentId));
+        }
+        const defaultAgent = requestedAgent ?? this.chatAgentService.getDefaultAgent(location, options?.modeInfo?.kind);
+        const preservedRequest = preserveRequestId && request instanceof ChatRequestModel ? request : undefined;
+        if (!preservedRequest) {
+            model.removeRequest(request.id, ChatRequestRemovalReason.Resend);
+        }
         const resendOptions = {
             ...options,
             locationData: request.locationData,
@@ -842,7 +1011,9 @@ let ChatService = class ChatService extends Disposable {
             enableCommandDetection,
             defaultAgent,
             location,
-            resendOptions
+            resendOptions,
+            preservedRequest,
+            preserveRequestId ? request.id : undefined
         ).responseCompletePromise;
     }
     queuePendingRequest(model, sessionResource, request, options) {
@@ -861,6 +1032,7 @@ let ChatService = class ChatService extends Disposable {
             modelId: options.userSelectedModelId,
             userSelectedTools: options.userSelectedTools?.get(),
             isSystemInitiated: options.isSystemInitiated,
+            isHiddenFromTranscript: options.hideFromTranscript,
             systemInitiatedLabel: options.systemInitiatedLabel,
             terminalExecutionId: options.terminalExecutionId
         }));
@@ -899,6 +1071,15 @@ let ChatService = class ChatService extends Disposable {
         if (!model) {
             throw ( new Error(`Unknown session: ${sessionResource}`));
         }
+        if (model.isReadOnly.get()) {
+            return {
+                kind: "rejected",
+                reason: "Session is read-only",
+                ...(newSessionResource ? {
+                    newSessionResource
+                } : {})
+            };
+        }
         if (!model.hasRequests && isUntitledChatSession(sessionResource) && getChatSessionType(sessionResource) !== localChatSessionType) {
             const materialized = await this._materializeUntitledSession(sessionResource, request, options, model);
             if (materialized) {
@@ -907,6 +1088,13 @@ let ChatService = class ChatService extends Disposable {
                 newSessionResource = materialized.newSessionResource;
             }
         }
+        if (model.isReadOnly.get()) {
+            return {
+                kind: "rejected",
+                reason: "Session is read-only",
+                newSessionResource
+            };
+        }
         const hasPendingRequest = ( this._pendingRequests.has(sessionResource));
         if (options?.queue) {
             const queued = this.queuePendingRequest(model, sessionResource, request, options);
@@ -1017,7 +1205,13 @@ let ChatService = class ChatService extends Disposable {
                 return undefined;
             }
             this.chatSessionService.registerSessionResourceAlias(untitledResource, newItem.resource);
-            const tempRef = await this.loadRemoteSession(newItem.resource, untitledModel.initialLocation, CancellationToken.None);
+            const tempRef = await this.loadRemoteSession(
+                newItem.resource,
+                untitledModel.initialLocation,
+                CancellationToken.None,
+                undefined,
+                untitledModel.sessionTypeSelectionReason
+            );
             const realModel = tempRef?.object;
             if (!realModel) {
                 throw ( new Error(`Failed to load session for resource: ${newItem.resource}`));
@@ -1025,6 +1219,7 @@ let ChatService = class ChatService extends Disposable {
             if (initialSessionOptions) {
                 this.chatSessionService.updateSessionOptions(realModel.sessionResource, initialSessionOptions);
             }
+            realModel.inputModel.setIntendedModel(untitledModel.inputModel.intendedModel);
             this.chatSessionService.setMaterializedSessionResource(untitledResource, newItem.resource);
             materialized.complete(newItem.resource);
             this.info(
@@ -1098,22 +1293,34 @@ let ChatService = class ChatService extends Disposable {
         enableCommandDetection,
         defaultAgent,
         location,
-        options
+        options,
+        preservedRequest,
+        requestId
     ) {
         const followupsCancelToken = this.refreshFollowupsCancellationToken(sessionResource);
         let request;
         const agentPart = parsedRequest.parts.find(r => r instanceof ChatRequestAgentPart);
         const agentSlashCommandPart = parsedRequest.parts.find(r => r instanceof ChatRequestAgentSubcommandPart);
         const commandPart = parsedRequest.parts.find(r => r instanceof ChatRequestSlashCommandPart);
-        const requests = [...model.getRequests()];
+        const requests = model.getRequests().filter(request => request !== preservedRequest);
+        const isTerminalCommand = isTerminalCommandPrompt(
+            parsedRequest.text,
+            this.chatSessionService.getCapabilitiesForSessionType(getChatSessionType(sessionResource))?.terminalCommandPrefix
+        );
         const requestTelemetry = this.instantiationService.createInstance(ChatRequestTelemetry, {
             agent: agentPart?.agent ?? defaultAgent,
             agentSlashCommandPart,
             commandPart,
             sessionResource: model.sessionResource,
+            requestIndex: requests.length,
+            sessionTypeSelectionReason: model.sessionTypeSelectionReason,
             location: model.initialLocation,
             options,
-            enableCommandDetection
+            enableCommandDetection,
+            isVirtualWorkspace: isVirtualWorkspace(this.workspaceContextService.getWorkspace()),
+            settingDefaultToCopilotHarness: this.configurationService.getValue(ChatConfiguration.DefaultToCopilotHarness) ?? false,
+            settingPreferCopilotHarness: this.configurationService.getValue(ChatConfiguration.EditorPreferCopilotHarness) ?? false,
+            settingLocalAgentEnabled: this.configurationService.getValue(ChatConfiguration.EditorLocalAgentEnabled) ?? true
         });
         let gotProgress = false;
         const requestType = commandPart ? "slashCommand" : "string";
@@ -1176,7 +1383,7 @@ let ChatService = class ChatService extends Disposable {
                         model.acceptResponseProgress(request, {
                             kind: "markdownContent",
                             content: ( new MarkdownString(( localize(
-                                8538,
+                                10242,
                                 "The `{0}` skill requires `{1}` to be enabled. After enabling, reload the window to apply. [Enable in Settings](command:workbench.action.openSettings?{2})",
                                 TROUBLESHOOT_COMMAND_NAME,
                                 AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING,
@@ -1223,6 +1430,37 @@ let ChatService = class ChatService extends Disposable {
                     hasDisabledClaudeHooks
                 };
             };
+            const collectCustomizationMigrationHint = async () => {
+                const sessionType = getChatSessionType(sessionResource);
+                const hintMode = this.configurationService.getValue(ChatConfiguration.ChatCustomizationsMigrationHint);
+                const hintAlreadyShown = model.inputModel.state.get()?.contrib[customizationMigrationHintShownStateKey] === true;
+                const showOnce = hintMode === CustomizationMigrationHintMode.Once;
+                if (!isAgentHostTarget(sessionType) || (!showOnce && hintMode !== CustomizationMigrationHintMode.Always) || this.storageService.getBoolean(
+                    getCustomizationMigrationHintDismissedStorageKey(sessionType),
+                    StorageScope.WORKSPACE
+                ) || (showOnce && hintAlreadyShown) || !this._customizationMigrationHintProvider) {
+                    return undefined;
+                }
+                try {
+                    const hint = await this._customizationMigrationHintProvider(sessionResource, token);
+                    if (hint && !token.isCancellationRequested) {
+                        for (const {
+                            type,
+                            count
+                        } of hint.counts) {
+                            this.telemetryService.publicLog2("chat.customizationMigrationAssessment", {
+                                category: type,
+                                count
+                            });
+                        }
+                        return hint;
+                    }
+                    return undefined;
+                } catch (error) {
+                    this.logService.warn("[ChatService] Failed to compute customization migration hint:", error);
+                    return undefined;
+                }
+            };
             const collectInstructions = async () => {
                 const ctx = options?.instructionContext;
                 if (!ctx) {
@@ -1279,7 +1517,7 @@ let ChatService = class ChatService extends Disposable {
                     const initVariableData = {
                         variables: []
                     };
-                    request = model.addRequest(
+                    request = preservedRequest ?? model.addRequest(
                         parsedRequest,
                         initVariableData,
                         attempt,
@@ -1292,14 +1530,20 @@ let ChatService = class ChatService extends Disposable {
                         undefined,
                         options?.userSelectedModelId,
                         options?.userSelectedTools?.get(),
-                        undefined,
+                        requestId,
                         options?.isSystemInitiated,
                         options?.systemInitiatedLabel,
-                        options?.terminalExecutionId
+                        options?.terminalExecutionId,
+                        isTerminalCommand,
+                        undefined,
+                        options?.hideFromTranscript
                     );
+                    preservedRequest?.response?.reopen();
                     const thisRequest = request;
                     completeResponseCreated();
-                    const [hooksResult, instructionEntries] = await Promise.all([collectHooks(), collectInstructions()]);
+                    const [hooksResult, instructionEntries, customizationMigrationHint] = await Promise.all(
+                        [collectHooks(), collectInstructions(), collectCustomizationMigrationHint()]
+                    );
                     const collectedHooks = hooksResult.hooks;
                     const hasDisabledClaudeHooks = hooksResult.hasDisabledClaudeHooks;
                     const allContext = this.prepareContext(request.attachedContext);
@@ -1337,6 +1581,7 @@ let ChatService = class ChatService extends Disposable {
                             acceptedConfirmationData: options?.acceptedConfirmationData,
                             rejectedConfirmationData: options?.rejectedConfirmationData,
                             agentHostSessionConfig: options?.agentHostSessionConfig,
+                            metadata: options?.metadata,
                             userSelectedModelId: options?.userSelectedModelId,
                             modelConfiguration: options?.userSelectedModelConfiguration ?? (options?.userSelectedModelId ? this.languageModelsService.getModelConfiguration(options.userSelectedModelId) : undefined),
                             userSelectedTools: options?.userSelectedTools?.get(),
@@ -1345,7 +1590,9 @@ let ChatService = class ChatService extends Disposable {
                             editedFileEvents: thisRequest.editedFileEvents,
                             hooks: collectedHooks,
                             hasHooksEnabled: !!collectedHooks && ( ( Object.values(collectedHooks)).some(arr => arr.length > 0)),
+                            isVoiceModeInput: options?.isVoiceModeInput,
                             isSystemInitiated: options?.isSystemInitiated,
+                            hideFromTranscript: options?.hideFromTranscript,
                             workingDirectory: model.workingDirectory
                         };
                         let isInitialTools = true;
@@ -1362,7 +1609,7 @@ let ChatService = class ChatService extends Disposable {
                         }));
                         return agentRequest;
                     };
-                    if (this.configurationService.getValue("chat.detectParticipant.enabled") !== false && this.chatAgentService.hasChatParticipantDetectionProviders() && !agentPart && !commandPart && !agentSlashCommandPart && enableCommandDetection && location !== ChatAgentLocation.EditorInline && options?.modeInfo?.kind !== ChatModeKind.Agent && options?.modeInfo?.kind !== ChatModeKind.Edit && !options?.agentIdSilent) {
+                    if (this.configurationService.getValue("chat.detectParticipant.enabled") !== false && this.chatAgentService.hasChatParticipantDetectionProviders() && !agentPart && !commandPart && !agentSlashCommandPart && enableCommandDetection && location !== ChatAgentLocation.EditorInline && options?.modeInfo?.kind !== ChatModeKind.Agent && options?.modeInfo?.kind !== ChatModeKind.Edit && !options?.agentId && !options?.agentIdSilent) {
                         const defaultAgentHistory = this.getHistoryEntriesFromModel(requests, location, defaultAgent.id);
                         const chatAgentRequest = buildAgentRequest(defaultAgent, undefined, enableCommandDetection, false);
                         const result = await this.chatAgentService.detectAgentOrCommand(chatAgentRequest, defaultAgentHistory, {
@@ -1398,6 +1645,51 @@ let ChatService = class ChatService extends Disposable {
                             });
                         }
                     }
+                    const showCustomizationMigrationHint = hint => {
+                        const hintAlreadyShown = model.inputModel.state.get()?.contrib[customizationMigrationHintShownStateKey] === true;
+                        const hintMode = this.configurationService.getValue(ChatConfiguration.ChatCustomizationsMigrationHint);
+                        const showOnce = hintMode === CustomizationMigrationHintMode.Once;
+                        if (!hint || token.isCancellationRequested || (showOnce && hintAlreadyShown)) {
+                            return;
+                        }
+                        if (showOnce) {
+                            model.inputModel.setState({
+                                contrib: {
+                                    ...model.inputModel.state.get()?.contrib,
+                                    [customizationMigrationHintShownStateKey]: true
+                                }
+                            });
+                        }
+                        const reviewArguments = hint.target === CustomizationMigrationHintTarget.FileMigrations ? [{
+                            migration: true
+                        }] : hint.target === CustomizationMigrationHintTarget.McpServers ? [{
+                            section: AICustomizationManagementSection.McpServers
+                        }] : undefined;
+                        const reviewLink = createMarkdownCommandLink({
+                            id: AICustomizationManagementCommands.OpenEditor,
+                            text: ( localize(10243, "Review customizations")),
+                            tooltip: ( localize(10244, "Open Chat Customizations")),
+                            arguments: reviewArguments
+                        });
+                        const dismissLink = createMarkdownCommandLink({
+                            id: AICustomizationManagementCommands.DismissMigrationHint,
+                            text: ( localize(10245, "Hide for this workspace")),
+                            tooltip: ( localize(10246, "Stop Showing Migration Hints for This Harness"))
+                        });
+                        progressCallback([{
+                            kind: "systemNotification",
+                            content: ( new MarkdownString(( localize(10247, "*{0} {1} | {2}*", hint.message, reviewLink, dismissLink)), {
+                                isTrusted: {
+                                    enabledCommands: [
+                                        AICustomizationManagementCommands.OpenEditor,
+                                        AICustomizationManagementCommands.DismissMigrationHint
+                                    ]
+                                }
+                            })),
+                            icon: Codicon.info
+                        }]);
+                    };
+                    showCustomizationMigrationHint(customizationMigrationHint);
                     const disabledClaudeHooksDismissedKey = "chat.disabledClaudeHooks.notification";
                     if (hasDisabledClaudeHooks && !this.storageService.getBoolean(disabledClaudeHooksDismissedKey, StorageScope.WORKSPACE)) {
                         this.storageService.store(
@@ -1481,7 +1773,7 @@ let ChatService = class ChatService extends Disposable {
                         );
                         rawResult = {
                             errorDetails: {
-                                message: ( localize(8539, "Provider returned null response"))
+                                message: ( localize(10248, "Provider returned null response"))
                             }
                         };
                     }
@@ -1510,7 +1802,12 @@ let ChatService = class ChatService extends Disposable {
                         agentOrCommandFollowups.then(followups => {
                             model.setFollowups(completedRequest, followups);
                             const commandForTelemetry = agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command;
-                            this._chatServiceTelemetry.retrievedFollowups(agentPart?.agent.id ?? "", commandForTelemetry, followups?.length ?? 0);
+                            this._chatServiceTelemetry.retrievedFollowups(
+                                model.sessionResource,
+                                agentPart?.agent.id ?? "",
+                                commandForTelemetry,
+                                followups?.length ?? 0
+                            );
                         });
                     }
                 }
@@ -1568,7 +1865,8 @@ let ChatService = class ChatService extends Disposable {
         }
         this._onDidSubmitRequest.fire({
             chatSessionResource: model.sessionResource,
-            message: parsedRequest
+            message: parsedRequest,
+            attachedContext: options?.attachedContext
         });
         return {
             responseCreatedPromise: responseCreated.p,
@@ -1582,7 +1880,7 @@ let ChatService = class ChatService extends Disposable {
         }
     }
     _isServerManagedQueue(sessionResource) {
-        return getChatSessionType(sessionResource).startsWith("agent-host-");
+        return this.chatSessionService.getChatSessionContribution(getChatSessionType(sessionResource))?.agentHostProviderId !== undefined;
     }
     processNextPendingRequest(model) {
         if (this._isServerManagedQueue(model.sessionResource)) {
@@ -1908,6 +2206,61 @@ let ChatService = class ChatService extends Disposable {
             model.setPendingRequests(requests);
         }
     }
+    syncPendingRequestsFromRemote(sessionResource, requests) {
+        const model = this._sessionModels.get(sessionResource);
+        if (!model) {
+            return;
+        }
+        const existing = model.getPendingRequests();
+        const existingById = ( new Map(( existing.map(request => [request.request.id, request]))));
+        const reconciled = ( requests.map(remote => {
+            const variableData = remote.variableData ?? {
+                variables: []
+            };
+            const local = existingById.get(remote.id);
+            if (local && local.request.message.text === remote.message && equals(local.request.variableData, variableData)) {
+                return local.kind === remote.kind ? local : {
+                    ...local,
+                    kind: remote.kind
+                };
+            }
+            const parsedRequest = this.parseChatRequest(sessionResource, remote.message, model.initialLocation, undefined);
+            const requestModel = ( new ChatRequestModel({
+                session: model,
+                message: parsedRequest,
+                variableData,
+                timestamp: remote.timestamp,
+                attachedContext: variableData.variables.slice(),
+                restoredId: remote.id
+            }));
+            return {
+                request: requestModel,
+                kind: remote.kind,
+                sendOptions: local?.sendOptions ?? {}
+            };
+        }));
+        if (existing.length === reconciled.length && reconciled.every((request, index) => existing[index] === request)) {
+            return;
+        }
+        const reconciledIds = ( new Set(( reconciled.map(request => request.request.id))));
+        model.replacePendingRequests(reconciled);
+        for (const local of existing) {
+            if (( reconciledIds.has(local.request.id))) {
+                continue;
+            }
+            const deferred = this._queuedRequestDeferreds.get(local.request.id);
+            if (deferred) {
+                deferred.complete({
+                    kind: "rejected",
+                    reason: "Request was removed from queue"
+                });
+                this._queuedRequestDeferreds.delete(local.request.id);
+            }
+        }
+        if (!( reconciled.some(request => request.kind === ChatRequestQueueKind.Steering))) {
+            this._pendingRequests.get(sessionResource)?.resetYieldRequested();
+        }
+    }
     async sendPendingRequestImmediately(sessionResource, requestId) {
         const model = this._sessionModels.get(sessionResource);
         if (!model) {
@@ -2015,7 +2368,7 @@ let ChatService = class ChatService extends Disposable {
 };
 ChatService = ( __decorate([( __param(0, IStorageService)), ( __param(1, ILogService)), ( __param(2, ITelemetryService)), ( __param(3, IExtensionService)), ( __param(4, IInstantiationService)), ( __param(5, IWorkspaceContextService)), ( __param(6, IChatSlashCommandService)), ( __param(7, IChatAgentService)), ( __param(8, IConfigurationService)), ( __param(9, IChatTransferService)), ( __param(10, IChatSessionsService)), ( __param(11, IMcpService)), ( __param(12, IPromptsService)), ( __param(13, IChatEntitlementService)), ( __param(14, ILanguageModelsService)), ( __param(15, IChatDebugService))], ChatService));
 async function chatModelToChatDetail(model) {
-    const title = model.title || ( localize(8540, "New Chat"));
+    const title = model.title || ( localize(10249, "New Chat"));
     return {
         sessionResource: model.sessionResource,
         title,
@@ -2028,4 +2381,4 @@ async function chatModelToChatDetail(model) {
     };
 }
 
-export { ChatService, chatModelToChatDetail };
+export { ChatService, backfillRestoredPickerState, backfillTransferredModel, chatModelToChatDetail };