@codingame/monaco-vscode-chat-service-override 32.0.1 → 33.0.4

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginsView.js

@@ -92,7 +92,7 @@ let UpdatePluginAction = class UpdatePluginAction extends Action {
         pluginInstallService,
         pluginMarketplaceService
     ) {
-        super(UpdatePluginAction_1.ID, ( localize(5158, "Update")), "extension-action label prominent install");
+        super(UpdatePluginAction_1.ID, ( localize(5191, "Update")), "extension-action label prominent install");
         this.plugin = plugin;
         this.liveMarketplacePlugin = liveMarketplacePlugin;
         this.pluginInstallService = pluginInstallService;
@@ -120,7 +120,7 @@ let ManagePluginAction = class ManagePluginAction extends Action {
         this.getActionGroups = getActionGroups;
         this.instantiationService = instantiationService;
         this._actionViewItem = null;
-        this.tooltip = ( localize(5159, "Manage"));
+        this.tooltip = ( localize(5192, "Manage"));
     }
     createActionViewItem(options) {
         this._actionViewItem = this.instantiationService.createInstance(DropDownActionViewItem, this, options);
@@ -357,7 +357,7 @@ let AgentPluginsListView = class AgentPluginsListView extends AbstractExtensions
                         return item?.name ?? "";
                     },
                     getWidgetAriaLabel() {
-                        return localize(5160, "Agent Plugins");
+                        return localize(5193, "Agent Plugins");
                     }
                 },
                 overrideStyles: getLocationBasedViewColors(this.viewDescriptorService.getViewLocationById(this.id)).listOverrideStyles
@@ -532,7 +532,7 @@ let AgentPluginsListView = class AgentPluginsListView extends AbstractExtensions
             this.bodyTemplate.pluginsList.classList.toggle("hidden", count === 0);
             this.bodyTemplate.messageContainer.classList.toggle("hidden", count > 0);
             if (count === 0 && this.isBodyVisible()) {
-                this.bodyTemplate.messageBox.textContent = ( localize(5161, "No agent plugins found."));
+                this.bodyTemplate.messageBox.textContent = ( localize(5194, "No agent plugins found."));
             }
         }
     }
