@opensumi/ide-ai-native 3.7.1 → 3.7.2-next-1739859371.0

package/src/browser/widget/inline-diff/inline-diff-previewer.ts

@@ -3,6 +3,7 @@ import { Disposable, ErrorResponse, IDisposable, ReplyResponse } from '@opensumi
 import { EOL, ICodeEditor, IPosition, ITextModel, Position, Selection } from '@opensumi/ide-monaco';
 import { ContentWidgetPositionPreference } from '@opensumi/ide-monaco/lib/browser/monaco-exports/editor';
 import { empty, getLeadingWhitespace } from '@opensumi/ide-utils/lib/strings';
+import { LineRange } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/lineRange';
 import { DefaultEndOfLine } from '@opensumi/monaco-editor-core/esm/vs/editor/common/model';
 import { createTextBuffer } from '@opensumi/monaco-editor-core/esm/vs/editor/common/model/textModel';
 import { ModelService } from '@opensumi/monaco-editor-core/esm/vs/editor/common/services/modelService';
@@ -43,10 +44,13 @@ export abstract class BaseInlineDiffPreviewer<N extends IInlineDiffPreviewerNode
   protected inlineContentWidget: AIInlineContentWidget | null = null;
   protected selection: Selection;
   protected model: ITextModel;
+  public modelId: string;
 
   constructor(protected readonly monacoEditor: ICodeEditor) {
     super();
     this.model = this.monacoEditor.getModel()!;
+    this.modelId = this.model.id;
+
     this.addDispose(
       Disposable.create(() => {
         if (this.inlineContentWidget) {
@@ -106,11 +110,7 @@ export abstract class BaseInlineDiffPreviewer<N extends IInlineDiffPreviewerNode
     return this.node;
   }
 
-  public createNodeSnapshot(): N | undefined {
-    return this.node;
-  }
-
-  public mount(contentWidget: AIInlineContentWidget): void {
+  public mountWidget(contentWidget: AIInlineContentWidget): void {
     this.inlineContentWidget = contentWidget;
   }
 
@@ -156,20 +156,25 @@ export abstract class BaseInlineDiffPreviewer<N extends IInlineDiffPreviewerNode
   setValue(content: string): void {
     // do nothing
   }
+
   getValue(): string {
     // do nothing
     return '';
   }
+
   getOriginValue(): string {
     // do nothing
     return '';
   }
+
   onError(error: ErrorResponse): void {
     // do nothing
   }
+
   onAbort(): void {
     // do nothing
   }
+
   onEnd(): void {
     // do nothing
   }
@@ -178,6 +183,30 @@ export abstract class BaseInlineDiffPreviewer<N extends IInlineDiffPreviewerNode
     // do nothing
   }
 
+  /**
+   * 会新建一个渲染层的实例
+   * 或重新赋值渲染层的数据
+   * 适用于首次渲染
+   */
+  render(): void {
+    // do nothing
+  }
+
+  /**
+   * 仅隐藏渲染层，而不销毁实例
+   */
+  hide(): void {
+    // do nothing
+  }
+
+  /**
+   * 恢复渲染层
+   * 适用于非首次渲染
+   */
+  resume(): void {
+    // do nothing
+  }
+
   isModel(uri: string): boolean {
     return this.model.uri.toString() === uri;
   }
@@ -199,30 +228,37 @@ export class SideBySideInlineDiffWidget extends BaseInlineDiffPreviewer<InlineDi
     this.addDispose(widget);
     return widget;
   }
-  mount(contentWidget: AIInlineContentWidget): void {
-    super.mount(contentWidget);
+
+  mountWidget(contentWidget: AIInlineContentWidget): void {
+    super.mountWidget(contentWidget);
     contentWidget.addDispose(this);
   }
+
   getPosition(): IPosition {
     return Position.lift({ lineNumber: this.selection.endLineNumber + 1, column: 1 });
   }
+
   layout(): void {
     this.inlineContentWidget?.setPositionPreference([ContentWidgetPositionPreference.BELOW]);
     super.layout();
   }
+
   onReady(exec: () => void): IDisposable {
     if (this.node) {
       return this.node!.onReady(exec.bind(this));
     }
     return Disposable.NULL;
   }
+
   show(line: number, heightInLines: number): void {
     this.node?.showByLine(line, heightInLines);
   }
+
   setValue(content: string): void {
     const modifiedModel = this.node?.getModifiedModel();
     modifiedModel?.setValue(this.formatIndentation(content));
   }
+
   getValue(): string {
     const model = this.node?.getModifiedModel();
     return model!.getValue();
@@ -240,10 +276,12 @@ export class SideBySideInlineDiffWidget extends BaseInlineDiffPreviewer<InlineDi
       this.model.pushStackElement();
     }
   }
+
   onLineCount(event: (count: number) => void): Disposable {
     this.node?.onMaxLineCount(event.bind(this));
     return this;
   }
+
   onData(data: ReplyResponse): void {
     const { message } = data;
 
@@ -258,12 +296,15 @@ export class SideBySideInlineDiffWidget extends BaseInlineDiffPreviewer<InlineDi
     disposable.dispose();
     this.node?.layout();
   }
+
   onError(error: ErrorResponse): void {
     this.node?.layout();
   }
+
   onAbort(): void {
     this.node?.layout();
   }
+
   onEnd(): void {
     this.node?.layout();
   }
@@ -296,30 +337,6 @@ export class LiveInlineDiffPreviewer extends BaseInlineDiffPreviewer<InlineStrea
     this.listenNode(node);
     return node;
   }
-  attachNode(node: InlineStreamDiffHandler): void {
-    this.node?.dispose();
-    this.node = node;
-
-    if (node) {
-      const snapshot = node.currentSnapshotStore;
-      if (snapshot) {
-        this.node.restoreDecorationSnapshot(snapshot.decorationSnapshotData);
-        this.listenNode(node);
-      }
-    }
-  }
-  public createNodeSnapshot(): InlineStreamDiffHandler | undefined {
-    if (!this.node) {
-      return this.createNode();
-    }
-
-    // 拿前一个 node 的快照信息
-    const snapshot = this.node.createSnapshot();
-    // 创建新的实例
-    const node = this.injector.get(InlineStreamDiffHandler, [this.monacoEditor]);
-    node.restoreSnapshot(snapshot);
-    return node;
-  }
 
   getPosition(): IPosition {
     const zone = this.node?.getZone();
@@ -328,6 +345,7 @@ export class LiveInlineDiffPreviewer extends BaseInlineDiffPreviewer<InlineStrea
     }
     return Position.lift({ lineNumber: 1, column: 1 });
   }
+
   handleAction(action: EResultKind): void {
     switch (action) {
       case EResultKind.ACCEPT:
@@ -343,9 +361,11 @@ export class LiveInlineDiffPreviewer extends BaseInlineDiffPreviewer<InlineStrea
         break;
     }
   }
+
   onLineCount() {
     return Disposable.NULL;
   }
+
   layout(): void {
     this.inlineContentWidget?.setPositionPreference([
       ContentWidgetPositionPreference.ABOVE,
@@ -365,17 +385,52 @@ export class LiveInlineDiffPreviewer extends BaseInlineDiffPreviewer<InlineStrea
           const firstRemovedWidgetLineNumber = firstRemovedWidget.getLastPosition()?.lineNumber;
           if (firstRemovedWidgetLineNumber <= lineNumber) {
             const lineHeight = this.inlineContentWidget.getLineHeight();
-            const len = firstRemovedWidget.height;
+            const len = firstRemovedWidget.height + 1;
             this.inlineContentWidget.setOffsetTop(-lineHeight * len - 4);
+          } else {
+            this.inlineContentWidget.setOffsetTop(0);
           }
         }
+      } else {
+        this.inlineContentWidget.setOffsetTop(0);
       }
     }
   }
