@codingame/monaco-vscode-api 31.0.1 → 32.0.1

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

@@ -5,6 +5,7 @@ import { IDisposable } from "../../../../base/common/lifecycle.js";
 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 { IChatAgentAttachmentCapabilities, IChatAgentRequest } from "./participants/chatAgents.js";
 import { IChatEditingSession } from "./editing/chatEditingService.js";
 import { IChatRequestModeInstructions, IChatRequestVariableData, ISerializableChatModelInputState } from "./model/chatModel.js";
@@ -29,6 +30,7 @@ export interface IChatSessionProviderOptionItem {
     readonly locked?: boolean;
     readonly icon?: ThemeIcon;
     readonly default?: boolean;
+    readonly slashCommand?: string;
 }
 export interface IChatSessionProviderOptionGroupCommand {
     readonly command: string;
@@ -56,6 +58,15 @@ export interface IChatSessionProviderOptionGroup {
      * These will be shown in a separate section at the end of the picker.
      */
     readonly commands?: readonly IChatSessionProviderOptionGroupCommand[];
+    /**
+     * Optional kind hint that controls how the group is presented.
+     * - `'permissions'`: the group's items are surfaced inside the chat permission picker
+     *   instead of being rendered as a standalone picker. At most one group per provider
+     *   may use this kind; if multiple are declared, the first one (in declaration order)
+     *   wins. The group has no UI of its own — it is invisible when the permission
+     *   picker is hidden by its own `when` clauses.
+     */
+    readonly kind?: "permissions";
 }
 export interface IChatSessionsExtensionPoint {
     readonly type: string;
@@ -111,9 +122,27 @@ export interface IChatSessionItem {
         readonly deletions: number;
     } | readonly IChatSessionFileChange[] | readonly IChatSessionFileChange2[];
     readonly archived?: boolean;
-    readonly metadata?: {
-        readonly [key: string]: unknown;
-    };
+    readonly metadata?: IChatSessionItemMetadata;
+}
+export interface IChatSessionItemMetadata {
+    readonly repositoryPath?: string;
+    readonly workingDirectoryPath?: string;
+    readonly firstCheckpointRef?: string;
+    readonly lastCheckpointRef?: string;
+    readonly worktreePath?: string;
+    readonly uncommittedChanges?: number;
+    readonly baseRefOid?: string;
+    readonly headRefOid?: string;
+    readonly branchName?: string;
+    readonly branch?: string;
+    readonly baseBranchName?: string;
+    readonly baseBranch?: string;
+    readonly baseBranchProtected?: boolean;
+    readonly hasGitHubRemote?: boolean;
+    readonly upstreamBranchName?: string;
+    readonly incomingChanges?: number;
+    readonly outgoingChanges?: number;
+    readonly [key: string]: unknown;
 }
 export interface IChatSessionFileChange {
     readonly modifiedUri: URI;
@@ -141,10 +170,33 @@ export type IChatSessionHistoryItem = {
     type: "response";
     parts: IChatProgress[];
     participant: string;
+    details?: string;
 };
 export type IChatSessionRequestHistoryItem = Extract<IChatSessionHistoryItem, {
     type: "request";
 }>;
+/**
+ * A set of well-known session types
+ */
+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-copilot";
+}
+/**
+ * Returns whether the given session type is an agent host target.
+ * Matches the local agent host (`agent-host-*`) and remote agent hosts (`remote-*`).
+ *
+ * Note: The `remote-` prefix convention is established by
+ * `RemoteAgentHostContribution` which generates session types as
+ * `remote-{sanitizedAddress}-{provider}`. If future remote providers that
+ * are NOT agent hosts need a different prefix, this function must be updated.
+ */
+export declare function isAgentHostTarget(target: string): boolean;
 /**
  * The session type used for local agent chat sessions.
  */
@@ -165,6 +217,7 @@ export interface IChatSession extends IDisposable {
      */
     readonly onDidStartServerRequest?: Event<{
         prompt: string;
+        variableData?: IChatRequestVariableData;
     }>;
     /**
      * Editing session transferred from a previously-untitled chat session in `onDidCommitChatSessionItem`.
@@ -185,6 +238,78 @@ export interface IChatSession extends IDisposable {
 }
 export interface IChatSessionContentProvider {
     provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
+    /**
+     * Optional. Compute completion items for an input being composed in this
+     * session. Returning `undefined` lets the workbench fall back to its
+     * default in-process completion providers.
+     */
+    provideChatInputCompletions?(sessionResource: URI, params: IChatInputCompletionsParams, token: CancellationToken): Promise<IChatInputCompletionsResult | undefined>;
+    /**
+     * Optional. Trigger characters that, when typed in the chat input,
+     * SHOULD cause the workbench to issue a `provideChatInputCompletions`
+     * request. Used to register a Monaco completion provider scoped to
+     * sessions handled by this content provider.
+     */
+    provideChatInputCompletionTriggerCharacters?(): Promise<readonly string[]>;
+}
+/**
+ * Inputs for {@link IChatSessionContentProvider.provideChatInputCompletions}
+ * and {@link IChatSessionsService.provideChatInputCompletions}.
+ */
+export interface IChatInputCompletionsParams {
+    /**
+     * The complete text of the input being completed (e.g. the user message
+     * the user is currently composing).
+     */
+    readonly text: string;
+    /**
+     * The character offset within {@link text} at which the completion is
+     * requested, measured in UTF-16 code units. MUST satisfy
+     * `0 <= offset <= text.length`.
+     */
+    readonly offset: number;
+}
+/**
+ * A neutral completion-item shape returned by
+ * {@link IChatSessionContentProvider.provideChatInputCompletions}. The
+ * workbench-side completion glue maps these into Monaco completion items
+ * and the corresponding chat-input attachment.
+ */
+export interface IChatInputCompletionItem {
+    /** Text inserted into the input when this item is accepted. */
+    readonly insertText: string;
+    /**
+     * Half-open range `[start, end)` in the *current* input text that
+     * {@link insertText} replaces. Positions use 1-based `lineNumber` and
+     * `column` to match Monaco. When omitted, the workbench replaces the
+     * word at the cursor.
+     */
+    readonly start?: IPosition;
+    readonly end?: IPosition;
+    /** Attachment associated with the item. */
+    readonly attachment: IChatInputCompletionAttachment;
+}
+/**
+ * Resource attachment associated with a completion item. The workbench
+ * adds it to the input's variable model when the item is accepted.
+ */
+export interface IChatInputCompletionAttachment {
+    readonly kind: "resource";
+    readonly uri: URI;
+    readonly displayName?: string;
+    readonly isDirectory?: boolean;
+    /**
+     * 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}.
+ */
+export interface IChatInputCompletionsResult {
+    readonly items: readonly IChatInputCompletionItem[];
 }
 export interface IChatNewSessionRequest {
     readonly prompt: string;
@@ -201,6 +326,7 @@ export interface IChatSessionItemController {
     refresh(token: CancellationToken): Promise<void>;
     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>;
 }
 export interface IChatSessionOptionsChangeEvent {
     readonly sessionResource: URI;

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

@@ -8,7 +8,20 @@ var ChatSessionStatus;
     ChatSessionStatus[ChatSessionStatus["InProgress"] = 2] = "InProgress";
     ChatSessionStatus[ChatSessionStatus["NeedsInput"] = 3] = "NeedsInput";
 })(ChatSessionStatus || (ChatSessionStatus = {}));
-const localChatSessionType = "local";
+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-copilot";
+})(SessionType || (SessionType = {}));
+function isAgentHostTarget(target) {
+    return target === SessionType.AgentHostCopilot || target.startsWith("agent-host-") || target.startsWith("remote-");
+}
+const localChatSessionType = SessionType.Local;
 var ChatSessionOptionsMap;
 (function(ChatSessionOptionsMap) {
     function fromRecord(obj) {
@@ -50,4 +63,4 @@ function isIChatSessionFileChange2(obj) {
     return candidate && candidate.uri instanceof URI && typeof candidate.insertions === "number" && typeof candidate.deletions === "number";
 }
 
-export { ChatSessionOptionsMap, ChatSessionStatus, isIChatSessionFileChange2, isSessionInProgressStatus, localChatSessionType };
+export { ChatSessionOptionsMap, ChatSessionStatus, SessionType, isAgentHostTarget, isIChatSessionFileChange2, isSessionInProgressStatus, 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, ReadonlyChatSessionOptionsMap, IChatSessionProviderOptionItem, IChatSessionOptionsChangeEvent, IChatSessionRequestHistoryItem, IChatSessionProviderOptionGroup, IChatNewSessionRequest, IChatSessionCustomizationsProvider, IChatSessionCustomizationItemGroup } from "./chatSessionsService.js";
+import { IChatSessionItemsDelta, IChatSessionCommitEvent, ResolvedChatSessionsExtensionPoint, 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>;
@@ -49,6 +49,11 @@ export interface IChatSessionsService {
         chatSessionType: string;
         count: number;
     }[];
+    /**
+    * Lazily resolves a chat session item, filling in expensive details like timing, changes, and badge.
+    * Returns the resolved item, or undefined if no resolve handler is available.
+    */
+    resolveChatSessionItem(chatSessionType: string, resource: URI, token: CancellationToken): Promise<IChatSessionItem | undefined>;
     readonly onDidChangeContentProviderSchemes: Event<{
         readonly added: string[];
         readonly removed: string[];
@@ -57,6 +62,23 @@ export interface IChatSessionsService {
     registerChatSessionContentProvider(scheme: string, provider: IChatSessionContentProvider): IDisposable;
     canResolveChatSession(sessionType: string): Promise<boolean>;
     getOrCreateChatSession(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
+    /**
+    * Compute completion items for an input being composed in the chat
+    * session identified by `sessionResource`. Delegates to the registered
+    * {@link IChatSessionContentProvider} for the session, if it implements
+    * {@link IChatSessionContentProvider.provideChatInputCompletions}.
+    * Returns `undefined` when no provider is available, in which case the
+    * workbench's default in-process providers should be used.
+    */
+    provideChatInputCompletions(sessionResource: URI, params: IChatInputCompletionsParams, token: CancellationToken): Promise<IChatInputCompletionsResult | undefined>;
+    /**
+    * Trigger characters announced by the content provider for the given
+    * session type. Used to dynamically register Monaco completion
+    * providers per content-provider scheme. Returns `undefined` when the
+    * scheme has no content provider, or `[]` when the provider does not
+    * announce any trigger characters.
+    */
+    getChatInputCompletionTriggerCharacters(sessionType: string): Promise<readonly string[] | undefined>;
     getSessionOptions(sessionResource: URI): ReadonlyChatSessionOptionsMap | undefined;
     getSessionOption(sessionResource: URI, optionId: string): string | IChatSessionProviderOptionItem | undefined;
     setSessionOption(sessionResource: URI, optionId: string, value: string | IChatSessionProviderOptionItem): boolean;

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

@@ -29,17 +29,21 @@ export declare enum ChatConfiguration {
     ThinkingGenerateTitles = "chat.agent.thinking.generateTitles",
     TerminalToolsInThinking = "chat.agent.thinking.terminalTools",
     SimpleTerminalCollapsible = "chat.tools.terminal.simpleCollapsible",
+    CompressOutputEnabled = "chat.tools.compressOutput.enabled",
     ThinkingPhrases = "chat.agent.thinking.phrases",
     AutoExpandToolFailures = "chat.tools.autoExpandFailures",
     TodosShowWidget = "chat.tools.todos.showWidget",
     NotifyWindowOnConfirmation = "chat.notifyWindowOnConfirmation",
     NotifyWindowOnResponseReceived = "chat.notifyWindowOnResponseReceived",
     ChatViewSessionsEnabled = "chat.viewSessions.enabled",
+    SessionSyncEnabled = "chat.sessionSync.enabled",
+    SessionSyncExcludeRepositories = "chat.sessionSync.excludeRepositories",
     ChatViewSessionsGrouping = "chat.viewSessions.grouping",
     ChatViewSessionsOrientation = "chat.viewSessions.orientation",
     ChatViewProgressBadgeEnabled = "chat.viewProgressBadge.enabled",
     ChatContextUsageEnabled = "chat.contextUsage.enabled",
     ChatPersistentProgressEnabled = "chat.persistentProgress.enabled",
+    ProgressBorder = "chat.progressBorder.enabled",
     SubagentToolCustomAgents = "chat.customAgentInSubagent.enabled",
     GeneralPurposeAgentEnabled = "chat.generalPurposeAgent.enabled",
     SubagentsAllowInvocationsFromSubagents = "chat.subagents.allowInvocationsFromSubagents",
@@ -49,9 +53,12 @@ export declare enum ChatConfiguration {
     ExplainChangesEnabled = "chat.editing.explainChanges.enabled",
     RevealNextChangeOnResolve = "chat.editing.revealNextChangeOnResolve",
     GrowthNotificationEnabled = "chat.growthNotification.enabled",
-    SignInTitleBarEnabled = "chat.signInTitleBar.enabled",
+    TitleBarSignInEnabled = "chat.titleBar.signIn.enabled",
     ChatCustomizationHarnessSelectorEnabled = "chat.customizations.harnessSelector.enabled",
+    ChatCustomizationsStructuredPreviewEnabled = "chat.customizations.structuredPreview.enabled",
+    UseChatSessionCustomizationsForCustomAgents = "chat.customizations.useChatSessionCustomizationsForCustomAgents",
     AutopilotEnabled = "chat.autopilot.enabled",
+    PlanReviewInlineEditorEnabled = "chat.planReview.inlineEditor.enabled",
     DefaultPermissionLevel = "chat.permissions.default",
     ImageCarouselEnabled = "imageCarousel.chat.enabled",
     ArtifactsEnabled = "chat.artifacts.enabled",
@@ -59,6 +66,8 @@ export declare enum ChatConfiguration {
     ArtifactsRulesByFilePath = "chat.artifacts.rules.byFilePath",
     ArtifactsRulesByMemoryFilePath = "chat.artifacts.rules.byMemoryFilePath",
     ToolConfirmationCarousel = "chat.tools.confirmationCarousel.enabled",
+    ToolRiskAssessmentEnabled = "chat.tools.riskAssessment.enabled",
+    ToolRiskAssessmentModel = "chat.tools.riskAssessment.model",
     DefaultNewSessionMode = "chat.newSession.defaultMode",
     AgentHostClientTools = "chat.agentHost.clientTools",
     IncrementalRendering = "chat.experimental.incrementalRendering.enabled",
@@ -84,7 +93,7 @@ export declare enum ChatPermissionLevel {
     /** Everything AutoApprove does plus an internal stop hook that continues until the task is done */
     Autopilot = "autopilot"
 }
-export declare function isChatPermissionLevel(level: string | undefined): level is ChatPermissionLevel;
+export declare function isChatPermissionLevel(level: unknown | undefined): level is ChatPermissionLevel;
 /**
  * Returns true if the permission level enables auto-approval of all tool calls.
  * Both {@link ChatPermissionLevel.AutoApprove} and {@link ChatPermissionLevel.Autopilot} enable auto-approval.
@@ -124,6 +133,9 @@ export declare namespace ChatAgentLocation {
 }
 export declare function isSupportedChatFileScheme(accessor: ServicesAccessor, scheme: string): boolean;
 export declare const MANAGE_CHAT_COMMAND_ID = "workbench.action.chat.manage";
+export declare const OPEN_WORKSPACE_IN_AGENTS_WINDOW_COMMAND_ID = "workbench.action.openWorkspaceInAgentsWindow";
+export declare const OPEN_AGENTS_WINDOW_COMMAND_ID = "workbench.action.openAgentsWindow";
+export declare const OPEN_AGENTS_WINDOW_PRECONDITION: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
 export declare const ChatEditorTitleMaxLength = 30;
 export declare const CHAT_TERMINAL_OUTPUT_MAX_PREVIEW_LINES = 1000;
 export declare const CONTEXT_MODELS_EDITOR: RawContextKey<boolean>;

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

@@ -2,6 +2,8 @@
 import { Schemas } from '../../../../base/common/network.js';
 import { IChatSessionsService } from './chatSessionsService.service.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import '../../../services/chat/common/chatEntitlementService.js';
+import '../../../common/contextkeys.js';
 
 var ChatConfiguration;
 (function(ChatConfiguration) {
@@ -33,17 +35,21 @@ var ChatConfiguration;
     ChatConfiguration["ThinkingGenerateTitles"] = "chat.agent.thinking.generateTitles";
     ChatConfiguration["TerminalToolsInThinking"] = "chat.agent.thinking.terminalTools";
     ChatConfiguration["SimpleTerminalCollapsible"] = "chat.tools.terminal.simpleCollapsible";
+    ChatConfiguration["CompressOutputEnabled"] = "chat.tools.compressOutput.enabled";
     ChatConfiguration["ThinkingPhrases"] = "chat.agent.thinking.phrases";
     ChatConfiguration["AutoExpandToolFailures"] = "chat.tools.autoExpandFailures";
     ChatConfiguration["TodosShowWidget"] = "chat.tools.todos.showWidget";
     ChatConfiguration["NotifyWindowOnConfirmation"] = "chat.notifyWindowOnConfirmation";
     ChatConfiguration["NotifyWindowOnResponseReceived"] = "chat.notifyWindowOnResponseReceived";
     ChatConfiguration["ChatViewSessionsEnabled"] = "chat.viewSessions.enabled";
+    ChatConfiguration["SessionSyncEnabled"] = "chat.sessionSync.enabled";
+    ChatConfiguration["SessionSyncExcludeRepositories"] = "chat.sessionSync.excludeRepositories";
     ChatConfiguration["ChatViewSessionsGrouping"] = "chat.viewSessions.grouping";
     ChatConfiguration["ChatViewSessionsOrientation"] = "chat.viewSessions.orientation";
     ChatConfiguration["ChatViewProgressBadgeEnabled"] = "chat.viewProgressBadge.enabled";
     ChatConfiguration["ChatContextUsageEnabled"] = "chat.contextUsage.enabled";
     ChatConfiguration["ChatPersistentProgressEnabled"] = "chat.persistentProgress.enabled";
+    ChatConfiguration["ProgressBorder"] = "chat.progressBorder.enabled";
     ChatConfiguration["SubagentToolCustomAgents"] = "chat.customAgentInSubagent.enabled";
     ChatConfiguration["GeneralPurposeAgentEnabled"] = "chat.generalPurposeAgent.enabled";
     ChatConfiguration["SubagentsAllowInvocationsFromSubagents"] = "chat.subagents.allowInvocationsFromSubagents";
@@ -53,9 +59,12 @@ var ChatConfiguration;
     ChatConfiguration["ExplainChangesEnabled"] = "chat.editing.explainChanges.enabled";
     ChatConfiguration["RevealNextChangeOnResolve"] = "chat.editing.revealNextChangeOnResolve";
     ChatConfiguration["GrowthNotificationEnabled"] = "chat.growthNotification.enabled";
-    ChatConfiguration["SignInTitleBarEnabled"] = "chat.signInTitleBar.enabled";
+    ChatConfiguration["TitleBarSignInEnabled"] = "chat.titleBar.signIn.enabled";
     ChatConfiguration["ChatCustomizationHarnessSelectorEnabled"] = "chat.customizations.harnessSelector.enabled";
+    ChatConfiguration["ChatCustomizationsStructuredPreviewEnabled"] = "chat.customizations.structuredPreview.enabled";
+    ChatConfiguration["UseChatSessionCustomizationsForCustomAgents"] = "chat.customizations.useChatSessionCustomizationsForCustomAgents";
     ChatConfiguration["AutopilotEnabled"] = "chat.autopilot.enabled";
+    ChatConfiguration["PlanReviewInlineEditorEnabled"] = "chat.planReview.inlineEditor.enabled";
     ChatConfiguration["DefaultPermissionLevel"] = "chat.permissions.default";
     ChatConfiguration["ImageCarouselEnabled"] = "imageCarousel.chat.enabled";
     ChatConfiguration["ArtifactsEnabled"] = "chat.artifacts.enabled";
@@ -63,6 +72,8 @@ var ChatConfiguration;
     ChatConfiguration["ArtifactsRulesByFilePath"] = "chat.artifacts.rules.byFilePath";
     ChatConfiguration["ArtifactsRulesByMemoryFilePath"] = "chat.artifacts.rules.byMemoryFilePath";
     ChatConfiguration["ToolConfirmationCarousel"] = "chat.tools.confirmationCarousel.enabled";
+    ChatConfiguration["ToolRiskAssessmentEnabled"] = "chat.tools.riskAssessment.enabled";
+    ChatConfiguration["ToolRiskAssessmentModel"] = "chat.tools.riskAssessment.model";
     ChatConfiguration["DefaultNewSessionMode"] = "chat.newSession.defaultMode";
     ChatConfiguration["AgentHostClientTools"] = "chat.agentHost.clientTools";
     ChatConfiguration["IncrementalRendering"] = "chat.experimental.incrementalRendering.enabled";
@@ -83,7 +94,7 @@ var ChatPermissionLevel;
 })(ChatPermissionLevel || (ChatPermissionLevel = {}));
 const chatPermissionLevels = ( new Set(( Object.values(ChatPermissionLevel))));
 function isChatPermissionLevel(level) {
-    return level !== undefined && ( chatPermissionLevels.has(level));
+    return ( chatPermissionLevels.has(level));
 }
 function isAutoApproveLevel(level) {
     return level === ChatPermissionLevel.AutoApprove || level === ChatPermissionLevel.Autopilot;
@@ -151,9 +162,10 @@ function isSupportedChatFileScheme(accessor, scheme) {
     return true;
 }
 const MANAGE_CHAT_COMMAND_ID = "workbench.action.chat.manage";
+const OPEN_WORKSPACE_IN_AGENTS_WINDOW_COMMAND_ID = "workbench.action.openWorkspaceInAgentsWindow";
 const ChatEditorTitleMaxLength = 30;
 const CONTEXT_MODELS_EDITOR = ( new RawContextKey("inModelsEditor", false));
 const CONTEXT_MODELS_SEARCH_FOCUS = ( new RawContextKey("inModelsSearch", false));
 const GeneralPurposeAgentName = "General Purpose";
 
-export { CONTEXT_MODELS_EDITOR, CONTEXT_MODELS_SEARCH_FOCUS, ChatAgentLocation, ChatConfiguration, ChatEditorTitleMaxLength, ChatModeKind, ChatNotificationMode, ChatPermissionLevel, CollapsedToolsDisplayMode, GeneralPurposeAgentName, MANAGE_CHAT_COMMAND_ID, ThinkingDisplayMode, isAutoApproveLevel, isChatPermissionLevel, isSupportedChatFileScheme };
+export { CONTEXT_MODELS_EDITOR, CONTEXT_MODELS_SEARCH_FOCUS, ChatAgentLocation, ChatConfiguration, ChatEditorTitleMaxLength, ChatModeKind, ChatNotificationMode, ChatPermissionLevel, CollapsedToolsDisplayMode, GeneralPurposeAgentName, MANAGE_CHAT_COMMAND_ID, OPEN_WORKSPACE_IN_AGENTS_WINDOW_COMMAND_ID, ThinkingDisplayMode, isAutoApproveLevel, isChatPermissionLevel, isSupportedChatFileScheme };

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

@@ -3,9 +3,9 @@ import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { Event } from "../../../../base/common/event.js";
 import { ThemeIcon } from "../../../../base/common/themables.js";
 import { URI } from "../../../../base/common/uri.js";
-import { IStorageSourceFilter } from "./aiCustomizationWorkspaceService.js";
+import { AICustomizationPromptsStorage, IStorageSourceFilter } from "./aiCustomizationWorkspaceService.js";
 import { PromptsType } from "./promptSyntax/promptTypes.js";
-import { IChatPromptSlashCommand, PromptsStorage } from "./promptSyntax/service/promptsService.js";
+import { IChatPromptSlashCommand, ICustomAgent, IResolvedChatPromptSlashCommand } from "./promptSyntax/service/promptsService.js";
 import { IPromptsService } from "./promptSyntax/service/promptsService.service.js";
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { ICustomizationHarnessService } from "./customizationHarnessService.service.js";
@@ -42,19 +42,21 @@ export interface ISectionOverride {
      */
     readonly fileExtension?: string;
 }
-/**
- * Identifies the AI harness (execution environment) that customizations
- * are filtered for. Storage answers "where did this come from?"; harness
- * answers "who consumes it?".
- */
-export declare enum CustomizationHarness {
-    VSCode = "vscode",
-    CLI = "cli"
+export interface ICustomizationItemAction {
+    readonly id: string;
+    readonly label: string;
+    readonly tooltip?: string;
+    readonly icon?: ThemeIcon;
+    readonly enabled?: boolean;
+    run(): void | Promise<void>;
 }
 /**
  * Describes a single harness option for the UI toggle.
  */
 export interface IHarnessDescriptor {
+    /**
+     * The harness/session-type identifier.
+     */
     readonly id: string;
     readonly label: string;
     readonly icon: ThemeIcon;
@@ -120,24 +122,35 @@ export interface IHarnessDescriptor {
      */
     readonly supportsTroubleshoot?: boolean;
     /**
-     * When set, this harness supports syncing local customizations to a
-     * remote target. The UI shows local items with sync checkboxes when
-     * this harness is active.
+     * When set, this harness uses an opt-out sync model where all eligible
+     * local customizations are synced by default. The UI shows disable
+     * affordances when this harness is active.
      */
     readonly syncProvider?: ICustomizationSyncProvider;
+    /**
+     * Optional plugin-management actions shown in the Plugins section add menu.
+     * Harnesses can use these to add environment-specific commands alongside
+     * the default install-from-source action (for example, configuring plugins on
+     * a remote agent host). The create action remains a separate toolbar button.
+     */
+    readonly pluginActions?: readonly ICustomizationItemAction[];
 }
 /**
  * Represents a customization item provided by any source.
  */
 export interface ICustomizationItem {
+    /** Optional stable identity used by list widgets when URI alone is not unique. */
+    readonly itemKey?: string;
     readonly uri: URI;
     readonly type: string;
     readonly name: string;
     readonly description?: string;
-    /** Storage origin (local, user, extension, plugin). Set by providers that know the source. */
-    readonly storage?: PromptsStorage;
-    /** Display name of the contributing extension (e.g. "GitHub Copilot Chat"). */
-    readonly extensionLabel?: string;
+    /** Storage origin (local, user, extension, plugin, builtin). Set by providers that know the source. */
+    readonly storage?: AICustomizationPromptsStorage;
+    /** The extension identifier that contributed this customization, if any. */
+    readonly extensionId: string | undefined;
+    /** The URI of the plugin that contributed this customization, if any. */
+    readonly pluginUri: URI | undefined;
     /** Server-reported loading status for this customization. */
     readonly status?: "loading" | "loaded" | "degraded" | "error";
     /** Human-readable status detail (e.g. error message or warning). */
@@ -150,7 +163,17 @@ export interface ICustomizationItem {
     readonly badge?: string;
     /** Tooltip shown when hovering the badge. */
     readonly badgeTooltip?: string;
+    /**
+     * Whether this customization item can be invoked by the user.
+     * Relevant for prompt / skill and custom agents
+     */
+    readonly userInvocable?: boolean;
+    /** Optional inline/context-menu actions specific to this item. */
+    readonly actions?: readonly ICustomizationItemAction[];
 }
+export declare function isPluginCustomizationItem(item: {
+    readonly type: string;
+}): boolean;
 /**
  * Provider interface for extension-contributed harnesses that supply
  * customization items directly from their SDK.
@@ -166,35 +189,16 @@ export interface ICustomizationItemProvider {
     provideChatSessionCustomizations(token: CancellationToken): Promise<ICustomizationItem[] | undefined>;
 }
 /**
- * Provider interface for harnesses that support syncing local customizations
- * to a remote target (e.g. a remote agent host).
+ * Provider interface for harnesses that use an opt-out sync model.
  *
- * The UI shows local customization items with sync checkboxes when the
- * active harness has a sync provider. Selected items are persisted and
- * automatically included in the active client's customization set.
+ * Every eligible local customization is synced by default; the user
+ * can disable individual items. The persisted set captures only the
+ * user's opt-outs.
  */
 export interface ICustomizationSyncProvider {
-    /**
-     * Fires when the set of selected sync items changes.
-     */
     readonly onDidChange: Event<void>;
-    /**
-     * Returns the URIs of local customizations currently selected for syncing.
-     */
-    getSelectedUris(): readonly URI[];
-    /**
-     * Updates the set of local customization URIs selected for syncing.
-     */
-    setSelectedUris(uris: readonly URI[]): void;
-    /**
-     * Returns whether the given URI is currently selected for syncing.
-     */
-    isSelected(uri: URI): boolean;
-    /**
-     * Toggles the sync selection state for a single URI.
-     * @param type Optional prompt type for file-level sync tracking.
-     */
-    toggleUri(uri: URI, type?: PromptsType): void;
+    isDisabled(uri: URI): boolean;
+    setDisabled(uri: URI, disabled: boolean): void;
 }
 /**
  * Minimal slash-command metadata resolved from the active harness.
@@ -207,12 +211,6 @@ export interface ICustomizationSlashCommand {
     readonly userInvocable: boolean;
     readonly sessionTypes?: readonly string[];
 }
-/**
- * Returns the prompt and skill slash commands for the currently active harness.
- * Provider-backed harnesses contribute their own items directly; the default
- * VS Code harness falls back to the core prompts service.
- */
-export declare function getActiveHarnessSlashCommands(harnessService: ICustomizationHarnessService, promptsService: Pick<IPromptsService, "getPromptSlashCommands" | "isValidSlashCommandName">, token: CancellationToken): Promise<readonly IChatPromptSlashCommand[]>;
 /**
  * Returns the user-home directories accessible to the Copilot CLI harness.
  */
@@ -245,18 +243,35 @@ export declare function matchesInstructionFileFilter(filePath: string, filters:
  * descriptors and a default harness id.
  */
 export declare class CustomizationHarnessServiceBase implements ICustomizationHarnessService {
+    private readonly promptsService;
     readonly _serviceBrand: undefined;
+    private readonly _onDidChangeSlashCommands;
+    readonly onDidChangeSlashCommands: Event<{
+        readonly sessionType: string;
+    }>;
+    private readonly _onDidChangeCustomAgents;
+    readonly onDidChangeCustomAgents: Event<{
+        readonly sessionType: string;
+    }>;
+    private readonly _providerListeners;
+    private _isDisposed;
     private readonly _activeHarness;
     readonly activeHarness: IObservable<string>;
     private readonly _staticHarnesses;
     private readonly _externalHarnesses;
     private readonly _availableHarnesses;
     readonly availableHarnesses: IObservable<readonly IHarnessDescriptor[]>;
-    constructor(staticHarnesses: readonly IHarnessDescriptor[], defaultHarness: string);
+    constructor(staticHarnesses: readonly IHarnessDescriptor[], defaultHarness: string, promptsService: IPromptsService);
     private _getAllHarnesses;
     private _refreshAvailableHarnesses;
+    private _rebindProviderListeners;
+    dispose(): void;
     registerExternalHarness(descriptor: IHarnessDescriptor): IDisposable;
+    findHarnessById(id: string): IHarnessDescriptor | undefined;
     setActiveHarness(id: string): void;
     getStorageSourceFilter(type: PromptsType): IStorageSourceFilter;
     getActiveDescriptor(): IHarnessDescriptor;
+    getSlashCommands(sessionType: string, token: CancellationToken): Promise<readonly IChatPromptSlashCommand[]>;
+    getCustomAgents(sessionType: string, token: CancellationToken): Promise<readonly ICustomAgent[]>;
+    resolvePromptSlashCommand(name: string, sessionType: string, token: CancellationToken): Promise<IResolvedChatPromptSlashCommand | undefined>;
 }