@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.1

package/vscode/src/vs/workbench/contrib/agentsVoice/common/voiceTranscriptStore.d.ts

@@ -0,0 +1,132 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IUserDataProfilesService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IVoiceTranscriptStore } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/agentsVoice/common/voiceTranscriptStore.service";
+/**
+ * Discriminates what produced this entry. Only ``user_voice`` and
+ * ``agent_voice`` are rendered in the transcripts UI; ``agent_tool_call`` and
+ * ``coding_event`` are persisted so we can replay them as cross-session
+ * context to the backend without polluting the visible transcript.
+ *
+ *   user_voice       — what the user said (ASR-committed)
+ *   agent_voice      — what the voice agent spoke back (TTS text)
+ *   agent_tool_call  — a tool the voice agent dispatched (send_to_chat, etc.)
+ *   coding_event     — a status transition on a Copilot coding session
+ *                       (started, finished, needs-input, errored)
+ */
+export type VoiceTranscriptKind = "user_voice" | "agent_voice" | "agent_tool_call" | "coding_event";
+/**
+ * Free-form metadata for non-voice entries. Field meaning depends on ``kind``:
+ *   agent_tool_call: { toolName, toolArgs? }
+ *   coding_event:    { codingSessionId, codingStatus, codingSessionLabel? }
+ */
+export interface IVoiceTranscriptEntryMetadata {
+    readonly toolName?: string;
+    readonly toolArgs?: Record<string, unknown>;
+    readonly codingSessionId?: string;
+    readonly codingStatus?: string;
+    readonly codingSessionLabel?: string;
+}
+/**
+ * One committed entry in a voice conversation timeline. Persisted as a single
+ * JSON line in the user's transcript JSONL file.
+ *
+ * Local-only — voice_code's backend does not have persistent conversation
+ * memory today. Entry IDs are generated client-side; ``ancestorIds`` chains
+ * the entries we have written so far.
+ *
+ * Backwards-compat note: older builds wrote entries without ``kind`` /
+ * ``metadata`` and only with ``role``. The store auto-wipes any such file on
+ * first read so we never have to read mixed-schema data in memory.
+ */
+export interface IVoiceTranscriptTurn {
+    /** Locally-generated entry id. */
+    readonly turnId: string;
+    /** Local ancestor entry ids, root → parent (the previous entry's turnId, or empty for the first entry). */
+    readonly ancestorIds: readonly string[];
+    /** What produced this entry. */
+    readonly kind: VoiceTranscriptKind;
+    /**
+     * Legacy/display role. Kept so the existing transcripts ViewPane can
+     * label rows without inspecting ``kind``. For non-voice kinds this is set
+     * to ``'assistant'`` (the entry is something the agent did).
+     */
+    readonly role: "user" | "assistant";
+    /**
+     * Human-readable text for this entry. For voice kinds this is the spoken
+     * sentence. For tool-call / coding-event kinds it is a one-line summary
+     * suitable for context replay (e.g. ``"called send_to_chat(text=...)"``).
+     */
+    readonly text: string;
+    /** Wall-clock time at the moment of persistence. ISO 8601 string. */
+    readonly timestamp: string;
+    /** Optional kind-specific structured fields. */
+    readonly metadata?: IVoiceTranscriptEntryMetadata;
+}
+/**
+ * Index of all transcripts known on this machine. Persisted via
+ * ``IStorageService`` (scope PROFILE, target MACHINE). One entry per
+ * GitHub login that has ever spoken on this machine.
+ */
+export interface IVoiceTranscriptIndex {
+    readonly entries: {
+        [userId: string]: IVoiceTranscriptIndexEntry;
+    };
+    readonly version: 1;
+}
+export interface IVoiceTranscriptIndexEntry {
+    /** GitHub login — partition key, doubles as filename stem. */
+    readonly userId: string;
+    /** ISO timestamp of first ever turn for this user. */
+    readonly createdAt: string;
+    /** ISO timestamp of most recent appended turn. */
+    readonly lastUpdatedAt: string;
+    /** Total turn count for this user. */
+    readonly turnCount: number;
+    /** Optional archive cutoff. Turns with timestamp < archivedBefore are hidden in the UI by default. */
+    readonly archivedBefore?: string;
+}
+/**
+ * Local on-disk transcript store for the Agents Voice feature.
+ *
+ * Layout (mirrors the chatSessionStore precedent, adapted for the per-user
+ * single-conversation model used by voice):
+ *
+ *   <globalStorageHome>/voiceTranscripts/<githubLogin>.jsonl   (append-only)
+ *   IStorageService[AgentsVoiceStorageKeys.TranscriptIndex]    (PROFILE/MACHINE)
+ *
+ * Writes are serialized via a ``Sequencer`` so simultaneous appendTurn calls
+ * preserve line ordering. A shutdown flush is registered so a final append
+ * completes before the window closes.
+ */
+export declare class VoiceTranscriptStore extends Disposable implements IVoiceTranscriptStore {
+    private readonly fileService;
+    private readonly storageService;
+    private readonly lifecycleService;
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private readonly storageRoot;
+    private readonly writeQueue;
+    /** Cached snapshot of the index; we read once at startup and write through. */
+    private indexCache;
+    private pendingWrite;
+    private shuttingDown;
+    constructor(fileService: IFileService, storageService: IStorageService, userDataProfilesService: IUserDataProfilesService, lifecycleService: ILifecycleService, logService: ILogService);
+    appendTurn(userId: string, turn: IVoiceTranscriptTurn): Promise<void>;
+    loadTurns(userId: string, opts?: {
+        since?: string;
+        limit?: number;
+    }): Promise<IVoiceTranscriptTurn[]>;
+    getIndexEntry(userId: string): IVoiceTranscriptIndexEntry | undefined;
+    archiveUpTo(userId: string, cutoff: string): Promise<void>;
+    unarchive(userId: string): Promise<void>;
+    deleteAll(userId: string): Promise<void>;
+    private fileFor;
+    private doAppendTurn;
+    private updateIndexEntry;
+    private flushIndex;
+    private readIndexFromStorage;
+}

