@codingame/monaco-vscode-api 26.1.1 → 26.2.0

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

@@ -21,7 +21,7 @@ import { ILogService } from '../../../../../platform/log/common/log.service.js';
 import { CellUri } from '../../../notebook/common/notebookCommon.js';
 import { IChatRequestVariableEntry, isStringVariableEntry, isImplicitVariableEntry, isStringImplicitContextValue } from '../attachments/chatVariableEntries.js';
 import { migrateLegacyTerminalToolSpecificData } from '../chat.js';
-import { IChatToolInvocation, ChatResponseClearToPreviousToolInvocationReason, ResponseModelState, ElicitationState, isIUsedContext } from '../chatService/chatService.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 { ModifiedFileEntryState } from '../editing/chatEditingService.js';
@@ -32,6 +32,7 @@ import { reviveParsedChatRequest, ChatRequestTextPart } from '../requestParser/c
 import { 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';
 import { observableValueOpts } from '../../../../../base/common/observableInternal/observables/observableValueOpts.js';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
 import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
@@ -181,9 +182,11 @@ class AbstractResponse {
             case "elicitation2":
             case "elicitationSerialized":
             case "thinking":
+            case "hook":
             case "multiDiffData":
             case "mcpServersStarting":
             case "questionCarousel":
+            case "disabledClaudeHooks":
                 continue;
             case "toolInvocation":
             case "toolInvocationSerialized":
@@ -243,7 +246,7 @@ class AbstractResponse {
             blocks.push(currentBlockSegments.join(""));
         }
         if (hasEditGroupsAfterLastClear) {
-            blocks.push(( localize(6246, "Made changes.")));
+            blocks.push(( localize(6344, "Made changes.")));
         }
         return blocks.join("\n\n");
     }
@@ -349,12 +352,12 @@ class Response extends AbstractResponse {
         if (progress.kind === "clearToPreviousToolInvocation") {
             if (progress.reason === ChatResponseClearToPreviousToolInvocationReason.CopyrightContentRetry) {
                 this.clearToPreviousToolInvocation(( localize(
-                    6247,
+                    6345,
                     "Response cleared due to possible match to public code, retrying with modified prompt."
                 )));
             } else if (progress.reason === ChatResponseClearToPreviousToolInvocationReason.FilteredContentRetry) {
                 this.clearToPreviousToolInvocation(( localize(
-                    6248,
+                    6346,
                     "Response cleared due to content safety filters, retrying with modified prompt."
                 )));
             } else {
@@ -622,7 +625,7 @@ class ChatResponseModel extends Disposable {
                         return title ? (isMarkdownString(title) ? title.value : title) : undefined;
                     }
                     if (state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
-                        return localize(6249, "Approve tool result?");
+                        return localize(6347, "Approve tool result?");
                     }
                 }
                 if (part.kind === "confirmation" && !part.isUsed) {
@@ -915,6 +918,71 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
     setRepoData(data) {
         this._repoData = data;
     }
+    getPendingRequests() {
+        return this._pendingRequests;
+    }
+    setPendingRequests(requests) {
+        const existingMap = ( new Map(( this._pendingRequests.map(p => [p.request.id, p]))));
+        const newPending = [];
+        for (const {
+            requestId,
+            kind
+        } of requests) {
+            const existing = existingMap.get(requestId);
+            if (existing) {
+                newPending.push(existing.kind === kind ? existing : {
+                    request: existing.request,
+                    kind,
+                    sendOptions: existing.sendOptions
+                });
+            }
+        }
+        this._pendingRequests.length = 0;
+        this._pendingRequests.push(...newPending);
+        this._onDidChangePendingRequests.fire();
+    }
+    addPendingRequest(request, kind, sendOptions) {
+        const pendingRequest = {
+            request,
+            kind,
+            sendOptions
+        };
+        if (kind === ChatRequestQueueKind.Steering) {
+            let insertIndex = 0;
+            for (let i = 0; i < this._pendingRequests.length; i++) {
+                if (this._pendingRequests[i].kind === ChatRequestQueueKind.Steering) {
+                    insertIndex = i + 1;
+                } else {
+                    break;
+                }
+            }
+            this._pendingRequests.splice(insertIndex, 0, pendingRequest);
+        } else {
+            this._pendingRequests.push(pendingRequest);
+        }
+        this._onDidChangePendingRequests.fire();
+        return pendingRequest;
+    }
+    removePendingRequest(id) {
+        const index = this._pendingRequests.findIndex(r => r.request.id === id);
+        if (index !== -1) {
+            this._pendingRequests.splice(index, 1);
+            this._onDidChangePendingRequests.fire();
+        }
+    }
+    dequeuePendingRequest() {
+        const request = this._pendingRequests.shift();
+        if (request) {
+            this._onDidChangePendingRequests.fire();
+        }
+        return request;
+    }
+    clearPendingRequests() {
+        if (this._pendingRequests.length > 0) {
+            this._pendingRequests.length = 0;
+            this._onDidChangePendingRequests.fire();
+        }
+    }
     get sessionId() {
         return this._sessionId;
     }
@@ -991,6 +1059,9 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
         this.onDidDispose = this._onDidDispose.event;
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
+        this._pendingRequests = [];
+        this._onDidChangePendingRequests = this._register(( new Emitter()));
+        this.onDidChangePendingRequests = this._onDidChangePendingRequests.event;
         this._isImported = false;
         this._canUseTools = true;
         this.currentEditedFileEvents = ( new ResourceMap());
@@ -1025,6 +1096,9 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
         this.dataSerializer = dataRef?.serializer;
         this._initialResponderUsername = initialData?.responderUsername;
         this._repoData = isValidFullData && initialData.repoData ? initialData.repoData : undefined;
+        if (isValidFullData && initialData.pendingRequests) {
+            this._pendingRequests = this._deserializePendingRequests(initialData.pendingRequests);
+        }
         this._initialLocation = initialData?.initialLocation ?? initialModelProps.initialLocation;
         this._canUseTools = initialModelProps.canUseTools;
         this.lastRequestObs = observableFromEvent(this, this.onDidChange, () => this._requests.at(-1));
@@ -1110,74 +1184,75 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
             return [];
         }
         try {
-            return ( requests.map(raw => {
-                const parsedRequest = typeof raw.message === "string" ? this.getParsedRequestFromString(raw.message) : reviveParsedChatRequest(raw.message);
-                const variableData = this.reviveVariableData(raw.variableData);
-                const request = ( new ChatRequestModel({
-                    session: this,
-                    message: parsedRequest,
-                    variableData,
-                    timestamp: raw.timestamp ?? -1,
-                    restoredId: raw.requestId,
-                    confirmation: raw.confirmation,
-                    editedFileEvents: raw.editedFileEvents,
-                    modelId: raw.modelId
-                }));
-                request.shouldBeRemovedOnSend = raw.isHidden ? {
-                    requestId: raw.requestId
-                } : raw.shouldBeRemovedOnSend;
-                if (raw.response || raw.result || raw.responseErrorDetails) {
-                    const agent =
-                    (raw.agent && "metadata" in raw.agent) ? reviveSerializedAgent(raw.agent) : undefined;
-                    const result = "responseErrorDetails" in raw ?
-                    {
-                        errorDetails: raw.responseErrorDetails
-                    } : raw.result;
-                    let modelState = raw.modelState || {
-                        value: raw.isCanceled ? ResponseModelState.Cancelled : ResponseModelState.Complete,
-                        completedAt: Date.now()
-                    };
-                    if (modelState.value === ResponseModelState.Pending || modelState.value === ResponseModelState.NeedsInput) {
-                        modelState = {
-                            value: ResponseModelState.Cancelled,
-                            completedAt: Date.now()
-                        };
-                    }
-                    request.response = ( new ChatResponseModel({
-                        responseContent: raw.response ?? [( new MarkdownString(raw.response))],
-                        session: this,
-                        agent,
-                        slashCommand: raw.slashCommand,
-                        requestId: request.id,
-                        modelState,
-                        vote: raw.vote,
-                        timestamp: raw.timestamp,
-                        voteDownReason: raw.voteDownReason,
-                        result,
-                        followups: raw.followups,
-                        restoredId: raw.responseId,
-                        timeSpentWaiting: raw.timeSpentWaiting,
-                        shouldBeBlocked: request.shouldBeBlocked.get(),
-                        codeBlockInfos: raw.responseMarkdownInfo?.map(info => ({
-                            suggestionId: info.suggestionId
-                        }))
-                    }));
-                    request.response.shouldBeRemovedOnSend = raw.isHidden ? {
-                        requestId: raw.requestId
-                    } : raw.shouldBeRemovedOnSend;
-                    if (raw.usedContext) {
-                        request.response.applyReference(revive(raw.usedContext));
-                    }
-                    raw.contentReferences?.forEach(r => request.response.applyReference(revive(r)));
-                    raw.codeCitations?.forEach(c => request.response.applyCodeCitation(revive(c)));
-                }
-                return request;
-            }));
+            return ( requests.map(r => this._deserializeRequest(r)));
         } catch (error) {
             this.logService.error("Failed to parse chat data", error);
             return [];
         }
     }
+    _deserializeRequest(raw) {
+        const parsedRequest = typeof raw.message === "string" ? this.getParsedRequestFromString(raw.message) : reviveParsedChatRequest(raw.message);
+        const variableData = this.reviveVariableData(raw.variableData);
+        const request = ( new ChatRequestModel({
+            session: this,
+            message: parsedRequest,
+            variableData,
+            timestamp: raw.timestamp ?? -1,
+            restoredId: raw.requestId,
+            confirmation: raw.confirmation,
+            editedFileEvents: raw.editedFileEvents,
+            modelId: raw.modelId
+        }));
+        request.shouldBeRemovedOnSend = raw.isHidden ? {
+            requestId: raw.requestId
+        } : raw.shouldBeRemovedOnSend;
+        if (raw.response || raw.result || raw.responseErrorDetails) {
+            const agent =
+            (raw.agent && "metadata" in raw.agent) ? reviveSerializedAgent(raw.agent) : undefined;
+            const result = "responseErrorDetails" in raw ?
+            {
+                errorDetails: raw.responseErrorDetails
+            } : raw.result;
+            let modelState = raw.modelState || {
+                value: raw.isCanceled ? ResponseModelState.Cancelled : ResponseModelState.Complete,
+                completedAt: Date.now()
+            };
+            if (modelState.value === ResponseModelState.Pending || modelState.value === ResponseModelState.NeedsInput) {
+                modelState = {
+                    value: ResponseModelState.Cancelled,
+                    completedAt: Date.now()
+                };
+            }
+            request.response = ( new ChatResponseModel({
+                responseContent: raw.response ?? [( new MarkdownString(raw.response))],
+                session: this,
+                agent,
+                slashCommand: raw.slashCommand,
+                requestId: request.id,
+                modelState,
+                vote: raw.vote,
+                timestamp: raw.timestamp,
+                voteDownReason: raw.voteDownReason,
+                result,
+                followups: raw.followups,
+                restoredId: raw.responseId,
+                timeSpentWaiting: raw.timeSpentWaiting,
+                shouldBeBlocked: request.shouldBeBlocked.get(),
+                codeBlockInfos: raw.responseMarkdownInfo?.map(info => ({
+                    suggestionId: info.suggestionId
+                }))
+            }));
+            request.response.shouldBeRemovedOnSend = raw.isHidden ? {
+                requestId: raw.requestId
+            } : raw.shouldBeRemovedOnSend;
+            if (raw.usedContext) {
+                request.response.applyReference(revive(raw.usedContext));
+            }
+            raw.contentReferences?.forEach(r => request.response.applyReference(revive(r)));
+            raw.codeCitations?.forEach(c => request.response.applyCodeCitation(revive(c)));
+        }
+        return request;
+    }
     reviveVariableData(raw) {
         const variableData = raw && Array.isArray(raw.variables) ? raw : {
             variables: []
@@ -1197,6 +1272,22 @@ let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
             parts
         };
     }
+    _deserializePendingRequests(pendingRequests) {
+        try {
+            return ( pendingRequests.map(pending => ({
+                id: pending.id,
+                request: this._deserializeRequest(pending.request),
+                kind: pending.kind,
+                sendOptions: {
+                    ...pending.sendOptions,
+                    userSelectedTools: pending.sendOptions.userSelectedTools ? constObservable(pending.sendOptions.userSelectedTools) : undefined
+                }
+            })));
+        } catch (e) {
+            this.logService.error("Failed to parse pending chat requests", e);
+            return [];
+        }
+    }
     getRequests() {
         return this._requests;
     }
@@ -1503,9 +1594,24 @@ function getCodeCitationsMessage(citations) {
         return "";
     }
     const licenseTypes = citations.reduce((set, c) => set.add(c.license), ( new Set()));
-    const label = licenseTypes.size === 1 ? ( localize(6250, "Similar code found with 1 license type", licenseTypes.size)) : ( localize(6251, "Similar code found with {0} license types", licenseTypes.size));
+    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));
     return label;
 }
