@theia/ai-chat-ui 1.61.0-next.8 → 1.62.0-next.3

package/src/browser/chat-tree-view/chat-view-tree-widget.tsx

@@ -20,10 +20,16 @@ import {
     ChatRequestModel,
     ChatResponseContent,
     ChatResponseModel,
+    ChatService,
+    EditableChatRequestModel,
     ParsedChatRequestAgentPart,
     ParsedChatRequestVariablePart,
+    type ChatRequest,
+    type ChatHierarchyBranch,
 } from '@theia/ai-chat';
-import { CommandRegistry, ContributionProvider } from '@theia/core';
+import { AIVariableService } from '@theia/ai-core';
+import { AIActivationService } from '@theia/ai-core/lib/browser';
+import { CommandRegistry, ContributionProvider, Disposable, DisposableCollection, Emitter } from '@theia/core';
 import {
     codicon,
     CompositeTreeNode,
@@ -37,7 +43,10 @@ import {
     TreeNode,
     TreeProps,
     TreeWidget,
+    Widget,
+    type ReactWidget
 } from '@theia/core/lib/browser';
+import { nls } from '@theia/core/lib/common/nls';
 import {
     inject,
     injectable,
@@ -46,20 +55,24 @@ import {
     postConstruct
 } from '@theia/core/shared/inversify';
 import * as React from '@theia/core/shared/react';
-import { nls } from '@theia/core/lib/common/nls';
-
 import { ChatNodeToolbarActionContribution } from '../chat-node-toolbar-action-contribution';
 import { ChatResponsePartRenderer } from '../chat-response-part-renderer';
 import { useMarkdownRendering } from '../chat-response-renderer/markdown-part-renderer';
-import { AIVariableService } from '@theia/ai-core';
 import { ProgressMessage } from '../chat-progress-message';
+import { AIChatTreeInputFactory, type AIChatTreeInputWidget } from './chat-view-tree-input-widget';
 
 // TODO Instead of directly operating on the ChatRequestModel we could use an intermediate view model
 export interface RequestNode extends TreeNode {
-    request: ChatRequestModel
+    request: ChatRequestModel,
+    branch: ChatHierarchyBranch
 }
 export const isRequestNode = (node: TreeNode): node is RequestNode => 'request' in node;
 
+export interface EditableRequestNode extends RequestNode {
+    request: EditableChatRequestModel
+}
+export const isEditableRequestNode = (node: TreeNode): node is EditableRequestNode => isRequestNode(node) && EditableChatRequestModel.is(node.request);
+
 // TODO Instead of directly operating on the ChatResponseModel we could use an intermediate view model
 export interface ResponseNode extends TreeNode {
     response: ChatResponseModel
@@ -105,6 +118,20 @@ export class ChatViewTreeWidget extends TreeWidget {
     @inject(ChatWelcomeMessageProvider) @optional()
     protected welcomeMessageProvider?: ChatWelcomeMessageProvider;
 
+    @inject(AIChatTreeInputFactory)
+    protected inputWidgetFactory: AIChatTreeInputFactory;
+
+    @inject(AIActivationService)
+    protected readonly activationService: AIActivationService;
+
+    @inject(ChatService)
+    protected readonly chatService: ChatService;
+
+    protected readonly onDidSubmitEditEmitter = new Emitter<ChatRequest>();
+    onDidSubmitEdit = this.onDidSubmitEditEmitter.event;
+
+    protected readonly chatInputs: Map<string, AIChatTreeInputWidget> = new Map();
+
     protected _shouldScrollToEnd = true;
 
     protected isEnabled = false;
@@ -143,6 +170,16 @@ export class ChatViewTreeWidget extends TreeWidget {
 
         this.id = ChatViewTreeWidget.ID + '-treeContainer';
         this.addClass('treeContainer');
+
+        this.toDispose.pushAll([
+            this.toDisposeOnChatModelChange,
+            this.activationService.onDidChangeActiveStatus(change => {
+                this.chatInputs.forEach(widget => {
+                    widget.setEnabled(change);
+                });
+                this.update();
+            })
+        ]);
     }
 
     public setEnabled(enabled: boolean): void {
@@ -168,11 +205,16 @@ export class ChatViewTreeWidget extends TreeWidget {
         return this.welcomeMessageProvider?.renderWelcomeMessage?.() ?? <></>;
     }
 
-    protected mapRequestToNode(request: ChatRequestModel): RequestNode {
+    protected mapRequestToNode(branch: ChatHierarchyBranch): RequestNode {
         return {
-            id: request.id,
             parent: this.model.root as CompositeTreeNode,
-            request
+            get id(): string {
+                return this.request.id;
+            },
+            get request(): ChatRequestModel {
+                return branch.get();
+            },
+            branch
         };
     }
 
@@ -184,25 +226,60 @@ export class ChatViewTreeWidget extends TreeWidget {
         };
     }
 
+    protected readonly toDisposeOnChatModelChange = new DisposableCollection();
     /**
      * Tracks the ChatModel handed over.
      * Tracking multiple chat models will result in a weird UI
      */
     public trackChatModel(chatModel: ChatModel): void {
+        this.toDisposeOnChatModelChange.dispose();
         this.recreateModelTree(chatModel);
         chatModel.getRequests().forEach(request => {
             if (!request.response.isComplete) {
                 request.response.onDidChange(() => this.scheduleUpdateScrollToRow());
             }
         });
-        this.toDispose.push(
+        this.toDisposeOnChatModelChange.pushAll([
+            Disposable.create(() => {
+                this.chatInputs.forEach(widget => widget.dispose());
+                this.chatInputs.clear();
+            }),
             chatModel.onDidChange(event => {
+                if (event.kind === 'enableEdit') {
+                    this.scrollToRow = this.rows.get(event.request.id)?.index;
+                    this.update();
+                    return;
+                } else if (event.kind === 'cancelEdit') {
+                    this.disposeChatInputWidget(event.request);
+                    this.scrollToRow = undefined;
+                    this.update();
+                    return;
+                } else if (event.kind === 'changeHierarchyBranch') {
+                    this.scrollToRow = undefined;
+                }
+
                 this.recreateModelTree(chatModel);
+
                 if (event.kind === 'addRequest' && !event.request.response.isComplete) {
                     event.request.response.onDidChange(() => this.scheduleUpdateScrollToRow());
+                } else if (event.kind === 'submitEdit') {
+                    event.branch.succeedingBranches().forEach(branch => {
+                        this.disposeChatInputWidget(branch.get());
+                    });
+                    this.onDidSubmitEditEmitter.fire(
+                        event.newRequest,
+                    );
                 }
             })
-        );
+        ]);
+    }
+
+    protected disposeChatInputWidget(request: ChatRequestModel): void {
+        const widget = this.chatInputs.get(request.id);
+        if (widget) {
+            widget.dispose();
+            this.chatInputs.delete(request.id);
+        }
     }
 
     protected override getScrollToRow(): number | undefined {
@@ -215,8 +292,9 @@ export class ChatViewTreeWidget extends TreeWidget {
     protected async recreateModelTree(chatModel: ChatModel): Promise<void> {
         if (CompositeTreeNode.is(this.model.root)) {
             const nodes: TreeNode[] = [];
-            chatModel.getRequests().forEach(request => {
-                nodes.push(this.mapRequestToNode(request));
+            chatModel.getBranches().forEach(branch => {
+                const request = branch.get();
+                nodes.push(this.mapRequestToNode(branch));
                 nodes.push(this.mapResponseToNode(request.response));
             });
             this.model.root.children = nodes;
@@ -338,6 +416,32 @@ export class ChatViewTreeWidget extends TreeWidget {
             chatAgentService={this.chatAgentService}
             variableService={this.variableService}
             openerService={this.openerService}
+            provideChatInputWidget={() => {
+                const editableNode = node;
+                if (isEditableRequestNode(editableNode)) {
+                    let widget = this.chatInputs.get(editableNode.id);
+                    if (!widget) {
+                        widget = this.inputWidgetFactory({
+                            node: editableNode,
+                            initialValue: editableNode.request.message.request.text,
+                            onQuery: async query => {
+                                editableNode.request.submitEdit({ text: query });
+                            }
+                        });
+
+                        this.chatInputs.set(editableNode.id, widget);
+
+                        widget.disposed.connect(() => {
+                            this.chatInputs.delete(editableNode.id);
+                            editableNode.request.cancelEdit();
+                        });
+                    }
+
+                    return widget;
+                }
+
+                return;
+            }}
         />;
     }
 
@@ -397,19 +501,92 @@ export class ChatViewTreeWidget extends TreeWidget {
         });
         event.preventDefault();
     }
+
+    protected override handleSpace(event: KeyboardEvent): boolean {
+        // We need to return false to prevent the handler within
+        // packages/core/src/browser/widgets/widget.ts
+        // Otherwise, the space key will never be handled by the monaco editor
+        return false;
+    }
+}
+
+interface WidgetContainerProps {
+    widget: ReactWidget;
 }
 
+const WidgetContainer: React.FC<WidgetContainerProps> = ({ widget }) => {
+    // eslint-disable-next-line no-null/no-null
+    const containerRef = React.useRef<HTMLDivElement | null>(null);
+
+    React.useEffect(() => {
+        if (containerRef.current && !widget.isAttached) {
+            Widget.attach(widget, containerRef.current);
+        }
+    }, [containerRef.current]);
+
+    // Clean up
+    React.useEffect(() =>
+        () => {
+            setTimeout(() => {
+                // Delay clean up to allow react to finish its rendering cycle
+                widget.clearFlag(Widget.Flag.IsAttached);
+                widget.dispose();
+            });
+        }, []);
+
+    return <div ref={containerRef} />;
+};
+
 const ChatRequestRender = (
     {
-        node, hoverService, chatAgentService, variableService, openerService
+        node, hoverService, chatAgentService, variableService, openerService,
+        provideChatInputWidget
     }: {
         node: RequestNode,
         hoverService: HoverService,
         chatAgentService: ChatAgentService,
         variableService: AIVariableService,
-        openerService: OpenerService
+        openerService: OpenerService,
+        provideChatInputWidget: () => ReactWidget | undefined,
     }) => {
     const parts = node.request.message.parts;
+    if (EditableChatRequestModel.isEditing(node.request)) {
+        const widget = provideChatInputWidget();
+        if (widget) {
+            return <div className="theia-RequestNode">
+                <WidgetContainer widget={widget}></WidgetContainer>
+            </div>;
+        }
+    }
+
+    const renderFooter = () => {
+        if (node.branch.items.length < 2) {
+            return;
+        }
+
+        const isFirst = node.branch.activeBranchIndex === 0;
+        const isLast = node.branch.activeBranchIndex === node.branch.items.length - 1;
+
+        return (
+            <div className='theia-RequestNode-Footer'>
+                <div className={`item ${isFirst ? '' : 'enabled'}`}>
+                    <div className="codicon codicon-chevron-left action-label" title="Previous" onClick={() => {
+                        node.branch.enablePrevious();
+                    }}></div>
+                </div>
+                <small>
+                    <span>{node.branch.activeBranchIndex + 1}/</span>
+                    <span>{node.branch.items.length}</span>
+                </small>
+                <div className={`item ${isLast ? '' : 'enabled'}`}>
+                    <div className='codicon codicon-chevron-right action-label' title="Next" onClick={() => {
+                        node.branch.enableNext();
+                    }}></div>
+                </div>
+            </div>
+        );
+    };
+
     return (
         <div className="theia-RequestNode">
             <p>
@@ -434,14 +611,20 @@ const ChatRequestRender = (
                             />
                         );
                     } else {
-                        // maintain the leading and trailing spaces with explicit `&nbsp;`, otherwise they would get trimmed by the markdown renderer
-                        const ref = useMarkdownRendering(part.text.replace(/^\s|\s$/g, '&nbsp;'), openerService, true);
+                        const ref = useMarkdownRendering(
+                            part.text
+                                .replace(/^[\r\n]+|[\r\n]+$/g, '') // remove excessive new lines
+                                .replace(/(^ )/g, '&nbsp;'), // enforce keeping space before
+                            openerService,
+                            true
+                        );
                         return (
                             <span key={index} ref={ref}></span>
                         );
                     }
                 })}
             </p>
+            {renderFooter()}
         </div>
     );
 };

package/src/browser/chat-view-commands.ts

@@ -38,6 +38,24 @@ export namespace ChatCommands {
         category: CHAT_CATEGORY,
         iconClass: codicon('bracket')
     }, 'Set Session Settings', CHAT_CATEGORY_KEY);
+
+    export const AI_CHAT_NEW_WITH_TASK_CONTEXT: Command = {
+        id: 'ai-chat.new-with-task-context',
+    };
+
+    export const AI_CHAT_SUMMARIZE_CURRENT_SESSION = Command.toLocalizedCommand({
+        id: 'ai-chat-summary-current-session',
+        iconClass: codicon('go-to-editing-session'),
+        label: 'Summarize Current Session',
+        category: CHAT_CATEGORY
+    }, undefined, CHAT_CATEGORY_KEY);
+
+    export const AI_CHAT_OPEN_SUMMARY_FOR_CURRENT_SESSION = Command.toLocalizedCommand({
+        id: 'ai-chat-open-current-session-summary',
+        iconClass: codicon('note'),
+        label: 'Open Current Session Summary',
+        category: CHAT_CATEGORY
+    }, undefined, CHAT_CATEGORY_KEY);
 }
 
 export const AI_CHAT_NEW_CHAT_WINDOW_COMMAND: Command = {

package/src/browser/chat-view-contribution.ts

@@ -17,9 +17,11 @@ import { Command, CommandContribution, CommandRegistry, CommandService, isObject
 import { CommonCommands, TreeNode } from '@theia/core/lib/browser';
 import { ClipboardService } from '@theia/core/lib/browser/clipboard-service';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { ChatViewTreeWidget, isRequestNode, isResponseNode, RequestNode, ResponseNode } from './chat-tree-view/chat-view-tree-widget';
+import {
+    ChatViewTreeWidget, isEditableRequestNode, isRequestNode,
+    isResponseNode, RequestNode, ResponseNode, type EditableRequestNode
+} from './chat-tree-view/chat-view-tree-widget';
 import { AIChatInputWidget } from './chat-input-widget';
-import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 
 export namespace ChatViewCommands {
     export const COPY_MESSAGE = Command.toDefaultLocalizedCommand({
@@ -34,6 +36,10 @@ export namespace ChatViewCommands {
         id: 'chat.copy.code',
         label: 'Copy Code Block'
     }, 'theia/ai/chat-ui/copyCodeBlock');
+    export const EDIT = Command.toLocalizedCommand({
+        id: 'chat.edit.request',
+        label: 'Edit'
+    }, 'theia/ai/chat-ui/editRequest');
 }
 
 @injectable()
@@ -56,17 +62,6 @@ export class ChatViewMenuContribution implements MenuContribution, CommandContri
             },
             isEnabled: (...args: unknown[]) => containsRequestOrResponseNode(args)
         });
-        commands.registerHandler(CommonCommands.PASTE.id, {
-            execute: async (...args) => {
-                if (hasEditorAsFirstArg(args)) {
-                    const editor = args[0];
-                    const range = editor.selection;
-                    const newText = await this.clipboardService.readText();
-                    editor.executeEdits([{ range, newText }]);
-                }
-            },
-            isEnabled: (...args) => hasEditorAsFirstArg(args)
-        });
         commands.registerCommand(ChatViewCommands.COPY_MESSAGE, {
             execute: (...args: unknown[]) => {
                 if (containsRequestOrResponseNode(args)) {
@@ -102,6 +97,13 @@ export class ChatViewMenuContribution implements MenuContribution, CommandContri
             },
             isEnabled: (...args: unknown[]) => containsRequestOrResponseNode(args) && containsCode(args)
         });
+        commands.registerCommand(ChatViewCommands.EDIT, {
+            execute: (...args: [EditableRequestNode, ...unknown[]]) => {
+                args[0].request.enableEdit();
+            },
+            isEnabled: (...args: unknown[]) => hasAsFirstArg(args, isEditableRequestNode) && !args[0].request.isEditing,
+            isVisible: (...args: unknown[]) => hasAsFirstArg(args, isEditableRequestNode) && !args[0].request.isEditing
+        });
     }
 
     protected copyMessage(args: (RequestNode | ResponseNode)[]): void {
@@ -135,6 +137,9 @@ export class ChatViewMenuContribution implements MenuContribution, CommandContri
         menus.registerMenuAction([...ChatViewTreeWidget.CONTEXT_MENU, '_1'], {
             commandId: ChatViewCommands.COPY_CODE.id
         });
+        menus.registerMenuAction([...ChatViewTreeWidget.CONTEXT_MENU, '_1'], {
+            commandId: ChatViewCommands.EDIT.id
+        });
         menus.registerMenuAction([...AIChatInputWidget.CONTEXT_MENU, '_1'], {
             commandId: CommonCommands.COPY.id
         });
@@ -142,11 +147,10 @@ export class ChatViewMenuContribution implements MenuContribution, CommandContri
             commandId: CommonCommands.PASTE.id
         });
     }
