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

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

@@ -0,0 +1,84 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+function formatEventDetail(event) {
+    switch (event.kind) {
+    case "toolCall":
+        {
+            const parts = [( localize(5580, "Tool: {0}", event.toolName))];
+            if (event.toolCallId) {
+                parts.push(( localize(5581, "Call ID: {0}", event.toolCallId)));
+            }
+            if (event.result) {
+                parts.push(( localize(5582, "Result: {0}", event.result)));
+            }
+            if (event.durationInMillis !== undefined) {
+                parts.push(( localize(5583, "Duration: {0}ms", event.durationInMillis)));
+            }
+            if (event.input) {
+                parts.push(`\n${( localize(5584, "Input:"))}\n${event.input}`);
+            }
+            if (event.output) {
+                parts.push(`\n${( localize(5585, "Output:"))}\n${event.output}`);
+            }
+            return parts.join("\n");
+        }
+    case "modelTurn":
+        {
+            const parts = [event.model ?? ( localize(5586, "Model Turn"))];
+            if (event.inputTokens !== undefined) {
+                parts.push(( localize(5587, "Input tokens: {0}", event.inputTokens)));
+            }
+            if (event.outputTokens !== undefined) {
+                parts.push(( localize(5588, "Output tokens: {0}", event.outputTokens)));
+            }
+            if (event.totalTokens !== undefined) {
+                parts.push(( localize(5589, "Total tokens: {0}", event.totalTokens)));
+            }
+            if (event.durationInMillis !== undefined) {
+                parts.push(( localize(5583, "Duration: {0}ms", event.durationInMillis)));
+            }
+            return parts.join("\n");
+        }
+    case "generic":
+        return `${event.name}\n${event.details ?? ""}`;
+    case "subagentInvocation":
+        {
+            const parts = [( localize(5590, "Agent: {0}", event.agentName))];
+            if (event.description) {
+                parts.push(( localize(5591, "Description: {0}", event.description)));
+            }
+            if (event.status) {
+                parts.push(( localize(5592, "Status: {0}", event.status)));
+            }
+            if (event.durationInMillis !== undefined) {
+                parts.push(( localize(5583, "Duration: {0}ms", event.durationInMillis)));
+            }
+            if (event.toolCallCount !== undefined) {
+                parts.push(( localize(5593, "Tool calls: {0}", event.toolCallCount)));
+            }
+            if (event.modelTurnCount !== undefined) {
+                parts.push(( localize(5594, "Model turns: {0}", event.modelTurnCount)));
+            }
+            return parts.join("\n");
+        }
+    case "userMessage":
+        {
+            const parts = [( localize(5595, "User Message: {0}", event.message))];
+            for (const section of event.sections) {
+                parts.push(`\n--- ${section.name} ---\n${section.content}`);
+            }
+            return parts.join("\n");
+        }
+    case "agentResponse":
+        {
+            const parts = [( localize(5596, "Agent Response: {0}", event.message))];
+            for (const section of event.sections) {
+                parts.push(`\n--- ${section.name} ---\n${section.content}`);
+            }
+            return parts.join("\n");
+        }
+    }
+}
+
+export { formatEventDetail };

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

@@ -0,0 +1,27 @@
+import { IListRenderer, IListVirtualDelegate } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/list";
+import { ITreeNode, ITreeRenderer } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/tree";
+import { IChatDebugEvent } from "../../common/chatDebugService.js";
+export interface IChatDebugEventTemplate {
+    readonly container: HTMLElement;
+    readonly created: HTMLElement;
+    readonly name: HTMLElement;
+    readonly details: HTMLElement;
+}
+export declare class ChatDebugEventRenderer implements IListRenderer<IChatDebugEvent, IChatDebugEventTemplate> {
+    static readonly TEMPLATE_ID = "chatDebugEvent";
+    get templateId(): string;
+    renderTemplate(container: HTMLElement): IChatDebugEventTemplate;
+    renderElement(element: IChatDebugEvent, index: number, templateData: IChatDebugEventTemplate): void;
+    disposeTemplate(_templateData: IChatDebugEventTemplate): void;
+}
+export declare class ChatDebugEventDelegate implements IListVirtualDelegate<IChatDebugEvent> {
+    getHeight(_element: IChatDebugEvent): number;
+    getTemplateId(_element: IChatDebugEvent): string;
+}
+export declare class ChatDebugEventTreeRenderer implements ITreeRenderer<IChatDebugEvent, void, IChatDebugEventTemplate> {
+    static readonly TEMPLATE_ID = "chatDebugEvent";
+    get templateId(): string;
+    renderTemplate(container: HTMLElement): IChatDebugEventTemplate;
+    renderElement(node: ITreeNode<IChatDebugEvent, void>, index: number, templateData: IChatDebugEventTemplate): void;
+    disposeTemplate(_templateData: IChatDebugEventTemplate): void;
+}

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

