@codingame/monaco-vscode-api 36.2.7 → 37.0.0

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

@@ -1,4 +1,5 @@
 
+import { localize } from '../../../../../nls.js';
 import { DisposableStore } from '../../../../../base/common/lifecycle.js';
 import '../../../../../base/common/observableInternal/index.js';
 import { hasKey } from '../../../../../base/common/types.js';
@@ -37,6 +38,10 @@ var ChatResponseClearToPreviousToolInvocationReason;
 function formatCopilotCredits(credits) {
     return ( parseFloat(credits.toFixed(1)).toString());
 }
+function formatCopilotCreditsLabel(credits) {
+    const formatted = formatCopilotCredits(credits);
+    return formatted === "1" ? ( localize(10240, "{0} credit", formatted)) : ( localize(10241, "{0} credits", formatted));
+}
 var ElicitationState;
 (function(ElicitationState) {
     ElicitationState["Pending"] = "pending";
@@ -65,6 +70,7 @@ var IChatToolInvocation;
         StateKind[StateKind["WaitingForPostApproval"] = 3] = "WaitingForPostApproval";
         StateKind[StateKind["Completed"] = 4] = "Completed";
         StateKind[StateKind["Cancelled"] = 5] = "Cancelled";
+        StateKind[StateKind["WaitingForAuthentication"] = 6] = "WaitingForAuthentication";
     })(
         StateKind = IChatToolInvocation.StateKind || (IChatToolInvocation.StateKind = {})
     );
