@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -1,6 +1,6 @@
 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";
+import { VoiceState, ITranscriptTurn, IPendingToolConfirmation } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController";
 export interface IVoiceSessionController {
     readonly _serviceBrand: undefined;
     readonly voiceState: IObservable<VoiceState>;
@@ -10,13 +10,67 @@ export interface IVoiceSessionController {
     readonly isConnected: IObservable<boolean>;
     readonly isConnecting: IObservable<boolean>;
     readonly isReconnecting: IObservable<boolean>;
+    /** Whether the user has muted the microphone while keeping the session connected. */
+    readonly isMuted: IObservable<boolean>;
     readonly pendingToolConfirmations: IObservable<readonly IPendingToolConfirmation[]>;
     /** The session resource that transcriptions will be sent to. undefined = active session. */
     readonly targetSession: IObservable<URI | undefined>;
+    /** Whether Voice Mode is explicitly owned by a new-session draft. */
+    readonly hasDraftTarget: IObservable<boolean>;
+    /** Session that produced the response most recently spoken to the user. */
+    getLastSpokenResponseSession(): URI | undefined;
     connect(window: Window & typeof globalThis): Promise<void>;
-    disconnect(): void;
-    pttDown(): void;
-    pttUp(): void;
+    /** Update the OS window whose focus controls capture and hands-free listening. */
+    setActiveWindow(window: Window & typeof globalThis): void;
+    disconnect(source?: "explicit" | "internal"): void;
+    pttDown(source?: "explicit" | "auto" | "connect", forceNewTurn?: boolean): void;
+    pttUp(source?: "explicit" | "internal", forceFinish?: boolean): void;
+    /**
+    * Stop the current recording / auto-listen loop without disconnecting.
+    * Any in-flight push-to-talk press is finished through the normal
+    * `ptt_end` path (the backend finalizes the turn) and the auto-listen
+    * re-arm loop is suppressed until the user talks again. The WebSocket
+    * stays connected so the user can resume via the Voice Mode button
+    * without a new handshake. Use `disconnect()` to fully end the session.
+    */
+    stopListening(source?: "explicit" | "internal"): void;
+    /**
+    * Mute or unmute the microphone without ending the session. While muted,
+    * captured audio is not forwarded to the backend so background noise or
+    * private speech never reaches transcription, but the WebSocket stays
+    * connected so the user can unmute and resume instantly.
+    */
+    setMuted(muted: boolean): void;
+    /**
+    * Hold hands-free auto-listen off until released.
+    *
+    * Unlike {@link stopListening}, this is safe to call *before* the session is
+    * connected: it survives the connect handshake, so a caller that needs the
+    * microphone to stay shut while the user reads or decides something can take
+    * the hold at `connect()` time rather than racing `session_init`. Releasing
+    * enters listening immediately if hands-free would have done so.
+    */
+    setAutoListenHeld(held: boolean): void;
+    /**
+    * Stop the current recording WITHOUT finalizing the turn: any in-flight
+    * push-to-talk press is aborted (no `ptt_end` is sent), so the backend
+    * never finalizes the buffered speech into a `send_to_chat`. Use this on
+    * focus changes so speech captured for one session can't be misrouted to a
+    * newly focused session. Like {@link stopListening}, the WebSocket stays
+    * connected and the auto-listen re-arm loop is suppressed until the user
+    * talks again.
+    */
+    discardListening(): void;
+    /**
+    * Stop listening on a focus change while the user is actively dictating:
+    * finalize the in-flight press (send `ptt_end`) but pin the resulting
+    * submission to `session` — the session the user was dictating into — so
+    * their words are not misrouted to the newly focused session. The WebSocket
+    * stays connected and the auto-listen re-arm loop is suppressed until the
+    * user talks again. Use {@link discardListening} instead when nothing has
+    * been dictated yet.
+    */
+    finishListeningAndSubmitTo(session: URI): 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
@@ -29,11 +83,31 @@ export interface IVoiceSessionController {
     * sent to this session instead of the currently active one.
     */
     setTargetSession(resource: URI | undefined): void;
+    /** Bind Voice Mode to the currently shown new-session draft. */
+    setDraftTarget(): void;
     /**
     * Create a new chat session and set it as the target for transcription.
     */
     newSessionAsTarget(): void;
     /**
+    * Declares the session shown in the UI for playback deferral and buffered
+    * flushes. It also supplies `is_active` when no voice target is pinned.
+    * `undefined` restores focus-based detection.
+    * `null` explicitly indicates that a draft with no session is shown.
+    */
+    setActiveSessionShown(resource: URI | null | undefined): void;
+    /** Promote the owned draft after that draft creates its first chat session. */
+    promoteDraftTarget(resource: URI): void;
+    /**
+    * Deterministically route audio to and narrate a session in response to an
+    * explicit UI action (e.g. clicking a session's pending-voice indicator).
+    * Unlike the shown/focus heuristics, this activates even when the session is
+    * already the active/shown one - so a completed background reply the user
+    * clicks to hear is played rather than silently ignored because no focus or
+    * view-model change event fired.
+    */
+    activateSession(resource: URI): void;
+    /**
     * Submit user feedback along with full diagnostic data (transcript history,
     * client state, environment info). Returns success/failure.
     */

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

@@ -1,5 +1,5 @@
-import { IVoiceToolCall } from "../../common/voiceClient/voiceClientService.js";
-import { IVoiceToolDispatchDelegate } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceToolDispatchService";
+import { IVoiceToolCall, IVoiceDispatchResult } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/voiceClient/voiceClientService";
+import { IVoiceToolDispatchDelegate } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceToolDispatchService";
 export interface IVoiceToolDispatchService {
     readonly _serviceBrand: undefined;
     /**
@@ -11,5 +11,14 @@ export interface IVoiceToolDispatchService {
     * Dispatch a tool call and return the result string.
     */
     dispatchToolCall(toolCall: IVoiceToolCall): Promise<string>;
+    /**
+    * Apply a backend-resolved response to whatever a session is waiting on.
+    *
+    * Separate from `dispatchToolCall` because it answers with a structured
+    * outcome rather than a string: the backend only speaks an acknowledgement
+    * for something it has actually observed, so "it landed" and "it didn't"
+    * have to be distinguishable.
+    */
+    respondToSession(toolCall: IVoiceToolCall): Promise<IVoiceDispatchResult>;
 }
 export declare const IVoiceToolDispatchService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IVoiceToolDispatchService>;

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

@@ -0,0 +1,32 @@
+import { IObservable } from "../../../../../base/common/observable.js";
+import { VoiceInputMode, SimulatedVoiceState, VoiceWalkthroughVersion } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/voiceInputMode/voiceInputMode";
+export declare const IVoiceInputModeService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IVoiceInputModeService>;
+export interface IVoiceInputModeService {
+    readonly _serviceBrand: undefined;
+    /** The currently selected mode (persisted). */
+    readonly selectedMode: IObservable<VoiceInputMode>;
+    /** Whether live Voice Mode is enabled and its chat-input control is visible. */
+    readonly voiceAvailable: IObservable<boolean>;
+    /** Whether dictation is configured and its chat-input control is visible. */
+    readonly dictationAvailable: IObservable<boolean>;
+    /** Whether Voice Mode runs hands-free (auto-listen) vs manual push-to-talk. */
+    readonly handsFree: IObservable<boolean>;
+    /** Dev/preview override for the voice-cell visual state (undefined = real state). */
+    readonly simulatedVoiceState: IObservable<SimulatedVoiceState | undefined>;
+    /** Dev/preview override for hands-free layout (undefined = real config). */
+    readonly simulatedHandsFree: IObservable<boolean | undefined>;
+    /** Dev/preview: which push-to-talk version the walkthrough is demoing (undefined = none). */
+    readonly simulatedVersion: IObservable<VoiceWalkthroughVersion | undefined>;
+    /** Dev/preview: whether the voice cell is being "hovered" (walkthrough only). */
+    readonly simulatedHover: IObservable<boolean>;
+    /** Persist a new selected mode and update the context key. */
+    setSelectedMode(mode: VoiceInputMode): void;
+    /** Set (or clear) the dev/preview simulated voice-cell state. */
+    setSimulatedVoiceState(state: SimulatedVoiceState | undefined): void;
+    /** Auto-play (looping) through a push-to-talk version's states, incl. glow. */
+    startVoiceStateWalkthrough(version: VoiceWalkthroughVersion): void;
+    /** Advance the simulated state to the next one in the walkthrough sequence. */
+    stepVoiceStateWalkthrough(): void;
+    /** Stop any running walkthrough and clear the simulated state. */
+    clearSimulation(): void;
+}

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

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

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatPetWidgetService.service.d.ts

@@ -0,0 +1,9 @@
+import { Event } from "../../../../../base/common/event.js";
+import { IObservable } from "../../../../../base/common/observable.js";
+import { IChatPetWidgetHost } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatPetWidget";
+import { IChatPetWidgetHostRegistration } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/widget/chatPetWidgetService";
+export declare const IChatPetWidgetService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatPetWidgetService>;
+export interface IChatPetWidgetService {
+    readonly _serviceBrand: undefined;
+    register(owner: object, host: IChatPetWidgetHost, preferred?: IObservable<boolean>, onDidFocus?: Event<void>): IChatPetWidgetHostRegistration;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatPetWidgetService.service.js

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

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatInputNoticeHub.service.d.ts

@@ -0,0 +1,14 @@
+import { IDisposable } from "../../../../../../base/common/lifecycle.js";
+import { ChatInputNoticeHost } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNoticeHost";
+export declare const IChatInputNoticeHubService: import("../../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatInputNoticeHubService>;
+export interface IChatInputNoticeHubService {
+    readonly _serviceBrand: undefined;
+    /** Track a chat input's notice host so commands can reach whichever one is in use. */
+    registerHost(host: ChatInputNoticeHost, focusRoot: HTMLElement): IDisposable;
+    /**
+    * Move focus into the notice showing in the most recently used chat input,
+    * or back to its input when the notice already has focus. Returns false when
+    * no notice is showing anywhere.
+    */
+    toggleNoticeFocus(): boolean;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatInputNoticeHub.service.js

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

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.d.ts

@@ -0,0 +1,140 @@
+import { IStringDictionary } from "../../../../../../base/common/collections.js";
+import { IMarkdownString } from "../../../../../../base/common/htmlContent.js";
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { URI } from "../../../../../../base/common/uri.js";
+import { ILogService } from "../../../../../../platform/log/common/log.service.js";
+import { IStorageService } from "../../../../../../platform/storage/common/storage.service.js";
+import { ILanguageModelChatMetadataAndIdentifier } from "../../../common/languageModels.js";
+import { IChatInputNotificationService } from "./chatInputNotificationService.service.js";
+export declare enum ChatInputNotificationSeverity {
+    Info = 0,
+    Warning = 1,
+    Error = 2
+}
+export declare enum ChatInputNotificationActionKind {
+    Command = "command",
+    OpenModelPicker = "openModelPicker",
+    SwitchToModel = "switchToModel"
+}
+interface IChatInputNotificationActionBase {
+    readonly label: string;
+    readonly keepOpen?: boolean;
+    /** Stable id reported to telemetry, so two actions of the same kind can be told apart. */
+    readonly telemetryActionId?: string;
+}
+export interface IChatInputNotificationCommandAction extends IChatInputNotificationActionBase {
+    readonly kind: ChatInputNotificationActionKind.Command;
+    readonly commandId: string;
+    readonly commandArgs?: unknown[];
+}
+export interface IChatInputNotificationOpenModelPickerAction extends IChatInputNotificationActionBase {
+    readonly kind: ChatInputNotificationActionKind.OpenModelPicker;
+}
+export interface IChatInputNotificationSwitchToModelAction extends IChatInputNotificationActionBase {
+    readonly kind: ChatInputNotificationActionKind.SwitchToModel;
+    /** Matches the target against models available to the rendering input. */
+    readonly matchesModel: (model: ILanguageModelChatMetadataAndIdentifier) => boolean;
+    /** Applied to the target model once switched. Keys its schema does not declare are dropped. */
+    readonly config?: IStringDictionary<unknown>;
+    /** Requires the target to match exactly one model, rather than taking the first match. */
+    readonly requireUniqueModel?: boolean;
+}
+export type IChatInputNotificationAction = IChatInputNotificationCommandAction | IChatInputNotificationOpenModelPickerAction | IChatInputNotificationSwitchToModelAction;
+export interface IChatInputNotificationMuteAction {
+    /** Command executed when the user clicks the mute (bell-slash) button. */
+    readonly commandId: string;
+    readonly commandArgs?: unknown[];
+    /** Tooltip and accessible label for the mute button. */
+    readonly tooltip: string;
+}
+/** Input state used to choose notification content. */
+export interface IChatInputNotificationModelState {
+    readonly currentModel: ILanguageModelChatMetadataAndIdentifier | undefined;
+    readonly models: readonly ILanguageModelChatMetadataAndIdentifier[];
+}
+export interface IChatInputNotificationContext {
+    readonly sessionType: string | undefined;
+    readonly sessionResource: URI | undefined;
+    readonly deferredNotificationsEnabled: boolean;
+    readonly isTransientChat: boolean;
+    readonly sessionStarted: boolean;
+    readonly modelState: IChatInputNotificationModelState;
+}
+/** A complete notification body selected for one input. */
+export interface IChatInputNotificationBody {
+    readonly description: string | IMarkdownString | undefined;
+    readonly actions: readonly IChatInputNotificationAction[];
+}
+export interface IChatInputNotification {
+    readonly id: string;
+    readonly telemetryId?: string;
+    readonly severity: ChatInputNotificationSeverity;
+    readonly message: string | IMarkdownString;
+    readonly description: string | IMarkdownString | undefined;
+    readonly actions: readonly IChatInputNotificationAction[];
+    /** Controls whether this notification applies to an input. */
+    readonly when?: (context: IChatInputNotificationContext) => boolean;
+    /** Resolves the description and actions for an input. */
+    readonly resolveBody?: (context: IChatInputNotificationContext) => IChatInputNotificationBody;
+    readonly dismissible: boolean;
+    readonly autoDismissOnMessage: boolean;
+    /**
+     * Optional allow-list of chat session types that should display this
+     * notification. When undefined, the notification renders in every chat
+     * input. When set, only chat inputs whose current session type is in the
+     * list will render it.
+     */
+    readonly sessionTypes?: readonly string[];
+    /** Optional allow-list of concrete chat session resources that should display this notification. */
+    readonly sessionResources?: readonly URI[];
+    /**
+     * Optional "mute" affordance rendered as a bell-slash icon button next to
+     * the dismiss (X) button. Use for a "stop showing this entirely" action
+     * that is distinct from a one-off dismissal. Omit to hide the button.
+     */
+    readonly mute?: IChatInputNotificationMuteAction;
+}
+/** Creates a matcher for a fixed model identifier. */
+export declare function matchesModelIdentifier(identifier: string): (model: ILanguageModelChatMetadataAndIdentifier) => boolean;
+/** Resolves one complete notification body for an input. */
+export declare function resolveChatInputNotificationBody(notification: IChatInputNotification, context: IChatInputNotificationContext, onError: (error: unknown) => void): IChatInputNotificationBody | undefined;
+/** Returns the text signature used to de-duplicate announcements. */
+export declare function getChatInputNotificationAnnouncementSignature(notification: IChatInputNotification, body: IChatInputNotificationBody): string;
+/** Returns whether a notification applies to the concrete model-target session type. */
+export declare function isChatInputNotificationApplicableToSessionType(notification: IChatInputNotification, sessionType: string | undefined): boolean;
+export declare function isChatInputNotificationApplicableToSession(notification: IChatInputNotification, sessionType: string | undefined, sessionResource: URI | undefined): boolean;
+export declare class ChatInputNotificationService extends Disposable implements IChatInputNotificationService {
+    private readonly _logService;
+    readonly _serviceBrand: undefined;
+    private readonly _notifications;
+    private readonly _dismissed;
+    /** Insertion order tracking — higher index = more recently set. */
+    private readonly _insertionOrder;
+    private _insertionCounter;
+    private readonly _onDidChange;
+    readonly onDidChange: import("../../../../../../base/common/event.js").Event<void>;
+    private readonly _onDidDismiss;
+    readonly onDidDismiss: import("../../../../../../base/common/event.js").Event<string>;
+    private readonly _announcedById;
+    constructor(_logService: ILogService);
+    setNotification(notification: IChatInputNotification): void;
+    refresh(): void;
+    deleteNotification(id: string): void;
+    dismissNotification(id: string): void;
+    getActiveNotification(filter?: (notification: IChatInputNotification) => boolean): IChatInputNotification | undefined;
+    handleMessageSent(context?: IChatInputNotificationContext): void;
+    private _fireDidChange;
+    announceRendered(notification: IChatInputNotification | undefined, body?: IChatInputNotificationBody): void;
+}
+/**
+ * Reads the ids a user has dismissed for good, kept in application storage so a dismissal in one
+ * window applies to every other. Returns an empty set for absent or corrupt data.
+ *
+ * The set is stored under one key, so two windows dismissing different notices in the same
+ * instant can leave the later write without the earlier id. Re-reading before each write keeps
+ * that to a genuine race, and the cost is only that a notice may appear once more.
+ */
+export declare function readDismissedNotificationIds(storageService: IStorageService, key: string): Set<string>;
+/** Records one id as dismissed for good. */
+export declare function addDismissedNotificationId(storageService: IStorageService, key: string, id: string): void;
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.js

@@ -0,0 +1,186 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { status } from '../../../../../../base/browser/ui/aria/aria.js';
+import { renderAsPlaintext } from '../../../../../../base/browser/markdownRenderer.js';
+import { Emitter } from '../../../../../../base/common/event.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import { isEqual } from '../../../../../../base/common/resources.js';
+import '../../../../../../platform/instantiation/common/extensions.js';
+import { ILogService } from '../../../../../../platform/log/common/log.service.js';
+import { StorageScope, StorageTarget } from '../../../../../../platform/storage/common/storage.js';
+import '../../../../../../platform/instantiation/common/instantiation.js';
+
+var ChatInputNotificationSeverity;
+(function(ChatInputNotificationSeverity) {
+    ChatInputNotificationSeverity[ChatInputNotificationSeverity["Info"] = 0] = "Info";
+    ChatInputNotificationSeverity[ChatInputNotificationSeverity["Warning"] = 1] = "Warning";
+    ChatInputNotificationSeverity[ChatInputNotificationSeverity["Error"] = 2] = "Error";
+})(ChatInputNotificationSeverity || (ChatInputNotificationSeverity = {}));
+var ChatInputNotificationActionKind;
+(function(ChatInputNotificationActionKind) {
+    ChatInputNotificationActionKind["Command"] = "command";
+    ChatInputNotificationActionKind["OpenModelPicker"] = "openModelPicker";
+    ChatInputNotificationActionKind["SwitchToModel"] = "switchToModel";
+})(ChatInputNotificationActionKind || (ChatInputNotificationActionKind = {}));
+function matchesModelIdentifier(identifier) {
+    return model => model.identifier === identifier;
+}
+function evaluateChatInputNotificationPredicate(predicate, onError) {
+    try {
+        return predicate();
+    } catch (error) {
+        onError(error);
+        return false;
+    }
+}
+function resolveChatInputNotificationBody(notification, context, onError) {
+    if (!evaluateChatInputNotificationPredicate(() => notification.when?.(context) ?? true, onError)) {
+        return undefined;
+    }
+    if (!notification.resolveBody) {
+        return notification;
+    }
+    try {
+        return notification.resolveBody(context);
+    } catch (error) {
+        onError(error);
+        return notification;
+    }
+}
+function getChatInputNotificationAnnouncementSignature(notification, body) {
+    const message = typeof notification.message === "string" ? notification.message : notification.message.value;
+    const description = typeof body.description === "string" ? body.description : body.description?.value ?? "";
+    return `${notification.id}\u0000${message}\u0000${description}`;
+}
+function isChatInputNotificationApplicableToSessionType(notification, sessionType) {
+    return !notification.sessionTypes?.length || (!!sessionType && notification.sessionTypes.includes(sessionType));
+}
+function isChatInputNotificationApplicableToSession(notification, sessionType, sessionResource) {
+    return isChatInputNotificationApplicableToSessionType(notification, sessionType) && (!notification.sessionResources?.length || (!!sessionResource && ( notification.sessionResources.some(resource => isEqual(resource, sessionResource)))));
+}
+let ChatInputNotificationService = class ChatInputNotificationService extends Disposable {
+    constructor(_logService) {
+        super();
+        this._logService = _logService;
+        this._notifications = ( new Map());
+        this._dismissed = ( new Set());
+        this._insertionOrder = ( new Map());
+        this._insertionCounter = 0;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onDidDismiss = this._register(( new Emitter()));
+        this.onDidDismiss = this._onDidDismiss.event;
+        this._announcedById = ( new Map());
+    }
+    setNotification(notification) {
+        this._notifications.set(notification.id, notification);
+        this._dismissed.delete(notification.id);
+        this._insertionOrder.set(notification.id, this._insertionCounter++);
+        this._fireDidChange();
+    }
+    refresh() {
+        this._fireDidChange();
+    }
+    deleteNotification(id) {
+        if (this._notifications.delete(id)) {
+            this._dismissed.delete(id);
+            this._insertionOrder.delete(id);
+            this._announcedById.delete(id);
+            this._fireDidChange();
+        }
+    }
+    dismissNotification(id) {
+        if (( this._notifications.has(id)) && !( this._dismissed.has(id))) {
+            this._dismissed.add(id);
+            this._announcedById.delete(id);
+            this._onDidDismiss.fire(id);
+            this._fireDidChange();
+        }
+    }
+    getActiveNotification(filter) {
+        let best;
+        let bestOrder = -1;
+        for (const notification of ( this._notifications.values())) {
+            if (( this._dismissed.has(notification.id))) {
+                continue;
+            }
+            if (filter && !filter(notification)) {
+                continue;
+            }
+            const order = this._insertionOrder.get(notification.id) ?? 0;
+            if (!best || notification.severity > best.severity || (notification.severity === best.severity && order > bestOrder)) {
+                best = notification;
+                bestOrder = order;
+            }
+        }
+        return best;
+    }
+    handleMessageSent(context) {
+        let changed = false;
+        for (const notification of ( this._notifications.values())) {
+            if (!notification.autoDismissOnMessage || ( this._dismissed.has(notification.id))) {
+                continue;
+            }
+            if (context && !isChatInputNotificationApplicableToSession(notification, context.sessionType, context.sessionResource)) {
+                continue;
+            }
+            if (context && !evaluateChatInputNotificationPredicate(
+                () => notification.when?.(context) ?? true,
+                error => this._logService.error("[ChatInputNotificationService] Failed to evaluate notification", error)
+            )) {
+                continue;
+            }
+            this._dismissed.add(notification.id);
+            this._announcedById.delete(notification.id);
+            changed = true;
+        }
+        if (changed) {
+            this._fireDidChange();
+        }
+    }
+    _fireDidChange() {
+        this._onDidChange.fire();
+    }
+    announceRendered(notification, body) {
+        if (!notification) {
+            return;
+        }
+        const resolvedBody = body ?? notification;
+        const signature = getChatInputNotificationAnnouncementSignature(notification, resolvedBody);
+        if (this._announcedById.get(notification.id) === signature) {
+            return;
+        }
+        this._announcedById.set(notification.id, signature);
+        const message = renderAsPlaintext(notification.message);
+        const description = resolvedBody.description ? renderAsPlaintext(resolvedBody.description) : "";
+        const text = description ? `${message}. ${description}` : message;
+        status(text);
+    }
+};
+ChatInputNotificationService = ( __decorate([( __param(0, ILogService))], ChatInputNotificationService));
+function readDismissedNotificationIds(storageService, key) {
+    const raw = storageService.get(key, StorageScope.APPLICATION);
+    try {
+        const parsed = raw ? JSON.parse(raw) : undefined;
+        return ( new Set(
+            Array.isArray(parsed) ? parsed.filter(value => typeof value === "string") : []
+        ));
+    } catch {
+        return ( new Set());
+    }
+}
+function addDismissedNotificationId(storageService, key, id) {
+    const dismissed = readDismissedNotificationIds(storageService, key);
+    if (( dismissed.has(id))) {
+        return;
+    }
+    dismissed.add(id);
+    storageService.store(
+        key,
+        JSON.stringify([...dismissed]),
+        StorageScope.APPLICATION,
+        StorageTarget.USER
+    );
+}
+
+export { ChatInputNotificationActionKind, ChatInputNotificationService, ChatInputNotificationSeverity, addDismissedNotificationId, getChatInputNotificationAnnouncementSignature, isChatInputNotificationApplicableToSession, isChatInputNotificationApplicableToSessionType, matchesModelIdentifier, readDismissedNotificationIds, resolveChatInputNotificationBody };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service.d.ts

@@ -1,5 +1,5 @@
 import { Event } from "../../../../../../base/common/event.js";
-import { IChatInputNotification } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService";
+import { IChatInputNotification, IChatInputNotificationContext, IChatInputNotificationBody } from "./chatInputNotificationService.js";
 export declare const IChatInputNotificationService: import("../../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatInputNotificationService>;
 export interface IChatInputNotificationService {
     readonly _serviceBrand: undefined;
@@ -16,6 +16,11 @@ export interface IChatInputNotificationService {
     */
     deleteNotification(id: string): void;
     /**
+    * Ask mounted inputs to re-evaluate what they render, without touching notification or
+    * dismissal state. Use when something a `when` predicate reads has changed.
+    */
+    refresh(): void;
+    /**
     * Mark a notification as dismissed by the user. It will no longer be returned
     * by {@link getActiveNotification} until it is re-pushed with new content.
     */
@@ -28,8 +33,19 @@ export interface IChatInputNotificationService {
     */
     getActiveNotification(filter?: (notification: IChatInputNotification) => boolean): IChatInputNotification | undefined;
     /**
-    * Called when the user sends a chat message. Auto-dismisses all notifications
-    * that have {@link IChatInputNotification.autoDismissOnMessage} set.
+    * Called when the user sends a chat message. Auto-dismisses the notifications
+    * that have {@link IChatInputNotification.autoDismissOnMessage} set and that
+    * apply to the session the message was sent in, so a message in one session
+    * doesn't hide session-scoped notifications belonging to another. When no
+    * context is given, all such notifications are dismissed.
+    */
+    handleMessageSent(context?: IChatInputNotificationContext): void;
+    /**
+    * Announce a notification that a chat input is about to render to screen
+    * readers. De-duplicated per notification id across all mounted chat inputs,
+    * so content shown in several widgets (panel, side bar, …) is only spoken
+    * once and session-scoped notifications are only announced when a chat input
+    * in a matching session actually renders them. Passing `undefined` is a no-op.
     */
-    handleMessageSent(): void;
+    announceRendered(notification: IChatInputNotification | undefined, body?: IChatInputNotificationBody): void;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatPhoneInputPresenter.service.d.ts

@@ -1,8 +1,6 @@
 import { IDisposable } from "../../../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../../../base/common/observable.js";
-import { IChatPhonePresenterImpl } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatPhoneInputPresenter";
-import { IModelPickerDelegate } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/modelPickerActionItem";
-import { IModePickerDelegate } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/modePickerActionItem";
+import { ChatPhoneInputPresenterRequest, IChatPhonePresenterImpl } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatPhoneInputPresenter";
 export declare const IChatPhoneInputPresenter: import("../../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatPhoneInputPresenter>;
 /**
 * Workbench-layer hook for phone-only chat-input picker presentation.
@@ -26,7 +24,7 @@ export interface IChatPhoneInputPresenter {
     * Show the unified phone-layout Mode + Model sheet. No-ops when
     * {@link enabled} is `false`.
     */
-    showCombinedModeAndModelSheet(target: HTMLElement, modeDelegate: IModePickerDelegate | undefined, modelDelegate: IModelPickerDelegate | undefined): Promise<void>;
+    showCombinedModeAndModelSheet(target: HTMLElement, request: ChatPhoneInputPresenterRequest): Promise<void>;
     /**
     * Register the phone implementation. Returns a disposable that removes
     * the registration. Only one impl is active at a time; the most recent