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

package/src/browser/skill-service.ts

@@ -16,7 +16,7 @@
 
 import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { DisposableCollection, Emitter, Event, ILogger, URI } from '@theia/core';
+import { ContributionProvider, Disposable, DisposableCollection, Emitter, Event, ILogger, MaybePromise, URI } from '@theia/core';
 import { Path } from '@theia/core/lib/common/path';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
@@ -26,6 +26,7 @@ import { AICorePreferences, PREFERENCE_NAME_SKILL_DIRECTORIES } from '../common/
 import {
     Skill,
     SkillDescription,
+    SkillDirectoryEntry,
     SKILL_FILE_NAME,
     validateSkillDescription,
     parseSkillFile,
@@ -35,12 +36,28 @@ import {
 /** Debounce delay for coalescing rapid file system events */
 const UPDATE_DEBOUNCE_MS = 50;
 
+export const SkillDirectoryContribution = Symbol('SkillDirectoryContribution');
+/**
+ * Contributes further roots to scan for skills. Point this at the *parent* of the skill folders,
+ * never at a skill folder itself. Contributed roots form the lowest-precedence `plugin` tier, so a
+ * directory the user controls always wins a path collision.
+ */
+export interface SkillDirectoryContribution {
+    /** Entries carrying a {@link SkillDirectoryEntry.qualifier} have their skills prefixed with it. */
+    getSkillDirectories(): MaybePromise<SkillDirectoryEntry[]>;
+    readonly onDidChange?: Event<void>;
+}
+
 export const SkillService = Symbol('SkillService');
 export interface SkillService {
     /** Get all discovered skills */
     getSkills(): Skill[];
 
-    /** Get a skill by name */
+    /**
+     * Matched against {@link Skill.qualifiedName} first, then the plain
+     * {@link SkillDescription.name} so unqualified references keep resolving. A plain name shared by
+     * several skills is ambiguous and resolves to `undefined`.
+     */
     getSkill(name: string): Skill | undefined;
 
     /** Event fired when skills change */
@@ -51,15 +68,14 @@ export interface SkillService {
 }
 
 @injectable()
-export class DefaultSkillService implements SkillService {
+export class DefaultSkillService implements SkillService, Disposable {
     @inject(AICorePreferences)
     protected readonly preferences: AICorePreferences;
 
     @inject(FileService)
     protected readonly fileService: FileService;
 
-    @inject(ILogger)
-    @named('SkillService')
+    @inject(ILogger) @named('ai-core:DefaultSkillService')
     protected readonly logger: ILogger;
 
     @inject(EnvVariablesServer)
@@ -68,8 +84,16 @@ export class DefaultSkillService implements SkillService {
     @inject(WorkspaceService)
     protected readonly workspaceService: WorkspaceService;
 
+    @inject(ContributionProvider)
+    @named(SkillDirectoryContribution)
+    protected readonly skillDirectoryContributions: ContributionProvider<SkillDirectoryContribution>;
+
+    /** Keyed by {@link Skill.qualifiedName}. */
     protected skills = new Map<string, Skill>();
+    /** Watchers of the current scan; disposed and rebuilt on every rescan. */
     protected toDispose = new DisposableCollection();
+    /** Kept apart from {@link toDispose}, which does not survive a rescan. */
+    protected readonly toDisposeOnServiceDispose = new DisposableCollection();
     protected watchedDirectories = new Set<string>();
     protected parentWatchers = new Map<string, string>();
 
@@ -91,6 +115,12 @@ export class DefaultSkillService implements SkillService {
 
     @postConstruct()
     protected init(): void {
+        for (const contribution of this.skillDirectoryContributions.getContributions()) {
+            if (contribution.onDidChange) {
+                this.toDisposeOnServiceDispose.push(contribution.onDidChange(() => this.scheduleUpdate()));
+            }
+        }
+
         this.fileService.onDidFilesChange(async (event: FileChangesEvent) => {
             for (const change of event.changes) {
                 if (change.type === FileChangeType.ADDED) {
@@ -131,29 +161,43 @@ export class DefaultSkillService implements SkillService {
             }
         });
 
-        // Wait for workspace to be ready before initial update
-        this.workspaceService.ready.then(() => {
-            this.update().then(() => {
-                this._ready.resolve();
-                // Only after initial update, start listening for changes
-                this.lastSkillDirectoriesValue = JSON.stringify(this.preferences[PREFERENCE_NAME_SKILL_DIRECTORIES]);
-
-                this.preferences.onPreferenceChanged(event => {
-                    if (event.preferenceName === PREFERENCE_NAME_SKILL_DIRECTORIES) {
-                        const currentValue = JSON.stringify(this.preferences[PREFERENCE_NAME_SKILL_DIRECTORIES]);
-                        if (currentValue === this.lastSkillDirectoriesValue) {
-                            return;
-                        }
-                        this.lastSkillDirectoriesValue = currentValue;
-                        this.scheduleUpdate();
-                    }
-                });
+        this.initializeSkills();
+    }
 
-                this.workspaceService.onWorkspaceChanged(() => {
-                    this.scheduleUpdate();
-                });
-            });
+    /** Runs the initial scan once the skill directory sources are known. {@link ready} always resolves, even if the scan failed. */
+    protected async initializeSkills(): Promise<void> {
+        try {
+            // The workspace contributes the workspace skill directories, the preferences the configured ones.
+            await Promise.all([this.workspaceService.ready, this.preferences.ready]);
+        } catch (error) {
+            this.logger.error('Failed to resolve skill directory sources, scanning the already known directories', error);
+        }
+
+        // Listen for changes before the initial scan, otherwise a change landing while it runs is recorded as
+        // already applied by the snapshot below and dropped. update()'s in-progress guard coalesces the overlap.
+        this.lastSkillDirectoriesValue = JSON.stringify(this.preferences[PREFERENCE_NAME_SKILL_DIRECTORIES]);
+
+        this.preferences.onPreferenceChanged(event => {
+            if (event.preferenceName === PREFERENCE_NAME_SKILL_DIRECTORIES) {
+                const currentValue = JSON.stringify(this.preferences[PREFERENCE_NAME_SKILL_DIRECTORIES]);
+                if (currentValue === this.lastSkillDirectoriesValue) {
+                    return;
+                }
+                this.lastSkillDirectoriesValue = currentValue;
+                this.scheduleUpdate();
+            }
         });
+
+        this.workspaceService.onWorkspaceChanged(() => {
+            this.scheduleUpdate();
+        });
+
+        try {
+            await this.update();
+        } catch (error) {
+            this.logger.error('Initial skill scan failed', error);
+        }
+        this._ready.resolve();
     }
 
     getSkills(): Skill[] {
@@ -161,7 +205,19 @@ export class DefaultSkillService implements SkillService {
     }
 
     getSkill(name: string): Skill | undefined {
-        return this.skills.get(name);
+        const qualifiedMatch = this.skills.get(name);
+        if (qualifiedMatch) {
+            return qualifiedMatch;
+        }
+        // Ambiguous plain names resolve to nothing: guessing would silently load a skill the caller
+        // did not ask for.
+        const plainMatches = this.getSkills().filter(skill => skill.name === name);
+        return plainMatches.length === 1 ? plainMatches[0] : undefined;
+    }
+
+    dispose(): void {
+        this.toDisposeOnServiceDispose.dispose();
+        this.toDispose.dispose();
     }
 
     protected scheduleUpdate(): void {
@@ -213,21 +269,25 @@ export class DefaultSkillService implements SkillService {
         const configuredDirectories = (this.preferences[PREFERENCE_NAME_SKILL_DIRECTORIES] ?? [])
             .map(dir => Path.untildify(dir, homePath));
         const defaultSkillsDirs = await this.getDefaultSkillsDirectoryPaths();
+        const pluginSkillsDirs = await this.getContributedSkillDirectories();
 
         const newWatchedDirectories = new Set<string>();
         const newParentWatchers = new Map<string, string>();
 
-        const allDirectories = combineSkillDirectories(workspaceSkillsDirs, configuredDirectories, defaultSkillsDirs);
-        for (const { path: directoryPath, tier } of allDirectories) {
+        const allDirectories = combineSkillDirectories(workspaceSkillsDirs, configuredDirectories, defaultSkillsDirs, pluginSkillsDirs);
+        for (const { path: directoryPath, tier, qualifier } of allDirectories) {
             if (tier === 'configured') {
-                await this.processConfiguredSkillDirectory(directoryPath, newSkills, newDisposables, newWatchedDirectories);
+                await this.processConfiguredSkillDirectory(directoryPath, newSkills, newDisposables, newWatchedDirectories, qualifier);
             } else {
+                // `plugin` roots take this path too: a plugin with no `skills` directory is a
+                // plugin without skills, worth watching for rather than warning about.
                 await this.processSkillDirectoryWithParentWatching(
                     directoryPath,
                     newSkills,
                     newDisposables,
                     newWatchedDirectories,
-                    newParentWatchers
+                    newParentWatchers,
+                    qualifier
                 );
             }
         }
@@ -244,6 +304,19 @@ export class DefaultSkillService implements SkillService {
         this.onSkillsChangedEmitter.fire();
     }
 
+    /** A failing contribution is skipped: one broken root must not cost every other skill. */
+    protected async getContributedSkillDirectories(): Promise<SkillDirectoryEntry[]> {
+        const entries: SkillDirectoryEntry[] = [];
+        for (const contribution of this.skillDirectoryContributions.getContributions()) {
+            try {
+                entries.push(...await contribution.getSkillDirectories());
+            } catch (error) {
+                this.logger.error(`Failed to collect contributed skill directories: ${error}`);
+            }
+        }
+        return entries;
+    }
+
     protected getWorkspaceSkillsDirectoryPaths(): string[] {
         return this.workspaceService.tryGetRoots().flatMap(root => [
             root.resource.resolve('.prompts/skills').path.fsPath(),
@@ -267,7 +340,8 @@ export class DefaultSkillService implements SkillService {
         skills: Map<string, Skill>,
         disposables: DisposableCollection,
         watchedDirectories: Set<string>,
-        parentWatchers: Map<string, string>
+        parentWatchers: Map<string, string>,
+        qualifier?: string
     ): Promise<void> {
         const dirURI = URI.fromFilePath(directoryPath);
 
@@ -275,7 +349,7 @@ export class DefaultSkillService implements SkillService {
             const dirExists = await this.fileService.exists(dirURI);
 
             if (dirExists) {
-                await this.processExistingSkillDirectory(dirURI, skills, disposables, watchedDirectories);
+                await this.processExistingSkillDirectory(dirURI, skills, disposables, watchedDirectories, qualifier);
             } else {
                 const parentPath = dirURI.parent.path.fsPath();
                 const parentURI = URI.fromFilePath(parentPath);
@@ -299,7 +373,8 @@ export class DefaultSkillService implements SkillService {
         directoryPath: string,
         skills: Map<string, Skill>,
         disposables: DisposableCollection,
-        watchedDirectories: Set<string>
+        watchedDirectories: Set<string>,
+        qualifier?: string
     ): Promise<void> {
         const dirURI = URI.fromFilePath(directoryPath);
 
@@ -311,7 +386,7 @@ export class DefaultSkillService implements SkillService {
                 return;
             }
 
-            await this.processExistingSkillDirectory(dirURI, skills, disposables, watchedDirectories);
+            await this.processExistingSkillDirectory(dirURI, skills, disposables, watchedDirectories, qualifier);
         } catch (error) {
             this.logger.error(`Error processing configured directory '${directoryPath}': ${error}`);
         }
@@ -321,7 +396,8 @@ export class DefaultSkillService implements SkillService {
         dirURI: URI,
         skills: Map<string, Skill>,
         disposables: DisposableCollection,
-        watchedDirectories: Set<string>
+        watchedDirectories: Set<string>,
+        qualifier?: string
     ): Promise<void> {
         const stat = await this.fileService.resolve(dirURI);
         if (!stat.children) {
@@ -331,14 +407,14 @@ export class DefaultSkillService implements SkillService {
         for (const child of stat.children) {
             if (child.isDirectory) {
                 const directoryName = child.name;
-                await this.loadSkillFromDirectory(child.resource, directoryName, skills);
+                await this.loadSkillFromDirectory(child.resource, directoryName, skills, qualifier);
             }
         }
 
         this.setupDirectoryWatcher(dirURI, disposables, watchedDirectories);
     }
 
-    protected async loadSkillFromDirectory(directoryUri: URI, directoryName: string, skills: Map<string, Skill>): Promise<void> {
+    protected async loadSkillFromDirectory(directoryUri: URI, directoryName: string, skills: Map<string, Skill>, qualifier?: string): Promise<void> {
         const skillFileUri = directoryUri.resolve(SKILL_FILE_NAME);
 
         const fileExists = await this.fileService.exists(skillFileUri);
@@ -366,19 +442,20 @@ export class DefaultSkillService implements SkillService {
                 return;
             }
 
-            const skillName = parsed.metadata.name;
+            const qualifiedName = Skill.qualifyName(parsed.metadata.name, qualifier);
 
-            if (skills.has(skillName)) {
-                this.logger.warn(`Skill '${skillName}': Duplicate skill found in '${directoryName}', using first discovered instance`);
+            if (skills.has(qualifiedName)) {
+                this.logger.warn(`Skill '${qualifiedName}': Duplicate skill found in '${directoryName}', using first discovered instance`);
                 return;
             }
 
             const skill: Skill = {
                 ...parsed.metadata,
-                location: skillFileUri.path.fsPath()
+                location: skillFileUri.path.fsPath(),
+                qualifiedName
             };
 
-            skills.set(skillName, skill);
+            skills.set(qualifiedName, skill);
         } catch (error) {
             this.logger.error(`Failed to load skill from '${directoryName}': ${error}`);
         }

package/src/browser/skills-variable-contribution.spec.ts

@@ -163,11 +163,13 @@ describe('SkillsVariableContribution', () => {
             const skills: Skill[] = [
                 {
                     name: 'pdf-processing',
+                    qualifiedName: 'pdf-processing',
                     description: 'Processes PDF documents and extracts text content',
                     location: '/path/to/skills/pdf-processing/SKILL.md'
                 },
                 {
                     name: 'data-analysis',
+                    qualifiedName: 'data-analysis',
                     description: 'Analyzes data sets and generates reports',
                     location: '/path/to/skills/data-analysis/SKILL.md'
                 }
@@ -207,6 +209,7 @@ describe('SkillsVariableContribution', () => {
             const skills: Skill[] = [
                 {
                     name: 'test-skill',
+                    qualifiedName: 'test-skill',
                     description: 'Handles <tags> & "quotes" with \'apostrophes\'',
                     location: '/path/to/skill/SKILL.md'
                 }
@@ -228,6 +231,7 @@ describe('SkillsVariableContribution', () => {
             const skills: Skill[] = [
                 {
                     name: 'skill<test>',
+                    qualifiedName: 'skill<test>',
                     description: 'Test skill',
                     location: '/path/with/&special/chars'
                 }
@@ -266,6 +270,7 @@ describe('SkillsVariableContribution', () => {
         it('should return skill content when skill found', async () => {
             const skill: Skill = {
                 name: 'my-skill',
+                qualifiedName: 'my-skill',
                 description: 'A test skill',
                 location: '/path/to/skills/my-skill/SKILL.md'
             };
@@ -293,6 +298,7 @@ This is the skill content.`
         it('should return undefined when file read fails', async () => {
             const skill: Skill = {
                 name: 'my-skill',
+                qualifiedName: 'my-skill',
                 description: 'A test skill',
                 location: '/path/to/skills/my-skill/SKILL.md'
             };

package/src/browser/skills-variable-contribution.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { ILogger, MaybePromise, nls, URI } from '@theia/core';
 import {
     AIVariable, AIVariableContext, AIVariableContribution, AIVariableResolutionRequest,
@@ -22,7 +22,7 @@ import {
 } from '../common/variable-service';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { SkillService } from './skill-service';
-import { parseSkillFile } from '../common/skill';
+import { parseSkillFile, Skill } from '../common/skill';
 
 export const SKILLS_VARIABLE: AIVariable = {
     id: 'skills',
@@ -39,6 +39,7 @@ export const SKILL_VARIABLE: AIVariable = {
 };
 
 export interface SkillSummary {
+    /** The name the model has to write to address the skill, i.e. {@link Skill.qualifiedName}. */
     name: string;
     description: string;
     location: string;
@@ -54,7 +55,7 @@ export class SkillsVariableContribution implements AIVariableContribution, AIVar
     @inject(SkillService)
     protected readonly skillService: SkillService;
 
-    @inject(ILogger)
+    @inject(ILogger) @named('ai-core:SkillsVariableContribution')
     protected readonly logger: ILogger;
 
     @inject(FileService)
@@ -80,11 +81,20 @@ export class SkillsVariableContribution implements AIVariableContribution, AIVar
 
         // Handle plural skills variable
         if (request.variable.name === SKILLS_VARIABLE.name) {
-            return this.resolveSkillsVariable(this.skillService.getSkills(), SKILLS_VARIABLE);
+            return this.resolveSkillsVariable(this.skillService.getSkills().map(skill => this.toSkillSummary(skill)), SKILLS_VARIABLE);
         }
         return undefined;
     }
 
+    /** Named by {@link Skill.qualifiedName}: that is what the model has to write to load it again. */
+    toSkillSummary(skill: Skill): SkillSummary {
+        return {
+            name: skill.qualifiedName,
+            description: skill.description,
+            location: skill.location
+        };
+    }
+
     /**
      * Resolves skills into a ResolvedSkillsVariable with XML format.
      */

package/src/browser/theia-variable-contribution.ts

@@ -51,40 +51,40 @@ export class TheiaVariableContribution implements AIVariableContribution, AIVari
         ['file', [
             {
                 name: 'currentAbsoluteFilePath',
-                description: nls.localize('theia/ai/core/variable-contribution/currentAbsoluteFilePath', 'The absolute path of the \
-                currently opened file.')
+                description: nls.localize('theia/ai/core/variable-contribution/currentAbsoluteFilePath',
+                    'The absolute path of the currently opened file.')
             }
         ]],
         ['selectedText', [
             {
-                description: nls.localize('theia/ai/core/variable-contribution/currentSelectedText', 'The plain text that is currently selected in the \
-                opened file. This excludes the information where the content is coming from.')
+                description: nls.localize('theia/ai/core/variable-contribution/currentSelectedText',
+                    'The plain text that is currently selected in the opened file. This excludes the information where the content is coming from.')
             }
         ]],
         ['currentText', [
             {
                 name: 'currentFileContent',
-                description: nls.localize('theia/ai/core/variable-contribution/currentFileContent', 'The plain content of the \
-                currently opened file. This excludes the information where the content is coming from.')
+                description: nls.localize('theia/ai/core/variable-contribution/currentFileContent',
+                    'The plain content of the currently opened file. This excludes the information where the content is coming from.')
             }
         ]],
         ['relativeFile', [
             {
                 name: 'currentRelativeFilePath',
-                description: nls.localize('theia/ai/core/variable-contribution/currentRelativeFilePath', 'The workspace-relative path of the \
-                currently opened file (e.g., my-project/src/index.ts).')
+                description: nls.localize('theia/ai/core/variable-contribution/currentRelativeFilePath',
+                    'The workspace-relative path of the currently opened file (e.g., my-project/src/index.ts).')
             },
             {
                 name: '_f',
-                description: nls.localize('theia/ai/core/variable-contribution/dotRelativePath', 'Short reference to the workspace-relative path of the \
-                currently opened file (\'currentRelativeFilePath\').')
+                description: nls.localize('theia/ai/core/variable-contribution/dotRelativePath',
+                    'Short reference to the workspace-relative path of the currently opened file (\'currentRelativeFilePath\').')
             }
         ]],
         ['relativeFileDirname', [
             {
                 name: 'currentRelativeDirPath',
-                description: nls.localize('theia/ai/core/variable-contribution/currentRelativeDirPath', 'The workspace-relative path of the directory \
-                containing the currently opened file (e.g., my-project/src).')
+                description: nls.localize('theia/ai/core/variable-contribution/currentRelativeDirPath',
+                    'The workspace-relative path of the directory containing the currently opened file (e.g., my-project/src).')
             }
         ]],
         ['lineNumber', [{}]],

package/src/common/ai-core-preferences.ts

@@ -28,6 +28,25 @@ import { ReasoningSettings, SERVER_SIDE_COMPACTION_TOKEN_THRESHOLD_MINIMUM } fro
 import { PreferenceSchema } from '@theia/core/lib/common/preferences/preference-schema';
 
 export const AI_CORE_PREFERENCES_TITLE = nls.localize('theia/ai-core/preferences/title', 'AI Features');
+
+/**
+ * Key under a preference's schema `typeDetails` where a language-model provider declares the
+ * human-readable name of its provider block. The AI Configuration view's Models page reads this to
+ * label the provider node (discovered from the `ai-features.<provider>.*` preferences) without
+ * having to hard-code provider names. Declare it on any one preference of the provider's block, e.g.
+ * `typeDetails: { [MODEL_PROVIDER_TYPE_DETAIL]: 'Anthropic' }`.
+ */
+export const MODEL_PROVIDER_TYPE_DETAIL = 'aiModelProvider';
+
+/**
+ * Shape a language-model provider stores under a preference's `typeDetails[MODEL_PROVIDER_TYPE_DETAIL]`
+ * to describe its `ai-features.<provider>.*` block to the AI Configuration view's Models page. Declared
+ * on any one preference of the block, e.g. `typeDetails: { [MODEL_PROVIDER_TYPE_DETAIL]: { label: 'Anthropic' } }`.
+ */
+export interface ModelProviderTypeDetail {
+    /** Human-readable provider name shown as the provider node/card label. */
+    label: string;
+}
 export const PREFERENCE_NAME_PROMPT_TEMPLATES = 'ai-features.promptTemplates.promptTemplatesFolder';
 export const PREFERENCE_NAME_REQUEST_SETTINGS = 'ai-features.modelSettings.requestSettings';
 export const PREFERENCE_NAME_REASONING = 'ai-features.reasoning.defaults';

package/src/common/ai-variable-resource.ts

@@ -15,8 +15,8 @@
 // *****************************************************************************
 
 import * as deepEqual from 'fast-deep-equal';
-import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { Resource, URI, generateUuid } from '@theia/core';
+import { inject, injectable, postConstruct, named } from '@theia/core/shared/inversify';
+import { Resource, URI, generateUuid, ILogger } from '@theia/core';
 import { AIVariableContext, AIVariableResolutionRequest } from './variable-service';
 import stableJsonStringify = require('fast-json-stable-stringify');
 import { ConfigurableInMemoryResources, ConfigurableMutableReferenceResource } from './configurable-in-memory-resources';
@@ -28,6 +28,9 @@ export const NO_CONTEXT_AUTHORITY = 'context-free';
 export class AIVariableResourceResolver {
     @inject(ConfigurableInMemoryResources) protected readonly inMemoryResources: ConfigurableInMemoryResources;
 
+    @inject(ILogger) @named('ai-core:AIVariableResourceResolver')
+    protected readonly logger: ILogger;
+
     @postConstruct()
     protected init(): void {
         this.inMemoryResources.onWillDispose(resource => this.cache.delete(resource.uri.toString()));
@@ -68,7 +71,7 @@ export class AIVariableResourceResolver {
             }
         } catch (err) {
             // Mostly that deep equal could overflow the stack, but it should run into === or inequality before that.
-            console.warn('Problem evaluating context in AIVariableResourceResolver', err);
+            this.logger.warn('Problem evaluating context in AIVariableResourceResolver', err);
         }
         return generateUuid();
     }

package/src/common/capability-variable-contribution.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { ILogger, nls } from '@theia/core';
-import { injectable, inject } from '@theia/core/shared/inversify';
+import { injectable, inject, named } from '@theia/core/shared/inversify';
 import * as monaco from '@theia/monaco-editor-core';
 import {
     AIVariable,
@@ -49,8 +49,8 @@ export class CapabilityVariableContribution implements AIVariableContribution, A
     @inject(PromptService)
     protected readonly promptService: PromptService;
 
-    @inject(ILogger)
-    protected logger: ILogger;
+    @inject(ILogger) @named('ai-core:CapabilityVariableContribution')
+    protected readonly logger: ILogger;
 
     registerVariables(service: AIVariableService): void {
         service.registerResolver(CAPABILITY_VARIABLE, this);

package/src/common/language-model.spec.ts

@@ -21,6 +21,7 @@ import {
     isLanguageModelStreamResponsePart,
     isModelMatching,
     isToolCallContent,
+    isToolCallHtmlAppResult,
     LanguageModel,
     LanguageModelSelector,
     resolveCompactionDefault,
@@ -260,3 +261,85 @@ describe('compaction contract', () => {
         expect(resolveServerSideCompaction(true, true, { enabled: false })).to.equal(false);
     });
 });
+
+describe('isToolCallHtmlAppResult', () => {
+    it('returns true for valid html app result', () => {
+        expect(isToolCallHtmlAppResult({ type: 'html', html: '<div>Hello</div>' })).to.be.true;
+    });
+
+    it('returns true with optional title', () => {
+        expect(isToolCallHtmlAppResult({ type: 'html', html: '<p>App</p>', title: 'My App' })).to.be.true;
+    });
+
+    it('returns false for text result', () => {
+        expect(isToolCallHtmlAppResult({ type: 'text', text: 'hello' })).to.be.false;
+    });
+
+    it('returns false for missing html field', () => {
+        expect(isToolCallHtmlAppResult({ type: 'html' })).to.be.false;
+    });
+
+    it('returns false for null', () => {
+        expect(isToolCallHtmlAppResult(undefined)).to.be.false;
+    });
+
+    it('returns false for undefined', () => {
+        expect(isToolCallHtmlAppResult(undefined)).to.be.false;
+    });
+
+    it('returns true for full iframe-ready html app result', () => {
+        const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Animated Unit Test Sandbox</title>
+<style>
+ html, body { margin: 0; height: 100%; overflow: hidden; background: #0f172a; font-family: Inter, Arial, sans-serif; }
+ .scene { position: relative; width: 100%; height: 100%; background: radial-gradient(circle at top, #1e293b 0%, #020617 70%); overflow: hidden; }
+ .grid { position: absolute; inset: 0; background-size: 40px 40px; animation: drift 12s linear infinite;
+  background-image: linear-gradient(rgba(255,255,255,0.04) 1px, transparent 1px),
+  linear-gradient(90deg, rgba(255,255,255,0.04) 1px, transparent 1px); }
+ @keyframes drift { from { transform: translateY(0px); } to { transform: translateY(40px); } }
+ .panel { position: absolute; top: 50%; left: 50%; width: 340px;
+  transform: translate(-50%, -50%); background: rgba(15, 23, 42, 0.85);
+  border: 1px solid rgba(255,255,255,0.1); border-radius: 20px; padding: 24px;
+  box-shadow: 0 0 50px rgba(59,130,246,0.3), inset 0 0 30px rgba(255,255,255,0.03);
+  backdrop-filter: blur(10px); }
+ .title { color: white; font-size: 24px; font-weight: 700; margin-bottom: 8px; }
+ .subtitle { color: #94a3b8; margin-bottom: 24px; }
+ .test { display: flex; align-items: center; gap: 12px; margin-bottom: 16px;
+  color: white; font-size: 14px; opacity: 0; transform: translateX(-10px);
+  animation: reveal 0.5s forwards; }
+ .test:nth-child(3) { animation-delay: 0.2s; }
+ .test:nth-child(4) { animation-delay: 0.5s; }
+ .test:nth-child(5) { animation-delay: 0.8s; }
+ .test:nth-child(6) { animation-delay: 1.1s; }
+ @keyframes reveal { to { opacity: 1; transform: translateX(0); } }
+ .dot { width: 12px; height: 12px; border-radius: 50%; background: #22c55e; box-shadow: 0 0 12px #22c55e; animation: pulse 1.5s infinite; }
+ .warn { background: #f59e0b; box-shadow: 0 0 12px #f59e0b; }
+ .fail { background: #ef4444; box-shadow: 0 0 12px #ef4444; }
+ @keyframes pulse { 0%, 100% { transform: scale(1); opacity: 1; } 50% { transform: scale(1.4); opacity: 0.7; } }
+ .particle { position: absolute; border-radius: 50%; background: rgba(96,165,250,0.25); animation: float linear infinite; }
+ @keyframes float { from { transform: translateY(100vh) scale(0.5); } to { transform: translateY(-120px) scale(1.2); } }
+ .footer { margin-top: 20px; color: #64748b; font-size: 12px; text-align: center; }
+</style>
+</head>
+<body>
+<div class="scene">
+ <div class="grid"></div>
+ <div class="panel">
+  <div class="title">Unit Test Runner</div>
+  <div class="subtitle">Simulated CI Environment</div>
+  <div class="test"><div class="dot"></div>auth.service.spec.ts</div>
+  <div class="test"><div class="dot"></div>payments.integration.spec.ts</div>
+  <div class="test"><div class="dot warn"></div>websocket.reconnect.spec.ts</div>
+  <div class="test"><div class="dot fail"></div>cache.invalidation.spec.ts</div>
+  <div class="footer">24 passed • 1 flaky • 1 failed</div>
+ </div>
+</div>
+</body>
+</html>`;
+        expect(isToolCallHtmlAppResult({ type: 'html', html, title: 'Animated Unit Test Sandbox' })).to.be.true;
+    });
+});