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

package/src/common/language-model.ts

@@ -534,13 +534,21 @@ export const isCompactionResponsePart = (part: unknown): part is CompactionRespo
 export interface ToolCallTextResult { type: 'text', text: string; };
 export interface ToolCallImageResult extends Base64ImageContent { type: 'image' };
 export interface ToolCallAudioResult { type: 'audio', data: string; mimeType: string };
+export interface ToolCallHtmlAppResult { type: 'html'; html: string; title?: string };
 export type ToolCallErrorKind = 'tool-not-available';
 export interface ToolCallErrorResult { type: 'error', data: string; errorKind?: ToolCallErrorKind; };
-export type ToolCallContentResult = ToolCallTextResult | ToolCallImageResult | ToolCallAudioResult | ToolCallErrorResult;
+export type ToolCallContentResult = ToolCallTextResult | ToolCallImageResult | ToolCallAudioResult | ToolCallHtmlAppResult | ToolCallErrorResult;
 export interface ToolCallContent {
     content: ToolCallContentResult[];
 }
 
+export const isToolCallHtmlAppResult = (item: unknown): item is ToolCallHtmlAppResult =>
+    !!(item &&
+        typeof item === 'object' &&
+        'type' in item && (item as ToolCallHtmlAppResult).type === 'html' &&
+        'html' in item &&
+        typeof (item as ToolCallHtmlAppResult).html === 'string');
+
 export const isToolCallContent = (result: unknown): result is ToolCallContent =>
     !!(result && typeof result === 'object' && 'content' in result && Array.isArray((result as ToolCallContent).content));
 
@@ -560,6 +568,26 @@ export const createToolCallError = (message: string, errorKind?: ToolCallErrorKi
     content: [errorKind ? { type: 'error', data: message, errorKind } : { type: 'error', data: message }]
 });
 
+/**
+ * Serializes a {@link ToolCallResult} to a string suitable for sending back to the model.
+ *
+ * HTML app results are replaced with a compact placeholder so that large bundled HTML
+ * (e.g. Plotly charts) does not blow the model's context window. The full HTML is still
+ * available in the structured result for rendering in the UI (e.g. via McpAppFrame).
+ */
+export function formatToolCallContentForModel(result: ToolCallResult): string {
+    if (isToolCallContent(result)) {
+        return result.content.map(c => {
+            if (c.type === 'text') { return c.text; }
+            if (c.type === 'html') { return `[interactive app displayed to the user${c.title ? ': ' + c.title : ''}]`; }
+            if (c.type === 'error') { return c.data; }
+            return JSON.stringify(c);
+        }).join('\n');
+    }
+    if (typeof result === 'string') { return result; }
+    return JSON.stringify(result);
+}
+
 export type ToolCallResult = undefined | object | string | ToolCallContent;
 export interface ToolCall {
     id?: string;
@@ -703,8 +731,10 @@ export interface FrontendLanguageModelRegistry extends LanguageModelRegistry {
 
 @injectable()
 export class DefaultLanguageModelRegistryImpl implements LanguageModelRegistry {
-    @inject(ILogger)
-    protected logger: ILogger;
+
+    @inject(ILogger) @named('ai-core:DefaultLanguageModelRegistryImpl')
+    protected readonly logger: ILogger;
+
     @inject(ContributionProvider) @named(LanguageModelProvider)
     protected readonly languageModelContributions: ContributionProvider<LanguageModelProvider>;
 
@@ -735,7 +765,7 @@ export class DefaultLanguageModelRegistryImpl implements LanguageModelRegistry {
     addLanguageModels(models: LanguageModel[]): void {
         models.forEach(model => {
             if (this.languageModels.find(lm => lm.id === model.id)) {
-                console.warn(`Tried to add already existing language model with id ${model.id}. The new model will be ignored.`);
+                this.logger.warn(`Tried to add already existing language model with id ${model.id}. The new model will be ignored.`);
                 return;
             }
             this.languageModels.push(model);
@@ -762,7 +792,7 @@ export class DefaultLanguageModelRegistryImpl implements LanguageModelRegistry {
                 this.languageModels.splice(index, 1);
                 this.changeEmitter.fire({ models: this.languageModels });
             } else {
-                console.warn(`Language model with id ${id} was requested to be removed, however it does not exist`);
+                this.logger.warn(`Language model with id ${id} was requested to be removed, however it does not exist`);
             }
         });
     }

package/src/common/prompt-service.spec.ts

@@ -669,3 +669,46 @@ describe('CustomAgentDescription', () => {
         });
     });
 });
