@codingame/monaco-vscode-katex-common 32.0.2 → 33.0.9

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

@@ -0,0 +1,502 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as agentHostChatInputPicker from './media/agentHostChatInputPicker.css';
+import { append, $, EventType, addDisposableListener, EventHelper, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Gesture, EventType as EventType$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { SessionConfigKey, KNOWN_AUTO_APPROVE_VALUES } from '../../../../../../platform/agentHost/common/sessionConfigKeys.js';
+import { ClaudeSessionConfigKey } from '../../../../../../platform/agentHost/common/claudeSessionConfigKeys.js';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
+import { StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { ActionListItemKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { IAgentHostSessionWorkingDirectoryResolver } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service';
+import { IAgentHostUntitledProvisionalSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(agentHostChatInputPicker);
+const FILTER_THRESHOLD = 10;
+const LEARN_MORE_VALUE = "__agentHostChatInputPicker.learnMore__";
+const PERMISSION_MODE_LEARN_MORE_URL = "https://code.visualstudio.com/docs/copilot/agents/agent-tools#_permission-levels";
+function getConfigIcon(property, value) {
+    if (property === SessionConfigKey.Isolation) {
+        if (value === "folder") {
+            return Codicon.folder;
+        }
+        if (value === "worktree") {
+            return Codicon.worktree;
+        }
+        return undefined;
+    }
+    if (property === SessionConfigKey.Branch) {
+        return Codicon.gitBranch;
+    }
+    if (property === SessionConfigKey.Mode) {
+        switch (value) {
+        case "plan":
+            return Codicon.checklist;
+        case "autopilot":
+            return Codicon.rocket;
+        case "interactive":
+            return Codicon.comment;
+        }
+    }
+    if (property === SessionConfigKey.AutoApprove) {
+        if (value === "autopilot") {
+            return Codicon.rocket;
+        }
+        if (value === "autoApprove") {
+            return Codicon.warning;
+        }
+        return Codicon.shield;
+    }
+    return undefined;
+}
+function toActionItems(property, items, currentValue) {
+    return (items.map(item => ({
+        kind: ActionListItemKind.Action,
+        label: item.label,
+        description: item.description,
+        group: {
+            title: "",
+            icon: getConfigIcon(property, item.value)
+        },
+        item: {
+            ...item,
+            label: item.value === currentValue ? `${item.label} ${( localize(5207, "(Selected)"))}` : item.label
+        }
+    })));
+}
+function renderPickerTrigger(slot, disabled, disposables, onOpen) {
+    const trigger = append(slot, disabled ? $("span.action-label") : $("a.action-label"));
+    if (disabled) {
+        trigger.setAttribute("aria-readonly", "true");
+    } else {
+        trigger.role = "button";
+        trigger.tabIndex = 0;
+        trigger.setAttribute("aria-haspopup", "listbox");
+        disposables.add(Gesture.addTarget(trigger));
+        for (const eventType of [EventType.CLICK, EventType$1.Tap]) {
+            disposables.add(addDisposableListener(trigger, eventType, e => {
+                EventHelper.stop(e, true);
+                onOpen();
+            }));
+        }
+        disposables.add(addDisposableListener(trigger, EventType.KEY_DOWN, e => {
+            if (e.key === "Enter" || e.key === " ") {
+                EventHelper.stop(e, true);
+                onOpen();
+            }
+        }));
+    }
+    slot.classList.toggle("disabled", disabled);
+    return trigger;
+}
+function toBackendSessionUri(sessionResource) {
+    const scheme = sessionResource.scheme;
+    const prefix = "agent-host-";
+    if (!scheme.startsWith(prefix)) {
+        return undefined;
+    }
+    const provider = scheme.substring(prefix.length);
+    if (!provider) {
+        return undefined;
+    }
+    const rawId = sessionResource.path.replace(/^\//, "");
+    return ( URI.from({
+        scheme: provider,
+        path: `/${rawId}`
+    }));
+}
+function isWellKnownAutoApproveSchema(schema) {
+    if (schema.type !== "string" || !Array.isArray(schema.enum) || schema.enum.length === 0) {
+        return false;
+    }
+    if (!schema.enum.includes("default")) {
+        return false;
+    }
+    return schema.enum.every(value => ( KNOWN_AUTO_APPROVE_VALUES.has(value)));
+}
+const WELL_KNOWN_PICKER_PROPERTIES = ( new Set([
+    SessionConfigKey.Mode,
+    SessionConfigKey.AutoApprove,
+    SessionConfigKey.Permissions,
+    ClaudeSessionConfigKey.PermissionMode
+]));
+function isClaimedByDedicatedPicker(property, schema) {
+    if (property === SessionConfigKey.AutoApprove) {
+        return isWellKnownAutoApproveSchema(schema);
+    }
+    return ( WELL_KNOWN_PICKER_PROPERTIES.has(property));
+}
+let AgentHostChatInputPicker = class AgentHostChatInputPicker extends Disposable {
+    constructor(
+        _widget,
+        _property,
+        _pickerOptions,
+        _agentHostService,
+        _actionWidgetService,
+        _openerService,
+        _workingDirectoryResolver,
+        _workspaceContextService,
+        _provisional
+    ) {
+        super();
+        this._widget = _widget;
+        this._property = _property;
+        this._pickerOptions = _pickerOptions;
+        this._agentHostService = _agentHostService;
+        this._actionWidgetService = _actionWidgetService;
+        this._openerService = _openerService;
+        this._workingDirectoryResolver = _workingDirectoryResolver;
+        this._workspaceContextService = _workspaceContextService;
+        this._provisional = _provisional;
+        this._renderDisposables = this._register(( new DisposableStore()));
+        this._filterDelayer = this._register(( new Delayer(200)));
+        this._subRef = this._register(( new MutableDisposable()));
+        this._initialResolveCts = this._register(( new MutableDisposable()));
+        this._register(this._widget.onDidChangeViewModel(() => {
+            this._reattach();
+        }));
+        const opts = this._pickerOptions;
+        if (opts) {
+            this._register(autorun(reader => {
+                opts.hideChevrons.read(reader);
+                this._renderChip();
+            }));
+        }
+        this._register(this._provisional.onDidChange(sessionResource => {
+            const current = this._widget.viewModel?.sessionResource;
+            if (current && ( current.toString()) === ( sessionResource.toString())) {
+                this._reattach();
+            }
+        }));
+        this._reattach();
+    }
+    render(container) {
+        this._container = container;
+        container.classList.add("agent-host-chat-input-picker-host");
+        container.classList.add(`agent-host-chat-input-picker-host-${this._property}`);
+        this._renderChip();
+    }
+    _reattach() {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const provisionalBackend = sessionResource ? this._provisional.get(sessionResource) : undefined;
+        const backendSession = provisionalBackend ?? (sessionResource ? toBackendSessionUri(sessionResource) : undefined);
+        if (!sessionResource || !backendSession) {
+            this._subRef.clear();
+            this._initialResolved = undefined;
+            this._cancelInitialResolve();
+            this._renderChip();
+            return;
+        }
+        if (isUntitledChatSession(sessionResource) && !provisionalBackend) {
+            this._subRef.clear();
+            if (!this._initialResolved || ( this._initialResolved.sessionResource.toString()) !== ( sessionResource.toString())) {
+                this._initialResolved = undefined;
+                void this._refreshInitialResolved(sessionResource, backendSession);
+            }
+            void this._provisional.getOrCreate(sessionResource, backendSession.scheme, this._readWorkingDirectory());
+            this._renderChip();
+            return;
+        }
+        this._initialResolved = undefined;
+        this._cancelInitialResolve();
+        const ref = this._agentHostService.getSubscription(StateComponents.Session, backendSession);
+        const sub = ref.object;
+        const listener = sub.onDidChange(() => this._renderChip());
+        this._subRef.value = {
+            sub,
+            backendSession,
+            dispose: () => {
+                listener.dispose();
+                ref.dispose();
+            }
+        };
+        this._renderChip();
+    }
+    _cancelInitialResolve() {
+        this._initialResolveCts.value?.cancel();
+        this._initialResolveCts.clear();
+    }
+    async _refreshInitialResolved(sessionResource, backendSession) {
+        this._initialResolveCts.value?.cancel();
+        const cts = ( new CancellationTokenSource());
+        this._initialResolveCts.value = cts;
+        try {
+            const result = await this._agentHostService.resolveSessionConfig({
+                provider: backendSession.scheme,
+                workingDirectory: this._readWorkingDirectory()
+            });
+            if (cts.token.isCancellationRequested || this._widget.viewModel?.sessionResource?.toString() !== ( sessionResource.toString())) {
+                return;
+            }
+            this._initialResolved = {
+                sessionResource,
+                result
+            };
+            this._renderChip();
+        } catch {}
+    }
+    _renderChip() {
+        if (!this._container) {
+            return;
+        }
+        this._renderDisposables.clear();
+        clearNode(this._container);
+        const ctx = this._readContext();
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const isStartedSession = !!sessionResource && !isUntitledChatSession(sessionResource);
+        if (!ctx || (isStartedSession && ctx.schema.sessionMutable === false)) {
+            this._container.style.display = "none";
+            this._container.classList.add("agent-host-chat-input-picker-host-hidden");
+            return;
+        }
+        if (this._property === SessionConfigKey.AutoApprove && !isWellKnownAutoApproveSchema(ctx.schema)) {
+            this._container.style.display = "none";
+            this._container.classList.add("agent-host-chat-input-picker-host-hidden");
+            return;
+        }
+        this._container.style.display = "";
+        this._container.classList.remove("agent-host-chat-input-picker-host-hidden");
+        const slot = append(this._container, $(".agent-host-chat-input-picker-slot"));
+        this._renderDisposables.add({
+            dispose: () => slot.remove()
+        });
+        const isReadOnly = !!ctx.schema.readOnly || (isStartedSession && ctx.schema.sessionMutable === false);
+        const trigger = renderPickerTrigger(slot, isReadOnly, this._renderDisposables, () => this._showPicker(trigger));
+        this._renderTrigger(trigger, ctx.schema, ctx.value, isReadOnly);
+    }
+    _renderTrigger(trigger, schema, value, isReadOnly) {
+        clearNode(trigger);
+        const compact = this._pickerOptions?.hideChevrons.get() ?? false;
+        const icon = getConfigIcon(this._property, value);
+        if (icon) {
+            append(trigger, renderIcon(icon));
+        }
+        if (this._property === SessionConfigKey.AutoApprove) {
+            trigger.classList.toggle("warning", value === "autopilot");
+            trigger.classList.toggle("info", value === "autoApprove");
+        }
+        const label = this._labelFor(schema, value);
+        if (!compact) {
+            const labelSpan = append(trigger, $("span.agent-host-chat-input-picker-label"));
+            labelSpan.textContent = label;
+        }
+        trigger.setAttribute("aria-label", isReadOnly ? ( localize(5208, "{0}: {1}, Read-Only", schema.title, label)) : ( localize(5209, "{0}: {1}", schema.title, label)));
+        if (!isReadOnly && !compact) {
+            append(trigger, renderIcon(Codicon.chevronDown));
+        }
+    }
+    _labelFor(schema, value) {
+        if (typeof value === "string") {
+            const index = schema.enum?.indexOf(value) ?? -1;
+            return index >= 0 ? schema.enumLabels?.[index] ?? value : value;
+        }
+        return schema.title;
+    }
+    _readContext() {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        if (!sessionResource) {
+            return undefined;
+        }
+        if (this._subRef.value) {
+            const state = this._subRef.value.sub.value;
+            if (!state || state instanceof Error) {
+                return undefined;
+            }
+            const overlay = this._provisional.getResolvedConfig(sessionResource);
+            const schemaSource = overlay?.schema ?? state.config?.schema;
+            const schema = schemaSource?.properties[this._property];
+            if (!schema) {
+                return undefined;
+            }
+            const value = overlay?.values?.[this._property] ?? state.config?.values?.[this._property] ?? schema.default;
+            return {
+                backendSession: this._subRef.value.backendSession,
+                schema,
+                value
+            };
+        }
+        if (this._initialResolved && ( this._initialResolved.sessionResource.toString()) === ( sessionResource.toString())) {
+            const schema = this._initialResolved.result.schema.properties[this._property];
+            if (!schema) {
+                return undefined;
+            }
+            const backendSession = toBackendSessionUri(sessionResource);
+            if (!backendSession) {
+                return undefined;
+            }
+            const value = this._initialResolved.result.values?.[this._property] ?? schema.default;
+            return {
+                backendSession,
+                schema,
+                value
+            };
+        }
+        return undefined;
+    }
+    async _showPicker(trigger) {
+        if (this._actionWidgetService.isVisible) {
+            return;
+        }
+        const ctx = this._readContext();
+        if (!ctx || ctx.schema.readOnly) {
+            return;
+        }
+        const items = await this._getItems(ctx.schema);
+        if (items.length === 0) {
+            return;
+        }
+        const currentValue = ctx.value;
+        const actionItems = toActionItems(this._property, items, currentValue);
+        if (this._property === ClaudeSessionConfigKey.PermissionMode || this._property === SessionConfigKey.AutoApprove) {
+            actionItems.push({
+                kind: ActionListItemKind.Action,
+                label: ( localize(5210, "Learn more about permissions")),
+                group: {
+                    title: "",
+                    icon: Codicon.blank
+                },
+                item: {
+                    value: LEARN_MORE_VALUE,
+                    label: ( localize(5210, "Learn more about permissions"))
+                }
+            });
+        }
+        const delegate = {
+            onSelect: item => {
+                this._actionWidgetService.hide();
+                if (item.value === LEARN_MORE_VALUE) {
+                    void this._openerService.open(( URI.parse(PERMISSION_MODE_LEARN_MORE_URL)));
+                    return;
+                }
+                void this._setValue(ctx.backendSession, item.value);
+            },
+            onFilter: ctx.schema.enumDynamic ? query => this._filterDelayer.trigger(async () => {
+                const refreshed = this._readContext();
+                if (!refreshed) {
+                    return [];
+                }
+                return toActionItems(
+                    this._property,
+                    await this._getItems(refreshed.schema, query),
+                    refreshed.value
+                );
+            }) : undefined,
+            onHide: () => trigger.focus()
+        };
+        this._actionWidgetService.show(
+            `agentHostChatInputPicker.${this._property}`,
+            false,
+            actionItems,
+            delegate,
+            trigger,
+            undefined,
+            [],
+            {
+                getAriaLabel: item => item.label ?? "",
+                getWidgetAriaLabel: () => ( localize(5211, "{0} Picker", ctx.schema.title))
+            },
+            actionItems.length > FILTER_THRESHOLD || ctx.schema.enumDynamic ? {
+                showFilter: true,
+                filterPlaceholder: ( localize(5212, "Filter..."))
+            } : undefined
+        );
+    }
+    async _getItems(schema, query) {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        const backendSession = this._subRef.value?.backendSession ?? (sessionResource ? toBackendSessionUri(sessionResource) : undefined);
+        if (schema.enumDynamic && backendSession) {
+            try {
+                const result = await this._agentHostService.sessionConfigCompletions({
+                    provider: backendSession.scheme,
+                    property: this._property,
+                    query,
+                    workingDirectory: this._readWorkingDirectory(),
+                    config: this._readCurrentValues()
+                });
+                return ( result.items.map(item => this._fromCompletion(item)));
+            } catch {}
+        }
+        return ( (schema.enum ?? []).map((value, index) => ({
+            value,
+            label: schema.enumLabels?.[index] ?? value,
+            description: schema.enumDescriptions?.[index]
+        })));
+    }
+    _fromCompletion(item) {
+        return {
+            value: item.value,
+            label: item.label,
+            description: item.description
+        };
+    }
+    _readWorkingDirectory() {
+        const state = this._subRef.value?.sub.value;
+        if (state && !(state instanceof Error)) {
+            const cwd = state.summary.workingDirectory;
+            return typeof cwd === "string" ? ( URI.parse(cwd)) : cwd;
+        }
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        return (sessionResource && this._workingDirectoryResolver.resolve(sessionResource)) ?? this._workspaceContextService.getWorkspace().folders[0]?.uri;
+    }
+    _readCurrentValues() {
+        const state = this._subRef.value?.sub.value;
+        if (state && !(state instanceof Error)) {
+            return state.config?.values;
+        }
+        return this._initialResolved?.result.values;
+    }
+    async _setValue(backendSession, value) {
+        const sessionResource = this._widget.viewModel?.sessionResource;
+        if (!sessionResource) {
+            return;
+        }
+        const partial = {
+            [this._property]: value
+        };
+        if (isUntitledChatSession(sessionResource)) {
+            const provider = backendSession.scheme;
+            const created = await this._provisional.applyConfigChange(sessionResource, provider, this._readWorkingDirectory(), partial);
+            if (!created) {
+                return;
+            }
+            if (!this._subRef.value || ( this._subRef.value.backendSession.toString()) !== ( created.toString())) {
+                this._reattach();
+            }
+            return;
+        }
+        this._agentHostService.dispatch({
+            type: ActionType.SessionConfigChanged,
+            session: ( backendSession.toString()),
+            config: partial
+        });
+    }
+};
+AgentHostChatInputPicker = ( __decorate([( __param(3, IAgentHostService)), ( __param(4, IActionWidgetService)), ( __param(5, IOpenerService)), ( __param(6, IAgentHostSessionWorkingDirectoryResolver)), ( __param(7, IWorkspaceContextService)), ( __param(8, IAgentHostUntitledProvisionalSessionService))], AgentHostChatInputPicker));
+class AgentHostChatInputPickerActionViewItem extends BaseActionViewItem {
+    constructor(action, _picker) {
+        super(undefined, action);
+        this._picker = _picker;
+        this._register(this._picker);
+    }
+    render(container) {
+        this._picker.render(container);
+    }
+}
+
+export { AgentHostChatInputPicker, AgentHostChatInputPickerActionViewItem, WELL_KNOWN_PICKER_PROPERTIES, isClaimedByDedicatedPicker, isWellKnownAutoApproveSchema };

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

@@ -0,0 +1,45 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import type { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import type { IChatInputPickerOptions } from "../../widget/input/chatInputPickerActionItem.js";
+import { IAgentHostSessionWorkingDirectoryResolver } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service";
+import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+/**
+ * Direct-render chip lane for agent-host session-config properties that are
+ * advertised by the agent's schema but are NOT handled by a dedicated
+ * well-known picker (e.g. Claude's custom approval-mode property).
+ *
+ * Unlike the dedicated chips, this lane is not registered with
+ * `MenuId.ChatInputSecondary`. It owns its own DOM container and creates
+ * one {@link AgentHostChatInputPicker} per generic property, syncing the
+ * set of chips whenever the active session's schema changes.
+ */
+export declare class AgentHostGenericConfigChips extends Disposable {
+    private readonly _widget;
+    private readonly _pickerOptions;
+    private readonly _instantiationService;
+    private readonly _agentHostService;
+    private readonly _provisional;
+    private readonly _workingDirectoryResolver;
+    private readonly _workspaceContextService;
+    private _container;
+    private readonly _chips;
+    /**
+     * Subscription to the active session's backend state. Maintained for the
+     * lifetime of any one (sessionResource, backendSession) pair; replaced
+     * via {@link _reattach} when the active session changes.
+     */
+    private readonly _subRef;
+    private _initialResolved;
+    private readonly _initialResolveCts;
+    constructor(_widget: IChatWidget, _pickerOptions: IChatInputPickerOptions | undefined, _instantiationService: IInstantiationService, _agentHostService: IAgentHostService, _provisional: IAgentHostUntitledProvisionalSessionService, _workingDirectoryResolver: IAgentHostSessionWorkingDirectoryResolver, _workspaceContextService: IWorkspaceContextService);
+    render(container: HTMLElement): void;
+    private _reattach;
+    private _cancelInitialResolve;
+    private _refreshInitialResolved;
+    private _readWorkingDirectory;
+    private _readSchemaProperties;
+    private _sync;
+}