@theia/ai-core 1.61.0 → 1.62.0

package/src/browser/prompttemplate-contribution.ts

@@ -22,7 +22,7 @@ import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/li
 
 import { codicon, Widget } from '@theia/core/lib/browser';
 import { EditorWidget, ReplaceOperation } from '@theia/editor/lib/browser';
-import { PromptCustomizationService, PromptService, PromptText, ToolInvocationRegistry } from '../common';
+import { PromptService, PromptText, ToolInvocationRegistry } from '../common';
 import { ProviderResult } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
 import { AIVariableService } from '../common/variable-service';
 
@@ -44,9 +44,6 @@ export class PromptTemplateContribution implements LanguageGrammarDefinitionCont
     @inject(PromptService)
     private readonly promptService: PromptService;
 
-    @inject(PromptCustomizationService)
-    protected readonly customizationService: PromptCustomizationService;
-
     @inject(ToolInvocationRegistry)
     protected readonly toolInvocationRegistry: ToolInvocationRegistry;
 
@@ -254,22 +251,22 @@ export class PromptTemplateContribution implements LanguageGrammarDefinitionCont
 
     protected canDiscard(widget: EditorWidget): boolean {
         const resourceUri = widget.editor.uri;
-        const id = this.customizationService.getTemplateIDFromURI(resourceUri);
+        const id = this.promptService.getTemplateIDFromResource(resourceUri);
         if (id === undefined) {
             return false;
         }
-        const rawPrompt = this.promptService.getRawPrompt(id);
-        const defaultPrompt = this.promptService.getDefaultRawPrompt(id);
+        const rawPrompt = this.promptService.getRawPromptFragment(id);
+        const defaultPrompt = this.promptService.getBuiltInRawPrompt(id);
         return rawPrompt?.template !== defaultPrompt?.template;
     }
 
     protected async discard(widget: EditorWidget): Promise<void> {
         const resourceUri = widget.editor.uri;
-        const id = this.customizationService.getTemplateIDFromURI(resourceUri);
+        const id = this.promptService.getTemplateIDFromResource(resourceUri);
         if (id === undefined) {
             return;
         }
-        const defaultPrompt = this.promptService.getDefaultRawPrompt(id);
+        const defaultPrompt = this.promptService.getBuiltInRawPrompt(id);
         if (defaultPrompt === undefined) {
             return;
         }

package/src/common/agent-service.ts

@@ -98,8 +98,13 @@ export class AgentServiceImpl implements AgentService {
 
     registerAgent(agent: Agent): void {
         this._agents.push(agent);
-        agent.promptTemplates.forEach(
-            template => this.promptService.storePromptTemplate(template)
+        agent.prompts.forEach(
+            prompt => {
+                this.promptService.addBuiltInPromptFragment(prompt.defaultVariant, prompt.id, true);
+                prompt.variants?.forEach(variant => {
+                    this.promptService.addBuiltInPromptFragment(variant, prompt.id);
+                });
+            }
         );
         this.onDidChangeAgentsEmitter.fire();
     }
@@ -108,8 +113,13 @@ export class AgentServiceImpl implements AgentService {
         const agent = this._agents.find(a => a.id === agentId);
         this._agents = this._agents.filter(a => a.id !== agentId);
         this.onDidChangeAgentsEmitter.fire();
-        agent?.promptTemplates.forEach(
-            template => this.promptService.removePrompt(template.id)
+        agent?.prompts.forEach(
+            prompt => {
+                this.promptService.removePromptFragment(prompt.defaultVariant.id);
+                prompt.variants?.forEach(variant => {
+                    this.promptService.removePromptFragment(variant.id);
+                });
+            }
         );
     }
 

package/src/common/agent.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { LanguageModelRequirement } from './language-model';
-import { PromptTemplate } from './prompt-service';
+import { BasePromptFragment } from './prompt-service';
 
 export interface AgentSpecificVariables {
     name: string;
@@ -23,6 +23,12 @@ export interface AgentSpecificVariables {
     usedInPrompt: boolean;
 }
 
+export interface PromptVariantSet {
+    id: string;
+    defaultVariant: BasePromptFragment;
+    variants?: BasePromptFragment[];
+}
+
 export const Agent = Symbol('Agent');
 /**
  * Agents represent the main functionality of the AI system. They are responsible for processing user input, collecting information from the environment,
@@ -53,8 +59,8 @@ export interface Agent {
     /** The list of global variable identifiers this agent needs to clarify its context requirements. See #39. */
     readonly variables: string[];
 
-    /** The prompt templates introduced and used by this agent. */
-    readonly promptTemplates: PromptTemplate[];
+    /** The prompts introduced and used by this agent. */
+    readonly prompts: PromptVariantSet[];
 
     /** Required language models. This includes the purpose and optional language model selector arguments. See #47. */
     readonly languageModelRequirements: LanguageModelRequirement[];

package/src/common/index.ts

@@ -16,7 +16,6 @@
 export * from './agent-service';
 export * from './agent';
 export * from './agents-variable-contribution';
-export * from './communication-recording-service';
 export * from './tool-invocation-registry';
 export * from './language-model-delegate';
 export * from './language-model-util';

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

@@ -0,0 +1,98 @@
+// *****************************************************************************
+// Copyright (C) 2025 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+import {
+    LanguageModelRequest,
+    LanguageModelResponse,
+    LanguageModelStreamResponse,
+    LanguageModelStreamResponsePart,
+} from './language-model';
+
+/**
+ * A session tracking raw exchanges with language models, organized into exchange units.
+ */
+export interface LanguageModelSession {
+    /**
+     * Identifier of this Language Model Session. Corresponds to Chat session ids
+     */
+    id: string;
+    /**
+     * All exchange units part of this session
+     */
+    exchanges: LanguageModelExchange[];
+}
+
+/**
+ * An exchange unit representing a logical operation which may involve multiple model requests.
+ */
+export interface LanguageModelExchange {
+    /**
+     * Identifier of the exchange unit.
+     */
+    id: string;
+    /**
+     * All requests that constitute this exchange
+     */
+    requests: LanguageModelExchangeRequest[];
+    /**
+     * Arbitrary metadata for the exchange
+     */
+    metadata: {
+        agent?: string;
+        [key: string]: unknown;
+    }
+}
+
+/**
+ * Alternative to the LanguageModelStreamResponse, suited for inspection
+ */
+export interface LanguageModelMonitoredStreamResponse {
+    parts: LanguageModelStreamResponsePart[];
+}
+
+/**
+ * Alternative to the LanguageModelResponse, suited for inspection
+ */
+export type LanguageModelExchangeRequestResponse = Exclude<LanguageModelResponse, LanguageModelStreamResponse> | LanguageModelMonitoredStreamResponse;
+
+/**
+ * Represents a request to a language model within an exchange unit, capturing the request and its response.
+ */
+export interface LanguageModelExchangeRequest {
+    /**
+     * Identifier of the request. Might share the id with the parent exchange if there's only one request.
+     */
+    id: string;
+    /**
+     * The actual request sent to the language model
+     */
+    request: LanguageModelRequest;
+    /**
+     * Arbitrary metadata for the request. Might contain an agent id and timestamp.
+     */
+    metadata: {
+        agent?: string;
+        timestamp?: number;
+        [key: string]: unknown;
+    };
+    /**
+     * The identifier of the language model the request was sent to
+     */
+    languageModel: string;
+    /**
+     * The recorded response
+     */
+    response: LanguageModelExchangeRequestResponse;
+}

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

@@ -15,13 +15,32 @@
 // *****************************************************************************
 
 import { inject } from '@theia/core/shared/inversify';
-import { LanguageModel, LanguageModelRegistry, LanguageModelResponse, UserRequest } from './language-model';
-import { CommunicationRecordingService } from './communication-recording-service';
+import { isLanguageModelStreamResponse, LanguageModel, LanguageModelRegistry, LanguageModelResponse, LanguageModelStreamResponsePart, UserRequest } from './language-model';
+import { LanguageModelExchangeRequest, LanguageModelSession } from './language-model-interaction-model';
+import { Emitter } from '@theia/core';
+
+export interface RequestAddedEvent {
+    type: 'requestAdded',
+    id: string;
+}
+export interface ResponseCompletedEvent {
+    type: 'responseCompleted',
+    requestId: string;
+}
+export interface SessionsClearedEvent {
+    type: 'sessionsCleared'
+}
+export type SessionEvent = RequestAddedEvent | ResponseCompletedEvent | SessionsClearedEvent;
 
 export const LanguageModelService = Symbol('LanguageModelService');
 export interface LanguageModelService {
+    onSessionChanged: Emitter<SessionEvent>['event'];
+    /**
+     * Collection of all recorded LanguageModelSessions.
+     */
+    sessions: LanguageModelSession[];
     /**
-     * Submit a language model request in the context of the given `chatRequest`.
+     * Submit a language model request, it will automatically be recorded within a LanguageModelSession.
      */
     sendRequest(
         languageModel: LanguageModel,
@@ -33,8 +52,21 @@ export class LanguageModelServiceImpl implements LanguageModelService {
     @inject(LanguageModelRegistry)
     protected languageModelRegistry: LanguageModelRegistry;
 
-    @inject(CommunicationRecordingService)
-    protected recordingService: CommunicationRecordingService;
+    private _sessions: LanguageModelSession[] = [];
+
+    get sessions(): LanguageModelSession[] {
+        return this._sessions;
+    }
+
+    set sessions(newSessions: LanguageModelSession[]) {
+        this._sessions = newSessions;
+        if (newSessions.length === 0) {
+            this.sessionChangedEmitter.fire({ type: 'sessionsCleared' });
+        }
+    }
+
+    protected sessionChangedEmitter = new Emitter<SessionEvent>();
+    onSessionChanged = this.sessionChangedEmitter.event;
 
     async sendRequest(
         languageModel: LanguageModel,
@@ -53,7 +85,84 @@ export class LanguageModelServiceImpl implements LanguageModelService {
             return true;
         });
 
-        return languageModel.request(languageModelRequest, languageModelRequest.cancellationToken);
+        let response = await languageModel.request(languageModelRequest, languageModelRequest.cancellationToken);
+        let storedResponse: LanguageModelExchangeRequest['response'];
+        if (isLanguageModelStreamResponse(response)) {
+            const parts: LanguageModelStreamResponsePart[] = [];
+            response = {
+                ...response,
+                stream: createLoggingAsyncIterable(response.stream,
+                    parts,
+                    () => this.sessionChangedEmitter.fire({ type: 'responseCompleted', requestId: languageModelRequest.subRequestId ?? languageModelRequest.requestId }))
+            };
+            storedResponse = { parts };
+        } else {
+            storedResponse = response;
+        }
+        this.storeRequest(languageModel, languageModelRequest, storedResponse);
+
+        return response;
     }
 
+    protected storeRequest(languageModel: LanguageModel, languageModelRequest: UserRequest, response: LanguageModelExchangeRequest['response']): void {
+        // Find or create the session for this request
+        let session = this._sessions.find(s => s.id === languageModelRequest.sessionId);
+        if (!session) {
+            session = {
+                id: languageModelRequest.sessionId,
+                exchanges: []
+            };
+            this._sessions.push(session);
+        }
+
+        // Find or create the exchange for this request
+        let exchange = session.exchanges.find(r => r.id === languageModelRequest.requestId);
+        if (!exchange) {
+            exchange = {
+                id: languageModelRequest.requestId,
+                requests: [],
+                metadata: { agent: languageModelRequest.agentId }
+            };
+            session.exchanges.push(exchange);
+        }
+
+        // Create and add the LanguageModelExchangeRequest to the exchange
+        const exchangeRequest: LanguageModelExchangeRequest = {
+            id: languageModelRequest.subRequestId ?? languageModelRequest.requestId,
+            request: languageModelRequest,
+            languageModel: languageModel.id,
+            response: response,
+            metadata: {}
+        };
+
+        exchange.requests.push(exchangeRequest);
+
+        exchangeRequest.metadata.agent = languageModelRequest.agentId;
+        exchangeRequest.metadata.timestamp = Date.now();
+
+        this.sessionChangedEmitter.fire({ type: 'requestAdded', id: languageModelRequest.subRequestId ?? languageModelRequest.requestId });
+    }
+
+}
+
+/**
+ * Creates an AsyncIterable wrapper that stores each yielded item while preserving the
+ * original AsyncIterable behavior.
+ */
+async function* createLoggingAsyncIterable(
+    stream: AsyncIterable<LanguageModelStreamResponsePart>,
+    parts: LanguageModelStreamResponsePart[],
+    streamFinished: () => void
+): AsyncIterable<LanguageModelStreamResponsePart> {
+    try {
+        for await (const part of stream) {
+            parts.push(part);
+            yield part;
+        }
+    } catch (error) {
+        parts.push({ content: `[NOT FROM LLM] An error occurred: ${error.message}` });
+        throw error;
+    } finally {
+        streamFinished();
+    }
 }

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

@@ -22,6 +22,7 @@ import {
     LanguageModelResponse,
     ToolRequest
 } from './language-model';
+import { LanguageModelMonitoredStreamResponse } from './language-model-interaction-model';
 
 /**
  * Retrieves the text content from a `LanguageModelResponse` object.
@@ -33,7 +34,7 @@ import {
  * @returns {Promise<string>} - A promise that resolves to the text content of the response.
  * @throws {Error} - Throws an error if the response type is not supported or does not contain valid text content.
  */
-export const getTextOfResponse = async (response: LanguageModelResponse): Promise<string> => {
+export const getTextOfResponse = async (response: LanguageModelResponse | LanguageModelMonitoredStreamResponse): Promise<string> => {
     if (isLanguageModelTextResponse(response)) {
         return response.text;
     } else if (isLanguageModelStreamResponse(response)) {
@@ -44,11 +45,18 @@ export const getTextOfResponse = async (response: LanguageModelResponse): Promis
         return result;
     } else if (isLanguageModelParsedResponse(response)) {
         return response.content;
+    } else if ('parts' in response) {
+        // Handle monitored stream response
+        let result = '';
+        for (const chunk of response.parts) {
+            result += (isTextResponsePart(chunk) && chunk.content) ? chunk.content : '';
+        }
+        return result;
     }
     throw new Error(`Invalid response type ${response}`);
 };
 
-export const getJsonOfResponse = async (response: LanguageModelResponse): Promise<unknown> => {
+export const getJsonOfResponse = async (response: LanguageModelResponse | LanguageModelMonitoredStreamResponse): Promise<unknown> => {
     const text = await getTextOfResponse(response);
     return getJsonOfText(text);
 };

package/src/common/language-model.ts

@@ -74,7 +74,7 @@ export const isLanguageModelRequestMessage = (obj: unknown): obj is LanguageMode
     );
 
 export interface ToolRequestParameterProperty {
-    type?: string;
+    type?: | 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
     anyOf?: ToolRequestParameterProperty[];
     [key: string]: unknown;
 }
@@ -159,10 +159,32 @@ export interface ResponseFormatJsonSchema {
     };
 }
 
+/**
+ * The UserRequest extends the "pure" LanguageModelRequest for cancelling support as well as
+ * logging metadata.
+ * The additional metadata might also be used for other use cases, for example to query default
+ * request settings based on the agent id, merging with the request settings handed over.
+ */
 export interface UserRequest extends LanguageModelRequest {
+    /**
+     * Identifier of the Ai/ChatSession
+     */
     sessionId: string;
+    /**
+     * Identifier of the request or overall exchange. Corresponds to request id in Chat sessions
+     */
     requestId: string;
-    agentId: string;
+    /**
+     * Id of a request in case a single exchange consists of multiple requests. In this case the requestId corresponds to the overall exchange.
+     */
+    subRequestId?: string;
+    /**
+     * Optional agent identifier in case the request was sent by an agent
+     */
+    agentId?: string;
+    /**
+     * Cancellation support
+     */
     cancellationToken?: CancellationToken;
 }
 
@@ -173,6 +195,10 @@ export const isLanguageModelTextResponse = (obj: unknown): obj is LanguageModelT
     !!(obj && typeof obj === 'object' && 'text' in obj && typeof (obj as { text: unknown }).text === 'string');
 
 export type LanguageModelStreamResponsePart = TextResponsePart | ToolCallResponsePart | ThinkingResponsePart | UsageResponsePart;
+
+export const isLanguageModelStreamResponsePart = (part: unknown): part is LanguageModelStreamResponsePart =>
+    isUsageResponsePart(part) || isTextResponsePart(part) || isThinkingResponsePart(part) || isToolCallResponsePart(part);
+
 export interface UsageResponsePart {
     input_tokens: number;
     output_tokens: number;