package/vscode/src/vs/workbench/contrib/agentsVoice/common/voiceTranscriptStore.js

@@ -0,0 +1,237 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Sequencer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { toFileOperationResult, FileOperationResult } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.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 { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { AgentsVoiceStorageKeys } from './agentsVoice.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+let VoiceTranscriptStore = class VoiceTranscriptStore extends Disposable {
+    constructor(
+        fileService,
+        storageService,
+        userDataProfilesService,
+        lifecycleService,
+        logService
+    ) {
+        super();
+        this.fileService = fileService;
+        this.storageService = storageService;
+        this.lifecycleService = lifecycleService;
+        this.logService = logService;
+        this.writeQueue = ( new Sequencer());
+        this.shuttingDown = false;
+        this.storageRoot = joinPath(
+            userDataProfilesService.defaultProfile.globalStorageHome,
+            "voiceTranscripts"
+        );
+        this.indexCache = this.readIndexFromStorage();
+        this._register(this.lifecycleService.onWillShutdown(e => {
+            this.shuttingDown = true;
+            if (!this.pendingWrite) {
+                return;
+            }
+            e.join(this.pendingWrite, {
+                id: "join.voiceTranscriptStore",
+                label: ( localize(4874, "Saving voice transcript"))
+            });
+        }));
+    }
+    async appendTurn(userId, turn) {
+        if (this.shuttingDown) {
+            this.logService.warn(`VoiceTranscriptStore: ignoring appendTurn for ${userId} (shutting down)`);
+            return;
+        }
+        const work = this.writeQueue.queue(() => this.doAppendTurn(userId, turn));
+        this.pendingWrite = work;
+        try {
+            await work;
+        } finally {
+            if (this.pendingWrite === work) {
+                this.pendingWrite = undefined;
+            }
+        }
+    }
+    async loadTurns(userId, opts) {
+        const file = this.fileFor(userId);
+        let raw;
+        try {
+            const content = await this.fileService.readFile(file);
+            raw = ( content.value.toString());
+        } catch (e) {
+            if (toFileOperationResult(e) === FileOperationResult.FILE_NOT_FOUND) {
+                return [];
+            }
+            this.logService.error(`VoiceTranscriptStore: failed to read transcript for ${userId}`, e);
+            return [];
+        }
+        const turns = [];
+        let sawLegacyEntry = false;
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (!parsed.kind) {
+                    sawLegacyEntry = true;
+                    break;
+                }
+                if (opts?.since && parsed.timestamp && parsed.timestamp < opts.since) {
+                    continue;
+                }
+                turns.push(parsed);
+            } catch (e) {
+                this.logService.warn(
+                    `VoiceTranscriptStore: skipping malformed line in ${userId}.jsonl: ${e.message}`
+                );
+            }
+        }
+        if (sawLegacyEntry) {
+            this.logService.info(
+                `VoiceTranscriptStore: detected pre-timeline transcript for ${userId}, wiping for new schema`
+            );
+            await this.deleteAll(userId);
+            return [];
+        }
+        if (opts?.limit !== undefined && turns.length > opts.limit) {
+            return turns.slice(turns.length - opts.limit);
+        }
+        return turns;
+    }
+    getIndexEntry(userId) {
+        return this.indexCache.entries[userId];
+    }
+    async archiveUpTo(userId, cutoff) {
+        const existing = this.indexCache.entries[userId];
+        if (!existing) {
+            return;
+        }
+        this.updateIndexEntry(userId, {
+            ...existing,
+            archivedBefore: cutoff
+        });
+    }
+    async unarchive(userId) {
+        const existing = this.indexCache.entries[userId];
+        if (!existing) {
+            return;
+        }
+        const {
+            archivedBefore: _unused,
+            ...rest
+        } = existing;
+        this.updateIndexEntry(userId, rest);
+    }
+    async deleteAll(userId) {
+        const file = this.fileFor(userId);
+        try {
+            await this.fileService.del(file);
+        } catch (e) {
+            if (toFileOperationResult(e) !== FileOperationResult.FILE_NOT_FOUND) {
+                this.logService.error(`VoiceTranscriptStore: failed to delete transcript for ${userId}`, e);
+            }
+        }
+        const next = {
+            ...this.indexCache.entries
+        };
+        delete next[userId];
+        this.indexCache = {
+            ...this.indexCache,
+            entries: next
+        };
+        this.flushIndex();
+    }
+    fileFor(userId) {
+        const safe = userId.replace(/[^A-Za-z0-9-]/g, "_");
+        if (!safe) {
+            throw ( new Error("Invalid userId for transcript storage"));
+        }
+        return joinPath(this.storageRoot, `${safe}.jsonl`);
+    }
+    async doAppendTurn(userId, turn) {
+        const file = this.fileFor(userId);
+        const line = JSON.stringify(turn) + "\n";
+        try {
+            try {
+                await this.fileService.createFolder(this.storageRoot);
+            } catch {}
+            await this.fileService.writeFile(file, VSBuffer.fromString(line), {
+                append: true
+            });
+        } catch (e) {
+            this.logService.error(`VoiceTranscriptStore: failed to append turn for ${userId}`, e);
+            return;
+        }
+        const existing = this.indexCache.entries[userId];
+        const next = existing ? {
+            ...existing,
+            lastUpdatedAt: turn.timestamp,
+            turnCount: existing.turnCount + 1
+        } : {
+            userId,
+            createdAt: turn.timestamp,
+            lastUpdatedAt: turn.timestamp,
+            turnCount: 1
+        };
+        this.updateIndexEntry(userId, next);
+    }
+    updateIndexEntry(userId, entry) {
+        this.indexCache = {
+            ...this.indexCache,
+            entries: {
+                ...this.indexCache.entries,
+                [userId]: entry
+            }
+        };
+        this.flushIndex();
+    }
+    flushIndex() {
+        try {
+            this.storageService.store(
+                AgentsVoiceStorageKeys.TranscriptIndex,
+                JSON.stringify(this.indexCache),
+                StorageScope.PROFILE,
+                StorageTarget.MACHINE
+            );
+        } catch (e) {
+            this.logService.error(`VoiceTranscriptStore: failed to flush transcript index`, e);
+        }
+    }
+    readIndexFromStorage() {
+        const raw = this.storageService.get(AgentsVoiceStorageKeys.TranscriptIndex, StorageScope.PROFILE);
+        if (!raw) {
+            return {
+                entries: {},
+                version: 1
+            };
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object" && parsed.entries && parsed.version === 1) {
+                return parsed;
+            }
+            this.logService.warn("VoiceTranscriptStore: ignoring index with unknown shape, starting fresh");
+        } catch (e) {
+            this.logService.warn("VoiceTranscriptStore: failed to parse stored index, starting fresh", e);
+        }
+        return {
+            entries: {},
+            version: 1
+        };
+    }
+};
+VoiceTranscriptStore = ( __decorate([( __param(0, IFileService)), ( __param(1, IStorageService)), ( __param(2, IUserDataProfilesService)), ( __param(3, ILifecycleService)), ( __param(4, ILogService))], VoiceTranscriptStore));
+
+export { VoiceTranscriptStore };

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatAccessibilityService.js

