@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatSubagentOpenChat.js

@@ -0,0 +1,714 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatSubagentOpenChat from './media/chatSubagentOpenChat.css';
+import { WindowIntervalTimer, $, addDisposableListener, EventType, EventHelper, isHTMLElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { createPixelSpinner } from '@codingame/monaco-vscode-katex-common/vscode/vs/base/browser/ui/pixelSpinner/pixelSpinner';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { toDisposable, MutableDisposable, DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { Action2, MenuId, registerAction2, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { parseChatUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { ACTIVE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { formatElapsedTime } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/chatProgressFormatting';
+import { formatCopilotCreditsLabel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { CHAT_SUBAGENT_RESOURCE_QUERY_PARAM, CHAT_OPEN_AGENT_HOST_CHAT_COMMAND_ID, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { AUTO_RAW_MODEL_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { getChatMarkdownRenderOptions } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatContentMarkdownRenderer';
+import { renderFileWidgets } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatInlineAnchorWidget';
+import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service';
+import { getCompactCodicon } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatIcons';
+
+registerCss(chatSubagentOpenChat);
+class SubagentChatOpenerRegistry {
+    constructor() {
+        this.openers = ( new Set());
+    }
+    register(opener) {
+        this.openers.add(opener);
+        return toDisposable(() => this.openers.delete(opener));
+    }
+    async open(context) {
+        for (const opener of this.openers) {
+            if (await opener.open(context)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+const subagentChatOpenerRegistry = ( new SubagentChatOpenerRegistry());
+function asOpenSubagentChatContext(context) {
+    if (typeof context === "string") {
+        return {
+            chatResource: context
+        };
+    }
+    if (context && typeof context === "object" && typeof context.chatResource === "string") {
+        return context;
+    }
+    return undefined;
+}
+function getSubagentEditorResource(context) {
+    const parsed = parseChatUri(context.chatResource);
+    if (!parsed || !context.parentSessionResource) {
+        return undefined;
+    }
+    try {
+        const parentSessionResource = ( URI.parse(context.parentSessionResource));
+        const query = ( new URLSearchParams(parentSessionResource.query));
+        query.set(CHAT_SUBAGENT_RESOURCE_QUERY_PARAM, context.chatResource);
+        return parentSessionResource.with({
+            fragment: parsed.chatId,
+            query: ( query.toString())
+        });
+    } catch {
+        return undefined;
+    }
+}
+function shouldShowSubagentModel(subagentModelName, parentModelId, parentModelName, parentModelMetadataId) {
+    const normalize = value => value?.trim().toLowerCase();
+    const subagent = normalize(subagentModelName);
+    if (!subagent || subagent === AUTO_RAW_MODEL_ID) {
+        return false;
+    }
+    const parentIdSuffix = parentModelId?.slice(parentModelId.lastIndexOf(":") + 1);
+    const parents = ( [parentModelId, parentIdSuffix, parentModelName, parentModelMetadataId].map(normalize));
+    const autoCandidates = parentModelId ? ( [parentModelId, parentIdSuffix].map(normalize)) : parents;
+    return autoCandidates.includes(AUTO_RAW_MODEL_ID) || !parents.includes(subagent);
+}
+function formatCompactSubagentDuration(startedAt, duration, now = Date.now()) {
+    const end = duration === undefined ? now : startedAt + Math.max(0, duration);
+    return formatElapsedTime(Math.max(0, end - startedAt));
+}
+function shouldAnimateSubagentToolTransition(displayedToolCallId, displayedIsTool, targetToolCallId, targetIsTool) {
+    if (!displayedIsTool && !targetIsTool) {
+        return false;
+    }
+    return displayedIsTool !== targetIsTool || displayedToolCallId !== targetToolCallId;
+}
+function createOpenSubagentAction(action) {
+    const proxy = ( new Action(
+        action.id,
+        action.label,
+        action.class,
+        false,
+        context => action.run(context)
+    ));
+    proxy.tooltip = action.tooltip;
+    return proxy;
+}
+function createEditorOpenSubagentAction(action, chatWidgetService, notificationService) {
+    const proxy = ( new Action(action.id, action.label, action.class, false, async rawContext => {
+        const context = asOpenSubagentChatContext(rawContext);
+        const resource = context && getSubagentEditorResource(context);
+        if (!resource) {
+            notificationService.error(( localize(9440, "The subagent chat could not be opened.")));
+            return;
+        }
+        await chatWidgetService.openSession(resource, ACTIVE_GROUP, {
+            pinned: true,
+            revealIfOpened: true,
+            title: context.title ? {
+                preferred: context.title
+            } : undefined
+        });
+    }));
+    proxy.tooltip = action.tooltip;
+    return proxy;
+}
+class OpenSubagentChatAction extends Action2 {
+    constructor() {
+        super({
+            id: CHAT_OPEN_AGENT_HOST_CHAT_COMMAND_ID,
+            title: ( localize2(9441, "Open Subagent")),
+            icon: Codicon.commentDiscussion,
+            f1: false,
+            menu: {
+                id: MenuId.ChatSubagentContent,
+                group: "navigation"
+            }
+        });
+    }
+    async run(accessor, rawContext) {
+        const notificationService = accessor.get(INotificationService);
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const context = asOpenSubagentChatContext(rawContext);
+        if (!context) {
+            throw ( new Error("Cannot open a subagent chat without a chat resource"));
+        }
+        if (await subagentChatOpenerRegistry.open(context)) {
+            return;
+        }
+        const resource = getSubagentEditorResource(context);
+        if (!resource) {
+            notificationService.error(( localize(9440, "The subagent chat could not be opened.")));
+            return;
+        }
+        await chatWidgetService.openSession(resource, ACTIVE_GROUP, {
+            pinned: true,
+            revealIfOpened: true,
+            title: context.title ? {
+                preferred: context.title
+            } : undefined
+        });
+    }
+}
+registerAction2(OpenSubagentChatAction);
+let OpenSubagentChatActionViewItem = class OpenSubagentChatActionViewItem extends BaseActionViewItem {
+    constructor(
+        context,
+        action,
+        options,
+        openInEditor = false,
+        markdownRendererService,
+        instantiationService,
+        chatMarkdownAnchorService,
+        accessibilityService,
+        chatWidgetService,
+        notificationService,
+        languageModelsService,
+        hoverService,
+        configurationService
+    ) {
+        super(
+            context,
+            openInEditor ? createEditorOpenSubagentAction(action, chatWidgetService, notificationService) : createOpenSubagentAction(action),
+            options
+        );
+        this.markdownRendererService = markdownRendererService;
+        this.instantiationService = instantiationService;
+        this.chatMarkdownAnchorService = chatMarkdownAnchorService;
+        this.accessibilityService = accessibilityService;
+        this.languageModelsService = languageModelsService;
+        this.hoverService = hoverService;
+        this.configurationService = configurationService;
+        this._confirmationCount = 0;
+        this._spinner = this._register(( new MutableDisposable()));
+        this._durationTimer = this._register(( new WindowIntervalTimer()));
+        this._toolTransition = this._register(( new MutableDisposable()));
+        this._activeToolRendered = this._register(( new MutableDisposable()));
+        this._activeToolFileWidgets = this._register(( new DisposableStore()));
+        this._pillHover = this._register(( new MutableDisposable()));
+        this._enabledTracker = this._register(( new MutableDisposable()));
+        this._targetActivityIsTool = false;
+        this._displayedActivityIsTool = false;
+        this._toolTransitionPhase = "idle";
+        this._sourceAction = action;
+        this._showElapsedOnly = openInEditor;
+        if (this._action instanceof Action) {
+            this._register(this._action);
+        }
+        this._register(this.accessibilityService.onDidChangeReducedMotion(() => {
+            if (this.accessibilityService.isMotionReduced()) {
+                this._finishToolTransition();
+            }
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(ChatConfiguration.SubagentsShowCreditUsage)) {
+                this._updateCredits();
+                this.updateTooltip();
+            }
+        }));
+    }
+    render(container) {
+        super.render(container);
+        container.classList.add("chat-subagent-pill-widget");
+        container.setAttribute("role", "button");
+        this._iconElement = $("span.chat-subagent-pill-icon");
+        this._iconElement.appendChild($(
+            `span.chat-subagent-pill-open-icon${ThemeIcon.asCSSSelector(Codicon.commentDiscussion)}`
+        ));
+        this._agentTypeElement = $("span.chat-subagent-pill-agent-type.hidden");
+        this._labelElement = $("span.chat-subagent-pill-label");
+        this._modelElement = $("span.chat-subagent-pill-model.hidden");
+        this._confirmationCountElement = $("span.chat-subagent-pill-confirmation-count");
+        const pillContent = $("span.chat-subagent-pill-content");
+        this._pillContentElement = pillContent;
+        const pillHeader = $("span.chat-subagent-pill-header");
+        this._durationElement = $("span.chat-subagent-pill-duration.hidden");
+        this._creditsElement = $("span.chat-subagent-pill-credits.hidden");
+        this._activeToolElement = $("span.chat-subagent-pill-active-tool.hidden");
+        this._activeToolElement.inert = true;
+        const connector = $("span.chat-subagent-pill-active-tool-connector");
+        connector.setAttribute("aria-hidden", "true");
+        this._activeToolIconElement = $("span.chat-subagent-pill-active-tool-icon");
+        this._activeToolIconElement.setAttribute("aria-hidden", "true");
+        this._activeToolLabelElement = $(".chat-subagent-pill-active-tool-label");
+        this._activeToolElement.append(connector, this._activeToolIconElement, this._activeToolLabelElement);
+        pillContent.append(
+            this._iconElement,
+            this._agentTypeElement,
+            this._labelElement,
+            this._modelElement,
+            this._confirmationCountElement
+        );
+        pillHeader.append(pillContent, this._durationElement, this._creditsElement);
+        container.append(pillHeader, this._activeToolElement);
+        this._pillHover.value = this.hoverService.setupDelayedHover(pillContent, () => ({
+            content: this.getTooltip() ?? ""
+        }));
+        if (this.options.draggable) {
+            this._register(addDisposableListener(container, EventType.DRAG_START, event => {
+                const context = asOpenSubagentChatContext(this._context);
+                if (!this.action.enabled || !context || !this._dragDataProvider?.(context, event)) {
+                    event.preventDefault();
+                }
+            }));
+            this._register(addDisposableListener(container, EventType.KEY_DOWN, event => {
+                const keyboardEvent = ( new StandardKeyboardEvent(event));
+                if (keyboardEvent.altKey && keyboardEvent.keyCode === KeyCode.Enter) {
+                    EventHelper.stop(event, true);
+                    this._openToSide();
+                }
+            }));
+        }
+        this._update();
+    }
+    onClick(event, preserveFocus = false) {
+        const target = event.target;
+        if (!this._pillContentElement || !isHTMLElement(target) || !this._pillContentElement.contains(target)) {
+            EventHelper.stop(event, true);
+            return;
+        }
+        if (event.altKey) {
+            if (this._openToSide()) {
+                EventHelper.stop(event, true);
+                return;
+            }
+        }
+        super.onClick(event, preserveFocus);
+    }
+    _openToSide() {
+        const context = asOpenSubagentChatContext(this._context);
+        if (!this.action.enabled || !context) {
+            return false;
+        }
+        this.actionRunner.run(this.action, {
+            ...context,
+            toSide: true
+        });
+        return true;
+    }
+    setActionContext(newContext) {
+        const previousResource = asOpenSubagentChatContext(this._context)?.chatResource;
+        super.setActionContext(newContext);
+        const resource = asOpenSubagentChatContext(newContext)?.chatResource;
+        if (resource !== previousResource) {
+            this._trackedEnabled = undefined;
+            this._resolvedTitle = undefined;
+            this._reportedModelName = undefined;
+            this._restartEnabledTracker();
+        }
+        this._update();
+    }
+    _update() {
+        if (!this.element) {
+            return;
+        }
+        const context = asOpenSubagentChatContext(this._context);
+        const enabled = this._trackedEnabled ?? (!!context && !!getSubagentEditorResource(context));
+        this._setEnabled(enabled);
+        this._setResolvedTitle(context?.title || this._resolvedTitle);
+        this._setAgentType(context?.agentType);
+        this._reportedModelName = context?.modelName;
+        const parentModel = context?.parentModelId ? this.languageModelsService.lookupLanguageModel(context.parentModelId) : undefined;
+        const contextModelName = shouldShowSubagentModel(
+            context?.modelName,
+            context?.parentModelId,
+            context?.parentModelName ?? parentModel?.name,
+            context?.parentResolvedModelId ?? parentModel?.id
+        ) ? context?.modelName : undefined;
+        this._setModelName(contextModelName);
+        this._setCredits(context?.credits);
+        this._updateConfirmationCount(context);
+        this._updateStatus(context);
+        this._updateDuration(context);
+        const showActivity = context?.isActive === true && (context.confirmationCount ?? 0) === 0;
+        const activeToolLabel = showActivity ? context.activeToolLabel : undefined;
+        this._setActiveTool(showActivity ? activeToolLabel ?? ( localize(9442, "Working on it...")) : undefined, showActivity ? context.activeToolIcon ?? (activeToolLabel ? undefined : Codicon.comment) : undefined, showActivity ? context.activeToolCallId : undefined, !!activeToolLabel);
+        this.updateTooltip();
+        this.updateEnabled();
+        this.updateAriaLabel();
+    }
+    trackEnabled(tracker) {
+        this._enabledTrackerFactory = tracker;
+        this._restartEnabledTracker();
+    }
+    setDragDataProvider(provider) {
+        this._dragDataProvider = provider;
+    }
+    _restartEnabledTracker() {
+        const context = asOpenSubagentChatContext(this._context);
+        if (!context || !this._enabledTrackerFactory) {
+            this._enabledTracker.clear();
+            return;
+        }
+        this._enabledTracker.value = this._enabledTrackerFactory(context, enabled => {
+            this._trackedEnabled = enabled;
+            this._setEnabled(enabled);
+        });
+    }
+    _setEnabled(enabled) {
+        const canOpen = enabled && asOpenSubagentChatContext(this._context)?.isChatAvailable !== false;
+        this._action.enabled = canOpen;
+        this._sourceAction.enabled = canOpen;
+        this.updateEnabled();
+        this.updateAriaLabel();
+    }
+    _setModelName(modelName) {
+        if (this._modelElement) {
+            this._modelElement.textContent = modelName ?? "";
+            this._modelElement.classList.toggle("hidden", !modelName);
+        }
+    }
+    _setCredits(credits) {
+        this._reportedCredits = typeof credits === "number" && credits > 0 ? credits : undefined;
+        this._updateCredits();
+    }
+    _updateCredits() {
+        const credits = this._reportedCredits;
+        const show = credits !== undefined && this._showCreditUsage;
+        if (this._creditsElement) {
+            this._creditsElement.textContent = show ? formatCopilotCreditsLabel(credits) : "";
+            this._creditsElement.classList.toggle("hidden", !show);
+        }
+    }
+    get _showCreditUsage() {
+        return this.configurationService.getValue(ChatConfiguration.SubagentsShowCreditUsage) === true;
+    }
+    _setAgentType(agentType) {
+        this._reportedAgentType = agentType;
+        if (this._agentTypeElement) {
+            this._agentTypeElement.textContent = agentType ?? "";
+            this._agentTypeElement.classList.toggle("hidden", !agentType);
+        }
+    }
+    _updateStatus(context) {
+        const status = (context?.confirmationCount ?? 0) > 0 ? "waiting" : context?.isActive === true ? "running" : context?.isActive === false ? "completed" : undefined;
+        if (status === this._renderedStatus) {
+            return;
+        }
+        this._renderedStatus = status;
+        const waiting = status === "waiting";
+        const running = status === "running";
+        this.element?.classList.toggle("chat-subagent-running", running);
+        this.element?.classList.toggle("chat-subagent-waiting", waiting);
+        this._spinner.clear();
+        if ((running || waiting) && this._iconElement) {
+            const store = ( new DisposableStore());
+            const spinner = store.add(createPixelSpinner(this._iconElement, {
+                variant: waiting ? "ring" : "grid"
+            }));
+            store.add(toDisposable(() => spinner.element.remove()));
+            this._spinner.value = store;
+        }
+    }
+    _updateConfirmationCount(context) {
+        const count = context?.confirmationCount ?? 0;
+        const confirmationActive = !!context?.confirmationActive;
+        this._confirmationCount = count;
+        this.element?.classList.toggle("chat-subagent-needs-confirmation", count > 0);
+        this.element?.classList.toggle("chat-subagent-has-multiple-confirmations", count > 1);
+        this.element?.classList.toggle("chat-subagent-confirmation-active", count > 0 && confirmationActive);
+        this.element?.classList.toggle("chat-subagent-confirmation-pending", count > 0 && !confirmationActive);
+        if (this._confirmationCountElement) {
+            this._confirmationCountElement.textContent = String(count);
+        }
+    }
+    _updateDuration(context) {
+        this._durationTimer.cancel();
+        const startedAt = context?.startedAt;
+        const durationValue = context?.duration;
+        if (!this._durationElement || startedAt === undefined) {
+            this._durationElement?.classList.add("hidden");
+            return;
+        }
+        const update = () => {
+            const duration = formatCompactSubagentDuration(startedAt, durationValue);
+            this._durationElement.textContent = this._showElapsedOnly ? duration : durationValue === undefined ? ( localize(9443, "Working for {0}", duration)) : ( localize(9444, "Worked for {0}", duration));
+            this.updateAriaLabel();
+        };
+        update();
+        this._durationElement.classList.remove("hidden");
+        if (durationValue === undefined) {
+            this._durationTimer.cancelAndSet(update, 1000);
+        }
+    }
+    _setActiveTool(label, icon, toolCallId, isTool) {
+        this._targetToolLabel = label;
+        this._targetToolIcon = icon;
+        this._targetToolCallId = toolCallId;
+        this._targetActivityIsTool = isTool;
+        if (!this._activeToolElement || !this._activeToolLabelElement || !this._activeToolIconElement) {
+            return;
+        }
+        this._activeToolElement.classList.toggle("hidden", !label);
+        if (!label) {
+            this._toolTransition.clear();
+            this._toolTransitionPhase = "idle";
+            this._clearToolTransitionClasses();
+            this._activeToolRendered.clear();
+            this._activeToolFileWidgets.clear();
+            this._activeToolLabelElement.textContent = "";
+            this._displayedToolLabel = undefined;
+            this._displayedToolIcon = undefined;
+            this._displayedToolCallId = undefined;
+            this._displayedToolAccessibleLabel = undefined;
+            this._displayedActivityIsTool = false;
+            this._renderActiveToolIcon(undefined);
+            return;
+        }
+        if (!this._displayedToolLabel || this.accessibilityService.isMotionReduced()) {
+            this._finishToolTransition();
+            return;
+        }
+        if (this._toolTransitionPhase === "idle" && !shouldAnimateSubagentToolTransition(
+            this._displayedToolCallId,
+            this._displayedActivityIsTool,
+            toolCallId,
+            isTool
+        )) {
+            this._setDisplayedTool(label, icon, toolCallId, isTool);
+            return;
+        }
+        this._runToolTransition();
+    }
+    _runToolTransition() {
+        if (!this._activeToolLabelElement || this._toolTransitionPhase !== "idle") {
+            return;
+        }
+        if (!shouldAnimateSubagentToolTransition(
+            this._displayedToolCallId,
+            this._displayedActivityIsTool,
+            this._targetToolCallId,
+            this._targetActivityIsTool
+        )) {
+            if (this._targetToolLabel !== this._displayedToolLabel || this._targetToolIcon?.id !== this._displayedToolIcon?.id || this._targetToolCallId !== this._displayedToolCallId || this._targetActivityIsTool !== this._displayedActivityIsTool) {
+                this._setDisplayedTool(
+                    this._targetToolLabel ?? "",
+                    this._targetToolIcon,
+                    this._targetToolCallId,
+                    this._targetActivityIsTool
+                );
+            }
+            return;
+        }
+        this._toolTransitionPhase = "out";
+        if (!this._restartToolTransition("chat-subagent-tool-fade-out")) {
+            this._completeToolTransition();
+        }
+    }
+    _completeToolTransition() {
+        this._toolTransition.clear();
+        if (this._toolTransitionPhase === "out") {
+            this._toolTransitionPhase = "in";
+            this._setDisplayedTool(
+                this._targetToolLabel ?? "",
+                this._targetToolIcon,
+                this._targetToolCallId,
+                this._targetActivityIsTool
+            );
+            if (!this._restartToolTransition("chat-subagent-tool-fade-in")) {
+                this._completeToolTransition();
+            }
+            return;
+        }
+        if (this._toolTransitionPhase === "in") {
+            this._clearToolTransitionClasses();
+            this._toolTransitionPhase = "idle";
+            this._runToolTransition();
+        }
+    }
+    _finishToolTransition() {
+        this._toolTransition.clear();
+        this._toolTransitionPhase = "idle";
+        this._clearToolTransitionClasses();
+        if (this._targetToolLabel) {
+            this._setDisplayedTool(
+                this._targetToolLabel,
+                this._targetToolIcon,
+                this._targetToolCallId,
+                this._targetActivityIsTool
+            );
+        }
+    }
+    _setDisplayedTool(label, icon, toolCallId, isTool) {
+        if (!this._activeToolLabelElement) {
+            return;
+        }
+        this._activeToolRendered.clear();
+        this._activeToolFileWidgets.clear();
+        this._activeToolLabelElement.textContent = "";
+        const rendered = this.markdownRendererService.render(( new MarkdownString(label)), getChatMarkdownRenderOptions(), this._activeToolLabelElement);
+        renderFileWidgets(
+            rendered.element,
+            this.instantiationService,
+            this.chatMarkdownAnchorService,
+            this._activeToolFileWidgets
+        );
+        this._activeToolRendered.value = rendered;
+        this._displayedToolLabel = label;
+        this._displayedToolIcon = icon;
+        this._displayedToolCallId = toolCallId;
+        this._displayedToolAccessibleLabel = rendered.element.textContent?.replace(/\s+/g, " ").trim() || label;
+        this._displayedActivityIsTool = isTool;
+        this._renderActiveToolIcon(icon);
+        this.updateTooltip();
+        this.updateAriaLabel();
+    }
+    _renderActiveToolIcon(icon) {
+        if (!this._activeToolIconElement) {
+            return;
+        }
+        this._activeToolIconElement.className = "chat-subagent-pill-active-tool-icon";
+        if (icon) {
+            this._activeToolIconElement.classList.add(...ThemeIcon.asClassNameArray(getCompactCodicon(icon)));
+        }
+    }
+    _clearToolTransitionClasses() {
+        this._activeToolLabelElement?.classList.remove("chat-subagent-tool-fade-in", "chat-subagent-tool-fade-out");
+    }
+    _restartToolTransition(className) {
+        if (!this._activeToolLabelElement) {
+            return false;
+        }
+        this._toolTransition.clear();
+        this._clearToolTransitionClasses();
+        const transition = ( new DisposableStore());
+        const complete = event => {
+            if (event.target === this._activeToolLabelElement) {
+                this._completeToolTransition();
+            }
+        };
+        transition.add(
+            addDisposableListener(this._activeToolLabelElement, EventType.ANIMATION_END, complete)
+        );
+        transition.add(
+            addDisposableListener(this._activeToolLabelElement, "animationcancel", complete)
+        );
+        this._toolTransition.value = transition;
+        this._activeToolLabelElement.classList.add(className);
+        if (this._activeToolLabelElement.getAnimations().length === 0) {
+            this._toolTransition.clear();
+            this._clearToolTransitionClasses();
+            return false;
+        }
+        return true;
+    }
+    _setResolvedTitle(title) {
+        this._resolvedTitle = title;
+        if (this._labelElement) {
+            this._labelElement.textContent = title || this._action.label;
+        }
+    }
+    getTooltip() {
+        const details = [];
+        if (!this._action.enabled) {
+            details.push(( localize(9445, "Subagent chat is not available yet.")));
+        } else if (this._confirmationCount > 0) {
+            details.push(this._confirmationCount === 1 ? ( localize(9446, "Open subagent chat (1 confirmation needed)")) : ( localize(
+                9447,
+                "Open subagent chat ({0} confirmations needed)",
+                this._confirmationCount
+            )));
+        } else {
+            details.push(this._resolvedTitle ? ( localize(9448, "Open subagent chat: {0}", this._resolvedTitle)) : this._action.label);
+        }
+        if (this._reportedAgentType) {
+            details.push(( localize(9449, "Subagent type: {0}", this._reportedAgentType)));
+        }
+        if (this._reportedModelName) {
+            details.push(( localize(9450, "Model: {0}", this._reportedModelName)));
+        }
+        if (this._reportedCredits !== undefined && this._showCreditUsage) {
+            details.push(formatCopilotCreditsLabel(this._reportedCredits));
+        }
+        if (this._displayedToolAccessibleLabel && this._displayedActivityIsTool) {
+            details.push(( localize(9451, "Active tool: {0}", this._displayedToolAccessibleLabel)));
+        }
+        return details.join("\n");
+    }
+    updateTooltip() {
+        this.updateAriaLabel();
+    }
+    updateEnabled() {
+        if (!this.element) {
+            return;
+        }
+        const enabled = this._action.enabled;
+        const hidden = !asOpenSubagentChatContext(this._context);
+        this.element.classList.toggle("disabled", !enabled);
+        this.element.classList.toggle("hidden", hidden);
+        this.element.setAttribute("aria-disabled", String(!enabled));
+        this.element.setAttribute("aria-hidden", String(hidden));
+    }
+    updateAriaLabel() {
+        if (!this.element) {
+            return;
+        }
+        const label = this._resolvedTitle ? this._action.enabled ? ( localize(9448, "Open subagent chat: {0}", this._resolvedTitle)) : ( localize(9452, "Subagent: {0}", this._resolvedTitle)) : this._action.label;
+        const status = this._renderedStatus === "running" ? ( localize(9453, "Subagent is working")) : this._renderedStatus === "waiting" ? ( localize(9454, "Subagent is waiting for input")) : this._renderedStatus === "completed" ? ( localize(9455, "Subagent completed")) : undefined;
+        const agentType = this._reportedAgentType ? ( localize(9456, "Subagent type {0}", this._reportedAgentType)) : undefined;
+        const model = this._reportedModelName ? ( localize(9457, "Model {0}", this._reportedModelName)) : undefined;
+        const activeTool = this._displayedToolAccessibleLabel && this._displayedActivityIsTool ? ( localize(9458, "Active tool {0}", this._displayedToolAccessibleLabel)) : undefined;
+        const duration = this._durationElement?.textContent;
+        const credits = this._creditsElement?.textContent;
+        this.element.setAttribute(
+            "aria-label",
+            [label, agentType, status, model, activeTool, duration, credits].filter(Boolean).join(". ")
+        );
+    }
+};
+OpenSubagentChatActionViewItem = ( __decorate([( __param(4, IMarkdownRendererService)), ( __param(5, IInstantiationService)), ( __param(6, IChatMarkdownAnchorService)), ( __param(7, IAccessibilityService)), ( __param(8, IChatWidgetService)), ( __param(9, INotificationService)), ( __param(10, ILanguageModelsService)), ( __param(11, IHoverService)), ( __param(12, IConfigurationService))], OpenSubagentChatActionViewItem));
+let EditorOpenSubagentChatActionViewItemContribution = class EditorOpenSubagentChatActionViewItemContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.editorOpenSubagentChatActionViewItem";
+    }
+    constructor(actionViewItemService, environmentService) {
+        super();
+        if (environmentService.isSessionsWindow) {
+            return;
+        }
+        const onDidRegister = this._register(( new Emitter()));
+        this._register(actionViewItemService.register(
+            MenuId.ChatSubagentContent,
+            CHAT_OPEN_AGENT_HOST_CHAT_COMMAND_ID,
+            (action, options, instantiationService) => {
+                if (!(action instanceof MenuItemAction)) {
+                    return undefined;
+                }
+                return instantiationService.createInstance(OpenSubagentChatActionViewItem, undefined, action, options, true);
+            },
+            onDidRegister.event
+        ));
+        onDidRegister.fire();
+    }
+};
+EditorOpenSubagentChatActionViewItemContribution = ( __decorate([( __param(0, IActionViewItemService)), ( __param(1, IWorkbenchEnvironmentService))], EditorOpenSubagentChatActionViewItemContribution));
+registerWorkbenchContribution2(
+    EditorOpenSubagentChatActionViewItemContribution.ID,
+    EditorOpenSubagentChatActionViewItemContribution,
+    WorkbenchPhase.BlockStartup
+);
+
+export { OpenSubagentChatActionViewItem, formatCompactSubagentDuration, getSubagentEditorResource, shouldAnimateSubagentToolTransition, shouldShowSubagentModel, subagentChatOpenerRegistry };