@codingame/monaco-vscode-api 26.2.2 → 28.0.0

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

@@ -10,9 +10,9 @@ import { EditSuggestionId } from "../../../../../editor/common/textModelEditSour
 import { ILogService } from "../../../../../platform/log/common/log.service.js";
 import { ICellEditOperation } from "../../../notebook/common/notebookCommon.js";
 import { ChatRequestToolReferenceEntry, IChatRequestVariableEntry } from "../attachments/chatVariableEntries.js";
-import { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatRequestQueueKind, IChatAgentMarkdownContentWithVulnerability, IChatClearToPreviousToolInvocation, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatDisabledClaudeHooksPart, IChatEditingSessionAction, IChatElicitationRequest, IChatElicitationRequestSerialized, IChatExtensionsContent, IChatFollowup, IChatHookPart, IChatLocationData, IChatMarkdownContent, IChatMcpServersStarting, IChatMcpServersStartingSerialized, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatProgress, IChatProgressMessage, IChatPullRequestContent, IChatQuestionCarousel, IChatResponseCodeblockUriPart, IChatResponseProgressFileTreeData, IChatSendRequestOptions, IChatSessionContext, IChatSessionTiming, IChatTask, IChatTaskSerialized, IChatTextEdit, IChatThinkingPart, IChatToolInvocation, IChatToolInvocationSerialized, IChatTreeData, IChatUndoStop, IChatUsedContext, IChatWarningMessage, IChatWorkspaceEdit, ResponseModelState } from "../chatService/chatService.js";
+import { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatRequestQueueKind, IChatAgentMarkdownContentWithVulnerability, IChatClearToPreviousToolInvocation, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatDisabledClaudeHooksPart, IChatEditingSessionAction, IChatElicitationRequest, IChatElicitationRequestSerialized, IChatExternalToolInvocationUpdate, IChatExtensionsContent, IChatFollowup, IChatHookPart, IChatLocationData, IChatMarkdownContent, IChatMcpServersStarting, IChatMcpServersStartingSerialized, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatProgress, IChatProgressMessage, IChatPullRequestContent, IChatQuestionCarousel, IChatResponseCodeblockUriPart, IChatResponseProgressFileTreeData, IChatSendRequestOptions, IChatSessionContext, IChatSessionTiming, IChatTask, IChatTaskSerialized, IChatTextEdit, IChatThinkingPart, IChatToolInvocation, IChatToolInvocationSerialized, IChatTreeData, IChatUndoStop, IChatUsage, IChatUsedContext, IChatWarningMessage, IChatWorkspaceEdit, ResponseModelState } from "../chatService/chatService.js";
 import { IChatService } from "../chatService/chatService.service.js";
-import { ChatAgentLocation, ChatModeKind } from "../constants.js";
+import { ChatAgentLocation, ChatModeKind, ChatPermissionLevel } from "../constants.js";
 import { IChatEditingSession } from "../editing/chatEditingService.js";
 import { IChatEditingService } from "../editing/chatEditingService.service.js";
 import { ILanguageModelChatMetadata, ILanguageModelChatMetadataAndIdentifier } from "../languageModels.js";
@@ -183,13 +183,15 @@ export interface IChatResponseModel {
     readonly voteDownReason: ChatAgentVoteDownReason | undefined;
     readonly followups?: IChatFollowup[] | undefined;
     readonly result?: IChatAgentResult;
+    readonly usage?: IChatUsage;
     readonly codeBlockInfos: ICodeBlockInfo[] | undefined;
     initializeCodeBlockInfos(codeBlockInfo: ICodeBlockInfo[]): void;
     addUndoStop(undoStop: IChatUndoStop): void;
     setVote(vote: ChatAgentVoteDirection): void;
     setVoteDownReason(reason: ChatAgentVoteDownReason | undefined): void;
+    setUsage(usage: IChatUsage): void;
     setEditApplied(edit: IChatTextEditGroup, editCount: number): boolean;
-    updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask, quiet?: boolean): void;
+    updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask | IChatExternalToolInvocationUpdate, quiet?: boolean): void;
     /**
      * Adopts any partially-undo {@link response} as the {@link entireResponse}.
      * Only valid when {@link isComplete}. This is needed because otherwise an
@@ -212,13 +214,17 @@ export interface IChatRequestModeInfo {
     isBuiltin: boolean;
     modeInstructions: IChatRequestModeInstructions | undefined;
     modeId: "ask" | "agent" | "edit" | "custom" | "applyCodeBlock" | undefined;
+    modeName?: string;
     applyCodeBlockSuggestionId: EditSuggestionId | undefined;
+    permissionLevel?: ChatPermissionLevel;
 }
 export interface IChatRequestModeInstructions {
+    readonly uri?: URI;
     readonly name: string;
     readonly content: string;
     readonly toolReferences: readonly ChatRequestToolReferenceEntry[];
     readonly metadata?: Record<string, boolean | string | number>;
+    readonly isBuiltin?: boolean;
 }
 export interface IChatRequestModelParameters {
     session: ChatModel;
@@ -300,10 +306,11 @@ export declare class Response extends AbstractResponse implements IDisposable {
     dispose(): void;
     clear(): void;
     clearToPreviousToolInvocation(message?: string): void;
-    updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask, quiet?: boolean): void;
+    updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask | IChatExternalToolInvocationUpdate, quiet?: boolean): void;
     addCitation(citation: IChatCodeCitation): void;
     private _mergeOrPushTextEditGroup;
     private _mergeOrPushNotebookEditGroup;
+    private _handleExternalToolInvocationUpdate;
     protected _updateRepr(quiet?: boolean): void;
 }
 export interface IChatResponseModelParameters {
@@ -348,6 +355,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     private _vote?;
     private _voteDownReason?;
     private _result?;
+    private _usage?;
     private _shouldBeRemovedOnSend;
     readonly isCompleteAddedRequest: boolean;
     private readonly _shouldBeBlocked;
@@ -372,6 +380,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     private _finalizedResponse?;
     get entireResponse(): IResponse;
     get result(): IChatAgentResult | undefined;
+    get usage(): IChatUsage | undefined;
     get username(): string;
     private _followups?;
     get agent(): IChatAgentData | undefined;
@@ -403,7 +412,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     /**
      * Apply a progress update to the actual response content.
      */
