@codingame/monaco-vscode-chat-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/chatDebugHomeView.d.ts

@@ -0,0 +1,19 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+export declare class ChatDebugHomeView extends Disposable {
+    private readonly chatService;
+    private readonly chatDebugService;
+    private readonly chatWidgetService;
+    private readonly _onNavigateToSession;
+    readonly onNavigateToSession: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<URI>;
+    readonly container: HTMLElement;
+    private readonly scrollContent;
+    private readonly renderDisposables;
+    constructor(parent: HTMLElement, chatService: IChatService, chatDebugService: IChatDebugService, chatWidgetService: IChatWidgetService);
+    show(): void;
+    hide(): void;
+    render(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/chatDebugHomeView.js

@@ -0,0 +1,128 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, append, clearNode, addDisposableListener, EventType, getActiveElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { isUUID } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+
+const $ = $$1;
+let ChatDebugHomeView = class ChatDebugHomeView extends Disposable {
+    constructor(parent, chatService, chatDebugService, chatWidgetService) {
+        super();
+        this.chatService = chatService;
+        this.chatDebugService = chatDebugService;
+        this.chatWidgetService = chatWidgetService;
+        this._onNavigateToSession = this._register(( new Emitter()));
+        this.onNavigateToSession = this._onNavigateToSession.event;
+        this.renderDisposables = this._register(( new DisposableStore()));
+        this.container = append(parent, $(".chat-debug-home"));
+        this.scrollContent = append(this.container, $("div.chat-debug-home-content"));
+    }
+    show() {
+        this.container.style.display = "";
+        this.render();
+    }
+    hide() {
+        this.container.style.display = "none";
+    }
+    render() {
+        clearNode(this.scrollContent);
+        this.renderDisposables.clear();
+        append(
+            this.scrollContent,
+            $("h2.chat-debug-home-title", undefined, ( localize(5631, "Agent Debug Panel")))
+        );
+        const activeWidget = this.chatWidgetService.lastFocusedWidget;
+        const activeSessionResource = activeWidget?.viewModel?.sessionResource;
+        const sessionResources = [...this.chatDebugService.getSessionResources()].reverse();
+        if (activeSessionResource) {
+            const activeIndex = sessionResources.findIndex(r => ( r.toString()) === ( activeSessionResource.toString()));
+            if (activeIndex > 0) {
+                sessionResources.splice(activeIndex, 1);
+                sessionResources.unshift(activeSessionResource);
+            }
+        }
+        append(this.scrollContent, $(
+            "p.chat-debug-home-subtitle",
+            undefined,
+            sessionResources.length > 0 ? ( localize(5632, "Select a chat session to debug")) : ( localize(5633, "Send a chat message to get started"))
+        ));
+        if (sessionResources.length > 0) {
+            const sessionList = append(this.scrollContent, $(".chat-debug-home-session-list"));
+            sessionList.setAttribute("role", "list");
+            sessionList.setAttribute("aria-label", ( localize(5634, "Chat sessions")));
+            const items = [];
+            for (const sessionResource of sessionResources) {
+                const sessionTitle = this.chatService.getSessionTitle(sessionResource) || LocalChatSessionUri.parseLocalSessionId(sessionResource) || ( sessionResource.toString());
+                const isActive = activeSessionResource !== undefined && ( sessionResource.toString()) === ( activeSessionResource.toString());
+                const item = append(sessionList, $("button.chat-debug-home-session-item"));
+                item.setAttribute("role", "listitem");
+                if (isActive) {
+                    item.classList.add("chat-debug-home-session-item-active");
+                    item.setAttribute("aria-current", "true");
+                }
+                append(item, $(`span${ThemeIcon.asCSSSelector(Codicon.comment)}`));
+                const titleSpan = append(item, $("span.chat-debug-home-session-item-title"));
+                const isShimmering = isUUID(sessionTitle);
+                if (isShimmering) {
+                    titleSpan.classList.add("chat-debug-home-session-item-shimmer");
+                    item.disabled = true;
+                    item.setAttribute("aria-busy", "true");
+                    item.setAttribute("aria-label", ( localize(5635, "Loading session…")));
+                } else {
+                    titleSpan.textContent = sessionTitle;
+                    const ariaLabel = isActive ? ( localize(5636, "{0} (active)", sessionTitle)) : sessionTitle;
+                    item.setAttribute("aria-label", ariaLabel);
+                }
+                if (isActive) {
+                    append(item, $("span.chat-debug-home-session-badge", undefined, ( localize(5637, "Active"))));
+                }
+                if (!isShimmering) {
+                    this.renderDisposables.add(addDisposableListener(item, EventType.CLICK, () => {
+                        this._onNavigateToSession.fire(sessionResource);
+                    }));
+                    items.push(item);
+                }
+            }
+            this.renderDisposables.add(addDisposableListener(sessionList, EventType.KEY_DOWN, e => {
+                if (items.length === 0) {
+                    return;
+                }
+                const focused = getActiveElement();
+                const idx = items.indexOf(focused);
+                if (idx === -1) {
+                    return;
+                }
+                let nextIdx;
+                switch (e.key) {
+                case "ArrowDown":
+                    nextIdx = idx + 1 < items.length ? idx + 1 : idx;
+                    break;
+                case "ArrowUp":
+                    nextIdx = idx - 1 >= 0 ? idx - 1 : idx;
+                    break;
+                case "Home":
+                    nextIdx = 0;
+                    break;
+                case "End":
+                    nextIdx = items.length - 1;
+                    break;
+                }
+                if (nextIdx !== undefined) {
+                    e.preventDefault();
+                    items[nextIdx].focus();
+                }
+            }));
+        }
+    }
+};
+ChatDebugHomeView = ( __decorate([( __param(1, IChatService)), ( __param(2, IChatDebugService)), ( __param(3, IChatWidgetService))], ChatDebugHomeView));
+
+export { ChatDebugHomeView };

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/chatDebugLogsView.d.ts

@@ -0,0 +1,58 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatDebugEvent } from "../../common/chatDebugService.js";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { ChatDebugFilterState } from "./chatDebugFilters.js";
+export declare enum LogsNavigation {
+    Home = "home",
+    Overview = "overview"
+}
+export declare class ChatDebugLogsView extends Disposable {
+    private readonly filterState;
+    private readonly chatService;
+    private readonly chatDebugService;
+    private readonly instantiationService;
+    private readonly contextKeyService;
+    private readonly _onNavigate;
+    readonly onNavigate: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<LogsNavigation>;
+    readonly container: HTMLElement;
+    private readonly breadcrumbWidget;
+    private readonly headerContainer;
+    private readonly tableHeader;
+    private readonly bodyContainer;
+    private readonly listContainer;
+    private readonly treeContainer;
+    private readonly detailPanel;
+    private readonly filterWidget;
+    private readonly viewModeToggle;
+    private list;
+    private tree;
+    private currentSessionResource;
+    private logsViewMode;
+    private events;
+    private currentDimension;
+    private readonly eventListener;
+    private readonly sessionStateDisposable;
+    private shimmerRow;
+    constructor(parent: HTMLElement, filterState: ChatDebugFilterState, chatService: IChatService, chatDebugService: IChatDebugService, instantiationService: IInstantiationService, contextKeyService: IContextKeyService);
+    setSession(sessionResource: URI): void;
+    show(): void;
+    hide(): void;
+    focus(): void;
+    updateBreadcrumb(): void;
+    layout(dimension: Dimension): void;
+    refreshList(): void;
+    private updateShimmerPosition;
+    addEvent(event: IChatDebugEvent): void;
+    private loadEvents;
+    private trackSessionState;
+    private refreshTree;
+    private buildTreeHierarchy;
+    private toggleViewMode;
+    private updateViewModeToggle;
+    private updateMoreFiltersChecked;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/chatDebugLogsView.js

@@ -0,0 +1,429 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, append, hide, show, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { BreadcrumbsWidget } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/breadcrumbs/breadcrumbsWidget';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { WorkbenchList, WorkbenchObjectTree } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { defaultBreadcrumbsWidgetStyles, defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { FilterWidget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/views/viewFilter';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { ChatDebugEventDelegate, ChatDebugEventRenderer, ChatDebugEventTreeRenderer } from './chatDebugEventList.js';
+import { LogsViewMode, setupBreadcrumbKeyboardNavigation, TextBreadcrumbItem } from './chatDebugTypes.js';
+import { bindFilterContextKeys } from './chatDebugFilters.js';
+import { ChatDebugDetailPanel } from './chatDebugDetailPanel.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const $ = $$1;
+var LogsNavigation;
+(function(LogsNavigation) {
+    LogsNavigation["Home"] = "home";
+    LogsNavigation["Overview"] = "overview";
+})(LogsNavigation || (LogsNavigation = {}));
+let ChatDebugLogsView = class ChatDebugLogsView extends Disposable {
+    constructor(
+        parent,
+        filterState,
+        chatService,
+        chatDebugService,
+        instantiationService,
+        contextKeyService
+    ) {
+        super();
+        this.filterState = filterState;
+        this.chatService = chatService;
+        this.chatDebugService = chatDebugService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this._onNavigate = this._register(( new Emitter()));
+        this.onNavigate = this._onNavigate.event;
+        this.logsViewMode = LogsViewMode.List;
+        this.events = [];
+        this.eventListener = this._register(( new MutableDisposable()));
+        this.sessionStateDisposable = this._register(( new MutableDisposable()));
+        this.container = append(parent, $(".chat-debug-logs"));
+        hide(this.container);
+        const breadcrumbContainer = append(this.container, $(".chat-debug-breadcrumb"));
+        this.breadcrumbWidget = this._register(( new BreadcrumbsWidget(
+            breadcrumbContainer,
+            3,
+            undefined,
+            Codicon.chevronRight,
+            defaultBreadcrumbsWidgetStyles
+        )));
+        this._register(
+            setupBreadcrumbKeyboardNavigation(breadcrumbContainer, this.breadcrumbWidget)
+        );
+        this._register(this.breadcrumbWidget.onDidSelectItem(e => {
+            if (e.type === "select" && e.item instanceof TextBreadcrumbItem) {
+                this.breadcrumbWidget.setSelection(undefined);
+                const items = this.breadcrumbWidget.getItems();
+                const idx = items.indexOf(e.item);
+                if (idx === 0) {
+                    this._onNavigate.fire(LogsNavigation.Home);
+                } else if (idx === 1) {
+                    this._onNavigate.fire(LogsNavigation.Overview);
+                }
+            }
+        }));
+        this.headerContainer = append(this.container, $(".chat-debug-editor-header"));
+        const scopedContextKeyService = this._register(this.contextKeyService.createScoped(this.headerContainer));
+        const syncContextKeys = bindFilterContextKeys(this.filterState, scopedContextKeyService);
+        syncContextKeys();
+        const childInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, scopedContextKeyService]))));
+        this.filterWidget = this._register(childInstantiationService.createInstance(FilterWidget, {
+            placeholder: ( localize(5638, "Filter (e.g. text, !exclude)")),
+            ariaLabel: ( localize(5639, "Filter debug events"))
+        }));
+        this.viewModeToggle = this._register(( new Button(this.headerContainer, {
+            ...defaultButtonStyles,
+            secondary: true,
+            title: ( localize(5640, "Toggle between list and tree view"))
+        })));
+        this.viewModeToggle.element.classList.add("chat-debug-view-mode-toggle", "monaco-text-button");
+        this.updateViewModeToggle();
+        this._register(this.viewModeToggle.onDidClick(() => {
+            this.toggleViewMode();
+        }));
+        const filterContainer = append(this.headerContainer, $(".viewpane-filter-container"));
+        filterContainer.appendChild(this.filterWidget.element);
+        this._register(this.filterWidget.onDidChangeFilterText(text => {
+            this.filterState.setTextFilter(text);
+        }));
+        this._register(this.filterState.onDidChange(() => {
+            syncContextKeys();
+            this.updateMoreFiltersChecked();
+            this.refreshList();
+        }));
+        const contentContainer = append(this.container, $(".chat-debug-logs-content"));
+        const mainColumn = append(contentContainer, $(".chat-debug-logs-main"));
+        this.tableHeader = append(mainColumn, $(".chat-debug-table-header"));
+        append(
+            this.tableHeader,
+            $("span.chat-debug-col-created", undefined, ( localize(5641, "Created")))
+        );
+        append(this.tableHeader, $("span.chat-debug-col-name", undefined, ( localize(5642, "Name"))));
+        append(
+            this.tableHeader,
+            $("span.chat-debug-col-details", undefined, ( localize(5643, "Details")))
+        );
+        this.bodyContainer = append(mainColumn, $(".chat-debug-logs-body"));
+        this.listContainer = append(this.bodyContainer, $(".chat-debug-list-container"));
+        const accessibilityProvider = {
+            getAriaLabel: e => {
+                switch (e.kind) {
+                case "toolCall":
+                    return localize(5644, "Tool call: {0}{1}", e.toolName, e.result ? ` (${e.result})` : "");
+                case "modelTurn":
+                    return localize(
+                        5645,
+                        "Model turn: {0}{1}",
+                        e.model ?? ( localize(5646, "model")),
+                        e.totalTokens ? ( localize(5647, " {0} tokens", e.totalTokens)) : ""
+                    );
+                case "generic":
+                    return `${e.category ? e.category + ": " : ""}${e.name}: ${e.details ?? ""}`;
+                case "subagentInvocation":
+                    return localize(
+                        5648,
+                        "Subagent: {0}{1}",
+                        e.agentName,
+                        e.description ? ` - ${e.description}` : ""
+                    );
+                case "userMessage":
+                    return localize(5649, "User message: {0}", e.message);
+                case "agentResponse":
+                    return localize(5650, "Agent response: {0}", e.message);
+                }
+            },
+            getWidgetAriaLabel: () => ( localize(5651, "Chat Debug Events"))
+        };
+        let nextFallbackId = 0;
+        const fallbackIds = ( new WeakMap());
+        const identityProvider = {
+            getId: e => {
+                if (e.id) {
+                    return e.id;
+                }
+                let fallback = fallbackIds.get(e);
+                if (!fallback) {
+                    fallback = `_fallback_${nextFallbackId++}`;
+                    fallbackIds.set(e, fallback);
+                }
+                return fallback;
+            }
+        };
+        this.list = this._register(
+            this.instantiationService.createInstance(WorkbenchList, "ChatDebugEvents", this.listContainer, ( new ChatDebugEventDelegate()), [( new ChatDebugEventRenderer())], {
+                identityProvider,
+                accessibilityProvider
+            })
+        );
+        this.treeContainer = append(this.bodyContainer, $(".chat-debug-list-container"));
+        hide(this.treeContainer);
+        this.tree = this._register(this.instantiationService.createInstance(
+            WorkbenchObjectTree,
+            "ChatDebugEventsTree",
+            this.treeContainer,
+            ( new ChatDebugEventDelegate()),
+            [( new ChatDebugEventTreeRenderer())],
+            {
+                identityProvider,
+                accessibilityProvider
+            }
+        ));
+        this.shimmerRow = append(this.bodyContainer, $(".chat-debug-logs-shimmer-row"));
+        this.shimmerRow.setAttribute("aria-label", ( localize(5652, "Loading more events…")));
+        this.shimmerRow.setAttribute("aria-busy", "true");
+        append(this.shimmerRow, $("span.chat-debug-logs-shimmer-bar"));
+        hide(this.shimmerRow);
+        this.detailPanel = this._register(
+            this.instantiationService.createInstance(ChatDebugDetailPanel, contentContainer)
+        );
+        this._register(this.detailPanel.onDidHide(() => {
+            if (this.list.getSelection().length > 0) {
+                this.list.setSelection([]);
+            }
+            if (this.tree.getSelection().length > 0) {
+                this.tree.setSelection([]);
+            }
+        }));
+        this._register(this.list.onDidChangeSelection(e => {
+            const selected = e.elements[0];
+            if (selected) {
+                this.detailPanel.show(selected);
+            } else {
+                this.detailPanel.hide();
+            }
+        }));
+        this._register(this.tree.onDidChangeSelection(e => {
+            const selected = e.elements[0];
+            if (selected) {
+                this.detailPanel.show(selected);
+            } else {
+                this.detailPanel.hide();
+            }
+        }));
+    }
+    setSession(sessionResource) {
+        this.currentSessionResource = sessionResource;
+    }
+    show() {
+        show(this.container);
+        this.loadEvents();
+        this.refreshList();
+    }
+    hide() {
+        hide(this.container);
+    }
+    focus() {
+        if (this.logsViewMode === LogsViewMode.Tree) {
+            this.tree.domFocus();
+        } else {
+            this.list.domFocus();
+        }
+    }
+    updateBreadcrumb() {
+        if (!this.currentSessionResource) {
+            return;
+        }
+        const sessionTitle = this.chatService.getSessionTitle(this.currentSessionResource) || LocalChatSessionUri.parseLocalSessionId(this.currentSessionResource) || ( this.currentSessionResource.toString());
+        this.breadcrumbWidget.setItems([( new TextBreadcrumbItem(( localize(5653, "Agent Debug Panel")), true)), ( new TextBreadcrumbItem(sessionTitle, true)), ( new TextBreadcrumbItem(( localize(5654, "Logs"))))]);
+    }
+    layout(dimension) {
+        this.currentDimension = dimension;
+        const breadcrumbHeight = 22;
+        const headerHeight = this.headerContainer.offsetHeight;
+        const tableHeaderHeight = this.tableHeader.offsetHeight;
+        const detailVisible = this.detailPanel.element.style.display !== "none";
+        const detailWidth = detailVisible ? this.detailPanel.element.offsetWidth : 0;
+        const listHeight = dimension.height - breadcrumbHeight - headerHeight - tableHeaderHeight;
+        const listWidth = dimension.width - detailWidth;
+        if (this.logsViewMode === LogsViewMode.Tree) {
+            this.tree.layout(listHeight, listWidth);
+        } else {
+            this.list.layout(listHeight, listWidth);
+        }
+    }
+    refreshList() {
+        let filtered = this.events;
+        filtered = filtered.filter(e => {
+            const category = e.kind === "generic" ? e.category : undefined;
+            return this.filterState.isKindVisible(e.kind, category);
+        });
+        const filterText = this.filterState.textFilter;
+        if (filterText) {
+            const terms = filterText.split(/\s*,\s*/).filter(t => t.length > 0);
+            const includeTerms = ( terms.filter(t => !t.startsWith("!")).map(t => t.trim()));
+            const excludeTerms = ( terms.filter(t => t.startsWith("!")).map(t => t.slice(1).trim())).filter(t => t.length > 0);
+            filtered = filtered.filter(e => {
+                const matchesText = term => {
+                    if (e.kind.toLowerCase().includes(term)) {
+                        return true;
+                    }
+                    switch (e.kind) {
+                    case "toolCall":
+                        return e.toolName.toLowerCase().includes(term) || (e.input?.toLowerCase().includes(term) ?? false) || (e.output?.toLowerCase().includes(term) ?? false);
+                    case "modelTurn":
+                        return (e.model?.toLowerCase().includes(term) ?? false);
+                    case "generic":
+                        return e.name.toLowerCase().includes(term) || (e.details?.toLowerCase().includes(term) ?? false) || (e.category?.toLowerCase().includes(term) ?? false);
+                    case "subagentInvocation":
+                        return e.agentName.toLowerCase().includes(term) || (e.description?.toLowerCase().includes(term) ?? false);
+                    case "userMessage":
+                        return e.message.toLowerCase().includes(term) || ( e.sections.some(
+                            s => s.name.toLowerCase().includes(term) || s.content.toLowerCase().includes(term)
+                        ));
+                    case "agentResponse":
+                        return e.message.toLowerCase().includes(term) || ( e.sections.some(
+                            s => s.name.toLowerCase().includes(term) || s.content.toLowerCase().includes(term)
+                        ));
+                    }
+                };
+                if (( excludeTerms.some(term => matchesText(term)))) {
+                    return false;
+                }
+                if (includeTerms.length > 0) {
+                    return ( includeTerms.some(term => matchesText(term)));
+                }
+                return true;
+            });
+        }
+        if (this.logsViewMode === LogsViewMode.List) {
+            this.list.splice(0, this.list.length, filtered);
+        } else {
+            this.refreshTree(filtered);
+        }
+        this.updateShimmerPosition(filtered.length);
+    }
+    updateShimmerPosition(itemCount) {
+        this.shimmerRow.style.top = `${itemCount * 28}px`;
+    }
+    addEvent(event) {
+        this.events.push(event);
+        this.refreshList();
+    }
+    loadEvents() {
+        this.events = [
+            ...this.chatDebugService.getEvents(this.currentSessionResource || undefined)
+        ];
+        this.eventListener.value = this.chatDebugService.onDidAddEvent(e => {
+            if (!this.currentSessionResource || ( e.sessionResource.toString()) === ( this.currentSessionResource.toString())) {
+                this.events.push(e);
+                this.refreshList();
+            }
+        });
+        this.updateBreadcrumb();
+        this.trackSessionState();
+    }
+    trackSessionState() {
+        if (!this.currentSessionResource) {
+            hide(this.shimmerRow);
+            this.sessionStateDisposable.clear();
+            return;
+        }
+        const model = this.chatService.getSession(this.currentSessionResource);
+        if (!model) {
+            hide(this.shimmerRow);
+            this.sessionStateDisposable.clear();
+            return;
+        }
+        this.sessionStateDisposable.value = autorun(reader => {
+            const inProgress = model.requestInProgress.read(reader);
+            if (inProgress) {
+                show(this.shimmerRow);
+            } else {
+                hide(this.shimmerRow);
+            }
+        });
+    }
+    refreshTree(filtered) {
+        const treeElements = this.buildTreeHierarchy(filtered);
+        this.tree.setChildren(null, treeElements);
+    }
+    buildTreeHierarchy(events) {
+        const idToEvent = ( new Map());
+        const idToChildren = ( new Map());
+        const roots = [];
+        for (const event of events) {
+            if (event.id) {
+                idToEvent.set(event.id, event);
+            }
+        }
+        for (const event of events) {
+            if (event.parentEventId && ( idToEvent.has(event.parentEventId))) {
+                let children = idToChildren.get(event.parentEventId);
+                if (!children) {
+                    children = [];
+                    idToChildren.set(event.parentEventId, children);
+                }
+                children.push(event);
+            } else {
+                roots.push(event);
+            }
+        }
+        const toTreeElement = event => {
+            const children = event.id ? idToChildren.get(event.id) : undefined;
+            return {
+                element: event,
+                children: children?.map(toTreeElement),
+                collapsible: (children?.length ?? 0) > 0,
+                collapsed: false
+            };
+        };
+        return ( roots.map(toTreeElement));
+    }
+    toggleViewMode() {
+        if (this.logsViewMode === LogsViewMode.List) {
+            this.logsViewMode = LogsViewMode.Tree;
+            hide(this.listContainer);
+            show(this.treeContainer);
+        } else {
+            this.logsViewMode = LogsViewMode.List;
+            show(this.listContainer);
+            hide(this.treeContainer);
+        }
+        this.updateViewModeToggle();
+        this.refreshList();
+        if (this.currentDimension) {
+            this.layout(this.currentDimension);
+        }
+    }
+    updateViewModeToggle() {
+        const el = this.viewModeToggle.element;
+        clearNode(el);
+        const isTree = this.logsViewMode === LogsViewMode.Tree;
+        append(el, $(
+            `span${ThemeIcon.asCSSSelector(isTree ? Codicon.listTree : Codicon.listFlat)}`
+        ));
+        const labelContainer = append(el, $("span.chat-debug-view-mode-labels"));
+        const treeLabel = append(labelContainer, $("span.chat-debug-view-mode-label"));
+        treeLabel.textContent = ( localize(5655, "Tree View"));
+        const listLabel = append(labelContainer, $("span.chat-debug-view-mode-label"));
+        listLabel.textContent = ( localize(5656, "List View"));
+        if (isTree) {
+            listLabel.classList.add("hidden");
+        } else {
+            treeLabel.classList.add("hidden");
+        }
+        const activeLabel = isTree ? ( localize(5657, "Switch to List View")) : ( localize(5658, "Switch to Tree View"));
+        el.setAttribute("aria-label", activeLabel);
+        this.viewModeToggle.setTitle(activeLabel);
+    }
+    updateMoreFiltersChecked() {
+        this.filterWidget.checkMoreFilters(!this.filterState.isAllFiltersDefault());
+    }
+};
+ChatDebugLogsView = ( __decorate([( __param(2, IChatService)), ( __param(3, IChatDebugService)), ( __param(4, IInstantiationService)), ( __param(5, IContextKeyService))], ChatDebugLogsView));
+
+export { ChatDebugLogsView, LogsNavigation };

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/chatDebugMessageContentRenderer.d.ts

