@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -1,4 +1,5 @@
 import { DeferredPromise } from "../../../../../../base/common/async.js";
+import { Event } from "../../../../../../base/common/event.js";
 import { UriComponents } from "../../../../../../base/common/uri.js";
 import { IChatPlanApprovalAction, IChatPlanReview, IChatPlanReviewResult } from "../../chatService/chatService.js";
 import { ToolDataSource } from "../../tools/languageModelToolsService.js";
@@ -17,11 +18,14 @@ export declare class ChatPlanReviewData implements IChatPlanReview {
     data?: IChatPlanReviewResult | undefined;
     isUsed?: boolean | undefined;
     source?: ToolDataSource | undefined;
+    isOutdated?: boolean | undefined;
     readonly kind: "planReview";
     readonly completion: DeferredPromise<IChatPlanReviewResult | undefined>;
+    private readonly _onDidDismiss;
+    readonly onDidDismiss: Event<void>;
     draftFeedback: string | undefined;
     draftCollapsed: boolean | undefined;
-    constructor(title: string, content: string, actions: IChatPlanApprovalAction[], canProvideFeedback: boolean, planUri?: UriComponents | undefined, resolveId?: string | undefined, data?: IChatPlanReviewResult | undefined, isUsed?: boolean | undefined, source?: ToolDataSource | undefined);
+    constructor(title: string, content: string, actions: IChatPlanApprovalAction[], canProvideFeedback: boolean, planUri?: UriComponents | undefined, resolveId?: string | undefined, data?: IChatPlanReviewResult | undefined, isUsed?: boolean | undefined, source?: ToolDataSource | undefined, isOutdated?: boolean | undefined);
     /** Dismiss without a user choice (e.g. the response was cancelled). */
     dismiss(): void;
     toJSON(): IChatPlanReview;

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

@@ -1,5 +1,6 @@
 
 import { DeferredPromise } from '../../../../../../base/common/async.js';
+import { Emitter } from '../../../../../../base/common/event.js';
 
 class ChatPlanReviewData {
     constructor(
@@ -11,7 +12,8 @@ class ChatPlanReviewData {
         resolveId,
         data,
         isUsed,
-        source
+        source,
+        isOutdated
     ) {
         this.title = title;
         this.content = content;
@@ -22,8 +24,11 @@ class ChatPlanReviewData {
         this.data = data;
         this.isUsed = isUsed;
         this.source = source;
+        this.isOutdated = isOutdated;
         this.kind = "planReview";
         this.completion = ( new DeferredPromise());
+        this._onDidDismiss = ( new Emitter());
+        this.onDidDismiss = this._onDidDismiss.event;
     }
     dismiss() {
         if (this.isUsed) {
@@ -33,6 +38,7 @@ class ChatPlanReviewData {
         this.draftFeedback = undefined;
         this.draftCollapsed = undefined;
         void this.completion.complete(undefined);
+        this._onDidDismiss.fire();
     }
     toJSON() {
         return {
@@ -45,6 +51,7 @@ class ChatPlanReviewData {
             resolveId: this.resolveId,
             data: this.data,
             isUsed: this.isUsed,
+            isOutdated: this.isOutdated,
             source: this.source
         };
     }

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

@@ -13,9 +13,10 @@ export declare class ChatQuestionCarouselData implements IChatQuestionCarousel {
     resolveId?: string | undefined;
     data?: IChatQuestionAnswers | undefined;
     isUsed?: boolean | undefined;
-    message?: (string | IMarkdownString) | undefined;
+    message?: string | IMarkdownString | undefined;
     source?: ToolDataSource | undefined;
     terminalId?: string | undefined;
+    answerPresentation?: "conversation" | undefined;
     readonly kind: "questionCarousel";
     readonly completion: DeferredPromise<{
         answers: IChatQuestionAnswers | undefined;
@@ -28,11 +29,17 @@ export declare class ChatQuestionCarouselData implements IChatQuestionCarousel {
      * directly in the associated terminal instead of using the carousel UI.
      */
     dismissedByTerminalInput?: boolean;
+    /**
+     * True when the input was accepted/answered outside the carousel UI, such
+     * as by voice or automatic reply.
+     */
+    answeredExternally?: boolean;
+    autoReply?: boolean;
     /**
      * Marks the carousel as dismissed with the given answers and clears draft
      * state. Safe to call multiple times — subsequent calls are no-ops.
      */
     dismiss(answers: IChatQuestionAnswers | undefined): void;
-    constructor(questions: IChatQuestion[], allowSkip: boolean, resolveId?: string | undefined, data?: IChatQuestionAnswers | undefined, isUsed?: boolean | undefined, message?: (string | IMarkdownString) | undefined, source?: ToolDataSource | undefined, terminalId?: string | undefined);
+    constructor(questions: IChatQuestion[], allowSkip: boolean, resolveId?: string | undefined, data?: IChatQuestionAnswers | undefined, isUsed?: boolean | undefined, message?: string | IMarkdownString | undefined, source?: ToolDataSource | undefined, terminalId?: string | undefined, answerPresentation?: "conversation" | undefined);
     toJSON(): IChatQuestionCarousel;
 }

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

@@ -15,7 +15,17 @@ class ChatQuestionCarouselData {
             answers
         });
     }
-    constructor(questions, allowSkip, resolveId, data, isUsed, message, source, terminalId) {
+    constructor(
+        questions,
+        allowSkip,
+        resolveId,
+        data,
+        isUsed,
+        message,
+        source,
+        terminalId,
+        answerPresentation
+    ) {
         this.questions = questions;
         this.allowSkip = allowSkip;
         this.resolveId = resolveId;
@@ -24,6 +34,7 @@ class ChatQuestionCarouselData {
         this.message = message;
         this.source = source;
         this.terminalId = terminalId;
+        this.answerPresentation = answerPresentation;
         this.kind = "questionCarousel";
         this.completion = ( new DeferredPromise());
     }
@@ -35,9 +46,12 @@ class ChatQuestionCarouselData {
             resolveId: this.resolveId,
             data: this.data,
             isUsed: this.isUsed,
+            answeredExternally: this.answeredExternally,
+            autoReply: this.autoReply,
             message: this.message,
             source: this.source,
-            terminalId: this.terminalId
+            terminalId: this.terminalId,
+            answerPresentation: this.answerPresentation
         };
     }
 }

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

@@ -1,7 +1,7 @@
 import { IMarkdownString } from "../../../../../../base/common/htmlContent.js";
 import { IObservable } from "../../../../../../base/common/observable.js";
 import { ThemeIcon } from "../../../../../../base/common/themables.js";
-import { ConfirmedReason, IChatToolInvocation, IChatToolInvocationSerialized, ToolConfirmKind } from "../../chatService/chatService.js";
+import { ConfirmedReason, IChatToolInvocation, IChatToolInvocationOtherClientData, IChatToolInvocationSerialized, ToolConfirmKind, type IChatMcpAuthenticationRequiredServer } from "../../chatService/chatService.js";
 import { IPreparedToolInvocation, IToolConfirmationMessages, IToolData, IToolProgressStep, IToolResult, ToolDataSource } from "../../tools/languageModelToolsService.js";
 export interface IStreamingToolCallOptions {
     toolCallId: string;
@@ -26,6 +26,7 @@ export declare class ChatToolInvocation implements IChatToolInvocation {
     generatedTitle?: string;
     readonly chatRequestId?: string;
     isAttachedToThinking: boolean;
+    otherClientToolCall?: IChatToolInvocationOtherClientData;
     private _toolSpecificData?;
     private readonly _toolSpecificDataKind;
     readonly toolSpecificDataKind: IObservable<string | undefined>;
@@ -52,6 +53,13 @@ export declare class ChatToolInvocation implements IChatToolInvocation {
         cancelReason?: ToolConfirmKind.Denied | ToolConfirmKind.Skipped;
         cancelReasonMessage?: string | IMarkdownString;
     }, chatRequestId?: string);
+    /**
+     * Shared confirmation handler used by every `WaitingForConfirmation` state
+     * this invocation can enter (initial construction, transition out of
+     * streaming, and re-arming via {@link requestConfirmation}). Denials/skips
+     * cancel; anything else moves to executing.
+     */
+    private _confirm;
     /**
      * Update the partial input observable during streaming.
      */
@@ -66,6 +74,7 @@ export declare class ChatToolInvocation implements IChatToolInvocation {
      * state to trigger autoruns that need to re-read tool metadata.
      */
     notifyToolSpecificDataChanged(): void;
+    updateConfirmationMessages(confirmationMessages: IToolConfirmationMessages): void;
     /**
      * Cancel a streaming invocation directly (e.g., when preToolUse hook denies).
      * Only works when in Streaming state.
@@ -77,8 +86,18 @@ export declare class ChatToolInvocation implements IChatToolInvocation {
      * Called when the full tool call is ready.
      */
     transitionFromStreaming(preparedInvocation: IPreparedToolInvocation | undefined, parameters: unknown, autoConfirmed: ConfirmedReason | undefined): void;
+    /**
+     * Applies locally prepared parameters and presentation without changing an
+     * invocation state already established by an external protocol.
+     */
+    updatePreparedInvocation(preparedInvocation: IPreparedToolInvocation | undefined, parameters: unknown): boolean;
+    private _updatePreparedInvocation;
+    /** Moves an active invocation into confirmation while preserving the same tool card. */
+    requestConfirmation(preparedInvocation: IPreparedToolInvocation): void;
     private _setCompleted;
     didExecuteTool(result: IToolResult | undefined, final?: boolean, checkIfResultAutoApproved?: () => Promise<ConfirmedReason | undefined>): Promise<IChatToolInvocation.State>;
+    setAuthenticationRequired(server: IChatMcpAuthenticationRequiredServer, cancel?: () => void): void;
+    setAuthenticationResolved(): void;
     acceptProgress(step: IToolProgressStep): void;
     toJSON(): IChatToolInvocationSerialized;
 }

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

@@ -69,7 +69,7 @@ class ChatToolInvocation {
         if (startOptions.startInStreaming) {
             defaultMessage = toolData.displayName;
         } else if (startOptions.startInCancelled) {
-            defaultMessage = startOptions.cancelReasonMessage ?? ( localize(8581, "Tool \"{0}\" was denied", toolData.displayName));
+            defaultMessage = startOptions.cancelReasonMessage ?? ( localize(10298, "Tool \"{0}\" was denied", toolData.displayName));
         }
         this.invocationMessage = preparedInvocation?.invocationMessage ?? defaultMessage;
         this.pastTenseMessage = preparedInvocation?.pastTenseMessage;
@@ -113,27 +113,28 @@ class ChatToolInvocation {
                 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);
-                    }
-                }
+                confirm: reason => this._confirm(reason)
             });
         }
     }
+    _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;
@@ -153,6 +154,17 @@ class ChatToolInvocation {
             ...current
         }, undefined);
     }
+    updateConfirmationMessages(confirmationMessages) {
+        const current = this._state.get();
+        if (current.type !== IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            return;
+        }
+        this.confirmationMessages = confirmationMessages;
+        this._state.set({
+            ...current,
+            confirmationMessages
+        }, undefined);
+    }
     cancelFromStreaming(reason, reasonMessage) {
         const currentState = this._state.get();
         if (currentState.type !== IChatToolInvocation.StateKind.Streaming) {
@@ -176,36 +188,9 @@ class ChatToolInvocation {
         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);
-            }
-        };
+        this._updatePreparedInvocation(preparedInvocation, parameters);
         if (autoConfirmed) {
-            confirm(autoConfirmed);
+            this._confirm(autoConfirmed);
         } else if (!this.confirmationMessages?.title) {
             this._state.set({
                 type: IChatToolInvocation.StateKind.Executing,
@@ -222,10 +207,62 @@ class ChatToolInvocation {
                 type: IChatToolInvocation.StateKind.WaitingForConfirmation,
                 parameters: this.parameters,
                 confirmationMessages: this.confirmationMessages,
-                confirm
+                confirm: reason => this._confirm(reason)
             }, undefined);
         }
     }
+    updatePreparedInvocation(preparedInvocation, parameters) {
+        const currentState = this._state.get();
+        if (currentState.type === IChatToolInvocation.StateKind.Streaming || currentState.type === IChatToolInvocation.StateKind.Completed || currentState.type === IChatToolInvocation.StateKind.Cancelled) {
+            return false;
+        }
+        this._updatePreparedInvocation(preparedInvocation, parameters);
+        this._state.set({
+            ...currentState,
+            parameters: this.parameters,
+            confirmationMessages: this.confirmationMessages
+        }, undefined);
+        return true;
+    }
+    _updatePreparedInvocation(preparedInvocation, parameters) {
+        this.parameters = parameters;
+        if (!preparedInvocation) {
+            return;
+        }
+        if (preparedInvocation.invocationMessage) {
+            this.invocationMessage = preparedInvocation.invocationMessage;
+        }
+        this.pastTenseMessage = preparedInvocation.pastTenseMessage;
+        this.confirmationMessages = preparedInvocation.confirmationMessages;
+        this.presentation = preparedInvocation.presentation;
+        this.toolSpecificData = preparedInvocation.toolSpecificData;
+    }
+    requestConfirmation(preparedInvocation) {
+        const currentType = this._state.get().type;
+        if (currentType === IChatToolInvocation.StateKind.Streaming) {
+            this.transitionFromStreaming(preparedInvocation, this.parameters, undefined);
+            return;
+        }
+        if (currentType === IChatToolInvocation.StateKind.Completed || currentType === IChatToolInvocation.StateKind.Cancelled || currentType === IChatToolInvocation.StateKind.WaitingForConfirmation) {
+            return;
+        }
+        if (preparedInvocation.invocationMessage) {
+            this.invocationMessage = preparedInvocation.invocationMessage;
+        }
+        this.pastTenseMessage = preparedInvocation.pastTenseMessage;
+        this.confirmationMessages = preparedInvocation.confirmationMessages;
+        this.presentation = preparedInvocation.presentation;
+        this.toolSpecificData = preparedInvocation.toolSpecificData;
+        if (!this.confirmationMessages?.title) {
+            return;
+        }
+        this._state.set({
+            type: IChatToolInvocation.StateKind.WaitingForConfirmation,
+            parameters: this.parameters,
+            confirmationMessages: this.confirmationMessages,
+            confirm: reason => this._confirm(reason)
+        }, undefined);
+    }
     _setCompleted(result, postConfirmed) {
         if (postConfirmed && (postConfirmed.type === ToolConfirmKind.Denied || postConfirmed.type === ToolConfirmKind.Skipped)) {
             this._state.set({
@@ -249,6 +286,13 @@ class ChatToolInvocation {
         }, undefined);
     }
     async didExecuteTool(result, final, checkIfResultAutoApproved) {
+        const currentState = this._state.get();
+        if (currentState.type === IChatToolInvocation.StateKind.Completed || currentState.type === IChatToolInvocation.StateKind.Cancelled) {
+            return currentState;
+        }
+        if (result?.toolSpecificData) {
+            this.toolSpecificData = result.toolSpecificData;
+        }
         if (result?.toolResultMessage) {
             this.pastTenseMessage = result.toolResultMessage;
         } else if (this._progress.get().message) {
@@ -276,6 +320,33 @@ class ChatToolInvocation {
         }
         return this._state.get();
     }
+    setAuthenticationRequired(server, cancel = () => {}) {
+        const state = this._state.get();
+        if (state.type !== IChatToolInvocation.StateKind.Executing && state.type !== IChatToolInvocation.StateKind.WaitingForAuthentication) {
+            return;
+        }
+        this._state.set({
+            type: IChatToolInvocation.StateKind.WaitingForAuthentication,
+            server,
+            cancel: state.type === IChatToolInvocation.StateKind.WaitingForAuthentication ? state.cancel : cancel,
+            confirmed: state.confirmed,
+            parameters: state.parameters,
+            confirmationMessages: state.confirmationMessages
+        }, undefined);
+    }
+    setAuthenticationResolved() {
+        const state = this._state.get();
+        if (state.type !== IChatToolInvocation.StateKind.WaitingForAuthentication) {
+            return;
+        }
+        this._state.set({
+            type: IChatToolInvocation.StateKind.Executing,
+            confirmed: state.confirmed,
+            progress: this._progress,
+            parameters: state.parameters,
+            confirmationMessages: state.confirmationMessages
+        }, undefined);
+    }
     acceptProgress(step) {
         const prev = this._progress.get();
         this._progress.set({
@@ -304,7 +375,7 @@ class ChatToolInvocation {
                     base64Data: encodeBase64(details.output.value)
                 }
             } : details,
-            toolSpecificData: this.toolSpecificData,
+            toolSpecificData: this.toolSpecificData?.kind === "automationConfiguration" ? undefined : this.toolSpecificData,
             toolCallId: this.toolCallId,
             toolId: this.toolId,
             subAgentInvocationId: this.subAgentInvocationId,

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

@@ -12,6 +12,10 @@ export declare namespace LocalChatSessionUri {
  * This exists mainly for backwards compatibility with existing code that uses string IDs in telemetry and storage.
  */
 export declare function chatSessionResourceToId(resource: URI): string;
+/**
+ * Resolves a session resource that must be an immediate child of its storage root.
+ */
+export declare function getChatSessionStorageResource(storageRoot: URI, sessionId: string, suffix?: string): URI;
 /**
  * Extracts the chat session type from a resource URI.
  *
@@ -22,3 +26,9 @@ export declare function chatSessionResourceToId(resource: URI): string;
  */
 export declare function getChatSessionType(resource: URI): string;
 export declare function isUntitledChatSession(resource: URI): boolean;
+/**
+ * Builds a fresh untitled session resource for the given session type. Local
+ * sessions get a new local-session URI; other types get an untitled URI under
+ * their own scheme.
+ */
+export declare function getNewChatSessionResource(sessionType: string): URI;

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

@@ -1,7 +1,9 @@
 
 import { encodeBase64, VSBuffer, decodeBase64 } from '../../../../../base/common/buffer.js';
 import { Schemas } from '../../../../../base/common/network.js';
+import { extUri } from '../../../../../base/common/resources.js';
 import { URI } from '../../../../../base/common/uri.js';
+import { generateUuid } from '../../../../../base/common/uuid.js';
 import { localChatSessionType } from '../chatSessionsService.js';
 
 var LocalChatSessionUri;
@@ -56,6 +58,13 @@ function chatSessionResourceToId(resource) {
     }
     return ( resource.toString());
 }
+function getChatSessionStorageResource(storageRoot, sessionId, suffix = "") {
+    const resource = extUri.joinPath(storageRoot, `${sessionId}${suffix}`);
+    if (!extUri.isEqual(extUri.dirname(resource), storageRoot)) {
+        throw ( new Error(`Invalid chat session ID: ${sessionId}`));
+    }
+    return resource;
+}
 function getChatSessionType(resource) {
     if (resource.scheme === Schemas.vscodeChatEditor) {
         return localChatSessionType;
@@ -68,5 +77,11 @@ function getChatSessionType(resource) {
 function isUntitledChatSession(resource) {
     return resource.path.startsWith("/untitled-");
 }
+function getNewChatSessionResource(sessionType) {
+    return sessionType === localChatSessionType ? LocalChatSessionUri.getNewSessionUri() : ( URI.from({
+        scheme: sessionType,
+        path: `/untitled-${generateUuid()}`
+    }));
+}
 
-export { LocalChatSessionUri, chatSessionResourceToId, getChatSessionType, isUntitledChatSession };
+export { LocalChatSessionUri, chatSessionResourceToId, getChatSessionStorageResource, getChatSessionType, getNewChatSessionResource, isUntitledChatSession };

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

@@ -6,7 +6,7 @@ import { ThemeIcon } from "../../../../../base/common/themables.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
 import { IChatRequestVariableEntry } from "../attachments/chatVariableEntries.js";
-import { ChatAgentVoteDirection, ChatRequestQueueKind, IChatCodeCitation, IChatContentReference, IChatDisabledClaudeHooksPart, IChatFollowup, IChatMcpAuthenticationRequired, IChatMcpServersStarting, IChatMcpServersStartingSlow, IChatPlanReview, IChatProgressMessage, IChatQuestionCarousel, IChatResponseErrorDetails, IChatTask, IChatUsage, IChatUsedContext } from "../chatService/chatService.js";
+import { ChatAgentVoteDirection, ChatRequestQueueKind, IChatCodeCitation, IChatContentReference, IChatDisabledClaudeHooksPart, IChatFollowup, IChatMcpAuthenticationRequired, IChatMcpServersStarting, IChatMcpServersStartingSlow, IChatPlanReview, IChatProgressMessage, IChatQuestionCarousel, IChatResponseErrorDetails, IChatUsage, IChatUsedContext } from "../chatService/chatService.js";
 import { IChatAgentCommand, IChatAgentData, IChatAgentResult } from "../participants/chatAgents.js";
 import { IChatAgentNameService } from "../participants/chatAgents.service.js";
 import { IParsedChatRequest } from "../requestParser/chatParserTypes.js";
@@ -15,6 +15,17 @@ import { IChatStreamStats } from "./chatStreamStats.js";
 export declare function isRequestVM(item: unknown): item is IChatRequestViewModel;
 export declare function isResponseVM(item: unknown): item is IChatResponseViewModel;
 export declare function isPendingDividerVM(item: unknown): item is IChatPendingDividerViewModel;
+interface IChatViewModelItemWithPendingState {
+    readonly id: string;
+    readonly kind?: string;
+    readonly pendingKind?: ChatRequestQueueKind;
+}
+/**
+ * The active response that content streams into: the last non-pending item, ignoring
+ * trailing queued/steering rows (and their dividers). Falls back to the last item when
+ * everything is pending.
+ */
+export declare function getStickyScrollTargetItem<T extends IChatViewModelItemWithPendingState>(items: readonly T[]): T | undefined;
 export declare function isChatTreeItem(item: unknown): item is IChatRequestViewModel | IChatResponseViewModel;
 export declare function assertIsResponseVM(item: unknown): asserts item is IChatResponseViewModel;
 export type IChatViewModelChangeEvent = IChatAddRequestEvent | IChangePlaceholderEvent | IChatSessionInitEvent | IChatSetHiddenEvent | null;
@@ -57,8 +68,11 @@ export interface IChatRequestViewModel {
     readonly contentReferences?: ReadonlyArray<IChatContentReference>;
     readonly confirmation?: string;
     readonly shouldBeRemovedOnSend: IChatRequestDisablement | undefined;
+    readonly isHiddenFromTranscript: boolean;
+    readonly isRequestHiddenFromTranscript: boolean;
     readonly isComplete: boolean;
     readonly isCompleteAddedRequest: boolean;
+    readonly isTerminalCommand: boolean;
     readonly slashCommand: IChatAgentCommand | undefined;
     readonly agentOrSlashCommandDetected: boolean;
     readonly shouldBeBlocked: IObservable<boolean>;
@@ -66,41 +80,13 @@ export interface IChatRequestViewModel {
     readonly modelId?: string;
     readonly resolvedModelId?: string;
     readonly timestamp: number;
+    readonly requestTimestamp: number | undefined;
     /** The kind of pending request, or undefined if not pending */
     readonly pendingKind?: ChatRequestQueueKind;
     readonly isSystemInitiated?: boolean;
+    readonly requestSource?: IChatRequestModel["requestSource"];
     readonly systemInitiatedLabel?: string;
-}
-export interface IChatResponseMarkdownRenderData {
-    renderedWordCount: number;
-    lastRenderTime: number;
-    isFullyRendered: boolean;
-    originalMarkdown: IMarkdownString;
-}
-export interface IChatResponseMarkdownRenderData2 {
-    renderedWordCount: number;
-    lastRenderTime: number;
-    isFullyRendered: boolean;
-    originalMarkdown: IMarkdownString;
-}
-export interface IChatProgressMessageRenderData {
-    progressMessage: IChatProgressMessage;
-    /**
-     * Indicates whether this is part of a group of progress messages that are at the end of the response.
-     * (Not whether this particular item is the very last one in the response).
-     * Need to re-render and add to partsToRender when this changes.
-     */
-    isAtEndOfResponse: boolean;
-    /**
-     * Whether this progress message the very last item in the response.
-     * Need to re-render to update spinner vs check when this changes.
-     */
-    isLast: boolean;
-}
-export interface IChatTaskRenderData {
-    task: IChatTask;
-    isSettled: boolean;
-    progressLength: number;
+    readonly origin?: IChatRequestModel["origin"];
 }
 export interface IChatResponseRenderData {
     renderedParts: IChatRendererContent[];
@@ -120,22 +106,6 @@ export interface IChatReferences {
 export interface IChatWorkingProgress {
     kind: "working";
     content?: IMarkdownString;
-    /**
-     * When present, the working progress will show elapsed time and token usage.
-     */
-    state?: IChatWorkingProgressState;
-}
-export interface IChatWorkingProgressState {
-    /** The confirmation-adjusted timestamp observable for computing elapsed time */
-    readonly confirmationAdjustedTimestamp: IObservable<number>;
-    /** Observable for tracking completion token count as it arrives */
-    readonly completionTokenCountObs: IObservable<number | undefined>;
-    /** Whether the response is complete (for past-tense display) */
-    readonly isComplete: boolean;
-    /** The completedAt timestamp for completed responses */
-    readonly completedAt?: number;
-    /** Pre-computed elapsed generation time in ms (reliable for restored sessions) */
-    readonly elapsedMs?: number;
 }
 /**
  * Content type for citations used during rendering, not in the model
@@ -158,6 +128,7 @@ export interface IChatTurnPillsPart {
     readonly kind: "turnPills";
     readonly requestId: string;
     readonly sessionResource: URI;
+    readonly isLastTurn: boolean;
 }
 /**
  * Type for content parts rendered by IChatListRenderer (not necessarily in the model)
@@ -184,6 +155,8 @@ export interface IChatResponseViewModel {
     readonly isComplete: boolean;
     readonly isCanceled: boolean;
     readonly isStale: boolean;
+    /** Whether this is the last row in the transcript. */
+    readonly isLast: boolean;
     readonly vote: ChatAgentVoteDirection | undefined;
     readonly replyFollowups?: IChatFollowup[];
     readonly errorDetails?: IChatResponseErrorDetails;
@@ -193,7 +166,9 @@ export interface IChatResponseViewModel {
     readonly usageObs: IObservable<IChatUsage | undefined>;
     readonly completionTokenCountObs: IObservable<number | undefined>;
     readonly shouldBeRemovedOnSend: IChatRequestDisablement | undefined;
+    readonly isHiddenFromTranscript: boolean;
     readonly isCompleteAddedRequest: boolean;
+    readonly isTerminalCommand: boolean;
     renderData?: IChatResponseRenderData;
     currentRenderedHeight: number | undefined;
     setVote(vote: ChatAgentVoteDirection): void;
@@ -241,39 +216,6 @@ export declare class ChatViewModel extends Disposable implements IChatViewModel
     setEditing(editing: IChatRequestViewModel | undefined): void;
     dispose(): void;
 }
-export declare class ChatRequestViewModel implements IChatRequestViewModel {
-    private readonly _model;
-    private readonly _pendingKind?;
-    get id(): string;
-    /**
-     * An ID that changes when the request should be re-rendered.
-     */
-    get dataId(): string;
-    get sessionResource(): URI;
-    get username(): string;
-    get avatarIcon(): ThemeIcon;
-    get message(): IParsedChatRequest;
-    get messageText(): string;
-    get attempt(): number;
-    get variables(): readonly IChatRequestVariableEntry[];
-    get contentReferences(): readonly IChatContentReference[] | undefined;
-    get confirmation(): string | undefined;
-    get isComplete(): boolean;
-    get isCompleteAddedRequest(): boolean;
-    get shouldBeRemovedOnSend(): IChatRequestDisablement | undefined;
-    get shouldBeBlocked(): IObservable<boolean>;
-    get slashCommand(): IChatAgentCommand | undefined;
-    get agentOrSlashCommandDetected(): boolean;
-    currentRenderedHeight: number | undefined;
-    get attachedContext(): IChatRequestVariableEntry[] | undefined;
-    get modelId(): string | undefined;
-    get resolvedModelId(): string | undefined;
-    get timestamp(): number;
-    get pendingKind(): ChatRequestQueueKind | undefined;
-    get isSystemInitiated(): boolean | undefined;
-    get systemInitiatedLabel(): string | undefined;
-    constructor(_model: IChatRequestModel, _pendingKind?: ChatRequestQueueKind | undefined);
-}
 export declare class ChatResponseViewModel extends Disposable implements IChatResponseViewModel {
     private readonly _model;
     readonly session: IChatViewModel;
@@ -299,7 +241,9 @@ export declare class ChatResponseViewModel extends Disposable implements IChatRe
     get isCanceled(): boolean;
     get shouldBeBlocked(): IObservable<boolean>;
     get shouldBeRemovedOnSend(): IChatRequestDisablement | undefined;
+    get isHiddenFromTranscript(): boolean;
     get isCompleteAddedRequest(): boolean;
+    get isTerminalCommand(): boolean;
     get replyFollowups(): IChatFollowup[] | undefined;
     get result(): IChatAgentResult | undefined;
     get errorDetails(): IChatResponseErrorDetails | undefined;
@@ -324,3 +268,4 @@ export declare class ChatResponseViewModel extends Disposable implements IChatRe
     setVote(vote: ChatAgentVoteDirection): void;
     setEditApplied(edit: IChatTextEditGroup, editCount: number): void;
 }
+export {};