@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.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(5648, "Tool: {0}", event.toolName))];
+            if (event.toolCallId) {
+                parts.push(( localize(5649, "Call ID: {0}", event.toolCallId)));
+            }
+            if (event.result) {
+                parts.push(( localize(5650, "Result: {0}", event.result)));
+            }
+            if (event.durationInMillis !== undefined) {
+                parts.push(( localize(5651, "Duration: {0}ms", event.durationInMillis)));
+            }
+            if (event.input) {
+                parts.push(`\n${( localize(5652, "Input:"))}\n${event.input}`);
+            }
+            if (event.output) {
+                parts.push(`\n${( localize(5653, "Output:"))}\n${event.output}`);
+            }
+            return parts.join("\n");
+        }
+    case "modelTurn":
+        {
+            const parts = [event.model ?? ( localize(5654, "Model Turn"))];
+            if (event.inputTokens !== undefined) {
+                parts.push(( localize(5655, "Input tokens: {0}", event.inputTokens)));
+            }
+            if (event.outputTokens !== undefined) {
+                parts.push(( localize(5656, "Output tokens: {0}", event.outputTokens)));
+            }
+            if (event.totalTokens !== undefined) {
+                parts.push(( localize(5657, "Total tokens: {0}", event.totalTokens)));
+            }
+            if (event.durationInMillis !== undefined) {
+                parts.push(( localize(5651, "Duration: {0}ms", event.durationInMillis)));
+            }
+            return parts.join("\n");
+        }
+    case "generic":
+        return `${event.name}\n${event.details ?? ""}`;
+    case "subagentInvocation":
+        {
+            const parts = [( localize(5658, "Agent: {0}", event.agentName))];
+            if (event.description) {
+                parts.push(( localize(5659, "Description: {0}", event.description)));
+            }
+            if (event.status) {
+                parts.push(( localize(5660, "Status: {0}", event.status)));
+            }
+            if (event.durationInMillis !== undefined) {
+                parts.push(( localize(5651, "Duration: {0}ms", event.durationInMillis)));
+            }
+            if (event.toolCallCount !== undefined) {
+                parts.push(( localize(5661, "Tool calls: {0}", event.toolCallCount)));
+            }
+            if (event.modelTurnCount !== undefined) {
+                parts.push(( localize(5662, "Model turns: {0}", event.modelTurnCount)));
+            }
+            return parts.join("\n");
+        }
+    case "userMessage":
+        {
+            const parts = [( localize(5663, "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(5664, "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(5665, "(unknown)")));
+        templateData.details.textContent = safeStr(element.result);
+        break;
+    case "modelTurn":
+        templateData.name.textContent = safeStr(element.model) || ( localize(5666, "Model Turn"));
+        templateData.details.textContent = [
+            safeStr(element.requestName),
+            element.totalTokens !== undefined ? ( localize(5667, "{0} tokens", element.totalTokens)) : ""
+        ].filter(Boolean).join(" · ");
+        break;
+    case "generic":
+        templateData.name.textContent = safeStr(element.name, ( localize(5665, "(unknown)")));
+        templateData.details.textContent = safeStr(element.details);
+        break;
+    case "subagentInvocation":
+        templateData.name.textContent = safeStr(element.agentName, ( localize(5665, "(unknown)")));
+        templateData.details.textContent = safeStr(element.description) || safeStr(element.status);
+        break;
+    case "userMessage":
+        templateData.name.textContent = ( localize(5668, "User Message"));
+        templateData.details.textContent = safeStr(element.message);
+        break;
+    case "agentResponse":
+        templateData.name.textContent = ( localize(5669, "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,46 @@
+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;
+    beforeTimestamp: number | undefined;
+    afterTimestamp: number | undefined;
+    isKindVisible(kind: string, category?: string): boolean;
+    isAllKindsVisible(): boolean;
+    isAllFiltersDefault(): boolean;
+    setTextFilter(text: string): void;
+    setBeforeTimestamp(timestamp: number | undefined): void;
+    /**
+     * Parse `before:YYYY[-MM[-DD[THH[:MM[:SS]]]]]` from the filter text.
+     * Each component after the year is optional.
+     */
+    private _parseTimestampFilters;
+    static parseTimeToken(text: string, prefix: string): number | undefined;
+    /** Returns the text filter with before:/after: tokens removed. */
+    get textFilterWithoutTimestamps(): string;
+    isTimestampVisible(created: Date): boolean;
+    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,170 @@
+
+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._parseTimestampFilters(normalized);
+            this._onDidChange.fire();
+        }
+    }
+    setBeforeTimestamp(timestamp) {
+        if (this.beforeTimestamp !== timestamp) {
+            this.beforeTimestamp = timestamp;
+            this._onDidChange.fire();
+        }
+    }
+    _parseTimestampFilters(text) {
+        this.beforeTimestamp = ChatDebugFilterState.parseTimeToken(text, "before");
+        this.afterTimestamp = ChatDebugFilterState.parseTimeToken(text, "after");
+    }
+    static parseTimeToken(text, prefix) {
+        const regex = ( new RegExp(
+            `${prefix}:(\\d{4})(?:-(\\d{2})(?:-(\\d{2})(?:t(\\d{1,2})(?::(\\d{2})(?::(\\d{2}))?)?)?)?)?(?!\\w)`
+        ));
+        const m = regex.exec(text);
+        if (!m) {
+            return undefined;
+        }
+        const year = parseInt(m[1], 10);
+        const month = m[2] !== undefined ? parseInt(m[2], 10) - 1 : undefined;
+        const day = m[3] !== undefined ? parseInt(m[3], 10) : undefined;
+        const hour = m[4] !== undefined ? parseInt(m[4], 10) : undefined;
+        const minute = m[5] !== undefined ? parseInt(m[5], 10) : undefined;
+        const second = m[6] !== undefined ? parseInt(m[6], 10) : undefined;
+        if (prefix === "before") {
+            if (second !== undefined) {
+                return ( new Date(year, month, day, hour, minute, second, 999)).getTime();
+            } else if (minute !== undefined) {
+                return ( new Date(year, month, day, hour, minute, 59, 999)).getTime();
+            } else if (hour !== undefined) {
+                return ( new Date(year, month, day, hour, 59, 59, 999)).getTime();
+            } else if (day !== undefined) {
+                return ( new Date(year, month, day, 23, 59, 59, 999)).getTime();
+            } else if (month !== undefined) {
+                return ( new Date(year, month + 1, 0, 23, 59, 59, 999)).getTime();
+            } else {
+                return ( new Date(year, 11, 31, 23, 59, 59, 999)).getTime();
+            }
+        } else {
+            return ( new Date(year, month ?? 0, day ?? 1, hour ?? 0, minute ?? 0, second ?? 0, 0)).getTime();
+        }
+    }
+    get textFilterWithoutTimestamps() {
+        return this.textFilter.replace(
+            /\b(?:before|after):\d{4}(?:-\d{2}(?:-\d{2}(?:t\d{1,2}(?::\d{2}(?::\d{2})?)?)?)?)?\b/g,
+            ""
+        ).trim();
+    }
+    isTimestampVisible(created) {
+        const time = created.getTime();
+        if (this.beforeTimestamp !== undefined && time > this.beforeTimestamp) {
+            return false;
+        }
+        if (this.afterTimestamp !== undefined && time < this.afterTimestamp) {
+            return false;
+        }
+        return true;
+    }
+    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(5670, "Tool Calls")), CHAT_DEBUG_KIND_TOOL_CALL, "1_kind", () => state.filterKindToolCall, v => {
+        state.filterKindToolCall = v;
+    }, kindToolCallKey);
+    registerToggle(CHAT_DEBUG_CMD_TOGGLE_MODEL_TURN, ( localize(5671, "Model Turns")), CHAT_DEBUG_KIND_MODEL_TURN, "1_kind", () => state.filterKindModelTurn, v => {
+        state.filterKindModelTurn = v;
+    }, kindModelTurnKey);
+    registerToggle(CHAT_DEBUG_CMD_TOGGLE_PROMPT_DISCOVERY, ( localize(5672, "Chat Customization")), CHAT_DEBUG_KIND_PROMPT_DISCOVERY, "1_kind", () => state.filterKindPromptDiscovery, v => {
+        state.filterKindPromptDiscovery = v;
+    }, kindPromptDiscoveryKey);
+    registerToggle(CHAT_DEBUG_CMD_TOGGLE_SUBAGENT, ( localize(5673, "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;
+}