@theia/ai-chat 1.60.2 → 1.61.0

package/src/common/chat-request-parser.ts

@@ -55,7 +55,7 @@ function offsetRange(start: number, endExclusive: number): OffsetRange {
     return { start, endExclusive };
 }
 @injectable()
-export class ChatRequestParserImpl {
+export class ChatRequestParserImpl implements ChatRequestParser {
     constructor(
         @inject(ChatAgentService) private readonly agentService: ChatAgentService,
         @inject(AIVariableService) private readonly variableService: AIVariableService,
@@ -90,7 +90,7 @@ export class ChatRequestParserImpl {
         }
 
         // Get resolved variables from variable cache after all variables have been resolved.
-        // We want to return all recursilvely resolved variables, thus use the whole cache.
+        // We want to return all recursively resolved variables, thus use the whole cache.
         const resolvedVariables = await getAllResolvedAIVariables(variableCache);
 
         return { request, parts, toolRequests, variables: resolvedVariables };

package/src/common/chat-service.ts

@@ -38,6 +38,7 @@ import {
 import { ChatRequestParser } from './chat-request-parser';
 import { ParsedChatRequest, ParsedChatRequestAgentPart } from './parsed-chat-request';
 import { ChatSessionNamingService } from './chat-session-naming-service';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export interface ChatRequestInvocation {
     /**
@@ -125,6 +126,7 @@ export interface ChatService {
     getSessions(): ChatSession[];
     createSession(location?: ChatAgentLocation, options?: SessionOptions, pinnedAgent?: ChatAgent): ChatSession;
     deleteSession(sessionId: string): void;
+    getActiveSession(): ChatSession | undefined;
     setActiveSession(sessionId: string, options?: SessionOptions): void;
 
     sendRequest(
@@ -208,6 +210,12 @@ export class ChatServiceImpl implements ChatService {
         this.onSessionEventEmitter.fire({ type: 'deleted', sessionId: sessionId });
     }
 
+    getActiveSession(): ChatSession | undefined {
+        const activeSessions = this._sessions.filter(candidate => candidate.isActive);
+        if (activeSessions.length > 1) { throw new Error('More than one session marked as active. This indicates an error in ChatService.'); }
+        return activeSessions.at(0);
+    }
+
     setActiveSession(sessionId: string | undefined, options?: SessionOptions): void {
         this._sessions.forEach(session => {
             session.isActive = session.id === sessionId;
@@ -225,7 +233,7 @@ export class ChatServiceImpl implements ChatService {
         }
 
         const resolutionContext: ChatSessionContext = { model: session.model };
-        const resolvedContext = await this.resolveChatContext(session.model.context.getVariables(), resolutionContext);
+        const resolvedContext = await this.resolveChatContext(request.variables ?? session.model.context.getVariables(), resolutionContext);
         const parsedRequest = await this.chatRequestParser.parseChatRequest(request, session.model.location, resolvedContext);
         const agent = this.getAgent(parsedRequest, session);
 
@@ -244,33 +252,23 @@ export class ChatServiceImpl implements ChatService {
         this.updateSessionMetadata(session, requestModel);
         resolutionContext.request = requestModel;
 
-        let resolveResponseCreated: (responseModel: ChatResponseModel) => void;
-        let resolveResponseCompleted: (responseModel: ChatResponseModel) => void;
+        const responseCompletionDeferred = new Deferred<ChatResponseModel>();
         const invocation: ChatRequestInvocation = {
             requestCompleted: Promise.resolve(requestModel),
-            responseCreated: new Promise(resolve => {
-                resolveResponseCreated = resolve;
-            }),
-            responseCompleted: new Promise(resolve => {
-                resolveResponseCompleted = resolve;
-            }),
+            responseCreated: Promise.resolve(requestModel.response),
+            responseCompleted: responseCompletionDeferred.promise,
         };
 
-        resolveResponseCreated!(requestModel.response);
         requestModel.response.onDidChange(() => {
             if (requestModel.response.isComplete) {
-                resolveResponseCompleted!(requestModel.response);
+                responseCompletionDeferred.resolve(requestModel.response);
             }
             if (requestModel.response.isError) {
-                resolveResponseCompleted!(requestModel.response);
+                responseCompletionDeferred.resolve(requestModel.response);
             }
         });
 
-        if (agent) {
-            agent.invoke(requestModel).catch(error => requestModel.response.error(error));
-        } else {
-            this.logger.error('No ChatAgents available to handle request!', requestModel);
-        }
+        agent.invoke(requestModel).catch(error => requestModel.response.error(error));
 
         return invocation;
     }
@@ -304,15 +302,8 @@ export class ChatServiceImpl implements ChatService {
         context: ChatSessionContext,
     ): Promise<ChatContext> {
         // TODO use a common cache to resolve variables and return recursively resolved variables?
-        const resolvedVariables = await Promise.all(
-            resolutionRequests.map(async contextVariable => {
-                const resolvedVariable = await this.variableService.resolveVariable(contextVariable, context);
-                if (ResolvedAIContextVariable.is(resolvedVariable)) {
-                    return resolvedVariable;
-                }
-                return undefined;
-            })
-        ).then(results => results.filter((result): result is ResolvedAIContextVariable => result !== undefined));
+        const resolvedVariables = await Promise.all(resolutionRequests.map(async contextVariable => this.variableService.resolveVariable(contextVariable, context)))
+            .then(results => results.filter(ResolvedAIContextVariable.is));
         return { variables: resolvedVariables };
     }
 

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

@@ -18,12 +18,13 @@ import {
     Agent,
     AgentService,
     CommunicationRecordingService,
+    CommunicationRequestEntryParam,
     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';
@@ -38,7 +39,7 @@ const CHAT_SESSION_NAMING_PROMPT = {
         'Use the same language for the chat conversation name as used in the provided conversation, if in doubt default to English. ' +
         'Start the chat conversation name with an upper-case letter. ' +
         'Below we also provide the already existing other conversation names, make sure your suggestion for a name is unique with respect to the existing ones.\n\n' +
-        'IMPORTANT: Your answer MUST ONLY CONTAIN THE PROPOSED NAME and must not be preceded or succeeded with any other text.' +
+        'IMPORTANT: Your answer MUST ONLY CONTAIN THE PROPOSED NAME and must not be preceded or followed by any other text.' +
         '\n\nOther session names:\n{{listOfSessionNames}}' +
         '\n\nConversation:\n{{conversation}}',
 };
@@ -92,7 +93,7 @@ export class ChatSessionNamingAgent implements Agent {
         }
 
         const conversation = chatSession.model.getRequests()
-            .map(req => `<user>${req.request.text}</user>` +
+            .map(req => `<user>${req.message.parts.map(chunk => chunk.promptText).join('')}</user>` +
                 (req.response.response ? `<assistant>${req.response.response.asString()}</assistant>` : ''))
             .join('\n\n');
         const listOfSessionNames = otherNames.map(name => name).join(', ');
@@ -103,22 +104,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, request: request.messages } satisfies CommunicationRequestEntryParam);
 
         const result = await lm.request(request);
         const response = await getTextOfResponse(result);

package/src/common/chat-session-summary-agent-prompt.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/tslint/config  */
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This file is licensed under the MIT License.
+// See LICENSE-MIT.txt in the project root for license information.
+// https://opensource.org/license/mit.
+//
+// SPDX-License-Identifier: MIT
+
+import { CHANGE_SET_SUMMARY_VARIABLE_ID } from './context-variables';
+
+export const CHAT_SESSION_SUMMARY_PROMPT = {
+    id: 'chat-session-summary-prompt',
+    template: `{{!-- !-- This prompt is licensed under the MIT License (https://opensource.org/license/mit).
+Made improvements or adaptations to this prompt template? We\'d love for you to share it with the community! Contribute back here: ' +
+        'https://github.com/eclipse-theia/theia/discussions/new?category=prompt-template-contribution --}}\n\n' +
+        'You are a chat agent for summarizing AI agent chat sessions for later use. \
+Review the conversation above and generate a concise summary that captures every crucial detail, \
+including all requirements, decisions, and pending tasks. \
+Ensure that the summary is sufficiently comprehensive to allow seamless continuation of the workflow. The summary will primarily be used by other AI agents, so tailor your \
+response for use by AI agents. \
+Also consider the system message.
+Make sure you include all necessary context information and use unique references (such as URIs, file paths, etc.).
+If the conversation was about a task, describe the state of the task, i.e. what has been completed and what is open.
+If a changeset is open in the session, describe the state of the suggested changes.
+{{${CHANGE_SET_SUMMARY_VARIABLE_ID}}}`,
+};

package/src/common/chat-session-summary-agent.ts

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH 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 {
+    LanguageModelRequirement,
+    PromptTemplate
+} from '@theia/ai-core';
+import { injectable } from '@theia/core/shared/inversify';
+import { AbstractStreamParsingChatAgent, ChatAgent } from './chat-agents';
+import { CHAT_SESSION_SUMMARY_PROMPT } from './chat-session-summary-agent-prompt';
+
+@injectable()
+export class ChatSessionSummaryAgent extends AbstractStreamParsingChatAgent implements ChatAgent {
+    static ID = 'chat-session-summary-agent';
+    id = ChatSessionSummaryAgent.ID;
+    name = 'Chat Session Summary';
+    override description = 'Agent for generating chat session summaries.';
+    override variables = [];
+    override promptTemplates: PromptTemplate[] = [CHAT_SESSION_SUMMARY_PROMPT];
+    protected readonly defaultLanguageModelPurpose = 'chat-session-summary';
+    languageModelRequirements: LanguageModelRequirement[] = [{
+        purpose: 'chat-session-summary',
+        identifier: 'openai/gpt-4o-mini',
+    }];
+    override agentSpecificVariables = [];
+    override functions = [];
+    override locations = [];
+    override tags = [];
+}

package/src/common/context-summary-variable.ts

@@ -38,7 +38,7 @@ export class ContextSummaryVariableContribution implements AIVariableContributio
 
     async resolve(request: AIVariableResolutionRequest, context: AIVariableContext): Promise<ResolvedAIVariable | undefined> {
         if (!ChatSessionContext.is(context) || request.variable.name !== CONTEXT_SUMMARY_VARIABLE.name) { return undefined; }
-        const data = context.model.context.getVariables().filter(variable => variable.variable.isContextVariable)
+        const data = ChatSessionContext.getVariables(context).filter(variable => variable.variable.isContextVariable)
             .map(variable => ({
                 type: variable.variable.name,
                 // eslint-disable-next-line no-null/no-null

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);
     }
 };