@@ -0,0 +1,110 @@
+
+import { $ as $$1, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ChatDebugLogLevel } from '../../common/chatDebugService.js';
+import { safeIntl } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
+
+const $ = $$1;
+function safeStr(value, fallback = "") {
+    if (value === null || value === undefined || typeof value !== "string") {
+        return fallback;
+    }
+    return value;
+}
+const dateFormatter = safeIntl.DateTimeFormat(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit"
+});
+function renderEventToTemplate(element, templateData) {
+    templateData.created.textContent = dateFormatter.value.format(element.created);
+    switch (element.kind) {
+    case "toolCall":
+        templateData.name.textContent = safeStr(element.toolName, ( localize(5597, "(unknown)")));
+        templateData.details.textContent = safeStr(element.result);
+        break;
+    case "modelTurn":
+        templateData.name.textContent = safeStr(element.model) || ( localize(5598, "Model Turn"));
+        templateData.details.textContent = [
+            safeStr(element.requestName),
+            element.totalTokens !== undefined ? ( localize(5599, "{0} tokens", element.totalTokens)) : ""
+        ].filter(Boolean).join(" · ");
+        break;
+    case "generic":
+        templateData.name.textContent = safeStr(element.name, ( localize(5597, "(unknown)")));
+        templateData.details.textContent = safeStr(element.details);
+        break;
+    case "subagentInvocation":
+        templateData.name.textContent = safeStr(element.agentName, ( localize(5597, "(unknown)")));
+        templateData.details.textContent = safeStr(element.description) || safeStr(element.status);
+        break;
+    case "userMessage":
+        templateData.name.textContent = ( localize(5600, "User Message"));
+        templateData.details.textContent = safeStr(element.message);
+        break;
+    case "agentResponse":
+        templateData.name.textContent = ( localize(5601, "Agent Response"));
+        templateData.details.textContent = safeStr(element.message);
+        break;
+    }
+    const isError = element.kind === "generic" && element.level === ChatDebugLogLevel.Error || element.kind === "toolCall" && element.result === "error";
+    const isWarning = element.kind === "generic" && element.level === ChatDebugLogLevel.Warning;
+    const isTrace = element.kind === "generic" && element.level === ChatDebugLogLevel.Trace;
+    templateData.container.classList.toggle("chat-debug-log-error", isError);
+    templateData.container.classList.toggle("chat-debug-log-warning", isWarning);
+    templateData.container.classList.toggle("chat-debug-log-trace", isTrace);
+}
+function createEventTemplate(container) {
+    container.classList.add("chat-debug-log-row");
+    const created = append(container, $("span.chat-debug-log-created"));
+    const name = append(container, $("span.chat-debug-log-name"));
+    const details = append(container, $("span.chat-debug-log-details"));
+    return {
+        container,
+        created,
+        name,
+        details
+    };
+}
+class ChatDebugEventRenderer {
+    static {
+        this.TEMPLATE_ID = "chatDebugEvent";
+    }
+    get templateId() {
+        return ChatDebugEventRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        return createEventTemplate(container);
+    }
+    renderElement(element, index, templateData) {
+        renderEventToTemplate(element, templateData);
+    }
+    disposeTemplate(_templateData) {}
+}
+class ChatDebugEventDelegate {
+    getHeight(_element) {
+        return 28;
+    }
+    getTemplateId(_element) {
+        return ChatDebugEventRenderer.TEMPLATE_ID;
+    }
+}
+class ChatDebugEventTreeRenderer {
+    static {
+        this.TEMPLATE_ID = "chatDebugEvent";
+    }
+    get templateId() {
+        return ChatDebugEventTreeRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        return createEventTemplate(container);
+    }
+    renderElement(node, index, templateData) {
+        renderEventToTemplate(node.element, templateData);
+    }
+    disposeTemplate(_templateData) {}
+}
+
+export { ChatDebugEventDelegate, ChatDebugEventRenderer, ChatDebugEventTreeRenderer };

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