@@ -0,0 +1,31 @@
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatDebugUserMessageEvent, IChatDebugAgentResponseEvent, IChatDebugEventMessageContent } from "../../common/chatDebugService.js";
+/**
+ * Render a user message event with collapsible prompt sections.
+ */
+export declare function renderUserMessageContent(event: IChatDebugUserMessageEvent): {
+    element: HTMLElement;
+    disposables: DisposableStore;
+};
+/**
+ * Render an agent response event with collapsible response sections.
+ */
+export declare function renderAgentResponseContent(event: IChatDebugAgentResponseEvent): {
+    element: HTMLElement;
+    disposables: DisposableStore;
+};
+/**
+ * Convert a user message or agent response event to plain text for clipboard / editor output.
+ */
+export declare function messageEventToPlainText(event: IChatDebugUserMessageEvent | IChatDebugAgentResponseEvent): string;
+/**
+ * Render a resolved message content (from resolveChatDebugLogEvent) with collapsible sections.
+ */
+export declare function renderResolvedMessageContent(content: IChatDebugEventMessageContent): {
+    element: HTMLElement;
+    disposables: DisposableStore;
+};
+/**
+ * Convert a resolved message content to plain text.
+ */
+export declare function resolvedMessageToPlainText(content: IChatDebugEventMessageContent): string;