-
 }
 
-function hasEditorAsFirstArg(args: unknown[]): args is [MonacoEditor, ...unknown[]] {
-    return args.length > 0 && args[0] instanceof MonacoEditor;
+function hasAsFirstArg<T>(args: unknown[], guard: (arg: unknown) => arg is T): args is [T, ...unknown[]] {
+    return args.length > 0 && guard(args[0]);
 }
 
 function extractRequestOrResponseNodes(args: unknown[]): (RequestNode | ResponseNode)[] {

package/src/browser/chat-view-language-contribution.ts

@@ -14,15 +14,15 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { ChatAgentService } from '@theia/ai-chat';
-import { AIContextVariable, AIVariableService } from '@theia/ai-core/lib/common';
+import { AIVariableService } from '@theia/ai-core/lib/common';
 import { PromptText } from '@theia/ai-core/lib/common/prompt-text';
 import { ToolInvocationRegistry } from '@theia/ai-core/lib/common/tool-invocation-registry';
 import { MaybePromise, nls } from '@theia/core';
-import { ApplicationShell, FrontendApplication, FrontendApplicationContribution } from '@theia/core/lib/browser';
+import { FrontendApplication, FrontendApplicationContribution } from '@theia/core/lib/browser';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import * as monaco from '@theia/monaco-editor-core';
 import { ProviderResult } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
-import { ChatViewWidget } from './chat-view-widget';
+import { AIChatFrontendContribution, VARIABLE_ADD_CONTEXT_COMMAND } from '@theia/ai-chat/lib/browser/ai-chat-frontend-contribution';
 
 export const CHAT_VIEW_LANGUAGE_ID = 'theia-ai-chat-view-language';
 export const SETTINGS_LANGUAGE_ID = 'theia-ai-chat-settings-language';
@@ -30,7 +30,6 @@ export const CHAT_VIEW_LANGUAGE_EXTENSION = 'aichatviewlanguage';
 
 const VARIABLE_RESOLUTION_CONTEXT = { context: 'chat-input-autocomplete' };
 const VARIABLE_ARGUMENT_PICKER_COMMAND = 'trigger-variable-argument-picker';
-const VARIABLE_ADD_CONTEXT_COMMAND = 'add-context-variable';
 
 interface CompletionSource<T> {
     triggerCharacter: string;
@@ -54,8 +53,8 @@ export class ChatViewLanguageContribution implements FrontendApplicationContribu
     @inject(ToolInvocationRegistry)
     protected readonly toolInvocationRegistry: ToolInvocationRegistry;
 
-    @inject(ApplicationShell)
-    protected readonly shell: ApplicationShell;
+    @inject(AIChatFrontendContribution)
+    protected readonly chatFrontendContribution: AIChatFrontendContribution;
 
     onStart(_app: FrontendApplication): MaybePromise<void> {
         monaco.languages.register({ id: CHAT_VIEW_LANGUAGE_ID, extensions: [CHAT_VIEW_LANGUAGE_EXTENSION] });
@@ -64,7 +63,6 @@ export class ChatViewLanguageContribution implements FrontendApplicationContribu
         this.registerCompletionProviders();
 
         monaco.editor.registerCommand(VARIABLE_ARGUMENT_PICKER_COMMAND, this.triggerVariableArgumentPicker.bind(this));
-        monaco.editor.registerCommand(VARIABLE_ADD_CONTEXT_COMMAND, (_, ...args) => args.length > 1 ? this.addContextVariable(args[0], args[1]) : undefined);
     }
 
     protected registerCompletionProviders(): void {
@@ -205,12 +203,12 @@ export class ChatViewLanguageContribution implements FrontendApplicationContribu
                 const items = await provider(model, position);
                 if (items) {
                     suggestions.push(...items.map(item => ({
-                        ...item,
                         command: {
-                            title: nls.localize('theia/ai/chat-ui/addContextVariable', 'Add context variable'),
-                            id: VARIABLE_ADD_CONTEXT_COMMAND,
+                            title: VARIABLE_ADD_CONTEXT_COMMAND.label!,
+                            id: VARIABLE_ADD_CONTEXT_COMMAND.id,
                             arguments: [variable.name, item.insertText]
-                        }
+                        },
+                        ...item,
                     })));
                 }
             }
@@ -262,22 +260,10 @@ export class ChatViewLanguageContribution implements FrontendApplicationContribu
             text: arg
         }]);
 
