@codingame/monaco-vscode-api 34.1.3 → 35.0.0

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

@@ -56,7 +56,7 @@ async function maybeEnableAuthExtension(extensionsWorkbenchService, logService)
         );
         try {
             await extensionsWorkbenchService.setEnablement([providerExtension], EnablementState.EnabledGlobally);
-            await extensionsWorkbenchService.updateRunningExtensions(( localize(6720, "Enabling GitHub Authentication")));
+            await extensionsWorkbenchService.updateRunningExtensions(( localize(7225, "Enabling GitHub Authentication")));
             return true;
         } catch (error) {
             logService.error(

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/promptFileRewriter.d.ts

@@ -3,7 +3,7 @@ import { URI } from "../../../../../base/common/uri.js";
 import { ICodeEditorService } from "../../../../../editor/browser/services/codeEditorService.service.js";
 import { Range } from "../../../../../editor/common/core/range.js";
 import { ITextModel } from "../../../../../editor/common/model.js";
-import { IToolAndToolSetEnablementMap } from "../../common/tools/languageModelToolsService.js";
+import { ToolAndToolSetEnablementMap } from "../../common/tools/languageModelToolsService.js";
 import { ILanguageModelToolsService } from "../../common/tools/languageModelToolsService.service.js";
 import { IPromptsService } from "../../common/promptSyntax/service/promptsService.service.js";
 export declare class PromptFileRewriter {
@@ -11,8 +11,8 @@ export declare class PromptFileRewriter {
     private readonly _promptsService;
     private readonly _languageModelToolsService;
     constructor(_codeEditorService: ICodeEditorService, _promptsService: IPromptsService, _languageModelToolsService: ILanguageModelToolsService);
-    openAndRewriteTools(uri: URI, newTools: IToolAndToolSetEnablementMap | undefined, token: CancellationToken): Promise<void>;
-    rewriteTools(model: ITextModel, newTools: IToolAndToolSetEnablementMap, range: Range, isString: boolean): void;
+    openAndRewriteTools(uri: URI, newTools: ToolAndToolSetEnablementMap | undefined, token: CancellationToken): Promise<void>;
+    rewriteTools(model: ITextModel, newTools: ToolAndToolSetEnablementMap, range: Range, isString: boolean): void;
     private rewriteAttribute;
     openAndRewriteName(uri: URI, newName: string, token: CancellationToken): Promise<void>;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService.service.d.ts

@@ -1,17 +1,19 @@
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
 import { IToolData } from "../../common/tools/languageModelToolsService.js";
-import { IToolRiskAssessment } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService";
+import { ToolRiskPromptKind, IToolRiskAssessment } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService";
 export declare const IChatToolRiskAssessmentService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatToolRiskAssessmentService>;
 export interface IChatToolRiskAssessmentService {
     readonly _serviceBrand: undefined;
     /** Returns whether the feature is enabled by configuration. */
     isEnabled(): boolean;
     /** Synchronously read a previously cached assessment, or undefined if none. */
-    getCached(tool: IToolData, parameters: unknown): IToolRiskAssessment | undefined;
+    getCached(tool: IToolData, parameters: unknown, kind?: ToolRiskPromptKind): IToolRiskAssessment | undefined;
     /**
-    * Get a cached or freshly-computed risk assessment for a tool call.
-    * Returns `undefined` when the feature is disabled, no model is available,
-    * or the assessment cannot be parsed.
+    * Get a cached or freshly-computed risk assessment for a tool call. Returns `undefined` when no
+    * model is available or the assessment cannot be parsed, or when the feature is disabled unless
+    * `options.ignoreEnablement` is set (used by the Autopilot risk gate).
     */
-    assess(tool: IToolData, parameters: unknown, token: CancellationToken): Promise<IToolRiskAssessment | undefined>;
+    assess(tool: IToolData, parameters: unknown, token: CancellationToken, kind?: ToolRiskPromptKind, options?: {
+        ignoreEnablement?: boolean;
+    }): Promise<IToolRiskAssessment | undefined>;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/micCaptureService.service.d.ts

@@ -0,0 +1,49 @@
+import { Event } from "../../../../../base/common/event.js";
+import { IPttDiagnostic } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/voiceClient/micCaptureService";
+export declare const IMicCaptureService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IMicCaptureService>;
+export interface IMicCaptureService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Store a window reference for later lazy mic acquisition without actually
+    * acquiring the microphone. The mic is acquired on `pttDown()` and released
+    * on `pttUp()`.
+    */
+    prepare(window: Window & typeof globalThis): void;
+    /** Start capturing audio from the microphone. */
+    startCapture(window: Window & typeof globalThis): Promise<void>;
+    /** Stop capturing and release mic resources. */
+    stopCapture(): void;
+    readonly isCapturing: boolean;
+    /** Fired when a PTT segment begins (mic ready). */
+    readonly onPttStart: Event<void>;
+    /** Fired during PTT hold with base64-encoded raw PCM16 chunks. */
+    readonly onPttAudioChunk: Event<string>;
+    /** Fired when a PTT segment ends. All chunks have been sent before this fires. */
+    readonly onPttEnd: Event<void>;
+    /**
+    * Fired after the diagnostic window closes (~1s after `pttUp`) with
+    * per-press telemetry. Always fires AFTER `onPttEnd` for normal
+    * presses. Used for tail-loss diagnosis; safe to ignore for normal
+    * operation.
+    */
+    readonly onPttDiagnostic: Event<IPttDiagnostic>;
+    /** The AnalyserNode for visualisation, available while capturing. */
+    readonly analyserNode: AnalyserNode | undefined;
+    /**
+    * Begin a PTT segment. Lazily acquires the microphone if not already
+    * capturing. Returns a promise that resolves once the mic is ready to
+    * record (or rejects if acquisition fails).
+    *
+    * `turnId` is an opaque per-press identifier propagated into the
+    * eventual `onPttDiagnostic` payload for correlation with backend logs.
+    * Pass empty string when no correlation is needed.
+    */
+    pttDown(turnId: string): Promise<void>;
+    /**
+    * End a PTT segment. Sends any remaining audio chunks, then fires pttEnd.
+    */
+    pttUp(): void;
+    isMuted: boolean;
+    /** Suppress mic output until the given timestamp (AEC gating). */
+    suppressUntil(timestamp: number): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/micCaptureService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const IMicCaptureService = ( createDecorator("micCaptureService"));
+
+export { IMicCaptureService };

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/ttsPlaybackService.service.d.ts

@@ -0,0 +1,23 @@
+import { Event } from "../../../../../base/common/event.js";
+export declare const ITtsPlaybackService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITtsPlaybackService>;
+export interface ITtsPlaybackService {
+    readonly _serviceBrand: undefined;
+    /** Append a base64-encoded audio chunk for streaming playback. */
+    playAudioChunk(audio: string, isFinal: boolean, window: Window & typeof globalThis): void;
+    /** Stop any current playback immediately. */
+    stopPlayback(): void;
+    readonly isPlaying: boolean;
+    readonly onPlaybackStarted: Event<void>;
+    readonly onPlaybackStopped: Event<void>;
+    /** Returns the PCM samples from the last completed playback turn, or null. */
+    getLastPlayedSamples(): Float32Array | null;
+    /** The playback AnalyserNode for visualisation, available during playback. */
+    readonly analyserNode: AnalyserNode | undefined;
+    /**
+    * Ensure the playback AudioContext exists and is resumed.
+    * Returns the AudioContext for callers that need it (e.g. pre-warming).
+    */
+    ensureContext(window: Window & typeof globalThis): AudioContext;
+    /** Close the AudioContext entirely (for full teardown). */
+    closeContext(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/ttsPlaybackService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const ITtsPlaybackService = ( createDecorator("ttsPlaybackService"));
+
+export { ITtsPlaybackService };

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.service.d.ts

@@ -0,0 +1,47 @@
+import { IObservable } from "../../../../../base/common/observable.js";
+import { URI } from "../../../../../base/common/uri.js";
+import { VoiceState, ITranscriptTurn, IPendingToolConfirmation } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController";
+export interface IVoiceSessionController {
+    readonly _serviceBrand: undefined;
+    readonly voiceState: IObservable<VoiceState>;
+    readonly statusText: IObservable<string>;
+    /** Rolling buffer of the last 2 transcript turns (oldest first). */
+    readonly transcriptTurns: IObservable<readonly ITranscriptTurn[]>;
+    readonly isConnected: IObservable<boolean>;
+    readonly isConnecting: IObservable<boolean>;
+    readonly isReconnecting: IObservable<boolean>;
+    readonly pendingToolConfirmations: IObservable<readonly IPendingToolConfirmation[]>;
+    /** The session resource that transcriptions will be sent to. undefined = active session. */
+    readonly targetSession: IObservable<URI | undefined>;
+    connect(window: Window & typeof globalThis): Promise<void>;
+    disconnect(): void;
+    pttDown(): void;
+    pttUp(): void;
+    /**
+    * Mark a session as having been cancelled by the user from VS Code UI. The
+    * next state-change detected for this session (typically the chat model
+    * transitioning to `idle`) will be suppressed so the backend doesn't
+    * narrate a status update the user already knows about.
+    */
+    markUserCancelled(sessionId: string): void;
+    /**
+    * Set the target session for transcription. When set, transcriptions are
+    * sent to this session instead of the currently active one.
+    */
+    setTargetSession(resource: URI | undefined): void;
+    /**
+    * Create a new chat session and set it as the target for transcription.
+    */
+    newSessionAsTarget(): void;
+    /**
+    * Submit user feedback along with full diagnostic data (transcript history,
+    * client state, environment info). Returns success/failure.
+    */
+    submitFeedback(feedbackText: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /** DEV ONLY: Simulate a connected session with fake transcript for UI testing. */
+    simulateConnection(): void;
+}
+export declare const IVoiceSessionController: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IVoiceSessionController>;

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const IVoiceSessionController = ( createDecorator("voiceSessionController"));
+
+export { IVoiceSessionController };

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/voiceToolDispatchService.service.d.ts

@@ -0,0 +1,15 @@
+import { IVoiceToolCall } from "../../common/voiceClient/voiceClientService.js";
+import { IVoiceToolDispatchDelegate } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceToolDispatchService";
+export interface IVoiceToolDispatchService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Set the delegate that bridges widget/UI concerns.
+    * Must be called before dispatching tool calls.
+    */
+    setDelegate(delegate: IVoiceToolDispatchDelegate): void;
+    /**
+    * Dispatch a tool call and return the result string.
+    */
+    dispatchToolCall(toolCall: IVoiceToolCall): Promise<string>;
+}
+export declare const IVoiceToolDispatchService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IVoiceToolDispatchService>;

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/voiceToolDispatchService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const IVoiceToolDispatchService = ( createDecorator("voiceToolDispatchService"));
+
+export { IVoiceToolDispatchService };

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput.d.ts

@@ -3,6 +3,7 @@ import { ThemeIcon } from "../../../../../../base/common/themables.js";
 import { URI } from "../../../../../../base/common/uri.js";
 import { ConfirmResult } from "../../../../../../platform/dialogs/common/dialogs.js";
 import { IDialogService } from "../../../../../../platform/dialogs/common/dialogs.service.js";
+import { IConfigurationService } from "../../../../../../platform/configuration/common/configuration.service.js";
 import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
 import { EditorInputCapabilities, IEditorIdentifier, IEditorSerializer, IUntypedEditorInput, Verbosity } from "../../../../../common/editor.js";
 import { EditorInput, IEditorCloseHandler } from "../../../../../common/editor/editorInput.js";
@@ -17,6 +18,7 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
     readonly options: IChatEditorOptions;
     private readonly chatService;
     private readonly dialogService;
+    private readonly configurationService;
     private readonly chatSessionsService;
     private readonly instantiationService;
     static readonly TypeID: string;
@@ -34,7 +36,7 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
     private readonly _modelChangeListener;
     private get model();
     static getNewEditorUri(): URI;
-    constructor(resource: URI, options: IChatEditorOptions, chatService: IChatService, dialogService: IDialogService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService);
+    constructor(resource: URI, options: IChatEditorOptions, chatService: IChatService, dialogService: IDialogService, configurationService: IConfigurationService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService);
     closeHandler: this;
     showConfirm(): boolean;
     transferOutEditingSession(): IChatEditingSession | undefined;
@@ -54,6 +56,7 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
      */
     getSessionType(): string;
     resolve(): Promise<ChatEditorModel | null>;
+    private shouldReplaceEmptyLocalSession;
     /**
      * Updates the editor input to track a new model. Called when the widget swaps
      * from an untitled session to a real session.

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput.js

@@ -12,6 +12,7 @@ import { URI } from '../../../../../../base/common/uri.js';
 import { localize } from '../../../../../../nls.js';
 import { ConfirmResult } from '../../../../../../platform/dialogs/common/dialogs.js';
 import { IDialogService } from '../../../../../../platform/dialogs/common/dialogs.service.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
 import { registerIcon } from '../../../../../../platform/theme/common/iconRegistry.js';
 import { EditorInputCapabilities, Verbosity } from '../../../../../common/editor.js';
@@ -19,12 +20,12 @@ import { EditorInput } from '../../../../../common/editor/editorInput.js';
 import { IChatService } from '../../../common/chatService/chatService.service.js';
 import { localChatSessionType } from '../../../common/chatSessionsService.js';
 import { IChatSessionsService } from '../../../common/chatSessionsService.service.js';
-import { ChatEditorTitleMaxLength, ChatAgentLocation } from '../../../common/constants.js';
+import { ChatEditorTitleMaxLength, ChatAgentLocation, getDefaultNewChatSessionResource, getDefaultNewChatSessionType } from '../../../common/constants.js';
 import { ModifiedFileEntryState } from '../../../common/editing/chatEditingService.js';
 import { LocalChatSessionUri, getChatSessionType } from '../../../common/model/chatUri.js';
 
 var ChatEditorInput_1;
-const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(7804, "Icon of the chat editor label.")));
+const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(8386, "Icon of the chat editor label.")));
 let ChatEditorInput = class ChatEditorInput extends EditorInput {
     static {
         ChatEditorInput_1 = this;
@@ -49,6 +50,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         options,
         chatService,
         dialogService,
+        configurationService,
         chatSessionsService,
         instantiationService
     ) {
@@ -57,6 +59,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         this.options = options;
         this.chatService = chatService;
         this.dialogService = dialogService;
+        this.configurationService = configurationService;
         this.chatSessionsService = chatSessionsService;
         this.instantiationService = instantiationService;
         this.didTransferOutEditingSession = false;
@@ -89,8 +92,8 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (!this.model?.editingSession || this.didTransferOutEditingSession || this.getSessionType() !== localChatSessionType) {
             return ConfirmResult.SAVE;
         }
-        const titleOverride = ( localize(7805, "Close Chat Editor"));
-        const messageOverride = ( localize(7806, "Closing the chat editor will end your current edit session."));
+        const titleOverride = ( localize(8387, "Close Chat Editor"));
+        const messageOverride = ( localize(8388, "Closing the chat editor will end your current edit session."));
         const result = await showClearEditingSessionConfirmation(this.model, this.dialogService, {
             titleOverride,
             messageOverride
@@ -132,7 +135,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (this.options.title?.preferred) {
             return this.options.title.preferred;
         }
-        return this.options.title?.fallback ?? ( localize(7807, "Chat"));
+        return this.options.title?.fallback ?? ( localize(8389, "Chat"));
     }
     getTitle(verbosity) {
         const name = this.getName();
@@ -169,7 +172,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         return undefined;
     }
     getSessionType() {
-        return getChatSessionType(this.resource);
+        return getChatSessionType(this._sessionResource ?? this.resource);
     }
     async resolve() {
         const searchParams = ( new URLSearchParams(this.resource.query));
@@ -182,6 +185,18 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
                 CancellationToken.None,
                 "ChatEditorInput#resolve"
             );
+            if (this.shouldReplaceEmptyLocalSession(this._sessionResource)) {
+                const defaultResource = getDefaultNewChatSessionResource(this.configurationService, this.chatSessionsService);
+                if (getChatSessionType(defaultResource) !== localChatSessionType) {
+                    this._sessionResource = defaultResource;
+                    this.modelRef.value = await this.chatService.acquireOrLoadSession(
+                        defaultResource,
+                        ChatAgentLocation.Chat,
+                        CancellationToken.None,
+                        "ChatEditorInput#resolveDefaultSession"
+                    );
+                }
+            }
             if (!this.model && LocalChatSessionUri.parseLocalSessionId(this._sessionResource)) {
                 this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
                     canUseTools: true,
@@ -189,10 +204,28 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
                 });
             }
         } else if (!this.options.target) {
-            this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
-                canUseTools: !inputType,
-                debugOwner: "ChatEditorInput#resolveUntitled"
-            });
+            if (this.options.explicitSessionType === localChatSessionType) {
+                this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
+                    canUseTools: !inputType,
+                    debugOwner: "ChatEditorInput#resolveExplicitLocal"
+                });
+            } else {
+                const defaultResource = getDefaultNewChatSessionResource(this.configurationService, this.chatSessionsService);
+                if (getChatSessionType(defaultResource) === localChatSessionType) {
+                    this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
+                        canUseTools: !inputType,
+                        debugOwner: "ChatEditorInput#resolveUntitled"
+                    });
+                } else {
+                    this._sessionResource = defaultResource;
+                    this.modelRef.value = await this.chatService.acquireOrLoadSession(
+                        defaultResource,
+                        ChatAgentLocation.Chat,
+                        CancellationToken.None,
+                        "ChatEditorInput#resolveDefaultUntitled"
+                    );
+                }
+            }
         } else if (this.options.target.data) {
             this.modelRef.value = this.chatService.loadSessionFromData(this.options.target.data, "ChatEditorInput#resolveImportedData");
         }
@@ -208,6 +241,9 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         this._onDidChangeLabel.fire();
         return this._register(( new ChatEditorModel(this.model)));
     }
+    shouldReplaceEmptyLocalSession(sessionResource) {
+        return LocalChatSessionUri.isLocalSession(sessionResource) && this.options.explicitSessionType !== localChatSessionType && !!this.model && !this.model.hasRequests && getDefaultNewChatSessionType(this.configurationService, this.chatSessionsService) !== localChatSessionType;
+    }
     updateModel(model) {
         this._sessionResource = model.sessionResource;
         this.modelRef.value = this.chatService.acquireExistingSession(model.sessionResource, "ChatEditorInput#updateModel");
@@ -234,7 +270,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         return false;
     }
 };
-ChatEditorInput = ChatEditorInput_1 = ( __decorate([( __param(2, IChatService)), ( __param(3, IDialogService)), ( __param(4, IChatSessionsService)), ( __param(5, IInstantiationService))], ChatEditorInput));
+ChatEditorInput = ChatEditorInput_1 = ( __decorate([( __param(2, IChatService)), ( __param(3, IDialogService)), ( __param(4, IConfigurationService)), ( __param(5, IChatSessionsService)), ( __param(6, IInstantiationService))], ChatEditorInput));
 class ChatEditorModel extends Disposable {
     constructor(model) {
         super();
@@ -316,25 +352,25 @@ async function showClearEditingSessionConfirmation(model, dialogService, options
     if (!undecidedEdits) {
         return true;
     }
-    const defaultPhrase = ( localize(7808, "Starting a new chat will end your current edit session."));
-    const defaultTitle = ( localize(7809, "Start new chat?"));
+    const defaultPhrase = ( localize(8390, "Starting a new chat will end your current edit session."));
+    const defaultTitle = ( localize(8391, "Start new chat?"));
     const phrase = options?.messageOverride ?? defaultPhrase;
     const title = options?.titleOverride ?? defaultTitle;
     const {
         result
     } = await dialogService.prompt({
         title,
-        message: phrase + " " + ( localize(7810, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
+        message: phrase + " " + ( localize(8392, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
         type: "info",
         cancelButton: true,
         buttons: [{
-            label: ( localize(7811, "Keep & Continue")),
+            label: ( localize(8393, "Keep & Continue")),
             run: async () => {
                 await model.editingSession.accept();
                 return true;
             }
         }, {
-            label: ( localize(7812, "Undo & Continue")),
+            label: ( localize(8394, "Undo & Continue")),
             run: async () => {
                 await model.editingSession.reject();
                 return true;

package/vscode/src/vs/workbench/contrib/chat/common/actions/chatContextKeys.d.ts

@@ -48,6 +48,20 @@ export declare namespace ChatContextKeys {
      */
     const lockedToCodingAgent: RawContextKey<boolean>;
     const lockedCodingAgentId: RawContextKey<string>;
+    /**
+     * Widget-scoped: true when the chat shown in this widget is read-only (non-interactive),
+     * e.g. an observable worker chat. Read-only chats hide the composer and do not offer
+     * mutating actions such as Start Over or Restore Checkpoint.
+     */
+    const readOnly: RawContextKey<boolean>;
+    /**
+     * Widget-scoped: true when this chat widget is locked to an Agent Host-backed chat session.
+     */
+    const chatIsAgentHostSession: RawContextKey<boolean>;
+    /**
+     * Widget-scoped: logical Agent Host provider ID for this chat widget, e.g. `copilotcli`, `claude`, or `codex`.
+     */
+    const chatAgentHostProviderId: RawContextKey<string>;
     /**
      * True when the chat session has a customAgentTarget defined in its contribution,
      * which means the mode picker should be shown with filtered custom agents.
@@ -76,6 +90,7 @@ export declare namespace ChatContextKeys {
     const location: RawContextKey<ChatAgentLocation>;
     const inQuickChat: RawContextKey<boolean>;
     const inAgentSessionsWelcome: RawContextKey<boolean>;
+    const inAutomationsDialog: RawContextKey<boolean>;
     const chatSessionType: RawContextKey<string>;
     const hasFileAttachments: RawContextKey<boolean>;
     const chatSessionIsEmpty: RawContextKey<boolean>;
@@ -134,6 +149,7 @@ export declare namespace ChatContextKeys {
     const agentSessionsViewerVisible: RawContextKey<boolean>;
     const agentSessionType: RawContextKey<string>;
     const chatSessionSupportsDelegation: RawContextKey<boolean>;
+    const hasPendingDelegationTarget: RawContextKey<boolean>;
     const chatSessionSupportsFork: RawContextKey<boolean>;
     const agentSessionSection: RawContextKey<string>;
     const isArchivedAgentSession: RawContextKey<boolean>;
@@ -153,10 +169,10 @@ export declare namespace ChatContextKeys {
 export declare namespace ChatContextKeyExprs {
     const inEditingMode: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     /**
-     * True when the locked coding agent is an agent host session (agent-host-* or remote-*).
+     * True when the locked coding agent is an Agent Host session.
      * These sessions use {@link AgentHostSnapshotController} which supports checkpoint-based restore.
      */
-    const isAgentHostSession: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
+    const isAgentHostSession: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression;
     /**
      * True when an agent session item (e.g. in the sessions viewer) is an agent
      * host session (agent-host-* or remote-*). Keyed on {@link ChatContextKeys.agentSessionType}