@codingame/monaco-vscode-api 26.2.1 → 27.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables.js

@@ -0,0 +1,243 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from '../../../../../base/common/arrays.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { Disposable, MutableDisposable, dispose, isDisposable } from '../../../../../base/common/lifecycle.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+import { isLocation } from '../../../../../editor/common/languages.js';
+import { Action2, registerAction2 } from '../../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
+import { ILabelService } from '../../../../../platform/label/common/label.service.js';
+import { addDynamicVariableActionId } from '../widget/input/editor/chatDynamicVariablesConstant.js';
+
+var ChatDynamicVariableModel_1;
+const dynamicVariableDecorationType = "chat-dynamic-variable";
+let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable {
+    static {
+        ChatDynamicVariableModel_1 = this;
+    }
+    static {
+        this.ID = "chatDynamicVariableModel";
+    }
+    get variables() {
+        return [...this._variables];
+    }
+    get id() {
+        return ChatDynamicVariableModel_1.ID;
+    }
+    constructor(widget, labelService) {
+        super();
+        this.widget = widget;
+        this.labelService = labelService;
+        this._variables = [];
+        this.decorationData = [];
+        this._editorListener = this._register(( new MutableDisposable()));
+        this._subscribeToEditor();
+        this._register(widget.onDidChangeActiveInputEditor(() => {
+            this._subscribeToEditor();
+            this.updateDecorations();
+        }));
+    }
+    _subscribeToEditor() {
+        this._editorListener.value = this.widget.inputEditor.onDidChangeModelContent(e => {
+            const removed = [];
+            let didChange = false;
+            this._variables = coalesce(( this._variables.map((ref, idx) => {
+                const model = this.widget.inputEditor.getModel();
+                if (!model) {
+                    removed.push(ref);
+                    return null;
+                }
+                const data = this.decorationData[idx];
+                if (!data) {
+                    removed.push(ref);
+                    return null;
+                }
+                const newRange = model.getDecorationRange(data.id);
+                if (!newRange) {
+                    removed.push(ref);
+                    return null;
+                }
+                const newText = model.getValueInRange(newRange);
+                if (newText !== data.text) {
+                    this.widget.inputEditor.executeEdits(this.id, [{
+                        range: newRange,
+                        text: ""
+                    }]);
+                    this.widget.refreshParsedInput();
+                    removed.push(ref);
+                    return null;
+                }
+                if (newRange.equalsRange(ref.range)) {
+                    return ref;
+                }
+                didChange = true;
+                return {
+                    ...ref,
+                    range: newRange
+                };
+            })));
+            dispose(removed.filter(isDisposable));
+            if (didChange || removed.length > 0) {
+                this.widget.refreshParsedInput();
+            }
+            this.updateDecorations();
+        });
+    }
+    getInputState(contrib) {
+        contrib[ChatDynamicVariableModel_1.ID] = this.variables;
+    }
+    setInputState(contrib) {
+        let s = contrib[ChatDynamicVariableModel_1.ID];
+        if (!Array.isArray(s)) {
+            s = [];
+        }
+        this.disposeVariables();
+        this._variables = [];
+        for (const variable of s) {
+            if (!isDynamicVariable(variable)) {
+                continue;
+            }
+            this.addReference(variable);
+        }
+    }
+    addReference(ref) {
+        if (!isValidEditorRange(ref.range)) {
+            return;
+        }
+        this._variables.push(ref);
+        this.updateDecorations();
+        this.widget.refreshParsedInput();
+    }
+    updateDecorations() {
+        const model = this.widget.inputEditor.getModel();
+        if (!model) {
+            this.decorationData = [];
+            return;
+        }
+        const validVariables = this._variables.filter(v => isValidEditorRange(v.range));
+        const decorationIds = this.widget.inputEditor.setDecorationsByType("chat", dynamicVariableDecorationType, ( validVariables.map(r => ({
+            range: r.range,
+            hoverMessage: this.getHoverForReference(r)
+        }))));
+        this._variables = validVariables.slice(0, decorationIds.length);
+        this.decorationData = [];
+        for (let i = 0; i < decorationIds.length; i++) {
+            this.decorationData.push({
+                id: decorationIds[i],
+                text: model.getValueInRange(this._variables[i].range)
+            });
+        }
+    }
+    getHoverForReference(ref) {
+        const value = ref.data;
+        if (URI.isUri(value)) {
+            return ( new MarkdownString(this.labelService.getUriLabel(value, {
+                relative: true
+            })));
+        } else if (isLocation(value)) {
+            const prefix = ref.fullName ? ` ${ref.fullName}` : "";
+            const rangeString = `#${value.range.startLineNumber}-${value.range.endLineNumber}`;
+            return ( new MarkdownString(prefix + this.labelService.getUriLabel(value.uri, {
+                relative: true
+            }) + rangeString));
+        } else {
+            return undefined;
+        }
+    }
+    disposeVariables() {
+        for (const variable of this._variables) {
+            if (isDisposable(variable)) {
+                variable.dispose();
+            }
+        }
+    }
+    dispose() {
+        this.disposeVariables();
+        super.dispose();
+    }
+};
+ChatDynamicVariableModel = ChatDynamicVariableModel_1 = ( __decorate([( __param(1, ILabelService))], ChatDynamicVariableModel));
+function isDynamicVariable(obj) {
+    return obj && typeof obj.id === "string" && Range.isIRange(obj.range) && isValidEditorRange(obj.range) && "data" in obj;
+}
+function isValidEditorRange(range) {
+    if (range.startLineNumber < 1 || range.endLineNumber < 1 || range.startColumn < 1 || range.endColumn < 1) {
+        return false;
+    }
+    if (range.startLineNumber > range.endLineNumber) {
+        return false;
+    }
+    if (range.startLineNumber === range.endLineNumber && range.startColumn >= range.endColumn) {
+        return false;
+    }
+    return true;
+}
+function isAddDynamicVariableContext(context) {
+    return "widget" in context && "range" in context && "variableData" in context;
+}
+class AddDynamicVariableAction extends Action2 {
+    static {
+        this.ID = addDynamicVariableActionId;
+    }
+    constructor() {
+        super({
+            id: AddDynamicVariableAction.ID,
+            title: ""
+        });
+    }
+    async run(accessor, ...args) {
+        const context = args[0];
+        if (!isAddDynamicVariableContext(context)) {
+            return;
+        }
+        let range = context.range;
+        const variableData = context.variableData;
+        const doCleanup = () => {
+            context.widget.inputEditor.executeEdits("chatInsertDynamicVariableWithArguments", [{
+                range: context.range,
+                text: ``
+            }]);
+        };
+        if (context.command) {
+            const commandService = accessor.get(ICommandService);
+            const selection = await commandService.executeCommand(context.command.id, ...(context.command.arguments ?? []));
+            if (!selection) {
+                doCleanup();
+                return;
+            }
+            const insertText = ":" + selection;
+            const insertRange = ( new Range(
+                range.startLineNumber,
+                range.endColumn,
+                range.endLineNumber,
+                range.endColumn + insertText.length
+            ));
+            range = ( new Range(
+                range.startLineNumber,
+                range.startColumn,
+                range.endLineNumber,
+                range.endColumn + insertText.length
+            ));
+            const editor = context.widget.inputEditor;
+            const success = editor.executeEdits("chatInsertDynamicVariableWithArguments", [{
+                range: insertRange,
+                text: insertText + " "
+            }]);
+            if (!success) {
+                doCleanup();
+                return;
+            }
+        }
+        context.widget.getContrib(ChatDynamicVariableModel.ID)?.addReference({
+            id: context.id,
+            range: range,
+            isFile: true,
+            data: variableData
+        });
+    }
+}
+registerAction2(AddDynamicVariableAction);
+
+export { AddDynamicVariableAction, ChatDynamicVariableModel, dynamicVariableDecorationType };

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatScreenshotContext.js

