@opensumi/ide-ai-native 3.7.1-next-1739774311.0 → 3.7.1

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

@@ -3,7 +3,6 @@ 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';
@@ -44,13 +43,10 @@ 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) {
@@ -110,7 +106,11 @@ export abstract class BaseInlineDiffPreviewer<N extends IInlineDiffPreviewerNode
     return this.node;
   }
 
-  public mountWidget(contentWidget: AIInlineContentWidget): void {
+  public createNodeSnapshot(): N | undefined {
+    return this.node;
+  }
+
+  public mount(contentWidget: AIInlineContentWidget): void {
     this.inlineContentWidget = contentWidget;
   }
 
@@ -156,25 +156,20 @@ 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
   }
@@ -183,30 +178,6 @@ 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;
   }
@@ -228,37 +199,30 @@ export class SideBySideInlineDiffWidget extends BaseInlineDiffPreviewer<InlineDi
     this.addDispose(widget);
     return widget;
   }
-
-  mountWidget(contentWidget: AIInlineContentWidget): void {
-    super.mountWidget(contentWidget);
+  mount(contentWidget: AIInlineContentWidget): void {
+    super.mount(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();
@@ -276,12 +240,10 @@ 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;
 
@@ -296,15 +258,12 @@ 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();
   }
@@ -337,6 +296,30 @@ 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();
@@ -345,7 +328,6 @@ export class LiveInlineDiffPreviewer extends BaseInlineDiffPreviewer<InlineStrea
     }
     return Position.lift({ lineNumber: 1, column: 1 });
   }
-
   handleAction(action: EResultKind): void {
     switch (action) {
       case EResultKind.ACCEPT:
@@ -361,11 +343,9 @@ export class LiveInlineDiffPreviewer extends BaseInlineDiffPreviewer<InlineStrea
         break;
     }
   }
-
   onLineCount() {
     return Disposable.NULL;
   }
