@codingame/monaco-vscode-api 26.2.1 → 27.0.0

package/vscode/src/vs/workbench/contrib/chat/common/model/chatModel.js

@@ -24,12 +24,14 @@ import { migrateLegacyTerminalToolSpecificData } from '../chat.js';
 import { IChatToolInvocation, ChatResponseClearToPreviousToolInvocationReason, ResponseModelState, ElicitationState, isIUsedContext, ChatRequestQueueKind } from '../chatService/chatService.js';
 import { IChatService } from '../chatService/chatService.service.js';
 import { ChatAgentLocation, ChatModeKind } from '../constants.js';
+import { ChatToolInvocation } from './chatProgressTypes/chatToolInvocation.js';
+import { ToolDataSource } from '../tools/languageModelToolsService.js';
 import { ModifiedFileEntryState } from '../editing/chatEditingService.js';
 import { IChatEditingService } from '../editing/chatEditingService.service.js';
 import { reviveSerializedAgent } from '../participants/chatAgents.js';
 import { IChatAgentService } from '../participants/chatAgents.service.js';
 import { reviveParsedChatRequest, ChatRequestTextPart } from '../requestParser/chatParserTypes.js';
-import { LocalChatSessionUri } from './chatUri.js';
+import { chatSessionResourceToId, LocalChatSessionUri } from './chatUri.js';
 import { observableFromEvent } from '../../../../../base/common/observableInternal/observables/observableFromEvent.js';
 import { autorunSelfDisposable, autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
 import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
@@ -246,7 +248,7 @@ class AbstractResponse {
             blocks.push(currentBlockSegments.join(""));
         }
         if (hasEditGroupsAfterLastClear) {
-            blocks.push(( localize(6344, "Made changes.")));
+            blocks.push(( localize(6895, "Made changes.")));
         }
         return blocks.join("\n\n");
     }
@@ -352,12 +354,12 @@ class Response extends AbstractResponse {
         if (progress.kind === "clearToPreviousToolInvocation") {
             if (progress.reason === ChatResponseClearToPreviousToolInvocationReason.CopyrightContentRetry) {
                 this.clearToPreviousToolInvocation(( localize(
-                    6345,
+                    6896,
                     "Response cleared due to possible match to public code, retrying with modified prompt."
                 )));
             } else if (progress.reason === ChatResponseClearToPreviousToolInvocationReason.FilteredContentRetry) {
                 this.clearToPreviousToolInvocation(( localize(
-                    6346,
+                    6897,
                     "Response cleared due to content safety filters, retrying with modified prompt."
                 )));
             } else {
@@ -430,6 +432,9 @@ class Response extends AbstractResponse {
             });
             this._responseParts.push(progress);
             this._updateRepr(quiet);
+        } else if (progress.kind === "externalToolInvocationUpdate") {
+            this._handleExternalToolInvocationUpdate(progress);
+            this._updateRepr(quiet);
         } else {
             this._responseParts.push(progress);
             this._updateRepr(quiet);
@@ -471,6 +476,48 @@ class Response extends AbstractResponse {
             isExternalEdit
         });
     }