-        await this.addContextVariable(variableName, arg);
+        await this.chatFrontendContribution.addContextVariable(variableName, arg);
     }
 
     protected getCharacterBeforePosition(model: monaco.editor.ITextModel, position: monaco.Position): string {
         return model.getLineContent(position.lineNumber)[position.column - 1 - 1];
     }
-
-    protected async addContextVariable(variableName: string, arg: string | undefined): Promise<void> {
-        const variable = this.variableService.getVariable(variableName);
-        if (!variable || !AIContextVariable.is(variable)) {
-            return;
-        }
-
-        const widget = this.shell.getWidgetById(ChatViewWidget.ID);
-        if (widget instanceof ChatViewWidget) {
-            widget.addContext({ variable, arg });
-        }
-    }
 }

package/src/browser/chat-view-widget.tsx

@@ -22,6 +22,8 @@ import { AIChatInputWidget } from './chat-input-widget';
 import { ChatViewTreeWidget } from './chat-tree-view/chat-view-tree-widget';
 import { AIActivationService } from '@theia/ai-core/lib/browser/ai-activation-service';
 import { AIVariableResolutionRequest } from '@theia/ai-core';
+import { ProgressBarFactory } from '@theia/core/lib/browser/progress-bar-factory';
+import { FrontendVariableService } from '@theia/ai-core/lib/browser';
 
 export namespace ChatViewWidget {
     export interface State {
@@ -50,6 +52,12 @@ export class ChatViewWidget extends BaseWidget implements ExtractableWidget, Sta
     @inject(AIActivationService)
     protected readonly activationService: AIActivationService;
 
+    @inject(FrontendVariableService)
+    protected readonly variableService: FrontendVariableService;
+
+    @inject(ProgressBarFactory)
+    protected readonly progressBarFactory: ProgressBarFactory;
+
     protected chatSession: ChatSession;
 
     protected _state: ChatViewWidget.State = { locked: false };
@@ -110,10 +118,11 @@ export class ChatViewWidget extends BaseWidget implements ExtractableWidget, Sta
             this.inputWidget.setEnabled(change);
             this.update();
         });
