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

package/src/browser/ai-configuration/categories/models-configuration-category.tsx

@@ -0,0 +1,264 @@
+// *****************************************************************************
+// 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 { Emitter, Event, nls } from '@theia/core';
+import { codicon } from '@theia/core/lib/browser';
+import { DisposableCollection } from '@theia/core/lib/common';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import * as React from '@theia/core/shared/react';
+import {
+    AiConfigurationCategory,
+    AiConfigurationCategoryId,
+    AiConfigurationCategoryOrder,
+    AiConfigurationRenderContext,
+    AiConfigurationSearchItem,
+    AiConfigurationSearchProvider,
+    AiConfigurationTreeItem
+} from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+import { AiSettingsRowService } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row-service';
+import { AiConfigurationSection } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-primitives';
+import { CollectionCategoryRenderer } from '@theia/ai-core-ui/lib/browser/ai-configuration/renderers/collection-category-renderer';
+import { AiSettingsRow } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-settings-row';
+
+/** Prefix shared by every AI preference. */
+const AI_FEATURES_PREFIX = 'ai-features.';
+
+/** Id of the cross-provider "Model Settings" section (kept in the overview, not a provider node). */
+const MODEL_SETTINGS_ID = 'model-settings';
+
+/** Segments that make up the cross-provider "Model Settings" section. */
+const MODEL_SETTINGS_SEGMENTS = new Set<string>(['modelSettings', 'reasoning']);
+
+interface ModelsSection {
+    readonly id: string;
+    readonly title: string;
+    readonly preferenceIds: string[];
+}
+
+/**
+ * The Models category: a `collection` listing each language-model provider as a tree child, so
+ * providers appear as nodes under the Models category. Provider blocks are discovered from the
+ * registered `ai-features.<provider>.*` preferences, so any installed provider package contributes
+ * a node here without ai-ide having to depend on it.
+ *
+ * The page layout comes from {@link CollectionCategoryRenderer}, like the other collection categories:
+ * the overview shows the cross-provider model settings (`ai-features.modelSettings.*`,
+ * `ai-features.reasoning.*`) above the provider cards, and selecting a provider node shows that
+ * provider's settings.
+ */
+@injectable()
+export class ModelsConfigurationCategory extends CollectionCategoryRenderer implements AiConfigurationCategory, AiConfigurationSearchProvider {
+
+    readonly id = AiConfigurationCategoryId.MODELS;
+    readonly label = nls.localize('theia/ai/core/aiConfiguration/models/label', 'Providers & Models');
+    readonly description = nls.localize('theia/ai/ide/modelsConfiguration/description',
+        'Configure language-model providers and the models available to agents.');
+    readonly iconClass = codicon('cloud');
+    readonly order = AiConfigurationCategoryOrder.MODELS;
+    readonly kind = 'collection' as const;
+
+    @inject(AiSettingsRowService)
+    protected readonly settingsRowService: AiSettingsRowService;
+
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
+    protected readonly toDispose = new DisposableCollection(this.onDidChangeEmitter);
+
+    get renderer(): this {
+        return this;
+    }
+
+    protected get categoryId(): string {
+        return this.id;
+    }
+
+    getOwnedPreferenceIds(): string[] {
+        return this.getSections().flatMap(section => section.preferenceIds);
+    }
+
+    get search(): AiConfigurationSearchProvider {
+        return this;
+    }
+
+    @postConstruct()
+    protected init(): void {
+        this.toDispose.push(this.settingsRowService.onPreferenceChanged(() => this.onDidChangeEmitter.fire()));
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    /**
+     * One tree child per discovered provider (the cross-provider model settings stay in the overview).
+     * Each carries the category icon so the overview cards show it; the tree nodes fall back to it anyway.
+     */
+    getTreeChildren(): AiConfigurationTreeItem[] {
+        return this.getProviderSections().map(section => ({
+            id: section.id,
+            label: section.title,
+            iconClass: this.iconClass
+        } satisfies AiConfigurationTreeItem));
+    }
+
+    protected override get overviewListTitle(): string {
+        return nls.localize('theia/ai/ide/modelsConfiguration/providers', 'Providers');
+    }
+
+    protected override getEmptyMessage(): string {
+        return nls.localize('theia/ai/ide/modelsConfiguration/noProviders', 'No language-model providers are installed.');
+    }
+
+    /** Shown above the provider cards: the cross-provider model settings, when any are registered. */
+    protected override renderCategorySettings(ctx: AiConfigurationRenderContext): React.ReactNode {
+        const modelSettings = this.getModelSettingsSection();
+        return modelSettings && <AiConfigurationSection title={modelSettings.title}>
+            {modelSettings.preferenceIds.map(preferenceId => this.renderPreferenceRow(ctx, preferenceId))}
+        </AiConfigurationSection>;
+    }
+
+    /** Provider detail (node selected): that provider's settings. */
+    protected renderItemSections(item: AiConfigurationTreeItem, ctx: AiConfigurationRenderContext): React.ReactNode {
+        const section = this.getProviderSections().find(candidate => candidate.id === item.id);
+        if (!section) {
+            return undefined;
+        }
+        return <AiConfigurationSection title={nls.localizeByDefault('Settings')}>
+            {section.preferenceIds.map(preferenceId => this.renderPreferenceRow(ctx, preferenceId))}
+        </AiConfigurationSection>;
+    }
+
+    protected renderPreferenceRow(ctx: AiConfigurationRenderContext, preferenceId: string): React.ReactNode {
+        return <AiSettingsRow
+            key={preferenceId}
+            service={this.settingsRowService}
+            preferenceId={preferenceId}
+            scope={ctx.scope}
+            control={this.settingsRowService.controlFor(preferenceId)}
+            onDidChange={() => ctx.update()}
+        />;
+    }
+
+    /** Discovers the model-settings and provider sections from the registered preference schema. */
+    protected getSections(): ModelsSection[] {
+        const displayable = this.settingsRowService.aiFeaturePreferenceIds();
+
+        // A `ai-features.<segment>.*` block is a provider block only when at least one of its preferences
+        // positively declares the `aiModelProvider` typeDetail (the same marker used to label the block).
+        // This replaces a hand-maintained denylist of non-provider segments: an unknown feature area that
+        // never claims to be a provider is no longer mistaken for one — it falls through to the General
+        // catch-all instead of showing up as a bogus provider block.
+        const providerSegments = new Set<string>();
+        for (const preferenceId of displayable) {
+            if (this.settingsRowService.isModelProviderPreference(preferenceId)) {
+                providerSegments.add(this.segmentOf(preferenceId));
+            }
+        }
+
+        const modelSettings: string[] = [];
+        const byProvider = new Map<string, string[]>();
+        for (const preferenceId of displayable) {
+            const segment = this.segmentOf(preferenceId);
+            if (MODEL_SETTINGS_SEGMENTS.has(segment)) {
+                modelSettings.push(preferenceId);
+            } else if (providerSegments.has(segment)) {
+                const block = byProvider.get(segment) ?? [];
+                block.push(preferenceId);
+                byProvider.set(segment, block);
+            }
+        }
+
+        const sections: ModelsSection[] = [];
+        if (modelSettings.length > 0) {
+            sections.push({
+                id: MODEL_SETTINGS_ID,
+                title: nls.localize('theia/ai/ide/modelsConfiguration/modelSettings', 'Model Settings'),
+                preferenceIds: modelSettings
+            });
+        }
+        const providerSections = Array.from(byProvider.entries()).map(([provider, preferenceIds]) => ({
+            id: provider,
+            title: this.getProviderLabel(provider, preferenceIds),
+            preferenceIds
+        } satisfies ModelsSection));
+        // Order provider nodes by the label the user actually sees, not by the raw preference segment.
+        providerSections.sort((left, right) => left.title.localeCompare(right.title));
+        sections.push(...providerSections);
+        return sections;
+    }
+
+    /**
+     * The human-readable display name for a provider block. A provider declares it in its preference
+     * schema (via the `aiModelProvider` `typeDetails`, `MODEL_PROVIDER_TYPE_DETAIL`), so this
+     * package does not have to know provider names. Providers that declare no name (e.g. third-party
+     * packages) fall back to a prettified form of the `ai-features.<provider>.*` segment.
+     */
+    protected getProviderLabel(providerId: string, preferenceIds: string[]): string {
+        for (const preferenceId of preferenceIds) {
+            const declared = this.settingsRowService.modelProviderLabel(preferenceId);
+            if (declared) {
+                return declared;
+            }
+        }
+        return this.prettifyProviderId(providerId);
+    }
+
+    /** The `ai-features.<segment>.…` area segment of a preference id, e.g. `ai-features.google.apiKey` → `google`. */
+    protected segmentOf(preferenceId: string): string {
+        return preferenceId.substring(AI_FEATURES_PREFIX.length).split('.')[0];
+    }
+
+    /** Turns an unknown provider segment such as `myProvider` or `my-provider` into `My Provider`. */
+    protected prettifyProviderId(providerId: string): string {
+        const spaced = providerId
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            .replace(/[-_]+/g, ' ')
+            .trim();
+        return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+    }
+
+    /** The cross-provider "Model Settings" section, if any settings are registered for it. */
+    protected getModelSettingsSection(): ModelsSection | undefined {
+        return this.getSections().find(section => section.id === MODEL_SETTINGS_ID);
+    }
+
+    /** The provider sections (everything except the cross-provider "Model Settings"). */
+    protected getProviderSections(): ModelsSection[] {
+        return this.getSections().filter(section => section.id !== MODEL_SETTINGS_ID);
+    }
+
+    getSearchItems(): AiConfigurationSearchItem[] {
+        const settingLabel = nls.localizeByDefault('Setting');
+        return this.getSections().flatMap(section => {
+            // Provider settings live in the provider's node; model settings live in the overview.
+            const isProvider = section.id !== MODEL_SETTINGS_ID;
+            return section.preferenceIds.map(preferenceId => {
+                const described = this.settingsRowService.describe(preferenceId);
+                return {
+                    label: described.label ?? preferenceId,
+                    typeLabel: settingLabel,
+                    categoryId: this.id,
+                    target: {
+                        categoryId: this.id,
+                        itemId: isProvider ? section.id : undefined,
+                        highlight: { rowId: preferenceId }
+                    },
+                    keywords: `${preferenceId} ${section.title}`
+                } satisfies AiConfigurationSearchItem;
+            });
+        });
+    }
+}

package/src/browser/ai-configuration/categories/prompt-snippets-configuration-category.spec.ts

@@ -0,0 +1,250 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { createRoot } from '@theia/core/shared/react-dom/client';
+import { flushSync } from '@theia/core/shared/react-dom';
+import { Agent } from '@theia/ai-core';
+import { GENERIC_CAPABILITIES_AGENT_DELEGATION_PROMPT_ID } from '@theia/ai-core/lib/common';
+import { PromptFragment } from '@theia/ai-core/lib/common/prompt-service';
+import { AiConfigurationCategoryId } from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+import { PromptSnippetEntry, PromptSnippetsConfiguration, PromptSnippetsConfigurationCategory } from './prompt-snippets-configuration-category';
+
+disableJSDOM();
+
+describe('PromptSnippetsConfigurationCategory', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    interface Setup {
+        /** `id -> fragments`, as `getAllPromptFragments` returns them (customizations first, built-in last). */
+        fragments?: Record<string, Partial<PromptFragment>[]>;
+        /** `variantSetId -> variantIds`, as `getPromptVariantSets` returns them. */
+        variantSets?: Record<string, string[]>;
+        /** `agentId -> template of its single prompt`, used to resolve `{{capability:...}}` references. */
+        agentTemplates?: Record<string, string>;
+    }
+
+    function loadEntries({ fragments = {}, variantSets = {}, agentTemplates = {} }: Setup): PromptSnippetEntry[] {
+        const category = new PromptSnippetsConfigurationCategory();
+        const withIds = new Map<string, PromptFragment[]>(
+            Object.entries(fragments).map(([id, list]) => [id, list.map(fragment => ({ id, template: '', ...fragment }) as PromptFragment)])
+        );
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).promptService = {
+            getAllPromptFragments: () => withIds,
+            getPromptVariantSets: () => new Map(Object.entries(variantSets)),
+            // The effective fragment is the first entry, mirroring the service's priority order.
+            getRawPromptFragment: (id: string) => withIds.get(id)?.[0],
+            getEffectiveVariantId: (id: string) => id
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).availableAgents = Object.keys(agentTemplates).map(agentId => ({
+            id: agentId,
+            prompts: [{ id: `${agentId}-prompt` }]
+        }) as unknown as Agent);
+        for (const [agentId, template] of Object.entries(agentTemplates)) {
+            withIds.set(`${agentId}-prompt`, [{ id: `${agentId}-prompt`, template } as PromptFragment]);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (category as any).loadEntries();
+    }
+
+    it('declares the prompt snippets single-page metadata', () => {
+        const category = new PromptSnippetsConfigurationCategory();
+        expect(category.id).to.equal(AiConfigurationCategoryId.PROMPT_SNIPPETS);
+        expect(category.kind).to.equal('single-page');
+    });
+
+    it('groups a fragment referenced as a capability under capabilities, and records the agents using it', () => {
+        const entries = loadEntries({
+            fragments: { github: [{ name: 'GitHub', description: 'talks to GitHub' }] },
+            agentTemplates: { coder: 'do work {{capability:github default on}}', architect: 'plan {{capability:github}}' }
+        });
+        const github = entries.find(entry => entry.id === 'github');
+
+        expect(github?.kind).to.equal('capability');
+        expect(github?.agentIds).to.deep.equal(['coder', 'architect']);
+    });
+
+    it('groups the fixed generic capability ids as generic, even when an agent references one as a capability', () => {
+        const entries = loadEntries({
+            fragments: { [GENERIC_CAPABILITIES_AGENT_DELEGATION_PROMPT_ID]: [{}] },
+            agentTemplates: { coder: `x {{capability:${GENERIC_CAPABILITIES_AGENT_DELEGATION_PROMPT_ID}}}` }
+        });
+
+        expect(entries.find(entry => entry.id === GENERIC_CAPABILITIES_AGENT_DELEGATION_PROMPT_ID)?.kind).to.equal('generic-capability');
+    });
+
+    it('treats declared frontmatter as a capability even when no agent references it yet', () => {
+        const entries = loadEntries({ fragments: { 'shell-execution': [{ name: 'Shell Execution' }] } });
+
+        expect(entries.find(entry => entry.id === 'shell-execution')?.kind).to.equal('capability');
+    });
+
+    it('groups a plain fragment without frontmatter as a snippet', () => {
+        const entries = loadEntries({ fragments: { 'project-info': [{ customizationId: 'workspace', priority: 1 }] } });
+        const snippet = entries.find(entry => entry.id === 'project-info');
+
+        expect(snippet?.kind).to.equal('snippet');
+        // Only a workspace file backs it, so resetting has nothing to fall back to: the row offers Remove.
+        expect(snippet?.customized).to.equal(true);
+        expect(snippet?.hasBuiltIn).to.equal(false);
+    });
+
+    it('reports a customized built-in as customized while keeping its built-in fallback', () => {
+        const entries = loadEntries({ fragments: { github: [{ customizationId: 'user', priority: 1, name: 'GitHub' }, { name: 'GitHub' }] } });
+        const github = entries.find(entry => entry.id === 'github');
+
+        expect(github?.customized).to.equal(true);
+        expect(github?.hasBuiltIn).to.equal(true);
+    });
+
+    it('excludes what other pages own: variant sets and their variants, slash commands, and generated MCP tool lists', () => {
+        const entries = loadEntries({
+            fragments: {
+                'coder-system': [{}],
+                'coder-system-edit': [{}],
+                'remember-conversation-context': [{ isCommand: true, commandName: 'remember' }],
+                // A customization that lost the `isCommand` frontmatter must still not resurface here.
+                'skill-command-refactor': [{ customizationId: 'user', priority: 1 }, { isCommand: true, commandName: 'refactor' }],
+                'mcp_github_tools': [{}],
+                'project-info': [{}]
+            },
+            variantSets: { 'coder-system': ['coder-system-edit'] }
+        });
+
+        expect(entries.map(entry => entry.id)).to.deep.equal(['project-info']);
+    });
+
+    it('counts the agents using a fragment in its pills, after the customization state', () => {
+        const category = new PromptSnippetsConfigurationCategory();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).availableAgents = [{ id: 'coder', name: 'Coder' }, { id: 'architect', name: 'Architect' }] as unknown as Agent[];
+        const build = (agentIds: string[], customized: boolean) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (category as any).buildRow(
+                { id: 'github', kind: 'capability', agentIds, customized, hasBuiltIn: true } as PromptSnippetEntry,
+                { scope: 'user', navigate: () => { }, update: () => { } },
+                () => { }
+            );
+
+        expect(build(['coder'], false).pills).to.deep.equal(['1 agent']);
+        expect(build(['coder', 'architect'], false).pills).to.deep.equal(['2 agents']);
+        // The customization state leads, so it reads before the agent count and the actions.
+        expect(build(['coder'], true).pills).to.deep.equal(['Customized', '1 agent']);
+    });
+
+    it('offers its actions in the row header, whether or not the row is expanded', () => {
+        const category = new PromptSnippetsConfigurationCategory();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).availableAgents = [];
+        const build = (customized: boolean, hasBuiltIn: boolean) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (category as any).buildRow(
+                { id: 'github', kind: 'capability', agentIds: [], customized, hasBuiltIn } as PromptSnippetEntry,
+                { scope: 'user', navigate: () => { }, update: () => { } },
+                () => { }
+            );
+
+        expect(build(false, true).actions).to.not.equal(undefined);
+        expect(build(true, false).actions).to.not.equal(undefined);
+    });
+
+    it('indexes every entry for search under one row-id scheme, so a deep link only needs the fragment id', () => {
+        const category = new PromptSnippetsConfigurationCategory();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).entries = [
+            { id: 'project-info', kind: 'snippet', agentIds: [], customized: false, hasBuiltIn: true },
+            { id: 'github', kind: 'capability', name: 'GitHub', agentIds: ['coder'], customized: false, hasBuiltIn: true },
+            { id: GENERIC_CAPABILITIES_AGENT_DELEGATION_PROMPT_ID, kind: 'generic-capability', agentIds: [], customized: false, hasBuiltIn: true }
+        ] as PromptSnippetEntry[];
+        const items = category.getSearchItems();
+
+        expect(items.map(item => item.target.highlight?.rowId)).to.deep.equal([
+            'fragment:project-info',
+            'fragment:github',
+            `fragment:${GENERIC_CAPABILITIES_AGENT_DELEGATION_PROMPT_ID}`
+        ]);
+        expect(items.map(item => item.label)).to.deep.equal(['project-info', 'GitHub', GENERIC_CAPABILITIES_AGENT_DELEGATION_PROMPT_ID]);
+        expect(new Set(items.map(item => item.typeLabel)).size).to.equal(3);
+        expect(items.every(item => item.target.categoryId === AiConfigurationCategoryId.PROMPT_SNIPPETS)).to.equal(true);
+    });
+
+    it('anchors each rendered row with the id the search item and the agent capability link navigate to', () => {
+        const category = new PromptSnippetsConfigurationCategory();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).availableAgents = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).entries = [
+            { id: 'project-info', kind: 'snippet', agentIds: [], customized: true, hasBuiltIn: false },
+            { id: 'github', kind: 'capability', name: 'GitHub', agentIds: [], customized: false, hasBuiltIn: true }
+        ] as PromptSnippetEntry[];
+        // The page asks the service whether a page-level reset would do anything while rendering.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).promptService = { getAllPromptFragments: () => new Map<string, PromptFragment[]>() };
+        const container = document.createElement('div');
+        document.body.appendChild(container);
+        const root = createRoot(container);
+        try {
+            flushSync(() => root.render(category.renderPage({ scope: 'user', navigate: () => { }, update: () => { } })));
+            const anchored = Array.from(container.querySelectorAll('[data-ai-config-row-id]'))
+                .map(element => element.getAttribute('data-ai-config-row-id'));
+
+            // Without the anchor the scroll-and-flash silently does nothing when navigated to from an agent.
+            expect(anchored).to.include(PromptSnippetsConfiguration.selectionFor('github').highlight!.rowId);
+            expect(anchored).to.include(PromptSnippetsConfiguration.selectionFor('project-info').highlight!.rowId);
+        } finally {
+            flushSync(() => root.unmount());
+            container.remove();
+        }
+    });
+
+    it('offers the page-level reset whenever a customized fragment has a built-in to fall back to', () => {
+        const category = new PromptSnippetsConfigurationCategory();
+        const withFragments = (fragments: Record<string, Partial<PromptFragment>[]>) => {
+            const map = new Map<string, PromptFragment[]>(
+                Object.entries(fragments).map(([id, list]) => [id, list.map(f => ({ id, template: '', ...f }) as PromptFragment)])
+            );
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (category as any).promptService = { getAllPromptFragments: () => map };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return (category as any).hasResettableCustomizations() as boolean;
+        };
+
+        // A customized built-in: resetting reverts it.
+        expect(withFragments({ github: [{ customizationId: 'user', priority: 1 }, {}] })).to.equal(true);
+        // Also true for a prompt variant the page itself does not list, since the reset covers those too.
+        expect(withFragments({ 'coder-system-agent-mode': [{ customizationId: 'user', priority: 1 }, {}] })).to.equal(true);
+        // A user-authored snippet has no built-in, so a reset would do nothing to it.
+        expect(withFragments({ 'project-info': [{ customizationId: 'workspace', priority: 1 }] })).to.equal(false);
+        expect(withFragments({ github: [{}] })).to.equal(false);
+    });
+
+    it('builds the same row id the agent capability deep link navigates to', () => {
+        const selection = PromptSnippetsConfiguration.selectionFor('github');
+
+        expect(selection.categoryId).to.equal(AiConfigurationCategoryId.PROMPT_SNIPPETS);
+        expect(selection.highlight?.rowId).to.equal('fragment:github');
+    });
+});