@codingame/monaco-vscode-api 30.0.0 → 31.0.0

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

@@ -140,6 +140,7 @@ export interface IChatDebugSourceFolderEntry {
 export interface IChatDebugEventFileListContent {
     readonly kind: "fileList";
     readonly discoveryType: string;
+    readonly durationInMillis: number;
     readonly files: readonly IChatDebugFileEntry[];
     readonly sourceFolders?: readonly IChatDebugSourceFolderEntry[];
 }
@@ -200,10 +201,40 @@ export interface IChatDebugEventHookContent {
     readonly exitCode?: number;
     readonly errorMessage?: string;
 }
+/**
+ * A single entry in the customization resolution log.
+ */
+export interface IChatDebugCustomizationLogEntry {
+    readonly category: "applying" | "skipped" | "referenced" | "skill" | "custom-agent" | "hook";
+    readonly name: string;
+    readonly uri?: URI;
+    readonly reason?: string;
+}
+/**
+ * Structured customization summary content for a resolved debug event.
+ * Contains per-file resolution logs showing how applyTo patterns, agent
+ * instructions, and referenced files were resolved by the instructions
+ * context computer.
+ */
+export interface IChatDebugEventCustomizationSummaryContent {
+    readonly kind: "customizationSummary";
+    /** Per-file resolution detail entries. */
+    readonly resolutionLogs: readonly IChatDebugCustomizationLogEntry[];
+    /** Total wall-clock time of the collect() call in milliseconds. */
+    readonly durationInMillis: number;
+    /** Counts by type for the summary header. */
+    readonly counts: {
+        readonly instructions: number;
+        readonly skills: number;
+        readonly agents: number;
+        readonly hooks: number;
+        readonly skipped: number;
+    };
+}
 /**
  * Union of all resolved event content types.
  */
-export type IChatDebugResolvedEventContent = IChatDebugEventTextContent | IChatDebugEventFileListContent | IChatDebugEventMessageContent | IChatDebugEventToolCallContent | IChatDebugEventModelTurnContent | IChatDebugEventHookContent;
+export type IChatDebugResolvedEventContent = IChatDebugEventTextContent | IChatDebugEventFileListContent | IChatDebugEventMessageContent | IChatDebugEventToolCallContent | IChatDebugEventModelTurnContent | IChatDebugEventHookContent | IChatDebugEventCustomizationSummaryContent;
 /**
  * Provider interface for debug events.
  */

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

@@ -1,3 +1,4 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
@@ -100,15 +101,33 @@ export interface IChatDebugService extends IDisposable {
     */
     getImportedSessionTitle(sessionResource: URI): string | undefined;
     /**
-    * Fired when debug data is attached to a session.
+    * Fired when available session resources change (e.g. historical sessions discovered from disk).
     */
-    readonly onDidAttachDebugData: Event<URI>;
+    readonly onDidChangeAvailableSessionResources: Event<void>;
     /**
-    * Mark a session as having debug data attached.
+    * Store session resources that have debug log data available on disk.
+    * Called by the main thread after the extension reports historical sessions.
     */
-    markDebugDataAttached(sessionResource: URI): void;
+    addAvailableSessionResources(resources: readonly {
+        uri: URI;
+        title?: string;
+    }[]): void;
     /**
-    * Check whether a session has had debug data attached.
+    * Get all session resources that have debug log data available,
+    * including historical sessions persisted on disk by the provider.
+    * Triggers a lazy fetch from the registered fetcher on first call.
     */
-    hasAttachedDebugData(sessionResource: URI): boolean;
+    getAvailableSessionResources(): readonly URI[];
+    /**
+    * Register a callback that fetches available session resources from a provider.
+    * Called lazily when `getAvailableSessionResources()` is first invoked.
+    */
+    registerAvailableSessionsFetcher(fetcher: (token: CancellationToken) => Promise<{
+        uri: URI;
+        title?: string;
+    }[]>): void;
+    /**
+    * Get the stored title for a historical session discovered from disk.
+    */
+    getHistoricalSessionTitle(sessionResource: URI): string | undefined;
 }

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

@@ -3,6 +3,7 @@ import { IObservable } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IOffsetRange } from "../../../../editor/common/core/ranges/offsetRange.js";
 import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+import { ContextKeyExpression } from "../../../../platform/contextkey/common/contextkey.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
 import { ILogService } from "../../../../platform/log/common/log.service.js";
 import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
