@codingame/monaco-vscode-api 37.6.1 → 38.0.1

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

@@ -0,0 +1,911 @@
+
+import { registerCss } from '../../../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as chatSubagentOpenChat from './media/chatSubagentOpenChat.css';
+import { WindowIntervalTimer, $, EventType, addDisposableListener, EventHelper, isHTMLElement } from '../../../../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../../../../base/browser/keyboardEvent.js';
+import { BaseActionViewItem } from '../../../../../../base/browser/ui/actionbar/actionViewItems.js';
+import { createPixelSpinner } from '../../../../../../base/browser/ui/pixelSpinner/pixelSpinner.js';
+import { Action } from '../../../../../../base/common/actions.js';
+import { Codicon } from '../../../../../../base/common/codicons.js';
+import { Emitter } from '../../../../../../base/common/event.js';
+import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
+import { KeyCode } from '../../../../../../base/common/keyCodes.js';
+import { toDisposable, MutableDisposable, DisposableStore, Disposable } from '../../../../../../base/common/lifecycle.js';
+import { equals } from '../../../../../../base/common/objects.js';
+import { ThemeIcon } from '../../../../../../base/common/themables.js';
+import { URI } from '../../../../../../base/common/uri.js';
+import { localize, localize2 } from '../../../../../../nls.js';
+import { IAccessibilityService } from '../../../../../../platform/accessibility/common/accessibility.service.js';
+import { IActionViewItemService } from '../../../../../../platform/actions/browser/actionViewItemService.service.js';
+import { Action2, MenuId, registerAction2, MenuItemAction } from '../../../../../../platform/actions/common/actions.js';
+import { parseChatUri } from '../../../../../../platform/agentHost/common/state/sessionState.js';
+import { getReasoningEffortLabel } from '../../../../../../platform/agentHost/common/reasoningEffort.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
+import { IHoverService } from '../../../../../../platform/hover/browser/hover.service.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { IMarkdownRendererService } from '../../../../../../platform/markdown/browser/markdownRenderer.service.js';
+import { INotificationService } from '../../../../../../platform/notification/common/notification.service.js';
+import { Link } from '../../../../../../platform/opener/browser/link.js';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '../../../../../common/contributions.js';
+import { SIDE_GROUP } from '../../../../../services/editor/common/editorService.js';
+import { IWorkbenchEnvironmentService } from '../../../../../services/environment/common/environmentService.service.js';
+import { formatElapsedTime } from '../../../common/chatProgressFormatting.js';
+import { formatCopilotCreditsLabel } from '../../../common/chatService/chatService.js';
+import { CHAT_SUBAGENT_RESOURCE_QUERY_PARAM, CHAT_OPEN_AGENT_HOST_CHAT_COMMAND_ID, ChatConfiguration } from '../../../common/constants.js';
+import { AUTO_RAW_MODEL_ID } from '../../../common/languageModels.js';
+import { ILanguageModelsService } from '../../../common/languageModels.service.js';
+import { IChatWidgetService } from '../../chat.service.js';
+import { getChatMarkdownRenderOptions } from '../chatContentMarkdownRenderer.js';
+import { getModelConfigDisplayValues, MODEL_CONFIG_GROUP_EFFORT, MODEL_CONFIG_GROUP_CONTEXT, getModelConfigProperty, getModelConfigValueLabel } from '../input/modelPicker/modelPickerModelConfig.js';
+import { renderFileWidgets } from './chatInlineAnchorWidget.js';
+import { IChatMarkdownAnchorService } from './chatMarkdownAnchorService.service.js';
+import { getCompactCodicon } from '../../chatIcons.js';
+
+registerCss(chatSubagentOpenChat, 1);
+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 asInlineSubagentDetailsContext(context) {
+    if (context && typeof context === "object") {
+        const candidate = context;
+        if (candidate.presentation === "inline" && typeof candidate.expanded === "boolean" && typeof candidate.contentId === "string" && typeof candidate.toggleDetails === "function") {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function getSubagentEditorResource(context) {
+    if (!context.parentSessionResource) {
+        return undefined;
+    }
+    try {
+        ( URI.parse(context.chatResource, true));
+        const parentSessionResource = ( URI.parse(context.parentSessionResource, true));
+        const query = ( new URLSearchParams(parentSessionResource.query));
+        query.set(CHAT_SUBAGENT_RESOURCE_QUERY_PARAM, context.chatResource);
+        return parentSessionResource.with({
+            fragment: parseChatUri(context.chatResource)?.chatId ?? context.chatResource,
+            query: ( query.toString())
+        });
+    } catch {
+        return undefined;
+    }
+}
+function shouldShowSubagentModel(
+    subagentModelName,
+    parentModelId,
+    parentModelName,
+    parentModelMetadataId,
+    subagentModelId
+) {
+    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;
+    if (autoCandidates.includes(AUTO_RAW_MODEL_ID)) {
+        return true;
+    }
+    if (subagentModelId && parentModelId) {
+        return subagentModelId !== parentModelId;
+    }
+    return !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,
+    run = async context => {
+        await action.run(context);
+    }
+) {
+    const proxy = ( new Action(action.id, action.label, action.class, false, async context => {
+        const inlineContext = asInlineSubagentDetailsContext(context);
+        if (inlineContext) {
+            inlineContext.toggleDetails();
+        } else {
+            await run(context);
+        }
+    }));
+    proxy.tooltip = action.tooltip;
+    return proxy;
+}
+function createEditorOpenSubagentAction(action, chatWidgetService, notificationService) {
+    return createOpenSubagentAction(action, async rawContext => {
+        const context = asOpenSubagentChatContext(rawContext);
+        const resource = context && getSubagentEditorResource(context);
+        if (!resource) {
+            notificationService.error(( localize(13915, "The subagent chat could not be opened.")));
+            return;
+        }
+        await chatWidgetService.openSession(resource, SIDE_GROUP, {
+            pinned: true,
+            revealIfOpened: true,
+            title: context.title ? {
+                preferred: context.title
+            } : undefined
+        });
+    });
+}
+class OpenSubagentChatAction extends Action2 {
+    constructor() {
+        super({
+            id: CHAT_OPEN_AGENT_HOST_CHAT_COMMAND_ID,
+            title: ( localize2(13916, "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(13915, "The subagent chat could not be opened.")));
+            return;
+        }
+        await chatWidgetService.openSession(resource, SIDE_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._activeToolDisposables = 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 = options.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();
+            }
+        }));
+        this._register(this.languageModelsService.onDidChangeLanguageModels(() => {
+            this._updateModelConfiguration();
+            this.updateTooltip();
+        }));
+    }
+    render(container) {
+        this._container = container;
+        container.classList.add("chat-subagent-pill-widget");
+        container.setAttribute("role", "presentation");
+        this._iconElement = $("span.chat-subagent-pill-icon");
+        this._statusIconElement = $(
+            `span.chat-subagent-pill-open-icon${ThemeIcon.asCSSSelector(Codicon.commentDiscussion)}`
+        );
+        this._iconElement.appendChild(this._statusIconElement);
+        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;
+        super.render(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");
+        for (const eventType of [EventType.KEY_DOWN, EventType.KEY_UP]) {
+            this._register(
+                addDisposableListener(this._activeToolElement, eventType, event => event.stopPropagation())
+            );
+        }
+        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(pillContent, EventType.DRAG_START, event => {
+                const context = this.navigationContext;
+                if (!this.action.enabled || !context || !this._dragDataProvider?.(context, event)) {
+                    event.preventDefault();
+                }
+            }));
+            this._register(addDisposableListener(pillContent, 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 = this.navigationContext;
+        if (!this.action.enabled || !context) {
+            return false;
+        }
+        this.actionRunner.run(this.action, {
+            ...context,
+            toSide: true
+        });
+        return true;
+    }
+    setActionContext(newContext) {
+        const previousResource = this.navigationContext?.chatResource;
+        super.setActionContext(newContext);
+        const resource = this.navigationContext?.chatResource;
+        if (resource !== previousResource) {
+            this._trackedEnabled = undefined;
+            this._resolvedTitle = undefined;
+            this._reportedModelName = undefined;
+            this._restartEnabledTracker();
+        }
+        this._update();
+    }
+    get navigationContext() {
+        return asOpenSubagentChatContext(this._context);
+    }
+    get pillContext() {
+        return this.navigationContext ?? asInlineSubagentDetailsContext(this._context);
+    }
+    get modelName() {
+        return this.pillContext?.modelName;
+    }
+    get showModel() {
+        const context = this.pillContext;
+        const parentModel = context?.parentModelId ? this.languageModelsService.lookupLanguageModel(context.parentModelId) : undefined;
+        return shouldShowSubagentModel(
+            this.modelName,
+            context?.parentModelId,
+            context?.parentModelName ?? parentModel?.name,
+            context?.parentResolvedModelId ?? parentModel?.id,
+            context?.modelId
+        );
+    }
+    get isActive() {
+        return this.pillContext?.isActive === true;
+    }
+    get activityLabel() {
+        return localize(13917, "Working on it...");
+    }
+    get activityAriaLabel() {
+        return this._displayedToolAccessibleLabel;
+    }
+    _update() {
+        if (!this.element) {
+            return;
+        }
+        const context = this.pillContext;
+        const navigationContext = this.navigationContext;
+        const enabled = this._trackedEnabled ?? (!!navigationContext && !!getSubagentEditorResource(navigationContext));
+        this._setEnabled(enabled);
+        this._setResolvedTitle(context?.title || this._resolvedTitle);
+        this._setAgentType(context?.agentType);
+        this._reportedModelName = this.modelName;
+        this._setModelName(this.showModel ? this._reportedModelName : undefined);
+        this._updateModelConfiguration();
+        this._setCredits(context?.credits);
+        this._updateConfirmationCount(context);
+        this._updateStatus();
+        this._updateDuration(context);
+        const showActivity = this.isActive;
+        const activeToolLabel = showActivity ? context?.activeToolLabel : undefined;
+        this._setActiveTool(
+            showActivity ? activeToolLabel ?? ((context?.confirmationCount ?? 0) > 0 ? ( localize(13918, "Waiting for input")) : this.activityLabel) : undefined,
+            showActivity ? context?.activeToolIcon ?? (activeToolLabel ? undefined : Codicon.comment) : undefined,
+            showActivity ? context?.activeToolCallId : undefined,
+            !!activeToolLabel,
+            showActivity ? context?.activeToolSubagent : undefined
+        );
+        this.updateTooltip();
+        this.updateEnabled();
+        this.updateAriaLabel();
+    }
+    trackEnabled(tracker) {
+        this._enabledTrackerFactory = tracker;
+        this._restartEnabledTracker();
+    }
+    setDragDataProvider(provider) {
+        this._dragDataProvider = provider;
+    }
+    _restartEnabledTracker() {
+        const context = this.navigationContext;
+        if (!context || !this._enabledTrackerFactory) {
+            this._enabledTracker.clear();
+            return;
+        }
+        this._enabledTracker.value = this._enabledTrackerFactory(context, enabled => {
+            this._trackedEnabled = enabled;
+            this._setEnabled(enabled);
+        });
+    }
+    _setEnabled(enabled) {
+        const context = this.navigationContext;
+        const canOpen = !!asInlineSubagentDetailsContext(this._context) || (enabled && !!context && 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);
+        }
+    }
+    _updateModelConfiguration() {
+        const context = this.pillContext;
+        const metadata = context?.modelId ? this.languageModelsService.lookupLanguageModel(context.modelId) : undefined;
+        const model = context?.modelId && metadata ? {
+            identifier: context.modelId,
+            metadata
+        } : undefined;
+        const configurationAccess = {
+            getModelConfiguration: () => context?.modelConfiguration
+        };
+        const values = getModelConfigDisplayValues(model, configurationAccess);
+        let effort = values.find(value => value.group === MODEL_CONFIG_GROUP_EFFORT)?.description;
+        let contextWindow = values.find(value => value.group === MODEL_CONFIG_GROUP_CONTEXT)?.description;
+        const runtime = context?.runtimeModelConfiguration;
+        if (runtime?.reasoningEffort) {
+            effort = ( localize(
+                13919,
+                "Reasoning effort: {0}",
+                getReasoningEffortLabel(runtime.reasoningEffort)
+            ));
+        }
+        if (runtime?.contextTier) {
+            const property = getModelConfigProperty(model, configurationAccess, MODEL_CONFIG_GROUP_CONTEXT);
+            const value = runtime.contextTier === "long_context" ? property?.schema.enum?.at(-1) : runtime.contextTier === "default" ? property?.schema.default : undefined;
+            const label = property && value !== undefined ? getModelConfigValueLabel(property.schema, value) : runtime.contextTier === "long_context" ? ( localize(13920, "Long context")) : runtime.contextTier === "default" ? ( localize(13921, "Default")) : runtime.contextTier;
+            contextWindow = ( localize(13922, "Context window: {0}", label));
+        }
+        this._modelConfigurationDescription = [effort, contextWindow].filter(Boolean).join(", ") || undefined;
+    }
+    _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);
+        }
+    }
+    get status() {
+        const context = this.pillContext;
+        return (context?.confirmationCount ?? 0) > 0 ? "waiting" : this.isActive ? "running" : context?.isActive === false ? "completed" : undefined;
+    }
+    get statusIcon() {
+        return Codicon.commentDiscussion;
+    }
+    _updateStatus() {
+        const status = this.status;
+        if (this._statusIconElement) {
+            this._statusIconElement.className = `chat-subagent-pill-open-icon ${ThemeIcon.asClassName(this.statusIcon)}`;
+        }
+        if (status === this._renderedStatus) {
+            return;
+        }
+        this._renderedStatus = status;
+        const waiting = status === "waiting";
+        const running = status === "running";
+        this._container?.classList.toggle("chat-subagent-running", running);
+        this._container?.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._container?.classList.toggle("chat-subagent-needs-confirmation", count > 0);
+        this._container?.classList.toggle("chat-subagent-has-multiple-confirmations", count > 1);
+        this._container?.classList.toggle("chat-subagent-confirmation-active", count > 0 && confirmationActive);
+        this._container?.classList.toggle("chat-subagent-confirmation-pending", count > 0 && !confirmationActive);
+        if (this._confirmationCountElement) {
+            this._confirmationCountElement.textContent = String(count);
+        }
+    }
+    get duration() {
+        return this.pillContext?.duration;
+    }
+    get showDuration() {
+        return true;
+    }
+    get durationLabel() {
+        return this._durationElement?.textContent ?? undefined;
+    }
+    _updateDuration(context) {
+        this._durationTimer.cancel();
+        const startedAt = context?.startedAt;
+        const durationValue = this.duration;
+        if (!this._durationElement || startedAt === undefined || !this.showDuration) {
+            this._durationElement?.classList.add("hidden");
+            if (this._durationElement) {
+                this._durationElement.textContent = "";
+            }
+            return;
+        }
+        const update = () => {
+            const duration = formatCompactSubagentDuration(startedAt, durationValue);
+            this._durationElement.textContent = this._showElapsedOnly ? duration : durationValue === undefined ? ( localize(13923, "Working for {0}", duration)) : ( localize(13924, "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, subagent) {
+        this._targetToolLabel = label;
+        this._targetToolIcon = icon;
+        this._targetToolCallId = toolCallId;
+        this._targetToolSubagent = subagent;
+        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._activeToolDisposables.clear();
+            this._activeToolLabelElement.textContent = "";
+            this._displayedToolLabel = undefined;
+            this._displayedToolIcon = undefined;
+            this._displayedToolCallId = undefined;
+            this._displayedToolSubagent = 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, subagent);
+            return;
+        }
+        this._runToolTransition();
+    }
+    _runToolTransition() {
+        if (!this._activeToolLabelElement || this._toolTransitionPhase !== "idle") {
+            return;
+        }
+        if (!shouldAnimateSubagentToolTransition(
+            this._displayedToolCallId,
+            this._displayedActivityIsTool,
+            this._targetToolCallId,
+            this._targetActivityIsTool
+        )) {
+            this._setDisplayedTool(
+                this._targetToolLabel ?? "",
+                this._targetToolIcon,
+                this._targetToolCallId,
+                this._targetActivityIsTool,
+                this._targetToolSubagent
+            );
+            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,
+                this._targetToolSubagent
+            );
+            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,
+                this._targetToolSubagent
+            );
+        }
+    }
+    _setDisplayedTool(label, icon, toolCallId, isTool, subagent) {
+        if (!this._activeToolLabelElement) {
+            return;
+        }
+        const sameIcon = icon === this._displayedToolIcon || (icon !== undefined && this._displayedToolIcon !== undefined && ThemeIcon.isEqual(icon, this._displayedToolIcon));
+        if (this._activeToolLabelElement.hasChildNodes() && label === this._displayedToolLabel && sameIcon && toolCallId === this._displayedToolCallId && isTool === this._displayedActivityIsTool && equals(subagent, this._displayedToolSubagent)) {
+            return;
+        }
+        this._activeToolRendered.clear();
+        this._activeToolDisposables.clear();
+        this._activeToolLabelElement.textContent = "";
+        if (subagent) {
+            this._activeToolLabelElement.classList.remove("rendered-markdown");
+            const context = subagent.chatResource ? {
+                chatResource: subagent.chatResource,
+                parentSessionResource: this.pillContext?.parentSessionResource,
+                title: subagent.title
+            } : undefined;
+            const action = this._activeToolDisposables.add(createOpenSubagentAction(this._action));
+            const descriptor = {
+                label,
+                href: "#"
+            };
+            const link = this._activeToolDisposables.add(
+                this.instantiationService.createInstance(Link, this._activeToolLabelElement, descriptor, {
+                    opener: () => {
+                        this.actionRunner.run(action, context);
+                    }
+                })
+            );
+            const updateEnabled = enabled => {
+                action.enabled = link.enabled = enabled && subagent.isChatAvailable !== false;
+                link.link = {
+                    ...descriptor,
+                    title: link.enabled ? ( localize(13925, "Open subagent chat to the side: {0}", subagent.title)) : ( localize(13926, "Subagent chat is not available yet."))
+                };
+            };
+            updateEnabled(!!context && !!getSubagentEditorResource(context));
+            if (context && this._enabledTrackerFactory) {
+                this._activeToolDisposables.add(this._enabledTrackerFactory(context, updateEnabled));
+            }
+        } else {
+            const rendered = this.markdownRendererService.render(( new MarkdownString(label)), getChatMarkdownRenderOptions(), this._activeToolLabelElement);
+            this._activeToolRendered.value = rendered;
+            renderFileWidgets(
+                rendered.element,
+                this.instantiationService,
+                this.chatMarkdownAnchorService,
+                this._activeToolDisposables
+            );
+        }
+        this._displayedToolLabel = label;
+        this._displayedToolIcon = icon;
+        this._displayedToolCallId = toolCallId;
+        this._displayedToolSubagent = subagent;
+        this._displayedToolAccessibleLabel = this._activeToolLabelElement.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(13926, "Subagent chat is not available yet.")));
+        } else if (this._confirmationCount > 0 && !asInlineSubagentDetailsContext(this._context)) {
+            details.push(this._confirmationCount === 1 ? ( localize(13927, "Open subagent chat (1 confirmation needed)")) : ( localize(
+                13928,
+                "Open subagent chat ({0} confirmations needed)",
+                this._confirmationCount
+            )));
+        } else {
+            details.push(this.getActionLabel());
+        }
+        if (this._reportedAgentType) {
+            details.push(( localize(13929, "Subagent type: {0}", this._reportedAgentType)));
+        }
+        if (this._reportedModelName) {
+            details.push(( localize(13930, "Model: {0}", this._reportedModelName)));
+        }
+        if (this._modelConfigurationDescription) {
+            details.push(this._modelConfigurationDescription);
+        }
+        if (this._reportedCredits !== undefined && this._showCreditUsage) {
+            details.push(formatCopilotCreditsLabel(this._reportedCredits));
+        }
+        if (this._displayedToolSubagent) {
+            details.push(( localize(13931, "Subagent: {0}", this._displayedToolSubagent.title)));
+        } else if (this._displayedToolAccessibleLabel && this._displayedActivityIsTool) {
+            details.push(( localize(13932, "Active tool: {0}", this._displayedToolAccessibleLabel)));
+        }
+        return details.join("\n");
+    }
+    updateTooltip() {
+        this.updateAriaLabel();
+    }
+    updateEnabled() {
+        if (!this.element) {
+            return;
+        }
+        const enabled = this._action.enabled;
+        const hidden = !this.pillContext;
+        this._container?.classList.toggle("disabled", !enabled);
+        this._container?.classList.toggle("hidden", hidden);
+        this.element.setAttribute("role", "button");
+        this.element.draggable = !!this.options.draggable;
+        this.element.setAttribute("aria-disabled", String(!enabled));
+        this.element.setAttribute("aria-hidden", String(hidden));
+        const inlineContext = asInlineSubagentDetailsContext(this._context);
+        if (inlineContext) {
+            this.element.setAttribute("aria-expanded", String(inlineContext.expanded));
+            this.element.setAttribute("aria-controls", inlineContext.contentId);
+        } else {
+            this.element.removeAttribute("aria-expanded");
+            this.element.removeAttribute("aria-controls");
+        }
+    }
+    getActionLabel() {
+        const inlineContext = asInlineSubagentDetailsContext(this._context);
+        if (inlineContext) {
+            return inlineContext.expanded ? ( localize(
+                13933,
+                "Hide subagent details: {0}",
+                this._resolvedTitle ?? this._action.label
+            )) : ( localize(
+                13934,
+                "Show subagent details: {0}",
+                this._resolvedTitle ?? this._action.label
+            ));
+        }
+        return this._resolvedTitle ? this._action.enabled ? ( localize(13935, "Open subagent chat: {0}", this._resolvedTitle)) : ( localize(13936, "Subagent: {0}", this._resolvedTitle)) : this._action.label;
+    }
+    updateAriaLabel() {
+        if (!this.element) {
+            return;
+        }
+        const label = this.getActionLabel();
+        const status = this._renderedStatus === "running" ? ( localize(13937, "Subagent is working")) : this._renderedStatus === "waiting" ? ( localize(13938, "Subagent is waiting for input")) : this._renderedStatus === "completed" ? ( localize(13939, "Subagent completed")) : undefined;
+        const agentType = this._reportedAgentType ? ( localize(13940, "Subagent type {0}", this._reportedAgentType)) : undefined;
+        const model = this._reportedModelName ? ( localize(13941, "Model {0}", this._reportedModelName)) : undefined;
+        const activeTool = this._displayedToolSubagent ? ( localize(13931, "Subagent: {0}", this._displayedToolSubagent.title)) : this._displayedToolAccessibleLabel && this._displayedActivityIsTool ? ( localize(13942, "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,
+            this._modelConfigurationDescription,
+            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 };