@theia/ai-chat 1.60.0 → 1.61.0-next.8

package/src/common/chat-model.ts

@@ -278,6 +278,12 @@ export interface ThinkingChatResponseContent
     signature: string;
 }
 
+export interface ProgressChatResponseContent
+    extends Required<ChatResponseContent> {
+    kind: 'progress';
+    message: string;
+}
+
 export interface Location {
     uri: URI;
     position: Position;
@@ -414,6 +420,17 @@ export namespace ThinkingChatResponseContent {
     }
 }
 
+export namespace ProgressChatResponseContent {
+    export function is(obj: unknown): obj is ProgressChatResponseContent {
+        return (
+            ChatResponseContent.is(obj) &&
+            obj.kind === 'progress' &&
+            'message' in obj &&
+            typeof obj.message === 'string'
+        );
+    }
+}
+
 export type QuestionResponseHandler = (
     selectedOption: { text: string, value?: string },
 ) => void;
@@ -1127,6 +1144,12 @@ class ChatResponseImpl implements ChatResponse {
         return this._content;
     }
 
+    clearContent(): void {
+        this._content = [];
+        this._updateResponseRepresentation();
+        this._onDidChangeEmitter.fire();
+    }
+
     addContents(contents: ChatResponseContent[]): void {
         contents.forEach(c => this.doAddContent(c));
         this._onDidChangeEmitter.fire();
@@ -1353,3 +1376,40 @@ export class ErrorChatResponseModel extends MutableChatResponseModel {
         this.error(error);
     }
 }
+
+export class ProgressChatResponseContentImpl implements ProgressChatResponseContent {
+    readonly kind = 'progress';
+    protected _message: string;
+
+    constructor(message: string) {
+        this._message = message;
+    }
+
+    get message(): string {
+        return this._message;
+    }
+
+    asString(): string {
+        return JSON.stringify({
+            type: 'progress',
+            message: this.message
+        });
+    }
+
+    asDisplayString(): string | undefined {
+        return `<Progress>${this.message}</Progress>`;
+    }
+
+    merge(nextChatResponseContent: ProgressChatResponseContent): boolean {
+        this._message = nextChatResponseContent.message;
+        return true;
+    }
+
+    toLanguageModelMessage(): TextMessage {
+        return {
+            actor: 'ai',
+            type: 'text',
+            text: this.message
+        };
+    }
+}

package/src/common/chat-session-naming-service.ts

@@ -20,10 +20,10 @@ import {
     CommunicationRecordingService,
     getTextOfResponse,
     LanguageModelRegistry,
-    LanguageModelRequest,
     LanguageModelRequirement,
     PromptService,
-    PromptTemplate
+    PromptTemplate,
+    UserRequest
 } from '@theia/ai-core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { ChatSession } from './chat-service';
@@ -103,22 +103,19 @@ export class ChatSessionNamingAgent implements Agent {
             throw new Error('Unable to create prompt message for generating chat session name');
         }
 
-        const request: LanguageModelRequest = {
+        const sessionId = generateUuid();
+        const requestId = generateUuid();
+        const request: UserRequest = {
             messages: [{
                 actor: 'user',
                 text: message,
                 type: 'text'
-            }]
-        };
-
-        const sessionId = generateUuid();
-        const requestId = generateUuid();
-        this.recordingService.recordRequest({
-            agentId: this.id,
-            sessionId,
+            }],
             requestId,
-            ...request
-        });
+            sessionId,
+            agentId: this.id
+        };
+        this.recordingService.recordRequest(request);
 
         const result = await lm.request(request);
         const response = await getTextOfResponse(result);

package/src/common/parse-contents-with-incomplete-parts.spec.ts

