@theia/ai-ide 1.75.0-next.8 → 1.75.0

package/src/browser/ai-configuration/categories/agent-capabilities-settings.tsx

@@ -0,0 +1,340 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import {
+    AISettingsService,
+    ParsedCapability,
+    GenericCapabilitySelections,
+    CAPABILITY_TYPE_PROMPT_MAP,
+    ServerToolDescriptor,
+} from '@theia/ai-core/lib/common';
+import { nls } from '@theia/core';
+import { codicon } from '@theia/core/lib/browser';
+import * as React from '@theia/core/shared/react';
+import { AiConfigurationItemRow } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-item-row';
+import { AiSettingsRowService } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row-service';
+import { AiToggleSwitch } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-controls';
+
+/**
+ * An agent-detail subsection header with an optional trailing action, so a section-wide action (e.g. its
+ * reset) rides on the title line instead of taking a prominent row of its own above the list.
+ */
+const AgentSectionHeader: React.FC<{ title: string; action?: React.ReactNode }> = ({ title, action }) => (
+    <div className='settings-section-subcategory-title ai-settings-section-subcategory-title ai-agent-section-header'>
+        <span>{title}</span>
+        {action}
+    </div>
+);
+
+/**
+ * The section-wide reset: the same discard icon button the prompt variant rows use, rather than a text
+ * button, so it reads as a Theia reset affordance. Its tooltip says what the section-wide reset does.
+ */
+const ResetAllButton: React.FC<{ title: string; disabled?: boolean; onReset: () => void }> = ({ title, disabled, onReset }) => (
+    <button
+        className='ai-variant-action-button ai-agent-section-header-action'
+        onClick={onReset}
+        disabled={disabled}
+        title={title}
+        aria-label={title}
+    >
+        <span aria-hidden='true' className={codicon('discard')}></span>
+    </button>
+);
+
+export interface AgentCapabilitiesSettingsProps {
+    capabilities: ParsedCapability[];
+    agentId: string;
+    savedOverrides: Record<string, boolean> | undefined;
+    aiSettingsService: AISettingsService;
+    settingsRowService: AiSettingsRowService;
+    /**
+     * Reveals the capability's prompt fragment on the Prompt Snippets page. The text is global, shared by
+     * every agent that references it, which is why the row links there instead of editing it in place.
+     */
+    onOpenPromptSnippet: (fragmentId: string) => void;
+}
+
+/**
+ * The "Available Capabilities" section of the agent detail page: one toggle per capability the prompt
+ * declares. Each toggle writes an override only when it differs from the agent's default; a per-row
+ * reset (gear menu) and a "Reset All to Defaults" button clear overrides back to the declared defaults.
+ */
+export const AgentCapabilitiesSettings = ({
+    capabilities, agentId, savedOverrides, aiSettingsService, settingsRowService, onOpenPromptSnippet
+}: AgentCapabilitiesSettingsProps) => {
+    const [loading, setLoading] = React.useState(false);
+
+    const handleToggle = async (fragmentId: string, currentValue: boolean): Promise<void> => {
+        if (loading) {
+            return;
+        }
+        setLoading(true);
+        try {
+            const capability = capabilities.find(c => c.fragmentId === fragmentId);
+            if (!capability) {
+                return;
+            }
+            const newValue = !currentValue;
+            const newOverrides = { ...savedOverrides };
+            if (newValue === capability.defaultEnabled) {
+                delete newOverrides[fragmentId];
+            } else {
+                newOverrides[fragmentId] = newValue;
+            }
+            await aiSettingsService.updateAgentSettings(agentId, { capabilityOverrides: newOverrides });
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    const handleResetAll = async (): Promise<void> => {
+        if (loading) {
+            return;
+        }
+        setLoading(true);
+        try {
+            await aiSettingsService.updateAgentSettings(agentId, { capabilityOverrides: undefined });
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    // Drop a single capability's override so it falls back to the agent's default.
+    const resetCapability = async (fragmentId: string): Promise<void> => {
+        if (loading) {
+            return;
+        }
+        setLoading(true);
+        try {
+            const newOverrides = { ...savedOverrides };
+            delete newOverrides[fragmentId];
+            await aiSettingsService.updateAgentSettings(agentId, { capabilityOverrides: newOverrides });
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    const getCurrentValue = (capability: ParsedCapability): boolean =>
+        savedOverrides && capability.fragmentId in savedOverrides ? savedOverrides[capability.fragmentId] : capability.defaultEnabled;
+    const hasOverride = (capability: ParsedCapability): boolean => savedOverrides !== undefined && capability.fragmentId in savedOverrides;
+    const hasAnyOverrides = savedOverrides && Object.keys(savedOverrides).length > 0;
+    // Show "Name (id)" when the fragment declares a name; otherwise just the id.
+    const labelFor = (capability: ParsedCapability): string =>
+        capability.name ? `${capability.name} (${capability.fragmentId})` : capability.fragmentId;
+    const snippetLinkTooltip = nls.localize('theia/ai/ide/agentConfiguration/showCapabilitySnippet', 'Show snippet');
+
+    return <>
+        <AgentSectionHeader
+            title={nls.localize('theia/ai/core/agentConfiguration/availableCapabilities', 'Available Capabilities')}
+            action={hasAnyOverrides && <ResetAllButton
+                onReset={handleResetAll}
+                disabled={loading}
+                title={nls.localize('theia/ai/ide/agentConfiguration/resetAllCapabilities', 'Reset all capabilities to their default values')}
+            />}
+        />
+        <div className='ai-configuration-item-list'>
+            {capabilities.map(capability => <AiConfigurationItemRow
+                key={capability.fragmentId}
+                label={labelFor(capability)}
+                description={capability.description}
+                modified={hasOverride(capability)}
+                onOpenMenu={hasOverride(capability)
+                    ? gear => settingsRowService.openResetMenu(gear, () => resetCapability(capability.fragmentId))
+                    : undefined}
+                onActivateLabel={() => onOpenPromptSnippet(capability.fragmentId)}
+                labelTooltip={snippetLinkTooltip}
+                trailing={<AiToggleSwitch
+                    checked={getCurrentValue(capability)}
+                    disabled={loading}
+                    ariaLabel={labelFor(capability)}
+                    onChange={() => handleToggle(capability.fragmentId, getCurrentValue(capability))}
+                />}
+            />)}
+        </div>
+    </>;
+};
+
+export interface AgentGenericCapabilitiesSettingsProps {
+    agentId: string;
+    savedSelections: GenericCapabilitySelections | undefined;
+    aiSettingsService: AISettingsService;
+    settingsRowService: AiSettingsRowService;
+    /** Reveals the snippet that wraps this capability type's selections, as in {@link AgentCapabilitiesSettings}. */
+    onOpenPromptSnippet: (fragmentId: string) => void;
+}
+
+/**
+ * The "Generic Capabilities" section of the agent detail page: one row per capability type the user has
+ * selected (skills, MCP functions, functions, prompt fragments, agent delegation, variables). Only
+ * selected types are shown; each row is an override with a per-type reset and a shared "Reset All".
+ */
+export const AgentGenericCapabilitiesSettings = ({
+    agentId, savedSelections, aiSettingsService, settingsRowService, onOpenPromptSnippet
+}: AgentGenericCapabilitiesSettingsProps) => {
+    const [loading, setLoading] = React.useState(false);
+
+    const handleResetAll = async (): Promise<void> => {
+        if (loading) {
+            return;
+        }
+        setLoading(true);
+        try {
+            await aiSettingsService.updateAgentSettings(agentId, { genericCapabilitySelections: undefined });
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    // Drop a single capability type's selections.
+    const handleReset = async (capabilityType: keyof GenericCapabilitySelections): Promise<void> => {
+        if (loading) {
+            return;
+        }
+        setLoading(true);
+        try {
+            await aiSettingsService.updateAgentSettings(agentId, { genericCapabilitySelections: { ...savedSelections, [capabilityType]: undefined } });
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    const capabilityTypes = CAPABILITY_TYPE_PROMPT_MAP.map(m => m.type);
+    const promptIdFor = (type: keyof GenericCapabilitySelections): string =>
+        CAPABILITY_TYPE_PROMPT_MAP.find(entry => entry.type === type)!.promptId;
+    const getDisplayName = (type: keyof GenericCapabilitySelections): string => ({
+        skills: nls.localizeByDefault('Skills'),
+        mcpFunctions: nls.localize('theia/ai/ide/agentConfiguration/genericCapabilityType/mcpFunctions', 'MCP Functions'),
+        functions: nls.localize('theia/ai/ide/agentConfiguration/genericCapabilityType/functions', 'Functions'),
+        promptFragments: nls.localize('theia/ai/ide/agentConfiguration/genericCapabilityType/promptFragments', 'Prompt Fragments'),
+        agentDelegation: nls.localize('theia/ai/ide/agentConfiguration/genericCapabilityType/agentDelegation', 'Agent Delegation'),
+        variables: nls.localizeByDefault('Variables')
+    } as const)[type];
+
+    // Only types the user has actually selected are shown; each such row is an override, so it carries the
+    // modified bar. A single "Reset All" clears every selection, mirroring the Available Capabilities section.
+    const shownTypes = capabilityTypes.filter(type => (savedSelections?.[type]?.length ?? 0) > 0);
+    return <>
+        <AgentSectionHeader
+            title={nls.localize('theia/ai/ide/agentConfiguration/genericCapabilitiesSettings', 'Generic Capabilities')}
+            action={shownTypes.length > 0 && <ResetAllButton
+                onReset={handleResetAll}
+                disabled={loading}
+                title={nls.localize('theia/ai/ide/agentConfiguration/resetAllGenericCapabilities', 'Reset all generic capability selections')}
+            />}
+        />
+        <div className='ai-configuration-item-list'>
+            {shownTypes.map(type => <AiConfigurationItemRow
+                key={type}
+                label={getDisplayName(type)}
+                description={(savedSelections?.[type] ?? []).join(', ')}
+                modified={true}
+                onOpenMenu={gear => settingsRowService.openResetMenu(gear, () => handleReset(type))}
+                onActivateLabel={() => onOpenPromptSnippet(promptIdFor(type))}
+                labelTooltip={nls.localize('theia/ai/ide/agentConfiguration/showCapabilitySnippet', 'Show snippet')}
+            />)}
+        </div>
+    </>;
+};
+
+export interface AgentServerToolsSettingsProps {
+    agentId: string;
+    /** Server tools the agent's model offers. */
+    tools: ServerToolDescriptor[];
+    /** Vendor the selections are keyed by: the vendor of the model offering the tools. */
+    vendor: string;
+    savedSelections: Record<string, string[]> | undefined;
+    aiSettingsService: AISettingsService;
+    /** Backs each enabled row's gear menu, whose "Reset Setting" switches that tool back off. */
+    settingsRowService: AiSettingsRowService;
+}
+
+/**
+ * The "Server Tools" section of the agent detail page: one toggle per tool the agent's model offers, executed
+ * by the provider rather than by Theia. The same per-agent setting the chat input's capabilities popup writes,
+ * keyed by model vendor because the tools are vendor-specific.
+ *
+ * Nothing is enabled unless it is listed, so an enabled tool is the deviation from the default and carries the
+ * modified indicator; "Reset All to Defaults" drops this vendor's selections, leaving other vendors' alone.
+ */
+export const AgentServerToolsSettings = ({
+    agentId, tools, vendor, savedSelections, aiSettingsService, settingsRowService
+}: AgentServerToolsSettingsProps) => {
+    const [loading, setLoading] = React.useState(false);
+    const enabledIds = savedSelections?.[vendor] ?? [];
+
+    const update = async (ids: string[]): Promise<void> => {
+        if (loading) {
+            return;
+        }
+        setLoading(true);
+        try {
+            // Drop the vendor's entry entirely once nothing is enabled, rather than leaving an empty array behind.
+            const next = { ...savedSelections };
+            if (ids.length > 0) {
+                next[vendor] = ids;
+            } else {
+                delete next[vendor];
+            }
+            await aiSettingsService.updateAgentSettings(agentId, {
+                serverToolSelections: Object.keys(next).length > 0 ? next : undefined
+            });
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    const handleToggle = (toolId: string, enabled: boolean): Promise<void> =>
+        update(enabled ? [...enabledIds, toolId] : enabledIds.filter(id => id !== toolId));
+
+    return <>
+        <AgentSectionHeader
+            title={nls.localize('theia/ai/core/languageModelRenderer/serverTools', 'Server Tools')}
+            action={enabledIds.length > 0 && <ResetAllButton
+                onReset={() => update([])}
+                disabled={loading}
+                title={nls.localize('theia/ai/ide/agentConfiguration/resetAllServerTools', 'Turn off every server tool of this provider')}
+            />}
+        />
+        {/* Same warning the capabilities popup shows on its Server Tools group, since enabling one here has
+            exactly that consequence. Reuses that key so both read identically in every language. */}
+        <div className='ai-agent-section-warning'>
+            <span aria-hidden='true' className={codicon('warning')}></span>
+            <span>{nls.localize('theia/ai/chat-ui/serverToolsWarning',
+                'These tools are auto-approved when selected. They may be executed by the model at any time.')}</span>
+        </div>
+        <div className='ai-configuration-item-list'>
+            {tools.map(tool => {
+                const enabled = enabledIds.includes(tool.id);
+                return <AiConfigurationItemRow
+                    key={tool.id}
+                    label={tool.name}
+                    description={tool.description}
+                    modified={enabled}
+                    onOpenMenu={enabled
+                        ? gear => settingsRowService.openResetMenu(gear, () => handleToggle(tool.id, false))
+                        : undefined}
+                    trailing={<AiToggleSwitch
+                        checked={enabled}
+                        disabled={loading}
+                        ariaLabel={tool.name}
+                        onChange={checked => handleToggle(tool.id, checked)}
+                    />}
+                />;
+            })}
+        </div>
+    </>;
+};

package/src/browser/ai-configuration/categories/agent-chips.tsx

@@ -0,0 +1,51 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Agent } from '@theia/ai-core';
+import { nls } from '@theia/core';
+import * as React from '@theia/core/shared/react';
+import { getAgentIconClass } from '../agent-icon';
+
+/** A single navigable agent chip (icon + name); shared by the Variables, Skills and Slash Command surfaces. */
+export const AgentChip: React.FC<{ agent: Agent; onOpenAgent: (agentId: string) => void }> = ({ agent, onOpenAgent }) => {
+    const label = nls.localize('theia/ai/ide/variableConfiguration/openAgent', 'Open agent {0}', agent.name);
+    return <button
+        type='button'
+        className='agent-chip'
+        aria-label={label}
+        title={label}
+        onClick={event => {
+            event.stopPropagation();
+            onOpenAgent(agent.id);
+        }}
+    >
+        <span aria-hidden='true' className={getAgentIconClass(agent)}></span>
+        {agent.name}
+    </button>;
+};
+
+export interface AgentChipsProps {
+    readonly agents: Agent[];
+    /** Navigates to an agent's detail page when a chip is activated. */
+    readonly onOpenAgent: (agentId: string) => void;
+}
+
+/** A row of navigable {@link AgentChip}s. */
+export const AgentChips: React.FC<AgentChipsProps> = ({ agents, onOpenAgent }) => (
+    <div className='agent-chips-container'>
+        {agents.map(agent => <AgentChip key={agent.id} agent={agent} onOpenAgent={onOpenAgent} />)}
+    </div>
+);

package/src/browser/ai-configuration/categories/agent-detail-model.ts

@@ -0,0 +1,152 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import {
+    Agent,
+    AgentService,
+    AISettingsService,
+    AIVariableService,
+    FrontendLanguageModelRegistry,
+    matchVariablesRegEx,
+    PROMPT_FUNCTION_REGEX,
+    ParsedCapability,
+    parseCapabilitiesFromTemplate,
+    PromptService,
+    NotificationType,
+    GenericCapabilitySelections,
+    ServerToolDescriptor,
+    ToolInvocationRegistry,
+} from '@theia/ai-core/lib/common';
+import { CommandService } from '@theia/core/lib/common/command';
+import { ILogger } from '@theia/core';
+import { AiSettingsRowService } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row-service';
+
+/** The services the agent detail page needs; injected into the owning category and passed down. */
+export interface AgentDetailServices {
+    readonly agentService: AgentService;
+    readonly aiSettingsService: AISettingsService;
+    readonly variableService: AIVariableService;
+    readonly promptService: PromptService;
+    readonly languageModelRegistry: FrontendLanguageModelRegistry;
+    readonly toolInvocationRegistry: ToolInvocationRegistry;
+    readonly commandService: CommandService;
+    readonly settingsRowService: AiSettingsRowService;
+    readonly logger: ILogger;
+}
+
+export interface ParsedPrompt {
+    functions: string[];
+    globalVariables: string[];
+    agentSpecificVariables: string[];
+    capabilities: ParsedCapability[];
+}
+
+export interface AgentDetailState {
+    parsed: ParsedPrompt;
+    showInChat: boolean;
+    completionNotification?: NotificationType;
+    capabilityOverrides?: Record<string, boolean>;
+    genericCapabilitySelections?: GenericCapabilitySelections;
+    /** Server tools the agent's model offers, if it declares any; empty/absent hides that section. */
+    serverTools?: ServerToolDescriptor[];
+    /** Vendor the server tool selections are keyed by, i.e. the vendor of the model offering them. */
+    serverToolVendor?: string;
+    /** Enabled server tool ids per vendor, as stored for this agent. */
+    serverToolSelections?: Record<string, string[]>;
+}
+
+export async function loadAgentDetail(agent: Agent, services: AgentDetailServices): Promise<AgentDetailState> {
+    const parsed = await parsePromptFragments(agent, services);
+    const agentSettings = await services.aiSettingsService.getAgentSettings(agent.id);
+    const serverToolModel = await resolveServerToolModel(agent, services);
+    return {
+        parsed,
+        showInChat: agentSettings?.showInChat ?? true,
+        completionNotification: agentSettings?.completionNotification,
+        capabilityOverrides: agentSettings?.capabilityOverrides,
+        genericCapabilitySelections: agentSettings?.genericCapabilitySelections,
+        serverTools: serverToolModel?.serverTools,
+        serverToolVendor: serverToolModel?.vendor,
+        serverToolSelections: agentSettings?.serverToolSelections ? { ...agentSettings.serverToolSelections } : undefined
+    };
+}
+
+/**
+ * The model whose provider server tools the agent can use: the first of its requirements that resolves to a
+ * model declaring any, mirroring how the chat input picks the model behind its capabilities popup. Server
+ * tools are vendor-specific, so the vendor comes from that same model.
+ */
+async function resolveServerToolModel(agent: Agent, services: AgentDetailServices): Promise<{ serverTools: ServerToolDescriptor[]; vendor?: string } | undefined> {
+    for (const requirement of agent.languageModelRequirements ?? []) {
+        try {
+            const model = await services.languageModelRegistry.selectLanguageModel({ agent: agent.id, ...requirement });
+            if (model?.serverTools && model.serverTools.length > 0) {
+                return { serverTools: model.serverTools, vendor: model.vendor };
+            }
+        } catch (error) {
+            services.logger.warn('Failed to resolve language model for server tools:', error);
+        }
+    }
+    return undefined;
+}
+
+async function parsePromptFragments(agent: Agent, services: AgentDetailServices): Promise<ParsedPrompt> {
+    const { aiSettingsService, promptService, variableService } = services;
+    const result: ParsedPrompt = { functions: [], globalVariables: [], agentSpecificVariables: [], capabilities: [] };
+    const agentSettings = await aiSettingsService.getAgentSettings(agent.id);
+    const selectedVariants = agentSettings?.selectedVariants ?? {};
+
+    for (const mainTemplate of agent.prompts) {
+        const promptId = selectedVariants[mainTemplate.id] ?? mainTemplate.defaultVariant?.id ?? mainTemplate.id;
+        const promptToAnalyze = promptService.getRawPromptFragment(promptId)?.template;
+        if (!promptToAnalyze) {
+            continue;
+        }
+        extractVariablesAndFunctions(promptToAnalyze, result, agent, variableService);
+        extractCapabilities(promptToAnalyze, result, promptService);
+    }
+    return result;
+}
+
+function extractCapabilities(promptContent: string, result: ParsedPrompt, promptService: PromptService): void {
+    const capabilities = parseCapabilitiesFromTemplate(promptContent);
+    const existingIds = new Set(result.capabilities.map(c => c.fragmentId));
+    for (const capability of capabilities) {
+        if (!existingIds.has(capability.fragmentId)) {
+            const fragment = promptService.getRawPromptFragment(capability.fragmentId);
+            result.capabilities.push({ ...capability, name: fragment?.name, description: fragment?.description });
+            existingIds.add(capability.fragmentId);
+        }
+    }
+}
+
+function extractVariablesAndFunctions(promptContent: string, result: ParsedPrompt, agent: Agent, variableService: AIVariableService): void {
+    const variableMatches = matchVariablesRegEx(promptContent);
+    variableMatches.forEach(match => {
+        const variableId = match[1];
+        if (variableId.startsWith('!--') || variableId.startsWith('capability:')) {
+            return;
+        }
+        const baseVariableId = variableId.split(':')[0];
+        if (variableService.hasVariable(baseVariableId) && agent.agentSpecificVariables.find(v => v.name === baseVariableId) === undefined) {
+            result.globalVariables.push(variableId);
+        } else {
+            result.agentSpecificVariables.push(variableId);
+        }
+    });
+    const functionMatches = [...promptContent.matchAll(PROMPT_FUNCTION_REGEX)];
+    functionMatches.forEach(match => result.functions.push(match[1]));
+}