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

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

@@ -0,0 +1,198 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, append, hide, addDisposableListener, EventType, getWindow, show, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+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, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { formatEventDetail } from './chatDebugEventDetailRenderer.js';
+import { fileListToPlainText, renderCustomizationDiscoveryContent } from './chatCustomizationDiscoveryRenderer.js';
+import { resolvedMessageToPlainText, renderResolvedMessageContent, messageEventToPlainText, renderUserMessageContent, renderAgentResponseContent } from './chatDebugMessageContentRenderer.js';
+import { toolCallContentToPlainText, renderToolCallContent } from './chatDebugToolCallContentRenderer.js';
+import { modelTurnContentToPlainText, renderModelTurnContent } from './chatDebugModelTurnContentRenderer.js';
+
+const $ = $$1;
+let ChatDebugDetailPanel = class ChatDebugDetailPanel extends Disposable {
+    constructor(
+        parent,
+        chatDebugService,
+        instantiationService,
+        editorService,
+        clipboardService,
+        hoverService,
+        openerService
+    ) {
+        super();
+        this.chatDebugService = chatDebugService;
+        this.instantiationService = instantiationService;
+        this.editorService = editorService;
+        this.clipboardService = clipboardService;
+        this.hoverService = hoverService;
+        this.openerService = openerService;
+        this._onDidHide = this._register(( new Emitter()));
+        this.onDidHide = this._onDidHide.event;
+        this.detailDisposables = this._register(( new DisposableStore()));
+        this.currentDetailText = "";
+        this.element = append(parent, $(".chat-debug-detail-panel"));
+        this.contentContainer = $(".chat-debug-detail-content");
+        hide(this.element);
+        this._register(addDisposableListener(this.element, EventType.KEY_DOWN, e => {
+            if ((e.ctrlKey || e.metaKey) && e.key === "a") {
+                const target = e.target;
+                if (target && this.element.contains(target)) {
+                    e.preventDefault();
+                    const targetWindow = getWindow(target);
+                    const selection = targetWindow.getSelection();
+                    if (selection) {
+                        const range = targetWindow.document.createRange();
+                        range.selectNodeContents(target);
+                        selection.removeAllRanges();
+                        selection.addRange(range);
+                    }
+                }
+            }
+        }));
+    }
+    async show(event) {
+        if (event.id && event.id === this.currentDetailEventId) {
+            return;
+        }
+        this.currentDetailEventId = event.id;
+        const resolved = event.id ? await this.chatDebugService.resolveEvent(event.id) : undefined;
+        show(this.element);
+        clearNode(this.element);
+        clearNode(this.contentContainer);
+        this.detailDisposables.clear();
+        const header = append(this.element, $(".chat-debug-detail-header"));
+        this.element.appendChild(this.contentContainer);
+        const fullScreenButton = this.detailDisposables.add(( new Button(header, {
+            ariaLabel: ( localize(5643, "Open in Editor")),
+            title: ( localize(5643, "Open in Editor"))
+        })));
+        fullScreenButton.element.classList.add("chat-debug-detail-button");
+        fullScreenButton.icon = Codicon.goToFile;
+        this.firstFocusableElement = fullScreenButton.element;
+        this.detailDisposables.add(fullScreenButton.onDidClick(() => {
+            this.editorService.openEditor({
+                contents: this.currentDetailText,
+                resource: undefined
+            });
+        }));
+        const copyButton = this.detailDisposables.add(( new Button(header, {
+            ariaLabel: ( localize(5644, "Copy")),
+            title: ( localize(5644, "Copy"))
+        })));
+        copyButton.element.classList.add("chat-debug-detail-button");
+        copyButton.icon = Codicon.copy;
+        this.detailDisposables.add(copyButton.onDidClick(() => {
+            this.clipboardService.writeText(this.currentDetailText);
+        }));
+        const closeButton = this.detailDisposables.add(( new Button(header, {
+            ariaLabel: ( localize(5645, "Close")),
+            title: ( localize(5645, "Close"))
+        })));
+        closeButton.element.classList.add("chat-debug-detail-button");
+        closeButton.icon = Codicon.close;
+        this.detailDisposables.add(closeButton.onDidClick(() => {
+            this.hide();
+        }));
+        if (resolved && resolved.kind === "fileList") {
+            this.currentDetailText = fileListToPlainText(resolved);
+            const {
+                element: contentEl,
+                disposables: contentDisposables
+            } = this.instantiationService.invokeFunction(accessor => renderCustomizationDiscoveryContent(
+                resolved,
+                this.openerService,
+                accessor.get(IModelService),
+                accessor.get(ILanguageService),
+                this.hoverService,
+                accessor.get(ILabelService)
+            ));
+            this.detailDisposables.add(contentDisposables);
+            this.contentContainer.appendChild(contentEl);
+        } else if (resolved && resolved.kind === "toolCall") {
+            this.currentDetailText = toolCallContentToPlainText(resolved);
+            const languageService = this.instantiationService.invokeFunction(accessor => accessor.get(ILanguageService));
+            const {
+                element: contentEl,
+                disposables: contentDisposables
+            } = await renderToolCallContent(resolved, languageService);
+            if (this.currentDetailEventId !== event.id) {
+                contentDisposables.dispose();
+                return;
+            }
+            this.detailDisposables.add(contentDisposables);
+            this.contentContainer.appendChild(contentEl);
+        } else if (resolved && resolved.kind === "message") {
+            this.currentDetailText = resolvedMessageToPlainText(resolved);
+            const {
+                element: contentEl,
+                disposables: contentDisposables
+            } = renderResolvedMessageContent(resolved);
+            this.detailDisposables.add(contentDisposables);
+            this.contentContainer.appendChild(contentEl);
+        } else if (resolved && resolved.kind === "modelTurn") {
+            this.currentDetailText = modelTurnContentToPlainText(resolved);
+            const {
+                element: contentEl,
+                disposables: contentDisposables
+            } = renderModelTurnContent(resolved);
+            this.detailDisposables.add(contentDisposables);
+            this.contentContainer.appendChild(contentEl);
+        } else if (event.kind === "userMessage") {
+            this.currentDetailText = messageEventToPlainText(event);
+            const {
+                element: contentEl,
+                disposables: contentDisposables
+            } = renderUserMessageContent(event);
+            this.detailDisposables.add(contentDisposables);
+            this.contentContainer.appendChild(contentEl);
+        } else if (event.kind === "agentResponse") {
+            this.currentDetailText = messageEventToPlainText(event);
+            const {
+                element: contentEl,
+                disposables: contentDisposables
+            } = renderAgentResponseContent(event);
+            this.detailDisposables.add(contentDisposables);
+            this.contentContainer.appendChild(contentEl);
+        } else {
+            const pre = append(this.contentContainer, $("pre"));
+            pre.tabIndex = 0;
+            if (resolved) {
+                this.currentDetailText = resolved.value;
+            } else {
+                this.currentDetailText = formatEventDetail(event);
+            }
+            pre.textContent = this.currentDetailText;
+        }
+    }
+    get isVisible() {
+        return this.element.style.display !== "none";
+    }
+    focus() {
+        this.firstFocusableElement?.focus();
+    }
+    hide() {
+        this.currentDetailEventId = undefined;
+        this.firstFocusableElement = undefined;
+        hide(this.element);
+        clearNode(this.element);
+        clearNode(this.contentContainer);
+        this.detailDisposables.clear();
+        this._onDidHide.fire();
+    }
+};
+ChatDebugDetailPanel = ( __decorate([( __param(1, IChatDebugService)), ( __param(2, IInstantiationService)), ( __param(3, IEditorService)), ( __param(4, IClipboardService)), ( __param(5, IHoverService)), ( __param(6, IOpenerService))], ChatDebugDetailPanel));
+
+export { ChatDebugDetailPanel };

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

