@codingame/monaco-vscode-api 23.3.0 → 24.1.0

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

@@ -12,114 +12,114 @@ var ChatContextKeys;
         'chatSessionResponseVote',
         '',
         { type: 'string', description: ( localize(
-            5766,
+            5876,
             "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(5767, "When the agent or command was automatically detected")) }
+        { type: 'boolean', description: ( localize(5877, "When the agent or command was automatically detected")) }
     ));
     ChatContextKeys.responseSupportsIssueReporting = ( new RawContextKey(
         'chatResponseSupportsIssueReporting',
         false,
-        { type: 'boolean', description: ( localize(5768, "True when the current chat response supports issue reporting.")) }
+        { type: 'boolean', description: ( localize(5878, "True when the current chat response supports issue reporting.")) }
     ));
     ChatContextKeys.responseIsFiltered = ( new RawContextKey(
         'chatSessionResponseFiltered',
         false,
-        { type: 'boolean', description: ( localize(5769, "True when the chat response was filtered out by the server.")) }
+        { type: 'boolean', description: ( localize(5879, "True when the chat response was filtered out by the server.")) }
     ));
     ChatContextKeys.responseHasError = ( new RawContextKey(
         'chatSessionResponseError',
         false,
-        { type: 'boolean', description: ( localize(5770, "True when the chat response resulted in an error.")) }
+        { type: 'boolean', description: ( localize(5880, "True when the chat response resulted in an error.")) }
     ));
     ChatContextKeys.requestInProgress = ( new RawContextKey(
         'chatSessionRequestInProgress',
         false,
-        { type: 'boolean', description: ( localize(5771, "True when the current request is still in progress.")) }
+        { type: 'boolean', description: ( localize(5881, "True when the current request is still in progress.")) }
     ));
     ChatContextKeys.currentlyEditing = ( new RawContextKey(
         'chatSessionCurrentlyEditing',
         false,
-        { type: 'boolean', description: ( localize(5772, "True when the current request is being edited.")) }
+        { type: 'boolean', description: ( localize(5882, "True when the current request is being edited.")) }
     ));
     ChatContextKeys.currentlyEditingInput = ( new RawContextKey(
         'chatSessionCurrentlyEditingInput',
         false,
-        { type: 'boolean', description: ( localize(5773, "True when the current request input at the bottom is being edited.")) }
+        { type: 'boolean', description: ( localize(5883, "True when the current request input at the bottom is being edited.")) }
     ));
-    ChatContextKeys.isResponse = ( new RawContextKey('chatResponse', false, { type: 'boolean', description: ( localize(5774, "The chat item is a response.")) }));
-    ChatContextKeys.isRequest = ( new RawContextKey('chatRequest', false, { type: 'boolean', description: ( localize(5775, "The chat item is a request")) }));
-    ChatContextKeys.itemId = ( new RawContextKey('chatItemId', '', { type: 'string', description: ( localize(5776, "The id of the chat item.")) }));
-    ChatContextKeys.lastItemId = ( new RawContextKey('chatLastItemId', [], { type: 'string', description: ( localize(5777, "The id of the last chat item.")) }));
-    ChatContextKeys.editApplied = ( new RawContextKey('chatEditApplied', false, { type: 'boolean', description: ( localize(5778, "True when the chat text edits have been applied.")) }));
-    ChatContextKeys.inputHasText = ( new RawContextKey('chatInputHasText', false, { type: 'boolean', description: ( localize(5779, "True when the chat input has text.")) }));
-    ChatContextKeys.inputHasFocus = ( new RawContextKey('chatInputHasFocus', false, { type: 'boolean', description: ( localize(5780, "True when the chat input has focus.")) }));
-    ChatContextKeys.inChatInput = ( new RawContextKey('inChatInput', false, { type: 'boolean', description: ( localize(5781, "True when focus is in the chat input, false otherwise.")) }));
-    ChatContextKeys.inChatSession = ( new RawContextKey('inChat', false, { type: 'boolean', description: ( localize(5782, "True when focus is in the chat widget, false otherwise.")) }));
-    ChatContextKeys.inChatEditor = ( new RawContextKey('inChatEditor', false, { type: 'boolean', description: ( localize(5783, "Whether focus is in a chat editor.")) }));
-    ChatContextKeys.hasPromptFile = ( new RawContextKey(
-        'chatPromptFileAttached',
+    ChatContextKeys.isResponse = ( new RawContextKey('chatResponse', false, { type: 'boolean', description: ( localize(5884, "The chat item is a response.")) }));
+    ChatContextKeys.isRequest = ( new RawContextKey('chatRequest', false, { type: 'boolean', description: ( localize(5885, "The chat item is a request")) }));
+    ChatContextKeys.itemId = ( new RawContextKey('chatItemId', '', { type: 'string', description: ( localize(5886, "The id of the chat item.")) }));
+    ChatContextKeys.lastItemId = ( new RawContextKey('chatLastItemId', [], { type: 'string', description: ( localize(5887, "The id of the last chat item.")) }));
+    ChatContextKeys.editApplied = ( new RawContextKey('chatEditApplied', false, { type: 'boolean', description: ( localize(5888, "True when the chat text edits have been applied.")) }));
+    ChatContextKeys.inputHasText = ( new RawContextKey('chatInputHasText', false, { type: 'boolean', description: ( localize(5889, "True when the chat input has text.")) }));
+    ChatContextKeys.inputHasFocus = ( new RawContextKey('chatInputHasFocus', false, { type: 'boolean', description: ( localize(5890, "True when the chat input has focus.")) }));
+    ChatContextKeys.inChatInput = ( new RawContextKey('inChatInput', false, { type: 'boolean', description: ( localize(5891, "True when focus is in the chat input, false otherwise.")) }));
+    ChatContextKeys.inChatSession = ( new RawContextKey('inChat', false, { type: 'boolean', description: ( localize(5892, "True when focus is in the chat widget, false otherwise.")) }));
+    ChatContextKeys.inChatEditor = ( new RawContextKey('inChatEditor', false, { type: 'boolean', description: ( localize(5893, "Whether focus is in a chat editor.")) }));
+    ChatContextKeys.inChatTerminalToolOutput = ( new RawContextKey(
+        'inChatTerminalToolOutput',
         false,
-        { type: 'boolean', description: ( localize(5784, "True when the chat has a prompt file attached.")) }
+        { type: 'boolean', description: ( localize(5894, "True when focus is in the chat terminal output region.")) }
     ));
     ChatContextKeys.chatModeKind = ( new RawContextKey(
         'chatAgentKind',
         ChatModeKind.Ask,
-        { type: 'string', description: ( localize(5785, "The 'kind' of the current agent.")) }
+        { type: 'string', description: ( localize(5895, "The 'kind' of the current agent.")) }
     ));
-    ChatContextKeys.chatToolCount = ( new RawContextKey('chatToolCount', 0, { type: 'number', description: ( localize(5786, "The number of tools available in the current agent.")) }));
+    ChatContextKeys.chatToolCount = ( new RawContextKey('chatToolCount', 0, { type: 'number', description: ( localize(5896, "The number of tools available in the current agent.")) }));
     ChatContextKeys.chatToolGroupingThreshold = ( new RawContextKey(
         'chat.toolGroupingThreshold',
         0,
-        { type: 'number', description: ( localize(5787, "The number of tools at which we start doing virtual grouping.")) }
+        { type: 'number', description: ( localize(5897, "The number of tools at which we start doing virtual grouping.")) }
     ));
     ChatContextKeys.supported = ( ContextKeyExpr.or(( IsWebContext.negate()), ( RemoteNameContext.notEqualsTo('')), ( ContextKeyExpr.has('config.chat.experimental.serverlessWebEnabled'))));
     ChatContextKeys.enabled = ( new RawContextKey('chatIsEnabled', false, { type: 'boolean', description: ( localize(
-        5788,
+        5898,
         "True when chat is enabled because a default chat participant is activated with an implementation."
     )) }));
     ChatContextKeys.lockedToCodingAgent = ( new RawContextKey(
         'lockedToCodingAgent',
         false,
-        { type: 'boolean', description: ( localize(5789, "True when the chat widget is locked to the coding agent session.")) }
+        { type: 'boolean', description: ( localize(5899, "True when the chat widget is locked to the coding agent session.")) }
     ));
     ChatContextKeys.agentSupportsAttachments = ( new RawContextKey(
         'agentSupportsAttachments',
         false,
-        { type: 'boolean', description: ( localize(5790, "True when the chat agent supports attachments.")) }
+        { type: 'boolean', description: ( localize(5900, "True when the chat agent supports attachments.")) }
     ));
     ChatContextKeys.withinEditSessionDiff = ( new RawContextKey(
         'withinEditSessionDiff',
         false,
-        { type: 'boolean', description: ( localize(5791, "True when the chat widget dispatches to the edit session chat.")) }
+        { type: 'boolean', description: ( localize(5901, "True when the chat widget dispatches to the edit session chat.")) }
     ));
     ChatContextKeys.filePartOfEditSession = ( new RawContextKey(
         'filePartOfEditSession',
         false,
-        { type: 'boolean', description: ( localize(5792, "True when the chat widget is within a file with an edit session.")) }
+        { type: 'boolean', description: ( localize(5902, "True when the chat widget is within a file with an edit session.")) }
     ));
     ChatContextKeys.extensionParticipantRegistered = ( new RawContextKey(
         'chatPanelExtensionParticipantRegistered',
         false,
         { type: 'boolean', description: ( localize(
-            5793,
+            5903,
             "True when a default chat participant is registered for the panel from an extension."
         )) }
     ));
     ChatContextKeys.panelParticipantRegistered = ( new RawContextKey(
         'chatPanelParticipantRegistered',
         false,
-        { type: 'boolean', description: ( localize(5794, "True when a default chat participant is registered for the panel.")) }
+        { type: 'boolean', description: ( localize(5904, "True when a default chat participant is registered for the panel.")) }
     ));
     ChatContextKeys.chatEditingCanUndo = ( new RawContextKey(
         'chatEditingCanUndo',
         false,
         { type: 'boolean', description: ( localize(
-            5795,
+            5905,
             "True when it is possible to undo an interaction in the editing panel."
         )) }
     ));
@@ -127,20 +127,20 @@ var ChatContextKeys;
         'chatEditingCanRedo',
         false,
         { type: 'boolean', description: ( localize(
-            5796,
+            5906,
             "True when it is possible to redo an interaction in the editing panel."
         )) }
     ));
     ChatContextKeys.languageModelsAreUserSelectable = ( new RawContextKey(
         'chatModelsAreUserSelectable',
         false,
-        { type: 'boolean', description: ( localize(5797, "True when the chat model can be selected manually by the user.")) }
+        { type: 'boolean', description: ( localize(5907, "True when the chat model can be selected manually by the user.")) }
     ));
     ChatContextKeys.chatSessionHasModels = ( new RawContextKey(
         'chatSessionHasModels',
         false,
         { type: 'boolean', description: ( localize(
-            5798,
+            5908,
             "True when the chat is in a contributed chat session that has available 'models' to display."
         )) }
     ));
@@ -148,34 +148,34 @@ var ChatContextKeys;
         'chatExtensionInvalid',
         false,
         { type: 'boolean', description: ( localize(
-            5799,
+            5909,
             "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(5800, "True when the quick chat UI has focus, false otherwise.")) }));
+    ChatContextKeys.inQuickChat = ( new RawContextKey('quickChatHasFocus', false, { type: 'boolean', description: ( localize(5910, "True when the quick chat UI has focus, false otherwise.")) }));
     ChatContextKeys.hasFileAttachments = ( new RawContextKey(
         'chatHasFileAttachments',
         false,
-        { type: 'boolean', description: ( localize(5801, "True when the chat has file attachments.")) }
+        { type: 'boolean', description: ( localize(5911, "True when the chat has file attachments.")) }
     ));
+    ChatContextKeys.chatSessionIsEmpty = ( new RawContextKey('chatSessionIsEmpty', true, { type: 'boolean', description: ( localize(5912, "True when the current chat session has no requests.")) }));
     ChatContextKeys.remoteJobCreating = ( new RawContextKey(
         'chatRemoteJobCreating',
         false,
-        { type: 'boolean', description: ( localize(5802, "True when a remote coding agent job is being created.")) }
+        { type: 'boolean', description: ( localize(5913, "True when a remote coding agent job is being created.")) }
     ));
-    ChatContextKeys.hasRemoteCodingAgent = ( new RawContextKey('hasRemoteCodingAgent', false, ( localize(5803, "Whether any remote coding agent is available"))));
-    ChatContextKeys.hasCloudButtonV2 = ( ContextKeyExpr.has('config.chat.useCloudButtonV2'));
+    ChatContextKeys.hasRemoteCodingAgent = ( new RawContextKey('hasRemoteCodingAgent', false, ( localize(5914, "Whether any remote coding agent is available"))));
     ChatContextKeys.enableRemoteCodingAgentPromptFileOverlay = ( new RawContextKey('enableRemoteCodingAgentPromptFileOverlay', false, ( localize(
-        5804,
+        5915,
         "Whether the remote coding agent prompt file overlay feature is enabled"
     ))));
     ChatContextKeys.skipChatRequestInProgressMessage = ( new RawContextKey(
         'chatSkipRequestInProgressMessage',
         false,
-        { type: 'boolean', description: ( localize(5805, "True when the chat request in progress message should be skipped.")) }
+        { type: 'boolean', description: ( localize(5916, "True when the chat request in progress message should be skipped.")) }
     ));
     ChatContextKeys.Setup = ChatEntitlementContextKeys.Setup;
     ChatContextKeys.Entitlement = ChatEntitlementContextKeys.Entitlement;
@@ -185,43 +185,82 @@ var ChatContextKeys;
         hasToolConfirmation: ( new RawContextKey(
             'chatHasToolConfirmation',
             false,
-            { type: 'boolean', description: ( localize(5806, "True when a tool confirmation is present.")) }
+            { type: 'boolean', description: ( localize(5917, "True when a tool confirmation is present.")) }
+        )),
+        hasElicitationRequest: ( new RawContextKey(
+            'chatHasElicitationRequest',
+            false,
+            { type: 'boolean', description: ( localize(5918, "True when a chat elicitation request is pending.")) }
         )),
     };
     ChatContextKeys.Tools = {
-        toolsCount: ( new RawContextKey('toolsCount', 0, { type: 'number', description: ( localize(5807, "The count of tools available in the chat.")) }))
+        toolsCount: ( new RawContextKey('toolsCount', 0, { type: 'number', description: ( localize(5919, "The count of tools available in the chat.")) }))
     };
     ChatContextKeys.Modes = {
         hasCustomChatModes: ( new RawContextKey(
             'chatHasCustomAgents',
             false,
-            { type: 'boolean', description: ( localize(5808, "True when the chat has custom agents available.")) }
+            { type: 'boolean', description: ( localize(5920, "True when the chat has custom agents available.")) }
+        )),
+        agentModeDisabledByPolicy: ( new RawContextKey(
+            'chatAgentModeDisabledByPolicy',
+            false,
+            { type: 'boolean', description: ( localize(5921, "True when agent mode is disabled by organization policy.")) }
         )),
     };
     ChatContextKeys.panelLocation = ( new RawContextKey(
         'chatPanelLocation',
         undefined,
-        { type: 'number', description: ( localize(5809, "The location of the chat panel.")) }
+        { type: 'number', description: ( localize(5922, "The location of the chat panel.")) }
     ));
-    ChatContextKeys.inEmptyStateWithHistoryEnabled = ( new RawContextKey(
-        'chatInEmptyStateWithHistoryEnabled',
+    ChatContextKeys.isCombinedAgentSessionsViewer = ( new RawContextKey(
+        'chatIsCombinedSessionViewer',
         false,
+        { type: 'boolean', description: ( localize(5923, "True when the chat session viewer uses the new combined style.")) }
+    ));
+    ChatContextKeys.agentSessionsViewerLimited = ( new RawContextKey(
+        'agentSessionsViewerLimited',
+        undefined,
         { type: 'boolean', description: ( localize(
-            5810,
-            "True when chat empty state history is enabled AND chat is in empty state."
+            5924,
+            "If the agent sessions view in the chat view is limited to show recent sessions only."
         )) }
     ));
-    ChatContextKeys.sessionType = ( new RawContextKey('chatSessionType', '', { type: 'string', description: ( localize(5811, "The type of the current chat session item.")) }));
-    ChatContextKeys.isHistoryItem = ( new RawContextKey('chatIsHistoryItem', false, { type: 'boolean', description: ( localize(5812, "True when the chat session item is from history.")) }));
-    ChatContextKeys.isActiveSession = ( new RawContextKey(
-        'chatIsActiveSession',
+    ChatContextKeys.agentSessionsViewerOrientation = ( new RawContextKey(
+        'agentSessionsViewerOrientation',
+        undefined,
+        { type: 'number', description: ( localize(5925, "Orientation of the agent sessions view in the chat view.")) }
+    ));
+    ChatContextKeys.agentSessionsViewerPosition = ( new RawContextKey(
+        'agentSessionsViewerPosition',
+        undefined,
+        { type: 'number', description: ( localize(5926, "Position of the agent sessions view in the chat view.")) }
+    ));
+    ChatContextKeys.agentSessionType = ( new RawContextKey('chatSessionType', '', { type: 'string', description: ( localize(5927, "The type of the current agent session item.")) }));
+    ChatContextKeys.hasAgentSessionChanges = ( new RawContextKey(
+        'agentSessionHasChanges',
+        false,
+        { type: 'boolean', description: ( localize(5928, "True when the current agent session item has changes.")) }
+    ));
+    ChatContextKeys.isArchivedAgentSession = ( new RawContextKey(
+        'agentSessionIsArchived',
+        false,
+        { type: 'boolean', description: ( localize(5929, "True when the agent session item is archived.")) }
+    ));
+    ChatContextKeys.isReadAgentSession = ( new RawContextKey(
+        'agentSessionIsRead',
+        false,
+        { type: 'boolean', description: ( localize(5930, "True when the agent session item is read.")) }
+    ));
+    ChatContextKeys.isActiveAgentSession = ( new RawContextKey(
+        'agentSessionIsActive',
         false,
-        { type: 'boolean', description: ( localize(5813, "True when the chat session is currently active (not deletable).")) }
+        { type: 'boolean', description: ( localize(5931, "True when the agent session is currently active (not deletable).")) }
     ));
     ChatContextKeys.isKatexMathElement = ( new RawContextKey(
         'chatIsKatexMathElement',
         false,
-        { type: 'boolean', description: ( localize(5814, "True when focusing a KaTeX math element.")) }
+        { type: 'boolean', description: ( localize(5932, "True when focusing a KaTeX math element.")) }
     ));
 })(ChatContextKeys || (ChatContextKeys = {}));
 var ChatContextKeyExprs;

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

@@ -11,9 +11,9 @@ import { EditSuggestionId } from "../../../../editor/common/textModelEditSource.
 import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
 import { IEditorPane } from "../../../common/editor.js";
 import { ICellEditOperation } from "../../notebook/common/notebookCommon.js";
-import { IChatAgentResult } from "@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
-import { IChatResponseModel } from "@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModel";
-import { IChatProgress } from "./chatService.js";
+import { IChatAgentResult } from "./chatAgents.js";
+import { IChatRequestDisablement, IChatResponseModel } from "./chatModel.js";
+import { IChatMultiDiffData, IChatProgress } from "./chatService.js";
 export interface IChatRequestDraft {
     readonly prompt: string;
     readonly files: readonly URI[];
@@ -43,7 +43,7 @@ export interface IStreamingEdits {
 export interface IModifiedEntryTelemetryInfo {
     readonly agentId: string | undefined;
     readonly command: string | undefined;
-    readonly sessionId: string;
+    readonly sessionResource: URI;
     readonly requestId: string;
     readonly result: IChatAgentResult | undefined;
     readonly modelId: string | undefined;
@@ -62,12 +62,12 @@ export interface ISnapshotEntry {
 }
 export interface IChatEditingSession extends IDisposable {
     readonly isGlobalEditingSession: boolean;
-    /** @deprecated */
-    readonly chatSessionId: string;
     readonly chatSessionResource: URI;
     readonly onDidDispose: Event<void>;
     readonly state: IObservable<ChatEditingSessionState>;
     readonly entries: IObservable<readonly IModifiedFileEntry[]>;
+    /** Requests disabled by undo/redo in the session */
+    readonly requestDisablement: IObservable<IChatRequestDisablement[]>;
     show(previousChanges?: boolean): Promise<void>;
     accept(...uris: URI[]): Promise<void>;
     reject(...uris: URI[]): Promise<void>;
@@ -80,7 +80,7 @@ export interface IChatEditingSession extends IDisposable {
      * agents that make changes on-disk rather than streaming edits through the
      * chat session.
      */
-    startExternalEdits(responseModel: IChatResponseModel, operationId: number, resources: URI[]): Promise<IChatProgress[]>;
+    startExternalEdits(responseModel: IChatResponseModel, operationId: number, resources: URI[], undoStopId: string): Promise<IChatProgress[]>;
     stopExternalEdits(responseModel: IChatResponseModel, operationId: number): Promise<IChatProgress[]>;
     /**
      * Gets the snapshot URI of a file at the request and _after_ changes made in the undo stop.
@@ -111,12 +111,39 @@ export interface IChatEditingSession extends IDisposable {
      * @returns The observable or undefined if there is no diff between the requests.
      */
     getEntryDiffBetweenRequests(uri: URI, startRequestIs: string, stopRequestId: string): IObservable<IEditSessionEntryDiff | undefined>;
+    /**
+     * Gets the diff of each file modified in this session, comparing the initial
+     * baseline to the current state.
+     */
+    getDiffsForFilesInSession(): IObservable<readonly IEditSessionEntryDiff[]>;
+    /**
+     * Gets the diff of each file modified in the request.
+     */
+    getDiffsForFilesInRequest(requestId: string): IObservable<readonly IEditSessionEntryDiff[]>;
+    /**
+     * Whether there are any edits made in the given request.
+     */
+    hasEditsInRequest(requestId: string, reader?: IReader): boolean;
+    /**
+     * Gets the aggregated diff stats for all files modified in this session.
+     */
+    getDiffForSession(): IObservable<IEditSessionDiffStats>;
     readonly canUndo: IObservable<boolean>;
     readonly canRedo: IObservable<boolean>;
     undoInteraction(): Promise<void>;
     redoInteraction(): Promise<void>;
 }
-export interface IEditSessionEntryDiff {
+export declare function chatEditingSessionIsReady(session: IChatEditingSession): Promise<void>;
+export declare function editEntriesToMultiDiffData(entriesObs: IObservable<readonly IEditSessionEntryDiff[]>): IChatMultiDiffData;
+export declare function awaitCompleteChatEditingDiff(diff: IObservable<IEditSessionEntryDiff>, token?: CancellationToken): Promise<IEditSessionEntryDiff>;
+export declare function awaitCompleteChatEditingDiff(diff: IObservable<readonly IEditSessionEntryDiff[]>, token?: CancellationToken): Promise<readonly IEditSessionEntryDiff[]>;
+export interface IEditSessionDiffStats {
+    /** Added data (e.g. line numbers) to show in the UI */
+    added: number;
+    /** Removed data (e.g. line numbers) to show in the UI */
+    removed: number;
+}
+export interface IEditSessionEntryDiff extends IEditSessionDiffStats {
     /** LHS and RHS of a diff editor, if opened: */
     originalURI: URI;
     modifiedURI: URI;
@@ -125,11 +152,10 @@ export interface IEditSessionEntryDiff {
     identical: boolean;
     /** True if nothing else will be added to this diff. */
     isFinal: boolean;
-    /** Added data (e.g. line numbers) to show in the UI */
-    added: number;
-    /** Removed data (e.g. line numbers) to show in the UI */
-    removed: number;
+    /** True if the diff is currently being computed or updated. */
+    isBusy: boolean;
 }
+export declare function emptySessionEntryDiff(originalURI: URI, modifiedURI: URI): IEditSessionEntryDiff;
 export declare enum ModifiedFileEntryState {
     Modified = 0,
     Accepted = 1,
@@ -221,6 +247,10 @@ export interface IModifiedFileEntry {
     readonly linesRemoved?: IObservable<number>;
     getEditorIntegration(editor: IEditorPane): IModifiedFileEntryEditorIntegration;
     hasModificationAt(location: Location): boolean;
+    /**
+     * Gets the document diff info, waiting for any ongoing promises to flush.
+     */
+    getDiffInfo?(): Promise<IDocumentDiff>;
 }
 export interface IChatEditingSessionStream {
     textEdits(resource: URI, textEdits: TextEdit[], isLastEdits: boolean, responseModel: IChatResponseModel): void;
@@ -253,6 +283,6 @@ export interface IChatEditingActionContext {
 export declare function isChatEditingActionContext(thing: unknown): thing is IChatEditingActionContext;
 export declare function getMultiDiffSourceUri(session: IChatEditingSession, showPreviousChanges?: boolean): URI;
 export declare function parseChatMultiDiffUri(uri: URI): {
-    chatSessionId: string;
+    chatSessionResource: URI;
     showPreviousChanges: boolean;
 };

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

@@ -1,9 +1,52 @@
 
+import { encodeHex, VSBuffer, decodeHex } from '../../../../base/common/buffer.js';
+import '../../../../base/common/errors.js';
+import '../../../../base/common/observableInternal/index.js';
 import { hasKey } from '../../../../base/common/types.js';
 import { URI } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { autorunSelfDisposable } from '../../../../base/common/observableInternal/reactions/autorun.js';
 
+function chatEditingSessionIsReady(session) {
+    return ( new Promise(resolve => {
+        autorunSelfDisposable(reader => {
+            const state = session.state.read(reader);
+            if (state !== ChatEditingSessionState.Initial) {
+                reader.dispose();
+                resolve();
+            }
+        });
+    }));
+}
+function editEntriesToMultiDiffData(entriesObs) {
+    return {
+        kind: 'multiDiffData',
+        collapsed: true,
+        multiDiffData: ( entriesObs.map(entries => ({
+            title: ( localize(5933, 'Changes to {0} files', entries.length)),
+            resources: ( entries.map(entry => ({
+                originalUri: entry.originalURI,
+                modifiedUri: entry.modifiedURI,
+                goToFileUri: entry.modifiedURI,
+                added: entry.added,
+                removed: entry.removed,
+            })))
+        }))),
+    };
+}
+function emptySessionEntryDiff(originalURI, modifiedURI) {
+    return {
+        originalURI,
+        modifiedURI,
+        added: 0,
+        removed: 0,
+        quitEarly: false,
+        identical: false,
+        isFinal: false,
+        isBusy: false,
+    };
+}
 var ModifiedFileEntryState;
 (function (ModifiedFileEntryState) {
     ModifiedFileEntryState[ModifiedFileEntryState["Modified"] = 0] = "Modified";
@@ -18,9 +61,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(5815, "The current state of the file in the chat editing widget"))));
+const chatEditingWidgetFileStateContextKey = ( new RawContextKey('chatEditingWidgetFileState', undefined, ( localize(5934, "The current state of the file in the chat editing widget"))));
 const chatEditingAgentSupportsReadonlyReferencesContextKey = ( new RawContextKey('chatEditingAgentSupportsReadonlyReferences', undefined, ( localize(
-    5816,
+    5935,
     "Whether the chat editing agent supports readonly references (temporary)"
 ))));
 const decidedChatEditingResourceContextKey = ( new RawContextKey('decidedChatEditingResource', []));
@@ -40,14 +83,14 @@ function isChatEditingActionContext(thing) {
 function getMultiDiffSourceUri(session, showPreviousChanges) {
     return ( URI.from({
         scheme: CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME,
-        authority: session.chatSessionId,
+        authority: encodeHex(VSBuffer.fromString(( session.chatSessionResource.toString()))),
         query: showPreviousChanges ? 'previous' : undefined,
     }));
 }
 function parseChatMultiDiffUri(uri) {
-    const chatSessionId = uri.authority;
+    const chatSessionResource = ( URI.parse(( decodeHex(uri.authority).toString())));
     const showPreviousChanges = uri.query === 'previous';
-    return { chatSessionId, showPreviousChanges };
+    return { chatSessionResource, showPreviousChanges };
 }
 
-export { CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, ChatEditKind, ChatEditingSessionState, ModifiedFileEntryState, applyingChatEditsFailedContextKey, chatEditingAgentSupportsReadonlyReferencesContextKey, chatEditingResourceContextKey, chatEditingWidgetFileStateContextKey, decidedChatEditingResourceContextKey, getMultiDiffSourceUri, hasAppliedChatEditsContextKey, hasUndecidedChatEditingResourceContextKey, inChatEditingSessionContextKey, isChatEditingActionContext, parseChatMultiDiffUri };
+export { CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, ChatEditKind, ChatEditingSessionState, ModifiedFileEntryState, applyingChatEditsFailedContextKey, chatEditingAgentSupportsReadonlyReferencesContextKey, chatEditingResourceContextKey, chatEditingSessionIsReady, chatEditingWidgetFileStateContextKey, decidedChatEditingResourceContextKey, editEntriesToMultiDiffData, emptySessionEntryDiff, getMultiDiffSourceUri, hasAppliedChatEditsContextKey, hasUndecidedChatEditingResourceContextKey, inChatEditingSessionContextKey, isChatEditingActionContext, parseChatMultiDiffUri };

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

@@ -3,11 +3,11 @@ 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-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { ChatModel } from "./chatModel.js";
 export declare const IChatEditingService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatEditingService>;
 export interface IChatEditingService {
     _serviceBrand: undefined;
-    startOrContinueGlobalEditingSession(chatModel: ChatModel): Promise<IChatEditingSession>;
+    startOrContinueGlobalEditingSession(chatModel: ChatModel): IChatEditingSession;
     getEditingSession(chatSessionResource: URI): IChatEditingSession | undefined;
     /**
     * All editing sessions, sorted by recency, e.g the last created session comes first.
@@ -16,11 +16,11 @@ export interface IChatEditingService {
     /**
     * Creates a new short lived editing session
     */
-    createEditingSession(chatModel: ChatModel): Promise<IChatEditingSession>;
+    createEditingSession(chatModel: ChatModel): IChatEditingSession;
     /**
     * Creates an editing session with state transferred from the provided session.
     */
-    transferEditingSession(chatModel: ChatModel, session: IChatEditingSession): Promise<IChatEditingSession>;
+    transferEditingSession(chatModel: ChatModel, session: IChatEditingSession): IChatEditingSession;
     hasRelatedFilesProviders(): boolean;
     registerRelatedFilesProvider(handle: number, provider: IChatRelatedFilesProvider): IDisposable;
     getRelatedFiles(chatSessionResource: URI, prompt: string, files: URI[], token: CancellationToken): Promise<{