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

package/src/browser/change-set-file-service.ts

@@ -14,8 +14,8 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { ILogger, UNTITLED_SCHEME, URI } from '@theia/core';
-import { DiffUris, LabelProvider, OpenerService, open } from '@theia/core/lib/browser';
+import { ILogger, URI } from '@theia/core';
+import { ApplicationShell, DiffUris, LabelProvider, NavigatableWidget, OpenerService, open } from '@theia/core/lib/browser';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { EditorManager } from '@theia/editor/lib/browser';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
@@ -40,6 +40,9 @@ export class ChangeSetFileService {
     @inject(EditorManager)
     protected readonly editorManager: EditorManager;
 
+    @inject(ApplicationShell)
+    protected readonly shell: ApplicationShell;
+
     @inject(MonacoWorkspace)
     protected readonly monacoWorkspace: MonacoWorkspace;
 
@@ -95,15 +98,14 @@ export class ChangeSetFileService {
     }
 
     async openDiff(originalUri: URI, suggestedUri: URI): Promise<void> {
-        const exists = await this.fileService.exists(originalUri);
-        const openedUri = exists ? originalUri : originalUri.withScheme(UNTITLED_SCHEME);
-        // Currently we don't have a great way to show the suggestions in a diff editor with accept/reject buttons
-        // So we just use plain diffs with the suggestions as original and the current state as modified, so users can apply changes in their current state
-        // But this leads to wrong colors and wrong label (revert change instead of accept change)
-        const diffUri = DiffUris.encode(openedUri, suggestedUri,
+        const diffUri = this.getDiffUri(originalUri, suggestedUri);
+        open(this.openerService, diffUri);
+    }
+
+    protected getDiffUri(originalUri: URI, suggestedUri: URI): URI {
+        return DiffUris.encode(originalUri, suggestedUri,
             `AI Changes: ${this.labelProvider.getName(originalUri)}`,
         );
-        open(this.openerService, diffUri);
     }
 
     async delete(uri: URI): Promise<void> {
@@ -113,24 +115,44 @@ export class ChangeSetFileService {
         }
     }
 
-    async write(uri: URI, targetState: string): Promise<void> {
-        const exists = await this.fileService.exists(uri);
-        if (!exists) {
-            await this.fileService.create(uri, targetState);
+    /** Returns true if there was a document available to save for the specified URI. */
+    async trySave(suggestedUri: URI): Promise<boolean> {
+        const openModel = this.monacoWorkspace.getTextDocument(suggestedUri.toString());
+        if (openModel) {
+            await openModel.save();
+            return true;
+        } else {
+            return false;
         }
-        await this.doWrite(uri, targetState);
     }
 
-    protected async doWrite(uri: URI, text: string): Promise<void> {
+    async writeFrom(from: URI, to: URI, fallbackContent: string): Promise<void> {
+        const authoritativeContent = this.monacoWorkspace.getTextDocument(from.toString())?.getText() ?? fallbackContent;
+        await this.write(to, authoritativeContent);
+    }
+
+    async write(uri: URI, text: string): Promise<void> {
         const document = this.monacoWorkspace.getTextDocument(uri.toString());
         if (document) {
             await this.monacoWorkspace.applyBackgroundEdit(document, [{
                 range: document.textEditorModel.getFullModelRange(),
                 text
-            }], (editor, wasDirty) => editor === undefined || !wasDirty);
+            }], () => true);
         } else {
             await this.fileService.write(uri, text);
         }
     }
 
+    closeDiffsForSession(sessionId: string, except?: URI[]): void {
+        const openEditors = this.shell.widgets.filter(widget => {
+            const uri = NavigatableWidget.getUri(widget);
+            return uri && uri.authority === sessionId && !except?.some(candidate => candidate.path.toString() === uri.path.toString());
+        });
+        openEditors.forEach(editor => editor.close());
+    }
+
+    closeDiff(uri: URI): void {
+        const openEditors = this.shell.widgets.filter(widget => NavigatableWidget.getUri(widget)?.isEqual(uri));
+        openEditors.forEach(editor => editor.close());
+    }
 }

package/src/browser/context-file-variable-label-provider.ts

@@ -0,0 +1,62 @@
+// *****************************************************************************
+// 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 { AIVariableResolutionRequest } from '@theia/ai-core';
+import { URI } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { LabelProvider, LabelProviderContribution } from '@theia/core/lib/browser';
+import { ChangeSetFileService } from './change-set-file-service';
+
+@injectable()
+export class ContextFileVariableLabelProvider implements LabelProviderContribution {
+
+    @inject(LabelProvider)
+    protected readonly labelProvider: LabelProvider;
+
+    @inject(ChangeSetFileService)
+    protected readonly changeSetFileService: ChangeSetFileService;
+
+    canHandle(element: object): number {
+        if (AIVariableResolutionRequest.is(element) && element.variable.name === 'file') {
+            return 10;
+        }
+        return -1;
+    }
+
+    getIcon(element: object): string | undefined {
+        return this.labelProvider.getIcon(this.getUri(element)!);
+    }
+
+    getName(element: object): string | undefined {
+        return this.labelProvider.getName(this.getUri(element)!);
+    }
+
+    getLongName(element: object): string | undefined {
+        return this.labelProvider.getLongName(this.getUri(element)!);
+    }
+
+    getDetails(element: object): string | undefined {
+        return this.changeSetFileService.getAdditionalInfo(this.getUri(element)!);
+    }
+
+    protected getUri(element: object): URI | undefined {
+        if (!AIVariableResolutionRequest.is(element)) {
+            return undefined;
+        }
+        return new URI(element.arg);
+    }
+
+}

package/src/browser/context-variable-label-provider.ts

@@ -0,0 +1,56 @@
+// *****************************************************************************
+// 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 { AIVariableResolutionRequest } from '@theia/ai-core';
+import { LabelProviderContribution } from '@theia/core/lib/browser';
+import { injectable } from '@theia/core/shared/inversify';
+
+@injectable()
+export class ContextVariableLabelProvider implements LabelProviderContribution {
+
+    canHandle(element: object): number {
+        if (AIVariableResolutionRequest.is(element)) {
+            return 1;
+        }
+        return -1;
+    }
+
+    getIcon(element: object): string | undefined {
+        return 'codicon codicon-variable';
+    }
+
+    getName(element: object): string | undefined {
+        if (!AIVariableResolutionRequest.is(element)) {
+            return undefined;
+        }
+        return element.variable.name;
+    }
+
+    getLongName(element: object): string | undefined {
+        if (!AIVariableResolutionRequest.is(element)) {
+            return undefined;
+        }
+        return element.variable.name + (element.arg ? ':' + element.arg : '');
+    }
+
+    getDetails(element: object): string | undefined {
+        if (!AIVariableResolutionRequest.is(element)) {
+            return undefined;
+        }
+        return element.arg;
+    }
+
+}

package/src/browser/file-chat-variable-contribution.ts

@@ -0,0 +1,143 @@
+// *****************************************************************************
+// 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 { AIVariableContext, AIVariableResolutionRequest, PromptText } from '@theia/ai-core';
+import { AIVariableDropResult, FrontendVariableContribution, FrontendVariableService } from '@theia/ai-core/lib/browser';
+import { FILE_VARIABLE } from '@theia/ai-core/lib/browser/file-variable-contribution';
+import { CancellationToken, QuickInputService, URI } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import * as monaco from '@theia/monaco-editor-core';
+import { FileQuickPickItem, QuickFileSelectService } from '@theia/file-search/lib/browser/quick-file-select-service';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+
+@injectable()
+export class FileChatVariableContribution implements FrontendVariableContribution {
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly wsService: WorkspaceService;
+
+    @inject(QuickInputService)
+    protected readonly quickInputService: QuickInputService;
+
+    @inject(QuickFileSelectService)
+    protected readonly quickFileSelectService: QuickFileSelectService;
+
+    registerVariables(service: FrontendVariableService): void {
+        service.registerArgumentPicker(FILE_VARIABLE, this.triggerArgumentPicker.bind(this));
+        service.registerArgumentCompletionProvider(FILE_VARIABLE, this.provideArgumentCompletionItems.bind(this));
+        service.registerDropHandler(this.handleDrop.bind(this));
+    }
+
+    protected async triggerArgumentPicker(): Promise<string | undefined> {
+        const quickPick = this.quickInputService.createQuickPick();
+        quickPick.items = await this.quickFileSelectService.getPicks();
+
+        const updateItems = async (value: string) => {
+            quickPick.items = await this.quickFileSelectService.getPicks(value, CancellationToken.None);
+        };
+
+        const onChangeListener = quickPick.onDidChangeValue(updateItems);
+        quickPick.show();
+
+        return new Promise(resolve => {
+            quickPick.onDispose(onChangeListener.dispose);
+            quickPick.onDidAccept(async () => {
+                const selectedItem = quickPick.selectedItems[0];
+                if (selectedItem && FileQuickPickItem.is(selectedItem)) {
+                    quickPick.dispose();
+                    resolve(await this.wsService.getWorkspaceRelativePath(selectedItem.uri));
+                }
+            });
+        });
+    }
+
+    protected async provideArgumentCompletionItems(
+        model: monaco.editor.ITextModel,
+        position: monaco.Position
+    ): Promise<monaco.languages.CompletionItem[] | undefined> {
+        const lineContent = model.getLineContent(position.lineNumber);
+        const indexOfVariableTrigger = lineContent.lastIndexOf(PromptText.VARIABLE_CHAR, position.column - 1);
+
+        // check if there is a variable trigger and no space typed between the variable trigger and the cursor
+        if (indexOfVariableTrigger === -1 || lineContent.substring(indexOfVariableTrigger).includes(' ')) {
+            return undefined;
+        }
+
+        // determine whether we are providing completions before or after the variable argument separator
+        const indexOfVariableArgSeparator = lineContent.lastIndexOf(PromptText.VARIABLE_SEPARATOR_CHAR, position.column - 1);
+        const triggerCharIndex = Math.max(indexOfVariableTrigger, indexOfVariableArgSeparator);
+
+        const typedWord = lineContent.substring(triggerCharIndex + 1, position.column - 1);
+        const range = new monaco.Range(position.lineNumber, triggerCharIndex + 2, position.lineNumber, position.column);
+        const picks = await this.quickFileSelectService.getPicks(typedWord, CancellationToken.None);
+        const prefix = lineContent[triggerCharIndex] === PromptText.VARIABLE_CHAR ? FILE_VARIABLE.name + PromptText.VARIABLE_SEPARATOR_CHAR : '';
+
+        return Promise.all(
+            picks
+                .filter(FileQuickPickItem.is)
+                // only show files with highlights, if the user started typing to filter down the results
+                .filter(p => !typedWord || p.highlights?.label)
+                .map(async (pick, index) => ({
+                    label: pick.label,
+                    kind: monaco.languages.CompletionItemKind.File,
+                    range,
+                    insertText: `${prefix}${await this.wsService.getWorkspaceRelativePath(pick.uri)}`,
+                    detail: await this.wsService.getWorkspaceRelativePath(pick.uri.parent),
+                    // don't let monaco filter the items, as we only return picks that are filtered
+                    filterText: typedWord,
+                    // keep the order of the items, but move them to the end of the list
+                    sortText: `ZZ${index.toString().padStart(4, '0')}_${pick.label}`,
+                }))
+        );
+    }
+
+    protected async handleDrop(event: DragEvent, _: AIVariableContext): Promise<AIVariableDropResult | undefined> {
+        const data = event.dataTransfer?.getData('selected-tree-nodes');
+        if (!data) {
+            return undefined;
+        }
+
+        try {
+            const nodes: string[] = JSON.parse(data);
+            const variables: AIVariableResolutionRequest[] = [];
+            const texts: string[] = [];
+
+            for (const node of nodes) {
+                const [, filePath] = node.split(':');
+                if (!filePath) {
+                    continue;
+                }
+
+                const uri = URI.fromFilePath(filePath);
+                if (await this.fileService.exists(uri)) {
+                    const wsRelativePath = await this.wsService.getWorkspaceRelativePath(uri);
+                    variables.push({
+                        variable: FILE_VARIABLE,
+                        arg: wsRelativePath
+                    });
+                    texts.push(`${PromptText.VARIABLE_CHAR}${FILE_VARIABLE.name}${PromptText.VARIABLE_SEPARATOR_CHAR}${wsRelativePath}`);
+                }
+            }
+
+            return { variables, text: texts.length ? texts.join(' ') : undefined };
+        } catch {
+            return undefined;
+        }
+    }
+}

package/src/browser/frontend-chat-service.ts

@@ -15,44 +15,45 @@
 // *****************************************************************************
 
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { ChatAgent, ChatServiceImpl, ParsedChatRequest } from '../common';
+import { ChangeSet, ChatAgent, ChatAgentLocation, ChatServiceImpl, ChatSession, ParsedChatRequest, SessionOptions } from '../common';
 import { PreferenceService } from '@theia/core/lib/browser';
-import { DEFAULT_CHAT_AGENT_PREF } from './ai-chat-preferences';
+import { DEFAULT_CHAT_AGENT_PREF, PIN_CHAT_AGENT_PREF } from './ai-chat-preferences';
+import { ChangeSetFileService } from './change-set-file-service';
 
+/**
+ * Customizes the ChatServiceImpl to consider preference based default chat agent
+ */
 @injectable()
 export class FrontendChatServiceImpl extends ChatServiceImpl {
 
     @inject(PreferenceService)
-    protected preferenceService: PreferenceService;
+    protected readonly preferenceService: PreferenceService;
 
-    protected override getAgent(parsedRequest: ParsedChatRequest): ChatAgent | undefined {
-        const agentPart = this.getMentionedAgent(parsedRequest);
-        if (agentPart) {
-            return this.chatAgentService.getAgent(agentPart.agentId);
-        }
+    @inject(ChangeSetFileService)
+    protected readonly changeSetFileService: ChangeSetFileService;
 
-        const configuredDefaultChatAgent = this.getConfiguredDefaultChatAgent();
-        if (configuredDefaultChatAgent) {
-            return configuredDefaultChatAgent;
+    protected override getAgent(parsedRequest: ParsedChatRequest, session: ChatSession): ChatAgent | undefined {
+        let agent = this.initialAgentSelection(parsedRequest);
+        if (!this.preferenceService.get<boolean>(PIN_CHAT_AGENT_PREF)) {
+            return agent;
         }
-
-        if (this.defaultChatAgentId) {
-            const defaultAgent = this.chatAgentService.getAgent(this.defaultChatAgentId.id);
-            // the default agent could be disabled
-            if (defaultAgent) {
-                return defaultAgent;
-            }
+        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;
+    }
 
-        // check whether "Universal" is available
-        const universalAgent = this.chatAgentService.getAgent('Universal');
-        if (universalAgent) {
-            return universalAgent;
+    protected override initialAgentSelection(parsedRequest: ParsedChatRequest): ChatAgent | undefined {
+        const agentPart = this.getMentionedAgent(parsedRequest);
+        if (!agentPart) {
+            const configuredDefaultChatAgent = this.getConfiguredDefaultChatAgent();
+            if (configuredDefaultChatAgent) {
+                return configuredDefaultChatAgent;
+            }
         }
-
-        this.logger.warn('No default chat agent is configured or available and the "Universal" Chat Agent is unavailable too. Falling back to first registered agent.');
-
-        return this.chatAgentService.getAgents()[0] ?? undefined;
+        return super.initialAgentSelection(parsedRequest);
     }
 
     protected getConfiguredDefaultChatAgent(): ChatAgent | undefined {
@@ -63,4 +64,17 @@ export class FrontendChatServiceImpl extends ChatServiceImpl {
         }
         return configuredDefaultChatAgent;
     }
+
+    override createSession(location?: ChatAgentLocation, options?: SessionOptions): ChatSession {
+        const session = super.createSession(location, options);
+        session.model.onDidChange(event => {
+            const changeSet = (event as { changeSet?: ChangeSet }).changeSet;
+            if (event.kind === 'removeChangeSet') {
+                this.changeSetFileService.closeDiffsForSession(session.id);
+            } else if (changeSet) {
+                this.changeSetFileService.closeDiffsForSession(session.id, changeSet.getElements().map(({ uri }) => uri));
+            }
+        });
+        return session;
+    }
 }

package/src/common/chat-agents.ts

@@ -20,6 +20,7 @@
 // Partially copied from https://github.com/microsoft/vscode/blob/a2cab7255c0df424027be05d58e1b7b941f4ea60/src/vs/workbench/contrib/chat/common/chatAgents.ts
 
 import {
+    AgentSpecificVariables,
     CommunicationRecordingService,
     getTextOfResponse,
     LanguageModel,
@@ -27,7 +28,9 @@ import {
     LanguageModelResponse,
     LanguageModelStreamResponse,
     PromptService,
+    PromptTemplate,
     ResolvedPromptTemplate,
+    ToolCall,
     ToolRequest,
 } from '@theia/ai-core';
 import {
@@ -39,11 +42,11 @@ import {
     MessageActor,
 } from '@theia/ai-core/lib/common';
 import { CancellationToken, ContributionProvider, ILogger, isArray } from '@theia/core';
-import { inject, injectable, named, postConstruct, unmanaged } from '@theia/core/shared/inversify';
+import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
 import { ChatAgentService } from './chat-agent-service';
 import {
     ChatModel,
-    ChatRequestModelImpl,
+    MutableChatRequestModel,
     ChatResponseContent,
     ErrorChatResponseContentImpl,
     MarkdownChatResponseContentImpl,
@@ -115,11 +118,11 @@ export const ChatAgent = Symbol('ChatAgent');
 export interface ChatAgent extends Agent {
     locations: ChatAgentLocation[];
     iconClass?: string;
-    invoke(request: ChatRequestModelImpl, chatAgentService?: ChatAgentService): Promise<void>;
+    invoke(request: MutableChatRequestModel, chatAgentService?: ChatAgentService): Promise<void>;
 }
 
 @injectable()
-export abstract class AbstractChatAgent {
+export abstract class AbstractChatAgent implements ChatAgent {
     @inject(LanguageModelRegistry) protected languageModelRegistry: LanguageModelRegistry;
     @inject(ILogger) protected logger: ILogger;
     @inject(CommunicationRecordingService) protected recordingService: CommunicationRecordingService;
@@ -128,21 +131,26 @@ export abstract class AbstractChatAgent {
 
     @inject(ContributionProvider) @named(ResponseContentMatcherProvider)
     protected contentMatcherProviders: ContributionProvider<ResponseContentMatcherProvider>;
-    protected additionalToolRequests: ToolRequest[] = [];
-    protected contentMatchers: ResponseContentMatcher[] = [];
 
     @inject(DefaultResponseContentFactory)
     protected defaultContentFactory: DefaultResponseContentFactory;
 
-    constructor(
-        @unmanaged() public id: string,
-        @unmanaged() public languageModelRequirements: LanguageModelRequirement[],
-        @unmanaged() protected defaultLanguageModelPurpose: string,
-        @unmanaged() public iconClass: string = 'codicon codicon-copilot',
-        @unmanaged() public locations: ChatAgentLocation[] = ChatAgentLocation.ALL,
-        @unmanaged() public tags: string[] = ['Chat'],
-        @unmanaged() public defaultLogging: boolean = true) {
-    }
+    readonly abstract id: string;
+    readonly abstract name: string;
+    readonly abstract languageModelRequirements: LanguageModelRequirement[];
+    iconClass: string = 'codicon codicon-copilot';
+    locations: ChatAgentLocation[] = ChatAgentLocation.ALL;
+    tags: string[] = ['Chat'];
+    description: string = '';
+    variables: string[] = [];
+    promptTemplates: PromptTemplate[] = [];
+    agentSpecificVariables: AgentSpecificVariables[] = [];
+    functions: string[] = [];
+    protected readonly abstract defaultLanguageModelPurpose: string;
+    protected defaultLogging: boolean = true;
+    protected systemPromptId: string | undefined = undefined;
+    protected additionalToolRequests: ToolRequest[] = [];
+    protected contentMatchers: ResponseContentMatcher[] = [];
 
     @postConstruct()
     init(): void {
@@ -154,7 +162,7 @@ export abstract class AbstractChatAgent {
         this.contentMatchers.push(...contributedContentMatchers);
     }
 
-    async invoke(request: ChatRequestModelImpl): Promise<void> {
+    async invoke(request: MutableChatRequestModel): Promise<void> {
         try {
             const languageModel = await this.getLanguageModel(this.defaultLanguageModelPurpose);
             if (!languageModel) {
@@ -206,7 +214,7 @@ export abstract class AbstractChatAgent {
         }
     }
 
-    protected parseContents(text: string, request: ChatRequestModelImpl): ChatResponseContent[] {
+    protected parseContents(text: string, request: MutableChatRequestModel): ChatResponseContent[] {
         return parseContents(
             text,
             request,
@@ -215,7 +223,7 @@ export abstract class AbstractChatAgent {
         );
     };
 
-    protected handleError(request: ChatRequestModelImpl, error: Error): void {
+    protected handleError(request: MutableChatRequestModel, error: Error): void {
         request.response.response.addContent(new ErrorChatResponseContentImpl(error));
         request.response.error(error);
     }
@@ -236,7 +244,13 @@ export abstract class AbstractChatAgent {
         return languageModel;
     }
 
-    protected abstract getSystemMessageDescription(): Promise<SystemMessageDescription | undefined>;
+    protected async getSystemMessageDescription(): Promise<SystemMessageDescription | undefined> {
+        if (this.systemPromptId === undefined) {
+            return undefined;
+        }
+        const resolvedPrompt = await this.promptService.getPrompt(this.systemPromptId);
+        return resolvedPrompt ? SystemMessageDescription.fromResolvedPromptTemplate(resolvedPrompt) : undefined;
+    }
 
     protected async getMessages(
         model: ChatModel, includeResponseInProgress = false
@@ -290,17 +304,17 @@ export abstract class AbstractChatAgent {
      * The default implementation sets the state of the response to `complete`.
      * Subclasses may override this method to perform additional actions or keep the response open for processing further requests.
      */
-    protected async onResponseComplete(request: ChatRequestModelImpl): Promise<void> {
+    protected async onResponseComplete(request: MutableChatRequestModel): Promise<void> {
         return request.response.complete();
     }
 
-    protected abstract addContentsToResponse(languageModelResponse: LanguageModelResponse, request: ChatRequestModelImpl): Promise<void>;
+    protected abstract addContentsToResponse(languageModelResponse: LanguageModelResponse, request: MutableChatRequestModel): Promise<void>;
 }
 
 @injectable()
 export abstract class AbstractTextToModelParsingChatAgent<T> extends AbstractChatAgent {
 
-    protected async addContentsToResponse(languageModelResponse: LanguageModelResponse, request: ChatRequestModelImpl): Promise<void> {
+    protected async addContentsToResponse(languageModelResponse: LanguageModelResponse, request: MutableChatRequestModel): Promise<void> {
         const responseAsText = await getTextOfResponse(languageModelResponse);
         const parsedCommand = await this.parseTextResponse(responseAsText);
         const content = this.createResponseContent(parsedCommand, request);
@@ -309,13 +323,31 @@ export abstract class AbstractTextToModelParsingChatAgent<T> extends AbstractCha
 
     protected abstract parseTextResponse(text: string): Promise<T>;
 
-    protected abstract createResponseContent(parsedModel: T, request: ChatRequestModelImpl): ChatResponseContent;
+    protected abstract createResponseContent(parsedModel: T, request: MutableChatRequestModel): ChatResponseContent;
+}
+
+/**
+ * Factory for creating ToolCallChatResponseContent instances.
+ */
+@injectable()
+export class ToolCallChatResponseContentFactory {
+    create(toolCall: ToolCall): ChatResponseContent {
+        return new ToolCallChatResponseContentImpl(
+            toolCall.id,
+            toolCall.function?.name,
+            toolCall.function?.arguments,
+            toolCall.finished,
+            toolCall.result
+        );
+    }
 }
 
 @injectable()
 export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
+    @inject(ToolCallChatResponseContentFactory)
+    protected toolCallResponseContentFactory: ToolCallChatResponseContentFactory;
 
-    protected override async addContentsToResponse(languageModelResponse: LanguageModelResponse, request: ChatRequestModelImpl): Promise<void> {
+    protected override async addContentsToResponse(languageModelResponse: LanguageModelResponse, request: MutableChatRequestModel): Promise<void> {
         if (isLanguageModelTextResponse(languageModelResponse)) {
             const contents = this.parseContents(languageModelResponse.text, request);
             request.response.response.addContents(contents);
@@ -335,7 +367,7 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
         );
     }
 
-    protected async addStreamResponse(languageModelResponse: LanguageModelStreamResponse, request: ChatRequestModelImpl): Promise<void> {
+    protected async addStreamResponse(languageModelResponse: LanguageModelStreamResponse, request: MutableChatRequestModel): Promise<void> {
         for await (const token of languageModelResponse.stream) {
             const newContents = this.parse(token, request);
             if (isArray(newContents)) {
@@ -362,7 +394,7 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
         }
     }
 
-    protected parse(token: LanguageModelStreamResponsePart, request: ChatRequestModelImpl): ChatResponseContent | ChatResponseContent[] {
+    protected parse(token: LanguageModelStreamResponsePart, request: MutableChatRequestModel): ChatResponseContent | ChatResponseContent[] {
         const content = token.content;
         // eslint-disable-next-line no-null/no-null
         if (content !== undefined && content !== null) {
@@ -371,10 +403,23 @@ export abstract class AbstractStreamParsingChatAgent extends AbstractChatAgent {
         const toolCalls = token.tool_calls;
         if (toolCalls !== undefined) {
             const toolCallContents = toolCalls.map(toolCall =>
-                new ToolCallChatResponseContentImpl(toolCall.id, toolCall.function?.name, toolCall.function?.arguments, toolCall.finished, toolCall.result));
+                this.createToolCallResponseContent(toolCall)
+            );
             return toolCallContents;
         }
         return this.defaultContentFactory.create('', request);
     }
 
+    /**
+     * Creates a ToolCallChatResponseContent instance from the provided tool call data.
+     *
+     * This method is called when parsing stream response tokens that contain tool call data.
+     * Subclasses can override this method to customize the creation of tool call response contents.
+     *
+     * @param toolCall The ToolCall.
+     * @returns A ChatResponseContent representing the tool call.
+     */
+    protected createToolCallResponseContent(toolCall: ToolCall): ChatResponseContent {
+        return this.toolCallResponseContentFactory.create(toolCall);
+    }
 }