@@ -0,0 +1,34 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+/**
+ * Shared filter state for the Agent Debug Panel.
+ *
+ * Both the Logs view and the Flow Chart view read from this single source of
+ * truth. Toggle commands modify the state and fire `onDidChange` so every
+ * consumer can re-render.
+ */
+export declare class ChatDebugFilterState extends Disposable {
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    filterKindToolCall: boolean;
+    filterKindModelTurn: boolean;
+    filterKindPromptDiscovery: boolean;
+    filterKindSubagent: boolean;
+    textFilter: string;
+    isKindVisible(kind: string, category?: string): boolean;
+    isAllKindsVisible(): boolean;
+    isAllFiltersDefault(): boolean;
+    setTextFilter(text: string): void;
+    fire(): void;
+}
+/**
+ * Registers the toggle-filter commands and menu items once, wired to a shared
+ * {@link ChatDebugFilterState}. Returns a disposable that unregisters them.
+ */
+export declare function registerFilterMenuItems(state: ChatDebugFilterState, scopedContextKeyService: IContextKeyService): DisposableStore;
+/**
+ * Binds context keys for filter state into a scoped context key service.
+ * Returns a function to sync all keys from the current state.
+ */
+export declare function bindFilterContextKeys(state: ChatDebugFilterState, scopedContextKeyService: IContextKeyService): () => void;

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

@@ -0,0 +1,111 @@
+
+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 { MenuRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { viewFilterSubmenu } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/views/viewFilter';
+import { CHAT_DEBUG_FILTER_ACTIVE, CHAT_DEBUG_KIND_TOOL_CALL, CHAT_DEBUG_KIND_MODEL_TURN, CHAT_DEBUG_KIND_PROMPT_DISCOVERY, CHAT_DEBUG_KIND_SUBAGENT, CHAT_DEBUG_CMD_TOGGLE_TOOL_CALL, CHAT_DEBUG_CMD_TOGGLE_MODEL_TURN, CHAT_DEBUG_CMD_TOGGLE_PROMPT_DISCOVERY, CHAT_DEBUG_CMD_TOGGLE_SUBAGENT } from './chatDebugTypes.js';
+
+class ChatDebugFilterState extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.filterKindToolCall = true;
+        this.filterKindModelTurn = true;
+        this.filterKindPromptDiscovery = true;
+        this.filterKindSubagent = true;
+        this.textFilter = "";
+    }
+    isKindVisible(kind, category) {
+        switch (kind) {
+        case "toolCall":
+            return this.filterKindToolCall;
+        case "modelTurn":
+            return this.filterKindModelTurn;
+        case "generic":
+            if (category !== "discovery") {
+                return true;
+            }
+            return this.filterKindPromptDiscovery;
+        case "subagentInvocation":
+            return this.filterKindSubagent;
+        default:
+            return true;
+        }
+    }
+    isAllKindsVisible() {
+        return this.filterKindToolCall && this.filterKindModelTurn && this.filterKindPromptDiscovery && this.filterKindSubagent;
+    }
+    isAllFiltersDefault() {
+        return this.isAllKindsVisible();
+    }
+    setTextFilter(text) {
+        const normalized = text.toLowerCase();
+        if (this.textFilter !== normalized) {
+            this.textFilter = normalized;
+            this._onDidChange.fire();
+        }
+    }
+    fire() {
+        this._onDidChange.fire();
+    }
+}
+function registerFilterMenuItems(state, scopedContextKeyService) {
+    const store = ( new DisposableStore());
+    CHAT_DEBUG_FILTER_ACTIVE.bindTo(scopedContextKeyService).set(true);
+    const kindToolCallKey = CHAT_DEBUG_KIND_TOOL_CALL.bindTo(scopedContextKeyService);
+    kindToolCallKey.set(true);
+    const kindModelTurnKey = CHAT_DEBUG_KIND_MODEL_TURN.bindTo(scopedContextKeyService);
+    kindModelTurnKey.set(true);
+    const kindPromptDiscoveryKey = CHAT_DEBUG_KIND_PROMPT_DISCOVERY.bindTo(scopedContextKeyService);
+    kindPromptDiscoveryKey.set(true);
+    const kindSubagentKey = CHAT_DEBUG_KIND_SUBAGENT.bindTo(scopedContextKeyService);
+    kindSubagentKey.set(true);
+    const registerToggle = (id, title, key, group, getter, setter, ctxKey) => {
+        store.add(CommandsRegistry.registerCommand(id, () => {
+            const newVal = !getter();
+            setter(newVal);
+            ctxKey.set(newVal);
+            state.fire();
+        }));
+        store.add(MenuRegistry.appendMenuItem(viewFilterSubmenu, {
+            command: {
+                id,
+                title,
+                toggled: key
+            },
+            group,
+            when: CHAT_DEBUG_FILTER_ACTIVE
+        }));
+    };
+    registerToggle(CHAT_DEBUG_CMD_TOGGLE_TOOL_CALL, ( localize(5602, "Tool Calls")), CHAT_DEBUG_KIND_TOOL_CALL, "1_kind", () => state.filterKindToolCall, v => {
+        state.filterKindToolCall = v;
+    }, kindToolCallKey);
+    registerToggle(CHAT_DEBUG_CMD_TOGGLE_MODEL_TURN, ( localize(5603, "Model Turns")), CHAT_DEBUG_KIND_MODEL_TURN, "1_kind", () => state.filterKindModelTurn, v => {
+        state.filterKindModelTurn = v;
+    }, kindModelTurnKey);
+    registerToggle(CHAT_DEBUG_CMD_TOGGLE_PROMPT_DISCOVERY, ( localize(5604, "Chat Customization")), CHAT_DEBUG_KIND_PROMPT_DISCOVERY, "1_kind", () => state.filterKindPromptDiscovery, v => {
+        state.filterKindPromptDiscovery = v;
+    }, kindPromptDiscoveryKey);
+    registerToggle(CHAT_DEBUG_CMD_TOGGLE_SUBAGENT, ( localize(5605, "Subagent Invocations")), CHAT_DEBUG_KIND_SUBAGENT, "1_kind", () => state.filterKindSubagent, v => {
+        state.filterKindSubagent = v;
+    }, kindSubagentKey);
+    return store;
+}
+function bindFilterContextKeys(state, scopedContextKeyService) {
+    CHAT_DEBUG_FILTER_ACTIVE.bindTo(scopedContextKeyService).set(true);
+    const kindToolCallKey = CHAT_DEBUG_KIND_TOOL_CALL.bindTo(scopedContextKeyService);
+    const kindModelTurnKey = CHAT_DEBUG_KIND_MODEL_TURN.bindTo(scopedContextKeyService);
+    const kindPromptDiscoveryKey = CHAT_DEBUG_KIND_PROMPT_DISCOVERY.bindTo(scopedContextKeyService);
+    const kindSubagentKey = CHAT_DEBUG_KIND_SUBAGENT.bindTo(scopedContextKeyService);
+    return () => {
+        kindToolCallKey.set(state.filterKindToolCall);
+        kindModelTurnKey.set(state.filterKindModelTurn);
+        kindPromptDiscoveryKey.set(state.filterKindPromptDiscovery);
+        kindSubagentKey.set(state.filterKindSubagent);
+    };
+}
+
+export { ChatDebugFilterState, bindFilterContextKeys, registerFilterMenuItems };

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