+        this.toDispose.push(this.progressBarFactory({ container: this.node, insertMode: 'prepend', locationId: 'ai-chat' }));
     }
 
     protected initListeners(): void {
-        this.toDispose.push(
+        this.toDispose.pushAll([
             this.chatService.onSessionEvent(event => {
                 if (!isActiveSessionChangedEvent(event)) {
                     return;
@@ -130,8 +139,12 @@ export class ChatViewWidget extends BaseWidget implements ExtractableWidget, Sta
                 } else {
                     console.warn(`Session with ${event.sessionId} not found.`);
                 }
+            }),
+            // The chat view needs to handle the submission of the edit request
+            this.treeWidget.onDidSubmitEdit(request => {
+                this.onQuery(request);
             })
-        );
+        ]);
     }
 
     protected override onActivateRequest(msg: Message): void {
@@ -164,10 +177,10 @@ export class ChatViewWidget extends BaseWidget implements ExtractableWidget, Sta
         return this.onStateChangedEmitter.event;
     }
 
-    protected async onQuery(query: string): Promise<void> {
-        if (query.length === 0) { return; }
+    protected async onQuery(query: string | ChatRequest): Promise<void> {
+        const chatRequest: ChatRequest = typeof query === 'string' ? { text: query } : { ...query };
+        if (chatRequest.text.length === 0) { return; }
 
-        const chatRequest: ChatRequest = { text: query };
         const requestProgress = await this.chatService.sendRequest(this.chatSession.id, chatRequest);
         requestProgress?.responseCompleted.then(responseModel => {
             if (responseModel.isError) {