-
   layout(): void {
     this.inlineContentWidget?.setPositionPreference([
       ContentWidgetPositionPreference.ABOVE,
@@ -385,52 +365,17 @@ export class LiveInlineDiffPreviewer extends BaseInlineDiffPreviewer<InlineStrea
           const firstRemovedWidgetLineNumber = firstRemovedWidget.getLastPosition()?.lineNumber;
           if (firstRemovedWidgetLineNumber <= lineNumber) {
             const lineHeight = this.inlineContentWidget.getLineHeight();
-            const len = firstRemovedWidget.height + 1;
+            const len = firstRemovedWidget.height;
             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,18 +6,12 @@ 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';
@@ -33,8 +27,6 @@ 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';
 
@@ -46,68 +38,106 @@ 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 previewerStore: Map<string, IInlineDiffPreviewer>;
-  private currentPreviewer: ISettableObservable<IInlineDiffPreviewer | undefined>;
-  private modelChangeObs: IObservable<monaco.editor.ITextModel, unknown>;
+  private previewer: BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined;
+  private _previewerNodeStore = new Map<string, InlineStreamDiffHandler | null>();
 
   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(
-      autorun((reader) => {
-        const model = this.modelChangeObs.read(reader);
-        if (!model) {
-          return;
-        }
+      this.eventBus.on(EditorGroupCloseEvent, (e: EditorGroupCloseEvent) => {
+        const uriString = e.payload.resource.uri.toString();
+        const node = this.getStoredState(uriString);
 
-        /**
-         * 切换到其他 model 且 previewer 未卸载时
-         * 保留 previewer 的实例，仅卸载 previewer 的渲染层
-         */
-        const id = model.id;
-        const previewer = this.currentPreviewer.get();
-        if (previewer && previewer.modelId !== id && !previewer.disposed) {
-          previewer.hide();
+        if (node && node.previewerOptions.disposeWhenEditorClosed) {
+          this.destroyPreviewer(uriString);
         }
-
-        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;
   }
 
-  getPreviewer(): IInlineDiffPreviewer | undefined {
-    return this.currentPreviewer.get();
+  storeState(key: string) {
+    if (!this.previewer) {
+      return;
+    }
+
+    // 存储的是快照
+    const node = this.previewer.createNodeSnapshot();
+    if (node) {
+      this._previewerNodeStore.set(key, node as InlineStreamDiffHandler);
+    }
   }
 
-  private renderDiff(previewer: IInlineDiffPreviewer, data: ReplyResponse) {
-    if (!previewer) {
+  tryRestoreState(monacoEditor: monaco.ICodeEditor, key: string) {
+    const node = this.getStoredState(key);
+    if (!node) {
       return;
     }
 
-    previewer.onData(data);
+    if (node.disposed) {
+      this.destroyPreviewer(key);
+      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());
+      }),
+    );
 
-    // 仅在当前 model 中进行流式渲染
-    if (this.modelChangeObs.get()?.id === previewer.modelId) {
-      previewer.render();
+    if (model) {
+      this.featureDisposable.addDispose(
+        model.onWillDispose(() => {
+          const uriString = model.uri.toString();
+          this.destroyPreviewer(uriString);
+        }),
+      );
     }
   }
 
@@ -124,10 +154,6 @@ 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();
@@ -142,7 +168,7 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
           disposable.addDispose([
             controller.onData((data) => {
               if (ReplyResponse.is(data)) {
-                this.renderDiff(previewer, data);
+                previewer.onData(data);
               }
             }),
             controller.onError((error) => {
@@ -177,61 +203,59 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
       EInlineDiffPreviewMode.inlineLive,
     );
 
-    let previewer: IInlineDiffPreviewer;
+    this.destroyPreviewer();
 
     if (inlineDiffMode === EInlineDiffPreviewMode.sideBySide) {
-      previewer = this.injector.get(SideBySideInlineDiffWidget, [monacoEditor]);
+      this.previewer = this.injector.get(SideBySideInlineDiffWidget, [monacoEditor]);
     } else {
-      previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
+      this.previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
     }
 
-    previewer.create(selection, options);
-    previewer.show(selection.startLineNumber - 1, selection.endLineNumber - selection.startLineNumber + 2);
+    this.previewer.create(selection, options);
+    this.previewer.show(selection.startLineNumber - 1, selection.endLineNumber - selection.startLineNumber + 2);
 
-    previewer.addDispose(previewer.onLineCount((lineCount) => this._onMaxLineCount.fire(lineCount)));
+    this.listenPreviewer(this.previewer);
 
-    previewer.addDispose(
-      Disposable.create(() => {
-        this.previewerStore.delete(previewer.modelId);
-      }),
-    );
-
-    return previewer;
+    return this.previewer;
   }
 
-  handleAction(action: EResultKind): void {
-    const previewer = this.getPreviewer();
+  private listenPreviewer(previewer: BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined) {
     if (!previewer) {
       return;
     }
 
-    previewer.handleAction(action);
+    previewer.addDispose(previewer.onLineCount((lineCount) => this._onMaxLineCount.fire(lineCount)));
   }
 
-  getModifyContent() {
-    const previewer = this.getPreviewer();
-    if (!previewer) {
-      return;
-    }
+  getPreviewer(): BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined {
+    return this.previewer;
+  }
 
-    return previewer.getValue();
+  getStoredState(uri: string) {
+    return this._previewerNodeStore.get(uri);
   }
 
-  getOriginContent() {
-    const previewer = this.getPreviewer();
-    if (!previewer) {
-      return;
-    }
+  handleAction(action: EResultKind): void {
+    this.previewer?.handleAction(action);
+  }
+
+  getModifyContent() {
+    return this.previewer?.getValue();
+  }
 
-    return previewer.getOriginValue();
+  getOriginContent() {
+    return this.previewer?.getOriginValue();
   }
 
-  revealFirstDiff() {
-    const previewer = this.getPreviewer();
-    if (!previewer) {
-      return;
+  destroyPreviewer(uriString?: string) {
+    this.previewer?.dispose();
+    this.previewer = undefined;
+    if (uriString) {
+      this._previewerNodeStore.delete(uriString);
     }
+  }
 
-    previewer.revealFirstDiff();
+  revealFirstDiff() {
+    this.previewer?.revealFirstDiff();
   }
 }

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

@@ -1,12 +1,13 @@
 import throttle from 'lodash/throttle';
 
 import { Disposable, IDisposable } from '@opensumi/ide-core-common';
-import * as monaco from '@opensumi/ide-monaco';
 import { ICodeEditor } from '@opensumi/ide-monaco';
+import * as monaco 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';
@@ -22,6 +23,10 @@ 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);
   }
@@ -54,6 +59,7 @@ 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,9 +1,8 @@
 import React, { ReactNode, useCallback, useEffect, useMemo, useState } from 'react';
 
-import { Injectable } from '@opensumi/di';
-import { AINativeConfigService, useInjectable } from '@opensumi/ide-core-browser';
+import { Autowired, Injectable } from '@opensumi/di';
 import { AIAction, InteractiveInput } from '@opensumi/ide-core-browser/lib/components/ai-native/index';
-import { AIInlineInputChatContentWidgetId, Disposable, Emitter, Event, localize } from '@opensumi/ide-core-common';
+import { AIInlineInputChatContentWidgetId, Disposable, 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';
@@ -11,24 +10,19 @@ 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 type { ICodeEditor as IMonacoCodeEditor } from '@opensumi/ide-monaco';
+import { InlineInputChatService } from './inline-input.service';
 
 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 { defaultValue, onClose, onInteractiveInputSend, onLayoutChange, onChatStatus, onResultClick, onValueChange } =
-    props;
+  const { onClose, onInteractiveInputSend, onLayoutChange, onChatStatus, onResultClick } = props;
   const [status, setStatus] = useState<EInlineChatStatus>(EInlineChatStatus.READY);
-  const aiNativeConfigService = useInjectable<AINativeConfigService>(AINativeConfigService);
 
   useEffect(() => {
     const dis = new Disposable();
@@ -70,12 +64,10 @@ 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={aiNativeConfigService.inlineChat.inputWidth}
+          width={320}
           disabled={isLoading}
           onSend={handleInteractiveInputSend}
         />
@@ -85,26 +77,16 @@ const InlineInputWidgetRender = (props: IInlineInputWidgetRenderProps) => {
 };
 
 @Injectable({ multiple: true })
-export class InlineInputWidget extends AIInlineContentWidget {
+export class InlineInputChatWidget extends AIInlineContentWidget {
+  @Autowired(InlineInputChatService)
+  private inlineInputChatService: InlineInputChatService;
+
   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.inlineInputService.hide();
+    this.inlineInputChatService.hide();
   }
 
   override id(): string {
@@ -115,18 +97,14 @@ export class InlineInputWidget extends AIInlineContentWidget {
     return (
       <div className={styles.input_wrapper}>
         <InlineInputWidgetRender
-          defaultValue={this.defaultValue}
-          onClose={() => this._onClose.fire()}
+          onClose={() => this.dispose()}
           onChatStatus={this.onStatusChange.bind(this)}
           onLayoutChange={() => {
             this.editor.layoutContentWidget(this);
           }}
-          onValueChange={(value) => {
-            this._onValueChange.fire(value);
-          }}
           onInteractiveInputSend={(value) => {
             this.launchChatStatus(EInlineChatStatus.THINKING);
-            this._onSend.fire(value);
+            this._onInteractiveInputValue.fire(value);
           }}
           onResultClick={(k: EResultKind) => {
             this._onResultClick.fire(k);