@codingame/monaco-vscode-api 34.1.3 → 35.0.0

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

@@ -1,6 +1,7 @@
 import { IAction } from "../../../../../base/common/actions.js";
 import { DeferredPromise } from "../../../../../base/common/async.js";
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { IStringDictionary } from "../../../../../base/common/collections.js";
 import { Event } from "../../../../../base/common/event.js";
 import { IMarkdownString } from "../../../../../base/common/htmlContent.js";
 import { IReference } from "../../../../../base/common/lifecycle.js";
@@ -125,8 +126,19 @@ export interface IChatUsage {
     completionTokens: number;
     outputBuffer?: number;
     promptTokenDetails?: readonly IChatUsagePromptTokenDetail[];
+    copilotCredits?: number;
+    /**
+     * The language-model ID that actually served the request. Set when a
+     * meta-model (e.g. "auto") routes to a concrete model so consumers
+     * can look up the real model's metadata (context window size, etc.).
+     */
+    actualModelId?: string;
     kind: "usage";
 }
+/**
+ * Formats a copilot credit value for display.
+ */
+export declare function formatCopilotCredits(credits: number): string;
 export interface IChatContentInlineReference {
     resolveId?: string;
     inlineReference: URI | Location | IWorkspaceSymbol;
@@ -183,6 +195,10 @@ export interface IChatProgressMessage {
     kind: "progressMessage";
     shimmer?: boolean;
 }
+export interface IChatSystemNotificationPart {
+    content: IMarkdownString;
+    kind: "systemNotification";
+}
 export interface IChatTask extends IChatTaskDto {
     deferred: DeferredPromise<string | void>;
     progress: (IChatWarningMessage | IChatContentReference)[];
@@ -433,6 +449,22 @@ export interface IChatThinkingPart {
     };
     generatedTitle?: string;
 }
+/**
+ * A progress part representing an auto-mode model routing resolution.
+ * Shown as a collapsible widget in the chat stream: collapsed displays
+ * "Routed to <model>", expanded shows routing details and confidence.
+ */
+export interface IChatAutoModeResolutionPart {
+    kind: "autoModeResolution";
+    /** The model ID that was selected by the router */
+    resolvedModel: string;
+    /** The user-facing display name of the resolved model */
+    resolvedModelName: string;
+    /** The router's classification label */
+    predictedLabel: "needs_reasoning" | "no_reasoning" | "fallback";
+    /** Confidence score (0-1) from the router */
+    confidence: number;
+}
 /**
  * A progress part representing the execution result of a hook.
  * Aligned with the hook output JSON structure: { stopReason, systemMessage, hookSpecificOutput }.
@@ -463,6 +495,12 @@ export interface IChatTerminalToolInvocationData {
         forDisplay?: string;
         isSandboxWrapped?: boolean;
     };
+    /**
+     * LM-generated intention describing why the command is being run, shown
+     * above the command in the terminal tool card. Set by the Agent Host; the
+     * built-in terminal tool leaves this unset.
+     */
+    intention?: string;
     /** The working directory URI for the terminal */
     cwd?: UriComponents;
     /**
@@ -529,6 +567,10 @@ export interface IChatTerminalToolInvocationData {
     autoApproveInfo?: IMarkdownString;
     /** Names of missing sandbox dependencies that the user may choose to install */
     missingSandboxDependencies?: string[];
+    /** Approved repair actions that may make an installed but unusable sandbox dependency work. */
+    sandboxRemediations?: string[];
+    /** User-visible reason a sandbox prerequisite cannot be repaired automatically. */
+    sandboxPrerequisiteFailure?: string;
 }
 /**
  * @deprecated This is the old API shape, we should support this for a while before removing it so
@@ -540,18 +582,47 @@ export interface ILegacyChatTerminalToolInvocationData {
     language: string;
 }
 export declare function isLegacyChatTerminalToolInvocationData(data: unknown): data is ILegacyChatTerminalToolInvocationData;
+/**
+ * Routing information for an MCP App's webview sub-RPCs. The kind
+ * determines where `tools/call`, `resources/read`,
+ * `sampling/createMessage`, etc. are sent:
+ *
+ * - `local`: resolves the MCP server via {@link IMcpService} from a
+ *   `serverDefinitionId` + `collectionId`. Used for locally-configured
+ *   MCP servers whose state lives in the workbench.
+ * - `agentHost`: routes through {@link IAgentHostService.handleMcpRequest}
+ *   on an AHP `mcp://` side channel. Used for MCP servers owned by an
+ *   agent host (e.g. Copilot CLI).
+ */
+export type ChatMcpAppData = {
+    kind: "local";
+    /** URI of the UI resource for rendering (e.g., "ui://weather-server/dashboard") */
+    resourceUri: string;
+    /** Reference to the server definition for reconnection */
+    serverDefinitionId: string;
+    /** Reference to the collection containing the server */
+    collectionId: string;
+} | {
+    kind: "agentHost";
+    /** URI of the UI resource for rendering (e.g., "ui://weather-server/dashboard") */
+    resourceUri: string;
+    /** AHP `mcp://` channel URI for the originating server. */
+    channel: string;
+    /**
+     * Stable identifier for the originating server, used as the
+     * additional key when computing the webview origin. Typically the
+     * AHP customization id. For top-level (bare) MCP servers this id
+     * is currently session-scoped, so see {@link ChatMcpAppModel} for
+     * how it avoids growing persistent application storage on every
+     * new session.
+     */
+    serverId: string;
+};
 export interface IChatToolInputInvocationData {
     kind: "input";
     rawInput: any;
     /** Optional MCP App UI metadata for rendering during and after tool execution */
-    mcpAppData?: {
-        /** URI of the UI resource for rendering (e.g., "ui://weather-server/dashboard") */
-        resourceUri: string;
-        /** Reference to the server definition for reconnection */
-        serverDefinitionId: string;
-        /** Reference to the collection containing the server */
-        collectionId: string;
-    };
+    mcpAppData?: ChatMcpAppData;
 }
 export declare enum ToolConfirmKind {
     Denied = 0,
@@ -581,7 +652,7 @@ export type ConfirmedReason = {
 };
 export interface IChatToolInvocation {
     readonly presentation: IPreparedToolInvocation["presentation"];
-    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData;
+    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData;
     /**
      * Observable that tracks the `kind` of `toolSpecificData`. Used by the
      * tool invocation part to re-render when the kind changes (e.g. from
@@ -691,7 +762,7 @@ export interface IToolResultOutputDetailsSerialized {
  */
 export interface IChatToolInvocationSerialized {
     presentation: IPreparedToolInvocation["presentation"];
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData;
     invocationMessage: string | IMarkdownString;
     originMessage: string | IMarkdownString | undefined;
     pastTenseMessage: string | IMarkdownString | undefined;
@@ -726,11 +797,21 @@ export interface IChatPullRequestContent {
 }
 export interface IChatSubagentToolInvocationData {
     kind: "subagent";
+    isActive?: boolean;
     description?: string;
     agentName?: string;
     prompt?: string;
     result?: string;
     modelName?: string;
+    credits?: number;
+    /**
+     * Resource (URI string) of the subagent's own chat, when the subagent runs as
+     * a distinct chat (e.g. an agent host worker chat). Used to offer an "Open
+     * chat" link that reveals the subagent's read-only chat. Undefined when the
+     * subagent has no separately-openable chat. A string (not a `URI`) so it stays
+     * serializable across the extension host protocol.
+     */
+    chatResource?: string;
 }
 /**
  * Progress type for external tool invocation updates from extensions.
@@ -791,6 +872,53 @@ export interface IChatModifiedFilesConfirmationData {
         readonly description?: string;
     }[];
 }
+/**
+ * Confirmation data for the agent host `viewUnreviewedComments` tool. The
+ * comments themselves are not carried here: the renderer fetches them (and
+ * performs reveal/delete/accept actions) through commands registered by the
+ * agent feedback feature, so this workbench/chat layer stays decoupled from the
+ * `vs/sessions` feedback model. The renderer resolves the owning session from
+ * its render context. Only the confirmation button labels are needed up front.
+ */
+export interface IChatAgentFeedbackReviewConfirmationData {
+    readonly kind: "agentFeedbackReviewConfirmation";
+    /** Confirmation button labels (first is the primary/approve action). */
+    readonly options: readonly string[];
+}
+/**
+ * A single unreviewed comment shown in the {@link IChatAgentFeedbackReviewConfirmationData}
+ * confirmation. Produced by {@link AgentFeedbackReviewCommandId.GetComments}.
+ */
+export interface IChatAgentFeedbackReviewComment {
+    readonly id: string;
+    /** Localized origin label, e.g. "PR Review" or "Agent Review"; absent for user-authored comments. */
+    readonly kindLabel?: string;
+    /** The comment body. */
+    readonly text: string;
+    /** The file the comment is anchored to. */
+    readonly fileUri: UriComponents;
+}
+/**
+ * Command ids the agent feedback review confirmation renderer (workbench/chat)
+ * uses to fetch unreviewed comments and apply the user's selection. They are
+ * implemented by the agent feedback feature in `vs/sessions`, keeping the chat
+ * layer decoupled from the feedback model. Most take the owning session resource
+ * (`UriComponents`) as their first argument; {@link AgentFeedbackReviewCommandId.RevealAt}
+ * instead resolves the session from the file resource so a rendered tool call
+ * can link to a comment without knowing the session URI.
+ */
+export declare enum AgentFeedbackReviewCommandId {
+    /** `(sessionResource)` -> `IChatAgentFeedbackReviewComment[]` (the `created` reviewable comments). */
+    GetComments = "_agentFeedbackReview.getComments",
+    /** `(sessionResource, commentId)` -> opens the file and reveals the comment. */
+    Reveal = "_agentFeedbackReview.reveal",
+    /** `(resourceUri, range)` -> resolves the owning session and reveals the comment at that file range. */
+    RevealAt = "_agentFeedbackReview.revealAt",
+    /** `(sessionResource, commentId)` -> deletes the comment entirely. */
+    Delete = "_agentFeedbackReview.delete",
+    /** `(sessionResource, commentIds)` -> accepts (reveals) the given comments. */
+    Accept = "_agentFeedbackReview.accept"
+}
 export interface IChatMcpServersStarting {
     readonly kind: "mcpServersStarting";
     readonly state?: IObservable<IAutostartResult>;
@@ -802,6 +930,41 @@ export interface IChatMcpServersStartingSerialized {
     readonly state?: undefined;
     didStartServerIds?: string[];
 }
+export interface IChatMcpAuthenticationRequired {
+    readonly kind: "mcpAuthenticationRequired";
+    readonly sessionResource: UriComponents;
+    readonly servers: IObservable<readonly IChatMcpAuthenticationRequiredServer[]>;
+    isUsed: boolean;
+}
+export interface IChatMcpAuthenticationRequiredServer {
+    readonly id: string;
+    readonly name: string;
+    readonly resource: string;
+    readonly authorizationServers?: readonly string[];
+    readonly requiredScopes?: readonly string[];
+    readonly reason?: string;
+}
+/**
+ * Surfaced by agent-host sessions when one or more MCP servers are still in the
+ * {@link McpServerStatus.Starting starting} state a noticeable time after a
+ * turn began without any content arriving from the host. The part lists the
+ * servers still starting and updates dynamically via {@link servers}: it hides
+ * itself (by emptying the observable) once every server has started, content
+ * starts being received, or the turn ends — whichever happens first.
+ *
+ * Unlike {@link IChatMcpServersStarting} (used by the in-process MCP autostart
+ * flow), this is a lightweight progress hint with no interactive affordance
+ * (there is no "Skip" button).
+ */
+export interface IChatMcpServersStartingSlow {
+    readonly kind: "mcpServersStartingSlow";
+    readonly sessionResource: UriComponents;
+    readonly servers: IObservable<readonly IChatMcpStartingServer[]>;
+}
+export interface IChatMcpStartingServer {
+    readonly id: string;
+    readonly name: string;
+}
 export interface IChatDisabledClaudeHooksPart {
     readonly kind: "disabledClaudeHooks";
 }
@@ -875,7 +1038,7 @@ export declare class ChatMcpServersStarting implements IChatMcpServersStarting {
     wait(): Promise<IAutostartResult>;
     toJSON(): IChatMcpServersStartingSerialized;
 }
-export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatUsage | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatInfoMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatExternalEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatPlanReview | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart;
+export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatUsage | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatSystemNotificationPart | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatInfoMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatExternalEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatPlanReview | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatMcpAuthenticationRequired | IChatMcpServersStartingSlow | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart | IChatAutoModeResolutionPart;
 export interface IChatFollowup {
     kind: "reply";
     message: string;
@@ -1109,6 +1272,13 @@ export declare enum ChatRequestQueueKind {
 export interface IChatSendRequestOptions {
     modeInfo?: IChatRequestModeInfo;
     userSelectedModelId?: string;
+    /**
+     * The configuration (e.g. context size, thinking effort) for the selected
+     * model as scoped to the requesting editor. When set, it takes precedence
+     * over the global per-model configuration so the value sent matches what the
+     * editor displays. See issue #320393.
+     */
+    userSelectedModelConfiguration?: IStringDictionary<unknown>;
     userSelectedTools?: IObservable<UserSelectedTools>;
     location?: ChatAgentLocation;
     locationData?: IChatLocationData;

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

@@ -34,6 +34,9 @@ var ChatResponseClearToPreviousToolInvocationReason;
 })(
     ChatResponseClearToPreviousToolInvocationReason || (ChatResponseClearToPreviousToolInvocationReason = {})
 );
+function formatCopilotCredits(credits) {
+    return ( parseFloat(credits.toFixed(1)).toString());
+}
 var ElicitationState;
 (function(ElicitationState) {
     ElicitationState["Pending"] = "pending";
@@ -221,6 +224,14 @@ var IChatToolInvocation;
     }
     IChatToolInvocation.getConfirmationMessages = getConfirmationMessages;
 })(IChatToolInvocation || (IChatToolInvocation = {}));
+var AgentFeedbackReviewCommandId;
+(function(AgentFeedbackReviewCommandId) {
+    AgentFeedbackReviewCommandId["GetComments"] = "_agentFeedbackReview.getComments";
+    AgentFeedbackReviewCommandId["Reveal"] = "_agentFeedbackReview.reveal";
+    AgentFeedbackReviewCommandId["RevealAt"] = "_agentFeedbackReview.revealAt";
+    AgentFeedbackReviewCommandId["Delete"] = "_agentFeedbackReview.delete";
+    AgentFeedbackReviewCommandId["Accept"] = "_agentFeedbackReview.accept";
+})(AgentFeedbackReviewCommandId || (AgentFeedbackReviewCommandId = {}));
 class ChatMcpServersStarting {
     get isEmpty() {
         const s = this.state.get();
@@ -311,4 +322,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, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };
+export { AgentFeedbackReviewCommandId, ChatAgentVoteDirection, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ChatSendResult, ChatStopCancellationNoopEventName, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, formatCopilotCredits, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };

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

@@ -95,6 +95,13 @@ export interface IChatService {
     * as needed. Idempotent, safe to call at any time.
     */
     processPendingRequests(sessionResource: URI): void;
+    /**
+    * Cancels the in-flight request and immediately sends a single pending
+    * (queued or steering) request. Local sessions move it to the front and
+    * dequeue it; server-managed (agent host) sessions re-send it as a normal
+    * turn, since the server does not drain its queue on cancellation.
+    */
+    sendPendingRequestImmediately(sessionResource: URI, requestId: string): Promise<void>;
     addCompleteRequest(sessionResource: URI, message: IParsedChatRequest | string, variableData: IChatRequestVariableData | undefined, attempt: number | undefined, response: IChatCompleteResponse): void;
     setChatSessionTitle(sessionResource: URI, title: string): void;
     getLocalSessionHistory(): Promise<IChatDetail[]>;

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

@@ -6,11 +6,23 @@ import { IObservable } from "../../../../base/common/observable.js";
 import { ThemeIcon } from "../../../../base/common/themables.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IPosition } from "../../../../editor/common/core/position.js";
+import { ServicesAccessor } from "../../../../platform/instantiation/common/instantiation.js";
 import { IChatAgentAttachmentCapabilities, IChatAgentRequest } from "./participants/chatAgents.js";
 import { IChatEditingSession } from "./editing/chatEditingService.js";
 import { IChatRequestModeInstructions, IChatRequestVariableData, ISerializableChatModelInputState } from "./model/chatModel.js";
-import { IChatProgress, IChatSessionTiming } from "./chatService/chatService.js";
+import { IChatProgress, IChatResponseErrorDetails, IChatSessionTiming } from "./chatService/chatService.js";
 import { Target } from "./promptSyntax/promptTypes.js";
+export declare enum ChatSessionsExtensions {
+    AsyncActivation = "workbench.contrib.chatSessions.asyncActivation"
+}
+export interface IAsyncChatSessionActivationContribution {
+    matchSessionType(sessionType: string): boolean;
+    waitForActivation(accessor: ServicesAccessor, sessionType: string): Promise<boolean>;
+}
+export interface IAsyncChatSessionActivationRegistry {
+    register(contribution: IAsyncChatSessionActivationContribution): IDisposable;
+    getActivators(sessionType: string): readonly IAsyncChatSessionActivationContribution[];
+}
 export declare enum ChatSessionStatus {
     Failed = 0,
     Completed = 1,
@@ -34,9 +46,11 @@ export interface IChatSessionProviderOptionModelMetadata {
     readonly inputCost?: number;
     readonly outputCost?: number;
     readonly cacheCost?: number;
+    readonly cacheWriteCost?: number;
     readonly longContextInputCost?: number;
     readonly longContextOutputCost?: number;
     readonly longContextCacheCost?: number;
+    readonly longContextCacheWriteCost?: number;
     readonly priceCategory?: string;
     readonly maxInputTokens?: number;
     readonly maxOutputTokens?: number;
@@ -121,6 +135,29 @@ export interface IChatSessionsExtensionPoint {
      */
     readonly customAgentTarget?: Target;
     readonly requiresCustomModels?: boolean;
+    /**
+     * Whether this session type supports the synthetic "Auto" model fallback.
+     * Defaults to true. When false and no models are available, the picker
+     * shows a "No models available" state instead of "Auto".
+     *
+     * This is distinct from {@link requiresCustomModels}, which only controls
+     * whether the picker is filtered to the session's own model pool — a
+     * session can own a custom pool yet still support Auto (e.g. the Copilot
+     * CLI agent host).
+     */
+    readonly supportsAutoModel?: boolean;
+    /**
+     * Logical Agent Host provider ID for Agent Host-backed chat sessions.
+     * For example, both local `agent-host-copilotcli` and remote
+     * `remote-{authority}-copilotcli` sessions use `copilotcli`.
+     */
+    readonly agentHostProviderId?: string;
+    /**
+     * Whether this type needs a GitHub Copilot account and so is unusable until the user signs in. Set by
+     * Copilot-backed types (Copilot CLI / agent host, cloud agent) where BYOK isn't supported. Defaults to false, so
+     * third-party types that don't depend on Copilot stay usable while signed out.
+     */
+    readonly requiresCopilotSignIn?: boolean;
     /**
      * When false, the delegation picker is hidden for this session type.
      * Defaults to true.
@@ -181,6 +218,7 @@ export interface IChatSessionFileChange {
     readonly originalUri?: URI;
     readonly insertions: number;
     readonly deletions: number;
+    readonly reviewed?: boolean;
 }
 export interface IChatSessionFileChange2 {
     readonly uri: URI;
@@ -188,6 +226,7 @@ export interface IChatSessionFileChange2 {
     readonly modifiedUri?: URI;
     readonly insertions: number;
     readonly deletions: number;
+    readonly reviewed?: boolean;
 }
 export type IChatSessionHistoryItem = {
     id?: string;
@@ -205,6 +244,12 @@ export type IChatSessionHistoryItem = {
     parts: IChatProgress[];
     participant: string;
     details?: string;
+    /**
+     * Error details for a failed response. Rendered as a proper chat error
+     * (including the quota-exceeded upgrade affordance), mirroring the live
+     * agent result's `errorDetails`.
+     */
+    errorDetails?: IChatResponseErrorDetails;
 };
 export type IChatSessionRequestHistoryItem = Extract<IChatSessionHistoryItem, {
     type: "request";
@@ -226,6 +271,8 @@ export declare namespace SessionType {
     const Codex = "openai-codex";
     const Growth = "copilot-growth";
     const AgentHostCopilot = "agent-host-copilotcli";
+    const AgentHostClaude = "agent-host-claude";
+    const AgentHostCodex = "agent-host-codex";
 }
 /**
  * Returns whether the given session type is a local agent host target.
@@ -290,6 +337,8 @@ export interface IChatSession extends IDisposable {
 }
 export interface IChatSessionContentProvider {
     provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
+    /** Resolves a parsed response Markdown URI before it is sanitized and rendered. */
+    resolveChatResponseUri?(sessionResource: URI, href: string, kind: "link" | "image"): string;
     /**
      * Optional. Compute completion items for an input being composed in this
      * session. Returning `undefined` lets the workbench fall back to its
@@ -418,6 +467,12 @@ export interface IChatSessionItemController {
     newChatSessionItem?(request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
     getNewChatSessionInputState?(sessionResource: URI, token: CancellationToken): Promise<readonly IChatSessionProviderOptionGroup[] | undefined>;
     resolveChatSessionItem?(resource: URI, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+    /**
+     * Permanently delete the session identified by `resource`. Implementations should tear down any backend state for
+     * the session. The controller is expected to fire an `onDidChangeChatSessionItems` event with the removed resource
+     * as a result of the deletion.
+     */
+    deleteChatSessionItem?(resource: URI, token: CancellationToken): Promise<void>;
 }
 export interface IChatSessionOptionsChangeEvent {
     readonly sessionResource: URI;

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

@@ -1,6 +1,28 @@
 
 import { URI } from '../../../../base/common/uri.js';
+import { isRemoteAgentHostSessionType } from '../../../../platform/agentHost/common/agentHostSessionType.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { LOCAL_AGENT_HOST_SCHEME_PREFIX } from '../../../../platform/agentHost/common/agentHostConnectionsService.js';
 
+var ChatSessionsExtensions;
+(function(ChatSessionsExtensions) {
+    ChatSessionsExtensions["AsyncActivation"] = "workbench.contrib.chatSessions.asyncActivation";
+})(ChatSessionsExtensions || (ChatSessionsExtensions = {}));
+class AsyncChatSessionActivationRegistry {
+    constructor() {
+        this._contributions = ( new Set());
+    }
+    register(contribution) {
+        this._contributions.add(contribution);
+        return {
+            dispose: () => this._contributions.delete(contribution)
+        };
+    }
+    getActivators(sessionType) {
+        return Array.from(this._contributions).filter(contribution => contribution.matchSessionType(sessionType));
+    }
+}
+Registry.add(ChatSessionsExtensions.AsyncActivation, ( new AsyncChatSessionActivationRegistry()));
 var ChatSessionStatus;
 (function(ChatSessionStatus) {
     ChatSessionStatus[ChatSessionStatus["Failed"] = 0] = "Failed";
@@ -17,12 +39,14 @@ var SessionType;
     SessionType.Codex = "openai-codex";
     SessionType.Growth = "copilot-growth";
     SessionType.AgentHostCopilot = "agent-host-copilotcli";
+    SessionType.AgentHostClaude = "agent-host-claude";
+    SessionType.AgentHostCodex = "agent-host-codex";
 })(SessionType || (SessionType = {}));
 function isLocalAgentHostTarget(target) {
-    return target === SessionType.AgentHostCopilot || target.startsWith("agent-host-");
+    return target === SessionType.AgentHostCopilot || target.startsWith(LOCAL_AGENT_HOST_SCHEME_PREFIX);
 }
 function isRemoteAgentHostTarget(target) {
-    return target.startsWith("remote-");
+    return isRemoteAgentHostSessionType(target);
 }
 function isAgentHostTarget(target) {
     return isLocalAgentHostTarget(target) || isRemoteAgentHostTarget(target);
@@ -69,4 +93,4 @@ function isIChatSessionFileChange2(obj) {
     return candidate && candidate.uri instanceof URI && typeof candidate.insertions === "number" && typeof candidate.deletions === "number";
 }
 
-export { ChatSessionOptionsMap, ChatSessionStatus, SessionType, isAgentHostTarget, isIChatSessionFileChange2, isLocalAgentHostTarget, isRemoteAgentHostTarget, isSessionInProgressStatus, localChatSessionType };
+export { ChatSessionOptionsMap, ChatSessionStatus, ChatSessionsExtensions, SessionType, isAgentHostTarget, isIChatSessionFileChange2, isLocalAgentHostTarget, isRemoteAgentHostTarget, isSessionInProgressStatus, localChatSessionType };

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

@@ -62,6 +62,8 @@ export interface IChatSessionsService {
     registerChatSessionContentProvider(scheme: string, provider: IChatSessionContentProvider): IDisposable;
     canResolveChatSession(sessionType: string): Promise<boolean>;
     getOrCreateChatSession(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
+    /** Resolves a parsed response Markdown URI through its session content provider. */
+    resolveChatResponseUri(sessionResource: URI, href: string, kind: "link" | "image"): string;
     /**
     * Compute completion items for an input being composed in the chat
     * session identified by `sessionResource`. Delegates to the registered
@@ -101,6 +103,19 @@ export interface IChatSessionsService {
     */
     requiresCustomModelsForSessionType(chatSessionType: string): boolean;
     /**
+    * Returns whether the session type supports the synthetic "Auto" model
+    * fallback. The built-in local chat always supports it; contributed session
+    * types default to `false` unless they set `supportsAutoModel`. When false
+    * and no models are available, the picker shows a "No models available"
+    * state instead of "Auto".
+    */
+    supportsAutoModelForSessionType(chatSessionType: string): boolean;
+    /**
+    * Whether the session type needs a Copilot account and so is unusable until the user signs in (BYOK isn't
+    * supported). Defaults to false, so third-party types stay usable while signed out.
+    */
+    requiresCopilotSignInForSessionType(chatSessionType: string): boolean;
+    /**
     * Returns whether the session type supports delegation.
     * Defaults to true when not explicitly set.
     */
@@ -142,11 +157,48 @@ export interface IChatSessionsService {
     */
     createNewChatSessionItem(chatSessionType: string, request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
     /**
-    * Registers an alias so that session-option lookups by the real resource
-    * are redirected to the canonical (untitled) resource in the internal session map.
+    * Permanently deletes a chat session item by delegating to the registered controller's `deleteChatSessionItem`
+    * handler. Throws if the controller does not implement `deleteChatSessionItem`.
+    */
+    deleteChatSessionItem(sessionResource: URI, token: CancellationToken): Promise<void>;
+    /**
+    * Records the inverse `real → untitled` alias so option lookups for the real
+    * session resolve to the untitled session's entry (e.g. {@link updateSessionOptions}).
+    *
+    * Call this BEFORE the real session loads, and never remove it — the real
+    * session keeps reading its options through this alias even after the untitled
+    * model is disposed. (Only the forward mapping is cleared, via
+    * {@link clearMaterializedSessionResource}.) Publishing the forward mapping is a
+    * separate step; see {@link setMaterializedSessionResource}.
     */
     registerSessionResourceAlias(untitledResource: URI, realResource: URI): void;
     /**
+    * Records the forward `untitled → real` mapping (read via
+    * {@link getMaterializedSessionResource}) so a late send still addressed to the
+    * untitled resource re-targets the real session. Call this only AFTER the real
+    * session has loaded.
+    *
+    * Kept separate from {@link registerSessionResourceAlias} on purpose: the
+    * inverse alias must exist BEFORE the load (for option lookups), but this
+    * forward mapping must appear only AFTER the real session exists — published
+    * earlier, a failed or still-loading session would be re-targeted before it
+    * exists (a later send would throw "Unknown session").
+    */
+    setMaterializedSessionResource(untitledResource: URI, realResource: URI): void;
+    /**
+    * Returns the real session resource that `untitledResource` materialized
+    * into (via {@link setMaterializedSessionResource}), or `undefined` if it has
+    * not materialized or the mapping was already cleared.
+    */
+    getMaterializedSessionResource(untitledResource: URI): URI | undefined;
+    /**
+    * Clears the forward `untitled → real` mapping for `sessionResource` (passed
+    * either the untitled key or the real value), so {@link getMaterializedSessionResource}
+    * stops re-targeting once the session is disposed. Does NOT remove the inverse
+    * alias, which is intentionally permanent (see {@link registerSessionResourceAlias}).
+    */
+    clearMaterializedSessionResource(sessionResource: URI): void;
+    /**
     * Fires {@link onDidCommitSession} to notify listeners that an untitled
     * session has been committed with a real resource URI.
     */