@theia/ai-core 1.58.3 → 1.59.0-next.72

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

@@ -14,10 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
+import { nls } from '@theia/core/lib/common/nls';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { VariableRegistry, VariableResolverService } from '@theia/variable-resolver/lib/browser';
 import { AIVariableContribution, AIVariableResolver, AIVariableService, AIVariableResolutionRequest, AIVariableContext, ResolvedAIVariable } from '../common';
 
+/**
+ * Integrates the Theia VariableRegistry with the Theia AI VariableService
+ */
 @injectable()
 export class TheiaVariableContribution implements AIVariableContribution, AIVariableResolver {
     @inject(VariableResolverService)
@@ -29,12 +33,21 @@ export class TheiaVariableContribution implements AIVariableContribution, AIVari
     @inject(FrontendApplicationStateService)
     protected readonly stateService: FrontendApplicationStateService;
 
+    protected variableRenameMap: Map<string, string> = new Map([
+        ['file', 'currentFilePath'],
+    ]);
+
     registerVariables(service: AIVariableService): void {
         this.stateService.reachedState('initialized_layout').then(() => {
             // some variable contributions in Theia are done as part of the onStart, same as our AI variable contributions
             // we therefore wait for all of them to be registered before we register we map them to our own
             this.variableRegistry.getVariables().forEach(variable => {
-                service.registerResolver({ id: `theia-${variable.name}`, name: variable.name, description: variable.description ?? 'Theia Built-in Variable' }, this);
+                const variableName = this.variableRenameMap.has(variable.name) ? this.variableRenameMap.get(variable.name)! : variable.name;
+                service.registerResolver({
+                    id: `theia-${variable.name}`,
+                    name: variableName,
+                    description: variable.description ?? nls.localize('theia/ai/core/variable-contribution/builtInVariable', 'Theia Built-in Variable')
+                }, this);
             });
         });
     }

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

@@ -15,13 +15,13 @@
 // *****************************************************************************
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { AIVariable, AIVariableContext, AIVariableContribution, AIVariableResolutionRequest, AIVariableResolver, AIVariableService, ResolvedAIVariable } from './variable-service';
-import { MaybePromise } from '@theia/core';
+import { MaybePromise, nls } from '@theia/core';
 import { AgentService } from './agent-service';
 
 export const AGENTS_VARIABLE: AIVariable = {
     id: 'agents',
     name: 'agents',
-    description: 'Returns the list of agents available in the system'
+    description: nls.localize('theia/ai/core/agentsVariable/description', 'Returns the list of agents available in the system')
 };
 
 export interface ResolvedAgentsVariable extends ResolvedAIVariable {

package/src/common/index.ts

@@ -23,8 +23,8 @@ export * from './language-model-util';
 export * from './language-model';
 export * from './prompt-service';
 export * from './prompt-service-util';
+export * from './prompt-text';
 export * from './protocol';
 export * from './today-variable-contribution';
-export * from './tomorrow-variable-contribution';
 export * from './variable-service';
 export * from './settings-service';

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

@@ -64,21 +64,4 @@ export const getJsonOfText = (text: string): unknown => {
     throw new Error('Invalid response format');
 };
 
-export const toolRequestToPromptText = (toolRequest: ToolRequest): string => {
-    const parameters = toolRequest.parameters;
-    let paramsText = '';
-    // parameters are supposed to be as a JSON schema. Thus, derive the parameters from its properties definition
-    if (parameters) {
-        const properties = parameters.properties;
-        paramsText = Object.keys(properties)
-            .map(key => {
-                const param = properties[key];
-                return `${key}: ${param.type}`;
-            })
-            .join(', ');
-    }
-    const descriptionText = toolRequest.description
-        ? `: ${toolRequest.description}`
-        : '';
-    return `You can call function: ${toolRequest.id}(${paramsText})${descriptionText}`;
-};
+export const toolRequestToPromptText = (toolRequest: ToolRequest): string => `${toolRequest.id}`;

package/src/common/prompt-service.ts

@@ -16,7 +16,7 @@
 
 import { URI, Event } from '@theia/core';
 import { inject, injectable, optional } from '@theia/core/shared/inversify';
-import { AIVariableService } from './variable-service';
+import { AIVariableContext, AIVariableService } from './variable-service';
 import { ToolInvocationRegistry } from './tool-invocation-registry';
 import { toolRequestToPromptText } from './language-model-util';
 import { ToolRequest } from './language-model';
@@ -67,7 +67,7 @@ export interface PromptService {
      * @param id the id of the prompt
      * @param args the object with placeholders, mapping the placeholder key to the value
      */
-    getPrompt(id: string, args?: { [key: string]: unknown }): Promise<ResolvedPromptTemplate | undefined>;
+    getPrompt(id: string, args?: { [key: string]: unknown }, context?: AIVariableContext): Promise<ResolvedPromptTemplate | undefined>;
     /**
      * Adds a {@link PromptTemplate} to the list of prompts.
      * @param promptTemplate the prompt template to store
@@ -239,7 +239,7 @@ export class PromptServiceImpl implements PromptService {
         return id;
     }
 
-    async getPrompt(id: string, args?: { [key: string]: unknown }): Promise<ResolvedPromptTemplate | undefined> {
+    async getPrompt(id: string, args?: { [key: string]: unknown }, context?: AIVariableContext): Promise<ResolvedPromptTemplate | undefined> {
         const variantId = await this.getVariantId(id);
         const prompt = this.getUnresolvedPrompt(variantId);
         if (prompt === undefined) {
@@ -262,7 +262,7 @@ export class PromptServiceImpl implements PromptService {
                 value: String(args?.[variableAndArg] ?? (await this.variableService?.resolveVariable({
                     variable: variableName,
                     arg: argument
-                }, {}))?.value ?? completeText)
+                }, context ?? {}))?.value ?? completeText)
             };
         }));
 

package/src/common/prompt-text.ts

@@ -0,0 +1,22 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// 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
+// *****************************************************************************
+
+export namespace PromptText {
+    export const AGENT_CHAR = '@';
+    export const VARIABLE_CHAR = '#';
+    export const FUNCTION_CHAR = '~';
+    export const VARIABLE_SEPARATOR_CHAR = ':';
+}

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

@@ -13,7 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { MaybePromise } from '@theia/core';
+import { MaybePromise, nls } from '@theia/core';
 import { injectable } from '@theia/core/shared/inversify';
 import { AIVariable, ResolvedAIVariable, AIVariableContribution, AIVariableResolver, AIVariableService, AIVariableResolutionRequest, AIVariableContext } from './variable-service';
 
@@ -24,11 +24,15 @@ export namespace TodayVariableArgs {
 
 export const TODAY_VARIABLE: AIVariable = {
     id: 'today-provider',
-    description: 'Does something for today',
+    description: nls.localize('theia/ai/core/todayVariable/description', 'Does something for today'),
     name: 'today',
     args: [
-        { name: TodayVariableArgs.IN_ISO_8601, description: 'Returns the current date in ISO 8601 format' },
-        { name: TodayVariableArgs.IN_UNIX_SECONDS, description: 'Returns the current date in unix seconds format' }
+        {
+            name: 'Format',
+            description: nls.localize('theia/ai/core/todayVariable/format/description', 'The format of the date'),
+            enum: [TodayVariableArgs.IN_ISO_8601, TodayVariableArgs.IN_UNIX_SECONDS],
+            isOptional: true
+        }
     ]
 };
 

package/src/common/variable-service.ts

@@ -21,37 +21,112 @@
 
 import { ContributionProvider, Disposable, Emitter, ILogger, MaybePromise, Prioritizeable, Event } from '@theia/core';
 import { inject, injectable, named } from '@theia/core/shared/inversify';
+import * as monaco from '@theia/monaco-editor-core';
 
+/**
+ * A variable is a short string that is used to reference a value that is resolved and replaced in the user prompt at request-time.
+ */
 export interface AIVariable {
     /** provider id */
     id: string;
-    /** variable name */
+    /** variable name, used for referencing variables in the chat */
     name: string;
     /** variable description */
     description: string;
+    /** optional label, used for showing the variable in the UI. If not provided, the variable name is used */
+    label?: string;
+    /** optional icon classes, used for showing the variable in the UI. */
+    iconClasses?: string[];
+    /** specifies whether this variable contributes to the context -- @see ResolvedAIContextVariable */
+    isContextVariable?: boolean;
+    /** optional arguments for resolving the variable into a value */
     args?: AIVariableDescription[];
 }
 
+export namespace AIVariable {
+    export function is(arg: unknown): arg is AIVariable {
+        return !!arg && typeof arg === 'object' &&
+            'id' in arg &&
+            'name' in arg &&
+            'description' in arg;
+    }
+}
+
+export interface AIContextVariable extends AIVariable {
+    label: string;
+    isContextVariable: true;
+}
+
+export namespace AIContextVariable {
+    export function is(arg: unknown): arg is AIContextVariable {
+        return AIVariable.is(arg) && 'isContextVariable' in arg && arg.isContextVariable === true;
+    }
+}
+
 export interface AIVariableDescription {
     name: string;
     description: string;
+    enum?: string[];
+    isOptional?: boolean;
 }
 
 export interface ResolvedAIVariable {
     variable: AIVariable;
+    arg?: string;
+    /** value that is inserted into the prompt at the position of the variable usage */
     value: string;
 }
 
+export namespace ResolvedAIVariable {
+    export function is(arg: unknown): arg is ResolvedAIVariable {
+        return !!arg && typeof arg === 'object' &&
+            'variable' in arg &&
+            'value' in arg &&
+            typeof (arg as { variable: unknown }).variable === 'object' &&
+            typeof (arg as { value: unknown }).value === 'string';
+    }
+}
+
+/**
+ * A context variable is a variable that also contributes to the context of a chat request.
+ *
+ * In contrast to a plain variable, it can also be attached to a request and is resolved into a context value.
+ * The context value is put into the `ChatRequestModel.context`, available to the processing chat agent for further
+ * processing by the chat agent, or invoked tool functions.
+ */
+export interface ResolvedAIContextVariable extends ResolvedAIVariable {
+    contextValue: string;
+}
+
+export namespace ResolvedAIContextVariable {
+    export function is(arg: unknown): arg is ResolvedAIContextVariable {
+        return ResolvedAIVariable.is(arg) &&
+            'contextValue' in arg &&
+            typeof (arg as { contextValue: unknown }).contextValue === 'string';
+    }
+}
+
 export interface AIVariableResolutionRequest {
     variable: AIVariable;
     arg?: string;
 }
 
+export namespace AIVariableResolutionRequest {
+    export function is(arg: unknown): arg is AIVariableResolutionRequest {
+        return !!arg && typeof arg === 'object' &&
+            'variable' in arg &&
+            typeof (arg as { variable: { name: unknown } }).variable.name === 'string';
+    }
+}
+
 export interface AIVariableContext {
 }
 
 export type AIVariableArg = string | { variable: string, arg?: string } | AIVariableResolutionRequest;
 
+export type AIVariableArgPicker = (context: AIVariableContext) => MaybePromise<string | undefined>;
+export type AIVariableArgCompletionProvider = (model: monaco.editor.ITextModel, position: monaco.Position) => MaybePromise<monaco.languages.CompletionItem[] | undefined>;
+
 export interface AIVariableResolver {
     canResolve(request: AIVariableResolutionRequest, context: AIVariableContext): MaybePromise<number>,
     resolve(request: AIVariableResolutionRequest, context: AIVariableContext): Promise<ResolvedAIVariable | undefined>;
@@ -62,6 +137,7 @@ export interface AIVariableService {
     hasVariable(name: string): boolean;
     getVariable(name: string): Readonly<AIVariable> | undefined;
     getVariables(): Readonly<AIVariable>[];
+    getContextVariables(): Readonly<AIContextVariable>[];
     unregisterVariable(name: string): void;
     readonly onDidChangeVariables: Event<void>;
 
@@ -69,9 +145,18 @@ export interface AIVariableService {
     unregisterResolver(variable: AIVariable, resolver: AIVariableResolver): void;
     getResolver(name: string, arg: string | undefined, context: AIVariableContext): Promise<AIVariableResolver | undefined>;
 
+    registerArgumentPicker(variable: AIVariable, argPicker: AIVariableArgPicker): Disposable;
+    unregisterArgumentPicker(variable: AIVariable, argPicker: AIVariableArgPicker): void;
+    getArgumentPicker(name: string, context: AIVariableContext): Promise<AIVariableArgPicker | undefined>;
+
+    registerArgumentCompletionProvider(variable: AIVariable, argPicker: AIVariableArgCompletionProvider): Disposable;
+    unregisterArgumentCompletionProvider(variable: AIVariable, argPicker: AIVariableArgCompletionProvider): void;
+    getArgumentCompletionProvider(name: string): Promise<AIVariableArgCompletionProvider | undefined>;
+
     resolveVariable(variable: AIVariableArg, context: AIVariableContext): Promise<ResolvedAIVariable | undefined>;
 }
 
+/** Contributions on the frontend can optionally implement `FrontendVariableContribution`. */
 export const AIVariableContribution = Symbol('AIVariableContribution');
 export interface AIVariableContribution {
     registerVariables(service: AIVariableService): void;
@@ -81,6 +166,8 @@ export interface AIVariableContribution {
 export class DefaultAIVariableService implements AIVariableService {
     protected variables = new Map<string, AIVariable>();
     protected resolvers = new Map<string, AIVariableResolver[]>();
+    protected argPickers = new Map<string, AIVariableArgPicker>();
+    protected argCompletionProviders = new Map<string, AIVariableArgCompletionProvider>();
 
     protected readonly onDidChangeVariablesEmitter = new Emitter<void>();
     readonly onDidChangeVariables: Event<void> = this.onDidChangeVariablesEmitter.event;
@@ -137,6 +224,10 @@ export class DefaultAIVariableService implements AIVariableService {
         return [...this.variables.values()];
     }
 
+    getContextVariables(): Readonly<AIContextVariable>[] {
+        return this.getVariables().filter(AIContextVariable.is);
+    }
+
     registerResolver(variable: AIVariable, resolver: AIVariableResolver): Disposable {
         const key = this.getKey(variable.name);
         if (!this.variables.get(key)) {
@@ -164,6 +255,42 @@ export class DefaultAIVariableService implements AIVariableService {
         this.onDidChangeVariablesEmitter.fire();
     }
 
+    registerArgumentPicker(variable: AIVariable, argPicker: AIVariableArgPicker): Disposable {
+        const key = this.getKey(variable.name);
+        this.argPickers.set(key, argPicker);
+        return Disposable.create(() => this.unregisterArgumentPicker(variable, argPicker));
+    }
+
+    unregisterArgumentPicker(variable: AIVariable, argPicker: AIVariableArgPicker): void {
+        const key = this.getKey(variable.name);
+        const registeredArgPicker = this.argPickers.get(key);
+        if (registeredArgPicker === argPicker) {
+            this.argPickers.delete(key);
+        }
+    }
+
+    async getArgumentPicker(name: string): Promise<AIVariableArgPicker | undefined> {
+        return this.argPickers.get(this.getKey(name)) ?? undefined;
+    }
+
+    registerArgumentCompletionProvider(variable: AIVariable, completionProvider: AIVariableArgCompletionProvider): Disposable {
+        const key = this.getKey(variable.name);
+        this.argCompletionProviders.set(key, completionProvider);
+        return Disposable.create(() => this.unregisterArgumentCompletionProvider(variable, completionProvider));
+    }
+
+    unregisterArgumentCompletionProvider(variable: AIVariable, completionProvider: AIVariableArgCompletionProvider): void {
+        const key = this.getKey(variable.name);
+        const registeredCompletionProvider = this.argCompletionProviders.get(key);
+        if (registeredCompletionProvider === completionProvider) {
+            this.argCompletionProviders.delete(key);
+        }
+    }
+
+    async getArgumentCompletionProvider(name: string): Promise<AIVariableArgCompletionProvider | undefined> {
+        return this.argCompletionProviders.get(this.getKey(name)) ?? undefined;
+    }
+
     async resolveVariable(request: AIVariableArg, context: AIVariableContext): Promise<ResolvedAIVariable | undefined> {
         const variableName = typeof request === 'string' ? request : typeof request.variable === 'string' ? request.variable : request.variable.name;
         const variable = this.getVariable(variableName);
@@ -172,6 +299,7 @@ export class DefaultAIVariableService implements AIVariableService {
         }
         const arg = typeof request === 'string' ? undefined : request.arg;
         const resolver = await this.getResolver(variableName, arg, context);
-        return resolver?.resolve({ variable, arg }, context);
+        const resolved = await resolver?.resolve({ variable, arg }, context);
+        return resolved ? { ...resolved, arg } : undefined;
     }
 }

package/lib/browser/ai-configuration/agent-configuration-widget.d.ts

@@ -1,28 +0,0 @@
-/// <reference types="react" />
-import { ReactWidget } from '@theia/core/lib/browser';
-import * as React from '@theia/core/shared/react';
-import { Agent, AISettingsService, AIVariableService, LanguageModel, LanguageModelRegistry, PromptCustomizationService, PromptService } from '../../common';
-import { AIConfigurationSelectionService } from './ai-configuration-service';
-import { AgentService } from '../../common/agent-service';
-export declare class AIAgentConfigurationWidget extends ReactWidget {
-    static readonly ID = "ai-agent-configuration-container-widget";
-    static readonly LABEL = "Agents";
-    protected readonly agentService: AgentService;
-    protected readonly languageModelRegistry: LanguageModelRegistry;
-    protected readonly promptCustomizationService: PromptCustomizationService;
-    protected readonly aiSettingsService: AISettingsService;
-    protected readonly aiConfigurationSelectionService: AIConfigurationSelectionService;
-    protected readonly variableService: AIVariableService;
-    protected promptService: PromptService;
-    protected languageModels: LanguageModel[] | undefined;
-    protected init(): void;
-    protected render(): React.ReactNode;
-    private renderAgentName;
-    private renderAgentDetails;
-    private parsePromptTemplatesForVariableAndFunction;
-    protected showVariableConfigurationTab(): void;
-    protected addCustomAgent(): void;
-    protected setActiveAgent(agent: Agent): void;
-    private toggleAgentEnabled;
-}
-//# sourceMappingURL=agent-configuration-widget.d.ts.map

package/lib/browser/ai-configuration/agent-configuration-widget.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-configuration-widget.d.ts","sourceRoot":"","sources":["../../../src/browser/ai-configuration/agent-configuration-widget.tsx"],"names":[],"mappings":";AAgBA,OAAO,EAAW,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,KAAK,MAAM,0BAA0B,CAAC;AAClD,OAAO,EACH,KAAK,EACL,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,qBAAqB,EAGrB,0BAA0B,EAC1B,aAAa,EAChB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AAE7E,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAQ1D,qBACa,0BAA2B,SAAQ,WAAW;IAEvD,MAAM,CAAC,QAAQ,CAAC,EAAE,6CAA6C;IAC/D,MAAM,CAAC,QAAQ,CAAC,KAAK,YAAY;IAGjC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IAG9C,SAAS,CAAC,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB,CAAC;IAGhE,SAAS,CAAC,QAAQ,CAAC,0BAA0B,EAAE,0BAA0B,CAAC;IAG1E,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAGxD,SAAS,CAAC,QAAQ,CAAC,+BAA+B,EAAE,+BAA+B,CAAC;IAGpF,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,iBAAiB,CAAC;IAGtD,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC;IAEvC,SAAS,CAAC,cAAc,EAAE,aAAa,EAAE,GAAG,SAAS,CAAC;IAGtD,SAAS,CAAC,IAAI,IAAI,IAAI;IAqBtB,SAAS,CAAC,MAAM,IAAI,KAAK,CAAC,SAAS;IAoBnC,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,kBAAkB;IA6E1B,OAAO,CAAC,0CAA0C;IA6BlD,SAAS,CAAC,4BAA4B,IAAI,IAAI;IAI9C,SAAS,CAAC,cAAc,IAAI,IAAI;IAIhC,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAK5C,OAAO,CAAC,kBAAkB,CAYxB;CAEL"}