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

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/chatViewTitleControl.d.ts

@@ -20,7 +20,7 @@ export declare class ChatViewTitleControl extends Disposable {
     private navigationToolbar?;
     private actionsToolbar?;
     private lastKnownHeight;
-    constructor(container: HTMLElement, delegate: IChatViewTitleDelegate, instantiationService: IInstantiationService);
+    constructor(container: HTMLElement, delegate: IChatViewTitleDelegate, resizeObserverCtor: typeof ResizeObserver | undefined, instantiationService: IInstantiationService);
     private registerActions;
     private render;
     update(model: IChatModel | undefined): void;

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/chatViewTitleControl.js

@@ -2,7 +2,7 @@
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import * as chatViewTitleControl from './media/chatViewTitleControl.css';
-import { h, EventType as EventType$1, addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { DisposableResizeObserver, getWindow, h, EventType as EventType$1, addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
 import { Gesture, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
@@ -23,12 +23,12 @@ let ChatViewTitleControl = class ChatViewTitleControl extends Disposable {
         ChatViewTitleControl_1 = this;
     }
     static {
-        this.DEFAULT_TITLE = ( localize(8414, "Chat"));
+        this.DEFAULT_TITLE = ( localize(10099, "Chat"));
     }
     static {
         this.PICK_AGENT_SESSION_ACTION_ID = "workbench.action.chat.pickAgentSession";
     }
-    constructor(container, delegate, instantiationService) {
+    constructor(container, delegate, resizeObserverCtor, instantiationService) {
         super();
         this.container = container;
         this.delegate = delegate;
@@ -40,6 +40,22 @@ let ChatViewTitleControl = class ChatViewTitleControl extends Disposable {
         this.modelDisposables = this._register(( new MutableDisposable()));
         this.lastKnownHeight = 0;
         this.render(this.container);
+        const resizeObserver = this._register(( new DisposableResizeObserver("ChatViewTitleControl.height", entries => {
+            const entry = entries.find(entry => entry.target === this.titleContainer);
+            if (!entry) {
+                return;
+            }
+            const height = entry.borderBoxSize[0]?.blockSize ?? entry.contentRect.height;
+            if (height !== this.lastKnownHeight) {
+                this.lastKnownHeight = height;
+                this._onDidChangeHeight.fire();
+            }
+        }, getWindow(this.titleContainer), {
+            resizeObserverCtor
+        })));
+        this._register(resizeObserver.observe(this.titleContainer, {
+            box: "border-box"
+        }));
         this.registerActions();
     }
     registerActions() {
@@ -48,7 +64,7 @@ let ChatViewTitleControl = class ChatViewTitleControl extends Disposable {
             constructor() {
                 super({
                     id: ChatViewTitleControl_1.PICK_AGENT_SESSION_ACTION_ID,
-                    title: ( localize(8415, "Pick Agent Session")),
+                    title: ( localize(10100, "Pick Agent Session")),
                     f1: false,
                     menu: [{
                         id: MenuId.ChatViewSessionTitleNavigationToolbar,
@@ -138,23 +154,15 @@ let ChatViewTitleControl = class ChatViewTitleControl extends Disposable {
         }
         this.titleContainer.classList.toggle("visible", this.shouldRender());
         this.titleLabel.value?.updateTitle(title);
-        const currentHeight = this.getHeight();
-        if (currentHeight !== this.lastKnownHeight) {
-            this.lastKnownHeight = currentHeight;
-            this._onDidChangeHeight.fire();
-        }
     }
     shouldRender() {
         return !!this.model?.title;
     }
     getHeight() {
-        if (!this.titleContainer || this.titleContainer.style.display === "none") {
-            return 0;
-        }
-        return this.titleContainer.offsetHeight;
+        return this.lastKnownHeight;
     }
 };
-ChatViewTitleControl = ChatViewTitleControl_1 = ( __decorate([( __param(2, IInstantiationService))], ChatViewTitleControl));
+ChatViewTitleControl = ChatViewTitleControl_1 = ( __decorate([( __param(3, IInstantiationService))], ChatViewTitleControl));
 class ChatViewTitleLabel extends ActionViewItem {
     constructor(action, options) {
         super(null, action, {

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/media/chatViewPane.css

@@ -3,27 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-/* Voice Agent Bar — wraps the shared AgentsVoiceWidget inside input container */
-.voice-agent-bar {
-	display: flex;
-	flex-direction: column;
-	flex-shrink: 0;
-	border-bottom: 1px solid var(--vscode-panel-border);
-	position: relative;
-	overflow: hidden;
-}
-
-@keyframes voiceTextPulse {
-	0%,
-	100% {
-		opacity: 0.9;
-	}
-
-	50% {
-		opacity: 0.4;
-	}
-}
-
 .voice-transcript-overlay-scrollable {
 	position: absolute !important;
 	top: 0;
@@ -62,7 +41,12 @@
 	color: var(--vscode-foreground);
 	opacity: 0.6;
 	font-style: italic;
-	animation: voiceTextPulse 1.5s ease-in-out infinite;
+}
+
+/* Placeholder text while listening: static, no shimmer animation. */
+.voice-transcript-overlay .listening {
+	color: var(--vscode-descriptionForeground);
+	font-style: italic;
 }
 
 .voice-transcript-overlay .assistant-text {

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

@@ -0,0 +1,22 @@
+import { IAutomationDescriptor, IAutomationSchedule } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automation";
+export declare const AUTOMATION_BLUEPRINT_FILE_SUFFIX = ".automation.md";
+export declare const AUTOMATION_BLUEPRINT_VERSION = 1;
+export type AutomationBlueprintParseErrorCode = "invalidFrontmatter" | "unknownProperty" | "invalidField" | "unsupportedVersion" | "invalidId" | "unsupportedSchedule" | "unsupportedTimeZone" | "missingPrompt";
+export declare class AutomationBlueprintParseError extends Error {
+    readonly code: AutomationBlueprintParseErrorCode;
+    readonly property?: string | undefined;
+    constructor(code: AutomationBlueprintParseErrorCode, property?: string | undefined);
+}
+/** A portable Automation definition without execution authority or machine-specific target state. */
+export interface IAutomationBlueprint {
+    readonly version: typeof AUTOMATION_BLUEPRINT_VERSION;
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly prompt: string;
+    readonly schedule: IAutomationSchedule;
+}
+export declare function parseAutomationBlueprint(content: string): IAutomationBlueprint;
+export declare function serializeAutomationBlueprint(blueprint: IAutomationBlueprint): string;
+export declare function automationToBlueprint(automation: IAutomationDescriptor): IAutomationBlueprint;
+export declare function createAutomationBlueprintFileName(name: string): string;

package/vscode/src/vs/workbench/contrib/chat/common/automations/automationBlueprint.js

@@ -0,0 +1,163 @@
+
+import { parseFrontMatter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/yaml';
+
+const AUTOMATION_BLUEPRINT_FILE_SUFFIX = ".automation.md";
+const AUTOMATION_BLUEPRINT_VERSION = 1;
+const AUTOMATION_BLUEPRINT_ID_PATTERN = /^(?!.*(?:--|\.\.))[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const AUTOMATION_BLUEPRINT_PROPERTIES = ( new Set(["version", "id", "name", "description", "schedule"]));
+const AUTOMATION_BLUEPRINT_MANUAL_SCHEDULE_PROPERTIES = ( new Set(["kind"]));
+const AUTOMATION_BLUEPRINT_HOURLY_SCHEDULE_PROPERTIES = ( new Set(["kind"]));
+const AUTOMATION_BLUEPRINT_CRON_SCHEDULE_PROPERTIES = ( new Set(["kind", "expression", "timeZone"]));
+class AutomationBlueprintParseError extends Error {
+    constructor(code, property) {
+        super(property ? `${code}: ${property}` : code);
+        this.code = code;
+        this.property = property;
+    }
+}
+function parseAutomationBlueprint(content) {
+    const errors = [];
+    const document = parseFrontMatter(content, errors);
+    if (!document?.header || document.header.type !== "map" || errors.length > 0) {
+        throw ( new AutomationBlueprintParseError("invalidFrontmatter"));
+    }
+    assertKnownProperties(document.header, AUTOMATION_BLUEPRINT_PROPERTIES);
+    const version = readRequiredInteger(document.header, "version");
+    if (version !== AUTOMATION_BLUEPRINT_VERSION) {
+        throw ( new AutomationBlueprintParseError("unsupportedVersion", String(version)));
+    }
+    const id = readRequiredString(document.header, "id");
+    if (id.length > 64 || !AUTOMATION_BLUEPRINT_ID_PATTERN.test(id)) {
+        throw ( new AutomationBlueprintParseError("invalidId", id));
+    }
+    const name = readRequiredString(document.header, "name");
+    const description = readOptionalString(document.header, "description");
+    const schedule = readSchedule(document.header);
+    const prompt = document.body.trim();
+    if (!prompt) {
+        throw ( new AutomationBlueprintParseError("missingPrompt"));
+    }
+    return {
+        version: AUTOMATION_BLUEPRINT_VERSION,
+        id,
+        name,
+        ...(description ? {
+            description
+        } : {}),
+        prompt,
+        schedule
+    };
+}
+function readSchedule(root) {
+    const node = getProperty(root, "schedule");
+    if (!node || node.type !== "map") {
+        throw ( new AutomationBlueprintParseError("invalidField", "schedule"));
+    }
+    const kind = readRequiredString(node, "kind");
+    if (kind === "manual") {
+        assertKnownProperties(node, AUTOMATION_BLUEPRINT_MANUAL_SCHEDULE_PROPERTIES, "schedule.");
+        return {
+            interval: "manual",
+            scheduleHour: 0,
+            scheduleMinute: 0,
+            scheduleDay: 0
+        };
+    }
+    if (kind === "hourly") {
+        assertKnownProperties(node, AUTOMATION_BLUEPRINT_HOURLY_SCHEDULE_PROPERTIES, "schedule.");
+        return {
+            interval: "hourly",
+            scheduleHour: 0,
+            scheduleMinute: 0,
+            scheduleDay: 0
+        };
+    }
+    if (kind !== "cron") {
+        throw ( new AutomationBlueprintParseError("invalidField", "schedule.kind"));
+    }
+    assertKnownProperties(node, AUTOMATION_BLUEPRINT_CRON_SCHEDULE_PROPERTIES, "schedule.");
+    const expression = readRequiredString(node, "expression");
+    const timeZone = readRequiredString(node, "timeZone");
+    if (timeZone !== "local") {
+        throw ( new AutomationBlueprintParseError("unsupportedTimeZone", timeZone));
+    }
+    return fromCronExpression(expression);
+}
+function fromCronExpression(expression) {
+    const [minuteValue, hourValue, dayOfMonth, month, dayValue, ...remaining] = expression.trim().split(/\s+/);
+    if (remaining.length > 0 || dayOfMonth !== "*" || month !== "*") {
+        throw ( new AutomationBlueprintParseError("unsupportedSchedule", expression));
+    }
+    const scheduleMinute = parseCronValue(minuteValue, 0, 59);
+    if (scheduleMinute === undefined) {
+        throw ( new AutomationBlueprintParseError("unsupportedSchedule", expression));
+    }
+    const scheduleHour = parseCronValue(hourValue, 0, 23);
+    if (scheduleHour === undefined) {
+        throw ( new AutomationBlueprintParseError("unsupportedSchedule", expression));
+    }
+    if (dayValue === "*") {
+        return {
+            interval: "daily",
+            scheduleHour,
+            scheduleMinute,
+            scheduleDay: 0
+        };
+    }
+    const scheduleDay = parseCronValue(dayValue, 0, 7);
+    if (scheduleDay === undefined) {
+        throw ( new AutomationBlueprintParseError("unsupportedSchedule", expression));
+    }
+    return {
+        interval: "weekly",
+        scheduleHour,
+        scheduleMinute,
+        scheduleDay: scheduleDay === 7 ? 0 : scheduleDay
+    };
+}
+function parseCronValue(value, minimum, maximum) {
+    if (!value || !/^\d+$/.test(value)) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return parsed >= minimum && parsed <= maximum ? parsed : undefined;
+}
+function assertKnownProperties(node, known, prefix = "") {
+    const unknown = node.properties.find(property => !( known.has(property.key.value)));
+    if (unknown) {
+        throw ( new AutomationBlueprintParseError("unknownProperty", `${prefix}${unknown.key.value}`));
+    }
+}
+function getProperty(node, name) {
+    return node.properties.find(property => property.key.value === name)?.value;
+}
+function readRequiredString(node, name) {
+    const value = readOptionalString(node, name);
+    if (!value) {
+        throw ( new AutomationBlueprintParseError("invalidField", name));
+    }
+    return value;
+}
+function readOptionalString(node, name) {
+    const property = getProperty(node, name);
+    if (!property) {
+        return undefined;
+    }
+    if (property.type !== "scalar") {
+        throw ( new AutomationBlueprintParseError("invalidField", name));
+    }
+    return property.value.trim();
+}
+function readRequiredInteger(node, name) {
+    const property = getProperty(node, name);
+    if (!property || property.type !== "scalar" || !/^-?\d+$/.test(property.value)) {
+        throw ( new AutomationBlueprintParseError("invalidField", name));
+    }
+    const value = Number(property.value);
+    if (!Number.isSafeInteger(value)) {
+        throw ( new AutomationBlueprintParseError("invalidField", name));
+    }
+    return value;
+}
+
+export { AUTOMATION_BLUEPRINT_FILE_SUFFIX, AUTOMATION_BLUEPRINT_VERSION, AutomationBlueprintParseError, parseAutomationBlueprint };

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

@@ -4,7 +4,10 @@ import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ChatDebugLogLevel, IChatDebugEvent, IChatDebugLogProvider, IChatDebugResolvedEventContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService";
 import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 export declare class ChatDebugServiceImpl extends Disposable implements IChatDebugService {
+    private readonly _configurationService;
     readonly _serviceBrand: undefined;
     static readonly MAX_EVENTS_PER_SESSION = 10000;
     static readonly MAX_SESSIONS = 5;
@@ -27,6 +30,14 @@ export declare class ChatDebugServiceImpl extends Disposable implements IChatDeb
     readonly onDidChangeAvailableSessionResources: Event<void>;
     private readonly _providers;
     private readonly _invocationCts;
+    /**
+     * Sessions whose provider events should be cleared before the next batch of
+     * provider events is applied. The clear is deferred until the first new
+     * provider event actually arrives so that a provider which transiently
+     * returns nothing (e.g. an Agent Host `events.jsonl` mid-rewrite) does not
+     * wipe the events currently shown.
+     */
+    private readonly _pendingProviderClear;
     /** Events that were returned by providers (not internally logged). */
     private readonly _providerEvents;
     /** Session URIs created via import. */
@@ -38,12 +49,24 @@ export declare class ChatDebugServiceImpl extends Disposable implements IChatDeb
     private readonly _historicalSessionTitles;
     /** Human-readable titles for imported sessions. */
     private readonly _importedSessionTitles;
-    activeSessionResource: URI | undefined;
+    private readonly _hasActiveSessionContextKey;
+    private readonly _activeSessionIsAgentHostContextKey;
+    private _activeSessionResource;
+    get activeSessionResource(): URI | undefined;
+    set activeSessionResource(value: URI | undefined);
+    constructor(_configurationService: IConfigurationService, contextKeyService: IContextKeyService);
     /** Priority for deduplicating events with the same ID: lower = richer. */
     private static readonly _eventKindPriority;
     /** Session types eligible for debug logging and provider invocation. */
     private static readonly _debugEligibleSessionTypes;
     private _isDebugEligibleSession;
+    /**
+     * The in-memory event capacity for a session. Agent host (Copilot CLI)
+     * sessions honor a dedicated, configurable cap so their (potentially large)
+     * on-disk logs can be surfaced without changing the local-session default;
+     * all other sessions use {@link ChatDebugServiceImpl.MAX_EVENTS_PER_SESSION}.
+     */
+    private _capacityForSession;
     log(sessionResource: URI, name: string, details?: string, level?: ChatDebugLogLevel, options?: {
         id?: string;
         category?: string;
@@ -72,15 +95,14 @@ export declare class ChatDebugServiceImpl extends Disposable implements IChatDeb
         uri: URI;
         title?: string;
     }[]): void;
-    /** Lazy fetcher for available sessions from the extension. */
-    private _availableSessionsFetcher;
-    private _availableSessionsFetchStarted;
+    /** Lazy fetchers for available sessions from providers. Each is invoked at most once. */
+    private readonly _availableSessionsFetchers;
     private _availableSessionsRequested;
     getAvailableSessionResources(): readonly URI[];
     registerAvailableSessionsFetcher(fetcher: (token: CancellationToken) => Promise<{
         uri: URI;
         title?: string;
-    }[]>): void;
+    }[]>): IDisposable;
     private _tryFetchAvailableSessions;
     getHistoricalSessionTitle(sessionResource: URI): string | undefined;
     exportLog(sessionResource: URI): Promise<Uint8Array | undefined>;

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

@@ -1,4 +1,5 @@
 
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
@@ -6,10 +7,14 @@ import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/c
 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 { extUri } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { ChatDebugLogLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
-import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { CHAT_DEBUG_HAS_ACTIVE_SESSION, CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST, ChatDebugLogLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
+import { isAgentHostTarget, localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { AgentHostAgentDebugLogMaxEventsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 
+var ChatDebugServiceImpl_1;
 class SessionEventBuffer {
     constructor(capacity) {
         this.capacity = capacity;
@@ -64,9 +69,27 @@ class SessionEventBuffer {
         this._size = 0;
     }
 }
-class ChatDebugServiceImpl extends Disposable {
-    constructor() {
-        super(...arguments);
+let ChatDebugServiceImpl = class ChatDebugServiceImpl extends Disposable {
+    static {
+        ChatDebugServiceImpl_1 = this;
+    }
+    static {
+        this.MAX_EVENTS_PER_SESSION = 10_000;
+    }
+    static {
+        this.MAX_SESSIONS = 5;
+    }
+    get activeSessionResource() {
+        return this._activeSessionResource;
+    }
+    set activeSessionResource(value) {
+        this._activeSessionResource = value;
+        this._hasActiveSessionContextKey.set(value !== undefined);
+        this._activeSessionIsAgentHostContextKey.set(value ? isAgentHostTarget(getChatSessionType(value)) : false);
+    }
+    constructor(_configurationService, contextKeyService) {
+        super();
+        this._configurationService = _configurationService;
         this._sessionBuffers = ( new ResourceMap());
         this._sessionOrder = [];
         this._seenEventIds = ( new ResourceMap());
@@ -80,20 +103,21 @@ class ChatDebugServiceImpl extends Disposable {
         this.onDidChangeAvailableSessionResources = this._onDidChangeAvailableSessionResources.event;
         this._providers = ( new Set());
         this._invocationCts = ( new ResourceMap());
+        this._pendingProviderClear = ( new ResourceMap());
         this._providerEvents = ( new WeakSet());
         this._importedSessions = ( new ResourceMap());
         this._availableSessionResources = [];
         this._availableSessionResourceSet = ( new Set());
         this._historicalSessionTitles = ( new ResourceMap());
         this._importedSessionTitles = ( new ResourceMap());
-        this._availableSessionsFetchStarted = false;
+        this._availableSessionsFetchers = ( new Set());
         this._availableSessionsRequested = false;
-    }
-    static {
-        this.MAX_EVENTS_PER_SESSION = 10_000;
-    }
-    static {
-        this.MAX_SESSIONS = 5;
+        this._hasActiveSessionContextKey = CHAT_DEBUG_HAS_ACTIVE_SESSION.bindTo(contextKeyService);
+        this._activeSessionIsAgentHostContextKey = CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST.bindTo(contextKeyService);
+        this._register(toDisposable(() => {
+            this._hasActiveSessionContextKey.reset();
+            this._activeSessionIsAgentHostContextKey.reset();
+        }));
     }
     static {
         this._eventKindPriority = {
@@ -109,13 +133,22 @@ class ChatDebugServiceImpl extends Disposable {
         this._debugEligibleSessionTypes = ( new Set([
         localChatSessionType,
         "copilotcli",
-        "agent-host-copilotcli",
-        "claude-code"]));
+        "agent-host-copilotcli"]));
     }
     _isDebugEligibleSession(sessionResource) {
         const sessionType = getChatSessionType(sessionResource);
         return (
-        ChatDebugServiceImpl._debugEligibleSessionTypes.has(sessionType)) || (sessionType.startsWith("remote-") && sessionType.endsWith("-copilotcli")) || ( this._importedSessions.has(sessionResource));
+        ChatDebugServiceImpl_1._debugEligibleSessionTypes.has(sessionType)) || (sessionType.startsWith("remote-") && sessionType.endsWith("-copilotcli")) || ( this._importedSessions.has(sessionResource));
+    }
+    _capacityForSession(sessionResource) {
+        if (!isAgentHostTarget(getChatSessionType(sessionResource))) {
+            return ChatDebugServiceImpl_1.MAX_EVENTS_PER_SESSION;
+        }
+        const configured = this._configurationService.getValue(AgentHostAgentDebugLogMaxEventsSettingId);
+        if (typeof configured === "number" && Number.isFinite(configured) && configured >= 1) {
+            return Math.floor(configured);
+        }
+        return ChatDebugServiceImpl_1.MAX_EVENTS_PER_SESSION;
     }
     log(sessionResource, name, details, level = ChatDebugLogLevel.Info, options) {
         if (!this._isDebugEligibleSession(sessionResource)) {
@@ -134,6 +167,8 @@ class ChatDebugServiceImpl extends Disposable {
         });
     }
     addEvent(event) {
+        let buffer = this._sessionBuffers.get(event.sessionResource);
+        const capacity = buffer?.capacity ?? this._capacityForSession(event.sessionResource);
         if (event.id) {
             let seen = this._seenEventIds.get(event.sessionResource);
             if (!seen) {
@@ -142,26 +177,25 @@ class ChatDebugServiceImpl extends Disposable {
             }
             const existingKind = seen.get(event.id);
             if (existingKind !== undefined) {
-                const priority = ChatDebugServiceImpl._eventKindPriority;
+                const priority = ChatDebugServiceImpl_1._eventKindPriority;
                 if ((priority[event.kind] ?? 5) >= (priority[existingKind] ?? 5)) {
                     return;
                 }
             }
             seen.set(event.id, event.kind);
-            if (seen.size > ChatDebugServiceImpl.MAX_EVENTS_PER_SESSION) {
+            if (seen.size > capacity) {
                 const firstKey = ( seen.keys()).next().value;
                 if (firstKey !== undefined) {
                     seen.delete(firstKey);
                 }
             }
         }
-        let buffer = this._sessionBuffers.get(event.sessionResource);
         if (!buffer) {
-            if (this._sessionOrder.length >= ChatDebugServiceImpl.MAX_SESSIONS) {
+            if (this._sessionOrder.length >= ChatDebugServiceImpl_1.MAX_SESSIONS) {
                 const evicted = this._sessionOrder.shift();
                 this._evictSession(evicted);
             }
-            buffer = ( new SessionEventBuffer(ChatDebugServiceImpl.MAX_EVENTS_PER_SESSION));
+            buffer = ( new SessionEventBuffer(capacity));
             this._sessionBuffers.set(event.sessionResource, buffer);
             this._sessionOrder.push(event.sessionResource);
         } else {
@@ -178,6 +212,10 @@ class ChatDebugServiceImpl extends Disposable {
         this._onDidAddEvent.fire(event);
     }
     addProviderEvent(event) {
+        if (( this._pendingProviderClear.has(event.sessionResource))) {
+            this._pendingProviderClear.delete(event.sessionResource);
+            this._clearProviderEvents(event.sessionResource);
+        }
         this._providerEvents.add(event);
         this.addEvent(event);
     }
@@ -211,7 +249,7 @@ class ChatDebugServiceImpl extends Disposable {
     }
     _deduplicateEvents(events) {
         const seen = ( new Map());
-        const priority = ChatDebugServiceImpl._eventKindPriority;
+        const priority = ChatDebugServiceImpl_1._eventKindPriority;
         const result = [];
         for (const event of events) {
             if (!event.id) {
@@ -279,7 +317,7 @@ class ChatDebugServiceImpl extends Disposable {
             existingCts.cancel();
             existingCts.dispose();
         }
-        this._clearProviderEvents(sessionResource);
+        this._pendingProviderClear.set(sessionResource, true);
         const cts = ( new CancellationTokenSource());
         this._invocationCts.set(sessionResource, cts);
         try {
@@ -390,21 +428,29 @@ class ChatDebugServiceImpl extends Disposable {
         return result;
     }
     registerAvailableSessionsFetcher(fetcher) {
-        this._availableSessionsFetcher = fetcher;
-        this._availableSessionsFetchStarted = false;
+        const entry = {
+            fetcher,
+            started: false
+        };
+        this._availableSessionsFetchers.add(entry);
         this._tryFetchAvailableSessions();
+        return toDisposable(() => this._availableSessionsFetchers.delete(entry));
     }
     _tryFetchAvailableSessions() {
-        if (!this._availableSessionsFetcher || !this._availableSessionsRequested || this._availableSessionsFetchStarted) {
+        if (!this._availableSessionsRequested) {
             return;
         }
-        this._availableSessionsFetchStarted = true;
-        const fetcher = this._availableSessionsFetcher;
-        fetcher(CancellationToken.None).then(entries => {
-            if (entries.length > 0) {
-                this.addAvailableSessionResources(entries);
+        for (const entry of this._availableSessionsFetchers) {
+            if (entry.started) {
+                continue;
             }
-        }).catch(onUnexpectedError);
+            entry.started = true;
+            entry.fetcher(CancellationToken.None).then(entries => {
+                if (entries.length > 0) {
+                    this.addAvailableSessionResources(entries);
+                }
+            }).catch(onUnexpectedError);
+        }
     }
     getHistoricalSessionTitle(sessionResource) {
         return this._historicalSessionTitles.get(sessionResource);
@@ -450,6 +496,7 @@ class ChatDebugServiceImpl extends Disposable {
         this._providers.clear();
         super.dispose();
     }
-}
+};
+ChatDebugServiceImpl = ChatDebugServiceImpl_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IContextKeyService))], ChatDebugServiceImpl));
 
 export { ChatDebugServiceImpl };

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

@@ -0,0 +1,6 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export declare enum ChatNotificationKind {
+    NeedsInput = "needsInput",
+    Idle = "idle"
+}
+export declare function getChatNotificationDedupeKey(sessionResource: URI, kind: ChatNotificationKind): string;

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

@@ -0,0 +1,12 @@
+
+
+var ChatNotificationKind;
+(function(ChatNotificationKind) {
+    ChatNotificationKind["NeedsInput"] = "needsInput";
+    ChatNotificationKind["Idle"] = "idle";
+})(ChatNotificationKind || (ChatNotificationKind = {}));
+function getChatNotificationDedupeKey(sessionResource, kind) {
+    return `chat-session:${( sessionResource.toString())}:${kind}`;
+}
+
+export { ChatNotificationKind, getChatNotificationDedupeKey };