@codingame/monaco-vscode-api 15.0.3 → 16.0.1

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibleViewActions.js

@@ -40,7 +40,7 @@ class AccessibleViewNextAction extends Action2 {
                 }
             ],
             icon: Codicon.arrowDown,
-            title: ( localize(4133, "Show Next in Accessible View"))
+            title: ( localize(4180, "Show Next in Accessible View"))
         });
     }
     run(accessor) {
@@ -63,7 +63,7 @@ class AccessibleViewNextCodeBlockAction extends Action2 {
                 ...accessibleViewMenu,
                 when: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewContainsCodeBlocks)),
             },
-            title: ( localize(4134, "Accessible View: Next Code Block"))
+            title: ( localize(4181, "Accessible View: Next Code Block"))
         });
     }
     run(accessor) {
@@ -86,7 +86,7 @@ class AccessibleViewPreviousCodeBlockAction extends Action2 {
                 ...accessibleViewMenu,
                 when: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewContainsCodeBlocks)),
             },
-            title: ( localize(4135, "Accessible View: Previous Code Block"))
+            title: ( localize(4182, "Accessible View: Previous Code Block"))
         });
     }
     run(accessor) {
@@ -111,7 +111,7 @@ class AccessibleViewPreviousAction extends Action2 {
                     when: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation)),
                 }
             ],
-            title: ( localize(4136, "Show Previous in Accessible View"))
+            title: ( localize(4183, "Show Previous in Accessible View"))
         });
     }
     run(accessor) {
@@ -137,7 +137,7 @@ class AccessibleViewGoToSymbolAction extends Action2 {
                     when: ( ContextKeyExpr.and(( ContextKeyExpr.or(accessibleViewIsShown, accessibilityHelpIsShown)), accessibleViewGoToSymbolSupported)),
                 }
             ],
-            title: ( localize(4137, "Go To Symbol in Accessible View"))
+            title: ( localize(4184, "Go To Symbol in Accessible View"))
         });
     }
     run(accessor) {
@@ -164,7 +164,7 @@ const AccessibilityHelpAction = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(4138, "Open Accessibility Help")),
+            title: ( localize(4185, "Open Accessibility Help")),
             order: 1
         }],
 })));
@@ -182,7 +182,7 @@ const AccessibleViewAction = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(4139, "Open Accessible View")),
+            title: ( localize(4186, "Open Accessible View")),
             order: 1
         }],
 })));
@@ -204,7 +204,7 @@ class AccessibleViewDisableHintAction extends Action2 {
                     when: ( ContextKeyExpr.and(( ContextKeyExpr.or(accessibleViewIsShown, accessibilityHelpIsShown)), accessibleViewVerbosityEnabled)),
                 }
             ],
-            title: ( localize(4140, "Disable Accessible View Hint"))
+            title: ( localize(4187, "Disable Accessible View Hint"))
         });
     }
     run(accessor) {
@@ -230,7 +230,7 @@ class AccessibilityHelpConfigureKeybindingsAction extends Action2 {
                     when: accessibleViewHasUnassignedKeybindings,
                 }
             ],
-            title: ( localize(4141, "Accessibility Help Configure Unassigned Keybindings"))
+            title: ( localize(4188, "Accessibility Help Configure Unassigned Keybindings"))
         });
     }
     async run(accessor) {
@@ -256,7 +256,7 @@ class AccessibilityHelpConfigureAssignedKeybindingsAction extends Action2 {
                     when: accessibleViewHasAssignedKeybindings,
                 }
             ],
-            title: ( localize(4142, "Accessibility Help Configure Assigned Keybindings"))
+            title: ( localize(4189, "Accessibility Help Configure Assigned Keybindings"))
         });
     }
     async run(accessor) {
@@ -273,7 +273,7 @@ class AccessibilityHelpOpenHelpLinkAction extends Action2 {
                 primary: KeyMod$1.Alt | KeyCode.KeyH,
                 weight: KeybindingWeight.WorkbenchContrib
             },
-            title: ( localize(4143, "Accessibility Help Open Help Link"))
+            title: ( localize(4190, "Accessibility Help Open Help Link"))
         });
     }
     run(accessor) {
@@ -307,7 +307,7 @@ class AccessibleViewAcceptInlineCompletionAction extends Action2 {
                     ))))
                 }
             ],