@@ -0,0 +1,114 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { MutableChatRequestModel, CodeChatResponseContentImpl, MarkdownChatResponseContentImpl } from './chat-model';
+import { parseContents } from './parse-contents';
+import { ResponseContentMatcher } from './response-content-matcher';
+
+const fakeRequest = {} as MutableChatRequestModel;
+
+// Custom matchers with incompleteContentFactory for testing
+const TestCodeContentMatcher: ResponseContentMatcher = {
+    start: /^```.*?$/m,
+    end: /^```$/m,
+    contentFactory: (content: string) => {
+        const language = content.match(/^```(\w+)/)?.[1] || '';
+        const code = content.replace(/^```(\w+)\n|```$/g, '');
+        return new CodeChatResponseContentImpl(code.trim(), language);
+    },
+    incompleteContentFactory: (content: string) => {
+        const language = content.match(/^```(\w+)/)?.[1] || '';
+        // Remove only the start delimiter, since we don't have an end delimiter yet
+        const code = content.replace(/^```(\w+)\n?/g, '');
+        return new CodeChatResponseContentImpl(code.trim(), language);
+    }
+};
+
+describe('parseContents with incomplete parts', () => {
+    it('should handle incomplete code blocks with incompleteContentFactory', () => {
+        // Only the start of a code block without an end
+        const text = '```typescript\nconsole.log("Hello World");';
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
+
+        expect(result.length).to.equal(1);
+        expect(result[0]).to.be.instanceOf(CodeChatResponseContentImpl);
+        const codeContent = result[0] as CodeChatResponseContentImpl;
+        expect(codeContent.code).to.equal('console.log("Hello World");');
+        expect(codeContent.language).to.equal('typescript');
+    });
+
+    it('should handle complete code blocks with contentFactory', () => {
+        const text = '```typescript\nconsole.log("Hello World");\n```';
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
+
+        expect(result.length).to.equal(1);
+        expect(result[0]).to.be.instanceOf(CodeChatResponseContentImpl);
+        const codeContent = result[0] as CodeChatResponseContentImpl;
+        expect(codeContent.code).to.equal('console.log("Hello World");');
+        expect(codeContent.language).to.equal('typescript');
+    });
+
+    it('should handle mixed content with incomplete and complete blocks', () => {
+        const text = 'Some text\n```typescript\nconsole.log("Hello");\n```\nMore text\n```python\nprint("World")';
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
+
+        expect(result.length).to.equal(4);
+        expect(result[0]).to.be.instanceOf(MarkdownChatResponseContentImpl);
+        expect(result[1]).to.be.instanceOf(CodeChatResponseContentImpl);
+        const completeContent = result[1] as CodeChatResponseContentImpl;
+        expect(completeContent.language).to.equal('typescript');
+        expect(result[2]).to.be.instanceOf(MarkdownChatResponseContentImpl);
+        expect(result[3]).to.be.instanceOf(CodeChatResponseContentImpl);
+        const incompleteContent = result[3] as CodeChatResponseContentImpl;
+        expect(incompleteContent.language).to.equal('python');
+    });
+
+    it('should use default content factory if no incompleteContentFactory provided', () => {
+        // Create a matcher without incompleteContentFactory
+        const matcherWithoutIncomplete: ResponseContentMatcher = {
+            start: /^<test>$/m,
+            end: /^<\/test>$/m,
+            contentFactory: (content: string) => new MarkdownChatResponseContentImpl('complete: ' + content)
+        };
+
+        // Text with only the start delimiter
+        const text = '<test>\ntest content';
+        const result = parseContents(text, fakeRequest, [matcherWithoutIncomplete]);
+
+        expect(result.length).to.equal(1);
+        expect(result[0]).to.be.instanceOf(MarkdownChatResponseContentImpl);
+        expect((result[0] as MarkdownChatResponseContentImpl).content.value).to.equal('<test>\ntest content');
+    });
+
+    it('should prefer complete matches over incomplete ones', () => {
+        // Text with both a complete and incomplete match at same position
+        const text = '```typescript\nconsole.log();\n```\n<test>\ntest content';
+        const matcherWithoutIncomplete: ResponseContentMatcher = {
+            start: /^<test>$/m,
+            end: /^<\/test>$/m,
+            contentFactory: (content: string) => new MarkdownChatResponseContentImpl('complete: ' + content)
+        };
+
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher, matcherWithoutIncomplete]);
+
+        expect(result.length).to.equal(2);
+        expect(result[0]).to.be.instanceOf(CodeChatResponseContentImpl);
+        expect((result[0] as CodeChatResponseContentImpl).language).to.equal('typescript');
+        expect(result[1]).to.be.instanceOf(MarkdownChatResponseContentImpl);
+        expect((result[1] as MarkdownChatResponseContentImpl).content.value).to.contain('test content');
+    });
+});

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