@@ -542,8 +542,8 @@ class AgentPluginsBrowseCommand extends Action2 {
     constructor() {
         super({
             id: "workbench.agentPlugins.browse",
-            title: ( localize2(5162, "Agent Plugins")),
-            tooltip: ( localize2(5163, "Browse Agent Plugins")),
+            title: ( localize2(5195, "Agent Plugins")),
+            tooltip: ( localize2(5196, "Browse Agent Plugins")),
             icon: Codicon.search,
             precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ChatContextKeys.Setup.disabledInWorkspace.negate()))),
             menu: [{
@@ -566,8 +566,8 @@ class CheckForPluginUpdatesCommand extends Action2 {
     constructor() {
         super({
             id: "workbench.agentPlugins.checkForUpdates",
-            title: ( localize2(5164, "Update Plugins")),
-            category: ( localize2(5165, "Chat")),
+            title: ( localize2(5197, "Update Plugins")),
+            category: ( localize2(5198, "Chat")),
             precondition: ChatContextKeys.enabled,
             f1: true
         });
@@ -580,8 +580,8 @@ class ForceUpdatePluginsCommand extends Action2 {
     constructor() {
         super({
             id: "workbench.agentPlugins.forceUpdate",
-            title: ( localize2(5166, "Update Plugins (Force)")),
-            category: ( localize2(5165, "Chat")),
+            title: ( localize2(5199, "Update Plugins (Force)")),
+            category: ( localize2(5198, "Chat")),
             precondition: ChatContextKeys.enabled,
             f1: true
         });
@@ -607,7 +607,7 @@ let AgentPluginsViewsContribution = class AgentPluginsViewsContribution extends
         registerAction2(ForceUpdatePluginsCommand);
         ( Registry.as(Extensions.ViewsRegistry)).registerViews([{
             id: InstalledAgentPluginsViewId,
-            name: ( localize2(5167, "Agent Plugins - Installed")),
+            name: ( localize2(5200, "Agent Plugins - Installed")),
             ctorDescriptor: ( new SyncDescriptor(AgentPluginsListView, [{
                 installedOnly: true
             }])),
@@ -617,7 +617,7 @@ let AgentPluginsViewsContribution = class AgentPluginsViewsContribution extends
             canToggleVisibility: true
         }, {
             id: "workbench.views.agentPlugins.default.marketplace",
-            name: ( localize2(5168, "Agent Plugins")),
+            name: ( localize2(5201, "Agent Plugins")),
             ctorDescriptor: ( new SyncDescriptor(AgentPluginsListView, [{}])),
             when: ( ContextKeyExpr.and(DefaultViewsContext, ( HasInstalledAgentPluginsContext.toNegated()), ( ChatContextKeys.Setup.hidden.negate()))),
             weight: 30,
@@ -626,7 +626,7 @@ let AgentPluginsViewsContribution = class AgentPluginsViewsContribution extends
             hideByDefault: true
         }, {
             id: "workbench.views.agentPlugins.marketplace",
-            name: ( localize2(5168, "Agent Plugins")),
+            name: ( localize2(5201, "Agent Plugins")),
             ctorDescriptor: ( new SyncDescriptor(AgentPluginsListView, [{}])),
             when: ( ContextKeyExpr.and(SearchAgentPluginsContext, ( ChatContextKeys.Setup.hidden.negate())))
         }], VIEW_CONTAINER);

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostPermissionUiContribution.js

@@ -64,23 +64,23 @@ let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution
         const path = request.uri.scheme === Schemas.file ? request.uri.fsPath : ( request.uri.toString());
         const fence = "`".repeat((path.match(/`+/g)?.reduce((m, s) => Math.max(m, s.length), 0) ?? 0) + 1);
         const codePath = `${fence}${path}${fence}`;
-        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(5169, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5170, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
-        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5171, "+1 more request waiting")) : ( localize(5172, "+{0} more requests waiting", totalPending - 1)) : undefined;
+        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(5213, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5214, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
+        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5215, "+1 more request waiting")) : ( localize(5216, "+{0} more requests waiting", totalPending - 1)) : undefined;
         return {
             id: AgentHostPermissionUiContribution_1.NOTIFICATION_ID,
             severity: ChatInputNotificationSeverity.Warning,
             message,
             description,
             actions: [{
-                label: ( localize(5173, "Deny")),
+                label: ( localize(5217, "Deny")),
                 commandId: DENY_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5174, "Allow")),
+                label: ( localize(5218, "Allow")),
                 commandId: ALLOW_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5175, "Always Allow")),
+                label: ( localize(5219, "Always Allow")),
                 commandId: ALLOW_ALWAYS_COMMAND,
                 commandArgs: [request.id]
             }],

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.d.ts

@@ -0,0 +1,51 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import type { ResolveSessionConfigResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
+export declare class AgentHostUntitledProvisionalSessionService extends Disposable implements IAgentHostUntitledProvisionalSessionService {
+    private readonly _agentHostService;
+    private readonly _logService;
+    private readonly _configurationService;
+    private readonly _environmentService;
+    readonly _serviceBrand: undefined;
+    private readonly _entries;
+    private readonly _pending;
+    private readonly _rebound;
+    private readonly _sequencer;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<URI>;
+    constructor(_agentHostService: IAgentHostService, _logService: ILogService, chatService: IChatService, _configurationService: IConfigurationService, _environmentService: IWorkbenchEnvironmentService);
+    get(sessionResource: URI): URI | undefined;
+    waitForPending(sessionResource: URI): Promise<URI | undefined>;
+    getOrCreate(sessionResource: URI, provider: string, workingDirectory: URI | undefined): Promise<URI | undefined>;
+    tryRebind(oldSessionResource: URI, newSessionResource: URI, provider: string, workingDirectory: URI | undefined): Promise<URI | undefined>;
+    disposeSession(sessionResource: URI): Promise<void>;
+    dispose(): void;
+    /**
+     * Convert the chat-input UI session URI (`agent-host-PROVIDER:/<id>`)
+     * to the agent-host backend URI (`PROVIDER:/<id>`).
+     */
+    private _toBackendUri;
+    getResolvedConfig(sessionResource: URI): ResolveSessionConfigResult | undefined;
+    applyConfigChange(sessionResource: URI, provider: string, workingDirectory: URI | undefined, partial: Record<string, unknown>): Promise<URI | undefined>;
+    /**
+     * Workbench-side initial config seed sent at `createSession` time so the
+     * agent's own server-side defaults don't fill `state.config.values` for
+     * keys the workbench wants to control. Without this, the merge filter in
+     * `agentHostSessionHandler` sees those agent defaults as "user-set" and
+     * drops the workbench defaults.
+     *
+     * - `isolation`: workbench has no isolation picker, so always `'folder'`.
+     * - `autoApprove`: seeded from `chat.permissions.default`, clamped to
+     *   `'default'` when the `chat.tools.global.autoApprove` policy is off.
+     *
+     * Skipped entirely in the Agents window, where the sessions provider
+     * supplies config via `request.agentHostSessionConfig` instead.
+     */
+    private _getInitialConfig;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.js

@@ -0,0 +1,267 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { SequencerByKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { SessionConfigKey, KNOWN_AUTO_APPROVE_VALUES } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisionalSessionService extends Disposable {
+    constructor(
+        _agentHostService,
+        _logService,
+        chatService,
+        _configurationService,
+        _environmentService
+    ) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._logService = _logService;
+        this._configurationService = _configurationService;
+        this._environmentService = _environmentService;
+        this._entries = ( new ResourceMap());
+        this._pending = ( new ResourceMap());
+        this._rebound = ( new ResourceSet());
+        this._sequencer = ( new SequencerByKey());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(chatService.onDidDisposeSession(e => {
+            for (const sessionResource of e.sessionResources) {
+                if (( this._entries.has(sessionResource))) {
+                    void this.disposeSession(sessionResource);
+                }
+                this._rebound.delete(sessionResource);
+            }
+        }));
+    }
+    get(sessionResource) {
+        return this._entries.get(sessionResource)?.backendSession;
+    }
+    async waitForPending(sessionResource) {
+        const inflight = this._pending.get(sessionResource);
+        if (inflight) {
+            await inflight;
+        }
+        return this.get(sessionResource);
+    }
+    getOrCreate(sessionResource, provider, workingDirectory) {
+        const existing = this.get(sessionResource);
+        if (existing) {
+            return Promise.resolve(existing);
+        }
+        if (( this._rebound.has(sessionResource))) {
+            return Promise.resolve(undefined);
+        }
+        const inflight = this._pending.get(sessionResource);
+        if (inflight) {
+            return inflight;
+        }
+        const work = this._sequencer.queue(( sessionResource.toString()), async () => {
+            const settled = this.get(sessionResource);
+            if (settled) {
+                return settled;
+            }
+            const backendSession = this._toBackendUri(sessionResource, provider);
+            const initialConfig = this._getInitialConfig();
+            try {
+                const created = await this._agentHostService.createSession({
+                    provider,
+                    session: backendSession,
+                    workingDirectory,
+                    config: initialConfig
+                });
+                this._entries.set(sessionResource, {
+                    backendSession: created,
+                    config: {
+                        ...(initialConfig ?? {})
+                    }
+                });
+                this._onDidChange.fire(sessionResource);
+                return created;
+            } catch (err) {
+                this._logService.warn(
+                    `[AgentHostProvisional] Failed to create provisional session for ${( sessionResource.toString())}: ${err instanceof Error ? err.message : String(err)}`
+                );
+                return undefined;
+            }
+        });
+        this._pending.set(sessionResource, work);
+        work.finally(() => {
+            if (this._pending.get(sessionResource) === work) {
+                this._pending.delete(sessionResource);
+            }
+        });
+        return work;
+    }
+    async tryRebind(oldSessionResource, newSessionResource, provider, workingDirectory) {
+        const alreadyBound = this.get(newSessionResource);
+        if (alreadyBound) {
+            return alreadyBound;
+        }
+        await this.waitForPending(oldSessionResource);
+        const oldEntry = this._entries.get(oldSessionResource);
+        if (!oldEntry) {
+            return undefined;
+        }
+        const config = oldEntry.config;
+        const newBackendSession = this._toBackendUri(newSessionResource, provider);
+        let created;
+        try {
+            created = await this._agentHostService.createSession({
+                provider,
+                session: newBackendSession,
+                workingDirectory,
+                config
+            });
+        } catch (err) {
+            this._logService.warn(
+                `[AgentHostProvisional] Failed to create rebound provisional: ${err instanceof Error ? err.message : String(err)}`
+            );
+            return undefined;
+        }
+        this._entries.set(newSessionResource, {
+            backendSession: created,
+            config: {
+                ...config
+            }
+        });
+        this._entries.delete(oldSessionResource);
+        this._rebound.add(oldSessionResource);
+        this._onDidChange.fire(newSessionResource);
+        this._agentHostService.disposeSession(oldEntry.backendSession).catch(err => {
+            this._logService.warn(
+                `[AgentHostProvisional] Failed to dispose temporary provisional ${( oldEntry.backendSession.toString())}: ${err instanceof Error ? err.message : String(err)}`
+            );
+        });
+        return created;
+    }
+    async disposeSession(sessionResource) {
+        await this.waitForPending(sessionResource);
+        const entry = this._entries.get(sessionResource);
+        if (!entry) {
+            return;
+        }
+        this._entries.delete(sessionResource);
+        this._onDidChange.fire(sessionResource);
+        try {
+            await this._agentHostService.disposeSession(entry.backendSession);
+        } catch (err) {
+            this._logService.warn(`[AgentHostProvisional] Failed to dispose provisional ${( entry.backendSession.toString())}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    dispose() {
+        for (const [, entry] of this._entries) {
+            this._agentHostService.disposeSession(entry.backendSession).catch(() => {});
+        }
+        this._entries.clear();
+        this._pending.clear();
+        this._rebound.clear();
+        super.dispose();
+    }
+    _toBackendUri(sessionResource, provider) {
+        const rawId = sessionResource.path.replace(/^\//, "");
+        return ( URI.from({
+            scheme: provider,
+            path: `/${rawId}`
+        }));
+    }
+    getResolvedConfig(sessionResource) {
+        return this._entries.get(sessionResource)?.resolvedConfig;
+    }
+    async applyConfigChange(sessionResource, provider, workingDirectory, partial) {
+        const preExisting = this._entries.get(sessionResource);
+        if (preExisting) {
+            Object.assign(preExisting.config, partial);
+            if (preExisting.resolvedConfig) {
+                preExisting.resolvedConfig = {
+                    ...preExisting.resolvedConfig,
+                    values: {
+                        ...preExisting.resolvedConfig.values,
+                        ...partial
+                    }
+                };
+            }
+        }
+        const backend = await this.getOrCreate(sessionResource, provider, workingDirectory);
+        if (!backend) {
+            return undefined;
+        }
+        if (!preExisting) {
+            const entry = this._entries.get(sessionResource);
+            if (entry) {
+                Object.assign(entry.config, partial);
+            }
+        }
+        this._agentHostService.dispatch({
+            type: ActionType.SessionConfigChanged,
+            session: ( backend.toString()),
+            config: partial
+        });
+        return this._sequencer.queue(( sessionResource.toString()), async () => {
+            const current = this._entries.get(sessionResource);
+            if (!current) {
+                return backend;
+            }
+            try {
+                const resolved = await this._agentHostService.resolveSessionConfig({
+                    provider,
+                    workingDirectory,
+                    config: {
+                        ...current.config
+                    }
+                });
+                const stillCurrent = this._entries.get(sessionResource);
+                if (stillCurrent === current) {
+                    const resolvedValues = {
+                        ...resolved.values
+                    };
+                    const mergedConfig = {
+                        ...stillCurrent.config,
+                        ...resolvedValues
+                    };
+                    const configChanged = !equals(stillCurrent.config, mergedConfig);
+                    const resolvedChanged = !equals(stillCurrent.resolvedConfig, resolved);
+                    if (configChanged || resolvedChanged) {
+                        stillCurrent.config = mergedConfig;
+                        stillCurrent.resolvedConfig = resolved;
+                        this._onDidChange.fire(sessionResource);
+                    }
+                }
+            } catch (err) {
+                this._logService.warn(
+                    `[AgentHostProvisional] schema re-resolve failed: ${err instanceof Error ? err.message : String(err)}`
+                );
+            }
+            return backend;
+        });
+    }
+    _getInitialConfig() {
+        if (this._environmentService.isSessionsWindow) {
+            return undefined;
+        }
+        const config = {
+            [SessionConfigKey.Isolation]: "folder"
+        };
+        const configured = this._configurationService.getValue(ChatConfiguration.DefaultPermissionLevel);
+        const policyValue = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue;
+        if (typeof configured === "string" && ( KNOWN_AUTO_APPROVE_VALUES.has(configured))) {
+            const policyRestricted = policyValue === false;
+            config[SessionConfigKey.AutoApprove] = policyRestricted ? "default" : configured;
+        }
+        return config;
+    }
+};
+AgentHostUntitledProvisionalSessionService = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, ILogService)), ( __param(2, IChatService)), ( __param(3, IConfigurationService)), ( __param(4, IWorkbenchEnvironmentService))], AgentHostUntitledProvisionalSessionService));
+
+export { AgentHostUntitledProvisionalSessionService };

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

@@ -16,6 +16,7 @@ import { registerAction2, MenuRegistry, MenuId } from '@codingame/monaco-vscode-
 import { FocusAgentSessionsAction, PickAgentSessionAction, ArchiveAllAgentSessionsAction, MarkAllAgentSessionsReadAction, ArchiveAgentSessionSectionAction, UnarchiveAgentSessionSectionAction, MarkAgentSessionSectionReadAction, CollapseAllAgentSessionSectionsAction, ArchiveAgentSessionAction, UnarchiveAgentSessionAction, PinAgentSessionAction, UnpinAgentSessionAction, RenameAgentSessionAction, DeleteAgentSessionAction, DeleteAllLocalSessionsAction, MarkAgentSessionUnreadAction, MarkAgentSessionReadAction, OpenAgentSessionInNewWindowAction, OpenAgentSessionInEditorGroupAction, OpenAgentSessionInNewEditorGroupAction, RefreshAgentSessionsViewerAction, FindAgentSessionInViewerAction, ShowAgentSessionsSidebar, HideAgentSessionsSidebar, ToggleAgentSessionsSidebar, ToggleShowAgentSessionsAction, SetAgentSessionsOrientationStackedAction, SetAgentSessionsOrientationSideBySideAction } from './agentSessionsActions.js';
 import { AGENT_SESSIONS_QUICK_ACCESS_PREFIX, AgentSessionsQuickAccessProvider } from './agentSessionsQuickAccess.js';
 import { AgentHostPermissionUiContribution } from './agentHost/agentHostPermissionUiContribution.js';
+import '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatInputPicker.contribution';
 
 registerAction2(FocusAgentSessionsAction);
 registerAction2(PickAgentSessionAction);
@@ -47,7 +48,7 @@ registerAction2(SetAgentSessionsOrientationStackedAction);
 registerAction2(SetAgentSessionsOrientationSideBySideAction);
 MenuRegistry.appendMenuItem(MenuId.AgentSessionsToolbar, {
     submenu: MenuId.AgentSessionsViewerFilterSubMenu,
-    title: ( localize2(5183, "Filter Agent Sessions")),
+    title: ( localize2(5227, "Filter Agent Sessions")),
     group: "navigation",
     order: 3,
     icon: Codicon.filter
@@ -117,9 +118,9 @@ MenuRegistry.appendMenuItem(MenuId.ChatViewSessionTitleToolbar, {
     prefix: AGENT_SESSIONS_QUICK_ACCESS_PREFIX,
     contextKey: "inAgentSessionsPicker",
     when: ChatContextKeys.enabled,
-    placeholder: ( localize(5184, "Search agent sessions by name")),
+    placeholder: ( localize(5228, "Search agent sessions by name")),
     helpEntries: [{
-        description: ( localize(5185, "Show All Agent Sessions")),
+        description: ( localize(5229, "Show All Agent Sessions")),
         commandId: "workbench.action.chat.history"
     }]
 });