-            title: ( localize(4144, "Accept Inline Completion"))
+            title: ( localize(4191, "Accept Inline Completion"))
         });
     }
     async run(accessor) {
@@ -317,7 +317,7 @@ class AccessibleViewAcceptInlineCompletionAction extends Action2 {
             return;
         }
         const model = InlineCompletionsController.get(editor)?.model.get();
-        const state = model?.inlineCompletionState.get();
+        const state = model?.state.get();
         if (!model || !state) {
             return;
         }

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

@@ -1,14 +1,15 @@
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
-import { ChatAgentLocation } from "../common/chatAgents.js";
 import { IChatResponseViewModel } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+import { ChatAgentLocation } from "../common/constants.js";
 import { IChatWidget, type ICodeBlockActionContextProvider, type IQuickChatOpenOptions } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chat";
 export declare const IChatWidgetService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatWidgetService>;
 export interface IChatWidgetService {
     readonly _serviceBrand: undefined;
     readonly lastFocusedWidget: IChatWidget | undefined;
     readonly onDidAddWidget: Event<IChatWidget>;
+    getAllWidgets(): ReadonlyArray<IChatWidget>;
     getWidgetByInputUri(uri: URI): IChatWidget | undefined;
     getWidgetBySessionId(sessionId: string): IChatWidget | undefined;
     getWidgetsByLocations(location: ChatAgentLocation): ReadonlyArray<IChatWidget>;

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

@@ -16,14 +16,14 @@ import { observableFromEvent, constObservable } from '../../../../../base/common
 import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
 import { derived } from '../../../../../base/common/observableInternal/derived.js';
 
-const ctxIsGlobalEditingSession = ( new RawContextKey('chatEdits.isGlobalEditingSession', undefined, ( localize(4573, "The current editor is part of the global edit session"))));
-const ctxHasEditorModification = ( new RawContextKey('chatEdits.hasEditorModifications', undefined, ( localize(4574, "The current editor contains chat modifications"))));
-const ctxReviewModeEnabled = ( new RawContextKey('chatEdits.isReviewModeEnabled', true, ( localize(4575, "Review mode for chat changes is enabled"))));
+const ctxIsGlobalEditingSession = ( new RawContextKey('chatEdits.isGlobalEditingSession', undefined, ( localize(4670, "The current editor is part of the global edit session"))));
+const ctxHasEditorModification = ( new RawContextKey('chatEdits.hasEditorModifications', undefined, ( localize(4671, "The current editor contains chat modifications"))));
+const ctxReviewModeEnabled = ( new RawContextKey('chatEdits.isReviewModeEnabled', true, ( localize(4672, "Review mode for chat changes is enabled"))));
 const ctxHasRequestInProgress = ( new RawContextKey('chatEdits.isRequestInProgress', false, ( localize(
-    4576,
+    4673,
     "The current editor shows a file from an edit session which is still in progress"
 ))));
-const ctxRequestCount = ( new RawContextKey('chatEdits.requestCount', 0, ( localize(4577, "The number of turns the editing session in this editor has"))));
+const ctxRequestCount = ( new RawContextKey('chatEdits.requestCount', 0, ( localize(4674, "The number of turns the editing session in this editor has"))));
 let ChatEditingEditorContextKeys = class ChatEditingEditorContextKeys {
     static { this.ID = 'chat.edits.editorContextKeys'; }
     constructor(instaService, editorGroupsService) {

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

@@ -0,0 +1,10 @@
+import { Event } from "../../../../base/common/event.js";
+import { IChatStatusItemChangeEvent, ChatStatusEntry } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/chatStatusItemService";
+export declare const IChatStatusItemService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatStatusItemService>;
+export interface IChatStatusItemService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChange: Event<IChatStatusItemChangeEvent>;
+    setOrUpdateEntry(entry: ChatStatusEntry): void;
+    deleteEntry(id: string): void;
+    getEntries(): Iterable<ChatStatusEntry>;
+}

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

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

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

@@ -1,15 +1,14 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
-import { ChatAgentLocation, IChatAgent, IChatAgentCommand, IChatAgentCompletionItem, IChatAgentData, IChatAgentHistoryEntry, IChatAgentImplementation, IChatAgentMetadata, IChatAgentRequest, IChatAgentResult, IChatParticipantDetectionProvider } from "./chatAgents.js";
+import { IChatAgent, IChatAgentCommand, IChatAgentCompletionItem, IChatAgentData, IChatAgentHistoryEntry, IChatAgentImplementation, IChatAgentMetadata, IChatAgentRequest, IChatAgentResult, IChatParticipantDetectionProvider } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
 import { IChatFollowup, IChatProgress } from "./chatService.js";
+import { ChatAgentLocation, ChatMode } from "./constants.js";
 export declare const IChatAgentService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatAgentService>;
 export interface IChatAgentService {
     _serviceBrand: undefined;
     readonly onDidChangeAgents: Event<IChatAgent | undefined>;
-    readonly onDidChangeToolsAgentModeEnabled: Event<void>;
-    readonly toolsAgentModeEnabled: boolean;
-    toggleToolsAgentMode(enabled?: boolean): void;
+    readonly hasToolsAgent: boolean;
     registerAgent(id: string, data: IChatAgentData): IDisposable;
     registerAgentImplementation(id: string, agent: IChatAgentImplementation): IDisposable;
     registerDynamicAgent(data: IChatAgentData, agentImpl: IChatAgentImplementation): IDisposable;
@@ -33,9 +32,8 @@ export interface IChatAgentService {
     getActivatedAgents(): Array<IChatAgent>;
     getAgentsByName(name: string): IChatAgentData[];
     agentHasDupeName(id: string): boolean;
-    getDefaultAgent(location: ChatAgentLocation): IChatAgent | undefined;
+    getDefaultAgent(location: ChatAgentLocation, mode?: ChatMode): IChatAgent | undefined;
     getContributedDefaultAgent(location: ChatAgentLocation): IChatAgentData | undefined;
-    getSecondaryAgent(): IChatAgentData | undefined;
     updateAgent(id: string, updateMetadata: IChatAgentMetadata): void;
 }
 export declare const IChatAgentNameService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatAgentNameService>;

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

@@ -1,5 +1,5 @@
 import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
-import { ChatAgentLocation } from "./chatAgents.js";
+import { ChatAgentLocation, ChatMode } from "./constants.js";
 export declare namespace ChatContextKeys {
     const responseVote: RawContextKey<string>;
     const responseDetectedAgentCommand: RawContextKey<boolean>;
@@ -18,7 +18,9 @@ export declare namespace ChatContextKeys {
     const inputHasFocus: RawContextKey<boolean>;
     const inChatInput: RawContextKey<boolean>;
     const inChatSession: RawContextKey<boolean>;
+    const inUnifiedChat: RawContextKey<boolean>;
     const instructionsAttached: RawContextKey<boolean>;
+    const chatMode: RawContextKey<ChatMode>;
     const supported: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     const enabled: RawContextKey<boolean>;
     const panelParticipantRegistered: RawContextKey<boolean>;
@@ -33,9 +35,12 @@ export declare namespace ChatContextKeys {
     const hasFileAttachments: RawContextKey<boolean>;
     const languageModelsAreUserSelectable: RawContextKey<boolean>;
     const Setup: {
-        signedOut: RawContextKey<boolean>;
         hidden: RawContextKey<boolean>;
         installed: RawContextKey<boolean>;
+        fromDialog: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression;
+    };
+    const Entitlement: {
+        signedOut: RawContextKey<boolean>;
         canSignUp: RawContextKey<boolean>;
         limited: RawContextKey<boolean>;
         pro: RawContextKey<boolean>;
@@ -46,8 +51,16 @@ export declare namespace ChatContextKeys {
     const completionsQuotaExceeded: RawContextKey<boolean>;
     const Editing: {
         hasToolsAgent: RawContextKey<boolean>;
-        agentMode: RawContextKey<boolean>;
         agentModeDisallowed: RawContextKey<boolean>;
         hasToolConfirmation: RawContextKey<boolean>;
     };
+    const Tools: {
+        toolsCount: RawContextKey<number>;
+    };
+}
+export declare namespace ChatContextKeyExprs {
+    const unifiedChatEnabled: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression;
+    const inEditsOrUnified: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
+    const inNonUnifiedPanel: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
+    const inEditingMode: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
 }

package/vscode/src/vs/workbench/contrib/chat/common/chatContextKeys.js

@@ -3,6 +3,7 @@ import { localize } from '../../../../nls.js';
 import { RawContextKey, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import { IsWebContext } from '../../../../platform/contextkey/common/contextkeys.js';
 import { RemoteNameContext } from '../../../common/contextkeys.js';
+import { ChatMode, ChatConfiguration, ChatAgentLocation } from './constants.js';
 
 var ChatContextKeys;
 (function (ChatContextKeys) {
@@ -10,79 +11,81 @@ var ChatContextKeys;
         'chatSessionResponseVote',
         '',
         { type: 'string', description: ( localize(
-            4817,
+            4934,
             "When the response has been voted up, is set to 'up'. When voted down, is set to 'down'. Otherwise an empty string."
         )) }
     ));
     ChatContextKeys.responseDetectedAgentCommand = ( new RawContextKey(
         'chatSessionResponseDetectedAgentOrCommand',
         false,
-        { type: 'boolean', description: ( localize(4818, "When the agent or command was automatically detected")) }
+        { type: 'boolean', description: ( localize(4935, "When the agent or command was automatically detected")) }
     ));
     ChatContextKeys.responseSupportsIssueReporting = ( new RawContextKey(
         'chatResponseSupportsIssueReporting',
         false,
-        { type: 'boolean', description: ( localize(4819, "True when the current chat response supports issue reporting.")) }
+        { type: 'boolean', description: ( localize(4936, "True when the current chat response supports issue reporting.")) }
     ));
     ChatContextKeys.responseIsFiltered = ( new RawContextKey(
         'chatSessionResponseFiltered',
         false,
-        { type: 'boolean', description: ( localize(4820, "True when the chat response was filtered out by the server.")) }
+        { type: 'boolean', description: ( localize(4937, "True when the chat response was filtered out by the server.")) }
     ));
     ChatContextKeys.responseHasError = ( new RawContextKey(
         'chatSessionResponseError',
         false,
-        { type: 'boolean', description: ( localize(4821, "True when the chat response resulted in an error.")) }
+        { type: 'boolean', description: ( localize(4938, "True when the chat response resulted in an error.")) }
     ));
     ChatContextKeys.requestInProgress = ( new RawContextKey(
         'chatSessionRequestInProgress',
         false,
-        { type: 'boolean', description: ( localize(4822, "True when the current request is still in progress.")) }
+        { type: 'boolean', description: ( localize(4939, "True when the current request is still in progress.")) }
     ));
     ChatContextKeys.isRequestPaused = ( new RawContextKey(
         'chatRequestIsPaused',
         false,
-        { type: 'boolean', description: ( localize(4823, "True when the current request is paused.")) }
+        { type: 'boolean', description: ( localize(4940, "True when the current request is paused.")) }
     ));
     ChatContextKeys.canRequestBePaused = ( new RawContextKey(
         'chatCanRequestBePaused',
         false,
-        { type: 'boolean', description: ( localize(4824, "True when the current request can be paused.")) }
-    ));
-    ChatContextKeys.isResponse = ( new RawContextKey('chatResponse', false, { type: 'boolean', description: ( localize(4825, "The chat item is a response.")) }));
-    ChatContextKeys.isRequest = ( new RawContextKey('chatRequest', false, { type: 'boolean', description: ( localize(4826, "The chat item is a request")) }));
-    ChatContextKeys.itemId = ( new RawContextKey('chatItemId', '', { type: 'string', description: ( localize(4827, "The id of the chat item.")) }));
-    ChatContextKeys.lastItemId = ( new RawContextKey('chatLastItemId', [], { type: 'string', description: ( localize(4828, "The id of the last chat item.")) }));
-    ChatContextKeys.editApplied = ( new RawContextKey('chatEditApplied', false, { type: 'boolean', description: ( localize(4829, "True when the chat text edits have been applied.")) }));
-    ChatContextKeys.inputHasText = ( new RawContextKey('chatInputHasText', false, { type: 'boolean', description: ( localize(4830, "True when the chat input has text.")) }));
-    ChatContextKeys.inputHasFocus = ( new RawContextKey('chatInputHasFocus', false, { type: 'boolean', description: ( localize(4831, "True when the chat input has focus.")) }));
-    ChatContextKeys.inChatInput = ( new RawContextKey('inChatInput', false, { type: 'boolean', description: ( localize(4832, "True when focus is in the chat input, false otherwise.")) }));
-    ChatContextKeys.inChatSession = ( new RawContextKey('inChat', false, { type: 'boolean', description: ( localize(4833, "True when focus is in the chat widget, false otherwise.")) }));
+        { type: 'boolean', description: ( localize(4941, "True when the current request can be paused.")) }
+    ));
+    ChatContextKeys.isResponse = ( new RawContextKey('chatResponse', false, { type: 'boolean', description: ( localize(4942, "The chat item is a response.")) }));
+    ChatContextKeys.isRequest = ( new RawContextKey('chatRequest', false, { type: 'boolean', description: ( localize(4943, "The chat item is a request")) }));
+    ChatContextKeys.itemId = ( new RawContextKey('chatItemId', '', { type: 'string', description: ( localize(4944, "The id of the chat item.")) }));
+    ChatContextKeys.lastItemId = ( new RawContextKey('chatLastItemId', [], { type: 'string', description: ( localize(4945, "The id of the last chat item.")) }));
+    ChatContextKeys.editApplied = ( new RawContextKey('chatEditApplied', false, { type: 'boolean', description: ( localize(4946, "True when the chat text edits have been applied.")) }));
+    ChatContextKeys.inputHasText = ( new RawContextKey('chatInputHasText', false, { type: 'boolean', description: ( localize(4947, "True when the chat input has text.")) }));
+    ChatContextKeys.inputHasFocus = ( new RawContextKey('chatInputHasFocus', false, { type: 'boolean', description: ( localize(4948, "True when the chat input has focus.")) }));
+    ChatContextKeys.inChatInput = ( new RawContextKey('inChatInput', false, { type: 'boolean', description: ( localize(4949, "True when focus is in the chat input, false otherwise.")) }));
+    ChatContextKeys.inChatSession = ( new RawContextKey('inChat', false, { type: 'boolean', description: ( localize(4950, "True when focus is in the chat widget, false otherwise.")) }));
+    ChatContextKeys.inUnifiedChat = ( new RawContextKey('inUnifiedChat', false, { type: 'boolean', description: ( localize(4951, "True when focus is in the unified chat widget, false otherwise.")) }));
     ChatContextKeys.instructionsAttached = ( new RawContextKey(
         'chatInstructionsAttached',
         false,
-        { type: 'boolean', description: ( localize(4834, "True when the chat has a prompt instructions attached.")) }
+        { type: 'boolean', description: ( localize(4952, "True when the chat has a prompt instructions attached.")) }
     ));
+    ChatContextKeys.chatMode = ( new RawContextKey('chatMode', ChatMode.Ask, { type: 'string', description: ( localize(4953, "The current chat mode.")) }));
     ChatContextKeys.supported = ( ContextKeyExpr.or(( IsWebContext.toNegated()), ( RemoteNameContext.notEqualsTo(''))));
     ChatContextKeys.enabled = ( new RawContextKey('chatIsEnabled', false, { type: 'boolean', description: ( localize(
-        4835,
+        4954,
         "True when chat is enabled because a default chat participant is activated with an implementation."
     )) }));
     ChatContextKeys.panelParticipantRegistered = ( new RawContextKey(
         'chatPanelParticipantRegistered',
         false,
-        { type: 'boolean', description: ( localize(4836, "True when a default chat participant is registered for the panel.")) }
+        { type: 'boolean', description: ( localize(4955, "True when a default chat participant is registered for the panel.")) }
     ));
     ChatContextKeys.editingParticipantRegistered = ( new RawContextKey(
         'chatEditingParticipantRegistered',
         false,
-        { type: 'boolean', description: ( localize(4837, "True when a default chat participant is registered for editing.")) }
+        { type: 'boolean', description: ( localize(4956, "True when a default chat participant is registered for editing.")) }
     ));
     ChatContextKeys.chatEditingCanUndo = ( new RawContextKey(
         'chatEditingCanUndo',
         false,
         { type: 'boolean', description: ( localize(
-            4838,
+            4957,
             "True when it is possible to undo an interaction in the editing panel."
         )) }
     ));
@@ -90,7 +93,7 @@ var ChatContextKeys;
         'chatEditingCanRedo',
         false,
         { type: 'boolean', description: ( localize(
-            4839,
+            4958,
             "True when it is possible to redo an interaction in the editing panel."
         )) }
     ));
@@ -98,52 +101,64 @@ var ChatContextKeys;
         'chatExtensionInvalid',
         false,
         { type: 'boolean', description: ( localize(
-            4840,
+            4959,
             "True when the installed chat extension is invalid and needs to be updated."
         )) }
     ));
     ChatContextKeys.inputCursorAtTop = ( new RawContextKey('chatCursorAtTop', false));
     ChatContextKeys.inputHasAgent = ( new RawContextKey('chatInputHasAgent', false));
     ChatContextKeys.location = ( new RawContextKey('chatLocation', undefined));
-    ChatContextKeys.inQuickChat = ( new RawContextKey('quickChatHasFocus', false, { type: 'boolean', description: ( localize(4841, "True when the quick chat UI has focus, false otherwise.")) }));
+    ChatContextKeys.inQuickChat = ( new RawContextKey('quickChatHasFocus', false, { type: 'boolean', description: ( localize(4960, "True when the quick chat UI has focus, false otherwise.")) }));
     ChatContextKeys.hasFileAttachments = ( new RawContextKey(
         'chatHasFileAttachments',
         false,
-        { type: 'boolean', description: ( localize(4842, "True when the chat has file attachments.")) }
+        { type: 'boolean', description: ( localize(4961, "True when the chat has file attachments.")) }
     ));
     ChatContextKeys.languageModelsAreUserSelectable = ( new RawContextKey(
         'chatModelsAreUserSelectable',
         false,
-        { type: 'boolean', description: ( localize(4843, "True when the chat model can be selected manually by the user.")) }
+        { type: 'boolean', description: ( localize(4962, "True when the chat model can be selected manually by the user.")) }
     ));
     ChatContextKeys.Setup = {
-        signedOut: ( new RawContextKey('chatSetupSignedOut', false, true)),
         hidden: ( new RawContextKey('chatSetupHidden', false, true)),
         installed: ( new RawContextKey('chatSetupInstalled', false, true)),
+        fromDialog: ( ContextKeyExpr.has('config.chat.setupFromDialog')),
+    };
+    ChatContextKeys.Entitlement = {
+        signedOut: ( new RawContextKey('chatSetupSignedOut', false, true)),
         canSignUp: ( new RawContextKey('chatPlanCanSignUp', false, true)),
         limited: ( new RawContextKey('chatPlanLimited', false, true)),
         pro: ( new RawContextKey('chatPlanPro', false, true))
     };
     ChatContextKeys.SetupViewKeys = ( new Set(
-        [ChatContextKeys.Setup.hidden.key, ChatContextKeys.Setup.installed.key, ChatContextKeys.Setup.signedOut.key, ChatContextKeys.Setup.canSignUp.key]
+        [ChatContextKeys.Setup.hidden.key, ChatContextKeys.Setup.installed.key, ChatContextKeys.Entitlement.signedOut.key, ChatContextKeys.Entitlement.canSignUp.key, ...( ChatContextKeys.Setup.fromDialog.keys())]
     ));
-    ChatContextKeys.SetupViewCondition = ( ContextKeyExpr.or(( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ChatContextKeys.Setup.installed.negate()))), ( ContextKeyExpr.and(ChatContextKeys.Setup.canSignUp, ChatContextKeys.Setup.installed)), ( ContextKeyExpr.and(ChatContextKeys.Setup.signedOut, ChatContextKeys.Setup.installed))));
+    ChatContextKeys.SetupViewCondition = ( ContextKeyExpr.and(( ChatContextKeys.Setup.fromDialog.negate()), ( ContextKeyExpr.or(( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ChatContextKeys.Setup.installed.negate()))), ( ContextKeyExpr.and(ChatContextKeys.Entitlement.canSignUp, ChatContextKeys.Setup.installed)), ( ContextKeyExpr.and(ChatContextKeys.Entitlement.signedOut, ChatContextKeys.Setup.installed))))));
     ChatContextKeys.chatQuotaExceeded = ( new RawContextKey('chatQuotaExceeded', false, true));
     ChatContextKeys.completionsQuotaExceeded = ( new RawContextKey('completionsQuotaExceeded', false, true));
     ChatContextKeys.Editing = {
-        hasToolsAgent: ( new RawContextKey('chatHasToolsAgent', false, { type: 'boolean', description: ( localize(4844, "True when a tools agent is registered.")) })),
-        agentMode: ( new RawContextKey('chatAgentMode', false, { type: 'boolean', description: ( localize(4845, "True when edits is in agent mode.")) })),
+        hasToolsAgent: ( new RawContextKey('chatHasToolsAgent', false, { type: 'boolean', description: ( localize(4963, "True when a tools agent is registered.")) })),
         agentModeDisallowed: ( new RawContextKey(
             'chatAgentModeDisallowed',
             undefined,
-            { type: 'boolean', description: ( localize(4846, "True when agent mode is not allowed.")) }
+            { type: 'boolean', description: ( localize(4964, "True when agent mode is not allowed.")) }
         )),
         hasToolConfirmation: ( new RawContextKey(
             'chatHasToolConfirmation',
             false,
-            { type: 'boolean', description: ( localize(4847, "True when a tool confirmation is present.")) }
+            { type: 'boolean', description: ( localize(4965, "True when a tool confirmation is present.")) }
         )),
     };
