@theia/ai-chat 1.58.2 → 1.59.0-next.62

package/src/common/chat-service.ts

@@ -19,22 +19,23 @@
  *--------------------------------------------------------------------------------------------*/
 // Partially copied from https://github.com/microsoft/vscode/blob/a2cab7255c0df424027be05d58e1b7b941f4ea60/src/vs/workbench/contrib/chat/common/chatService.ts
 
+import { AIVariableResolutionRequest, AIVariableService, ResolvedAIContextVariable } from '@theia/ai-core';
+import { Emitter, ILogger, generateUuid } from '@theia/core';
 import { inject, injectable, optional } from '@theia/core/shared/inversify';
+import { Event } from '@theia/core/shared/vscode-languageserver-protocol';
+import { ChatAgentService } from './chat-agent-service';
+import { ChatAgent, ChatAgentLocation } from './chat-agents';
 import {
     ChatModel,
-    ChatModelImpl,
+    MutableChatModel,
     ChatRequest,
     ChatRequestModel,
     ChatResponseModel,
-    ErrorChatResponseModelImpl,
+    ErrorChatResponseModel,
+    ChatContext,
 } from './chat-model';
-import { ChatAgentService } from './chat-agent-service';
-import { Emitter, ILogger, generateUuid } from '@theia/core';
 import { ChatRequestParser } from './chat-request-parser';