-    updateContent(responsePart: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit, quiet?: boolean): void;
+    updateContent(responsePart: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatExternalToolInvocationUpdate, quiet?: boolean): void;
     /**
      * Adds an undo stop at the current position in the stream.
      */
@@ -415,6 +424,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     applyCodeCitation(progress: IChatCodeCitation): void;
     setAgent(agent: IChatAgentData, slashCommand?: IChatAgentCommand): void;
     setResult(result: IChatAgentResult): void;
+    setUsage(usage: IChatUsage): void;
     complete(): void;
     cancel(): void;
     setFollowups(followups: IChatFollowup[] | undefined): void;
@@ -471,6 +481,7 @@ export interface IChatModel extends IDisposable {
     toExport(): IExportableChatData;
     toJSON(): ISerializableChatData;
     readonly contributedChatSession: IChatSessionContext | undefined;
+    setContributedChatSession(session: IChatSessionContext | undefined): void;
     readonly repoData: IExportableRepoData | undefined;
     setRepoData(data: IExportableRepoData | undefined): void;
     readonly onDidChangePendingRequests: Event<void>;
@@ -820,6 +831,11 @@ export declare class ChatModel extends Disposable implements IChatModel {
      * @internal Used by ChatService to dequeue the next pending request
      */
     dequeuePendingRequest(): IChatPendingRequest | undefined;
+    /**
+     * @internal Used by ChatService to dequeue all consecutive steering requests at the front of the queue.
+     * Returns an empty array if the first pending request is not a steering request.
+     */
+    dequeueAllSteeringRequests(): IChatPendingRequest[];
     /**
      * @internal Used by ChatService to clear all pending requests
      */
@@ -863,7 +879,6 @@ export declare class ChatModel extends Disposable implements IChatModel {
         canUseTools: boolean;
         inputState?: ISerializableChatModelInputState;
         resource?: URI;
-        sessionId?: string;
         disableBackgroundKeepAlive?: boolean;
     }, logService: ILogService, chatAgentService: IChatAgentService, chatEditingService: IChatEditingService, chatService: IChatService);
     startEditingSession(isGlobalEditingSession?: boolean, transferFromSession?: IChatEditingSession): void;

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(7011, "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,
+                    7012,
                     "Response cleared due to possible match to public code, retrying with modified prompt."
                 )));
             } else if (progress.reason === ChatResponseClearToPreviousToolInvocationReason.FilteredContentRetry) {
                 this.clearToPreviousToolInvocation(( localize(
-                    6346,
+                    7013,
                     "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(7014, "Approve tool result?");
                     }
                 }
                 if (part.kind === "confirmation" && !part.isUsed) {
                     return part.title;
                 }
+                if (part.kind === "questionCarousel" && !part.isUsed) {
+                    return localize(7015, "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;
@@ -977,6 +1034,16 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
         }
         return request;
     }
+    dequeueAllSteeringRequests() {
+        const steeringRequests = [];
+        while (this._pendingRequests.at(0)?.kind === ChatRequestQueueKind.Steering) {
+            steeringRequests.push(this._pendingRequests.shift());
+        }
+        if (steeringRequests.length > 0) {
+            this._onDidChangePendingRequests.fire();
+        }
+        return steeringRequests;
+    }
     clearPendingRequests() {
         if (this._pendingRequests.length > 0) {
             this._pendingRequests.length = 0;
@@ -1075,8 +1142,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 +1212,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 +1228,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 +1298,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 +1378,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 +1402,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 +1412,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 +1639,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 +1686,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(7016, "Similar code found with 1 license type", licenseTypes.size)) : ( localize(7017, "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,22 @@
+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;
+    }>;
+    draftAnswers: Record<string, unknown> | undefined;
+    draftCurrentIndex: number | 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;
+}