+    ChatContextKeys.Tools = {
+        toolsCount: ( new RawContextKey('toolsCount', 0, { type: 'number', description: ( localize(4966, "The count of tools available in the chat.")) }))
+    };
 })(ChatContextKeys || (ChatContextKeys = {}));
+var ChatContextKeyExprs;
+(function (ChatContextKeyExprs) {
+    ChatContextKeyExprs.unifiedChatEnabled = ( ContextKeyExpr.has(`config.${ChatConfiguration.UnifiedChatView}`));
+    ChatContextKeyExprs.inEditsOrUnified = ( ContextKeyExpr.or(( ChatContextKeys.location.isEqualTo(ChatAgentLocation.EditingSession)), ChatContextKeys.inUnifiedChat));
+    ChatContextKeyExprs.inNonUnifiedPanel = ( ContextKeyExpr.and(( ChatContextKeys.location.isEqualTo(ChatAgentLocation.Panel)), ( ChatContextKeys.inUnifiedChat.negate())));
+    ChatContextKeyExprs.inEditingMode = ( ContextKeyExpr.or(( ChatContextKeys.chatMode.isEqualTo(ChatMode.Edit)), ( ChatContextKeys.chatMode.isEqualTo(ChatMode.Agent))));
+})(ChatContextKeyExprs || (ChatContextKeyExprs = {}));
 