@@ -59,6 +60,7 @@ export interface IChatModeData {
     readonly target?: Target;
     readonly visibility?: ICustomAgentVisibility;
     readonly agents?: readonly string[];
+    readonly sessionTypes?: readonly string[];
     readonly infer?: boolean;
 }
 export interface IChatMode {
@@ -79,6 +81,8 @@ export interface IChatMode {
     readonly target: IObservable<Target>;
     readonly visibility?: IObservable<ICustomAgentVisibility | undefined>;
     readonly agents?: IObservable<readonly string[] | undefined>;
+    readonly sessionTypes?: readonly string[];
+    readonly when?: ContextKeyExpression;
 }
 export interface IVariableReference {
     readonly name: string;
@@ -102,6 +106,8 @@ export declare class CustomChatMode implements IChatMode {
     private readonly _visibilityObservable;
     private readonly _agentsObservable;
     private _source;
+    private _sessionTypes;
+    private _when;
     readonly id: string;
     get name(): IObservable<string>;
     get description(): IObservable<string | undefined>;
@@ -118,6 +124,8 @@ export declare class CustomChatMode implements IChatMode {
     get target(): IObservable<Target>;
     get visibility(): IObservable<ICustomAgentVisibility | undefined>;
     get agents(): IObservable<readonly string[] | undefined>;
+    get sessionTypes(): readonly string[] | undefined;
+    get when(): ContextKeyExpression | undefined;
     readonly kind = ChatModeKind.Agent;
     constructor(customChatMode: ICustomAgent);
     /**

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

@@ -115,6 +115,7 @@ let ChatModeService = class ChatModeService extends Disposable {
                         target: cachedMode.target ?? Target.Undefined,
                         visibility,
                         agents: cachedMode.agents,
+                        sessionTypes: cachedMode.sessionTypes,
                         source: reviveChatModeSource(cachedMode.source) ?? {
                             storage: PromptsStorage.local
                         }
@@ -210,7 +211,7 @@ function isCachedChatModeData(data) {
         return false;
     }
     const mode = data;
-    return typeof mode.id === "string" && typeof mode.name === "string" && typeof mode.kind === "string" && (mode.description === undefined || typeof mode.description === "string") && (mode.customTools === undefined || Array.isArray(mode.customTools)) && (mode.modeInstructions === undefined || (typeof mode.modeInstructions === "object" && mode.modeInstructions !== null)) && (mode.model === undefined || typeof mode.model === "string" || Array.isArray(mode.model)) && (mode.argumentHint === undefined || typeof mode.argumentHint === "string") && (mode.handOffs === undefined || Array.isArray(mode.handOffs)) && (mode.uri === undefined || (typeof mode.uri === "object" && mode.uri !== null)) && (mode.source === undefined || isChatModeSourceData(mode.source)) && (mode.target === undefined || isTarget(mode.target)) && (mode.visibility === undefined || isCustomAgentVisibility(mode.visibility)) && (mode.agents === undefined || Array.isArray(mode.agents));
+    return typeof mode.id === "string" && typeof mode.name === "string" && typeof mode.kind === "string" && (mode.description === undefined || typeof mode.description === "string") && (mode.customTools === undefined || Array.isArray(mode.customTools)) && (mode.modeInstructions === undefined || (typeof mode.modeInstructions === "object" && mode.modeInstructions !== null)) && (mode.model === undefined || typeof mode.model === "string" || Array.isArray(mode.model)) && (mode.argumentHint === undefined || typeof mode.argumentHint === "string") && (mode.handOffs === undefined || Array.isArray(mode.handOffs)) && (mode.uri === undefined || (typeof mode.uri === "object" && mode.uri !== null)) && (mode.source === undefined || isChatModeSourceData(mode.source)) && (mode.target === undefined || isTarget(mode.target)) && (mode.visibility === undefined || isCustomAgentVisibility(mode.visibility)) && (mode.agents === undefined || Array.isArray(mode.agents)) && (mode.sessionTypes === undefined || Array.isArray(mode.sessionTypes));
 }
 class CustomChatMode {
     get name() {
@@ -258,6 +259,12 @@ class CustomChatMode {
     get agents() {
         return this._agentsObservable;
     }
+    get sessionTypes() {
+        return this._sessionTypes;
+    }
+    get when() {
+        return this._when;
+    }
     constructor(customChatMode) {
         this.kind = ChatModeKind.Agent;
         this.id = ( customChatMode.uri.toString());
@@ -273,6 +280,8 @@ class CustomChatMode {
         this._modeInstructions = observableValue("_modeInstructions", customChatMode.agentInstructions);
         this._uriObservable = observableValue("uri", customChatMode.uri);
         this._source = customChatMode.source;
+        this._sessionTypes = customChatMode.sessionTypes;
+        this._when = customChatMode.when;
     }
     updateData(newData) {
         transaction(tx => {
@@ -288,6 +297,8 @@ class CustomChatMode {
             this._modeInstructions.set(newData.agentInstructions, tx);
             this._uriObservable.set(newData.uri, tx);
             this._source = newData.source;
+            this._sessionTypes = newData.sessionTypes;
+            this._when = newData.when;
         });
     }
     toJSON() {
@@ -305,7 +316,8 @@ class CustomChatMode {
             source: serializeChatModeSource(this._source),
             target: this.target.get(),
             visibility: this.visibility.get(),
-            agents: this.agents.get()
+            agents: this.agents.get(),
+            sessionTypes: this.sessionTypes
         };
     }
 }
@@ -396,9 +408,9 @@ class BuiltinChatMode {
 }
 var ChatMode;
 (function(ChatMode) {
-    ChatMode.Ask = ( new BuiltinChatMode(ChatModeKind.Ask, "Ask", ( localize(7254, "Explore and understand your code")), Codicon.question));
-    ChatMode.Edit = ( new BuiltinChatMode(ChatModeKind.Edit, "Edit", ( localize(7255, "Edit or refactor selected code")), Codicon.edit));
-    ChatMode.Agent = ( new BuiltinChatMode(ChatModeKind.Agent, "Agent", ( localize(7256, "Describe what to build")), Codicon.agent));
+    ChatMode.Ask = ( new BuiltinChatMode(ChatModeKind.Ask, "Ask", ( localize(7376, "Explore and understand your code")), Codicon.question));
+    ChatMode.Edit = ( new BuiltinChatMode(ChatModeKind.Edit, "Edit", ( localize(7377, "Edit or refactor selected code")), Codicon.edit));
+    ChatMode.Agent = ( new BuiltinChatMode(ChatModeKind.Agent, "Agent", ( localize(7378, "Describe what to build")), Codicon.agent));
 })(ChatMode || (ChatMode = {}));
 function isBuiltinChatMode(mode) {
     return mode.id === ChatMode.Ask.id || mode.id === ChatMode.Edit.id || mode.id === ChatMode.Agent.id;

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

@@ -2,26 +2,42 @@
 import { mark, clearMarks } from '../../../../base/common/performance.js';
 import { chatSessionResourceToId } from './model/chatUri.js';
 
-const chatPerfPrefix = 'code/chat/';
+const chatPerfPrefix = "code/chat/";
+const chatMarksBySession = ( new Map());
 const ChatPerfMark = {
-    RequestStart: 'request/start',
-    RequestUiUpdated: 'request/uiUpdated',
-    WillCollectInstructions: 'request/willCollectInstructions',
-    DidCollectInstructions: 'request/didCollectInstructions',
-    FirstToken: 'request/firstToken',
-    RequestComplete: 'request/complete',
-    AgentWillInvoke: 'agent/willInvoke',
-    AgentDidInvoke: 'agent/didInvoke',
+    RequestStart: "request/start",
+    RequestUiUpdated: "request/uiUpdated",
+    WillCollectInstructions: "request/willCollectInstructions",
+    DidCollectInstructions: "request/didCollectInstructions",
+    FirstToken: "request/firstToken",
+    RequestComplete: "request/complete",
+    AgentWillInvoke: "agent/willInvoke",
+    AgentDidInvoke: "agent/didInvoke"
 };
 function markChat(sessionResource, name) {
-    mark(`${chatPerfPrefix}${chatSessionResourceToId(sessionResource)}/${name}`);
+    const sessionId = chatSessionResourceToId(sessionResource);
+    const fullName = `${chatPerfPrefix}${sessionId}/${name}`;
+    let names = chatMarksBySession.get(sessionId);
+    if (!names) {
+        names = ( new Set());
+        chatMarksBySession.set(sessionId, names);
+    }
+    names.add(fullName);
+    mark(fullName);
 }
 function clearChatMarks(sessionResource) {
-    clearMarks(`${chatPerfPrefix}${chatSessionResourceToId(sessionResource)}/`);
+    const sessionId = chatSessionResourceToId(sessionResource);
+    const names = chatMarksBySession.get(sessionId);
+    if (names) {
+        for (const name of names) {
+            clearMarks(name);
+        }
+        chatMarksBySession.delete(sessionId);
+    }
 }
 const ChatGlobalPerfMark = {
-    WillWaitForActivation: 'willWaitForActivation',
-    DidWaitForActivation: 'didWaitForActivation',
+    WillWaitForActivation: "willWaitForActivation",
+    DidWaitForActivation: "didWaitForActivation"
 };
 function markChatGlobal(name) {
     mark(`${chatPerfPrefix}${name}`);

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

@@ -8,21 +8,21 @@ import { IObservable, IReader } from "../../../../../base/common/observable.js";
 import { ThemeIcon } from "../../../../../base/common/themables.js";
 import { URI, UriComponents } from "../../../../../base/common/uri.js";
 import { IRange } from "../../../../../editor/common/core/range.js";
-import { HookTypeValue } from "../promptSyntax/hookTypes.js";
 import { ISelection } from "../../../../../editor/common/core/selection.js";
 import { Command, Location, TextEdit } from "../../../../../editor/common/languages.js";
 import { FileType } from "../../../../../platform/files/common/files.js";
 import { IAutostartResult } from "../../../mcp/common/mcpTypes.js";
 import { ICellEditOperation } from "../../../notebook/common/notebookCommon.js";
 import { IWorkspaceSymbol } from "../../../search/common/search.js";
-import { IChatAgentCommand, IChatAgentData, IChatAgentResult, UserSelectedTools } from "../participants/chatAgents.js";
-import { IChatModel, IChatRequestModeInfo, IChatResponseModel } from "../model/chatModel.js";
-import { IChatParserContext } from "../requestParser/chatRequestParser.js";
 import { IChatRequestVariableEntry } from "../attachments/chatVariableEntries.js";
 import { IChatRequestVariableValue } from "../attachments/chatVariables.js";
-import { ChatAgentLocation } from "../constants.js";
-import { IPreparedToolInvocation, IToolConfirmationMessages, IToolResult, IToolResultInputOutputDetails, ToolDataSource } from "../tools/languageModelToolsService.js";
 import { ReadonlyChatSessionOptionsMap } from "../chatSessionsService.js";
+import { ChatAgentLocation, ChatModeKind } from "../constants.js";
+import { IChatModel, IChatRequestModeInfo, IChatResponseModel } from "../model/chatModel.js";
+import { IChatAgentCommand, IChatAgentData, IChatAgentResult, UserSelectedTools } from "../participants/chatAgents.js";
+import { HookTypeValue } from "../promptSyntax/hookTypes.js";
+import { IChatParserContext } from "../requestParser/chatRequestParser.js";
+import { IPreparedToolInvocation, IToolConfirmationMessages, IToolResult, IToolResultInputOutputDetails, ToolDataSource } from "../tools/languageModelToolsService.js";
 export interface IChatRequest {
     message: string;
     variables: Record<string, IChatRequestVariableValue[]>;
@@ -96,6 +96,8 @@ export interface IChatContentReference {
             removed: number;
         };
         originalUri?: URI;
+        /** Overrides the reference URI when opening the modified side of a diff. */
+        modifiedUri?: URI;
         isDeletion?: boolean;
     };
     kind: "reference";
@@ -307,6 +309,7 @@ export interface IChatQuestion {
     allowFreeformInput?: boolean;
     required?: boolean;
     validation?: IChatQuestionValidation;
+    detailedMessage?: string | IMarkdownString;
 }
 /** Answer shape for a single-select question. */
 export interface IChatSingleSelectAnswer {
@@ -339,6 +342,8 @@ export interface IChatQuestionCarousel {
     message?: string | IMarkdownString;
     /** Source attribution (e.g. MCP server) */
     source?: ToolDataSource;
+    /** Terminal ID when the carousel was triggered by a terminal needing input */
+    terminalId?: string;
     kind: "questionCarousel";
 }
 export declare enum ElicitationState {
@@ -526,6 +531,12 @@ export type ConfirmedReason = {
 export interface IChatToolInvocation {
     readonly presentation: IPreparedToolInvocation["presentation"];
     readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData;
+    /**
+     * Observable that tracks the `kind` of `toolSpecificData`. Used by the
+     * tool invocation part to re-render when the kind changes (e.g. from
+     * `'input'` to `'terminal'` when terminal content arrives).
+     */
+    readonly toolSpecificDataKind: IObservable<string | undefined>;
     readonly originMessage: string | IMarkdownString | undefined;
     readonly invocationMessage: string | IMarkdownString;
     readonly pastTenseMessage: string | IMarkdownString | undefined;
@@ -605,6 +616,7 @@ export declare namespace IChatToolInvocation {
     export function awaitPostConfirmation(invocation: IChatToolInvocation, token?: CancellationToken): Promise<ConfirmedReason>;
     export function resultDetails(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): IToolResultInputOutputDetails | import("../tools/languageModelToolsService.js").IToolResultOutputDetails | (URI | Location)[] | IToolResultOutputDetailsSerialized | undefined;
     export function isComplete(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean;
+    export function isEffectivelyHidden(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean;
     export function isStreaming(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean;
     /**
      * Get parameters from invocation. Returns undefined during streaming state.
@@ -709,6 +721,16 @@ export interface IChatModifiedFilesConfirmationData {
     readonly modifiedFiles: readonly {
         readonly uri: UriComponents;
         readonly originalUri?: UriComponents;
+        /**
+         * Optional URI to read the modified (after) content from for the diff
+         * view. When absent, {@link uri} is used as the modified side.
+         */
+        readonly modifiedContentUri?: UriComponents;
+        /**
+         * Optional URI to read the original (before) content from for the diff
+         * view. When absent, {@link originalUri} is used as the original side.
+         */
+        readonly originalContentUri?: UriComponents;
         readonly insertions?: number;
         readonly deletions?: number;
         readonly title?: string;
@@ -729,6 +751,46 @@ export interface IChatMcpServersStartingSerialized {
 export interface IChatDisabledClaudeHooksPart {
     readonly kind: "disabledClaudeHooks";
 }
+/** A single approval option shown in the plan review dropdown button. */
+export interface IChatPlanApprovalAction {
+    label: string;
+    description?: string;
+    default?: boolean;
+    /** When set to 'autopilot', a confirmation dialog is shown before proceeding. */
+    permissionLevel?: "autopilot";
+}
+/** The result of reviewing a plan. */
+export interface IChatPlanReviewResult {
+    action?: string;
+    rejected: boolean;
+    feedback?: string;
+}
+/**
+ * A plan review widget. Presents a title, markdown plan content, an optional
+ * link to edit the backing plan file, a dropdown of approval actions, a reject
+ * button and an optional feedback textarea.
+ */
+export interface IChatPlanReview {
+    kind: "planReview";
+    /** Title to display in the widget header. */
+    title: string;
+    /** Markdown content rendered in the body (plan summary or contents). */
+    content: string;
+    /** Selectable approval actions. Displayed as a dropdown primary button. */
+    actions: IChatPlanApprovalAction[];
+    /** Whether to show the additional feedback textarea. */
+    canProvideFeedback: boolean;
+    /** Optional URI to the underlying plan file. An Edit button opens it. */
+    planUri?: UriComponents;
+    /** Unique identifier for resolving the review back to the extension. */
+    resolveId?: string;
+    /** Stored result once the user has responded. */
+    data?: IChatPlanReviewResult;
+    /** Whether the widget has been responded to. */
+    isUsed?: boolean;
+    /** Source attribution. */
+    source?: ToolDataSource;
+}
 export declare class ChatMcpServersStarting implements IChatMcpServersStarting {
     readonly state: IObservable<IAutostartResult>;
     readonly kind = "mcpServersStarting";
@@ -738,7 +800,7 @@ export declare class ChatMcpServersStarting implements IChatMcpServersStarting {
     wait(): Promise<IAutostartResult>;
     toJSON(): IChatMcpServersStartingSerialized;
 }
-export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart;
+export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatPlanReview | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart;
 export interface IChatFollowup {
     kind: "reply";
     message: string;
@@ -977,6 +1039,7 @@ export interface IChatSendRequestOptions {
     rejectedConfirmationData?: any[];
     attachedContext?: IChatRequestVariableEntry[];
     resolvedVariables?: IChatRequestVariableEntry[];
+    agentHostSessionConfig?: Record<string, string>;
     /** The target agent ID can be specified with this property instead of using @ in 'message' */
     agentId?: string;
     /** agentId, but will not add a @ name to the request */
@@ -996,16 +1059,43 @@ export interface IChatSendRequestOptions {
      * The request stays in the queue until `processPendingRequests` is called explicitly.
      */
     pauseQueue?: boolean;
+    /**
+     * When true, the request is rendered as a compact tool-progress-style line
+     * instead of a full user message bubble. Used for system-initiated notifications
+     * such as terminal command completion.
+     */
+    isSystemInitiated?: boolean;
+    /**
+     * Display label for system-initiated requests. When set, the request row renders
+     * this label as a compact progress-style message instead of the full request text.
+     */
+    systemInitiatedLabel?: string;
+    /**
+     * Structured terminal execution ID for system-initiated terminal notifications.
+     * This avoids parsing IDs from request text when tools need to correlate
+     * terminal prompts with follow-up actions.
+     */
+    terminalExecutionId?: string;
+    /**
+     * When set, the chat service will collect automatic instructions
+     * (for example `.instructions.md` files and skills) asynchronously after showing
+     * the request in the UI, rather than blocking the UI on collection.
+     */
+    instructionContext?: {
+        modeKind: ChatModeKind;
+        enabledTools?: UserSelectedTools;
+        enabledSubAgents?: readonly string[];
+    };
 }
 export type IChatModelReference = IReference<IChatModel>;
 export interface IChatSessionContext {
-    readonly chatSessionResource: URI;
     readonly initialSessionOptions?: ReadonlyChatSessionOptionsMap;
 }
 export declare const KEYWORD_ACTIVIATION_SETTING_ID = "accessibility.voice.keywordActivation";
 export interface IChatSessionStartOptions {
     canUseTools?: boolean;
     disableBackgroundKeepAlive?: boolean;
+    debugOwner?: string;
 }
 export declare const ChatStopCancellationNoopEventName = "chat.stopCancellationNoop";
 export type ChatStopCancellationNoopEvent = {

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

@@ -18,9 +18,6 @@ function isIDocumentContext(obj) {
 function isIUsedContext(obj) {
     return (!!obj && typeof obj === "object" && "documents" in obj && Array.isArray(obj.documents) && obj.documents.every(isIDocumentContext));
 }
-function isChatContentVariableReference(obj) {
-    return !!obj && typeof obj === "object" && typeof obj.variableName === "string";
-}
 var ChatResponseReferencePartStatusKind;
 (function(ChatResponseReferencePartStatusKind) {
     ChatResponseReferencePartStatusKind[ChatResponseReferencePartStatusKind["Complete"] = 1] = "Complete";
@@ -183,6 +180,16 @@ var IChatToolInvocation;
         return state.type === StateKind.Completed || state.type === StateKind.Cancelled;
     }
     IChatToolInvocation.isComplete = isComplete;
+    function isEffectivelyHidden(invocation, reader) {
+        if (invocation.presentation === "hidden") {
+            return true;
+        }
+        if (invocation.presentation === "hiddenAfterComplete" && isComplete(invocation, reader)) {
+            return true;
+        }
+        return false;
+    }
+    IChatToolInvocation.isEffectivelyHidden = isEffectivelyHidden;
     function isStreaming(invocation, reader) {
         if (invocation.kind === "toolInvocationSerialized") {
             return false;
@@ -304,4 +311,4 @@ var ChatRequestQueueKind;
 const ChatStopCancellationNoopEventName = "chat.stopCancellationNoop";
 const ChatPendingRequestChangeEventName = "chat.pendingRequestChange";
 
-export { ChatAgentVoteDirection, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ChatSendResult, ChatStopCancellationNoopEventName, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, isChatContentVariableReference, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };
+export { ChatAgentVoteDirection, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ChatSendResult, ChatStopCancellationNoopEventName, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };

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

@@ -5,8 +5,9 @@ import { URI } from "../../../../../base/common/uri.js";
 import { ChatAgentLocation } from "../constants.js";
 import { IChatEditingSession } from "../editing/chatEditingService.js";
 import { IChatModel, IExportableChatData, ISerializableChatData, IChatRequestModel, IChatRequestVariableData } from "../model/chatModel.js";
+import { IChatModelReferenceDebugSnapshot } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/model/chatModelStore";
 import { IParsedChatRequest } from "../requestParser/chatParserTypes.js";
-import { IChatSessionStartOptions, IChatModelReference, IChatSessionContext, IChatSendRequestOptions, ChatSendResult, IChatProgress, ChatRequestQueueKind, IChatCompleteResponse, IChatDetail, IChatUserActionEvent, IChatQuestionAnswers } from "./chatService.js";
+import { IChatSessionStartOptions, IChatModelReference, IChatSendRequestOptions, ChatSendResult, IChatProgress, ChatRequestQueueKind, IChatCompleteResponse, IChatDetail, IChatUserActionEvent, IChatQuestionAnswers } from "./chatService.js";
 export declare const IChatService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatService>;
 export interface IChatService {
     _serviceBrand: undefined;
@@ -40,19 +41,19 @@ export interface IChatService {
     *
     * @returns A reference to the session's model or undefined if there is no active session for the given resource.
     */
-    acquireExistingSession(sessionResource: URI): IChatModelReference | undefined;
+    acquireExistingSession(sessionResource: URI, debugOwner?: string): IChatModelReference | undefined;
     /**
     * Tries to acquire an existing a chat session for the resource. If no session exists, tries to load one for the given
     * session resource and location. This may load the session from an external provider.
     *
     * @returns A reference to the session's model, or undefined if the session could not be loaded
     */
-    acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken): Promise<IChatModelReference | undefined>;
+    acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken, debugOwner?: string): Promise<IChatModelReference | undefined>;
     /**
     * Loads a session from exported chat data
     */
-    loadSessionFromData(data: IExportableChatData | ISerializableChatData): IChatModelReference;
-    getChatSessionFromInternalUri(sessionResource: URI): IChatSessionContext | undefined;
+    loadSessionFromData(data: IExportableChatData | ISerializableChatData, debugOwner?: string): IChatModelReference;
+    getChatModelReferenceDebugInfo(): IChatModelReferenceDebugSnapshot;
     /**
     * Sends a chat request for the given session.
     * @returns A result indicating whether the request was sent, queued, or rejected.

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

@@ -25,6 +25,7 @@ export interface IChatSessionProviderOptionItem {
     readonly id: string;
     readonly name: string;
     readonly description?: string;
+    readonly detail?: string;
     readonly locked?: boolean;
     readonly icon?: ThemeIcon;
     readonly default?: boolean;
@@ -39,9 +40,9 @@ export interface IChatSessionProviderOptionGroup {
     readonly id: string;
     readonly name: string;
     readonly description?: string;
+    readonly detail?: string;
+    readonly selected?: IChatSessionProviderOptionItem;
     readonly items: readonly IChatSessionProviderOptionItem[];
-    readonly searchable?: boolean;
-    readonly onSearch?: (query: string, token: CancellationToken) => Thenable<IChatSessionProviderOptionItem[]>;
     /**
      * A context key expression that controls visibility of this option group picker.
      * When specified, the picker is only visible when the expression evaluates to true.
@@ -94,10 +95,6 @@ export interface IChatSessionsExtensionPoint {
      * for this session type. Defaults to false when not specified.
      */
     readonly autoAttachReferences?: boolean;
-    /**
-     * When true, uses the incoming request's mode instructions to populate the built-in pickers such as Agent and Model pickers. When false, the pickers are populated based on the session type as they have been before. This is useful for testing the new ChatRequestTurn2-based flow for populating pickers.
-     */
-    readonly useRequestToPopulateBuiltInPickers?: boolean;
 }
 export interface IChatSessionItem {
     readonly resource: URI;
@@ -152,10 +149,6 @@ export type IChatSessionRequestHistoryItem = Extract<IChatSessionHistoryItem, {
  * The session type used for local agent chat sessions.
  */
 export declare const localChatSessionType = "local";
-/**
- * The option ID used for selecting the agent in chat sessions.
- */
-export declare const agentOptionId = "agent";
 export interface IChatSession extends IDisposable {
     readonly onWillDispose: Event<void>;
     readonly sessionResource: URI;
@@ -207,6 +200,7 @@ export interface IChatSessionItemController {
     get items(): readonly IChatSessionItem[];
     refresh(token: CancellationToken): Promise<void>;
     newChatSessionItem?(request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+    getNewChatSessionInputState?(sessionResource: URI, token: CancellationToken): Promise<readonly IChatSessionProviderOptionGroup[] | undefined>;
 }
 export interface IChatSessionOptionsChangeEvent {
     readonly sessionResource: URI;

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

@@ -9,7 +9,6 @@ var ChatSessionStatus;
     ChatSessionStatus[ChatSessionStatus["NeedsInput"] = 3] = "NeedsInput";
 })(ChatSessionStatus || (ChatSessionStatus = {}));
 const localChatSessionType = "local";
-const agentOptionId = "agent";
 var ChatSessionOptionsMap;
 (function(ChatSessionOptionsMap) {
     function fromRecord(obj) {
@@ -18,7 +17,8 @@ var ChatSessionOptionsMap;
     ChatSessionOptionsMap.fromRecord = fromRecord;
     function toRecord(map) {
         const record = Object.create(null);
-        for (const [key, value] of map) {
+        const entries = ensureIterable(map);
+        for (const [key, value] of entries) {
             record[key] = value;
         }
         return record;
@@ -28,12 +28,19 @@ var ChatSessionOptionsMap;
         if (!map) {
             return undefined;
         }
-        return Array.from(map, ([optionId, value]) => ({
+        const entries = ensureIterable(map);
+        return Array.from(entries, ([optionId, value]) => ({
             optionId,
             value: typeof value === "string" ? value : value.id
         }));
     }
     ChatSessionOptionsMap.toStrValueArray = toStrValueArray;
+    function ensureIterable(map) {
+        if (map instanceof Map) {
+            return map;
+        }
+        return Object.entries(map);
+    }
 })(ChatSessionOptionsMap || (ChatSessionOptionsMap = {}));
 function isSessionInProgressStatus(state) {
     return state === ChatSessionStatus.InProgress || state === ChatSessionStatus.NeedsInput;
@@ -43,4 +50,4 @@ function isIChatSessionFileChange2(obj) {
     return candidate && candidate.uri instanceof URI && typeof candidate.insertions === "number" && typeof candidate.deletions === "number";
 }
 
-export { ChatSessionOptionsMap, ChatSessionStatus, agentOptionId, isIChatSessionFileChange2, isSessionInProgressStatus, localChatSessionType };
+export { ChatSessionOptionsMap, ChatSessionStatus, isIChatSessionFileChange2, isSessionInProgressStatus, localChatSessionType };

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

@@ -97,9 +97,12 @@ export interface IChatSessionsService {
     forkChatSession(sessionResource: URI, request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken): Promise<IChatSessionItem>;
     readonly onDidChangeOptionGroups: Event<string>;
     getOptionGroupsForSessionType(chatSessionType: string): IChatSessionProviderOptionGroup[] | undefined;
-    setOptionGroupsForSessionType(chatSessionType: string, handle: number, optionGroups?: IChatSessionProviderOptionGroup[]): void;
-    getNewSessionOptionsForSessionType(chatSessionType: string): ReadonlyChatSessionOptionsMap | undefined;
-    setNewSessionOptionsForSessionType(chatSessionType: string, options: ReadonlyChatSessionOptionsMap): void;
+    setOptionGroupsForSessionType(chatSessionType: string, handle: number, optionGroups?: readonly IChatSessionProviderOptionGroup[]): void;
+    /**
+    * Get the default options for new sessions of this type, derived from option groups'
+    * `selected` or `default` items.
+    */
+    getNewChatSessionInputState(chatSessionType: string, sessionResource: URI): Promise<readonly IChatSessionProviderOptionGroup[] | undefined>;
     /**
     * Creates a new chat session item using the controller's newChatSessionItemHandler.
     * Returns undefined if the controller doesn't have a handler or if no controller is registered.