-import { ChatAgent, ChatAgentLocation } from './chat-agents';
-import { ParsedChatRequestAgentPart, ParsedChatRequestVariablePart, ParsedChatRequest } from './parsed-chat-request';
-import { AIVariableService } from '@theia/ai-core';
-import { Event } from '@theia/core/shared/vscode-languageserver-protocol';
+import { ParsedChatRequest, ParsedChatRequestAgentPart, ParsedChatRequestVariablePart } from './parsed-chat-request';
 
 export interface ChatRequestInvocation {
     /**
@@ -56,6 +57,11 @@ export interface ChatSession {
     title?: string;
     model: ChatModel;
     isActive: boolean;
+    pinnedAgent?: ChatAgent;
+}
+
+export interface ChatContextRequest {
+    variableRequests: AIVariableResolutionRequest[]
 }
 
 export interface ActiveSessionChangedEvent {
@@ -67,24 +73,39 @@ export interface SessionOptions {
     focus?: boolean;
 }
 
+/**
+ * The default chat agent to invoke
+ */
 export const DefaultChatAgentId = Symbol('DefaultChatAgentId');
 export interface DefaultChatAgentId {
     id: string;
 }
 
+/**
+ * In case no fitting chat agent is available, this one will be used (if it is itself available)
+ */
+export const FallbackChatAgentId = Symbol('FallbackChatAgentId');
+export interface FallbackChatAgentId {
+    id: string;
+}
+
+export const PinChatAgent = Symbol('PinChatAgent');
+export type PinChatAgent = boolean;
+
 export const ChatService = Symbol('ChatService');
 export interface ChatService {
     onActiveSessionChanged: Event<ActiveSessionChangedEvent>
 
     getSession(id: string): ChatSession | undefined;
     getSessions(): ChatSession[];
-    createSession(location?: ChatAgentLocation, options?: SessionOptions): ChatSession;
+    createSession(location?: ChatAgentLocation, options?: SessionOptions, pinnedAgent?: ChatAgent): ChatSession;
     deleteSession(sessionId: string): void;
     setActiveSession(sessionId: string, options?: SessionOptions): void;
 
     sendRequest(
         sessionId: string,
-        request: ChatRequest
+        request: ChatRequest,
+        requestedContext?: ChatContextRequest
     ): Promise<ChatRequestInvocation | undefined>;
 
     deleteChangeSet(sessionId: string): void;
@@ -94,7 +115,7 @@ export interface ChatService {
 }
 
 interface ChatSessionInternal extends ChatSession {
-    model: ChatModelImpl;
+    model: MutableChatModel;
 }
 
 @injectable()
@@ -108,6 +129,12 @@ export class ChatServiceImpl implements ChatService {
     @inject(DefaultChatAgentId) @optional()
     protected defaultChatAgentId: DefaultChatAgentId | undefined;
 
+    @inject(FallbackChatAgentId) @optional()
+    protected fallbackChatAgentId: FallbackChatAgentId | undefined;
+
+    @inject(PinChatAgent) @optional()
+    protected pinChatAgent: boolean | undefined;
+
     @inject(ChatRequestParser)
     protected chatRequestParser: ChatRequestParser;
 
@@ -127,12 +154,13 @@ export class ChatServiceImpl implements ChatService {
         return this._sessions.find(session => session.id === id);
     }
 
-    createSession(location = ChatAgentLocation.Panel, options?: SessionOptions): ChatSession {
-        const model = new ChatModelImpl(location);
+    createSession(location = ChatAgentLocation.Panel, options?: SessionOptions, pinnedAgent?: ChatAgent): ChatSession {
+        const model = new MutableChatModel(location);
         const session: ChatSessionInternal = {
             id: model.id,
             model,
-            isActive: true
+            isActive: true,
+            pinnedAgent
         };
         this._sessions.push(session);
         this.setActiveSession(session.id, options);
@@ -140,11 +168,15 @@ export class ChatServiceImpl implements ChatService {
     }
 
     deleteSession(sessionId: string): void {
+        const sessionIndex = this._sessions.findIndex(candidate => candidate.id === sessionId);
+        if (~sessionIndex) { return; }
+        const session = this._sessions[sessionIndex];
         // If the removed session is the active one, set the newest one as active
-        if (this.getSession(sessionId)?.isActive) {
+        if (session.isActive) {
             this.setActiveSession(this._sessions[this._sessions.length - 1]?.id);
         }
-        this._sessions = this._sessions.filter(item => item.id !== sessionId);
+        session.model.dispose();
+        this._sessions.splice(sessionIndex, 1);
     }
 
     setActiveSession(sessionId: string | undefined, options?: SessionOptions): void {
@@ -156,7 +188,8 @@ export class ChatServiceImpl implements ChatService {
 
     async sendRequest(
         sessionId: string,
-        request: ChatRequest
+        request: ChatRequest,
+        requestedContext: ChatContextRequest = { variableRequests: [] }
     ): Promise<ChatRequestInvocation | undefined> {
         const session = this.getSession(sessionId);
         if (!session) {
@@ -165,19 +198,21 @@ export class ChatServiceImpl implements ChatService {
         session.title = request.text;
 
         const parsedRequest = this.chatRequestParser.parseChatRequest(request, session.model.location);
+        const agent = this.getAgent(parsedRequest, session);
 
-        const agent = this.getAgent(parsedRequest);
         if (agent === undefined) {
             const error = 'No ChatAgents available to handle request!';
             this.logger.error(error);
-            const chatResponseModel = new ErrorChatResponseModelImpl(generateUuid(), new Error(error));
+            const chatResponseModel = new ErrorChatResponseModel(generateUuid(), new Error(error));
             return {
                 requestCompleted: Promise.reject(error),
                 responseCreated: Promise.reject(error),
                 responseCompleted: Promise.resolve(chatResponseModel),
             };
         }
-        const requestModel = session.model.addRequest(parsedRequest, agent?.id);
+
+        const resolvedContext = await this.resolveChatContext(requestedContext, request, session);
+        const requestModel = session.model.addRequest(parsedRequest, agent?.id, resolvedContext);
 
         for (const part of parsedRequest.parts) {
             if (part instanceof ParsedChatRequestVariablePart) {
@@ -224,18 +259,56 @@ export class ChatServiceImpl implements ChatService {
         return invocation;
     }
 
+    protected async resolveChatContext(
+        requestedContext: ChatContextRequest,
+        request: ChatRequest,
+        session: ChatSessionInternal
+    ): Promise<ChatContext> {
+        const resolvedVariables = await Promise.all(
+            requestedContext.variableRequests.map(async contextVariable => {
+                const resolvedVariable = await this.variableService.resolveVariable(contextVariable, { request, model: session });
+                if (ResolvedAIContextVariable.is(resolvedVariable)) {
+                    return resolvedVariable;
+                }
+                return undefined;
+            })
+        ).then(results => results.filter((result): result is ResolvedAIContextVariable => result !== undefined));
+        return { variables: resolvedVariables };
+    }
+
     async cancelRequest(sessionId: string, requestId: string): Promise<void> {
         return this.getSession(sessionId)?.model.getRequest(requestId)?.response.cancel();
     }
 
-    protected getAgent(parsedRequest: ParsedChatRequest): ChatAgent | undefined {
+    protected getAgent(parsedRequest: ParsedChatRequest, session: ChatSession): ChatAgent | undefined {
+        let agent = this.initialAgentSelection(parsedRequest);
+        if (this.pinChatAgent === false) {
+            return agent;
+        }
+        if (!session.pinnedAgent && agent && agent.id !== this.defaultChatAgentId?.id) {
+            session.pinnedAgent = agent;
+        } else if (session.pinnedAgent && this.getMentionedAgent(parsedRequest) === undefined) {
+            agent = session.pinnedAgent;
+        }
+        return agent;
+    }
+
+    protected initialAgentSelection(parsedRequest: ParsedChatRequest): ChatAgent | undefined {
         const agentPart = this.getMentionedAgent(parsedRequest);
         if (agentPart) {
             return this.chatAgentService.getAgent(agentPart.agentId);
         }
+        let chatAgent = undefined;
         if (this.defaultChatAgentId) {
-            return this.chatAgentService.getAgent(this.defaultChatAgentId.id);
+            chatAgent = this.chatAgentService.getAgent(this.defaultChatAgentId.id);
+        }
+        if (!chatAgent && this.fallbackChatAgentId) {
+            chatAgent = this.chatAgentService.getAgent(this.fallbackChatAgentId.id);
+        }
+        if (chatAgent) {
+            return chatAgent;
         }
+        this.logger.warn('Neither the default chat agent nor the fallback chat agent are configured or available. Falling back to the first registered agent');
         return this.chatAgentService.getAgents()[0] ?? undefined;
     }
 
@@ -248,6 +321,6 @@ export class ChatServiceImpl implements ChatService {
     }
 
     deleteChangeSetElement(sessionId: string, index: number): void {
-        this.getSession(sessionId)?.model.changeSet?.removeElement(index);
+        this.getSession(sessionId)?.model.changeSet?.removeElements(index);
     }
 }

package/src/common/chat-tool-request-service.ts

@@ -16,12 +16,12 @@
 
 import { ToolRequest } from '@theia/ai-core';
 import { injectable } from '@theia/core/shared/inversify';
-import { ChatRequestModelImpl } from './chat-model';
+import { MutableChatRequestModel } from './chat-model';
 
 export interface ChatToolRequest extends ToolRequest {
     handler: (
         arg_string: string,
-        context: ChatRequestModelImpl,
+        context: MutableChatRequestModel,
     ) => Promise<unknown>;
 }
 
@@ -34,7 +34,7 @@ export interface ChatToolRequest extends ToolRequest {
 @injectable()
 export class ChatToolRequestService {
 
-    getChatToolRequests(request: ChatRequestModelImpl): ChatToolRequest[] {
+    getChatToolRequests(request: MutableChatRequestModel): ChatToolRequest[] {
         const toolRequests = request.message.toolRequests.size > 0 ? [...request.message.toolRequests.values()] : undefined;
         if (!toolRequests) {
             return [];
@@ -42,14 +42,14 @@ export class ChatToolRequestService {
         return this.toChatToolRequests(toolRequests, request);
     }
 
-    toChatToolRequests(toolRequests: ToolRequest[] | undefined, request: ChatRequestModelImpl): ChatToolRequest[] {
+    toChatToolRequests(toolRequests: ToolRequest[] | undefined, request: MutableChatRequestModel): ChatToolRequest[] {
         if (!toolRequests) {
             return [];
         }
         return toolRequests.map(toolRequest => this.toChatToolRequest(toolRequest, request));
     }
 
-    protected toChatToolRequest(toolRequest: ToolRequest, request: ChatRequestModelImpl): ChatToolRequest {
+    protected toChatToolRequest(toolRequest: ToolRequest, request: MutableChatRequestModel): ChatToolRequest {
         return {
             ...toolRequest,
             handler: async (arg_string: string) => toolRequest.handler(arg_string, request)

package/src/common/custom-chat-agent.ts

@@ -14,29 +14,17 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { AgentSpecificVariables, PromptTemplate } from '@theia/ai-core';
-import { AbstractStreamParsingChatAgent, ChatAgent, SystemMessageDescription } from './chat-agents';
+import { LanguageModelRequirement } from '@theia/ai-core';
+import { AbstractStreamParsingChatAgent } from './chat-agents';
 import { injectable } from '@theia/core/shared/inversify';
 
 @injectable()
-export class CustomChatAgent
-    extends AbstractStreamParsingChatAgent
-    implements ChatAgent {
-    name: string;
-    description: string;
-    readonly variables: string[] = [];
-    readonly functions: string[] = [];
-    readonly promptTemplates: PromptTemplate[] = [];
-    readonly agentSpecificVariables: AgentSpecificVariables[] = [];
-
-    constructor(
-    ) {
-        super('CustomChatAgent', [{ purpose: 'chat' }], 'chat');
-    }
-    protected override async getSystemMessageDescription(): Promise<SystemMessageDescription | undefined> {
-        const resolvedPrompt = await this.promptService.getPrompt(`${this.name}_prompt`);
-        return resolvedPrompt ? SystemMessageDescription.fromResolvedPromptTemplate(resolvedPrompt) : undefined;
-    }
+export class CustomChatAgent extends AbstractStreamParsingChatAgent {
+    id: string = 'CustomChatAgent';
+    name: string = 'CustomChatAgent';
+    languageModelRequirements: LanguageModelRequirement[] = [{ purpose: 'chat' }];
+    protected defaultLanguageModelPurpose: string = 'chat';
+    protected override systemPromptId: string = `${this.name}_prompt`;
 
     set prompt(prompt: string) {
         this.promptTemplates.push({ id: `${this.name}_prompt`, template: prompt });

package/src/common/index.ts

@@ -19,8 +19,5 @@ export * from './chat-model';
 export * from './chat-model-util';
 export * from './chat-request-parser';
 export * from './chat-service';
-export * from './command-chat-agents';
 export * from './custom-chat-agent';
 export * from './parsed-chat-request';
-export * from './orchestrator-chat-agent';
-export * from './universal-chat-agent';

package/src/common/parse-contents.spec.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
-import { ChatRequestModelImpl, ChatResponseContent, CodeChatResponseContentImpl, MarkdownChatResponseContentImpl } from './chat-model';
+import { MutableChatRequestModel, ChatResponseContent, CodeChatResponseContentImpl, MarkdownChatResponseContentImpl } from './chat-model';
 import { parseContents } from './parse-contents';
 import { CodeContentMatcher, ResponseContentMatcher } from './response-content-matcher';
 
@@ -33,7 +33,7 @@ export const CommandContentMatcher: ResponseContentMatcher = {
     }
 };
 
-const fakeRequest = {} as ChatRequestModelImpl;
+const fakeRequest = {} as MutableChatRequestModel;
 
 describe('parseContents', () => {
     it('should parse code content', () => {

package/src/common/parse-contents.ts

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  */
-import { ChatRequestModelImpl, ChatResponseContent } from './chat-model';
+import { MutableChatRequestModel, ChatResponseContent } from './chat-model';
 import { CodeContentMatcher, MarkdownContentFactory, ResponseContentFactory, ResponseContentMatcher } from './response-content-matcher';
 
 interface Match {
@@ -24,7 +24,7 @@ interface Match {
 
 export function parseContents(
     text: string,
-    request: ChatRequestModelImpl,
+    request: MutableChatRequestModel,
     contentMatchers: ResponseContentMatcher[] = [CodeContentMatcher],
     defaultContentFactory: ResponseContentFactory = MarkdownContentFactory
 ): ChatResponseContent[] {

package/src/common/response-content-matcher.ts

@@ -14,14 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  */
 import {
-    ChatRequestModelImpl,
+    MutableChatRequestModel,
     ChatResponseContent,
     CodeChatResponseContentImpl,
     MarkdownChatResponseContentImpl
 } from './chat-model';
 import { injectable } from '@theia/core/shared/inversify';
 
-export type ResponseContentFactory = (content: string, request: ChatRequestModelImpl) => ChatResponseContent;
+export type ResponseContentFactory = (content: string, request: MutableChatRequestModel) => ChatResponseContent;
 
 export const MarkdownContentFactory: ResponseContentFactory = (content: string) =>
     new MarkdownChatResponseContentImpl(content);
@@ -34,7 +34,7 @@ export const MarkdownContentFactory: ResponseContentFactory = (content: string)
  */
 @injectable()
 export class DefaultResponseContentFactory {
-    create(content: string, request: ChatRequestModelImpl): ChatResponseContent {
+    create(content: string, request: MutableChatRequestModel): ChatResponseContent {
         return MarkdownContentFactory(content, request);
     }
 }

package/lib/common/command-chat-agents.d.ts

@@ -1,33 +0,0 @@
-import { AbstractTextToModelParsingChatAgent, ChatAgent, SystemMessageDescription } from './chat-agents';
-import { PromptTemplate, AgentSpecificVariables } from '@theia/ai-core';
-import { ChatRequestModelImpl, ChatResponseContent } from './chat-model';
-import { CommandRegistry, MessageService } from '@theia/core';
-export declare const commandTemplate: PromptTemplate;
-interface ParsedCommand {
-    type: 'theia-command' | 'custom-handler' | 'no-command';
-    commandId: string;
-    arguments?: string[];
-    message?: string;
-}
-export declare class CommandChatAgent extends AbstractTextToModelParsingChatAgent<ParsedCommand> implements ChatAgent {
-    protected commandRegistry: CommandRegistry;
-    protected messageService: MessageService;
-    readonly name: string;
-    readonly description: string;
-    readonly variables: string[];
-    readonly promptTemplates: PromptTemplate[];
-    readonly functions: string[];
-    readonly agentSpecificVariables: AgentSpecificVariables[];
-    constructor();
-    protected getSystemMessageDescription(): Promise<SystemMessageDescription | undefined>;
-    /**
-     * @param text the text received from the language model
-     * @returns the parsed command if the text contained a valid command.
-     * If there was no json in the text, return a no-command response.
-     */
-    protected parseTextResponse(text: string): Promise<ParsedCommand>;
-    protected createResponseContent(parsedCommand: ParsedCommand, request: ChatRequestModelImpl): ChatResponseContent;
-    protected commandCallback(...commandArgs: unknown[]): Promise<void>;
-}
-export {};
-//# sourceMappingURL=command-chat-agents.d.ts.map

package/lib/common/command-chat-agents.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"command-chat-agents.d.ts","sourceRoot":"","sources":["../../src/common/command-chat-agents.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,mCAAmC,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzG,OAAO,EACH,cAAc,EACd,sBAAsB,EACzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACH,oBAAoB,EACpB,mBAAmB,EAKtB,MAAM,cAAc,CAAC;AACtB,OAAO,EACH,eAAe,EACf,cAAc,EAEjB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,eAAe,EAAE,cA8M5B,CAAC;AAEH,UAAU,aAAa;IACnB,IAAI,EAAE,eAAe,GAAG,gBAAgB,GAAG,YAAY,CAAA;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBACa,gBAAiB,SAAQ,mCAAmC,CAAC,aAAa,CAAE,YAAW,SAAS;IAEzG,SAAS,CAAC,eAAe,EAAE,eAAe,CAAC;IAE3C,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,sBAAsB,EAAE,sBAAsB,EAAE,CAAC;;cAqB1C,2BAA2B,IAAI,OAAO,CAAC,wBAAwB,GAAG,SAAS,CAAC;IAc5F;;;;OAIG;cACa,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAUvE,SAAS,CAAC,qBAAqB,CAAC,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,oBAAoB,GAAG,mBAAmB;cAqCjG,eAAe,CAAC,GAAG,WAAW,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAI5E"}