@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -0,0 +1,115 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
+import { ChatConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { PromptFileSource, PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { PromptsStorage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+export declare enum CustomizationMigrationType {
+    UserData = "userData",
+    PromptFiles = "promptFiles",
+    ConfiguredLocations = "configuredLocations",
+    McpServers = "mcpServers"
+}
+export declare function getCustomizationMigrationEnablementSetting(type: CustomizationMigrationType): ChatConfiguration;
+export interface MigratableConfiguration {
+    readonly uri: URI;
+    readonly type: PromptsType;
+    readonly storage: PromptsStorage;
+    readonly name?: string;
+    readonly description?: string;
+    readonly source?: PromptFileSource;
+}
+export declare function getCustomizationMigrationTargetType(customization: MigratableConfiguration): PromptsType;
+export declare function isPromptFileMigrationCandidate(customization: MigratableConfiguration): boolean;
+export declare function isUserDataMigrationCandidate(customization: MigratableConfiguration): boolean;
+export declare function isConfiguredLocationMigrationCandidate(customization: MigratableConfiguration): boolean;
+export type FileCustomizationMigrationType = CustomizationMigrationType.UserData | CustomizationMigrationType.PromptFiles | CustomizationMigrationType.ConfiguredLocations;
+export interface FileCustomizationMigration {
+    readonly type: FileCustomizationMigrationType;
+    readonly files: readonly URI[];
+    readonly candidates: readonly MigratableConfiguration[];
+}
+export interface IMcpServerCustomizationMigrationItem {
+    readonly id: string;
+    readonly name: string;
+    /** Whether Agent Host delivery fully supports this server's configuration. */
+    readonly supported: boolean;
+}
+export interface IMcpServerCustomizationMigrationCandidate {
+    readonly type: CustomizationMigrationType.McpServers;
+    readonly id: string;
+    readonly name: string;
+    readonly sourceUri: URI;
+    readonly targetUri: URI;
+    readonly projectedConfiguration: IMcpServerConfiguration;
+}
+export declare function getMcpServerCustomizationMigrationCandidateKey(candidate: IMcpServerCustomizationMigrationCandidate): string;
+export interface IAgentHostMcpServerSupportCoverage {
+    /** Some installed servers may be absent or disabled because MCP access is restricted. */
+    readonly restrictedByMcpAccess: boolean;
+    /** Customization policy may prevent otherwise supported servers from reaching the Agent Host. */
+    readonly restrictedByCustomizationPolicy: boolean;
+}
+export interface McpServerCustomizationMigration {
+    readonly type: CustomizationMigrationType.McpServers;
+    readonly servers: readonly IMcpServerCustomizationMigrationItem[];
+    readonly candidates: readonly IMcpServerCustomizationMigrationCandidate[];
+    /** Whether all lazy MCP collections known to the client have loaded; when false, servers may be missing. */
+    readonly discoveryComplete: boolean;
+    /** Snapshot-wide restrictions that may limit inventory or delivery, independent of per-server support. */
+    readonly coverage: IAgentHostMcpServerSupportCoverage;
+}
+export declare enum McpServerCustomizationMigrationFailureReason {
+    /** The server or execution context no longer satisfies the migration requirements. */
+    NoLongerEligible = "noLongerEligible",
+    /** A source configuration file is missing or could not be read. */
+    SourceUnavailable = "sourceUnavailable",
+    /** The source JSON, servers map, or selected server definition is invalid. */
+    InvalidSource = "invalidSource",
+    /** The configuration cannot be moved losslessly because of unsupported properties, unresolved variables, or projection differences. */
+    UnrepresentableConfiguration = "unrepresentableConfiguration",
+    /** The source entry or file no longer matches what was validated for migration. */
+    SourceChanged = "sourceChanged",
+    /** An existing destination cannot be read or parsed as a supported MCP configuration document. */
+    InvalidTarget = "invalidTarget",
+    /** The destination already defines the same server name with a non-equivalent configuration. */
+    TargetConflict = "targetConflict",
+    /** The server name is also defined or selected for migration in another workspace root. */
+    CrossRootConflict = "crossRootConflict",
+    /** The destination changed before writing, or final source/target verification failed. */
+    TargetChanged = "targetChanged",
+    /** A migration file operation failed without a more specific failure reason. */
+    WriteFailed = "writeFailed",
+    /** Original file contents could not be safely restored; a newly created destination may be retained. */
+    RollbackFailed = "rollbackFailed",
+    /** The source and destination are not a same-root .vscode/mcp.json to .mcp.json pair. */
+    InconsistentTarget = "inconsistentTarget"
+}
+export interface IMcpServerCustomizationMigrationFailure {
+    readonly id: string;
+    readonly name: string;
+    readonly sourceUri: URI;
+    readonly targetUri: URI;
+    readonly reason: McpServerCustomizationMigrationFailureReason;
+    readonly conflictingUri?: URI;
+    readonly error?: Error;
+}
+export interface IMcpServerCustomizationMigrationResult {
+    readonly migratedCount: number;
+    readonly failures: readonly IMcpServerCustomizationMigrationFailure[];
+}
+export type CustomizationMigrationCandidate = MigratableConfiguration | IMcpServerCustomizationMigrationCandidate;
+export declare function isMcpServerCustomizationMigrationCandidate(candidate: CustomizationMigrationCandidate): candidate is IMcpServerCustomizationMigrationCandidate;
+export type CustomizationMigration = FileCustomizationMigration | McpServerCustomizationMigration;
+export declare enum CustomizationMigrationHintTarget {
+    FileMigrations = "fileMigrations",
+    McpServers = "mcpServers"
+}
+export interface ICustomizationMigrationHint {
+    readonly message: string;
+    readonly target: CustomizationMigrationHintTarget;
+    readonly counts: readonly ICustomizationMigrationCount[];
+}
+export interface ICustomizationMigrationCount {
+    readonly type: CustomizationMigrationType;
+    readonly count: number;
+}

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

@@ -0,0 +1,69 @@
+
+import { getComparisonKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { PromptsType, PromptFileSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+
+var CustomizationMigrationType;
+(function (CustomizationMigrationType) {
+    CustomizationMigrationType["UserData"] = "userData";
+    CustomizationMigrationType["PromptFiles"] = "promptFiles";
+    CustomizationMigrationType["ConfiguredLocations"] = "configuredLocations";
+    CustomizationMigrationType["McpServers"] = "mcpServers";
+})(CustomizationMigrationType || (CustomizationMigrationType = {}));
+function getCustomizationMigrationEnablementSetting(type) {
+    switch (type) {
+        case CustomizationMigrationType.UserData: return ChatConfiguration.ChatCustomizationsUserDataMigrationEnabled;
+        case CustomizationMigrationType.PromptFiles: return ChatConfiguration.ChatCustomizationsPromptMigrationEnabled;
+        case CustomizationMigrationType.ConfiguredLocations: return ChatConfiguration.ChatCustomizationsLocationsMigrationEnabled;
+        case CustomizationMigrationType.McpServers: return ChatConfiguration.ChatCustomizationsMcpServerMigrationEnabled;
+    }
+}
+function getCustomizationMigrationTargetType(customization) {
+    return customization.type === PromptsType.prompt ? PromptsType.skill : customization.type;
+}
+function isPromptFileMigrationCandidate(customization) {
+    return customization.type === PromptsType.prompt
+        && (customization.storage === PromptsStorage.local || customization.storage === PromptsStorage.user);
+}
+function isUserDataMigrationCandidate(customization) {
+    return customization.source === PromptFileSource.UserData
+        && (customization.type === PromptsType.agent || customization.type === PromptsType.instructions);
+}
+function isConfiguredLocationMigrationCandidate(customization) {
+    return (customization.source === PromptFileSource.ConfigWorkspace || customization.source === PromptFileSource.ConfigPersonal)
+        && (customization.type === PromptsType.agent || customization.type === PromptsType.instructions || customization.type === PromptsType.skill);
+}
+function getMcpServerCustomizationMigrationCandidateKey(candidate) {
+    return JSON.stringify([
+        candidate.id,
+        candidate.name,
+        getComparisonKey(candidate.sourceUri),
+        getComparisonKey(candidate.targetUri),
+    ]);
+}
+var McpServerCustomizationMigrationFailureReason;
+(function (McpServerCustomizationMigrationFailureReason) {
+    McpServerCustomizationMigrationFailureReason["NoLongerEligible"] = "noLongerEligible";
+    McpServerCustomizationMigrationFailureReason["SourceUnavailable"] = "sourceUnavailable";
+    McpServerCustomizationMigrationFailureReason["InvalidSource"] = "invalidSource";
+    McpServerCustomizationMigrationFailureReason["UnrepresentableConfiguration"] = "unrepresentableConfiguration";
+    McpServerCustomizationMigrationFailureReason["SourceChanged"] = "sourceChanged";
+    McpServerCustomizationMigrationFailureReason["InvalidTarget"] = "invalidTarget";
+    McpServerCustomizationMigrationFailureReason["TargetConflict"] = "targetConflict";
+    McpServerCustomizationMigrationFailureReason["CrossRootConflict"] = "crossRootConflict";
+    McpServerCustomizationMigrationFailureReason["TargetChanged"] = "targetChanged";
+    McpServerCustomizationMigrationFailureReason["WriteFailed"] = "writeFailed";
+    McpServerCustomizationMigrationFailureReason["RollbackFailed"] = "rollbackFailed";
+    McpServerCustomizationMigrationFailureReason["InconsistentTarget"] = "inconsistentTarget";
+})(McpServerCustomizationMigrationFailureReason || (McpServerCustomizationMigrationFailureReason = {}));
+function isMcpServerCustomizationMigrationCandidate(candidate) {
+    return candidate.type === CustomizationMigrationType.McpServers;
+}
+var CustomizationMigrationHintTarget;
+(function (CustomizationMigrationHintTarget) {
+    CustomizationMigrationHintTarget["FileMigrations"] = "fileMigrations";
+    CustomizationMigrationHintTarget["McpServers"] = "mcpServers";
+})(CustomizationMigrationHintTarget || (CustomizationMigrationHintTarget = {}));
+
+export { CustomizationMigrationHintTarget, CustomizationMigrationType, McpServerCustomizationMigrationFailureReason, getCustomizationMigrationEnablementSetting, getCustomizationMigrationTargetType, getMcpServerCustomizationMigrationCandidateKey, isConfiguredLocationMigrationCandidate, isMcpServerCustomizationMigrationCandidate, isPromptFileMigrationCandidate, isUserDataMigrationCandidate };

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

@@ -0,0 +1,60 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ISessionChatPillVisibilityService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/sessionChatPills.service";
+/** The kinds of pill shown above an agent chat input, each independently hideable. */
+export declare enum SessionChatPillKind {
+    Changes = "changes",
+    Artifacts = "artifacts",
+    References = "references",
+    Customizations = "customizations",
+    PullRequests = "pullRequests",
+    Issues = "issues",
+    Browsers = "browsers",
+    Subagents = "subagents"
+}
+/** All pill kinds, in the order they are offered in the visibility menu. */
+export declare const SESSION_CHAT_PILL_KINDS: readonly SessionChatPillKind[];
+export declare function getSessionChatPillLabel(kind: SessionChatPillKind): string;
+/**
+ * Whether the user can hide a pill. Changes reports what the turn did to the
+ * user's files, so it always shows once it has data.
+ */
+export declare function isSessionChatPillHideable(kind: SessionChatPillKind): boolean;
+/** One entry of the pill visibility context menu. */
+export interface ISessionChatPillMenuEntry {
+    readonly kind: SessionChatPillKind;
+    readonly label: string;
+    /** Whether the pill shows when it has data. */
+    readonly checked: boolean;
+}
+/**
+ * The pill visibility context menu: an optional "Hide X" for the pill that was
+ * right-clicked, then the kinds the surface has data for, then the rest. The
+ * caller renders a separator between the groups it shows.
+ */
+export interface ISessionChatPillMenu {
+    readonly hide?: {
+        readonly kind: SessionChatPillKind;
+        readonly label: string;
+    };
+    readonly withData: readonly ISessionChatPillMenuEntry[];
+    readonly withoutData: readonly ISessionChatPillMenuEntry[];
+}
+/**
+ * Builds the visibility menu. Every offered, hideable kind is listed and
+ * toggleable, checked while it is not hidden, and grouped by whether the
+ * current session has data for it.
+ */
+export declare function getSessionChatPillMenu(kindsWithData: ReadonlySet<SessionChatPillKind>, hiddenKinds: ReadonlySet<SessionChatPillKind>, targetKind?: SessionChatPillKind, offeredKinds?: readonly SessionChatPillKind[]): ISessionChatPillMenu;
+/** The user's per-kind pill visibility choices, persisted across windows. */
+export declare class SessionChatPillVisibility extends Disposable implements ISessionChatPillVisibilityService {
+    readonly _serviceBrand: undefined;
+    readonly pullRequests: ISessionChatPillVisibilityService["pullRequests"];
+    private readonly _hiddenKinds;
+    constructor(storageService: IStorageService);
+    readHiddenKinds(reader: IReader | undefined): ReadonlySet<SessionChatPillKind>;
+    isVisible(kind: SessionChatPillKind, reader: IReader | undefined): boolean;
+    hide(kind: SessionChatPillKind): void;
+    toggle(kind: SessionChatPillKind): void;
+}

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

@@ -0,0 +1,139 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { observableMemento } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/observableMemento';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+
+var SessionChatPillKind;
+(function(SessionChatPillKind) {
+    SessionChatPillKind["Changes"] = "changes";
+    SessionChatPillKind["Artifacts"] = "artifacts";
+    SessionChatPillKind["References"] = "references";
+    SessionChatPillKind["Customizations"] = "customizations";
+    SessionChatPillKind["PullRequests"] = "pullRequests";
+    SessionChatPillKind["Issues"] = "issues";
+    SessionChatPillKind["Browsers"] = "browsers";
+    SessionChatPillKind["Subagents"] = "subagents";
+})(SessionChatPillKind || (SessionChatPillKind = {}));
+const SESSION_CHAT_PILL_KINDS = [
+    SessionChatPillKind.Changes,
+    SessionChatPillKind.PullRequests,
+    SessionChatPillKind.Issues,
+    SessionChatPillKind.Artifacts,
+    SessionChatPillKind.References,
+    SessionChatPillKind.Customizations,
+    SessionChatPillKind.Browsers,
+    SessionChatPillKind.Subagents
+];
+function getSessionChatPillLabel(kind) {
+    switch (kind) {
+    case SessionChatPillKind.Changes:
+        return localize(10663, "Changes");
+    case SessionChatPillKind.Artifacts:
+        return localize(10664, "Artifacts");
+    case SessionChatPillKind.References:
+        return localize(10665, "References");
+    case SessionChatPillKind.Customizations:
+        return localize(10666, "Customizations");
+    case SessionChatPillKind.PullRequests:
+        return localize(10667, "Pull Requests");
+    case SessionChatPillKind.Issues:
+        return localize(10668, "Issues");
+    case SessionChatPillKind.Browsers:
+        return localize(10669, "Browsers");
+    case SessionChatPillKind.Subagents:
+        return localize(10670, "Subagents");
+    }
+}
+function isSessionChatPillHideable(kind) {
+    return kind !== SessionChatPillKind.Changes;
+}
+function getSessionChatPillMenu(
+    kindsWithData,
+    hiddenKinds,
+    targetKind,
+    offeredKinds = SESSION_CHAT_PILL_KINDS
+) {
+    const offered = ( new Set(offeredKinds));
+    const withData = [];
+    const withoutData = [];
+    for (const kind of SESSION_CHAT_PILL_KINDS) {
+        if (!( offered.has(kind)) || !isSessionChatPillHideable(kind)) {
+            continue;
+        }
+        (( kindsWithData.has(kind)) ? withData : withoutData).push({
+            kind,
+            label: getSessionChatPillLabel(kind),
+            checked: !( hiddenKinds.has(kind))
+        });
+    }
+    const hide = targetKind !== undefined && offeredKinds.includes(targetKind) && isSessionChatPillHideable(targetKind) ? {
+        kind: targetKind,
+        label: ( localize(10671, "Hide {0}", getSessionChatPillLabel(targetKind)))
+    } : undefined;
+    return {
+        ...(hide ? {
+            hide
+        } : {}),
+        withData,
+        withoutData
+    };
+}
+const defaultHiddenKinds = [SessionChatPillKind.Customizations, SessionChatPillKind.Subagents];
+const hiddenSessionChatPills = observableMemento({
+    defaultValue: defaultHiddenKinds,
+    key: "sessions.chatPills.hidden",
+    toStorage: kinds => JSON.stringify(kinds),
+    fromStorage: value => {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed.filter(kind => typeof kind === "string") : [];
+    }
+});
+const showAllSessionPullRequests = observableMemento({
+    defaultValue: true,
+    key: "sessions.chatPills.pullRequests.showAll",
+    toStorage: value => String(value),
+    fromStorage: value => value !== "false"
+});
+let SessionChatPillVisibility = class SessionChatPillVisibility extends Disposable {
+    constructor(storageService) {
+        super();
+        this._hiddenKinds = this._register(
+            hiddenSessionChatPills(StorageScope.APPLICATION, StorageTarget.USER, storageService)
+        );
+        const showAll = this._register(
+            showAllSessionPullRequests(StorageScope.APPLICATION, StorageTarget.USER, storageService)
+        );
+        this.pullRequests = {
+            showAll,
+            isVisible: (state, reader) => showAll.read(reader) || (state !== "closed" && state !== "merged"),
+            setShowAll: value => showAll.set(value, undefined)
+        };
+    }
+    readHiddenKinds(reader) {
+        return ( new Set(this._hiddenKinds.read(reader).filter(isSessionChatPillHideable)));
+    }
+    isVisible(kind, reader) {
+        return !isSessionChatPillHideable(kind) || !this._hiddenKinds.read(reader).includes(kind);
+    }
+    hide(kind) {
+        if (isSessionChatPillHideable(kind) && !this._hiddenKinds.get().includes(kind)) {
+            this._hiddenKinds.set([...this._hiddenKinds.get(), kind], undefined);
+        }
+    }
+    toggle(kind) {
+        if (!isSessionChatPillHideable(kind)) {
+            return;
+        }
+        const hidden = this._hiddenKinds.get();
+        this._hiddenKinds.set(
+            hidden.includes(kind) ? hidden.filter(hiddenKind => hiddenKind !== kind) : [...hidden, kind],
+            undefined
+        );
+    }
+};
+SessionChatPillVisibility = ( __decorate([( __param(0, IStorageService))], SessionChatPillVisibility));
+
+export { SESSION_CHAT_PILL_KINDS, SessionChatPillKind, SessionChatPillVisibility, getSessionChatPillLabel, getSessionChatPillMenu, isSessionChatPillHideable };

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

@@ -20,7 +20,7 @@ var PhraseTextType;
 })(PhraseTextType || (PhraseTextType = {}));
 const VoiceChatInProgress = ( new RawContextKey("voiceChatInProgress", false, {
     type: "boolean",
-    description: ( localize(9010, "A speech-to-text session is in progress for chat."))
+    description: ( localize(10738, "A speech-to-text session is in progress for chat."))
 }));
 let VoiceChatService = class VoiceChatService extends Disposable {
     static {

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

@@ -15,12 +15,17 @@ export declare class VoicePlaybackService extends Disposable implements IVoicePl
     private readonly _lastPlayed;
     private readonly _lastPlayedVersion;
     readonly lastPlayedVersion: IObservable<number>;
+    private readonly _pendingResponses;
+    private readonly _pendingResponseVersion;
+    readonly pendingResponseVersion: IObservable<number>;
     private _activeReplay;
     constructor(commandService: ICommandService);
     notifyPlaybackStart(sessionResource: URI | undefined, transcript: string | undefined): void;
     notifyPlaybackEnd(sessionResource: URI | undefined): void;
     getLastPlayed(sessionResource: URI): IVoicePlaybackEntry | undefined;
     hasLastPlayed(sessionResource: URI): boolean;
+    setPendingResponse(sessionResource: URI, pending: boolean): void;
+    hasPendingResponse(sessionResource: URI): boolean;
     replay(sessionResource: URI): Promise<void>;
     stop(sessionResource?: URI): void;
 }

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

@@ -2,7 +2,7 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
@@ -20,6 +20,9 @@ let VoicePlaybackService = class VoicePlaybackService extends Disposable {
         this._lastPlayed = ( new ResourceMap());
         this._lastPlayedVersion = observableValue(this, 0);
         this.lastPlayedVersion = this._lastPlayedVersion;
+        this._pendingResponses = ( new ResourceSet());
+        this._pendingResponseVersion = observableValue(this, 0);
+        this.pendingResponseVersion = this._pendingResponseVersion;
         this._register(toDisposable(() => {
             this._activeReplay?.dispose(true);
             this._activeReplay = undefined;
@@ -50,6 +53,23 @@ let VoicePlaybackService = class VoicePlaybackService extends Disposable {
     hasLastPlayed(sessionResource) {
         return ( this._lastPlayed.has(sessionResource));
     }
+    setPendingResponse(sessionResource, pending) {
+        let changed;
+        if (pending) {
+            changed = !( this._pendingResponses.has(sessionResource));
+            if (changed) {
+                this._pendingResponses.add(sessionResource);
+            }
+        } else {
+            changed = this._pendingResponses.delete(sessionResource);
+        }
+        if (changed) {
+            this._pendingResponseVersion.set(this._pendingResponseVersion.get() + 1, undefined);
+        }
+    }
+    hasPendingResponse(sessionResource) {
+        return ( this._pendingResponses.has(sessionResource));
+    }
     async replay(sessionResource) {
         const entry = this._lastPlayed.get(sessionResource);
         if (!entry || !entry.transcript) {

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

@@ -7,6 +7,25 @@ import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/fi
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 import { IChatResponseResourceFileSystemProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/chatResponseResourceFileSystemProvider.service";
+/**
+ * Data associated with a URI, readable until it is disposed. Disposing releases
+ * only this association; data shared with other associations of the same URI is
+ * kept until the last of them is disposed.
+ */
+export interface IChatResourceAssociation extends IDisposable {
+    readonly resource: URI;
+}
+export interface IChatResourceAssociateOptions {
+    /** Also releases the data when this chat session is disposed. */
+    readonly sessionResource?: URI;
+    /**
+     * Stable identity: associating the same id again yields the same URI, and its
+     * data is only released once every association for that id has been disposed.
+     */
+    readonly id?: string;
+    /** Appended to the URI so the resource carries a readable name. */
+    readonly name?: string;
+}
 export declare class ChatResponseResourceFileSystemProvider extends Disposable implements IChatResponseResourceFileSystemProvider, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileReadStreamCapability {
     private readonly chatService;
     private readonly _fileService;
@@ -19,9 +38,13 @@ export declare class ChatResponseResourceFileSystemProvider extends Disposable i
     /** Tracks which associated URIs belong to which session, for cleanup on dispose. */
     private readonly _sessionAssociations;
     constructor(chatService: IChatService, _fileService: IFileService);
-    associate(sessionResource: URI, data: Uint8Array | {
+    associate(data: Uint8Array | {
         base64: string;
-    }, name?: string): URI;
+    }, options?: IChatResourceAssociateOptions): IChatResourceAssociation;
+    /** Drops one reference to the data at `uri`, releasing it once none are left. */
+    private _release;
+    /** Releases the data at `uri` along with every session's claim on it. */
+    private _forget;
     readFile(resource: URI): Promise<Uint8Array>;
     readFileStream(resource: URI): ReadableStreamEvents<Uint8Array>;
     stat(resource: URI): Promise<IStat>;

package/vscode/src/vs/workbench/contrib/chat/common/widget/chatResponseResourceFileSystemProvider.js

@@ -2,6 +2,7 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { VSBuffer, decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { createSingleCallFunction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/functional';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { newWriteableStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stream';
@@ -28,29 +29,65 @@ let ChatResponseResourceFileSystemProvider = class ChatResponseResourceFileSyste
         this._register(this.chatService.onDidDisposeSession(e => {
             for (const sessionResource of e.sessionResources) {
                 const uris = this._sessionAssociations.get(sessionResource);
-                if (uris) {
-                    for (const uri of uris) {
-                        this._associated.delete(uri);
+                if (!uris) {
+                    continue;
+                }
+                for (const uri of [...uris]) {
+                    const entry = this._associated.get(uri);
+                    if (entry) {
+                        this._forget(uri, entry);
                     }
-                    this._sessionAssociations.delete(sessionResource);
                 }
+                this._sessionAssociations.delete(sessionResource);
             }
         }));
     }
-    associate(sessionResource, data, name) {
-        const id = generateUuid();
+    associate(data, options) {
         const uri = ( URI.from({
             scheme: ChatResponseResource.scheme,
-            path: `/assoc/${id}` + (name ? `/${name}` : "")
+            path: `/assoc/${options?.id ?? generateUuid()}` + (options?.name ? `/${options.name}` : "")
         }));
-        this._associated.set(uri, data);
-        let set = this._sessionAssociations.get(sessionResource);
-        if (!set) {
-            set = ( new ResourceSet());
-            this._sessionAssociations.set(sessionResource, set);
+        let entry = this._associated.get(uri);
+        if (entry) {
+            entry.data = data;
+            entry.refCount++;
+        } else {
+            entry = {
+                data,
+                refCount: 1,
+                sessionResources: ( new ResourceSet())
+            };
+            this._associated.set(uri, entry);
+        }
+        if (options?.sessionResource) {
+            entry.sessionResources.add(options.sessionResource);
+            let set = this._sessionAssociations.get(options.sessionResource);
+            if (!set) {
+                set = ( new ResourceSet());
+                this._sessionAssociations.set(options.sessionResource, set);
+            }
+            set.add(uri);
+        }
+        return {
+            resource: uri,
+            dispose: createSingleCallFunction(() => this._release(uri))
+        };
+    }
+    _release(uri) {
+        const entry = this._associated.get(uri);
+        if (!entry || --entry.refCount > 0) {
+            return;
+        }
+        this._forget(uri, entry);
+    }
+    _forget(uri, entry) {
+        this._associated.delete(uri);
+        for (const sessionResource of entry.sessionResources) {
+            const uris = this._sessionAssociations.get(sessionResource);
+            if (uris?.delete(uri) && uris.size === 0) {
+                this._sessionAssociations.delete(sessionResource);
+            }
         }
-        set.add(uri);
-        return uri;
     }
     readFile(resource) {
         return Promise.resolve(this.lookupURI(resource));
@@ -119,11 +156,11 @@ let ChatResponseResourceFileSystemProvider = class ChatResponseResourceFileSyste
     lookupURI(uri) {
         const associated = this._associated.get(uri);
         if (associated) {
-            if (associated instanceof Uint8Array) {
-                return associated;
+            if (associated.data instanceof Uint8Array) {
+                return associated.data;
             }
-            const decoded = decodeBase64(associated.base64).buffer;
-            this._associated.set(uri, decoded);
+            const decoded = decodeBase64(associated.data.base64).buffer;
+            associated.data = decoded;
             return decoded;
         }
         const {