+
+describe('PromptService variable arguments', () => {
+    let promptService: PromptService;
+
+    beforeEach(() => {
+        const container = new Container();
+        container.bind<PromptService>(PromptService).to(PromptServiceImpl).inSingletonScope();
+
+        const variableService = new DefaultAIVariableService({ getContributions: () => [] });
+        (variableService as unknown as Record<string, unknown>)['logger'] = sinon.createStubInstance(Logger);
+        // A resolver that echoes what it was given, so that the test asserts on the split of the
+        // reference into variable name and argument rather than on any resolver behaviour.
+        const fileVariable = { id: 'file', name: 'file', description: 'Echoes its argument' };
+        variableService.registerResolver(fileVariable, {
+            canResolve: () => 100,
+            resolve: async request => ({ variable: fileVariable, value: `arg=${request.arg}` })
+        });
+        container.bind<AIVariableService>(AIVariableService).toConstantValue(variableService);
+        container.bind<ILogger>(ILogger).toConstantValue(new MockLogger);
+
+        promptService = container.get<PromptService>(PromptService);
+    });
+
+    it('keeps the whole argument of a variable reference whose argument contains further colons', async () => {
+        // Regression test: the reference used to be split with `split(':', 2)`, which truncates, so a
+        // Windows path lost everything from its drive-letter colon onwards.
+        promptService.addBuiltInPromptFragment({ id: 'windows-path', template: 'Read {{file:C:\\some\\path}}' });
+        const prompt = await promptService.getResolvedPromptFragment('windows-path');
+        expect(prompt?.text).to.equal('Read arg=C:\\some\\path');
+    });
+
+    it('keeps a single-colon argument intact', async () => {
+        promptService.addBuiltInPromptFragment({ id: 'simple-arg', template: 'Read {{file:workspace/path/name.ext}}' });
+        const prompt = await promptService.getResolvedPromptFragment('simple-arg');
+        expect(prompt?.text).to.equal('Read arg=workspace/path/name.ext');
+    });
+
+    it('resolves a reference without an argument with an undefined argument', async () => {
+        promptService.addBuiltInPromptFragment({ id: 'no-arg', template: 'Read {{file}}' });
+        const prompt = await promptService.getResolvedPromptFragment('no-arg');
+        expect(prompt?.text).to.equal('Read arg=undefined');
+    });
+});

package/src/common/prompt-service.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { Event, Emitter, URI, ILogger, DisposableCollection } from '@theia/core';
-import { inject, injectable, optional, postConstruct } from '@theia/core/shared/inversify';
+import { inject, injectable, optional, postConstruct, named } from '@theia/core/shared/inversify';
 import { AIVariableArg, AIVariableContext, AIVariableService, createAIResolveVariableCache, ResolvedAIVariable } from './variable-service';
 import { ToolInvocationRegistry } from './tool-invocation-registry';
 import { toolRequestToPromptText } from './language-model-util';