@@ -0,0 +1,71 @@
+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 { 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 FlowChartNavigation {
+    Home = "home",
+    Overview = "overview"
+}
+export declare class ChatDebugFlowChartView extends Disposable {
+    private readonly filterState;
+    private readonly chatService;
+    private readonly chatDebugService;
+    private readonly contextKeyService;
+    private readonly instantiationService;
+    private readonly _onNavigate;
+    readonly onNavigate: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<FlowChartNavigation>;
+    readonly container: HTMLElement;
+    private readonly content;
+    private readonly breadcrumbWidget;
+    private readonly filterWidget;
+    private readonly headerContainer;
+    private readonly loadDisposables;
+    private scale;
+    private translateX;
+    private translateY;
+    private isPanning;
+    private startX;
+    private startY;
+    private mouseDownX;
+    private mouseDownY;
+    private svgWrapper;
+    private svgElement;
+    private renderResult;
+    private currentSessionResource;
+    private lastEventCount;
+    private hasUserPanned;
+    private focusedElementId;
+    private readonly collapsedNodeIds;
+    private readonly expandedMergedIds;
+    private visibleLimit;
+    private readonly detailPanel;
+    private eventById;
+    constructor(parent: HTMLElement, filterState: ChatDebugFilterState, chatService: IChatService, chatDebugService: IChatDebugService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService);
+    setSession(sessionResource: URI): void;
+    show(): void;
+    hide(): void;
+    refresh(): void;
+    updateBreadcrumb(): void;
+    private load;
+    private setupPanZoom;
+    private setupKeyboard;
+    private toggleSubgraph;
+    private toggleMergedDiscovery;
+    private focusFirstElement;
+    private focusLastElement;
+    private focusAdjacentElement;
+    private focusEdgeNeighbor;
+    private focusFirstChildOf;
+    private restoreFocus;
+    private zoomBy;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleClick;
+    private handleWheel;
+    private applyTransform;
+    private centerContent;
+}