+    _handleExternalToolInvocationUpdate(progress) {
+        const existingInvocation = this._responseParts.findLast(
+            part => part.kind === "toolInvocation" && part.toolCallId === progress.toolCallId
+        );
+        if (existingInvocation) {
+            if (progress.isComplete) {
+                existingInvocation.didExecuteTool({
+                    content: [],
+                    toolResultMessage: progress.pastTenseMessage,
+                    toolResultError: progress.errorMessage
+                });
+            }
+            if (progress.toolSpecificData !== undefined) {
+                existingInvocation.toolSpecificData = progress.toolSpecificData;
+            }
+            return;
+        }
+        const toolData = {
+            id: progress.toolName,
+            source: ToolDataSource.External,
+            displayName: progress.toolName,
+            modelDescription: progress.toolName
+        };
+        const invocation = ( new ChatToolInvocation({
+            invocationMessage: progress.invocationMessage,
+            pastTenseMessage: progress.pastTenseMessage,
+            toolSpecificData: progress.toolSpecificData
+        }, toolData, progress.toolCallId, progress.subagentInvocationId,
+        undefined, {},
+        undefined));
+        if (progress.isComplete) {
+            invocation.didExecuteTool({
+                content: [],
+                toolResultMessage: progress.pastTenseMessage,
+                toolResultError: progress.errorMessage
+            });
+            if (progress.toolSpecificData !== undefined) {
+                invocation.toolSpecificData = progress.toolSpecificData;
+            }
+        }
+        this._responseParts.push(invocation);
+    }
     _updateRepr(quiet) {
         super._updateRepr();
         if (!this._onDidChangeValue) {
@@ -543,6 +590,9 @@ class ChatResponseModel extends Disposable {
     get result() {
         return this._result;
     }
+    get usage() {
+        return this._usage;
+    }
     get username() {
         return this.session.responderUsername;
     }
@@ -625,12 +675,15 @@ class ChatResponseModel extends Disposable {
                         return title ? (isMarkdownString(title) ? title.value : title) : undefined;
                     }
                     if (state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
-                        return localize(6347, "Approve tool result?");
+                        return localize(6898, "Approve tool result?");
                     }
                 }
                 if (part.kind === "confirmation" && !part.isUsed) {
                     return part.title;
                 }
+                if (part.kind === "questionCarousel" && !part.isUsed) {
+                    return localize(6899, "Answer questions to continue...");
+                }
                 if (part.kind === "elicitation2" && part.state.read(r) === ElicitationState.Pending) {
                     const title = part.title;
                     return isMarkdownString(title) ? title.value : title;
@@ -715,6 +768,10 @@ class ChatResponseModel extends Disposable {
         this._result = result;
         this._onDidChange.fire(defaultChatResponseModelChangeReason);
     }
+    setUsage(usage) {
+        this._usage = usage;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
     complete() {
         if (this.isComplete) {
             return;
@@ -1075,8 +1132,16 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
             );
         }
         this._isImported = !!initialData && isValidExportedData && !isValidFullData;
-        this._sessionId = (isValidFullData && initialData.sessionId) || initialModelProps.sessionId || generateUuid();
-        this._sessionResource = initialModelProps.resource ?? LocalChatSessionUri.forSession(this._sessionId);
+        if (initialModelProps.resource) {
+            this._sessionId = chatSessionResourceToId(initialModelProps.resource);
+            this._sessionResource = initialModelProps.resource;
+        } else if (isValidFullData) {
+            this._sessionId = initialData.sessionId;
+            this._sessionResource = LocalChatSessionUri.forSession(initialData.sessionId);
+        } else {
+            this._sessionId = generateUuid();
+            this._sessionResource = LocalChatSessionUri.forSession(this._sessionId);
+        }
         this._disableBackgroundKeepAlive = initialModelProps.disableBackgroundKeepAlive ?? false;
         this._requests = initialData ? this._deserialize(initialData) : [];
         this._timestamp = (isValidFullData && initialData.creationDate) || Date.now();
@@ -1137,7 +1202,7 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
                 const needsInput = this.requestNeedsInput.read(r);
                 const shouldStayAlive = inProgress || !!needsInput;
                 if (shouldStayAlive && !selfRef.value) {
-                    selfRef.value = chatService.getActiveSessionReference(this._sessionResource);
+                    selfRef.value = chatService.acquireExistingSession(this._sessionResource);
                 } else if (!shouldStayAlive && selfRef.value) {
                     selfRef.clear();
                 }
@@ -1153,7 +1218,7 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
             this._register(autorun(r => {
                 const hasModified = ( session.entries.read(r).some(e => e.state.read(r) === ModifiedFileEntryState.Modified));
                 if (hasModified && !selfRef.value) {
-                    selfRef.value = this.chatService.getActiveSessionReference(this._sessionResource);
+                    selfRef.value = this.chatService.acquireExistingSession(this._sessionResource);
                 } else if (!hasModified && selfRef.value) {
                     selfRef.clear();
                 }
@@ -1223,6 +1288,15 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
                     completedAt: Date.now()
                 };
             }
+            if (raw.response) {
+                for (const part of raw.response) {
+                    if (hasKey(part, {
+                        kind: true
+                    }) && (part.kind === "questionCarousel")) {
+                        part.isUsed = true;
+                    }
+                }
+            }
             request.response = ( new ChatResponseModel({
                 responseContent: raw.response ?? [( new MarkdownString(raw.response))],
                 session: this,
@@ -1294,6 +1368,9 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
     resetCheckpoint() {
         for (const request of this._requests) {
             request.setShouldBeBlocked(false);
+            if (request.response) {
+                request.response.setBlockedState(false);
+            }
         }
     }
     setCheckpoint(requestId) {
@@ -1315,6 +1392,9 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
             const request = this._requests[i];
             if (this._checkpoint && !checkpoint) {
                 request.setShouldBeBlocked(false);
+                if (request.response) {
+                    request.response.setBlockedState(false);
+                }
             } else if (checkpoint && i >= checkpointIndex) {
                 request.setShouldBeBlocked(true);
                 if (request.response) {
@@ -1322,6 +1402,9 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
                 }
             } else if (checkpoint && i < checkpointIndex) {
                 request.setShouldBeBlocked(false);
+                if (request.response) {
+                    request.response.setBlockedState(false);
+                }
             }
         }
         this._checkpoint = checkpoint;
@@ -1546,8 +1629,7 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
             sessionId: this.sessionId,
             creationDate: this._timestamp,
             customTitle: this._customTitle,
-            inputState: this.inputModel.toJSON(),
-            repoData: this._repoData
+            inputState: this.inputModel.toJSON()
         };
     }
     dispose() {
@@ -1594,7 +1676,7 @@ function getCodeCitationsMessage(citations) {
         return "";
     }
     const licenseTypes = citations.reduce((set, c) => set.add(c.license), ( new Set()));
-    const label = licenseTypes.size === 1 ? ( localize(6348, "Similar code found with 1 license type", licenseTypes.size)) : ( localize(6349, "Similar code found with {0} license types", licenseTypes.size));
+    const label = licenseTypes.size === 1 ? ( localize(6900, "Similar code found with 1 license type", licenseTypes.size)) : ( localize(6901, "Similar code found with {0} license types", licenseTypes.size));
     return label;
 }
 function serializeSendOptions(options) {

package/vscode/src/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatQuestionCarouselData.d.ts

@@ -0,0 +1,20 @@
+import { DeferredPromise } from "../../../../../../base/common/async.js";
+import { IChatQuestion, IChatQuestionCarousel } from "../../chatService/chatService.js";
+/**
+ * Runtime representation of a question carousel with a {@link DeferredPromise}
+ * that is resolved when the user submits answers. {@link toJSON} strips the
+ * completion so only serialisable data is persisted.
+ */
+export declare class ChatQuestionCarouselData implements IChatQuestionCarousel {
+    questions: IChatQuestion[];
+    allowSkip: boolean;
+    resolveId?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+    isUsed?: boolean | undefined;
+    readonly kind: "questionCarousel";
+    readonly completion: DeferredPromise<{
+        answers: Record<string, unknown> | undefined;
+    }>;
+    constructor(questions: IChatQuestion[], allowSkip: boolean, resolveId?: string | undefined, data?: Record<string, unknown> | undefined, isUsed?: boolean | undefined);
+    toJSON(): IChatQuestionCarousel;
+}

package/vscode/src/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatQuestionCarouselData.js

@@ -0,0 +1,26 @@
+
+import { DeferredPromise } from '../../../../../../base/common/async.js';
+
+class ChatQuestionCarouselData {
+    constructor(questions, allowSkip, resolveId, data, isUsed) {
+        this.questions = questions;
+        this.allowSkip = allowSkip;
+        this.resolveId = resolveId;
+        this.data = data;
+        this.isUsed = isUsed;
+        this.kind = "questionCarousel";
+        this.completion = ( new DeferredPromise());
+    }
+    toJSON() {
+        return {
+            kind: this.kind,
+            questions: this.questions,
+            allowSkip: this.allowSkip,
+            resolveId: this.resolveId,
+            data: this.data,
+            isUsed: this.isUsed
+        };
+    }
+}
+
+export { ChatQuestionCarouselData };

package/vscode/src/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatToolInvocation.d.ts

@@ -0,0 +1,71 @@
+import { IMarkdownString } from "../../../../../../base/common/htmlContent.js";
+import { IObservable } from "../../../../../../base/common/observable.js";
+import { ConfirmedReason, IChatExtensionsContent, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, IChatToolInvocation, IChatToolInvocationSerialized, ToolConfirmKind, type IChatTerminalToolInvocationData } from "../../chatService/chatService.js";
+import { IPreparedToolInvocation, IToolConfirmationMessages, IToolData, IToolProgressStep, IToolResult, ToolDataSource } from "../../tools/languageModelToolsService.js";
+export interface IStreamingToolCallOptions {
+    toolCallId: string;
+    toolId: string;
+    toolData: IToolData;
+    subagentInvocationId?: string;
+    chatRequestId?: string;
+}
+export declare class ChatToolInvocation implements IChatToolInvocation {
+    readonly toolCallId: string;
+    readonly kind: "toolInvocation";
+    invocationMessage: string | IMarkdownString;
+    readonly originMessage: string | IMarkdownString | undefined;
+    pastTenseMessage: string | IMarkdownString | undefined;
+    confirmationMessages: IToolConfirmationMessages | undefined;
+    presentation: IPreparedToolInvocation["presentation"];
+    readonly toolId: string;
+    source: ToolDataSource;
+    readonly subAgentInvocationId: string | undefined;
+    parameters: unknown;
+    generatedTitle?: string;
+    readonly chatRequestId?: string;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData;
+    private readonly _progress;
+    private readonly _state;
+    private readonly _partialInput;
+    private readonly _streamingMessage;
+    get state(): IObservable<IChatToolInvocation.State>;
+    /**
+     * Create a tool invocation in streaming state.
+     * Use this when the tool call is beginning to stream partial input from the LM.
+     */
+    static createStreaming(options: IStreamingToolCallOptions): ChatToolInvocation;
+    /**
+     * Create a tool invocation already in cancelled state.
+     * Use this when a hook denies tool execution before it even starts.
+     */
+    static createCancelled(options: IStreamingToolCallOptions, parameters: unknown, reason: ToolConfirmKind.Denied | ToolConfirmKind.Skipped, reasonMessage?: string | IMarkdownString): ChatToolInvocation;
+    constructor(preparedInvocation: IPreparedToolInvocation | undefined, toolData: IToolData, toolCallId: string, subAgentInvocationId: string | undefined, parameters: unknown, startOptions?: {
+        startInStreaming?: boolean;
+        startInCancelled?: boolean;
+        cancelReason?: ToolConfirmKind.Denied | ToolConfirmKind.Skipped;
+        cancelReasonMessage?: string | IMarkdownString;
+    }, chatRequestId?: string);
+    /**
+     * Update the partial input observable during streaming.
+     */
+    updatePartialInput(input: unknown): void;
+    /**
+     * Update the streaming message (from handleToolStream).
+     */
+    updateStreamingMessage(message: string | IMarkdownString): void;
+    /**
+     * Cancel a streaming invocation directly (e.g., when preToolUse hook denies).
+     * Only works when in Streaming state.
+     * @returns true if the cancellation was applied, false if not in streaming state
+     */
+    cancelFromStreaming(reason: ToolConfirmKind.Denied | ToolConfirmKind.Skipped, reasonMessage?: string | IMarkdownString): boolean;
+    /**
+     * Transition from streaming state to prepared/executing state.
+     * Called when the full tool call is ready.
+     */
+    transitionFromStreaming(preparedInvocation: IPreparedToolInvocation | undefined, parameters: unknown, autoConfirmed: ConfirmedReason | undefined): void;
+    private _setCompleted;
+    didExecuteTool(result: IToolResult | undefined, final?: boolean, checkIfResultAutoApproved?: () => Promise<ConfirmedReason | undefined>): Promise<IChatToolInvocation.State>;
+    acceptProgress(step: IToolProgressStep): void;
+    toJSON(): IChatToolInvocationSerialized;
+}

package/vscode/src/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatToolInvocation.js

@@ -0,0 +1,298 @@
+
+import { encodeBase64 } from '../../../../../../base/common/buffer.js';
+import '../../../../../../base/common/observableInternal/index.js';
+import { localize } from '../../../../../../nls.js';
+import { ToolConfirmKind, IChatToolInvocation } from '../../chatService/chatService.js';
+import { isToolResultOutputDetails } from '../../tools/languageModelToolsService.js';
+import { observableValue } from '../../../../../../base/common/observableInternal/observables/observableValue.js';
+
+class ChatToolInvocation {
+    get state() {
+        return this._state;
+    }
+    static createStreaming(options) {
+        return ( new ChatToolInvocation(
+            undefined,
+            options.toolData,
+            options.toolCallId,
+            options.subagentInvocationId,
+            undefined,
+            {
+                startInStreaming: true
+            },
+            options.chatRequestId
+        ));
+    }
+    static createCancelled(options, parameters, reason, reasonMessage) {
+        return ( new ChatToolInvocation(
+            undefined,
+            options.toolData,
+            options.toolCallId,
+            options.subagentInvocationId,
+            parameters,
+            {
+                startInCancelled: true,
+                cancelReason: reason,
+                cancelReasonMessage: reasonMessage
+            },
+            options.chatRequestId
+        ));
+    }
+    constructor(
+        preparedInvocation,
+        toolData,
+        toolCallId,
+        subAgentInvocationId,
+        parameters,
+        startOptions = {},
+        chatRequestId
+    ) {
+        this.toolCallId = toolCallId;
+        this.kind = "toolInvocation";
+        this._progress = observableValue(this, {
+            progress: 0
+        });
+        this._partialInput = observableValue(this, undefined);
+        this._streamingMessage = observableValue(this, undefined);
+        let defaultMessage = "";
+        if (startOptions.startInStreaming) {
+            defaultMessage = ( localize(6902, "Using \"{0}\"", toolData.displayName));
+        } else if (startOptions.startInCancelled) {
+            defaultMessage = startOptions.cancelReasonMessage ?? ( localize(6903, "Tool \"{0}\" was denied", toolData.displayName));
+        }
+        this.invocationMessage = preparedInvocation?.invocationMessage ?? defaultMessage;
+        this.pastTenseMessage = preparedInvocation?.pastTenseMessage;
+        this.originMessage = preparedInvocation?.originMessage;
+        this.confirmationMessages = preparedInvocation?.confirmationMessages;
+        this.presentation = preparedInvocation?.presentation;
+        this.toolSpecificData = preparedInvocation?.toolSpecificData;
+        this.toolId = toolData.id;
+        this.source = toolData.source;
+        this.subAgentInvocationId = subAgentInvocationId;
+        this.parameters = parameters;
+        this.chatRequestId = chatRequestId;
+        if (startOptions.startInCancelled) {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.Cancelled,
+                reason: startOptions.cancelReason ?? ToolConfirmKind.Denied,
+                reasonMessage: startOptions.cancelReasonMessage,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            });
+        } else if (startOptions.startInStreaming) {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.Streaming,
+                partialInput: this._partialInput,
+                streamingMessage: this._streamingMessage
+            });
+        } else if (!this.confirmationMessages?.title) {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.Executing,
+                confirmed: {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: this.confirmationMessages?.confirmationNotNeededReason
+                },
+                progress: this._progress,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            });
+        } else {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.WaitingForConfirmation,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages,
+                confirm: reason => {
+                    if (reason.type === ToolConfirmKind.Denied || reason.type === ToolConfirmKind.Skipped) {
+                        this._state.set({
+                            type: IChatToolInvocation.StateKind.Cancelled,
+                            reason: reason.type,
+                            parameters: this.parameters,
+                            confirmationMessages: this.confirmationMessages
+                        }, undefined);
+                    } else {
+                        this._state.set({
+                            type: IChatToolInvocation.StateKind.Executing,
+                            confirmed: reason,
+                            progress: this._progress,
+                            parameters: this.parameters,
+                            confirmationMessages: this.confirmationMessages
+                        }, undefined);
+                    }
+                }
+            });
+        }
+    }
+    updatePartialInput(input) {
+        if (this._state.get().type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        this._partialInput.set(input, undefined);
+    }
+    updateStreamingMessage(message) {
+        const state = this._state.get();
+        if (state.type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        this._streamingMessage.set(message, undefined);
+    }
+    cancelFromStreaming(reason, reasonMessage) {
+        const currentState = this._state.get();
+        if (currentState.type !== IChatToolInvocation.StateKind.Streaming) {
+            return false;
+        }
+        this._state.set({
+            type: IChatToolInvocation.StateKind.Cancelled,
+            reason: reason,
+            reasonMessage: reasonMessage,
+            parameters: this.parameters,
+            confirmationMessages: this.confirmationMessages
+        }, undefined);
+        return true;
+    }
+    transitionFromStreaming(preparedInvocation, parameters, autoConfirmed) {
+        const currentState = this._state.get();
+        if (currentState.type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        const lastStreamingMessage = this._streamingMessage.get();
+        if (lastStreamingMessage && !preparedInvocation?.invocationMessage) {
+            this.invocationMessage = lastStreamingMessage;
+        }
+        this.parameters = parameters;
+        if (preparedInvocation) {
+            if (preparedInvocation.invocationMessage) {
+                this.invocationMessage = preparedInvocation.invocationMessage;
+            }
+            this.pastTenseMessage = preparedInvocation.pastTenseMessage;
+            this.confirmationMessages = preparedInvocation.confirmationMessages;
+            this.presentation = preparedInvocation.presentation;
+            this.toolSpecificData = preparedInvocation.toolSpecificData;
+        }
+        const confirm = reason => {
+            if (reason.type === ToolConfirmKind.Denied || reason.type === ToolConfirmKind.Skipped) {
+                this._state.set({
+                    type: IChatToolInvocation.StateKind.Cancelled,
+                    reason: reason.type,
+                    parameters: this.parameters,
+                    confirmationMessages: this.confirmationMessages
+                }, undefined);
+            } else {
+                this._state.set({
+                    type: IChatToolInvocation.StateKind.Executing,
+                    confirmed: reason,
+                    progress: this._progress,
+                    parameters: this.parameters,
+                    confirmationMessages: this.confirmationMessages
+                }, undefined);
+            }
+        };
+        if (autoConfirmed) {
+            confirm(autoConfirmed);
+        } else if (!this.confirmationMessages?.title) {
+            this._state.set({
+                type: IChatToolInvocation.StateKind.Executing,
+                confirmed: {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: this.confirmationMessages?.confirmationNotNeededReason
+                },
+                progress: this._progress,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            }, undefined);
+        } else {
+            this._state.set({
+                type: IChatToolInvocation.StateKind.WaitingForConfirmation,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages,
+                confirm
+            }, undefined);
+        }
+    }
+    _setCompleted(result, postConfirmed) {
+        if (postConfirmed && (postConfirmed.type === ToolConfirmKind.Denied || postConfirmed.type === ToolConfirmKind.Skipped)) {
+            this._state.set({
+                type: IChatToolInvocation.StateKind.Cancelled,
+                reason: postConfirmed.type,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            }, undefined);
+            return;
+        }
+        this._state.set({
+            type: IChatToolInvocation.StateKind.Completed,
+            confirmed: IChatToolInvocation.executionConfirmedOrDenied(this) || {
+                type: ToolConfirmKind.ConfirmationNotNeeded
+            },
+            resultDetails: result?.toolResultDetails,
+            postConfirmed,
+            contentForModel: result?.content || [],
+            parameters: this.parameters,
+            confirmationMessages: this.confirmationMessages
+        }, undefined);
+    }
+    async didExecuteTool(result, final, checkIfResultAutoApproved) {
+        if (result?.toolResultMessage) {
+            this.pastTenseMessage = result.toolResultMessage;
+        } else if (this._progress.get().message) {
+            this.pastTenseMessage = this._progress.get().message;
+        }
+        if (this.confirmationMessages?.confirmResults && !result?.toolResultError && result?.confirmResults !== false && !final) {
+            const autoApproved = await checkIfResultAutoApproved?.();
+            if (autoApproved) {
+                this._setCompleted(result, autoApproved);
+            } else {
+                this._state.set({
+                    type: IChatToolInvocation.StateKind.WaitingForPostApproval,
+                    confirmed: IChatToolInvocation.executionConfirmedOrDenied(this) || {
+                        type: ToolConfirmKind.ConfirmationNotNeeded
+                    },
+                    resultDetails: result?.toolResultDetails,
+                    contentForModel: result?.content || [],
+                    confirm: reason => this._setCompleted(result, reason),
+                    parameters: this.parameters,
+                    confirmationMessages: this.confirmationMessages
+                }, undefined);
+            }
+        } else {
+            this._setCompleted(result);
+        }
+        return this._state.get();
+    }
+    acceptProgress(step) {
+        const prev = this._progress.get();
+        this._progress.set({
+            progress: step.progress || prev.progress || 0,
+            message: step.message
+        }, undefined);
+    }
+    toJSON() {
+        const waitingForPostApproval = this.state.get().type === IChatToolInvocation.StateKind.WaitingForPostApproval;
+        const details = waitingForPostApproval ? undefined : IChatToolInvocation.resultDetails(this);
+        return {
+            kind: "toolInvocationSerialized",
+            presentation: this.presentation,
+            invocationMessage: this.invocationMessage,
+            pastTenseMessage: this.pastTenseMessage,
+            originMessage: this.originMessage,
+            isConfirmed: waitingForPostApproval ? {
+                type: ToolConfirmKind.Skipped
+            } : IChatToolInvocation.executionConfirmedOrDenied(this),
+            isComplete: true,
+            source: this.source,
+            resultDetails: isToolResultOutputDetails(details) ? {
+                output: {
+                    type: "data",
+                    mimeType: details.output.mimeType,
+                    base64Data: encodeBase64(details.output.value)
+                }
+            } : details,
+            toolSpecificData: this.toolSpecificData,
+            toolCallId: this.toolCallId,
+            toolId: this.toolId,
+            subAgentInvocationId: this.subAgentInvocationId,
+            generatedTitle: this.generatedTitle
+        };
+    }
+}
+
+export { ChatToolInvocation };

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

@@ -2,6 +2,7 @@ import { URI } from "../../../../../base/common/uri.js";
 export declare namespace LocalChatSessionUri {
     const scheme = "vscode-chat-session";
     function forSession(sessionId: string): URI;
+    function getNewSessionUri(): URI;
     function parseLocalSessionId(resource: URI): string | undefined;
     function isLocalSession(resource: URI): boolean;
 }

package/vscode/src/vs/workbench/contrib/chat/common/model/chatUri.js

@@ -16,6 +16,11 @@ var LocalChatSessionUri;
         }));
     }
     LocalChatSessionUri.forSession = forSession;
+    function getNewSessionUri() {
+        const handle = Math.floor(Math.random() * 1e9);
+        return forSession(`chat-${handle}`);
+    }
+    LocalChatSessionUri.getNewSessionUri = getNewSessionUri;
     function parseLocalSessionId(resource) {
         const parsed = parse(resource);
         return parsed?.chatSessionType === localChatSessionType ? parsed.sessionId : undefined;