@codingame/monaco-vscode-katex-common 29.1.1 → 30.0.1

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatToolPicker.js

@@ -0,0 +1,637 @@
+
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ExtensionEditorTab } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { McpCommandIds } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpServerEditorTab, McpConnectionState, McpServerCacheState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { IMcpService, IMcpWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { startServerAndWaitForLiveTools } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
+import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { ConfigureToolSets } from '../tools/toolSetsContribution.js';
+
+var BucketOrdinal;
+(function(BucketOrdinal) {
+    BucketOrdinal[BucketOrdinal["User"] = 0] = "User";
+    BucketOrdinal[BucketOrdinal["BuiltIn"] = 1] = "BuiltIn";
+    BucketOrdinal[BucketOrdinal["Mcp"] = 2] = "Mcp";
+    BucketOrdinal[BucketOrdinal["Extension"] = 3] = "Extension";
+})(BucketOrdinal || (BucketOrdinal = {}));
+function isBucketTreeItem(item) {
+    return item.itemType === "bucket";
+}
+function isToolSetTreeItem(item) {
+    return item.itemType === "toolset";
+}
+function isToolTreeItem(item) {
+    return item.itemType === "tool";
+}
+function isCallbackTreeItem(item) {
+    return item.itemType === "callback";
+}
+function mapIconToTreeItem(icon, useDefaultToolIcon = false) {
+    if (!icon) {
+        if (useDefaultToolIcon) {
+            return {
+                iconClass: ThemeIcon.asClassName(Codicon.tools)
+            };
+        }
+        return {};
+    }
+    if (ThemeIcon.isThemeIcon(icon)) {
+        return {
+            iconClass: ThemeIcon.asClassName(icon)
+        };
+    } else {
+        return {
+            iconPath: icon
+        };
+    }
+}
+function createToolTreeItemFromData(tool, checked) {
+    const iconProps = mapIconToTreeItem(tool.icon, true);
+    return {
+        itemType: "tool",
+        tool,
+        id: tool.id,
+        label: tool.toolReferenceName ?? tool.displayName,
+        description: tool.userDescription ?? tool.modelDescription,
+        checked,
+        ...iconProps
+    };
+}
+function createToolSetTreeItem(toolset, checked, editorService) {
+    const iconProps = mapIconToTreeItem(toolset.icon);
+    const buttons = [];
+    if (toolset.source.type === "user") {
+        const resource = toolset.source.file;
+        buttons.push({
+            iconClass: ThemeIcon.asClassName(Codicon.edit),
+            tooltip: ( localize(5025, "Edit Tool Set")),
+            action: () => editorService.openEditor({
+                resource
+            })
+        });
+    }
+    return {
+        itemType: "toolset",
+        toolset,
+        buttons,
+        id: toolset.id,
+        label: toolset.referenceName,
+        description: toolset.description,
+        checked,
+        children: undefined,
+        collapsed: true,
+        ...iconProps
+    };
+}
+async function showToolsPicker(accessor, placeHolder, source, description, getToolsEntries, model, token) {
+    const quickPickService = accessor.get(IQuickInputService);
+    const mcpService = accessor.get(IMcpService);
+    const mcpRegistry = accessor.get(IMcpRegistry);
+    const commandService = accessor.get(ICommandService);
+    const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+    const editorService = accessor.get(IEditorService);
+    const mcpWorkbenchService = accessor.get(IMcpWorkbenchService);
+    const toolsService = accessor.get(ILanguageModelToolsService);
+    const confirmationService = accessor.get(ILanguageModelToolsConfirmationService);
+    const telemetryService = accessor.get(ITelemetryService);
+    const mcpServerByTool = ( new Map());
+    for (const server of mcpService.servers.get()) {
+        for (const tool of server.tools.get()) {
+            mcpServerByTool.set(tool.id, server);
+        }
+    }
+    function computeItems(previousToolsEntries) {
+        let toolsEntries = getToolsEntries ? ( new Map(( [...getToolsEntries()].map(([k, enabled]) => [k.id, enabled])))) : undefined;
+        if (!toolsEntries) {
+            const defaultEntries = ( new Map());
+            for (const tool of toolsService.getTools(model)) {
+                if (tool.canBeReferencedInPrompt) {
+                    defaultEntries.set(tool, false);
+                }
+            }
+            for (const toolSet of toolsService.getToolSetsForModel(model)) {
+                defaultEntries.set(toolSet, false);
+            }
+            toolsEntries = defaultEntries;
+        }
+        previousToolsEntries?.forEach((value, key) => {
+            toolsEntries.set(key.id, value);
+        });
+        const treeItems = [];
+        const bucketMap = ( new Map());
+        const getKey = source => {
+            switch (source.type) {
+            case "mcp":
+            case "extension":
+                return ToolDataSource.toKey(source);
+            case "internal":
+                return ( BucketOrdinal.BuiltIn.toString());
+            case "user":
+                return ( BucketOrdinal.User.toString());
+            case "external":
+                throw ( new Error("should not be reachable"));
+            default:
+                assertNever();
+            }
+        };
+        const mcpServers = ( new Map(( mcpService.servers.get().map(s => [s.definition.id, {
+            server: s,
+            seen: false
+        }]))));
+        const createBucket = (source, key) => {
+            if (source.type === "mcp") {
+                const mcpServerEntry = mcpServers.get(source.definitionId);
+                if (!mcpServerEntry) {
+                    return undefined;
+                }
+                mcpServerEntry.seen = true;
+                const mcpServer = mcpServerEntry.server;
+                const buttons = [];
+                const collection = mcpRegistry.collections.get().find(c => c.id === mcpServer.collection.id);
+                if (collection?.source) {
+                    buttons.push({
+                        iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                        tooltip: ( localize(5026, "Configure {0}", collection.label)),
+                        action: () => collection.source ? collection.source instanceof ExtensionIdentifier ? extensionsWorkbenchService.open(collection.source.value, {
+                            tab: ExtensionEditorTab.Features,
+                            feature: "mcp"
+                        }) : mcpWorkbenchService.open(collection.source, {
+                            tab: McpServerEditorTab.Configuration
+                        }) : undefined
+                    });
+                } else if (collection?.presentation?.origin) {
+                    buttons.push({
+                        iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                        tooltip: ( localize(5026, "Configure {0}", collection.label)),
+                        action: () => editorService.openEditor({
+                            resource: collection.presentation.origin
+                        })
+                    });
+                }
+                if (mcpServer.connectionState.get().state === McpConnectionState.Kind.Error) {
+                    buttons.push({
+                        iconClass: ThemeIcon.asClassName(Codicon.warning),
+                        tooltip: ( localize(5027, "Show Output")),
+                        action: () => mcpServer.showOutput()
+                    });
+                }
+                const cacheState = mcpServer.cacheState.get();
+                const children = [];
+                let collapsed = true;
+                if (cacheState === McpServerCacheState.Unknown || cacheState === McpServerCacheState.Outdated) {
+                    collapsed = false;
+                    children.push({
+                        itemType: "callback",
+                        iconClass: ThemeIcon.asClassName(Codicon.sync),
+                        label: ( localize(5028, "Update Tools")),
+                        pickable: false,
+                        run: () => {
+                            treePicker.busy = true;
+                            (async () => {
+                                const ok = await startServerAndWaitForLiveTools(mcpServer, {
+                                    promptType: "all-untrusted"
+                                });
+                                if (!ok) {
+                                    mcpServer.showOutput();
+                                    treePicker.hide();
+                                    return;
+                                }
+                                treePicker.busy = false;
+                                computeItems(collectResults());
+                            })();
+                            return false;
+                        }
+                    });
+                }
+                const bucket = {
+                    itemType: "bucket",
+                    ordinal: BucketOrdinal.Mcp,
+                    id: key,
+                    label: source.label,
+                    checked: undefined,
+                    collapsed,
+                    children,
+                    buttons,
+                    sortOrder: 2
+                };
+                const iconPath = mcpServer.serverMetadata.get()?.icons.getUrl(22);
+                if (iconPath) {
+                    bucket.iconPath = iconPath;
+                } else {
+                    bucket.iconClass = ThemeIcon.asClassName(Codicon.mcp);
+                }
+                return bucket;
+            } else if (source.type === "extension") {
+                return {
+                    itemType: "bucket",
+                    ordinal: BucketOrdinal.Extension,
+                    id: key,
+                    label: source.label,
+                    checked: undefined,
+                    children: [],
+                    buttons: [],
+                    collapsed: true,
+                    iconClass: ThemeIcon.asClassName(Codicon.extensions),
+                    sortOrder: 3
+                };
+            } else if (source.type === "internal") {
+                return {
+                    itemType: "bucket",
+                    ordinal: BucketOrdinal.BuiltIn,
+                    id: key,
+                    label: ( localize(5029, "Built-In")),
+                    checked: undefined,
+                    children: [],
+                    buttons: [],
+                    collapsed: false,
+                    sortOrder: 1
+                };
+            } else {
+                return {
+                    itemType: "bucket",
+                    ordinal: BucketOrdinal.User,
+                    id: key,
+                    label: ( localize(5030, "User Defined Tool Sets")),
+                    checked: undefined,
+                    children: [],
+                    buttons: [],
+                    collapsed: true,
+                    sortOrder: 4
+                };
+            }
+        };
+        const getBucket = source => {
+            const key = getKey(source);
+            let bucket = bucketMap.get(key);
+            if (!bucket) {
+                bucket = createBucket(source, key);
+                if (bucket) {
+                    bucketMap.set(key, bucket);
+                }
+            }
+            return bucket;
+        };
+        for (const toolSet of toolsService.getToolSetsForModel(model)) {
+            if (!( toolsEntries.has(toolSet.id))) {
+                continue;
+            }
+            const bucket = getBucket(toolSet.source);
+            if (!bucket) {
+                continue;
+            }
+            const toolSetChecked = toolsEntries.get(toolSet.id) === true;
+            if (toolSet.source.type === "mcp") {
+                bucket.toolset = toolSet;
+                if (toolSetChecked) {
+                    bucket.checked = toolSetChecked;
+                }
+            } else {
+                const treeItem = createToolSetTreeItem(toolSet, toolSetChecked, editorService);
+                bucket.children.push(treeItem);
+                const children = [];
+                for (const tool of toolSet.getTools()) {
+                    const toolChecked = toolSetChecked || toolsEntries.get(tool.id) === true;
+                    const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
+                    children.push(toolTreeItem);
+                }
+                if (children.length > 0) {
+                    treeItem.children = children;
+                }
+            }
+        }
+        for (const tool of toolsService.getAllToolsIncludingDisabled()) {
+            if (!tool.canBeReferencedInPrompt || !( toolsEntries.has(tool.id))) {
+                continue;
+            }
+            const bucket = getBucket(tool.source);
+            if (!bucket) {
+                continue;
+            }
+            const toolChecked = bucket.checked === true || toolsEntries.get(tool.id) === true;
+            const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
+            bucket.children.push(toolTreeItem);
+        }
+        for (const {
+            server,
+            seen
+        } of ( mcpServers.values())) {
+            const cacheState = server.cacheState.get();
+            if (!seen && (cacheState === McpServerCacheState.Unknown || cacheState === McpServerCacheState.Outdated)) {
+                getBucket({
+                    type: "mcp",
+                    definitionId: server.definition.id,
+                    label: server.definition.label,
+                    instructions: "",
+                    serverLabel: "",
+                    collectionId: server.collection.id
+                });
+            }
+        }
+        const sortedBuckets = Array.from(( bucketMap.values())).sort((a, b) => {
+            if (a.sortOrder !== b.sortOrder) {
+                return a.sortOrder - b.sortOrder;
+            }
+            return a.label.localeCompare(b.label);
+        });
+        for (const bucket of sortedBuckets) {
+            treeItems.push(bucket);
+            bucket.children.sort((a, b) => a.label.localeCompare(b.label));
+            for (const child of bucket.children) {
+                if (isToolSetTreeItem(child) && child.children) {
+                    child.children.sort((a, b) => a.label.localeCompare(b.label));
+                }
+            }
+        }
+        for (const bucket of sortedBuckets) {
+            const isMcpBucket = bucket.ordinal === BucketOrdinal.Mcp;
+            const addConfirmationButton = toolItem => {
+                if (!confirmationService.toolCanManageConfirmation(toolItem.tool)) {
+                    return;
+                }
+                const tool = toolItem.tool;
+                const manageTools = isMcpBucket ? bucket.children.flatMap(
+                    c => isToolTreeItem(c) ? [c.tool] : isToolSetTreeItem(c) && c.children ? ( c.children.filter(isToolTreeItem).map(gc => gc.tool)) : []
+                ) : [tool];
+                const buttons = toolItem.buttons ? [...toolItem.buttons] : [];
+                buttons.push({
+                    iconClass: ThemeIcon.asClassName(Codicon.pass),
+                    tooltip: ( localize(5031, "Manage Approval")),
+                    keepOpen: true,
+                    action: () => confirmationService.manageConfirmationPreferences(manageTools, {
+                        focusToolId: tool.id
+                    })
+                });
+                toolItem.buttons = buttons;
+            };
+            for (const child of bucket.children) {
+                if (isToolTreeItem(child)) {
+                    addConfirmationButton(child);
+                } else if (isToolSetTreeItem(child) && child.children) {
+                    for (const grandchild of child.children) {
+                        if (isToolTreeItem(grandchild)) {
+                            addConfirmationButton(grandchild);
+                        }
+                    }
+                }
+            }
+        }
+        if (treeItems.length === 0) {
+            treePicker.placeholder = ( localize(5032, "Add tools to chat"));
+        } else {
+            treePicker.placeholder = placeHolder;
+        }
+        treePicker.setItemTree(treeItems);
+    }
+    const store = ( new DisposableStore());
+    const treePicker = store.add(quickPickService.createQuickTree());
+    treePicker.placeholder = placeHolder;
+    treePicker.description = description;
+    treePicker.matchOnDescription = true;
+    treePicker.matchOnLabel = true;
+    treePicker.sortByLabel = false;
+    computeItems();
+    store.add(treePicker.onDidTriggerItemButton(e => {
+        if (e.button && typeof e.button.action === "function") {
+            const actionableButton = e.button;
+            actionableButton.action();
+            store.dispose();
+        }
+    }));
+    const collectResults = () => {
+        const result = ( new Map());
+        const traverse = items => {
+            for (const item of items) {
+                if (isBucketTreeItem(item)) {
+                    if (item.toolset) {
+                        const allChecked = item.checked === true;
+                        result.set(item.toolset, allChecked);
+                    }
+                    traverse(item.children);
+                } else if (isToolSetTreeItem(item)) {
+                    result.set(item.toolset, item.checked === true);
+                    if (item.children) {
+                        traverse(item.children);
+                    }
+                } else if (isToolTreeItem(item)) {
+                    result.set(item.tool, item.checked || result.get(item.tool) === true);
+                }
+            }
+        };
+        traverse(treePicker.itemTree);
+        return result;
+    };
+    let didAccept = false;
+    const didAcceptFinalItem = store.add(( new Emitter()));
+    store.add(treePicker.onDidAccept(() => {
+        const activeItems = treePicker.activeItems;
+        const callbackItem = activeItems.find(isCallbackTreeItem);
+        if (!callbackItem) {
+            didAccept = true;
+            treePicker.hide();
+            return;
+        }
+        const ret = callbackItem.run();
+        if (ret !== false) {
+            didAcceptFinalItem.fire();
+        }
+    }));
+    const addMcpServerButton = {
+        iconClass: ThemeIcon.asClassName(Codicon.mcp),
+        tooltip: ( localize(5033, "Add MCP Server..."))
+    };
+    const installExtension = {
+        iconClass: ThemeIcon.asClassName(Codicon.extensions),
+        tooltip: ( localize(5034, "Install Extension..."))
+    };
+    const configureToolSets = {
+        iconClass: ThemeIcon.asClassName(Codicon.gear),
+        tooltip: ( localize(5035, "Configure Tool Sets..."))
+    };
+    treePicker.title = ( localize(5036, "Configure Tools"));
+    treePicker.buttons = [addMcpServerButton, installExtension, configureToolSets];
+    store.add(treePicker.onDidTriggerButton(button => {
+        if (button === addMcpServerButton) {
+            commandService.executeCommand(McpCommandIds.AddConfiguration);
+        } else if (button === installExtension) {
+            extensionsWorkbenchService.openSearch("@tag:language-model-tools");
+        } else if (button === configureToolSets) {
+            commandService.executeCommand(ConfigureToolSets.ID);
+        }
+        treePicker.hide();
+    }));
+    if (token) {
+        store.add(token.onCancellationRequested(() => {
+            treePicker.hide();
+        }));
+    }
+    const initialState = collectResults();
+    treePicker.show();
+    await Promise.race([
+        Event.toPromise(Event.any(treePicker.onDidHide, didAcceptFinalItem.event), store)
+    ]);
+    sendDidChangeEvent(source, telemetryService, initialState, collectResults(), mcpRegistry);
+    store.dispose();
+    return didAccept ? collectResults() : undefined;
+}
+function categorizeTool(item, mcpRegistry) {
+    const source = item.source;
+    switch (source.type) {
+    case "internal":
+        return {
+            category: "builtin",
+            name: item.id
+        };
+    case "extension":
+        return {
+            category: "extension",
+            name: item.id,
+            extensionId: source.extensionId.value
+        };
+    case "mcp":
+        {
+            const collection = mcpRegistry.collections.get().find(c => c.id === source.collectionId);
+            if (collection?.source instanceof ExtensionIdentifier) {
+                return {
+                    category: "extension-mcp",
+                    extensionId: collection.source.value
+                };
+            }
+            return {
+                category: "user-mcp"
+            };
+        }
+    case "user":
+        return {
+            category: "user-toolset"
+        };
+    case "external":
+        return {
+            category: "user-toolset"
+        };
+    default:
+        assertNever();
+    }
+}
+function computeToolToggleSummary(initialState, finalState, mcpRegistry) {
+    const summary = {
+        builtinEnabled: 0,
+        builtinDisabled: 0,
+        extensionEnabled: 0,
+        extensionDisabled: 0,
+        extensionMcpEnabled: 0,
+        extensionMcpDisabled: 0,
+        userMcpEnabled: 0,
+        userMcpDisabled: 0,
+        userToolsetEnabled: 0,
+        userToolsetDisabled: 0,
+        details: ""
+    };
+    const detailItems = [];
+    for (const [item, finalEnabled] of finalState) {
+        const initialEnabled = initialState.get(item) ?? false;
+        if (initialEnabled === finalEnabled) {
+            continue;
+        }
+        const categorized = categorizeTool(item, mcpRegistry);
+        const enabled = finalEnabled;
+        switch (categorized.category) {
+        case "builtin":
+            if (enabled) {
+                summary.builtinEnabled++;
+            } else {
+                summary.builtinDisabled++;
+            }
+            detailItems.push({
+                category: "builtin",
+                name: categorized.name,
+                enabled
+            });
+            break;
+        case "extension":
+            if (enabled) {
+                summary.extensionEnabled++;
+            } else {
+                summary.extensionDisabled++;
+            }
+            detailItems.push({
+                category: "extension",
+                name: categorized.name,
+                extensionId: categorized.extensionId,
+                enabled
+            });
+            break;
+        case "extension-mcp":
+            if (enabled) {
+                summary.extensionMcpEnabled++;
+            } else {
+                summary.extensionMcpDisabled++;
+            }
+            detailItems.push({
+                category: "extension-mcp",
+                extensionId: categorized.extensionId,
+                enabled
+            });
+            break;
+        case "user-mcp":
+            if (enabled) {
+                summary.userMcpEnabled++;
+            } else {
+                summary.userMcpDisabled++;
+            }
+            detailItems.push({
+                category: "user-mcp",
+                enabled
+            });
+            break;
+        case "user-toolset":
+            if (enabled) {
+                summary.userToolsetEnabled++;
+            } else {
+                summary.userToolsetDisabled++;
+            }
+            detailItems.push({
+                category: "user-toolset",
+                enabled
+            });
+            break;
+        }
+    }
+    summary.details = JSON.stringify(detailItems);
+    return summary;
+}
+function sendDidChangeEvent(source, telemetryService, initialState, finalState, mcpRegistry) {
+    const summary = computeToolToggleSummary(initialState, finalState, mcpRegistry);
+    const changed = summary.builtinEnabled > 0 || summary.builtinDisabled > 0 || summary.extensionEnabled > 0 || summary.extensionDisabled > 0 || summary.extensionMcpEnabled > 0 || summary.extensionMcpDisabled > 0 || summary.userMcpEnabled > 0 || summary.userMcpDisabled > 0 || summary.userToolsetEnabled > 0 || summary.userToolsetDisabled > 0;
+    telemetryService.publicLog2("chatToolPickerClosed", {
+        source,
+        changed,
+        builtinEnabled: summary.builtinEnabled,
+        builtinDisabled: summary.builtinDisabled,
+        extensionEnabled: summary.extensionEnabled,
+        extensionDisabled: summary.extensionDisabled,
+        extensionMcpEnabled: summary.extensionMcpEnabled,
+        extensionMcpDisabled: summary.extensionMcpDisabled,
+        userMcpEnabled: summary.userMcpEnabled,
+        userMcpDisabled: summary.userMcpDisabled,
+        userToolsetEnabled: summary.userToolsetEnabled,
+        userToolsetDisabled: summary.userToolsetDisabled,
+        details: summary.details
+    });
+}
+
+export { showToolsPicker };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentSessionApprovalModel.d.ts

@@ -6,6 +6,7 @@ import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/
 export interface IAgentSessionApprovalInfo {
     readonly label: string;
     readonly languageId: string | undefined;
+    readonly since: Date;
     confirm(): void;
 }
 /**

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentSessionApprovalModel.js

@@ -90,6 +90,7 @@ let AgentSessionApprovalModel = class AgentSessionApprovalModel extends Disposab
                     setIfChanged({
                         label,
                         languageId,
+                        since: ( new Date()),
                         confirm: () => confirmState.confirm({
                             type: ToolConfirmKind.UserAction
                         })