@@ -607,7 +607,7 @@ export interface PromptService {
 
 @injectable()
 export class PromptServiceImpl implements PromptService {
-    @inject(ILogger)
+    @inject(ILogger) @named('ai-core:PromptServiceImpl')
     protected readonly logger: ILogger;
 
     @inject(AISettingsService) @optional()
@@ -983,10 +983,12 @@ export class PromptServiceImpl implements PromptService {
             let variableName = variableAndArg;
             let argument: string | undefined;
 
-            const parts = variableAndArg.split(':', 2);
-            if (parts.length > 1) {
-                variableName = parts[0];
-                argument = parts[1];
+            // First colon only, keeping the whole remainder: `split(':', 2)` truncates instead, which
+            // mangles every argument containing a colon, e.g. `{{file:C:\some\path}}`.
+            const separatorIndex = variableAndArg.indexOf(':');
+            if (separatorIndex >= 0) {
+                variableName = variableAndArg.substring(0, separatorIndex);
+                argument = variableAndArg.substring(separatorIndex + 1);
             }
 
             let replacementValue: string;

package/src/common/skill.spec.ts

@@ -17,7 +17,10 @@
 import { expect } from 'chai';
 import {
     SKILL_FILE_NAME,
+    Skill,
     SkillDescription,
+    SkillDirectoryEntry,
+    combineSkillDirectories,
     isValidSkillName,
     validateSkillDescription
 } from './skill';
@@ -218,5 +221,101 @@ describe('Skill Types', () => {
             const errors = validateSkillDescription(description, 'my-skill');
             expect(errors).to.be.empty;
         });
+
+        it('does not require the frontmatter name of an owned skill to carry its qualifier', () => {
+            // Qualification is layered on top of the name; it never changes what an artifact has to
+            // write into its SKILL.md, which would change the artifact's content hash.
+            const description: SkillDescription = {
+                name: 'query-builder',
+                description: 'Build SQL'
+            };
+            expect(validateSkillDescription(description, 'query-builder')).to.be.empty;
+            expect(Skill.qualifyName(description.name, 'bq')).to.equal('bq:query-builder');
+        });
+    });
+
+    describe('Skill.qualifyName', () => {
+        it('returns the plain name when there is no qualifier', () => {
+            expect(Skill.qualifyName('code-review')).to.equal('code-review');
+        });
+
+        it('prefixes the name with the qualifier', () => {
+            expect(Skill.qualifyName('query-builder', 'bigquery-data-analytics')).to.equal('bigquery-data-analytics:query-builder');
+        });
+    });
+
+    describe('Skill.qualifierOf', () => {
+        const skill = (name: string, qualifiedName: string): Skill =>
+            ({ name, description: 'd', location: '/skills/' + name + '/SKILL.md', qualifiedName });
+
+        it('returns undefined for a skill from a built-in root', () => {
+            expect(Skill.qualifierOf(skill('code-review', 'code-review'))).to.be.undefined;
+        });
+
+        it('returns the qualifier of a contributed skill', () => {
+            expect(Skill.qualifierOf(skill('query-builder', 'bq:query-builder'))).to.equal('bq');
+        });
+
+        it('round-trips with qualifyName', () => {
+            const qualifiedName = Skill.qualifyName('query-builder', 'io.github.acme_tools');
+            expect(Skill.qualifierOf(skill('query-builder', qualifiedName))).to.equal('io.github.acme_tools');
+        });
+    });
+
+    describe('combineSkillDirectories with plugin directories', () => {
+        const pluginEntry: SkillDirectoryEntry = {
+            path: '/home/user/.agents/plugins/io.example.bq/skills',
+            tier: 'plugin',
+            qualifier: 'bq'
+        };
+
+        it('appends plugin directories after every user-controlled tier', () => {
+            const result = combineSkillDirectories(
+                ['/workspace/.prompts/skills'],
+                ['/custom/skills'],
+                ['/home/user/.agents/skills'],
+                [pluginEntry]
+            );
+
+            expect(result).to.deep.equal([
+                { path: '/workspace/.prompts/skills', tier: 'workspace' },
+                { path: '/custom/skills', tier: 'configured' },
+                { path: '/home/user/.agents/skills', tier: 'default' },
+                pluginEntry
+            ]);
+        });
+
+        it('keeps the qualifier of a plugin directory', () => {
+            const result = combineSkillDirectories([], [], [], [pluginEntry]);
+            expect(result[0].qualifier).to.equal('bq');
+        });
+
+        it('drops a plugin directory whose path a user-controlled tier already claimed, so the user wins the collision', () => {
+            const result = combineSkillDirectories(
+                [],
+                [pluginEntry.path],
+                [],
+                [pluginEntry]
+            );
+
+            expect(result).to.deep.equal([
+                { path: pluginEntry.path, tier: 'configured' }
+            ]);
+        });
+
+        it('deduplicates two plugin directories with the same path, keeping the first', () => {
+            const second: SkillDirectoryEntry = {
+                ...pluginEntry,
+                qualifier: 'other'
+            };
+            const result = combineSkillDirectories([], [], [], [pluginEntry, second]);
+            expect(result).to.deep.equal([pluginEntry]);
+        });
+
+        it('behaves exactly as before when no plugin directories are passed', () => {
+            expect(combineSkillDirectories(['/workspace/skills'], [], [])).to.deep.equal([
+                { path: '/workspace/skills', tier: 'workspace' }
+            ]);
+        });
     });
 });