@@ -19,6 +19,16 @@ import { MutableChatRequestModel, ChatResponseContent, CodeChatResponseContentIm
 import { parseContents } from './parse-contents';
 import { CodeContentMatcher, ResponseContentMatcher } from './response-content-matcher';
 
+export const TestCodeContentMatcher: ResponseContentMatcher = {
+    start: /^```.*?$/m,
+    end: /^```$/m,
+    contentFactory: (content: string) => {
+        const language = content.match(/^```(\w+)/)?.[1] || '';
+        const code = content.replace(/^```(\w+)\n|```$/g, '');
+        return new CodeChatResponseContentImpl(code.trim(), language);
+    }
+};
+
 export class CommandChatResponseContentImpl implements ChatResponseContent {
     constructor(public readonly command: string) { }
     kind = 'command';
@@ -38,19 +48,19 @@ const fakeRequest = {} as MutableChatRequestModel;
 describe('parseContents', () => {
     it('should parse code content', () => {
         const text = '```typescript\nconsole.log("Hello World");\n```';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([new CodeChatResponseContentImpl('console.log("Hello World");', 'typescript')]);
     });
 
     it('should parse markdown content', () => {
         const text = 'Hello **World**';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([new MarkdownChatResponseContentImpl('Hello **World**')]);
     });
 
     it('should parse multiple content blocks', () => {
         const text = '```typescript\nconsole.log("Hello World");\n```\nHello **World**';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([
             new CodeChatResponseContentImpl('console.log("Hello World");', 'typescript'),
             new MarkdownChatResponseContentImpl('\nHello **World**')
@@ -59,7 +69,7 @@ describe('parseContents', () => {
 
     it('should parse multiple content blocks with different languages', () => {
         const text = '```typescript\nconsole.log("Hello World");\n```\n```python\nprint("Hello World")\n```';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([
             new CodeChatResponseContentImpl('console.log("Hello World");', 'typescript'),
             new CodeChatResponseContentImpl('print("Hello World")', 'python')
@@ -68,7 +78,7 @@ describe('parseContents', () => {
 
     it('should parse multiple content blocks with different languages and markdown', () => {
         const text = '```typescript\nconsole.log("Hello World");\n```\nHello **World**\n```python\nprint("Hello World")\n```';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([
             new CodeChatResponseContentImpl('console.log("Hello World");', 'typescript'),
             new MarkdownChatResponseContentImpl('\nHello **World**\n'),
@@ -78,7 +88,7 @@ describe('parseContents', () => {
 
     it('should parse content blocks with empty content', () => {
         const text = '```typescript\n```\nHello **World**\n```python\nprint("Hello World")\n```';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([
             new CodeChatResponseContentImpl('', 'typescript'),
             new MarkdownChatResponseContentImpl('\nHello **World**\n'),
@@ -88,7 +98,7 @@ describe('parseContents', () => {
 
     it('should parse content with markdown, code, and markdown', () => {
         const text = 'Hello **World**\n```typescript\nconsole.log("Hello World");\n```\nGoodbye **World**';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([
             new MarkdownChatResponseContentImpl('Hello **World**\n'),
             new CodeChatResponseContentImpl('console.log("Hello World");', 'typescript'),
@@ -98,34 +108,36 @@ describe('parseContents', () => {
 
     it('should handle text with no special content', () => {
         const text = 'Just some plain text.';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([new MarkdownChatResponseContentImpl('Just some plain text.')]);
     });
 
     it('should handle text with only start code block', () => {
         const text = '```typescript\nconsole.log("Hello World");';
+        // We're using the standard CodeContentMatcher which has incompleteContentFactory
         const result = parseContents(text, fakeRequest);
-        expect(result).to.deep.equal([new MarkdownChatResponseContentImpl('```typescript\nconsole.log("Hello World");')]);
+        expect(result).to.deep.equal([new CodeChatResponseContentImpl('console.log("Hello World");', 'typescript')]);
     });
 
     it('should handle text with only end code block', () => {
         const text = 'console.log("Hello World");\n```';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([new MarkdownChatResponseContentImpl('console.log("Hello World");\n```')]);
     });
 
     it('should handle text with unmatched code block', () => {
         const text = '```typescript\nconsole.log("Hello World");\n```\n```python\nprint("Hello World")';
+        // We're using the standard CodeContentMatcher which has incompleteContentFactory
         const result = parseContents(text, fakeRequest);
         expect(result).to.deep.equal([
             new CodeChatResponseContentImpl('console.log("Hello World");', 'typescript'),
-            new MarkdownChatResponseContentImpl('\n```python\nprint("Hello World")')
+            new CodeChatResponseContentImpl('print("Hello World")', 'python')
         ]);
     });
 
     it('should parse code block without newline after language', () => {
         const text = '```typescript console.log("Hello World");```';
-        const result = parseContents(text, fakeRequest);
+        const result = parseContents(text, fakeRequest, [TestCodeContentMatcher]);
         expect(result).to.deep.equal([
             new MarkdownChatResponseContentImpl('```typescript console.log("Hello World");```')
         ]);

package/src/common/parse-contents.ts

@@ -20,6 +20,7 @@ interface Match {
     matcher: ResponseContentMatcher;
     index: number;
     content: string;
+    isComplete: boolean;
 }
 
 export function parseContents(
@@ -50,7 +51,16 @@ export function parseContents(
             }
         }
         // 2. Add the matched content object
-        result.push(match.matcher.contentFactory(match.content, request));
+        if (match.isComplete) {
+            // Complete match, use regular content factory
+            result.push(match.matcher.contentFactory(match.content, request));
+        } else if (match.matcher.incompleteContentFactory) {
+            // Incomplete match with an incomplete content factory available
+            result.push(match.matcher.incompleteContentFactory(match.content, request));
+        } else {
+            // Incomplete match but no incomplete content factory available, use default
+            result.push(defaultContentFactory(match.content, request));
+        }
         // Update currentIndex to the end of the end of the match
         // And continue with the search after the end of the match
         currentIndex += match.index + match.content.length;
@@ -60,7 +70,9 @@ export function parseContents(
 }
 
 export function findFirstMatch(contentMatchers: ResponseContentMatcher[], text: string): Match | undefined {
-    let firstMatch: { matcher: ResponseContentMatcher, index: number, content: string } | undefined;
+    let firstMatch: Match | undefined;
+    let firstIncompleteMatch: Match | undefined;
+
     for (const matcher of contentMatchers) {
         const startMatch = matcher.start.exec(text);
         if (!startMatch) {
@@ -70,24 +82,58 @@ export function findFirstMatch(contentMatchers: ResponseContentMatcher[], text:
         const endOfStartMatch = startMatch.index + startMatch[0].length;
         if (endOfStartMatch >= text.length) {
             // There is no text after the start match.
-            // No need to search for the end match yet, try next matcher.
+            // This is an incomplete match if the matcher has an incompleteContentFactory
+            if (matcher.incompleteContentFactory) {
+                const incompleteMatch: Match = {
+                    matcher,
+                    index: startMatch.index,
+                    content: text.substring(startMatch.index),
+                    isComplete: false
+                };
+                if (!firstIncompleteMatch || incompleteMatch.index < firstIncompleteMatch.index) {
+                    firstIncompleteMatch = incompleteMatch;
+                }
+            }
             continue;
         }
+
         const remainingTextAfterStartMatch = text.substring(endOfStartMatch);
         const endMatch = matcher.end.exec(remainingTextAfterStartMatch);
+
         if (!endMatch) {
-            // No end match found, try next matcher.
+            // No end match found, this is an incomplete match
+            if (matcher.incompleteContentFactory) {
+                const incompleteMatch: Match = {
+                    matcher,
+                    index: startMatch.index,
+                    content: text.substring(startMatch.index),
+                    isComplete: false
+                };
+                if (!firstIncompleteMatch || incompleteMatch.index < firstIncompleteMatch.index) {
+                    firstIncompleteMatch = incompleteMatch;
+                }
+            }
             continue;
         }
+
         // Found start and end match.
         // Record the full match, if it is the earliest found so far.
         const index = startMatch.index;
         const contentEnd = index + startMatch[0].length + endMatch.index + endMatch[0].length;
         const content = text.substring(index, contentEnd);
+        const completeMatch: Match = { matcher, index, content, isComplete: true };
+
         if (!firstMatch || index < firstMatch.index) {
-            firstMatch = { matcher, index, content };
+            firstMatch = completeMatch;
         }
     }
-    return firstMatch;
+
+    // If we found a complete match, return it
+    if (firstMatch) {
+        return firstMatch;
+    }
+
+    // Otherwise, return the first incomplete match if one exists
+    return firstIncompleteMatch;
 }
 

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

@@ -23,7 +23,7 @@ import { injectable } from '@theia/core/shared/inversify';
 
 export type ResponseContentFactory = (content: string, request: MutableChatRequestModel) => ChatResponseContent;
 
-export const MarkdownContentFactory: ResponseContentFactory = (content: string) =>
+export const MarkdownContentFactory: ResponseContentFactory = (content: string, request: MutableChatRequestModel) =>
     new MarkdownChatResponseContentImpl(content);
 
 /**
@@ -53,14 +53,32 @@ export interface ResponseContentMatcher {
      * from start index to end index of the match (including delimiters).
      */
     contentFactory: ResponseContentFactory;
+    /**
+     * Optional factory for creating a response content when only the start delimiter has been matched,
+     * but not yet the end delimiter. Used during streaming to provide better visual feedback.
+     * If not provided, the default content factory will be used until the end delimiter is matched.
+     */
+    incompleteContentFactory?: ResponseContentFactory;
 }
 
 export const CodeContentMatcher: ResponseContentMatcher = {
-    start: /^```.*?$/m,
+    // Only match when we have the complete first line ending with a newline
+    // This ensures we have the full language specification before creating the editor
+    start: /^```.*\n/m,
     end: /^```$/m,
-    contentFactory: (content: string) => {
+    contentFactory: (content: string, request: MutableChatRequestModel) => {
         const language = content.match(/^```(\w+)/)?.[1] || '';
         const code = content.replace(/^```(\w+)\n|```$/g, '');
+        return new CodeChatResponseContentImpl(code.trim(), language);
+    },
+    incompleteContentFactory: (content: string, request: MutableChatRequestModel) => {
+        // By this point, we know we have at least the complete first line with ```
+        const firstLine = content.split('\n')[0];
+        const language = firstLine.match(/^```(\w+)/)?.[1] || '';
+
+        // Remove the first line to get just the code content
+        const code = content.substring(content.indexOf('\n') + 1);
+
         return new CodeChatResponseContentImpl(code.trim(), language);
     }
 };