+function serializeSendOptions(options) {
+    return {
+        modeInfo: options.modeInfo,
+        userSelectedModelId: options.userSelectedModelId,
+        userSelectedTools: options.userSelectedTools?.get(),
+        location: options.location,
+        locationData: options.locationData,
+        attempt: options.attempt,
+        noCommandDetection: options.noCommandDetection,
+        agentId: options.agentId,
+        agentIdSilent: options.agentIdSilent,
+        slashCommand: options.slashCommand,
+        confirmation: options.confirmation
+    };
+}
 var ChatRequestEditedFileEventKind;
 (function(ChatRequestEditedFileEventKind) {
     ChatRequestEditedFileEventKind[ChatRequestEditedFileEventKind["Keep"] = 1] = "Keep";
@@ -1554,4 +1660,4 @@ var ChatResponseResource;
     ChatResponseResource.parseUri = parseUri;
 })(ChatResponseResource || (ChatResponseResource = {}));
 
-export { CHAT_ATTACHABLE_IMAGE_MIME_TYPES, ChatModel, ChatRequestEditedFileEventKind, ChatRequestModel, ChatRequestRemovalReason, ChatResponseModel, ChatResponseResource, IChatRequestVariableData, Response, appendMarkdownString, canMergeMarkdownStrings, defaultChatResponseModelChangeReason, getAttachableImageExtension, getCodeCitationsMessage, isCellTextEditOperation, isCellTextEditOperationArray, isExportableSessionData, isSerializableSessionData, normalizeSerializableChatData, toChatHistoryContent, updateRanges };
+export { CHAT_ATTACHABLE_IMAGE_MIME_TYPES, ChatModel, ChatRequestEditedFileEventKind, ChatRequestModel, ChatRequestRemovalReason, ChatResponseModel, ChatResponseResource, IChatRequestVariableData, Response, appendMarkdownString, canMergeMarkdownStrings, defaultChatResponseModelChangeReason, getAttachableImageExtension, getCodeCitationsMessage, isCellTextEditOperation, isCellTextEditOperationArray, isExportableSessionData, isSerializableSessionData, normalizeSerializableChatData, serializeSendOptions, toChatHistoryContent, updateRanges };

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, ChatAgentVoteDownReason, IChatCodeCitation, IChatContentReference, IChatFollowup, IChatMcpServersStarting, IChatProgressMessage, IChatQuestionCarousel, IChatResponseErrorDetails, IChatTask, IChatUsedContext } from "../chatService/chatService.js";
+import { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatRequestQueueKind, IChatCodeCitation, IChatContentReference, IChatDisabledClaudeHooksPart, IChatFollowup, IChatMcpServersStarting, IChatProgressMessage, IChatQuestionCarousel, IChatResponseErrorDetails, IChatTask, 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,7 @@ import { IChatModel, IChatProgressRenderableResponseContent, IChatRequestDisable
 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;
 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;
@@ -36,7 +37,7 @@ export interface IChatViewModel {
     readonly onDidDisposeModel: Event<void>;
     readonly onDidChange: Event<IChatViewModelChangeEvent>;
     readonly inputPlaceholder?: string;
-    getItems(): (IChatRequestViewModel | IChatResponseViewModel)[];
+    getItems(): (IChatRequestViewModel | IChatResponseViewModel | IChatPendingDividerViewModel)[];
     setInputPlaceholder(text: string): void;
     resetInputPlaceholder(): void;
     editing?: IChatRequestViewModel;
@@ -64,6 +65,8 @@ export interface IChatRequestViewModel {
     readonly shouldBeBlocked: IObservable<boolean>;
     readonly modelId?: string;
     readonly timestamp: number;
+    /** The kind of pending request, or undefined if not pending */
+    readonly pendingKind?: ChatRequestQueueKind;
 }
 export interface IChatResponseMarkdownRenderData {
     renderedWordCount: number;
@@ -134,7 +137,7 @@ export interface IChatChangesSummaryPart {
 /**
  * Type for content parts rendered by IChatListRenderer (not necessarily in the model)
  */
-export type IChatRendererContent = IChatProgressRenderableResponseContent | IChatReferences | IChatCodeCitations | IChatErrorDetailsPart | IChatChangesSummaryPart | IChatWorkingProgress | IChatMcpServersStarting | IChatQuestionCarousel;
+export type IChatRendererContent = IChatProgressRenderableResponseContent | IChatReferences | IChatCodeCitations | IChatErrorDetailsPart | IChatChangesSummaryPart | IChatWorkingProgress | IChatMcpServersStarting | IChatQuestionCarousel | IChatDisabledClaudeHooksPart;
 export interface IChatResponseViewModel {
     readonly model: IChatResponseModel;
     readonly id: string;
@@ -173,6 +176,14 @@ export interface IChatResponseViewModel {
     setEditApplied(edit: IChatTextEditGroup, editCount: number): void;
     readonly shouldBeBlocked: IObservable<boolean>;
 }
+export interface IChatPendingDividerViewModel {
+    readonly kind: "pendingDivider";
+    readonly id: string;
+    readonly sessionResource: URI;
+    readonly isComplete: true;
+    readonly dividerKind: ChatRequestQueueKind;
+    currentRenderedHeight: number | undefined;
+}
 export interface IChatViewModelOptions {
     /**
      * Maximum number of items to return from getItems().
@@ -198,7 +209,7 @@ export declare class ChatViewModel extends Disposable implements IChatViewModel
     get sessionResource(): URI;
     constructor(_model: IChatModel, codeBlockModelCollection: CodeBlockModelCollection, _options: IChatViewModelOptions | undefined, instantiationService: IInstantiationService);
     private onAddResponse;
-    getItems(): (IChatRequestViewModel | IChatResponseViewModel)[];
+    getItems(): (IChatRequestViewModel | IChatResponseViewModel | IChatPendingDividerViewModel)[];
     private _editing;
     get editing(): IChatRequestViewModel | undefined;
     setEditing(editing: IChatRequestViewModel | undefined): void;
@@ -206,6 +217,7 @@ export declare class ChatViewModel extends Disposable implements IChatViewModel
 }
 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.
@@ -229,7 +241,8 @@ export declare class ChatRequestViewModel implements IChatRequestViewModel {
     currentRenderedHeight: number | undefined;
     get modelId(): string | undefined;
     get timestamp(): number;
-    constructor(_model: IChatRequestModel);
+    get pendingKind(): ChatRequestQueueKind | undefined;
+    constructor(_model: IChatRequestModel, _pendingKind?: ChatRequestQueueKind | undefined);
 }
 export declare class ChatResponseViewModel extends Disposable implements IChatResponseViewModel {
     private readonly _model;

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

@@ -4,6 +4,7 @@ import { Codicon } from '../../../../../base/common/codicons.js';
 import { Emitter } from '../../../../../base/common/event.js';
 import { Disposable, dispose } from '../../../../../base/common/lifecycle.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ChatRequestQueueKind } from '../chatService/chatService.js';
 import { getFullyQualifiedId } from '../participants/chatAgents.js';
 import { IChatAgentNameService } from '../participants/chatAgents.service.js';
 import { ChatStreamStatsTracker } from './chatStreamStats.js';
@@ -15,6 +16,9 @@ function isRequestVM(item) {
 function isResponseVM(item) {
     return !!item && typeof item.setVote !== "undefined";
 }
+function isPendingDividerVM(item) {
+    return !!item && typeof item === "object" && item.kind === "pendingDivider";
+}
 function isChatTreeItem(item) {
     return isRequestVM(item) || isResponseVM(item);
 }
@@ -66,6 +70,7 @@ let ChatViewModel = class ChatViewModel extends Disposable {
             }
         });
         this._register(_model.onDidDispose(() => this._onDidDisposeModel.fire()));
+        this._register(_model.onDidChangePendingRequests(() => this._onDidChange.fire(null)));
         this._register(_model.onDidChange(e => {
             if (e.kind === "addRequest") {
                 const requestModel = this.instantiationService.createInstance(ChatRequestViewModel, e.request);
@@ -107,11 +112,44 @@ let ChatViewModel = class ChatViewModel extends Disposable {
         this._items.push(response);
     }
     getItems() {
-        const items = this._items.filter(
+        let items = this._items.filter(
             item => !item.shouldBeRemovedOnSend || item.shouldBeRemovedOnSend.afterUndoStop
         );
         if (this._options?.maxVisibleItems !== undefined && items.length > this._options.maxVisibleItems) {
-            return items.slice(-this._options.maxVisibleItems);
+            items = items.slice(-this._options.maxVisibleItems);
+        }
+        const pendingRequests = this._model.getPendingRequests();
+        if (pendingRequests.length > 0) {
+            const steeringRequests = pendingRequests.filter(p => p.kind === ChatRequestQueueKind.Steering);
+            const queuedRequests = pendingRequests.filter(p => p.kind === ChatRequestQueueKind.Queued);
+            if (steeringRequests.length > 0) {
+                items.push({
+                    kind: "pendingDivider",
+                    id: "pending-divider-steering",
+                    sessionResource: this._model.sessionResource,
+                    isComplete: true,
+                    dividerKind: ChatRequestQueueKind.Steering,
+                    currentRenderedHeight: undefined
+                });
+                for (const pending of steeringRequests) {
+                    const requestVM = this.instantiationService.createInstance(ChatRequestViewModel, pending.request, pending.kind);
+                    items.push(requestVM);
+                }
+            }
+            if (queuedRequests.length > 0) {
+                items.push({
+                    kind: "pendingDivider",
+                    id: "pending-divider-queued",
+                    sessionResource: this._model.sessionResource,
+                    isComplete: true,
+                    dividerKind: ChatRequestQueueKind.Queued,
+                    currentRenderedHeight: undefined
+                });
+                for (const pending of queuedRequests) {
+                    const requestVM = this.instantiationService.createInstance(ChatRequestViewModel, pending.request, pending.kind);
+                    items.push(requestVM);
+                }
+            }
         }
         return items;
     }
@@ -188,8 +226,12 @@ class ChatRequestViewModel {
     get timestamp() {
         return this._model.timestamp;
     }
-    constructor(_model) {
+    get pendingKind() {
+        return this._pendingKind;
+    }
+    constructor(_model, _pendingKind) {
         this._model = _model;
+        this._pendingKind = _pendingKind;
     }
 }
 let ChatResponseViewModel = class ChatResponseViewModel extends Disposable {
@@ -337,4 +379,4 @@ let ChatResponseViewModel = class ChatResponseViewModel extends Disposable {
 };
 ChatResponseViewModel = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IChatAgentNameService))], ChatResponseViewModel));
 
-export { ChatRequestViewModel, ChatResponseViewModel, ChatViewModel, assertIsResponseVM, isChatTreeItem, isRequestVM, isResponseVM };
+export { ChatRequestViewModel, ChatResponseViewModel, ChatViewModel, assertIsResponseVM, isChatTreeItem, isPendingDividerVM, isRequestVM, isResponseVM };

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

@@ -14,6 +14,7 @@ import { IProductService } from "../../../../../platform/product/common/productS
 import { IRequestService } from "../../../../../platform/request/common/request.service.js";
 import { IStorageService } from "../../../../../platform/storage/common/storage.service.js";
 import { IChatAgentEditedFileEvent, IChatProgressHistoryResponseContent, IChatRequestModeInstructions, IChatRequestVariableData, ISerializableChatAgentData } from "../model/chatModel.js";
+import { IChatRequestHooks } from "../promptSyntax/hookSchema.js";
 import { IRawChatCommandContribution } from "./chatParticipantContribTypes.js";
 import { IChatFollowup, IChatLocationData, IChatProgress, IChatResponseErrorDetails, IChatTaskDto } from "../chatService/chatService.js";
 import { ChatAgentLocation, ChatModeKind } from "../constants.js";
@@ -75,6 +76,7 @@ export interface IChatWelcomeMessageContent {
 export interface IChatAgentImplementation {
     invoke(request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
     setRequestTools?(requestId: string, tools: UserSelectedTools): void;
+    setYieldRequested?(requestId: string): void;
     provideFollowups?(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     provideChatTitle?: (history: IChatAgentHistoryEntry[], token: CancellationToken) => Promise<string | undefined>;
     provideChatSummary?: (history: IChatAgentHistoryEntry[], token: CancellationToken) => Promise<string | undefined>;
@@ -133,6 +135,15 @@ export interface IChatAgentRequest {
     userSelectedTools?: UserSelectedTools;
     modeInstructions?: IChatRequestModeInstructions;
     editedFileEvents?: IChatAgentEditedFileEvent[];
+    /**
+     * Collected hooks configuration for this request.
+     * Contains all hooks defined in hooks .json files, organized by hook type.
+     */
+    hooks?: IChatRequestHooks;
+    /**
+     * Whether any hooks are enabled for this request.
+     */
+    hasHooksEnabled?: boolean;
     /**
      * Unique ID for the subagent invocation, used to group tool calls from the same subagent run together.
      */
@@ -141,6 +152,10 @@ export interface IChatAgentRequest {
      * Display name of the subagent that is invoking this request.
      */
     subAgentName?: string;
+    /**
+     * The request ID of the parent request that invoked this subagent.
+     */
+    parentRequestId?: string;
 }
 export interface IChatQuestion {
     readonly prompt: string;
@@ -224,6 +239,7 @@ export declare class ChatAgentService extends Disposable implements IChatAgentSe
     agentHasDupeName(id: string): boolean;
     invokeAgent(id: string, request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
     setRequestTools(id: string, requestId: string, tools: UserSelectedTools): void;
+    setYieldRequested(id: string, requestId: string): void;
     getFollowups(id: string, request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     getChatTitle(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
     getChatSummary(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
@@ -265,6 +281,7 @@ export declare class MergedChatAgent implements IChatAgent {
     }[];
     invoke(request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
     setRequestTools(requestId: string, tools: UserSelectedTools): void;
+    setYieldRequested(requestId: string): void;
     provideFollowups(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     toJSON(): IChatAgentData;
 }

package/vscode/src/vs/workbench/contrib/chat/common/participants/chatAgents.js

@@ -237,6 +237,13 @@ let ChatAgentService = class ChatAgentService extends Disposable {
         }
         data.impl.setRequestTools?.(requestId, tools);
     }
+    setYieldRequested(id, requestId) {
+        const data = this._agents.get(id);
+        if (!data?.impl) {
+            return;
+        }
+        data.impl.setYieldRequested?.(requestId);
+    }
     async getFollowups(id, request, result, history, token) {
         const data = this._agents.get(id);
         if (!data?.impl?.provideFollowups) {
@@ -374,6 +381,9 @@ class MergedChatAgent {
     setRequestTools(requestId, tools) {
         this.impl.setRequestTools?.(requestId, tools);
     }
+    setYieldRequested(requestId) {
+        this.impl.setYieldRequested?.(requestId);
+    }
     async provideFollowups(request, result, history, token) {
         if (this.impl.provideFollowups) {
             return this.impl.provideFollowups(request, result, history, token);

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

@@ -27,6 +27,7 @@ export interface IChatAgentService {
     hasChatParticipantDetectionProviders(): boolean;
     invokeAgent(agent: string, request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
     setRequestTools(agent: string, requestId: string, tools: UserSelectedTools): void;
+    setYieldRequested(agent: string, requestId: string): void;
     getFollowups(id: string, request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     getChatTitle(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
     getChatSummary(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;

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

@@ -18,6 +18,9 @@ export type InstructionsCollectionEvent = {
     agentInstructionsCount: number;
     listedInstructionsCount: number;
     totalInstructionsCount: number;
+    claudeRulesCount: number;
+    claudeMdCount: number;
+    claudeAgentsCount: number;
 };
 export declare function newInstructionsCollectionEvent(): InstructionsCollectionEvent;
 export declare class ComputeAutomaticInstructions {
@@ -44,6 +47,12 @@ export declare class ComputeAutomaticInstructions {
     }, variables: ChatRequestVariableSet, telemetryEvent: InstructionsCollectionEvent, token: CancellationToken): Promise<void>;
     private _getContext;
     private _addAgentInstructions;
+    /**
+     * Combines the `applyTo` and `paths` attributes into a single comma-separated
+     * pattern string that can be matched by {@link _matches}.
+     * Used for the instructions list XML output where both should be shown.
+     */
+    private _getApplyToPattern;
     private _matches;
     private _getTool;
     private _getInstructionsWithPatternsList;