package/src/common/skill.ts

@@ -87,6 +87,32 @@ export namespace SkillDescription {
 export interface Skill extends SkillDescription {
     /** Absolute file path to the SKILL.md file */
     location: string;
+    /**
+     * What the runtime and the model address this skill by: `name` for a built-in root,
+     * `<qualifier>:<name>` for a contributed one. Unlike `name` this is unique across all discovered
+     * skills, which is why it keys the registry.
+     */
+    qualifiedName: string;
+}
+
+export namespace Skill {
+    /**
+     * Never changes what is written in `SKILL.md` - the frontmatter `name` must still equal the
+     * skill's directory name; qualification is layered on top.
+     */
+    export function qualifyName(name: string, qualifier?: string): string {
+        return qualifier ? `${qualifier}:${name}` : name;
+    }
+
+    /**
+     * The qualifier of {@link Skill.qualifiedName}, or `undefined` for a skill from a built-in root.
+     * Unambiguous because neither part can contain a colon: a skill name is validated as lowercase
+     * kebab-case, and a qualifier has to be a single path segment.
+     */
+    export function qualifierOf(skill: Skill): string | undefined {
+        const separatorIndex = skill.qualifiedName.indexOf(':');
+        return separatorIndex < 0 ? undefined : skill.qualifiedName.substring(0, separatorIndex);
+    }
 }
 
 /**
@@ -144,10 +170,8 @@ export function parseSkillFile(content: string): { metadata: SkillDescription |
     return { metadata, content: body };
 }
 
-/**
- * Provenance tier of a skill directory, used to dispatch tier-specific processing.
- */
-export type SkillDirectoryTier = 'workspace' | 'configured' | 'default';
+/** Provenance tier of a skill directory, used to dispatch tier-specific processing. */
+export type SkillDirectoryTier = 'workspace' | 'configured' | 'default' | 'plugin';
 
 /**
  * A skill directory paired with the tier it originates from.
@@ -157,32 +181,43 @@ export interface SkillDirectoryEntry {
     path: string;
     /** Tier the directory belongs to */
     tier: SkillDirectoryTier;
+    /**
+     * Prefixes the names of skills beneath this root, as `<qualifier>:<name>`. Skills are addressed
+     * by one global name, so two artifacts shipping the same skill name could not otherwise coexist -
+     * and renaming the directory instead would change the artifact's content hash. Must be a single
+     * path segment, so that it can be told from the skill name it is joined to.
+     */
+    qualifier?: string;
 }
 
 /**
- * Combines skill directories with proper priority ordering and provenance.
- * Workspace directories have highest priority, followed by configured directories, then defaults.
+ * Combines skill directories with proper priority ordering and provenance: workspace, then
+ * configured, then defaults, then installed artifacts - so a directory the user controls always wins.
  * First occurrence of a path wins on duplicates; later occurrences (regardless of tier) are dropped.
  */
 export function combineSkillDirectories(
     workspaceSkillsDirs: string[],
     configuredDirectories: string[],
-    defaultSkillsDirs: string[]
+    defaultSkillsDirs: string[],
+    pluginSkillsDirs: SkillDirectoryEntry[] = []
 ): SkillDirectoryEntry[] {
     const seen = new Set<string>();
     const result: SkillDirectoryEntry[] = [];
-    const tiers: Array<{ dirs: string[]; tier: SkillDirectoryTier }> = [
-        { dirs: workspaceSkillsDirs, tier: 'workspace' },
-        { dirs: configuredDirectories, tier: 'configured' },
-        { dirs: defaultSkillsDirs, tier: 'default' }
+    const candidates: SkillDirectoryEntry[] = [
+        ...toSkillDirectoryEntries(workspaceSkillsDirs, 'workspace'),
+        ...toSkillDirectoryEntries(configuredDirectories, 'configured'),
+        ...toSkillDirectoryEntries(defaultSkillsDirs, 'default'),
+        ...pluginSkillsDirs
     ];
-    for (const { dirs, tier } of tiers) {
-        for (const dir of dirs) {
-            if (!seen.has(dir)) {
-                seen.add(dir);
-                result.push({ path: dir, tier });
-            }
+    for (const candidate of candidates) {
+        if (!seen.has(candidate.path)) {
+            seen.add(candidate.path);
+            result.push(candidate);
         }
     }
     return result;
 }
+
+function toSkillDirectoryEntries(dirs: string[], tier: SkillDirectoryTier): SkillDirectoryEntry[] {
+    return dirs.map(dir => ({ path: dir, tier }));
+}

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

@@ -24,7 +24,8 @@ export namespace TodayVariableArgs {
 
 export const TODAY_VARIABLE: AIVariable = {
     id: 'today-provider',
-    description: nls.localize('theia/ai/core/todayVariable/description', 'Does something for today'),
+    description: nls.localize('theia/ai/core/todayVariable/dateDescription',
+        'The current date. Resolves to a human-readable date string by default, or to ISO 8601 or Unix seconds via the format argument.'),
     name: 'today',
     args: [
         {

package/src/common/tool-invocation-registry.ts

@@ -16,7 +16,7 @@
 
 import { inject, injectable, named, postConstruct, interfaces } from '@theia/core/shared/inversify';
 import { ToolRequest } from './language-model';
-import { ContributionProvider, Emitter, Event } from '@theia/core';
+import { ContributionProvider, Emitter, Event, ILogger } from '@theia/core';
 
 export const ToolInvocationRegistry = Symbol('ToolInvocationRegistry');
 
@@ -99,6 +99,9 @@ export class ToolInvocationRegistryImpl implements ToolInvocationRegistry {
     @named(ToolProvider)
     private providers: ContributionProvider<ToolProvider>;
 
+    @inject(ILogger) @named('ai-core:ToolInvocationRegistryImpl')
+    protected readonly logger: ILogger;
+
     @postConstruct()
     init(): void {
         this.providers.getContributions().forEach(provider => {
@@ -135,7 +138,7 @@ export class ToolInvocationRegistryImpl implements ToolInvocationRegistry {
 
     registerTool(tool: ToolRequest): void {
         if (this.tools.has(tool.id)) {
-            console.warn(`Function with id ${tool.id} is already registered.`);
+            this.logger.warn(`Function with id ${tool.id} is already registered.`);
         } else {
             this.tools.set(tool.id, tool);
             this.onDidChangeEmitter.fire();

package/src/node/language-model-frontend-delegate.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 { CancellationToken, CancellationTokenSource, ILogger, generateUuid } from '@theia/core';
 import {
     LanguageModelMetaData,
@@ -53,8 +53,8 @@ export class LanguageModelFrontendDelegateImpl implements LanguageModelFrontendD
     @inject(LanguageModelRegistry)
     private registry: LanguageModelRegistry;
 
-    @inject(ILogger)
-    private logger: ILogger;
+    @inject(ILogger) @named('ai-core:LanguageModelFrontendDelegateImpl')
+    protected readonly logger: ILogger;
 
     private frontendDelegateClient: LanguageModelDelegateClient;
     private requestCancellationTokenMap: Map<string, CancellationTokenSource> = new Map();