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

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

@@ -0,0 +1,125 @@
+import { IChatDebugEvent } from "../../common/chatDebugService.js";
+export interface FlowNode {
+    readonly id: string;
+    readonly kind: IChatDebugEvent["kind"];
+    /** For `generic` nodes: the event category (e.g. `'discovery'`). Used to narrow filtering. */
+    readonly category?: string;
+    readonly label: string;
+    readonly sublabel?: string;
+    readonly description?: string;
+    readonly tooltip?: string;
+    readonly isError?: boolean;
+    readonly created: number;
+    readonly children: FlowNode[];
+    /** Present on merged discovery nodes: the individual nodes that were merged. */
+    readonly mergedNodes?: FlowNode[];
+}
+export interface FlowFilterOptions {
+    readonly isKindVisible: (kind: string, category?: string) => boolean;
+    readonly textFilter: string;
+}
+export interface LayoutNode {
+    readonly id: string;
+    readonly kind: IChatDebugEvent["kind"];
+    readonly label: string;
+    readonly sublabel?: string;
+    readonly tooltip?: string;
+    readonly isError?: boolean;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    /** Number of individual nodes merged into this one (for discovery merging). */
+    readonly mergedCount?: number;
+    /** Whether the merged node is currently expanded (individual nodes shown to the right). */
+    readonly isMergedExpanded?: boolean;
+}
+export interface LayoutEdge {
+    readonly fromId?: string;
+    readonly toId?: string;
+    readonly fromX: number;
+    readonly fromY: number;
+    readonly toX: number;
+    readonly toY: number;
+}
+export interface SubgraphRect {
+    readonly label: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly nodeId: string;
+    readonly collapsedChildCount?: number;
+}
+export interface FlowLayout {
+    readonly nodes: LayoutNode[];
+    readonly edges: LayoutEdge[];
+    readonly subgraphs: SubgraphRect[];
+    readonly width: number;
+    readonly height: number;
+}
+export interface FlowChartRenderResult {
+    readonly svg: SVGElement;
+    /** Map from node/subgraph ID to its focusable SVG element. */
+    readonly focusableElements: Map<string, SVGElement>;
+    /** Adjacency lists derived from graph edges: successors and predecessors per node ID. */
+    readonly adjacency: Map<string, {
+        next: string[];
+        prev: string[];
+    }>;
+    /** Map from node/subgraph ID to its layout position. */
+    readonly positions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+}
+export declare function buildFlowGraph(events: readonly IChatDebugEvent[]): FlowNode[];
+/**
+ * Filters a flow node tree by kind visibility and text search.
+ * Returns a new tree — the input is not mutated.
+ *
+ * Kind filtering: nodes whose kind is not visible are removed.
+ * For `subagentInvocation` nodes, the entire subgraph is removed.
+ * For other kinds, the node is removed and its children are re-parented.
+ *
+ * Text filtering: only nodes whose label, sublabel, or tooltip match the
+ * search term are kept, along with all their ancestors (path to root).
+ * If a subagent label matches, its entire subgraph is kept.
+ */
+export declare function filterFlowNodes(nodes: FlowNode[], options: FlowFilterOptions): FlowNode[];
+export interface FlowSliceResult {
+    readonly nodes: FlowNode[];
+    readonly totalCount: number;
+    readonly shownCount: number;
+}
+/**
+ * Slices a flow node tree to at most `maxCount` nodes (pre-order DFS).
+ *
+ * When a subagent's children would exceed the remaining budget, the
+ * children list is truncated. Returns the sliced tree along with total
+ * and shown node counts for the "Show More" UI.
+ */
+export declare function sliceFlowNodes(nodes: readonly FlowNode[], maxCount: number): FlowSliceResult;
+/**
+ * Merges consecutive prompt-discovery nodes (generic events with
+ * `category === 'discovery'`) into a single summary node.
+ *
+ * The merged node always stays in the graph and carries the individual
+ * nodes in `mergedNodes`.  Expansion (showing the individual nodes to the
+ * right) is handled at the layout level.
+ *
+ * Operates recursively on children.
+ */
+export declare function mergeDiscoveryNodes(nodes: readonly FlowNode[]): FlowNode[];
+/**
+ * Merges consecutive tool-call nodes that invoke the same tool into a
+ * single summary node.
+ *
+ * This mirrors `mergeDiscoveryNodes`: the merged node carries the
+ * individual nodes in `mergedNodes` and expansion is handled at the
+ * layout level.
+ *
+ * Operates recursively on children.
+ */
+export declare function mergeToolCallNodes(nodes: readonly FlowNode[]): FlowNode[];

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