+
+  render(): void {
+    this.inlineContentWidget?.show();
+    this.node?.rateRenderEditController();
+  }
+
+  hide(): void {
+    this.inlineContentWidget?.hide();
+    this.node?.hide();
+  }
+
+  resume(): void {
+    this.inlineContentWidget?.show();
+    this.node?.resume();
+  }
+
   onData(data: ReplyResponse): void {
     const { message } = data;
     this.node?.addLinesToDiff(this.formatIndentation(message));
   }
+
+  onAbort(): void {
+    const diffModel = this.node?.recompute(EComputerMode.default);
+    if (diffModel) {
+      /**
+       * abort 的时候，需要保留当前已经输出的内容
+       * 同时需要去掉流式过程中的 pending 区域和 activeLine
+       */
+      diffModel.activeLine = 0;
+      diffModel.pendingRange = new LineRange(0, 0);
+
+      this.node?.finallyRender(diffModel);
+    }
+  }
+
   onEnd(): void {
     const diffModel = this.node?.recompute(EComputerMode.legacy);
     if (diffModel) {

package/src/browser/widget/inline-diff/inline-diff.controller.ts

@@ -6,12 +6,18 @@ import {
   Emitter,
   Event,
   IDisposable,
-  IEventBus,
   ReplyResponse,
 } from '@opensumi/ide-core-common';
-import { EditorGroupCloseEvent } from '@opensumi/ide-editor/lib/browser';
 import * as monaco from '@opensumi/ide-monaco';
 import { ICodeEditor } from '@opensumi/ide-monaco';
+import {
+  IObservable,
+  ISettableObservable,
+  autorun,
+  observableFromEvent,
+  observableValue,
+  transaction,
+} from '@opensumi/ide-monaco/lib/common/observable';
 
 import { BaseAIMonacoEditorController } from '../../contrib/base';
 import { EInlineDiffPreviewMode } from '../../preferences/schema';
@@ -27,6 +33,8 @@ import {
 } from './inline-diff-previewer';
 import { InlineDiffWidget } from './inline-diff-widget';
 
+type IInlineDiffPreviewer = BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler>;
+
 export class InlineDiffController extends BaseAIMonacoEditorController {
   public static readonly ID = 'editor.contrib.ai.inline.diff';
 
@@ -38,106 +46,68 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
     return this.injector.get(PreferenceService);
   }
 
-  private get eventBus(): IEventBus {
-    return this.injector.get(IEventBus);
-  }
-
   private readonly _onMaxLineCount = new Emitter<number>();
   public readonly onMaxLineCount: Event<number> = this._onMaxLineCount.event;
 
-  private previewer: BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined;
-  private _previewerNodeStore = new Map<string, InlineStreamDiffHandler | null>();
+  private previewerStore: Map<string, IInlineDiffPreviewer>;
+  private currentPreviewer: ISettableObservable<IInlineDiffPreviewer | undefined>;
+  private modelChangeObs: IObservable<monaco.editor.ITextModel, unknown>;
 
   mount(): IDisposable {
+    this.previewerStore = new Map();
+    this.currentPreviewer = observableValue(this, undefined);
+    this.modelChangeObs = observableFromEvent<monaco.editor.ITextModel>(
+      this,
+      this.monacoEditor.onDidChangeModel,
+      () => this.monacoEditor.getModel()!,
+    );
+
     this.featureDisposable.addDispose(
-      this.eventBus.on(EditorGroupCloseEvent, (e: EditorGroupCloseEvent) => {
-        const uriString = e.payload.resource.uri.toString();
-        const node = this.getStoredState(uriString);
+      autorun((reader) => {
+        const model = this.modelChangeObs.read(reader);
+        if (!model) {
+          return;
+        }
 
-        if (node && node.previewerOptions.disposeWhenEditorClosed) {
-          this.destroyPreviewer(uriString);
+        /**
+         * 切换到其他 model 且 previewer 未卸载时
+         * 保留 previewer 的实例，仅卸载 previewer 的渲染层
+         */
+        const id = model.id;
+        const previewer = this.currentPreviewer.get();
+        if (previewer && previewer.modelId !== id && !previewer.disposed) {
+          previewer.hide();
         }
+
+        const storedPreview = this.previewerStore.get(model.id);
+        transaction((tx) => {
+          if (storedPreview && storedPreview.modelId === id) {
+            this.currentPreviewer.set(storedPreview, tx);
+            storedPreview.resume();
+          } else {
+            this.currentPreviewer.set(undefined, tx);
+          }
+        });
       }),
     );
 
-    this.registerInlineDiffFeature(this.monacoEditor);
-
     return this.featureDisposable;
   }
 
-  storeState(key: string) {
-    if (!this.previewer) {
-      return;
-    }
-
-    // 存储的是快照
-    const node = this.previewer.createNodeSnapshot();
-    if (node) {
-      this._previewerNodeStore.set(key, node as InlineStreamDiffHandler);
-    }
+  getPreviewer(): IInlineDiffPreviewer | undefined {
+    return this.currentPreviewer.get();
   }
 
-  tryRestoreState(monacoEditor: monaco.ICodeEditor, key: string) {
-    const node = this.getStoredState(key);
-    if (!node) {
-      return;
-    }
-
-    if (node.disposed) {
-      this.destroyPreviewer(key);
+  private renderDiff(previewer: IInlineDiffPreviewer, data: ReplyResponse) {
+    if (!previewer) {
       return;
     }
 
-    return this.restoreState(monacoEditor, node);
-  }
-
-  restoreState(monacoEditor: monaco.ICodeEditor, node: InlineStreamDiffHandler) {
-    const uri = monacoEditor.getModel()?.uri;
-
-    if (uri) {
-      this.previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
-      this.previewer.attachNode(node);
-      this.listenPreviewer(this.previewer);
-
-      const dispose = this.previewer.onDispose(() => {
-        this.destroyPreviewer();
-        dispose.dispose();
-      });
-    }
-  }
-
-  registerInlineDiffFeature(monacoEditor: monaco.ICodeEditor): void {
-    const model = monacoEditor.getModel();
-
-    this.featureDisposable.addDispose(
-      monacoEditor.onWillChangeModel((e) => {
-        if (!e.oldModelUrl) {
-          return;
-        }
-
-        const urlString = e.oldModelUrl.toString();
-        this.storeState(urlString);
-
-        this.destroyPreviewer();
-      }),
-    );
-
-    this.featureDisposable.addDispose(
-      monacoEditor.onDidChangeModel((e) => {
-        if (!e.newModelUrl) {
-          return;
-        }
-        this.tryRestoreState(monacoEditor, e.newModelUrl.toString());
-      }),
-    );
+    previewer.onData(data);
 
-    if (model) {
-      this.featureDisposable.addDispose(
-        model.onWillDispose(() => {
-          const uriString = model.uri.toString();
-          this.destroyPreviewer(uriString);
-        }),
-      );
+    // 仅在当前 model 中进行流式渲染
+    if (this.modelChangeObs.get()?.id === previewer.modelId) {
+      previewer.render();
     }
   }
 
@@ -154,6 +124,10 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
     const disposable = new Disposable();
 
     const previewer = this.createDiffPreviewer(monacoEditor, crossSelection, options.previewerOptions);
+    transaction((tx) => {
+      this.currentPreviewer.set(previewer, tx);
+      this.previewerStore.set(previewer.modelId, previewer);
+    });
 
     const onFinish = () => {
       previewer.layout();
@@ -168,7 +142,7 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
           disposable.addDispose([
             controller.onData((data) => {
               if (ReplyResponse.is(data)) {
-                previewer.onData(data);
+                this.renderDiff(previewer, data);
               }
             }),
             controller.onError((error) => {
@@ -203,59 +177,61 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
       EInlineDiffPreviewMode.inlineLive,
     );
 
-    this.destroyPreviewer();
+    let previewer: IInlineDiffPreviewer;
 
     if (inlineDiffMode === EInlineDiffPreviewMode.sideBySide) {
-      this.previewer = this.injector.get(SideBySideInlineDiffWidget, [monacoEditor]);
+      previewer = this.injector.get(SideBySideInlineDiffWidget, [monacoEditor]);
     } else {
-      this.previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
+      previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
     }
 
-    this.previewer.create(selection, options);
-    this.previewer.show(selection.startLineNumber - 1, selection.endLineNumber - selection.startLineNumber + 2);
+    previewer.create(selection, options);
+    previewer.show(selection.startLineNumber - 1, selection.endLineNumber - selection.startLineNumber + 2);
 
-    this.listenPreviewer(this.previewer);
+    previewer.addDispose(previewer.onLineCount((lineCount) => this._onMaxLineCount.fire(lineCount)));
 
-    return this.previewer;
+    previewer.addDispose(
+      Disposable.create(() => {
+        this.previewerStore.delete(previewer.modelId);
+      }),
+    );
+
+    return previewer;
   }
 
-  private listenPreviewer(previewer: BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined) {
+  handleAction(action: EResultKind): void {
+    const previewer = this.getPreviewer();
     if (!previewer) {
       return;
     }
 
-    previewer.addDispose(previewer.onLineCount((lineCount) => this._onMaxLineCount.fire(lineCount)));
-  }
-
-  getPreviewer(): BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined {
-    return this.previewer;
-  }
-
-  getStoredState(uri: string) {
-    return this._previewerNodeStore.get(uri);
-  }
-
-  handleAction(action: EResultKind): void {
-    this.previewer?.handleAction(action);
+    previewer.handleAction(action);
   }
 
   getModifyContent() {
-    return this.previewer?.getValue();
-  }
+    const previewer = this.getPreviewer();
+    if (!previewer) {
+      return;
+    }
 
-  getOriginContent() {
-    return this.previewer?.getOriginValue();
+    return previewer.getValue();
   }
 
-  destroyPreviewer(uriString?: string) {
-    this.previewer?.dispose();
-    this.previewer = undefined;
-    if (uriString) {
-      this._previewerNodeStore.delete(uriString);
+  getOriginContent() {
+    const previewer = this.getPreviewer();
+    if (!previewer) {
+      return;
     }
+
+    return previewer.getOriginValue();
   }
 
   revealFirstDiff() {
-    this.previewer?.revealFirstDiff();
+    const previewer = this.getPreviewer();
+    if (!previewer) {
+      return;
+    }
+
+    previewer.revealFirstDiff();
   }
 }

package/src/browser/widget/inline-hint/inline-hint.controller.ts

@@ -1,13 +1,12 @@
 import throttle from 'lodash/throttle';
 
 import { Disposable, IDisposable } from '@opensumi/ide-core-common';
-import { ICodeEditor } from '@opensumi/ide-monaco';
 import * as monaco from '@opensumi/ide-monaco';
+import { ICodeEditor } from '@opensumi/ide-monaco';
 
 import { AINativeContextKey } from '../../ai-core.contextkeys';
 import { BaseAIMonacoEditorController } from '../../contrib/base';
 import { AICompletionsService } from '../../contrib/inline-completions/service/ai-completions.service';
-import { InlineInputChatService } from '../inline-input/inline-input.service';
 import { InlineInputPreviewDecorationID } from '../internal.type';
 
 import { InlineHintLineDecoration } from './inline-hint-line-widget';
@@ -23,10 +22,6 @@ export class InlineHintController extends BaseAIMonacoEditorController {
     return this.injector.get(AICompletionsService);
   }
 
-  private get inlineInputChatService(): InlineInputChatService {
-    return this.injector.get(InlineInputChatService);
-  }
-
   mount(): IDisposable {
     return this.registerHintLineFeature(this.monacoEditor);
   }
@@ -59,7 +54,6 @@ export class InlineHintController extends BaseAIMonacoEditorController {
         if (!lineContent?.trim()) {
           inlineHintLineDecoration.show(position);
         }
-        this.inlineInputChatService.setCurrentVisiblePosition(position);
 
         aiNativeContextKey.inlineHintWidgetIsVisible.set(true);
 

package/src/browser/widget/inline-input/inline-input-widget.tsx

@@ -1,8 +1,9 @@
 import React, { ReactNode, useCallback, useEffect, useMemo, useState } from 'react';
 
-import { Autowired, Injectable } from '@opensumi/di';
+import { Injectable } from '@opensumi/di';
+import { AINativeConfigService, useInjectable } from '@opensumi/ide-core-browser';
 import { AIAction, InteractiveInput } from '@opensumi/ide-core-browser/lib/components/ai-native/index';
-import { AIInlineInputChatContentWidgetId, Disposable, Event, localize } from '@opensumi/ide-core-common';
+import { AIInlineInputChatContentWidgetId, Disposable, Emitter, Event, localize } from '@opensumi/ide-core-common';
 import { ContentWidgetPositionPreference } from '@opensumi/ide-monaco/lib/browser/monaco-exports/editor';
 
 import { InlineResultAction } from '../inline-actions/result-items/index';
@@ -10,19 +11,24 @@ import { EInlineChatStatus, EResultKind } from '../inline-chat/inline-chat.servi
 import { AIInlineContentWidget } from '../inline-chat/inline-content-widget';
 
 import styles from './inline-input.module.less';
-import { InlineInputChatService } from './inline-input.service';
+
+import type { ICodeEditor as IMonacoCodeEditor } from '@opensumi/ide-monaco';
 
 interface IInlineInputWidgetRenderProps {
+  defaultValue?: string;
   onLayoutChange: (height: number) => void;
   onClose?: () => void;
   onInteractiveInputSend?: (value: string) => void;
   onChatStatus: Event<EInlineChatStatus>;
   onResultClick: (k: EResultKind) => void;
+  onValueChange?: (value: string) => void;
 }
 
 const InlineInputWidgetRender = (props: IInlineInputWidgetRenderProps) => {
-  const { onClose, onInteractiveInputSend, onLayoutChange, onChatStatus, onResultClick } = props;
+  const { defaultValue, onClose, onInteractiveInputSend, onLayoutChange, onChatStatus, onResultClick, onValueChange } =
+    props;
   const [status, setStatus] = useState<EInlineChatStatus>(EInlineChatStatus.READY);
+  const aiNativeConfigService = useInjectable<AINativeConfigService>(AINativeConfigService);
 
   useEffect(() => {
     const dis = new Disposable();
@@ -64,10 +70,12 @@ const InlineInputWidgetRender = (props: IInlineInputWidgetRenderProps) => {
       customOperationRender={
         <InteractiveInput
           autoFocus
+          defaultValue={defaultValue}
+          onValueChange={onValueChange}
           onHeightChange={(height) => onLayoutChange(height)}
           size='small'
           placeholder={localize('aiNative.inline.chat.input.placeholder.default')}
-          width={320}
+          width={aiNativeConfigService.inlineChat.inputWidth}
           disabled={isLoading}
           onSend={handleInteractiveInputSend}
         />
@@ -77,16 +85,26 @@ const InlineInputWidgetRender = (props: IInlineInputWidgetRenderProps) => {
 };
 
 @Injectable({ multiple: true })
-export class InlineInputChatWidget extends AIInlineContentWidget {
-  @Autowired(InlineInputChatService)
-  private inlineInputChatService: InlineInputChatService;
-
+export class InlineInputWidget extends AIInlineContentWidget {
   allowEditorOverflow = true;
   positionPreference = [ContentWidgetPositionPreference.ABOVE];
 
+  protected readonly _onSend = new Emitter<string>();
+  public readonly onSend = this._onSend.event;
+
+  protected readonly _onClose = new Emitter<void>();
+  public readonly onClose = this._onClose.event;
+
+  protected readonly _onValueChange = new Emitter<string>();
+  public readonly onValueChange = this._onValueChange.event;
+
+  constructor(protected readonly editor: IMonacoCodeEditor, protected readonly defaultValue?: string) {
+    super(editor);
+  }
+
   override dispose(): void {
     super.dispose();
-    this.inlineInputChatService.hide();
+    this.inlineInputService.hide();
   }
 
   override id(): string {
@@ -97,14 +115,18 @@ export class InlineInputChatWidget extends AIInlineContentWidget {
     return (
       <div className={styles.input_wrapper}>
         <InlineInputWidgetRender
-          onClose={() => this.dispose()}
+          defaultValue={this.defaultValue}
+          onClose={() => this._onClose.fire()}
           onChatStatus={this.onStatusChange.bind(this)}
           onLayoutChange={() => {
             this.editor.layoutContentWidget(this);
           }}
+          onValueChange={(value) => {
+            this._onValueChange.fire(value);
+          }}
           onInteractiveInputSend={(value) => {
             this.launchChatStatus(EInlineChatStatus.THINKING);
-            this._onInteractiveInputValue.fire(value);
+            this._onSend.fire(value);
           }}
           onResultClick={(k: EResultKind) => {
             this._onResultClick.fire(k);