-export { ChatContextKeys };
+export { ChatContextKeyExprs, ChatContextKeys };

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

@@ -1,7 +1,6 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
-import { ResourceMap } from "../../../../base/common/map.js";
 import { IObservable, IReader, ITransaction } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
 import { TextEdit } from "../../../../editor/common/languages.js";
@@ -27,7 +26,6 @@ export interface IChatRelatedFilesProvider {
 export interface WorkingSetDisplayMetadata {
     state: WorkingSetEntryState;
     description?: string;
-    isMarkedReadonly?: boolean;
 }
 export interface IStreamingEdits {
     pushText(edits: TextEdit[]): void;
@@ -43,11 +41,8 @@ export interface IChatEditingSession extends IDisposable {
     readonly onDidDispose: Event<void>;
     readonly state: IObservable<ChatEditingSessionState>;
     readonly entries: IObservable<readonly IModifiedFileEntry[]>;
-    readonly workingSet: ResourceMap<WorkingSetDisplayMetadata>;
-    addFileToWorkingSet(uri: URI, description?: string, kind?: WorkingSetEntryState.Suggested): void;
     show(): Promise<void>;
     remove(reason: WorkingSetEntryRemovalReason, ...uris: URI[]): void;
-    markIsReadonly(uri: URI, isReadonly?: boolean): void;
     accept(...uris: URI[]): Promise<void>;
     reject(...uris: URI[]): Promise<void>;
     getEntry(uri: URI): IModifiedFileEntry | undefined;
@@ -80,8 +75,7 @@ export declare enum WorkingSetEntryState {
     Rejected = 2,
     Transient = 3,
     Attached = 4,
-    Sent = 5,
-    Suggested = 6
+    Sent = 5
 }
 export declare enum ChatEditingSessionChangeType {
     WorkingSet = 0,
@@ -133,7 +127,6 @@ export declare enum ChatEditingSessionState {
 }
 export declare const CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME = "chat-editing-multi-diff-source";
 export declare const chatEditingWidgetFileStateContextKey: RawContextKey<WorkingSetEntryState>;
-export declare const chatEditingWidgetFileReadonlyContextKey: RawContextKey<boolean>;
 export declare const chatEditingAgentSupportsReadonlyReferencesContextKey: RawContextKey<boolean>;
 export declare const decidedChatEditingResourceContextKey: RawContextKey<string[]>;
 export declare const chatEditingResourceContextKey: RawContextKey<string | undefined>;

package/vscode/src/vs/workbench/contrib/chat/common/chatEditingService.js

@@ -17,7 +17,6 @@ var WorkingSetEntryState;
     WorkingSetEntryState[WorkingSetEntryState["Transient"] = 3] = "Transient";
     WorkingSetEntryState[WorkingSetEntryState["Attached"] = 4] = "Attached";
     WorkingSetEntryState[WorkingSetEntryState["Sent"] = 5] = "Sent";
-    WorkingSetEntryState[WorkingSetEntryState["Suggested"] = 6] = "Suggested";
 })(WorkingSetEntryState || (WorkingSetEntryState = {}));
 var ChatEditingSessionChangeType;
 (function (ChatEditingSessionChangeType) {
@@ -32,13 +31,9 @@ var ChatEditingSessionState;
     ChatEditingSessionState[ChatEditingSessionState["Disposed"] = 3] = "Disposed";
 })(ChatEditingSessionState || (ChatEditingSessionState = {}));
 const CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME = 'chat-editing-multi-diff-source';
-const chatEditingWidgetFileStateContextKey = ( new RawContextKey('chatEditingWidgetFileState', undefined, ( localize(4848, "The current state of the file in the chat editing widget"))));
-const chatEditingWidgetFileReadonlyContextKey = ( new RawContextKey('chatEditingWidgetFileReadonly', undefined, ( localize(
-    4849,
-    "Whether the file has been marked as read-only in the chat editing widget"
-))));
+const chatEditingWidgetFileStateContextKey = ( new RawContextKey('chatEditingWidgetFileState', undefined, ( localize(4967, "The current state of the file in the chat editing widget"))));
 const chatEditingAgentSupportsReadonlyReferencesContextKey = ( new RawContextKey('chatEditingAgentSupportsReadonlyReferences', undefined, ( localize(
-    4850,
+    4968,
     "Whether the chat editing agent supports readonly references (temporary)"
 ))));
 const decidedChatEditingResourceContextKey = ( new RawContextKey('decidedChatEditingResource', []));
@@ -62,4 +57,4 @@ function getMultiDiffSourceUri(session) {
     }));
 }
 
