@codingame/monaco-vscode-api 22.1.9 → 23.0.0

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

@@ -1,16 +1,19 @@
+import { VSBuffer } from "../../../../base/common/buffer.js";
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable, IReader } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
+import { IDocumentDiff } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/editor/common/diff/documentDiffProvider";
 import { Location, TextEdit } from "../../../../editor/common/languages.js";
 import { ITextModel } from "../../../../editor/common/model.js";
+import { EditSuggestionId } from "../../../../editor/common/textModelEditSource.js";
 import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
 import { IEditorPane } from "../../../common/editor.js";
-import { EditSuggestionId } from "../../../../editor/common/textModelEditSource.js";
 import { ICellEditOperation } from "../../notebook/common/notebookCommon.js";
-import { IChatAgentResult } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
-import { IChatResponseModel } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+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";
 export interface IChatRequestDraft {
     readonly prompt: string;
     readonly files: readonly URI[];
@@ -46,7 +49,7 @@ export interface IModifiedEntryTelemetryInfo {
     readonly modelId: string | undefined;
     readonly modeId: "ask" | "edit" | "agent" | "custom" | "applyCodeBlock" | undefined;
     readonly applyCodeBlockSuggestionId: EditSuggestionId | undefined;
-    readonly feature: "sideBarChat" | "inlineChat" | string | undefined;
+    readonly feature: "sideBarChat" | "inlineChat" | undefined;
 }
 export interface ISnapshotEntry {
     readonly resource: URI;
@@ -59,7 +62,9 @@ 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[]>;
@@ -67,15 +72,23 @@ export interface IChatEditingSession extends IDisposable {
     accept(...uris: URI[]): Promise<void>;
     reject(...uris: URI[]): Promise<void>;
     getEntry(uri: URI): IModifiedFileEntry | undefined;
-    readEntry(uri: URI, reader?: IReader): IModifiedFileEntry | undefined;
+    readEntry(uri: URI, reader: IReader): IModifiedFileEntry | undefined;
     restoreSnapshot(requestId: string, stopId: string | undefined): Promise<void>;
+    /**
+     * Marks all edits to the given resources as agent edits until
+     * {@link stopExternalEdits} is called with the same ID. This is used for
+     * agents that make changes on-disk rather than streaming edits through the
+     * chat session.
+     */
+    startExternalEdits(responseModel: IChatResponseModel, operationId: number, resources: URI[]): 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.
      * @param uri File in the workspace
      */
     getSnapshotUri(requestId: string, uri: URI, stopId: string | undefined): URI | undefined;
+    getSnapshotContents(requestId: string, uri: URI, stopId: string | undefined): Promise<VSBuffer | undefined>;
     getSnapshotModel(requestId: string, undoStop: string | undefined, snapshotUri: URI): Promise<ITextModel | null>;
-    getSnapshot(requestId: string, undoStop: string | undefined, snapshotUri: URI): ISnapshotEntry | undefined;
     /**
      * Will lead to this object getting disposed
      */
@@ -110,6 +123,8 @@ export interface IEditSessionEntryDiff {
     /** Diff state information: */
     quitEarly: boolean;
     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 */
@@ -172,7 +187,10 @@ export interface IModifiedFileEntry {
     readonly modifiedURI: URI;
     readonly lastModifyingRequestId: string;
     readonly state: IObservable<ModifiedFileEntryState>;
-    readonly isCurrentlyBeingModifiedBy: IObservable<IChatResponseModel | undefined>;
+    readonly isCurrentlyBeingModifiedBy: IObservable<{
+        responseModel: IChatResponseModel;
+        undoStopId: string | undefined;
+    } | undefined>;
     readonly lastModifyingResponse: IObservable<IChatResponseModel | undefined>;
     readonly rewriteRatio: IObservable<number>;
     readonly waitsForLastEdits: IObservable<boolean>;
@@ -189,6 +207,10 @@ export interface IModifiedFileEntry {
      * Number of changes for this file
      */
     readonly changesCount: IObservable<number>;
+    /**
+     * Diff information for this entry
+     */
+    readonly diffInfo?: IObservable<IDocumentDiff>;
     /**
      * Number of lines added in this entry.
      */
@@ -226,7 +248,7 @@ export declare enum ChatEditKind {
     Modified = 1
 }
 export interface IChatEditingActionContext {
-    sessionId: string;
+    sessionResource: URI;
 }
 export declare function isChatEditingActionContext(thing: unknown): thing is IChatEditingActionContext;
 export declare function getMultiDiffSourceUri(session: IChatEditingSession, showPreviousChanges?: boolean): URI;

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

@@ -1,4 +1,5 @@
 
+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';
@@ -17,9 +18,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(5588, "The current state of the file in the chat editing widget"))));
+const chatEditingWidgetFileStateContextKey = ( new RawContextKey('chatEditingWidgetFileState', undefined, ( localize(5792, "The current state of the file in the chat editing widget"))));
 const chatEditingAgentSupportsReadonlyReferencesContextKey = ( new RawContextKey('chatEditingAgentSupportsReadonlyReferences', undefined, ( localize(
-    5589,
+    5793,
     "Whether the chat editing agent supports readonly references (temporary)"
 ))));
 const decidedChatEditingResourceContextKey = ( new RawContextKey('decidedChatEditingResource', []));
@@ -34,7 +35,7 @@ var ChatEditKind;
     ChatEditKind[ChatEditKind["Modified"] = 1] = "Modified";
 })(ChatEditKind || (ChatEditKind = {}));
 function isChatEditingActionContext(thing) {
-    return typeof thing === 'object' && !!thing && 'sessionId' in thing;
+    return typeof thing === 'object' && !!thing && hasKey(thing, { sessionResource: true });
 }
 function getMultiDiffSourceUri(session, showPreviousChanges) {
     return ( URI.from({

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

@@ -3,12 +3,12 @@ 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-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { ChatModel } from "@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-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(chatModel: ChatModel): Promise<IChatEditingSession>;
-    getEditingSession(chatSessionId: string): IChatEditingSession | undefined;
+    getEditingSession(chatSessionResource: URI): IChatEditingSession | undefined;
     /**
     * All editing sessions, sorted by recency, e.g the last created session comes first.
     */
@@ -17,9 +17,13 @@ export interface IChatEditingService {
     * Creates a new short lived editing session
     */
     createEditingSession(chatModel: ChatModel): Promise<IChatEditingSession>;
+    /**
+    * Creates an editing session with state transferred from the provided session.
+    */
+    transferEditingSession(chatModel: ChatModel, session: IChatEditingSession): Promise<IChatEditingSession>;
     hasRelatedFilesProviders(): boolean;
     registerRelatedFilesProvider(handle: number, provider: IChatRelatedFilesProvider): IDisposable;
-    getRelatedFiles(chatSessionId: string, prompt: string, files: URI[], token: CancellationToken): Promise<{
+    getRelatedFiles(chatSessionResource: URI, prompt: string, files: URI[], token: CancellationToken): Promise<{
         group: string;
         files: IChatRelatedFile[];
     }[] | undefined>;

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

@@ -1,9 +1,9 @@
 import { Event } from "../../../../base/common/event.js";
-import { IChatMode } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModes";
+import { IChatMode } from "@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModes";
 export declare const IChatModeService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatModeService>;
 export interface IChatModeService {
     readonly _serviceBrand: undefined;
-    onDidChangeChatModes: Event<void>;
+    readonly onDidChangeChatModes: Event<void>;
     getModes(): {
         builtin: readonly IChatMode[];
         custom: readonly IChatMode[];

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

@@ -1,19 +1,21 @@
 import { IAction } from "../../../../base/common/actions.js";
 import { DeferredPromise } from "../../../../base/common/async.js";
+import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IMarkdownString } from "../../../../base/common/htmlContent.js";
-import { IObservable } from "../../../../base/common/observable.js";
+import { IObservable, IReader } from "../../../../base/common/observable.js";
 import { ThemeIcon } from "../../../../base/common/themables.js";
-import { URI } from "../../../../base/common/uri.js";
+import { URI, UriComponents } from "../../../../base/common/uri.js";
 import { IRange } from "../../../../editor/common/core/range.js";
 import { ISelection } from "../../../../editor/common/core/selection.js";
 import { Command, Location, TextEdit } from "../../../../editor/common/languages.js";
 import { FileType } from "../../../../platform/files/common/files.js";
+import { IAutostartResult } from "../../mcp/common/mcpTypes.js";
 import { ICellEditOperation } from "../../notebook/common/notebookCommon.js";
-import { IWorkspaceSymbol } from "@codingame/monaco-vscode-5084de40-f866-5cb5-9d9b-33a10f6f235d-common/vscode/vs/workbench/contrib/search/common/search";
-import { IChatAgentCommand, IChatAgentData, IChatAgentResult, UserSelectedTools } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
-import { IChatRequestModeInfo, IChatResponseModel } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
-import { IChatParserContext } from "@codingame/monaco-vscode-5084de40-f866-5cb5-9d9b-33a10f6f235d-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser";
+import { IWorkspaceSymbol } from "@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/contrib/search/common/search";
+import { IChatAgentCommand, IChatAgentData, IChatAgentResult, UserSelectedTools } from "@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatRequestModeInfo, IChatResponseModel } from "@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatParserContext } from "@codingame/monaco-vscode-bc6f260d-ec63-5c95-9446-1ca7d0872719-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser";
 import { IChatRequestVariableEntry } from "./chatVariableEntries.js";
 import { IChatRequestVariableValue } from "./chatVariables.js";
 import { ChatAgentLocation, ChatModeKind } from "./constants.js";
@@ -111,9 +113,10 @@ export interface IChatContentInlineReference {
     kind: "inlineReference";
 }
 export interface IChatMarkdownContent {
+    kind: "markdownContent";
     content: IMarkdownString;
     inlineReferences?: Record<string, IChatContentInlineReference>;
-    kind: "markdownContent";
+    fromSubagent?: boolean;
 }
 export interface IChatTreeData {
     treeData: IChatResponseProgressFileTreeData;
@@ -131,6 +134,7 @@ export interface IChatMultiDiffData {
         }>;
     };
     kind: "multiDiffData";
+    readOnly?: boolean;
 }
 export interface IChatProgressMessage {
     content: IMarkdownString;
@@ -139,7 +143,7 @@ export interface IChatProgressMessage {
 export interface IChatTask extends IChatTaskDto {
     deferred: DeferredPromise<string | void>;
     progress: (IChatWarningMessage | IChatContentReference)[];
-    onDidAddProgress: Event<IChatWarningMessage | IChatContentReference>;
+    readonly onDidAddProgress: Event<IChatWarningMessage | IChatContentReference>;
     add(progress: IChatWarningMessage | IChatContentReference): void;
     complete: (result: string | void) => void;
     task: () => Promise<string | void>;
@@ -149,6 +153,11 @@ export interface IChatUndoStop {
     kind: "undoStop";
     id: string;
 }
+export interface IChatExternalEditsDto {
+    kind: "externalEdits";
+    start: boolean; /** true=start, false=stop */
+    resources: UriComponents[];
+}
 export interface IChatTaskDto {
     content: IMarkdownString;
     kind: "progressTask";
@@ -194,6 +203,7 @@ export interface IChatTextEdit {
     edits: TextEdit[];
     kind: "textEdit";
     done?: boolean;
+    isExternalEdit?: boolean;
 }
 export interface IChatClearToPreviousToolInvocation {
     kind: "clearToPreviousToolInvocation";
@@ -204,11 +214,14 @@ export interface IChatNotebookEdit {
     edits: ICellEditOperation[];
     kind: "notebookEdit";
     done?: boolean;
+    isExternalEdit?: boolean;
 }
 export interface IChatConfirmation {
     title: string;
     message: string | IMarkdownString;
     data: any;
+    /** Indicates whether this came from a current chat session (true/undefined) or a restored historic session (false) */
+    isLive?: boolean;
     buttons?: string[];
     isUsed?: boolean;
     kind: "confirmation";
@@ -248,6 +261,8 @@ export interface IChatTerminalToolInvocationData {
     alternativeRecommendation?: string;
     language: string;
     terminalToolSessionId?: string;
+    /** The predefined command ID that will be used for this terminal command */
+    terminalCommandId?: string;
     autoApproveInfo?: IMarkdownString;
 }
 /**
@@ -287,30 +302,71 @@ export type ConfirmedReason = {
     type: ToolConfirmKind.Skipped;
 };
 export interface IChatToolInvocation {
-    presentation: IPreparedToolInvocation["presentation"];
-    toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent;
-    /** Presence of this property says that confirmation is required */
-    confirmationMessages?: IToolConfirmationMessages;
-    confirmed: DeferredPromise<ConfirmedReason>;
-    /** undefined=don't know yet. */
-    isConfirmed: ConfirmedReason | undefined;
-    originMessage: string | IMarkdownString | undefined;
-    invocationMessage: string | IMarkdownString;
-    pastTenseMessage: string | IMarkdownString | undefined;
-    resultDetails: IToolResult["toolResultDetails"];
-    source: ToolDataSource;
-    progress: IObservable<{
-        message?: string | IMarkdownString;
-        progress: number | undefined;
-    }>;
+    readonly presentation: IPreparedToolInvocation["presentation"];
+    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent;
+    readonly confirmationMessages?: IToolConfirmationMessages;
+    readonly originMessage: string | IMarkdownString | undefined;
+    readonly invocationMessage: string | IMarkdownString;
+    readonly pastTenseMessage: string | IMarkdownString | undefined;
+    readonly source: ToolDataSource;
     readonly toolId: string;
     readonly toolCallId: string;
+    readonly parameters: unknown;
     readonly fromSubAgent?: boolean;
-    isCompletePromise: Promise<void>;
-    isComplete: boolean;
-    complete(result: IToolResult): void;
+    readonly state: IObservable<IChatToolInvocation.State>;
     kind: "toolInvocation";
 }
+export declare namespace IChatToolInvocation {
+    export enum StateKind {
+        WaitingForConfirmation = 0,
+        Executing = 1,
+        WaitingForPostApproval = 2,
+        Completed = 3,
+        Cancelled = 4
+    }
+    interface IChatToolInvocationStateBase {
+        type: StateKind;
+    }
+    interface IChatToolInvocationWaitingForConfirmationState extends IChatToolInvocationStateBase {
+        type: StateKind.WaitingForConfirmation;
+        confirm(reason: ConfirmedReason): void;
+    }
+    interface IChatToolInvocationPostConfirmState {
+        confirmed: ConfirmedReason;
+    }
+    interface IChatToolInvocationExecutingState extends IChatToolInvocationStateBase, IChatToolInvocationPostConfirmState {
+        type: StateKind.Executing;
+        progress: IObservable<{
+            message?: string | IMarkdownString;
+            progress: number | undefined;
+        }>;
+    }
+    interface IChatToolInvocationPostExecuteState extends IChatToolInvocationPostConfirmState {
+        resultDetails: IToolResult["toolResultDetails"];
+    }
+    interface IChatToolWaitingForPostApprovalState extends IChatToolInvocationStateBase, IChatToolInvocationPostExecuteState {
+        type: StateKind.WaitingForPostApproval;
+        confirm(reason: ConfirmedReason): void;
+        contentForModel: IToolResult["content"];
+    }
+    interface IChatToolInvocationCompleteState extends IChatToolInvocationStateBase, IChatToolInvocationPostExecuteState {
+        type: StateKind.Completed;
+        postConfirmed: ConfirmedReason | undefined;
+        contentForModel: IToolResult["content"];
+    }
+    interface IChatToolInvocationCancelledState extends IChatToolInvocationStateBase {
+        type: StateKind.Cancelled;
+        reason: ToolConfirmKind.Denied | ToolConfirmKind.Skipped;
+    }
+    export type State = IChatToolInvocationWaitingForConfirmationState | IChatToolInvocationExecutingState | IChatToolWaitingForPostApprovalState | IChatToolInvocationCompleteState | IChatToolInvocationCancelledState;
+    export function executionConfirmedOrDenied(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): ConfirmedReason | undefined;
+    export function awaitConfirmation(invocation: IChatToolInvocation, token?: CancellationToken): Promise<ConfirmedReason>;
+    export function confirmWith(invocation: IChatToolInvocation | undefined, reason: ConfirmedReason): boolean;
+    export function awaitPostConfirmation(invocation: IChatToolInvocation, token?: CancellationToken): Promise<ConfirmedReason>;
+    export function resultDetails(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): (URI | Location)[] | IToolResultInputOutputDetails | IToolResultOutputDetailsSerialized | import("./languageModelToolsService.js").IToolResultOutputDetails | undefined;
+    export function isComplete(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean;
+    export {};
+}
 export interface IToolResultOutputDetailsSerialized {
     output: {
         type: "data";
@@ -359,21 +415,25 @@ export interface IChatTodoListContent {
         status: "not-started" | "in-progress" | "completed";
     }>;
 }
-export interface IChatMcpServersInteractionRequired {
-    kind: "mcpServersInteractionRequired";
-    isDone?: boolean;
-    servers: Array<{
-        serverId: string;
-        serverLabel: string;
-        errorMessage?: string;
-    }>;
-    startCommand: Command;
+export interface IChatMcpServersStarting {
+    readonly kind: "mcpServersStarting";
+    readonly state?: IObservable<IAutostartResult>;
+    didStartServerIds?: string[];
+}
+export declare class ChatMcpServersStarting implements IChatMcpServersStarting {
+    readonly state: IObservable<IAutostartResult>;
+    readonly kind = "mcpServersStarting";
+    didStartServerIds?: string[];
+    get isEmpty(): boolean;
+    constructor(state: IObservable<IAutostartResult>);
+    wait(): Promise<IAutostartResult>;
+    toJSON(): IChatMcpServersStarting;
 }
 export interface IChatPrepareToolInvocationPart {
     readonly kind: "prepareToolInvocation";
     readonly toolName: string;
 }
-export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatMultiDiffData | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatPrepareToolInvocationPart | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatMcpServersInteractionRequired;
+export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatMultiDiffData | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatPrepareToolInvocationPart | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatMcpServersStarting;
 export interface IChatFollowup {
     kind: "reply";
     message: string;
@@ -481,7 +541,7 @@ export interface IChatUserActionEvent {
     action: ChatUserAction;
     agentId: string | undefined;
     command: string | undefined;
-    sessionId: string;
+    sessionResource: URI;
     requestId: string;
     result: IChatAgentResult | undefined;
     modelId?: string | undefined;
@@ -503,7 +563,7 @@ export interface IChatCompleteResponse {
     followups?: IChatFollowup[];
 }
 export interface IChatDetail {
-    sessionId: string;
+    sessionResource: URI;
     title: string;
     lastMessageDate: number;
     isActive: boolean;
@@ -531,7 +591,7 @@ export interface IChatEditorLocationData {
     selection: ISelection;
     wholeRange: IRange;
     close: () => void;
-    delegateSessionId: string | undefined;
+    delegateSessionResource: URI | undefined;
 }
 export interface IChatNotebookLocationData {
     type: ChatAgentLocation.Notebook;
@@ -562,5 +622,17 @@ export interface IChatSendRequestOptions {
      * The label of the confirmation action that was selected.
      */
     confirmation?: string;
+    /**
+     * Summary data for chat sessions context
+     */
+    chatSummary?: {
+        prompt?: string;
+        history?: string;
+    };
+}
+export interface IChatSessionContext {
+    readonly chatSessionType: string;
+    readonly chatSessionResource: URI;
+    readonly isUntitled: boolean;
 }
 export declare const KEYWORD_ACTIVIATION_SETTING_ID = "accessibility.voice.keywordActivation";

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

@@ -1,6 +1,9 @@
 
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/index.js';
 import { URI } from '../../../../base/common/uri.js';
 import { Range } from '../../../../editor/common/core/range.js';
+import { autorun, autorunSelfDisposable } from '../../../../base/common/observableInternal/reactions/autorun.js';
 
 var ChatErrorLevel;
 (function (ChatErrorLevel) {
@@ -43,6 +46,145 @@ var ToolConfirmKind;
     ToolConfirmKind[ToolConfirmKind["UserAction"] = 4] = "UserAction";
     ToolConfirmKind[ToolConfirmKind["Skipped"] = 5] = "Skipped";
 })(ToolConfirmKind || (ToolConfirmKind = {}));
+var IChatToolInvocation;
+(function (IChatToolInvocation) {
+    let StateKind;
+    (function (StateKind) {
+        StateKind[StateKind["WaitingForConfirmation"] = 0] = "WaitingForConfirmation";
+        StateKind[StateKind["Executing"] = 1] = "Executing";
+        StateKind[StateKind["WaitingForPostApproval"] = 2] = "WaitingForPostApproval";
+        StateKind[StateKind["Completed"] = 3] = "Completed";
+        StateKind[StateKind["Cancelled"] = 4] = "Cancelled";
+    })(StateKind = IChatToolInvocation.StateKind || (IChatToolInvocation.StateKind = {}));
+    function executionConfirmedOrDenied(invocation, reader) {
+        if (invocation.kind === 'toolInvocationSerialized') {
+            if (invocation.isConfirmed === undefined || typeof invocation.isConfirmed === 'boolean') {
+                return { type: invocation.isConfirmed ? ToolConfirmKind.UserAction : ToolConfirmKind.Denied };
+            }
+            return invocation.isConfirmed;
+        }
+        const state = invocation.state.read(reader);
+        if (state.type === StateKind.WaitingForConfirmation) {
+            return undefined;
+        }
+        if (state.type === StateKind.Cancelled) {
+            return { type: state.reason };
+        }
+        return state.confirmed;
+    }
+    IChatToolInvocation.executionConfirmedOrDenied = executionConfirmedOrDenied;
+    function awaitConfirmation(invocation, token) {
+        const reason = executionConfirmedOrDenied(invocation);
+        if (reason) {
+            return Promise.resolve(reason);
+        }
+        const store = ( new DisposableStore());
+        return ( new Promise(resolve => {
+            if (token) {
+                store.add(token.onCancellationRequested(() => {
+                    resolve({ type: ToolConfirmKind.Denied });
+                }));
+            }
+            store.add(autorun(reader => {
+                const reason = executionConfirmedOrDenied(invocation, reader);
+                if (reason) {
+                    store.dispose();
+                    resolve(reason);
+                }
+            }));
+        })).finally(() => {
+            store.dispose();
+        });
+    }
+    IChatToolInvocation.awaitConfirmation = awaitConfirmation;
+    function postApprovalConfirmedOrDenied(invocation, reader) {
+        const state = invocation.state.read(reader);
+        if (state.type === StateKind.Completed) {
+            return state.postConfirmed || { type: ToolConfirmKind.ConfirmationNotNeeded };
+        }
+        if (state.type === StateKind.Cancelled) {
+            return { type: state.reason };
+        }
+        return undefined;
+    }
+    function confirmWith(invocation, reason) {
+        const state = invocation?.state.get();
+        if (state?.type === StateKind.WaitingForConfirmation || state?.type === StateKind.WaitingForPostApproval) {
+            state.confirm(reason);
+            return true;
+        }
+        return false;
+    }
+    IChatToolInvocation.confirmWith = confirmWith;
+    function awaitPostConfirmation(invocation, token) {
+        const reason = postApprovalConfirmedOrDenied(invocation);
+        if (reason) {
+            return Promise.resolve(reason);
+        }
+        const store = ( new DisposableStore());
+        return ( new Promise(resolve => {
+            if (token) {
+                store.add(token.onCancellationRequested(() => {
+                    resolve({ type: ToolConfirmKind.Denied });
+                }));
+            }
+            store.add(autorun(reader => {
+                const reason = postApprovalConfirmedOrDenied(invocation, reader);
+                if (reason) {
+                    store.dispose();
+                    resolve(reason);
+                }
+            }));
+        })).finally(() => {
+            store.dispose();
+        });
+    }
+    IChatToolInvocation.awaitPostConfirmation = awaitPostConfirmation;
+    function resultDetails(invocation, reader) {
+        if (invocation.kind === 'toolInvocationSerialized') {
+            return invocation.resultDetails;
+        }
+        const state = invocation.state.read(reader);
+        if (state.type === StateKind.Completed || state.type === StateKind.WaitingForPostApproval) {
+            return state.resultDetails;
+        }
+        return undefined;
+    }
+    IChatToolInvocation.resultDetails = resultDetails;
+    function isComplete(invocation, reader) {
+        if ('isComplete' in invocation) {
+            return true;
+        }
+        const state = invocation.state.read(reader);
+        return state.type === StateKind.Completed || state.type === StateKind.Cancelled;
+    }
+    IChatToolInvocation.isComplete = isComplete;
+})(IChatToolInvocation || (IChatToolInvocation = {}));
+class ChatMcpServersStarting {
+    get isEmpty() {
+        const s = this.state.get();
+        return !s.working && s.serversRequiringInteraction.length === 0;
+    }
+    constructor(state) {
+        this.state = state;
+        this.kind = 'mcpServersStarting';
+        this.didStartServerIds = [];
+    }
+    wait() {
+        return ( new Promise(resolve => {
+            autorunSelfDisposable(reader => {
+                const s = this.state.read(reader);
+                if (!s.working) {
+                    reader.dispose();
+                    resolve(s);
+                }
+            });
+        }));
+    }
+    toJSON() {
+        return { kind: 'mcpServersStarting', didStartServerIds: this.didStartServerIds };
+    }
+}
 var ChatAgentVoteDirection;
 (function (ChatAgentVoteDirection) {
     ChatAgentVoteDirection[ChatAgentVoteDirection["Down"] = 0] = "Down";
@@ -66,4 +208,4 @@ var ChatCopyKind;
     ChatCopyKind[ChatCopyKind["Toolbar"] = 2] = "Toolbar";
 })(ChatCopyKind || (ChatCopyKind = {}));
 
-export { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatCopyKind, ChatErrorLevel, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ToolConfirmKind, isIDocumentContext, isIUsedContext };
+export { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, IChatToolInvocation, ToolConfirmKind, isIDocumentContext, isIUsedContext };