@@ -0,0 +1,504 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+function truncateLabel(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return text.substring(0, maxLength - 1) + "…";
+}
+function buildFlowGraph(events) {
+    const subagentToolNames = ( new Set(["runSubagent", "search_subagent"]));
+    const completionDescsByParent = ( new Map());
+    const startedCountByParent = ( new Map());
+    for (const e of events) {
+        if (e.kind === "subagentInvocation" && ( subagentToolNames.has(e.agentName)) && e.description && e.parentEventId) {
+            let descs = completionDescsByParent.get(e.parentEventId);
+            if (!descs) {
+                descs = [];
+                completionDescsByParent.set(e.parentEventId, descs);
+            }
+            descs.push(e.description);
+        }
+    }
+    function getSubagentDescription(event) {
+        if (event.kind !== "subagentInvocation" || !event.parentEventId) {
+            return undefined;
+        }
+        const descs = completionDescsByParent.get(event.parentEventId);
+        if (!descs || descs.length === 0) {
+            return event.description && event.description !== event.agentName ? event.description : undefined;
+        }
+        const idx = startedCountByParent.get(event.parentEventId) ?? 0;
+        startedCountByParent.set(event.parentEventId, idx + 1);
+        return descs[idx] ?? descs[0];
+    }
+    const filtered = events.filter(e => {
+        if (e.kind === "toolCall" && ( subagentToolNames.has(e.toolName.replace(/^\u{1F6E0}\uFE0F?\s*/u, "")))) {
+            return false;
+        }
+        if (e.kind === "subagentInvocation" && ( subagentToolNames.has(e.agentName))) {
+            return false;
+        }
+        return true;
+    });
+    const idToEvent = ( new Map());
+    const idToChildren = ( new Map());
+    const roots = [];
+    for (const event of filtered) {
+        if (event.id) {
+            idToEvent.set(event.id, event);
+        }
+    }
+    for (const event of filtered) {
+        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);
+        }
+    }
+    function toFlowNode(event) {
+        const children = event.id ? idToChildren.get(event.id) : undefined;
+        const effectiveKind = getEffectiveKind(event);
+        let sublabel = getEventSublabel(event, effectiveKind);
+        let tooltip = getEventTooltip(event);
+        let description;
+        if (effectiveKind === "subagentInvocation") {
+            description = getSubagentDescription(event);
+            if (description) {
+                sublabel = truncateLabel(description, 30) + (sublabel ? ` \u00b7 ${sublabel}` : "");
+                if (tooltip && !tooltip.includes(description)) {
+                    const lines = tooltip.split("\n");
+                    lines.splice(1, 0, description);
+                    tooltip = lines.join("\n");
+                }
+            }
+        }
+        return {
+            id: event.id ?? `event-${events.indexOf(event)}`,
+            kind: effectiveKind,
+            category: event.kind === "generic" ? event.category : undefined,
+            label: getEventLabel(event, effectiveKind),
+            sublabel,
+            description,
+            tooltip,
+            isError: isErrorEvent(event),
+            created: event.created.getTime(),
+            children: children?.map(toFlowNode) ?? []
+        };
+    }
+    return ( roots.map(toFlowNode));
+}
+function filterFlowNodes(nodes, options) {
+    let result = filterByKind(nodes, options.isKindVisible);
+    if (options.textFilter) {
+        result = filterByText(result, options.textFilter);
+    }
+    return result;
+}
+function filterByKind(nodes, isKindVisible) {
+    const result = [];
+    let changed = false;
+    for (const node of nodes) {
+        if (!isKindVisible(node.kind, node.category)) {
+            changed = true;
+            if (node.kind === "subagentInvocation") {
+                continue;
+            }
+            result.push(...filterByKind(node.children, isKindVisible));
+            continue;
+        }
+        const filteredChildren = filterByKind(node.children, isKindVisible);
+        if (filteredChildren !== node.children) {
+            changed = true;
+            result.push({
+                ...node,
+                children: filteredChildren
+            });
+        } else {
+            result.push(node);
+        }
+    }
+    return changed ? result : nodes;
+}
+function nodeMatchesText(node, text) {
+    return node.label.toLowerCase().includes(text) || (node.sublabel?.toLowerCase().includes(text) ?? false) || (node.tooltip?.toLowerCase().includes(text) ?? false);
+}
+function filterByText(nodes, text) {
+    const result = [];
+    for (const node of nodes) {
+        if (nodeMatchesText(node, text)) {
+            result.push(node);
+            continue;
+        }
+        const filteredChildren = filterByText(node.children, text);
+        if (filteredChildren.length > 0) {
+            result.push({
+                ...node,
+                children: filteredChildren
+            });
+        }
+    }
+    return result;
+}
+function countNodes(nodes) {
+    let count = 0;
+    for (const node of nodes) {
+        count += 1 + countNodes(node.children);
+    }
+    return count;
+}
+function sliceFlowNodes(nodes, maxCount) {
+    const totalCount = countNodes(nodes);
+    if (totalCount <= maxCount) {
+        return {
+            nodes: nodes,
+            totalCount,
+            shownCount: totalCount
+        };
+    }
+    let remaining = maxCount;
+    function sliceTree(nodeList) {
+        const result = [];
+        for (const node of nodeList) {
+            if (remaining <= 0) {
+                break;
+            }
+            remaining--;
+            if (node.children.length === 0 || remaining <= 0) {
+                result.push(node.children.length === 0 ? node : {
+                    ...node,
+                    children: []
+                });
+            } else {
+                const slicedChildren = sliceTree(node.children);
+                result.push(slicedChildren !== node.children ? {
+                    ...node,
+                    children: slicedChildren
+                } : node);
+            }
+        }
+        return result;
+    }
+    const sliced = sliceTree(nodes);
+    const shownCount = maxCount - remaining;
+    return {
+        nodes: sliced,
+        totalCount,
+        shownCount
+    };
+}
+function isDiscoveryNode(node) {
+    return node.kind === "generic" && node.category === "discovery";
+}
+function mergeDiscoveryNodes(nodes) {
+    const result = [];
+    let i = 0;
+    while (i < nodes.length) {
+        const node = nodes[i];
+        if (!isDiscoveryNode(node)) {
+            const mergedChildren = mergeDiscoveryNodes(node.children);
+            result.push(mergedChildren !== node.children ? {
+                ...node,
+                children: mergedChildren
+            } : node);
+            i++;
+            continue;
+        }
+        const run = [node];
+        let j = i + 1;
+        while (j < nodes.length && isDiscoveryNode(nodes[j])) {
+            run.push(nodes[j]);
+            j++;
+        }
+        if (run.length < 2) {
+            result.push(node);
+            i = j;
+            continue;
+        }
+        const mergedId = `merged-discovery:${run[0].id}`;
+        const labels = ( run.map(n => n.label));
+        const uniqueLabels = [...( new Set(labels))];
+        const summaryLabel = uniqueLabels.length <= 2 ? uniqueLabels.join(", ") : ( localize(5614, "{0} +{1} more", uniqueLabels[0], run.length - 1));
+        result.push({
+            id: mergedId,
+            kind: "generic",
+            category: "discovery",
+            label: summaryLabel,
+            sublabel: ( localize(5615, "{0} discovery steps", run.length)),
+            tooltip: ( run.map(n => n.label + (n.sublabel ? `: ${n.sublabel}` : ""))).join("\n"),
+            created: run[0].created,
+            children: [],
+            mergedNodes: run
+        });
+        i = j;
+    }
+    return result;
+}
+function isToolCallNode(node) {
+    return node.kind === "toolCall";
+}
+function getToolName(node) {
+    return node.label;
+}
+function mergeToolCallNodes(nodes) {
+    const result = [];
+    let i = 0;
+    while (i < nodes.length) {
+        const node = nodes[i];
+        if (!isToolCallNode(node)) {
+            const mergedChildren = mergeToolCallNodes(node.children);
+            result.push(mergedChildren !== node.children ? {
+                ...node,
+                children: mergedChildren
+            } : node);
+            i++;
+            continue;
+        }
+        const toolName = getToolName(node);
+        const run = [node];
+        let j = i + 1;
+        while (j < nodes.length && isToolCallNode(nodes[j]) && getToolName(nodes[j]) === toolName) {
+            run.push(nodes[j]);
+            j++;
+        }
+        if (run.length < 2) {
+            const mergedChildren = mergeToolCallNodes(node.children);
+            result.push(mergedChildren !== node.children ? {
+                ...node,
+                children: mergedChildren
+            } : node);
+            i = j;
+            continue;
+        }
+        const mergedId = `merged-toolCall:${run[0].id}`;
+        result.push({
+            id: mergedId,
+            kind: "toolCall",
+            label: toolName,
+            sublabel: ( localize(5616, "{0} calls", run.length)),
+            tooltip: ( run.map(n => n.label + (n.sublabel ? `: ${n.sublabel}` : ""))).join("\n"),
+            created: run[0].created,
+            children: [],
+            mergedNodes: run
+        });
+        i = j;
+    }
+    return result;
+}
+function getEffectiveKind(event) {
+    if (event.kind === "generic") {
+        const name = event.name.toLowerCase().replace(/[\s_-]+/g, "");
+        if (name === "usermessage" || name === "userprompt" || name === "user" || name.startsWith("usermessage")) {
+            return "userMessage";
+        }
+        if (name === "response" || name.startsWith("agentresponse") || name.startsWith("assistantresponse") || name.startsWith("modelresponse")) {
+            return "agentResponse";
+        }
+        const cat = event.category?.toLowerCase();
+        if (cat === "user" || cat === "usermessage") {
+            return "userMessage";
+        }
+        if (cat === "response" || cat === "agentresponse") {
+            return "agentResponse";
+        }
+    }
+    return event.kind;
+}
+function getEventLabel(event, effectiveKind) {
+    const kind = effectiveKind ?? event.kind;
+    switch (kind) {
+    case "userMessage":
+        return localize(5617, "User");
+    case "modelTurn":
+        return event.kind === "modelTurn" ? (event.model ?? ( localize(5618, "Model Turn"))) : ( localize(5618, "Model Turn"));
+    case "toolCall":
+        return event.kind === "toolCall" ? event.toolName : event.kind === "generic" ? event.name : "";
+    case "subagentInvocation":
+        return event.kind === "subagentInvocation" ? event.agentName : "";
+    case "agentResponse":
+        {
+            if (event.kind === "agentResponse") {
+                return event.message || ( localize(5619, "Response"));
+            }
+            if (event.kind === "generic") {
+                const match = /\(([^)]+)\)\s*$/.exec(event.name);
+                if (match) {
+                    return match[1];
+                }
+            }
+            return localize(5619, "Response");
+        }
+    case "generic":
+        return event.kind === "generic" ? event.name : "";
+    }
+}
+function getEventSublabel(event, effectiveKind) {
+    const kind = effectiveKind ?? event.kind;
+    switch (kind) {
+    case "modelTurn":
+        {
+            const parts = [];
+            if (event.kind === "modelTurn" && event.requestName) {
+                parts.push(event.requestName);
+            }
+            if (event.kind === "modelTurn" && event.totalTokens) {
+                parts.push(( localize(5620, "{0} tokens", event.totalTokens)));
+            }
+            if (event.kind === "modelTurn" && event.durationInMillis) {
+                parts.push(formatDuration(event.durationInMillis));
+            }
+            return parts.length > 0 ? parts.join(" · ") : undefined;
+        }
+    case "toolCall":
+        {
+            const parts = [];
+            if (event.kind === "toolCall" && event.result) {
+                parts.push(event.result);
+            }
+            if (event.kind === "toolCall" && event.durationInMillis) {
+                parts.push(formatDuration(event.durationInMillis));
+            }
+            return parts.length > 0 ? parts.join(" · ") : undefined;
+        }
+    case "subagentInvocation":
+        {
+            const parts = [];
+            if (event.kind === "subagentInvocation" && event.status) {
+                parts.push(event.status);
+            }
+            if (event.kind === "subagentInvocation" && event.durationInMillis) {
+                parts.push(formatDuration(event.durationInMillis));
+            }
+            return parts.length > 0 ? parts.join(" · ") : undefined;
+        }
+    case "userMessage":
+    case "agentResponse":
+        {
+            let text;
+            if (event.kind === "userMessage" || event.kind === "agentResponse") {
+                text = event.sections[0]?.content || event.message;
+            } else if (event.kind === "generic") {
+                text = event.details;
+            }
+            if (!text) {
+                return undefined;
+            }
+            const lines = text.split("\n");
+            let firstLine = "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    firstLine = trimmed;
+                    break;
+                }
+            }
+            if (!firstLine) {
+                return undefined;
+            }
+            return firstLine.length > 60 ? firstLine.substring(0, 57) + "..." : firstLine;
+        }
+    default:
+        return undefined;
+    }
+}
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function isErrorEvent(event) {
+    return (event.kind === "toolCall" && event.result === "error") || (event.kind === "generic" && event.level === 3)  || (event.kind === "subagentInvocation" && event.status === "failed");
+}
+const TOOLTIP_MAX_LENGTH = 500;
+function getEventTooltip(event) {
+    switch (event.kind) {
+    case "userMessage":
+        {
+            const msg = event.message.trim();
+            if (msg.length > TOOLTIP_MAX_LENGTH) {
+                return msg.substring(0, TOOLTIP_MAX_LENGTH) + "…";
+            }
+            return msg || undefined;
+        }
+    case "toolCall":
+        {
+            const parts = [event.toolName];
+            if (event.input) {
+                const input = event.input.trim();
+                parts.push(( localize(
+                    5621,
+                    "Input: {0}",
+                    input.length > TOOLTIP_MAX_LENGTH ? input.substring(0, TOOLTIP_MAX_LENGTH) + "…" : input
+                )));
+            }
+            if (event.output) {
+                const output = event.output.trim();
+                parts.push(( localize(
+                    5622,
+                    "Output: {0}",
+                    output.length > TOOLTIP_MAX_LENGTH ? output.substring(0, TOOLTIP_MAX_LENGTH) + "…" : output
+                )));
+            }
+            if (event.result) {
+                parts.push(( localize(5623, "Result: {0}", event.result)));
+            }
+            return parts.join("\n");
+        }
+    case "subagentInvocation":
+        {
+            const parts = [event.agentName];
+            if (event.description) {
+                parts.push(event.description);
+            }
+            if (event.status) {
+                parts.push(( localize(5624, "Status: {0}", event.status)));
+            }
+            if (event.toolCallCount !== undefined) {
+                parts.push(( localize(5625, "Tool calls: {0}", event.toolCallCount)));
+            }
+            if (event.modelTurnCount !== undefined) {
+                parts.push(( localize(5626, "Model turns: {0}", event.modelTurnCount)));
+            }
+            return parts.join("\n");
+        }
+    case "generic":
+        {
+            if (event.details) {
+                const details = event.details.trim();
+                return details.length > TOOLTIP_MAX_LENGTH ? details.substring(0, TOOLTIP_MAX_LENGTH) + "…" : details;
+            }
+            return undefined;
+        }
+    case "modelTurn":
+        {
+            const parts = [];
+            if (event.model) {
+                parts.push(event.model);
+            }
+            if (event.totalTokens) {
+                parts.push(( localize(5627, "Tokens: {0}", event.totalTokens)));
+            }
+            if (event.inputTokens) {
+                parts.push(( localize(5628, "Input tokens: {0}", event.inputTokens)));
+            }
+            if (event.outputTokens) {
+                parts.push(( localize(5629, "Output tokens: {0}", event.outputTokens)));
+            }
+            if (event.durationInMillis) {
+                parts.push(( localize(5630, "Duration: {0}", formatDuration(event.durationInMillis))));
+            }
+            return parts.length > 0 ? parts.join("\n") : undefined;
+        }
+    default:
+        return undefined;
+    }
+}
+
+export { buildFlowGraph, filterFlowNodes, mergeDiscoveryNodes, mergeToolCallNodes, sliceFlowNodes };

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

@@ -0,0 +1,10 @@
+import { FlowLayout, FlowNode, FlowChartRenderResult } from "./chatDebugFlowGraph.js";
+/**
+ * Lays out a list of flow nodes in a top-down vertical flow.
+ * Parallel subagent invocations are arranged side by side.
+ */
+export declare function layoutFlowGraph(roots: FlowNode[], options?: {
+    collapsedIds?: ReadonlySet<string>;
+    expandedMergedIds?: ReadonlySet<string>;
+}): FlowLayout;
+export declare function renderFlowChartSVG(layout: FlowLayout): FlowChartRenderResult;