@@ -227,6 +233,7 @@ var IChatToolInvocation;
 var AgentFeedbackReviewCommandId;
 (function(AgentFeedbackReviewCommandId) {
     AgentFeedbackReviewCommandId["GetComments"] = "_agentFeedbackReview.getComments";
+    AgentFeedbackReviewCommandId["GetPullRequestThreadLinks"] = "_agentFeedbackReview.getPullRequestThreadLinks";
     AgentFeedbackReviewCommandId["Reveal"] = "_agentFeedbackReview.reveal";
     AgentFeedbackReviewCommandId["RevealAt"] = "_agentFeedbackReview.revealAt";
     AgentFeedbackReviewCommandId["Delete"] = "_agentFeedbackReview.delete";
@@ -322,4 +329,4 @@ var ChatRequestQueueKind;
 const ChatStopCancellationNoopEventName = "chat.stopCancellationNoop";
 const ChatPendingRequestChangeEventName = "chat.pendingRequestChange";
 
-export { AgentFeedbackReviewCommandId, ChatAgentVoteDirection, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ChatSendResult, ChatStopCancellationNoopEventName, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, formatCopilotCredits, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };
+export { AgentFeedbackReviewCommandId, ChatAgentVoteDirection, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ChatSendResult, ChatStopCancellationNoopEventName, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, formatCopilotCredits, formatCopilotCreditsLabel, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };

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

@@ -1,22 +1,22 @@
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
 import { Event } from "../../../../../base/common/event.js";
+import { IDisposable } from "../../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../../base/common/observable.js";
 import { URI } from "../../../../../base/common/uri.js";
-import { ChatAgentLocation } from "../constants.js";
+import { ChatAgentLocation, SessionTypeSelectionReason } 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 { ICustomizationMigrationHint } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/customizationMigrationService";
 import { IParsedChatRequest } from "../requestParser/chatParserTypes.js";
-import { IChatSessionStartOptions, IChatModelReference, IChatSendRequestOptions, ChatSendResult, IChatProgress, ChatRequestQueueKind, IChatCompleteResponse, IChatDetail, IChatUserActionEvent, IChatQuestionAnswers } from "./chatService.js";
+import { IChatRequestSubmittedEvent, IChatSessionStartOptions, IChatModelReference, IChatSendRequestOptions, ChatSendResult, IChatProgress, ChatRequestQueueKind, IRemotePendingRequest, IChatCompleteResponse, IChatDetail, IChatUserActionEvent, IChatQuestionAnswers } from "./chatService.js";
 export declare const IChatService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatService>;
 export interface IChatService {
     _serviceBrand: undefined;
     transferredSessionResource: URI | undefined;
-    readonly onDidSubmitRequest: Event<{
-        readonly chatSessionResource: URI;
-        readonly message?: IParsedChatRequest;
-    }>;
+    readonly onDidSubmitRequest: Event<IChatRequestSubmittedEvent>;
     readonly onDidCreateModel: Event<IChatModel>;
+    registerCustomizationMigrationHintProvider(provider: (sessionResource: URI, token: CancellationToken) => Promise<ICustomizationMigrationHint | undefined>): IDisposable;
     /**
     * An observable containing all live chat models.
     */
@@ -48,11 +48,11 @@ export interface IChatService {
     *
     * @returns A reference to the session's model, or undefined if the session could not be loaded
     */
-    acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken, debugOwner?: string): Promise<IChatModelReference | undefined>;
+    acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken, debugOwner?: string, sessionTypeSelectionReason?: SessionTypeSelectionReason): Promise<IChatModelReference | undefined>;
     /**
     * Loads a session from exported chat data
     */
-    loadSessionFromData(data: IExportableChatData | ISerializableChatData, debugOwner?: string): IChatModelReference;
+    loadSessionFromData(data: IExportableChatData | ISerializableChatData, debugOwner?: string, sessionTypeSelectionReason?: SessionTypeSelectionReason): IChatModelReference;
     getChatModelReferenceDebugInfo(): IChatModelReferenceDebugSnapshot;
     /**
     * Sends a chat request for the given session.
@@ -62,7 +62,7 @@ export interface IChatService {
     getSessionTitle(sessionResource: URI): string | undefined;
     setSessionTitle(sessionResource: URI, title: string): void;
     appendProgress(request: IChatRequestModel, progress: IChatProgress): void;
-    resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
+    resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions, preserveRequestId?: boolean): Promise<void>;
     adoptRequest(sessionResource: URI, request: IChatRequestModel): Promise<void>;
     removeRequest(sessionResource: URI, requestId: string): Promise<void>;
     cancelCurrentRequestForSession(sessionResource: URI, source?: string): Promise<void>;
@@ -89,6 +89,11 @@ export interface IChatService {
         kind: ChatRequestQueueKind;
     }[]): void;
     /**
+    * Atomically reconciles the pending queue with messages authored by another client.
+    * Preserves remote ids and existing matching requests, and no-ops when already equal.
+    */
+    syncPendingRequestsFromRemote(sessionResource: URI, requests: readonly IRemotePendingRequest[]): void;
+    /**
     * Ensures pending requests for the session are processing. If restoring from
     * storage or after an error, pending requests may be present without an
     * active chat message 'loop' happening. THis triggers the loop to happen
@@ -128,6 +133,10 @@ export interface IChatService {
     activateDefaultAgent(location: ChatAgentLocation): Promise<void>;
     readonly requestInProgressObs: IObservable<boolean>;
     /**
+    * Returns the contributed session types with a request that is materializing or in progress.
+    */
+    getPendingRequestSessionTypes(): readonly string[];
+    /**
     * For tests only!
     */
     setSaveModelsEnabled(enabled: boolean): void;

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

@@ -0,0 +1,5 @@
+import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
+export declare const CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY = "chat.userSelectedSessionType";
+export declare function getRememberedSessionType(storageService: IStorageService): string | undefined;
+export declare function storeUserSelectedSessionType(storageService: IStorageService, sessionType: string): void;
+export declare function clearUserSelectedSessionType(storageService: IStorageService): void;

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

@@ -0,0 +1,15 @@
+
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+
+const CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY = 'chat.userSelectedSessionType';
+function getRememberedSessionType(storageService) {
+    return storageService.get(CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY, StorageScope.PROFILE);
+}
+function storeUserSelectedSessionType(storageService, sessionType) {
+    storageService.store(CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY, sessionType, StorageScope.PROFILE, StorageTarget.MACHINE);
+}
+function clearUserSelectedSessionType(storageService) {
+    storageService.remove(CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY, StorageScope.PROFILE);
+}
+
+export { CHAT_USER_SELECTED_SESSION_TYPE_STORAGE_KEY, clearUserSelectedSessionType, getRememberedSessionType, storeUserSelectedSessionType };

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

@@ -9,8 +9,10 @@ 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 { ChatRequestSource, IChatRequestModeInstructions, IChatRequestVariableData, ISerializableChatModelInputState } from "./model/chatModel.js";
+import { IChatRequestOrigin } from "./chatRequestOrigin.js";
 import { IChatProgress, IChatResponseErrorDetails, IChatSessionTiming } from "./chatService/chatService.js";
+import { ChatAgentLocation } from "./constants.js";
 import { Target } from "./promptSyntax/promptTypes.js";
 export declare enum ChatSessionsExtensions {
     AsyncActivation = "workbench.contrib.chatSessions.asyncActivation"
@@ -52,6 +54,12 @@ export interface IChatSessionProviderOptionModelMetadata {
     readonly longContextCacheCost?: number;
     readonly longContextCacheWriteCost?: number;
     readonly priceCategory?: string;
+    readonly promo?: {
+        readonly id: string;
+        readonly discountPercent: number;
+        readonly endsAt?: string;
+        readonly message: string;
+    };
     readonly maxInputTokens?: number;
     readonly maxOutputTokens?: number;
     readonly capabilities?: {
@@ -125,6 +133,11 @@ export interface IChatSessionsExtensionPoint {
     readonly inputPlaceholder?: string;
     readonly capabilities?: IChatAgentAttachmentCapabilities;
     readonly commands?: IChatSessionCommandContribution[];
+    /**
+     * Chat surfaces where this session type's agent can be selected.
+     * Defaults to the primary Chat surface.
+     */
+    readonly locations?: ChatAgentLocation[];
     readonly canDelegate?: boolean;
     readonly isReadOnly?: boolean;
     /**
@@ -156,10 +169,23 @@ export interface IChatSessionsExtensionPoint {
      * 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.
+     *
+     * May be a function for programmatically-registered types (e.g. agent host) that derive the requirement
+     * dynamically — for instance from the agent's currently-advertised protected resources, re-evaluated whenever
+     * {@link IChatSessionAvailabilityNotifier.notifyChanged} fires. Declaratively-contributed extensions can only
+     * supply a static boolean (parsed from JSON).
      */
-    readonly requiresCopilotSignIn?: boolean;
+    readonly requiresCopilotSignIn?: boolean | (() => boolean);
     /**
-     * When false, the delegation picker is hidden for this session type.
+     * Fires when a functional {@link requiresCopilotSignIn} would return a
+     * different value (e.g. an agent-host agent flipped between proxy and native).
+     * The sessions service re-fires {@link IChatSessionsService.onDidChangeAvailability}
+     * in response. Only meaningful for programmatically-registered contributions —
+     * declaratively-contributed extensions supply a static boolean and omit this.
+     */
+    readonly onDidChangeRequiresCopilotSignIn?: Event<void>;
+    /**
+     * Whether this session type can delegate to another session.
      * Defaults to true.
      */
     readonly supportsDelegation?: boolean;
@@ -184,6 +210,12 @@ export interface IChatSessionItem {
         readonly deletions: number;
     } | readonly IChatSessionFileChange[] | readonly IChatSessionFileChange2[];
     readonly archived?: boolean;
+    /**
+     * Authoritative read state, set by controllers that own it (see
+     * {@link IChatSessionItemController.setChatSessionItemRead}). Otherwise
+     * `undefined`, and the workbench falls back to its own read tracking.
+     */
+    readonly isRead?: boolean;
     readonly metadata?: IChatSessionItemMetadata;
     /**
      * Resource identifier the item was previously known by. When set, host-stored
@@ -236,14 +268,23 @@ export type IChatSessionHistoryItem = {
     command?: string;
     variableData?: IChatRequestVariableData;
     modelId?: string;
+    timestamp?: number;
     modeInstructions?: IChatRequestModeInstructions;
     isSystemInitiated?: boolean;
+    /** The feature that submitted this request on the user's behalf. */
+    requestSource?: ChatRequestSource;
+    isHidden?: boolean;
+    isRequestHidden?: boolean;
     systemInitiatedLabel?: string;
+    isTerminalRequest?: boolean;
+    origin?: IChatRequestOrigin;
 } | {
     type: "response";
     parts: IChatProgress[];
     participant: string;
     details?: string;
+    elapsedMs?: number;
+    completedAt?: number;
     /**
      * Error details for a failed response. Rendered as a proper chat error
      * (including the quota-exceeded upgrade affordance), mirroring the live
@@ -255,11 +296,31 @@ export type IChatSessionRequestHistoryItem = Extract<IChatSessionHistoryItem, {
     type: "request";
 }>;
 export interface IChatSessionServerRequest {
+    /**
+     * Identifier of the backing provider turn.
+     */
+    readonly id: string;
     readonly prompt: string;
     readonly variableData?: IChatRequestVariableData;
+    readonly timestamp?: number;
     readonly isSystemInitiated?: boolean;
+    /** The feature that submitted this request on the user's behalf. */
+    readonly requestSource?: ChatRequestSource;
+    readonly isHidden?: boolean;
+    readonly isRequestHidden?: boolean;
     readonly systemInitiatedLabel?: string;
+    readonly isTerminalRequest?: boolean;
+    /** Reopen the existing request with this id instead of adding another request. */
+    readonly resume?: boolean;
+    readonly origin?: IChatRequestOrigin;
 }
+/**
+ * Whether `text` runs as a terminal command for the given command `prefix`
+ * (e.g. `!`) — it starts with the prefix and has a non-empty command after it.
+ * Mirrors the agent host's bang parser, where a lone `!` (or `!` followed only
+ * by whitespace) is forwarded to the agent rather than executed.
+ */
+export declare function isTerminalCommandPrompt(text: string, prefix: string | undefined): boolean;
 /**
  * A set of well-known session types
  */
@@ -267,7 +328,6 @@ export declare namespace SessionType {
     const CopilotCLI = "copilotcli";
     const CopilotCloud = "copilot-cloud-agent";
     const Local = "local";
-    const ClaudeCode = "claude-code";
     const Codex = "openai-codex";
     const Growth = "copilot-growth";
     const AgentHostCopilot = "agent-host-copilotcli";
@@ -292,6 +352,7 @@ export declare function isRemoteAgentHostTarget(target: string): boolean;
  * Matches the local agent host (`agent-host-*`) and remote agent hosts (`remote-*`).
  */
 export declare function isAgentHostTarget(target: string): boolean;
+export declare function isAgentHostSessionResource(resource: URI): boolean;
 /**
  * The session type used for local agent chat sessions.
  */
@@ -304,6 +365,7 @@ export interface IChatSession extends IDisposable {
     readonly options?: ReadonlyChatSessionOptionsMap;
     readonly progressObs?: IObservable<IChatProgress[]>;
     readonly isCompleteObs?: IObservable<boolean>;
+    readonly isReadOnly?: IObservable<boolean>;
     readonly interruptActiveResponseCallback?: () => Promise<boolean>;
     /**
      * Event fired when the server initiates a new request (e.g. from a consumed
@@ -337,6 +399,8 @@ export interface IChatSession extends IDisposable {
 }
 export interface IChatSessionContentProvider {
     provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
+    /** Updates provider-owned metadata for a session. */
+    updateChatSessionMetadata?(sessionResource: URI, metadata: Record<string, unknown>): void;
     /** Resolves a parsed response Markdown URI before it is sanitized and rendered. */
     resolveChatResponseUri?(sessionResource: URI, href: string, kind: "link" | "image"): string;
     /**
@@ -379,6 +443,13 @@ export interface IChatInputCompletionsParams {
 export interface IChatInputCompletionItem {
     /** Text inserted into the input when this item is accepted. */
     readonly insertText: string;
+    /**
+     * Optional display label shown in the completion picker. When omitted, the
+     * workbench displays {@link insertText}. Set this when the inserted text
+     * differs from the label — e.g. an action item that inserts nothing
+     * (`insertText: ''`) but should still be shown to the user.
+     */
+    readonly label?: string;
     /**
      * Half-open range `[start, end)` in the *current* input text that
      * {@link insertText} replaces. Positions use 1-based `lineNumber` and
@@ -388,7 +459,7 @@ export interface IChatInputCompletionItem {
     readonly start?: IPosition;
     readonly end?: IPosition;
     /** Attachment associated with the item. */
-    readonly attachment: IChatInputCompletionResourceAttachment | IChatInputCompletionCommandAttachment | IChatInputCompletionSkillAttachment;
+    readonly attachment: IChatInputCompletionResourceAttachment | IChatInputCompletionCommandAttachment | IChatInputCompletionSkillAttachment | IChatInputCompletionChatAttachment;
 }
 /**
  * Resource attachment associated with a completion item. The workbench
@@ -412,6 +483,7 @@ export interface IChatInputCompletionResourceAttachment {
 export interface IChatInputCompletionCommandAttachment {
     readonly kind: "command";
     readonly command: string;
+    readonly isSkill?: true;
     readonly description: string;
     /**
      * Implementation-defined metadata that MUST be preserved by the
@@ -436,6 +508,39 @@ export interface IChatInputCompletionSkillAttachment {
      */
     readonly _meta?: Record<string, unknown>;
 }
+/**
+ * Chat attachment associated with a completion item. References another chat's
+ * transcript through a fixed completed turn. The workbench adds it to the
+ * input's variable model when the item is accepted so it round-trips back to
+ * the provider as a chat attachment on the outgoing user message.
+ */
+export interface IChatInputCompletionChatAttachment {
+    readonly kind: "chat";
+    /**
+     * The opaque **backend** chat URI of the referenced chat — the exact value
+     * carried on `MessageChatAttachment.resource`. The workbench stores it
+     * verbatim on the accepted reference entry (`value`) and round-trips it back
+     * on send; it never parses or constructs it.
+     */
+    readonly uri: URI;
+    /**
+     * The last completed turn included in the referenced transcript, when the
+     * reference is pinned to a specific turn. Omitted for references that resolve
+     * to the referenced chat's latest completed turn at accept time (e.g. a
+     * reference produced by dragging a chat into the input).
+     */
+    readonly endTurn?: string;
+    /** The chat title, used as the display label. */
+    readonly title: string;
+    /** Display label shown in the completion picker; defaults to {@link title}. */
+    readonly displayName?: string;
+    /**
+     * Implementation-defined metadata that MUST be preserved by the
+     * workbench when the accepted completion is sent back as part of a
+     * user message attachment.
+     */
+    readonly _meta?: Record<string, unknown>;
+}
 /**
  * Result of {@link IChatSessionContentProvider.provideChatInputCompletions}.
  */
@@ -446,6 +551,12 @@ export interface IChatNewSessionRequest {
     readonly prompt: string;
     readonly command?: string;
     readonly initialSessionOptions?: ReadonlyChatSessionOptionsMap;
+    /** VS Code-specific metadata forwarded to Agent Host session creation. */
+    readonly _meta?: Record<string, unknown>;
+    /**
+     * Marks this session as a throwaway UI surface that must not be retained or listed.
+     */
+    readonly isEphemeral?: boolean;
     /**
      * The chat-input session resource the user was typing into when this
      * request was issued. Set when the chat infrastructure is rewriting an
@@ -458,6 +569,7 @@ export interface IChatNewSessionRequest {
 }
 export interface IChatSessionItemsDelta {
     readonly addedOrUpdated?: readonly IChatSessionItem[];
+    /** Sessions no longer provided by the controller. Retained content is disposed and pending resolutions are cancelled. */
     readonly removed?: readonly URI[];
 }
 export interface IChatSessionItemController {
@@ -465,6 +577,10 @@ export interface IChatSessionItemController {
     get items(): readonly IChatSessionItem[];
     refresh(token: CancellationToken): Promise<void>;
     newChatSessionItem?(request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+    /**
+     * Notifies the controller that a locally-created session now exists on its backend.
+     */
+    notifySessionMaterialized?(resource: URI): void;
     getNewChatSessionInputState?(sessionResource: URI, token: CancellationToken): Promise<readonly IChatSessionProviderOptionGroup[] | undefined>;
     resolveChatSessionItem?(resource: URI, token: CancellationToken): Promise<IChatSessionItem | undefined>;
     /**
@@ -473,6 +589,17 @@ export interface IChatSessionItemController {
      * as a result of the deletion.
      */
     deleteChatSessionItem?(resource: URI, token: CancellationToken): Promise<void>;
+    /**
+     * Set the authoritative archived state for the session identified by `resource`.
+     */
+    setChatSessionItemArchived?(resource: URI, archived: boolean): void;
+    /**
+     * Set the authoritative read state for the session identified by `resource`.
+     * Implementing this declares that the controller, not the workbench, owns read
+     * state — letting it be shared with other clients on the same backend. The
+     * controller reflects the new value back via {@link IChatSessionItem.isRead}.
+     */
+    setChatSessionItemRead?(resource: URI, isRead: boolean): void;
 }
 export interface IChatSessionOptionsChangeEvent {
     readonly sessionResource: URI;

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

@@ -30,12 +30,14 @@ var ChatSessionStatus;
     ChatSessionStatus[ChatSessionStatus["InProgress"] = 2] = "InProgress";
     ChatSessionStatus[ChatSessionStatus["NeedsInput"] = 3] = "NeedsInput";
 })(ChatSessionStatus || (ChatSessionStatus = {}));
+function isTerminalCommandPrompt(text, prefix) {
+    return !!prefix && text.startsWith(prefix) && text.slice(prefix.length).trim().length > 0;
+}
 var SessionType;
 (function(SessionType) {
     SessionType.CopilotCLI = "copilotcli";
     SessionType.CopilotCloud = "copilot-cloud-agent";
     SessionType.Local = "local";
-    SessionType.ClaudeCode = "claude-code";
     SessionType.Codex = "openai-codex";
     SessionType.Growth = "copilot-growth";
     SessionType.AgentHostCopilot = "agent-host-copilotcli";
@@ -51,6 +53,9 @@ function isRemoteAgentHostTarget(target) {
 function isAgentHostTarget(target) {
     return isLocalAgentHostTarget(target) || isRemoteAgentHostTarget(target);
 }
+function isAgentHostSessionResource(resource) {
+    return isAgentHostTarget(resource.scheme);
+}
 const localChatSessionType = SessionType.Local;
 var ChatSessionOptionsMap;
 (function(ChatSessionOptionsMap) {
@@ -93,4 +98,4 @@ function isIChatSessionFileChange2(obj) {
     return candidate && candidate.uri instanceof URI && typeof candidate.insertions === "number" && typeof candidate.deletions === "number";
 }
 
-export { ChatSessionOptionsMap, ChatSessionStatus, ChatSessionsExtensions, SessionType, isAgentHostTarget, isIChatSessionFileChange2, isLocalAgentHostTarget, isRemoteAgentHostTarget, isSessionInProgressStatus, localChatSessionType };
+export { ChatSessionOptionsMap, ChatSessionStatus, ChatSessionsExtensions, SessionType, isAgentHostSessionResource, isAgentHostTarget, isIChatSessionFileChange2, isLocalAgentHostTarget, isRemoteAgentHostTarget, isSessionInProgressStatus, isTerminalCommandPrompt, localChatSessionType };

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

@@ -2,7 +2,7 @@ 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";
-import { IChatSessionItemsDelta, IChatSessionCommitEvent, ResolvedChatSessionsExtensionPoint, IChatSessionsExtensionPoint, IChatSessionItemController, IChatSessionItem, IChatSessionContentProvider, IChatSession, IChatInputCompletionsParams, IChatInputCompletionsResult, ReadonlyChatSessionOptionsMap, IChatSessionProviderOptionItem, IChatSessionOptionsChangeEvent, IChatSessionRequestHistoryItem, IChatSessionProviderOptionGroup, IChatNewSessionRequest, IChatSessionCustomizationsProvider, IChatSessionCustomizationItemGroup } from "./chatSessionsService.js";
+import { IChatSessionItemsDelta, IChatSessionCommitEvent, ResolvedChatSessionsExtensionPoint, IChatSessionHistoryItem, IChatSessionsExtensionPoint, IChatSessionItemController, IChatSessionItem, IChatSessionContentProvider, IChatSession, IChatInputCompletionsParams, IChatInputCompletionsResult, ReadonlyChatSessionOptionsMap, IChatSessionProviderOptionItem, IChatSessionOptionsChangeEvent, IChatSessionRequestHistoryItem, IChatSessionProviderOptionGroup, IChatNewSessionRequest, IChatSessionCustomizationsProvider, IChatSessionCustomizationItemGroup } from "./chatSessionsService.js";
 import { IChatAgentAttachmentCapabilities } from "./participants/chatAgents.js";
 import { Target } from "./promptSyntax/promptTypes.js";
 export declare const IChatSessionsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatSessionsService>;
@@ -22,6 +22,11 @@ export interface IChatSessionsService {
     getChatSessionContribution(chatSessionType: string): ResolvedChatSessionsExtensionPoint | undefined;
     getAllChatSessionContributions(): ResolvedChatSessionsExtensionPoint[];
     /**
+    * Reads a session's history without retaining a contributed session in the
+    * global session cache. Intended for lightweight ranking and previews.
+    */
+    getChatSessionHistory(sessionResource: URI, token: CancellationToken): Promise<readonly IChatSessionHistoryItem[]>;
+    /**
     * Programmatically register a chat session contribution (for internal session types
     * that don't go through the extension point).
     */
@@ -54,6 +59,22 @@ export interface IChatSessionsService {
     * Returns the resolved item, or undefined if no resolve handler is available.
     */
     resolveChatSessionItem(chatSessionType: string, resource: URI, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+    /**
+    * Whether the registered item controller owns archived state for the session.
+    */
+    canSetChatSessionItemArchived(sessionResource: URI): boolean;
+    /**
+    * Sets archived state by delegating to the registered item controller.
+    */
+    setChatSessionItemArchived(sessionResource: URI, archived: boolean): void;
+    /**
+    * Whether the registered item controller owns read state for the session.
+    */
+    canSetChatSessionItemRead(sessionResource: URI): boolean;
+    /**
+    * Sets read state by delegating to the registered item controller.
+    */
+    setChatSessionItemRead(sessionResource: URI, isRead: boolean): void;
     readonly onDidChangeContentProviderSchemes: Event<{
         readonly added: string[];
         readonly removed: string[];
@@ -62,6 +83,7 @@ export interface IChatSessionsService {
     registerChatSessionContentProvider(scheme: string, provider: IChatSessionContentProvider): IDisposable;
     canResolveChatSession(sessionType: string): Promise<boolean>;
     getOrCreateChatSession(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
+    updateChatSessionMetadata(sessionResource: URI, metadata: Record<string, unknown>): boolean;
     /** Resolves a parsed response Markdown URI through its session content provider. */
     resolveChatResponseUri(sessionResource: URI, href: string, kind: "link" | "image"): string;
     /**
@@ -112,7 +134,9 @@ export interface IChatSessionsService {
     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.
+    * supported). A type's {@link IChatSessionsExtensionPoint.requiresCopilotSignIn} may be a static boolean or a
+    * function evaluated on demand (e.g. agent-host types derive it from the agent's currently-advertised protected
+    * resources); defaults to false so third-party types stay usable while signed out.
     */
     requiresCopilotSignInForSessionType(chatSessionType: string): boolean;
     /**
@@ -157,6 +181,10 @@ export interface IChatSessionsService {
     */
     createNewChatSessionItem(chatSessionType: string, request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
     /**
+    * Notifies the registered controller that a locally-created session now exists on its backend.
+    */
+    notifySessionMaterialized?(sessionResource: URI): void;
+    /**
     * Permanently deletes a chat session item by delegating to the registered controller's `deleteChatSessionItem`
     * handler. Throws if the controller does not implement `deleteChatSessionItem`.
     */

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

@@ -0,0 +1,17 @@
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IChatSideChatProvider, IChatSideChatSelection, IChatSideChatOrigin } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/chatSideChatService";
+export declare const IChatSideChatService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatSideChatService>;
+export interface IChatSideChatService {
+    readonly _serviceBrand: undefined;
+    registerProvider(provider: IChatSideChatProvider): IDisposable;
+    /** @see IChatSideChatProvider.canAskInSideChat */
+    canAskInSideChat(sessionResource: URI): boolean;
+    /** @see IChatSideChatProvider.askInSideChat */
+    askInSideChat(sessionResource: URI, query: string, selection?: IChatSideChatSelection): Promise<void>;
+    /** @see IChatSideChatProvider.observeSideChatOrigin */
+    observeSideChatOrigin(sessionResource: URI): IObservable<IChatSideChatOrigin | undefined>;
+    /** @see IChatSideChatProvider.revealSideChatSource */
+    revealSideChatSource(sessionResource: URI): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatSideChatService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IChatSideChatService = ( createDecorator("chatSideChatService"));
+
+export { IChatSideChatService };