-export { CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, ChatEditKind, ChatEditingSessionChangeType, ChatEditingSessionState, WorkingSetEntryRemovalReason, WorkingSetEntryState, applyingChatEditsFailedContextKey, chatEditingAgentSupportsReadonlyReferencesContextKey, chatEditingResourceContextKey, chatEditingSnapshotScheme, chatEditingWidgetFileReadonlyContextKey, chatEditingWidgetFileStateContextKey, decidedChatEditingResourceContextKey, getMultiDiffSourceUri, hasAppliedChatEditsContextKey, hasUndecidedChatEditingResourceContextKey, inChatEditingSessionContextKey, isChatEditingActionContext };
+export { CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, ChatEditKind, ChatEditingSessionChangeType, ChatEditingSessionState, WorkingSetEntryRemovalReason, WorkingSetEntryState, applyingChatEditsFailedContextKey, chatEditingAgentSupportsReadonlyReferencesContextKey, chatEditingResourceContextKey, chatEditingSnapshotScheme, chatEditingWidgetFileStateContextKey, decidedChatEditingResourceContextKey, getMultiDiffSourceUri, hasAppliedChatEditsContextKey, hasUndecidedChatEditingResourceContextKey, inChatEditingSessionContextKey, isChatEditingActionContext };

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

@@ -3,13 +3,14 @@ import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IChatEditingSession, IChatRelatedFilesProvider, IChatRelatedFile } from "./chatEditingService.js";
+import { ChatModel } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 export declare const IChatEditingService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatEditingService>;
 export interface IChatEditingService {
     _serviceBrand: undefined;
-    startOrContinueGlobalEditingSession(chatSessionId: string): Promise<IChatEditingSession>;
+    startOrContinueGlobalEditingSession(chatModel: ChatModel): Promise<IChatEditingSession>;
     getEditingSession(chatSessionId: string): IChatEditingSession | undefined;
     readonly editingSessionsObs: IObservable<readonly IChatEditingSession[]>;
-    createEditingSession(chatSessionId: string): Promise<IChatEditingSession>;
+    createEditingSession(chatModel: ChatModel): Promise<IChatEditingSession>;
     hasRelatedFilesProviders(): boolean;
     registerRelatedFilesProvider(handle: number, provider: IChatRelatedFilesProvider): IDisposable;
     getRelatedFiles(chatSessionId: string, prompt: string, files: URI[], token: CancellationToken): Promise<{

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

@@ -0,0 +1,15 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { Event } from "../../../../base/common/event.js";
+import { ChatEntitlement, IChatQuotas, ChatSentiment } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatEntitlementService";
+export declare const IChatEntitlementService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatEntitlementService>;
+export interface IChatEntitlementService {
+    _serviceBrand: undefined;
+    readonly onDidChangeEntitlement: Event<void>;
+    readonly entitlement: ChatEntitlement;
+    readonly onDidChangeQuotaExceeded: Event<void>;
+    readonly onDidChangeQuotaRemaining: Event<void>;
+    readonly quotas: IChatQuotas;
+    update(token: CancellationToken): Promise<void>;
+    readonly onDidChangeSentiment: Event<void>;
+    readonly sentiment: ChatSentiment;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatEntitlementService.service.js

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