@@ -0,0 +1,55 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+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 { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+import { EditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+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";
+import { IChatDebugEditorOptions } from "./chatDebugTypes.js";
+export declare class ChatDebugEditor extends EditorPane {
+    private readonly instantiationService;
+    private readonly chatDebugService;
+    private readonly chatWidgetService;
+    private readonly chatService;
+    private readonly contextKeyService;
+    static readonly ID: string;
+    private container;
+    private currentDimension;
+    private viewState;
+    private homeView;
+    private overviewView;
+    private logsView;
+    private flowChartView;
+    private filterState;
+    private readonly sessionModelListener;
+    private readonly modelChangeListeners;
+    /** Saved session resource so we can restore it after the editor is re-shown. */
+    private savedSessionResource;
+    /**
+     * Stops the streaming pipeline and clears cached events for the
+     * active session. Called when navigating away from a session or
+     * when the editor becomes hidden.
+     */
+    private endActiveSession;
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService, instantiationService: IInstantiationService, chatDebugService: IChatDebugService, chatWidgetService: IChatWidgetService, chatService: IChatService, contextKeyService: IContextKeyService);
+    protected createEditor(parent: HTMLElement): void;
+    private showView;
+    navigateToSession(sessionResource: URI, view?: "logs" | "overview" | "flowchart"): void;
+    private trackSessionModelChanges;
+    focus(): void;
+    setInput(input: EditorInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    setOptions(options: IChatDebugEditorOptions | undefined): void;
+    setEditorVisible(visible: boolean): void;
+    private _applyNavigationOptions;
+    layout(dimension: Dimension): void;
+    private doLayout;
+}

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

@@ -0,0 +1,314 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatDebug from './media/chatDebug.css';
+import { $ as $$1, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { MutableDisposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+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 { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { EditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane';
+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';
+import { ViewState } from './chatDebugTypes.js';
+import { ChatDebugFilterState, registerFilterMenuItems } from './chatDebugFilters.js';
+import { ChatDebugHomeView } from './chatDebugHomeView.js';
+import { ChatDebugOverviewView, OverviewNavigation } from './chatDebugOverviewView.js';
+import { ChatDebugLogsView, LogsNavigation } from './chatDebugLogsView.js';
+import { ChatDebugFlowChartView, FlowChartNavigation } from './chatDebugFlowChartView.js';
+
+var ChatDebugEditor_1;
+registerCss(chatDebug);
+const $ = $$1;
+let ChatDebugEditor = class ChatDebugEditor extends EditorPane {
+    static {
+        ChatDebugEditor_1 = this;
+    }
+    static {
+        this.ID = "workbench.editor.chatDebug";
+    }
+    endActiveSession() {
+        const sessionResource = this.chatDebugService.activeSessionResource;
+        if (sessionResource) {
+            this.chatDebugService.endSession(sessionResource);
+        }
+        this.chatDebugService.activeSessionResource = undefined;
+    }
+    constructor(
+        group,
+        telemetryService,
+        themeService,
+        storageService,
+        instantiationService,
+        chatDebugService,
+        chatWidgetService,
+        chatService,
+        contextKeyService
+    ) {
+        super(
+            ChatDebugEditor_1.ID,
+            group,
+            telemetryService,
+            themeService,
+            storageService
+        );
+        this.instantiationService = instantiationService;
+        this.chatDebugService = chatDebugService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatService = chatService;
+        this.contextKeyService = contextKeyService;
+        this.viewState = ViewState.Home;
+        this.sessionModelListener = this._register(( new MutableDisposable()));
+        this.modelChangeListeners = this._register(( new DisposableMap()));
+    }
+    createEditor(parent) {
+        this.container = append(parent, $(".chat-debug-editor"));
+        this.filterState = this._register(( new ChatDebugFilterState()));
+        const scopedContextKeyService = this._register(this.contextKeyService.createScoped(this.container));
+        this._register(registerFilterMenuItems(this.filterState, scopedContextKeyService));
+        this.homeView = this._register(
+            this.instantiationService.createInstance(ChatDebugHomeView, this.container)
+        );
+        this._register(this.homeView.onNavigateToSession(sessionResource => {
+            this.navigateToSession(sessionResource);
+        }));
+        this.overviewView = this._register(
+            this.instantiationService.createInstance(ChatDebugOverviewView, this.container)
+        );
+        this._register(this.overviewView.onNavigate(nav => {
+            switch (nav) {
+            case OverviewNavigation.Home:
+                this.endActiveSession();
+                this.showView(ViewState.Home);
+                break;
+            case OverviewNavigation.Logs:
+                this.showView(ViewState.Logs);
+                break;
+            case OverviewNavigation.FlowChart:
+                this.showView(ViewState.FlowChart);
+                break;
+            }
+        }));
+        this.logsView = this._register(
+            this.instantiationService.createInstance(ChatDebugLogsView, this.container, this.filterState)
+        );
+        this._register(this.logsView.onNavigate(nav => {
+            switch (nav) {
+            case LogsNavigation.Home:
+                this.endActiveSession();
+                this.showView(ViewState.Home);
+                break;
+            case LogsNavigation.Overview:
+                this.showView(ViewState.Overview);
+                break;
+            }
+        }));
+        this.flowChartView = this._register(
+            this.instantiationService.createInstance(ChatDebugFlowChartView, this.container, this.filterState)
+        );
+        this._register(this.flowChartView.onNavigate(nav => {
+            switch (nav) {
+            case FlowChartNavigation.Home:
+                this.endActiveSession();
+                this.showView(ViewState.Home);
+                break;
+            case FlowChartNavigation.Overview:
+                this.showView(ViewState.Overview);
+                break;
+            }
+        }));
+        this._register(this.chatDebugService.onDidAddEvent(event => {
+            if (this.viewState === ViewState.Home) {
+                this.homeView?.render();
+            } else if (this.chatDebugService.activeSessionResource && ( event.sessionResource.toString()) === ( this.chatDebugService.activeSessionResource.toString())) {
+                if (this.viewState === ViewState.Overview) {
+                    this.overviewView?.refresh();
+                } else if (this.viewState === ViewState.Logs) {
+                    this.logsView?.refreshList();
+                } else if (this.viewState === ViewState.FlowChart) {
+                    this.flowChartView?.refresh();
+                }
+            }
+        }));
+        this._register(this.chatWidgetService.onDidChangeFocusedSession(() => {
+            if (this.viewState === ViewState.Home) {
+                this.homeView?.render();
+            }
+        }));
+        this._register(this.chatService.onDidCreateModel(model => {
+            if (this.viewState === ViewState.Home) {
+                this.homeView?.render();
+            }
+            const key = ( model.sessionResource.toString());
+            this.modelChangeListeners.set(key, model.onDidChange(e => {
+                if (e.kind === "setCustomTitle") {
+                    if (this.viewState === ViewState.Home) {
+                        this.homeView?.render();
+                    } else if (this.viewState === ViewState.Overview || this.viewState === ViewState.Logs || this.viewState === ViewState.FlowChart) {
+                        this.overviewView?.updateBreadcrumb();
+                        this.logsView?.updateBreadcrumb();
+                        this.flowChartView?.updateBreadcrumb();
+                    }
+                }
+            }));
+        }));
+        this._register(this.chatService.onDidDisposeSession(() => {
+            if (this.viewState === ViewState.Home) {
+                this.homeView?.render();
+            }
+        }));
+        this.showView(ViewState.Home);
+    }
+    showView(state) {
+        this.viewState = state;
+        this.telemetryService.publicLog2("chatDebugViewSwitched", {
+            viewState: state
+        });
+        if (state === ViewState.Home) {
+            this.homeView?.show();
+        } else {
+            this.homeView?.hide();
+        }
+        if (state === ViewState.Overview) {
+            this.overviewView?.show();
+        } else {
+            this.overviewView?.hide();
+        }
+        if (state === ViewState.Logs) {
+            this.logsView?.show();
+            this.doLayout();
+            this.logsView?.focus();
+        } else {
+            this.logsView?.hide();
+        }
+        if (state === ViewState.FlowChart) {
+            this.flowChartView?.show();
+        } else {
+            this.flowChartView?.hide();
+        }
+    }
+    navigateToSession(sessionResource, view) {
+        const previousSessionResource = this.chatDebugService.activeSessionResource;
+        if (previousSessionResource && ( previousSessionResource.toString()) !== ( sessionResource.toString())) {
+            this.chatDebugService.endSession(previousSessionResource);
+        }
+        this.chatDebugService.activeSessionResource = sessionResource;
+        if (!this.chatDebugService.hasInvokedProviders(sessionResource)) {
+            this.chatDebugService.invokeProviders(sessionResource);
+        }
+        this.trackSessionModelChanges(sessionResource);
+        this.overviewView?.setSession(sessionResource);
+        this.logsView?.setSession(sessionResource);
+        this.flowChartView?.setSession(sessionResource);
+        this.showView(
+            view === "logs" ? ViewState.Logs : view === "flowchart" ? ViewState.FlowChart : ViewState.Overview
+        );
+    }
+    trackSessionModelChanges(sessionResource) {
+        const model = this.chatService.getSession(sessionResource);
+        if (!model) {
+            this.sessionModelListener.clear();
+            return;
+        }
+        this.sessionModelListener.value = model.onDidChange(e => {
+            if (e.kind === "addRequest" || e.kind === "completedRequest") {
+                if (this.viewState === ViewState.Overview) {
+                    this.overviewView?.refresh();
+                }
+            }
+        });
+    }
+    focus() {
+        if (this.viewState === ViewState.Logs) {
+            this.logsView?.focus();
+        } else {
+            this.container?.focus();
+        }
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        if (options) {
+            this._applyNavigationOptions(options);
+        }
+    }
+    setOptions(options) {
+        super.setOptions(options);
+        if (options) {
+            this._applyNavigationOptions(options);
+        }
+    }
+    setEditorVisible(visible) {
+        super.setEditorVisible(visible);
+        if (visible) {
+            this.telemetryService.publicLog2("chatDebugPanelOpened");
+            if (this.viewState === ViewState.Home) {
+                const sessionResource = this.chatDebugService.activeSessionResource ?? this.savedSessionResource;
+                this.savedSessionResource = undefined;
+                if (sessionResource) {
+                    this.navigateToSession(sessionResource, "overview");
+                } else {
+                    this.showView(ViewState.Home);
+                }
+            } else {
+                const sessionResource = this.chatDebugService.activeSessionResource ?? this.savedSessionResource;
+                this.savedSessionResource = undefined;
+                if (sessionResource) {
+                    this.chatDebugService.activeSessionResource = sessionResource;
+                    if (!this.chatDebugService.hasInvokedProviders(sessionResource)) {
+                        this.chatDebugService.invokeProviders(sessionResource);
+                    }
+                } else {
+                    this.showView(ViewState.Home);
+                }
+            }
+        } else {
+            this.savedSessionResource = this.chatDebugService.activeSessionResource;
+            this.endActiveSession();
+        }
+    }
+    _applyNavigationOptions(options) {
+        const {
+            sessionResource,
+            viewHint,
+            filter
+        } = options;
+        if (viewHint === "logs" && sessionResource) {
+            this.navigateToSession(sessionResource, "logs");
+        } else if (viewHint === "flowchart" && sessionResource) {
+            this.navigateToSession(sessionResource, "flowchart");
+        } else if (viewHint === "overview" && sessionResource) {
+            this.navigateToSession(sessionResource, "overview");
+        } else if (viewHint === "home") {
+            this.endActiveSession();
+            this.showView(ViewState.Home);
+        } else if (sessionResource) {
+            this.navigateToSession(sessionResource, "overview");
+        } else if (this.viewState === ViewState.Home) {
+            this.showView(ViewState.Home);
+        }
+        if (filter !== undefined && this.filterState) {
+            this.filterState.setTextFilter(filter);
+            this.logsView?.setFilterText(filter);
+        }
+    }
+    layout(dimension) {
+        this.currentDimension = dimension;
+        if (this.container) {
+            this.container.style.width = `${dimension.width}px`;
+            this.container.style.height = `${dimension.height}px`;
+        }
+        this.doLayout();
+    }
+    doLayout() {
+        if (!this.currentDimension || this.viewState !== ViewState.Logs) {
+            return;
+        }
+        this.logsView?.layout(this.currentDimension);
+    }
+};
+ChatDebugEditor = ChatDebugEditor_1 = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, IThemeService)), ( __param(3, IStorageService)), ( __param(4, IInstantiationService)), ( __param(5, IChatDebugService)), ( __param(6, IChatWidgetService)), ( __param(7, IChatService)), ( __param(8, IContextKeyService))], ChatDebugEditor));
+
+export { ChatDebugEditor };

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

@@ -0,0 +1,23 @@
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { EditorInputCapabilities, IEditorSerializer, IUntypedEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+export declare class ChatDebugEditorInput extends EditorInput {
+    static readonly ID = "workbench.editor.chatDebug";
+    static readonly RESOURCE: URI;
+    private static _instance;
+    static get instance(): ChatDebugEditorInput;
+    get typeId(): string;
+    get editorId(): string | undefined;
+    get capabilities(): EditorInputCapabilities;
+    readonly resource: URI;
+    getName(): string;
+    getIcon(): ThemeIcon;
+    matches(other: EditorInput | IUntypedEditorInput): boolean;
+}
+export declare class ChatDebugEditorInputSerializer implements IEditorSerializer {
+    canSerialize(editorInput: EditorInput): boolean;
+    serialize(editorInput: EditorInput): string;
+    deserialize(instantiationService: IInstantiationService): EditorInput;
+}

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

@@ -0,0 +1,64 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { EditorInputCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { EditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput';
+
+const chatDebugEditorIcon = registerIcon("chat-debug-editor-label-icon", Codicon.bug, ( localize(5646, "Icon of the chat debug editor label.")));
+class ChatDebugEditorInput extends EditorInput {
+    constructor() {
+        super(...arguments);
+        this.resource = ChatDebugEditorInput.RESOURCE;
+    }
+    static {
+        this.ID = "workbench.editor.chatDebug";
+    }
+    static {
+        this.RESOURCE = ( URI.from({
+            scheme: "chat-debug",
+            path: "default"
+        }));
+    }
+    static get instance() {
+        if (!ChatDebugEditorInput._instance || ChatDebugEditorInput._instance.isDisposed()) {
+            ChatDebugEditorInput._instance = ( new ChatDebugEditorInput());
+        }
+        return ChatDebugEditorInput._instance;
+    }
+    get typeId() {
+        return ChatDebugEditorInput.ID;
+    }
+    get editorId() {
+        return ChatDebugEditorInput.ID;
+    }
+    get capabilities() {
+        return EditorInputCapabilities.Readonly | EditorInputCapabilities.Singleton;
+    }
+    getName() {
+        return localize(5647, "Agent Debug Panel");
+    }
+    getIcon() {
+        return chatDebugEditorIcon;
+    }
+    matches(other) {
+        if (super.matches(other)) {
+            return true;
+        }
+        return other instanceof ChatDebugEditorInput;
+    }
+}
+class ChatDebugEditorInputSerializer {
+    canSerialize(editorInput) {
+        return true;
+    }
+    serialize(editorInput) {
+        return "";
+    }
+    deserialize(instantiationService) {
+        return ChatDebugEditorInput.instance;
+    }
+}
+
+export { ChatDebugEditorInput, ChatDebugEditorInputSerializer };

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

@@ -0,0 +1,5 @@
+import { IChatDebugEvent } from "../../common/chatDebugService.js";
+/**
+ * Format the detail text for a debug event (used when no resolved content is available).
+ */
+export declare function formatEventDetail(event: IChatDebugEvent): string;