@@ -117,7 +117,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             });
         }
         this.toasts.clearAndDisposeAll();
-        const title = widget?.viewModel?.model.title ? ( localize(4844, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4845, "Untitled Chat"));
+        const title = widget?.viewModel?.model.title ? ( localize(5040, "Chat: {0}", widget.viewModel.model.title)) : ( localize(5041, "Untitled Chat"));
         const cts = ( new CancellationTokenSource());
         const disposable = toDisposable(() => cts.dispose(true));
         this.toasts.add(disposable);
@@ -125,7 +125,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             clicked
         } = await this._hostService.showToast({
             title,
-            body: ( localize(4846, "New chat response."))
+            body: ( localize(5042, "New chat response."))
         }, cts.token);
         this.toasts.deleteAndDispose(disposable);
         if (clicked) {

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatResponseAccessibleView.d.ts

@@ -6,7 +6,7 @@ import { IAccessibleViewImplementation } from "@codingame/monaco-vscode-api/vsco
 import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { AccessibilityVerbositySettingId } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration";
-import { IChatExtensionsContent, IChatModifiedFilesConfirmationData, IChatPullRequestContent, IChatSearchToolInvocationData, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTerminalToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, IChatToolResourcesInvocationData, ILegacyChatTerminalToolInvocationData, IToolResultOutputDetailsSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatAgentFeedbackReviewConfirmationData, IChatExtensionsContent, IChatModifiedFilesConfirmationData, IChatPullRequestContent, IChatSearchToolInvocationData, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTerminalToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, IChatToolResourcesInvocationData, ILegacyChatTerminalToolInvocationData, IToolResultOutputDetailsSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IToolResultInputOutputDetails, IToolResultOutputDetails } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { ChatTreeItem, IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 import { Location } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
@@ -17,7 +17,7 @@ export declare class ChatResponseAccessibleView implements IAccessibleViewImplem
     readonly when: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").RawContextKey<boolean>;
     getProvider(accessor: ServicesAccessor): ChatResponseAccessibleProvider | undefined;
 }
-type ToolSpecificData = IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData;
+type ToolSpecificData = IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData;
 type ResultDetails = Array<URI | Location> | IToolResultInputOutputDetails | IToolResultOutputDetails | IToolResultOutputDetailsSerialized;
 export declare const CHAT_ACCESSIBLE_VIEW_INCLUDE_THINKING_STORAGE_KEY = "chat.accessibleView.includeThinking";
 export declare function isThinkingContentIncludedInAccessibleView(storageService: IStorageService): boolean;

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatResponseAccessibleView.js

@@ -78,29 +78,29 @@ function getToolSpecificDataDescription(toolSpecificData) {
         {
             const parts = [];
             if (toolSpecificData.agentName) {
-                parts.push(( localize(4847, "Agent: {0}", toolSpecificData.agentName)));
+                parts.push(( localize(5043, "Agent: {0}", toolSpecificData.agentName)));
             }
             if (toolSpecificData.description) {
                 parts.push(toolSpecificData.description);
             }
             if (toolSpecificData.prompt) {
-                parts.push(( localize(4848, "Task: {0}", toolSpecificData.prompt)));
+                parts.push(( localize(5044, "Task: {0}", toolSpecificData.prompt)));
             }
             return parts.join(". ") || "";
         }
     case "extensions":
-        return toolSpecificData.extensions.length > 0 ? ( localize(4849, "Extensions: {0}", toolSpecificData.extensions.join(", "))) : "";
+        return toolSpecificData.extensions.length > 0 ? ( localize(5045, "Extensions: {0}", toolSpecificData.extensions.join(", "))) : "";
     case "todoList":
         {
             const todos = toolSpecificData.todoList;
             if (todos.length === 0) {
                 return "";
             }
-            const todoDescriptions = ( todos.map(t => ( localize(4850, "{0} ({1})", t.title, t.status))));
-            return localize(4851, "{0} items: {1}", todos.length, todoDescriptions.join("; "));
+            const todoDescriptions = ( todos.map(t => ( localize(5046, "{0} ({1})", t.title, t.status))));
+            return localize(5047, "{0} items: {1}", todos.length, todoDescriptions.join("; "));
         }
     case "pullRequest":
-        return localize(4852, "PR: {0} by {1}", toolSpecificData.title, toolSpecificData.author);
+        return localize(5048, "PR: {0} by {1}", toolSpecificData.title, toolSpecificData.author);
     case "input":
         return typeof toolSpecificData.rawInput === "string" ? toolSpecificData.rawInput : JSON.stringify(toolSpecificData.rawInput);
     case "resources":
@@ -116,13 +116,13 @@ function getToolSpecificDataDescription(toolSpecificData) {
                     return v.fsPath || v.path;
                 }
             })).join(", ");