@@ -5,7 +5,7 @@ const ScreenshotVariableId = "screenshot-focused-window";
 function convertBufferToScreenshotVariable(buffer) {
     return {
         id: ScreenshotVariableId,
-        name: ( localize(5110, "Screenshot")),
+        name: ( localize(5361, "Screenshot")),
         value: buffer.buffer,
         kind: "image"
     };

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

@@ -204,6 +204,11 @@ export interface IChatAcceptInputOptions {
      * If Steering, also sets yieldRequested on any active request to signal it should wrap up.
      */
     queue?: ChatRequestQueueKind;
+    /**
+     * When true, always queues the request regardless of whether a request is currently in progress.
+     * The request stays in the pending queue until explicitly processed.
+     */
+    alwaysQueue?: boolean;
 }
 export interface IChatWidgetViewModelChangeEvent {
     readonly previousSessionResource: URI | undefined;
@@ -224,6 +229,7 @@ export interface IChatWidget {
         slashCommand?: IChatAgentCommand;
     }>;
     readonly onDidChangeParsedInput: Event<void>;
+    readonly onDidChangeActiveInputEditor: Event<void>;
     readonly onDidFocus: Event<void>;
     readonly location: ChatAgentLocation;
     readonly viewContext: IChatWidgetViewContext;
@@ -261,6 +267,42 @@ export interface IChatWidget {
      */
     focusResponseItem(lastFocused?: boolean): void;
     focusInput(): void;
+    /**
+     * Focuses the Todos view in the chat widget.
+     * @returns Whether the operation succeeded (i.e., the Todos view was focused).
+     */
+    focusTodosView(): boolean;
+    /**
+     * Toggles focus between the Todos view and the previous focus target in the chat widget.
+     * @returns Whether the operation succeeded (i.e., the focus was toggled).
+     */
+    toggleTodosViewFocus(): boolean;
+    /**
+     * Focuses the question carousel in the chat widget.
+     * @returns Whether the operation succeeded (i.e., the question carousel was focused).
+     */
+    focusQuestionCarousel(): boolean;
+    /**
+     * Toggles focus between the question carousel and the chat input.
+     * @returns Whether the operation succeeded (i.e., the focus was toggled).
+     */
+    toggleQuestionCarouselFocus(): boolean;
+    /**
+     * Navigates to the previous question in the question carousel.
+     * @returns Whether the operation succeeded (i.e., a previous question exists).
+     */
+    navigateToPreviousQuestion(): boolean;
+    /**
+     * Navigates to the next question in the question carousel.
+     * @returns Whether the operation succeeded (i.e., a next question exists).
+     */
+    navigateToNextQuestion(): boolean;
+    /**
+     * Toggles focus between the tip widget and the chat input.
+     * Returns false if no tip is visible.
+     * @returns Whether the operation succeeded (i.e., the focus was toggled).
+     */
+    toggleTipFocus(): boolean;
     hasInputFocus(): boolean;
     getModeRequestOptions(): Partial<IChatSendRequestOptions>;
     getCodeBlockInfoForEditor(uri: URI): IChatCodeBlockInfo | undefined;

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

@@ -25,6 +25,15 @@ export interface IChatWidgetService {
     */
     readonly onDidBackgroundSession: Event<URI>;
     /**
+    * Fires when the focused chat widget changes.
+    */
+    readonly onDidChangeFocusedWidget: Event<IChatWidget | undefined>;
+    /**
+    * Fires when the focused chat session changes, either because the focused widget
+    * changed or because the focused widget loaded a different session.
+    */
+    readonly onDidChangeFocusedSession: Event<void>;
+    /**
     * Reveals the widget, focusing its input unless `preserveFocus` is true.
     */
     reveal(widget: IChatWidget, preserveFocus?: boolean): Promise<boolean>;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys.js

@@ -17,16 +17,16 @@ import { autorun } from '../../../../../base/common/observableInternal/reactions
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
 import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
 
-const ctxIsGlobalEditingSession = ( new RawContextKey("chatEdits.isGlobalEditingSession", undefined, ( localize(5342, "The current editor is part of the global edit session"))));
-const ctxHasEditorModification = ( new RawContextKey("chatEdits.hasEditorModifications", undefined, ( localize(5343, "The current editor contains chat modifications"))));
-const ctxIsCurrentlyBeingModified = ( new RawContextKey("chatEdits.isCurrentlyBeingModified", undefined, ( localize(5344, "The current editor is currently being modified"))));
-const ctxReviewModeEnabled = ( new RawContextKey("chatEdits.isReviewModeEnabled", true, ( localize(5345, "Review mode for chat changes is enabled"))));
+const ctxIsGlobalEditingSession = ( new RawContextKey("chatEdits.isGlobalEditingSession", undefined, ( localize(5775, "The current editor is part of the global edit session"))));
+const ctxHasEditorModification = ( new RawContextKey("chatEdits.hasEditorModifications", undefined, ( localize(5776, "The current editor contains chat modifications"))));
+const ctxIsCurrentlyBeingModified = ( new RawContextKey("chatEdits.isCurrentlyBeingModified", undefined, ( localize(5777, "The current editor is currently being modified"))));
+const ctxReviewModeEnabled = ( new RawContextKey("chatEdits.isReviewModeEnabled", true, ( localize(5778, "Review mode for chat changes is enabled"))));
 const ctxHasRequestInProgress = ( new RawContextKey("chatEdits.isRequestInProgress", false, ( localize(
-    5346,
+    5779,
     "The current editor shows a file from an edit session which is still in progress"
 ))));
-const ctxRequestCount = ( new RawContextKey("chatEdits.requestCount", 0, ( localize(5347, "The number of turns the editing session in this editor has"))));
-const ctxCursorInChangeRange = ( new RawContextKey("chatEdits.cursorInChangeRange", false, ( localize(5348, "The cursor is inside a change range made by chat editing."))));
+const ctxRequestCount = ( new RawContextKey("chatEdits.requestCount", 0, ( localize(5780, "The number of turns the editing session in this editor has"))));
+const ctxCursorInChangeRange = ( new RawContextKey("chatEdits.cursorInChangeRange", false, ( localize(5781, "The cursor is inside a change range made by chat editing."))));
 let ChatEditingEditorContextKeys = class ChatEditingEditorContextKeys {
     static {
         this.ID = "chat.edits.editorContextKeys";

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

@@ -1,15 +1,63 @@
+import { Event } from "../../../../base/common/event.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
 import { IChatTip } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/chatTipService";
 export declare const IChatTipService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatTipService>;
 export interface IChatTipService {
     readonly _serviceBrand: undefined;
     /**
-    * Gets a tip to show for a request, or undefined if a tip has already been shown this session.
-    * Only one tip is shown per VS Code session (resets on reload).
-    * Tips are only shown for requests created after the service was instantiated.
-    * @param requestId The unique ID of the request (used for stable rerenders).
-    * @param requestTimestamp The timestamp when the request was created.
-    * @param contextKeyService The context key service to evaluate tip eligibility.
+    * Fired when the current tip is dismissed.
     */
-    getNextTip(requestId: string, requestTimestamp: number, contextKeyService: IContextKeyService): IChatTip | undefined;
+    readonly onDidDismissTip: Event<void>;
+    /**
+    * Fired when the user navigates to a different tip (previous/next).
+    */
+    readonly onDidNavigateTip: Event<IChatTip>;
+    /**
+    * Fired when the tip widget is hidden without dismissing the tip.
+    */
+    readonly onDidHideTip: Event<void>;
+    /**
+    * Fired when tips are disabled.
+    */
+    readonly onDidDisableTips: Event<void>;
+    /**
+    * Gets a tip to show on the welcome/getting-started view.
+    * Returns the same tip on repeated calls for stable rerenders.
+    */
+    getWelcomeTip(contextKeyService: IContextKeyService): IChatTip | undefined;
+    /**
+    * Resets tip state for a new conversation.
+    * Call this when the chat widget binds to a new model.
+    */
+    resetSession(): void;
+    /**
+    * Dismisses the current tip and allows a new one to be picked for the same request.
+    * The dismissed tip will not be shown again for this user on this application installation.
+    */
+    dismissTip(): void;
+    /**
+    * Hides the tip widget without permanently dismissing the tip.
+    * The tip may be shown again in a future session.
+    */
+    hideTip(): void;
+    /**
+    * Disables tips permanently by setting the `chat.tips.enabled` configuration to false.
+    */
+    disableTips(): Promise<void>;
+    /**
+    * Navigates to the next tip in the catalog without permanently dismissing the current one.
+    */
+    navigateToNextTip(): IChatTip | undefined;
+    /**
+    * Navigates to the previous tip in the catalog without permanently dismissing the current one.
+    */
+    navigateToPreviousTip(): IChatTip | undefined;
+    /**
+    * Returns whether there are multiple eligible tips for navigation.
+    */
+    hasMultipleTips(): boolean;
+    /**
+    * Clears all dismissed tips so they can be shown again.
+    */
+    clearDismissedTips(): void;
 }

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

@@ -34,7 +34,7 @@ let PromptFileRewriter = class PromptFileRewriter {
             this.rewriteAttribute(model, "", toolsAttr.range);
             return;
         } else {
-            this.rewriteTools(model, newTools, toolsAttr.value.range, toolsAttr.value.type === "string");
+            this.rewriteTools(model, newTools, toolsAttr.value.range, toolsAttr.value.type === "scalar");
         }
     }
     rewriteTools(model, newTools, range, isString) {
@@ -64,7 +64,7 @@ let PromptFileRewriter = class PromptFileRewriter {
         if (!nameAttr) {
             return;
         }
-        if (nameAttr.value.type === "string" && nameAttr.value.value === newName) {
+        if (nameAttr.value.type === "scalar" && nameAttr.value.value === newName) {
             return;
         }
         editor.setSelection(nameAttr.range);

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

@@ -3,6 +3,7 @@ import { __decorate, __param } from '../../../../../../../../../external/tslib/t
 import { CancellationToken } from '../../../../../../base/common/cancellation.js';
 import { Codicon } from '../../../../../../base/common/codicons.js';
 import { MutableDisposable, Disposable } from '../../../../../../base/common/lifecycle.js';
+import { revive } from '../../../../../../base/common/marshalling.js';
 import { Schemas } from '../../../../../../base/common/network.js';
 import { isEqual } from '../../../../../../base/common/resources.js';
 import { truncate } from '../../../../../../base/common/strings.js';
@@ -22,7 +23,7 @@ import { ModifiedFileEntryState } from '../../../common/editing/chatEditingServi
 import { LocalChatSessionUri, getChatSessionType } from '../../../common/model/chatUri.js';
 
 var ChatEditorInput_1;
-const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(6226, "Icon of the chat editor label.")));
+const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(6765, "Icon of the chat editor label.")));
 let ChatEditorInput = class ChatEditorInput extends EditorInput {
     static {
         ChatEditorInput_1 = this;
@@ -78,8 +79,8 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (!this.model?.editingSession || this.didTransferOutEditingSession || this.getSessionType() !== localChatSessionType) {
             return ConfirmResult.SAVE;
         }
-        const titleOverride = ( localize(6227, "Close Chat Editor"));
-        const messageOverride = ( localize(6228, "Closing the chat editor will end your current edit session."));
+        const titleOverride = ( localize(6766, "Close Chat Editor"));
+        const messageOverride = ( localize(6767, "Closing the chat editor will end your current edit session."));
         const result = await showClearEditingSessionConfirmation(this.model, this.dialogService, {
             titleOverride,
             messageOverride
@@ -118,7 +119,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (this.options.title?.preferred) {
             return this.options.title.preferred;
         }
-        return this.options.title?.fallback ?? ( localize(6229, "Chat"));
+        return this.options.title?.fallback ?? ( localize(6768, "Chat"));
     }
     getTitle(verbosity) {
         const name = this.getName();
@@ -165,18 +166,18 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         const chatSessionType = searchParams.get("chatSessionType");
         const inputType = chatSessionType ?? this.resource.authority;
         if (this._sessionResource) {
-            this.modelRef.value = await this.chatService.loadSessionForResource(this._sessionResource, ChatAgentLocation.Chat, CancellationToken.None);
+            this.modelRef.value = await this.chatService.acquireOrLoadSession(this._sessionResource, ChatAgentLocation.Chat, CancellationToken.None);
             if (!this.model && LocalChatSessionUri.parseLocalSessionId(this._sessionResource)) {
-                this.modelRef.value = this.chatService.startSession(ChatAgentLocation.Chat, {
+                this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
                     canUseTools: true
                 });
             }
         } else if (!this.options.target) {
-            this.modelRef.value = this.chatService.startSession(ChatAgentLocation.Chat, {
+            this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
                 canUseTools: !inputType
             });
         } else if (this.options.target.data) {
-            this.modelRef.value = this.chatService.loadSessionFromContent(this.options.target.data);
+            this.modelRef.value = this.chatService.loadSessionFromData(this.options.target.data);
         }
         if (!this.model || this.isDisposed()) {
             return null;
@@ -265,7 +266,7 @@ class ChatEditorInputSerializer {
     }
     deserialize(instantiationService, serializedEditor) {
         try {
-            const parsed = JSON.parse(serializedEditor);
+            const parsed = revive(JSON.parse(serializedEditor));
             if (parsed.sessionResource) {
                 const sessionResource = URI.revive(parsed.sessionResource);
                 return instantiationService.createInstance(ChatEditorInput, sessionResource, parsed.options);
@@ -285,25 +286,25 @@ async function showClearEditingSessionConfirmation(model, dialogService, options
     if (!undecidedEdits) {
         return true;
     }
-    const defaultPhrase = ( localize(6230, "Starting a new chat will end your current edit session."));
-    const defaultTitle = ( localize(6231, "Start new chat?"));
+    const defaultPhrase = ( localize(6769, "Starting a new chat will end your current edit session."));
+    const defaultTitle = ( localize(6770, "Start new chat?"));
     const phrase = options?.messageOverride ?? defaultPhrase;
     const title = options?.titleOverride ?? defaultTitle;
     const {
         result
     } = await dialogService.prompt({
         title,
-        message: phrase + " " + ( localize(6232, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
+        message: phrase + " " + ( localize(6771, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
         type: "info",
         cancelButton: true,
         buttons: [{
-            label: ( localize(6233, "Keep & Continue")),
+            label: ( localize(6772, "Keep & Continue")),
             run: async () => {
                 await model.editingSession.accept();
                 return true;
             }
         }, {
-            label: ( localize(6234, "Undo & Continue")),
+            label: ( localize(6773, "Undo & Continue")),
             run: async () => {
                 await model.editingSession.reject();
                 return true;

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

@@ -25,10 +25,15 @@ export declare namespace ChatContextKeys {
     const inputHasFocus: RawContextKey<boolean>;
     const inChatInput: RawContextKey<boolean>;
     const inChatSession: RawContextKey<boolean>;
+    const inChatQuestionCarousel: RawContextKey<boolean>;
     const inChatEditor: RawContextKey<boolean>;
+    const inChatTodoList: RawContextKey<boolean>;
+    const inChatTip: RawContextKey<boolean>;
+    const multipleChatTips: RawContextKey<boolean>;
     const inChatTerminalToolOutput: RawContextKey<boolean>;
     const chatModeKind: RawContextKey<ChatModeKind>;
     const chatModeName: RawContextKey<string>;
+    const chatModelId: RawContextKey<string>;
     const supported: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     const enabled: RawContextKey<boolean>;
     /**
@@ -40,6 +45,12 @@ export declare namespace ChatContextKeys {
      * which means the mode picker should be shown with filtered custom agents.
      */
     const chatSessionHasCustomAgentTarget: RawContextKey<boolean>;
+    /**
+     * True when the current chat session has models that specifically target it
+     * via `targetChatSessionType`, which means the model picker should be shown
+     * even when the widget is locked to a coding agent.
+     */
+    const chatSessionHasTargetedModels: RawContextKey<boolean>;
     const agentSupportsAttachments: RawContextKey<boolean>;
     const withinEditSessionDiff: RawContextKey<boolean>;
     const filePartOfEditSession: RawContextKey<boolean>;
@@ -60,6 +71,7 @@ export declare namespace ChatContextKeys {
     const hasFileAttachments: RawContextKey<boolean>;
     const chatSessionIsEmpty: RawContextKey<boolean>;
     const hasPendingRequests: RawContextKey<boolean>;
+    const chatSessionHasDebugData: RawContextKey<boolean>;
     const remoteJobCreating: RawContextKey<boolean>;
     const hasRemoteCodingAgent: RawContextKey<boolean>;
     const hasCanDelegateProviders: RawContextKey<boolean>;
@@ -91,6 +103,7 @@ export declare namespace ChatContextKeys {
     const Editing: {
         hasToolConfirmation: RawContextKey<boolean>;
         hasElicitationRequest: RawContextKey<boolean>;
+        hasQuestionCarousel: RawContextKey<boolean>;
     };
     const Tools: {
         toolsCount: RawContextKey<number>;
@@ -111,6 +124,13 @@ export declare namespace ChatContextKeys {
     const hasMultipleAgentSessionsSelected: RawContextKey<boolean>;
     const hasAgentSessionChanges: RawContextKey<boolean>;
     const isKatexMathElement: RawContextKey<boolean>;
+    /**
+     * True when the user has submitted a chat request using any of the `/create-*` slash commands.
+     * This is persisted in application storage and used to suppress onboarding tips once discovered.
+     */
+    const hasUsedCreateSlashCommands: RawContextKey<boolean>;
+    const contextUsageHasBeenOpened: RawContextKey<boolean>;
+    const newChatButtonExperimentIcon: RawContextKey<string>;
 }
 export declare namespace ChatContextKeyExprs {
     const inEditingMode: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;