-            return localize(4853, "Resources: {0}", paths);
+            return localize(5049, "Resources: {0}", paths);
         }
     case "simpleToolInvocation":
         {
             const inputText = toolSpecificData.input;
             const outputText = toolSpecificData.output;
-            return localize(4854, "Input: {0}, Output: {1}", inputText, outputText);
+            return localize(5050, "Input: {0}, Output: {1}", inputText, outputText);
         }
     case "modifiedFilesConfirmation":
         {
@@ -130,7 +130,7 @@ function getToolSpecificDataDescription(toolSpecificData) {
                 return "";
             }
             return localize(
-                4855,
+                5051,
                 "Modified files: {0}",
                 ( toolSpecificData.modifiedFiles.map(file => {
                     const revivedUri = URI.revive(file.uri);
@@ -165,12 +165,12 @@ function getResultDetailsDescription(resultDetails) {
     }
     if (isOutputDetailsSerialized(resultDetails)) {
         return {
-            input: ( localize(4856, "{0} data", resultDetails.output.mimeType))
+            input: ( localize(5052, "{0} data", resultDetails.output.mimeType))
         };
     }
     if (isToolResultOutputDetails(resultDetails)) {
         return {
-            input: ( localize(4856, "{0} data", resultDetails.output.mimeType))
+            input: ( localize(5052, "{0} data", resultDetails.output.mimeType))
         };
     }
     return {};
@@ -194,13 +194,13 @@ function getToolInvocationA11yDescription(
     if (isComplete && resultDetails) {
         const details = getResultDetailsDescription(resultDetails);
         if (details.isError) {
-            parts.unshift(( localize(4857, "Errored")));
+            parts.unshift(( localize(5053, "Errored")));
         }
         if (details.input && !toolDataDesc) {
-            parts.push(( localize(4858, "Input: {0}", details.input)));
+            parts.push(( localize(5054, "Input: {0}", details.input)));
         }
         if (details.files && details.files.length > 0) {
-            parts.push(( localize(4859, "Files: {0}", details.files.join(", "))));
+            parts.push(( localize(5055, "Files: {0}", details.files.join(", "))));
         }
     }
     return parts.join(". ");
@@ -262,7 +262,7 @@ class ChatResponseAccessibleProvider extends Disposable {
                     const thinkingValue = Array.isArray(part.value) ? part.value.join("") : (part.value || "");
                     const trimmed = thinkingValue.trim();
                     if (trimmed) {
-                        contentParts.push(( localize(4860, "Thinking: {0}", trimmed)));
+                        contentParts.push(( localize(5056, "Thinking: {0}", trimmed)));
                     }
                     break;
                 }
@@ -338,7 +338,7 @@ class ChatResponseAccessibleProvider extends Disposable {
                         contentParts.push(toolContent);
                     } else if (state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
                         const postApprovalDetails = isToolResultInputOutputDetails(state.resultDetails) ? state.resultDetails.input : isToolResultOutputDetails(state.resultDetails) ? undefined : toolContentToA11yString(state.contentForModel);
-                        contentParts.push(( localize(4861, "Approve results of {0}? Result: ", part.toolId)) + (postApprovalDetails ?? ""));
+                        contentParts.push(( localize(5057, "Approve results of {0}? Result: ", part.toolId)) + (postApprovalDetails ?? ""));
                     } else {
                         const resultDetails = IChatToolInvocation.resultDetails(part);
                         const isComplete = IChatToolInvocation.isComplete(part);
@@ -369,6 +369,22 @@ class ChatResponseAccessibleProvider extends Disposable {
                     }
                     break;
                 }
+            case "autoModeResolution":
+                {
+                    if (part.predictedLabel === "fallback") {
+                        contentParts.push(( localize(5058, "Routed to {0}. Unable to resolve.", part.resolvedModelName)));
+                    } else {
+                        const label = part.predictedLabel === "needs_reasoning" ? ( localize(5059, "Reasoning")) : ( localize(5060, "Non-reasoning"));
+                        contentParts.push(( localize(
+                            5061,
+                            "Routed to {0}. {1} - Confidence {2}%",
+                            part.resolvedModelName,
+                            label,
+                            (part.confidence * 100).toFixed(0)
+                        )));
+                    }
+                    break;
+                }
             }
         }
         return this._normalizeWhitespace(contentParts.join("\n"));

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatAccessibilityActions.js

@@ -22,11 +22,11 @@ class AnnounceChatConfirmationAction extends Action2 {
         super({
             id: ACTION_ID_FOCUS_CHAT_CONFIRMATION,
             title: {
-                value: ( localize(4862, "Focus Chat Confirmation")),
+                value: ( localize(5062, "Focus Chat Confirmation")),
                 original: "Focus Chat Confirmation"
             },
             category: {
-                value: ( localize(4863, "Chat")),
+                value: ( localize(5063, "Chat")),
                 original: "Chat"
             },
             precondition: ChatContextKeys.enabled,
@@ -42,12 +42,12 @@ class AnnounceChatConfirmationAction extends Action2 {
         const chatWidgetService = accessor.get(IChatWidgetService);
         const pendingWidget = chatWidgetService.getAllWidgets().find(widget => widget.viewModel?.model.requestNeedsInput.get());
         if (!pendingWidget) {
-            alert(( localize(4864, "No active chat session found.")));
+            alert(( localize(5064, "No active chat session found.")));
             return;
         }
         const viewModel = pendingWidget.viewModel;
         if (!viewModel) {
-            alert(( localize(4865, "Chat interface not ready.")));
+            alert(( localize(5065, "Chat interface not ready.")));
             return;
         }
         let firstConfirmationElement;
@@ -69,7 +69,7 @@ class AnnounceChatConfirmationAction extends Action2 {
                 firstConfirmationElement.focus();
             }
         } else {
-            alert(( localize(4866, "No chat confirmation required")));
+            alert(( localize(5066, "No chat confirmation required")));
         }
     }
 }
@@ -78,11 +78,11 @@ class ToggleThinkingContentAccessibleViewAction extends Action2 {
         super({
             id: ACTION_ID_TOGGLE_THINKING_CONTENT_ACCESSIBLE_VIEW,
             title: {
-                value: ( localize(4867, "Toggle Thinking Content in Accessible View")),
+                value: ( localize(5067, "Toggle Thinking Content in Accessible View")),
                 original: "Toggle Thinking Content in Accessible View"
             },
             category: {
-                value: ( localize(4863, "Chat")),
+                value: ( localize(5063, "Chat")),
                 original: "Chat"
             },
             precondition: ChatContextKeys.enabled,
@@ -104,7 +104,7 @@ class ToggleThinkingContentAccessibleViewAction extends Action2 {
             StorageScope.PROFILE,
             StorageTarget.USER
         );
-        alert(updatedValue ? ( localize(4868, "Thinking content will be included in the accessible view.")) : ( localize(4869, "Thinking content will be hidden from the accessible view.")));
+        alert(updatedValue ? ( localize(5068, "Thinking content will be included in the accessible view.")) : ( localize(5069, "Thinking content will be hidden from the accessible view.")));
     }
 }
 function registerChatAccessibilityActions() {

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatAccessibilityHelp.d.ts

@@ -31,5 +31,5 @@ export declare class AgentChatAccessibilityHelp implements IAccessibleViewImplem
     readonly when: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").ContextKeyExpression | undefined;
     getProvider(accessor: ServicesAccessor): AccessibleContentProvider | undefined;
 }
-export declare function getAccessibilityHelpText(type: "panelChat" | "inlineChat" | "agentView" | "quickChat" | "editsView" | "agentView", keybindingService: IKeybindingService): string;
+export declare function getAccessibilityHelpText(type: "panelChat" | "inlineChat" | "quickChat" | "editsView" | "agentView", keybindingService: IKeybindingService): string;
 export declare function getChatAccessibilityHelpProvider(accessor: ServicesAccessor, editor: ICodeEditor | undefined, type: "panelChat" | "inlineChat" | "quickChat" | "editsView" | "agentView"): AccessibleContentProvider | undefined;