@opensumi/ide-ai-native 3.7.1-next-1739430207.0 → 3.7.1-next-1739439717.0

package/src/browser/model/enhanceDecorationsCollection.ts

@@ -1,15 +1,20 @@
-import { Disposable, Emitter, Event, isDefined, isUndefined, uuid } from '@opensumi/ide-core-common';
+import { Disposable, Emitter, Event, isDefined, isUndefined } from '@opensumi/ide-core-common';
 import {
   ICodeEditor,
   IContentSizeChangedEvent,
   IModelDecorationOptions,
+  IModelDecorationsChangeAccessor,
   IModelDeltaDecoration,
   IPosition,
   IRange,
   ITextModel,
+  Range,
 } from '@opensumi/ide-monaco';
+import { space } from '@opensumi/ide-utils/lib/strings';
 import { UndoRedoGroup } from '@opensumi/monaco-editor-core/esm/vs/platform/undoRedo/common/undoRedo';
 
+import styles from './styles.module.less';
+
 export interface IDecorationSerializableState {
   startPosition: IPosition;
   endPosition: IPosition;
@@ -23,10 +28,8 @@ interface IDeltaData extends IModelDeltaDecoration {
 
 export interface IEnhanceModelDeltaDecoration extends IDeltaData {
   id: string;
-  decorationId: string;
   isHidden: boolean;
   readonly editorDecoration: IModelDeltaDecoration;
-  show(): void;
   hide(): void;
   resume(): void;
   getRange(): IRange;
@@ -44,13 +47,12 @@ export interface IDeltaDecorationsOptions {
   group?: UndoRedoGroup;
 }
 
-export class DeltaDecorations implements IEnhanceModelDeltaDecoration {
+class DeltaDecorations implements IEnhanceModelDeltaDecoration {
   length: number;
   range: IRange;
   options: IModelDecorationOptions;
 
   private resumeRange: IRange;
-  private _decorationId: string;
   private _group: UndoRedoGroup;
 
   private _hidden = false;
@@ -70,10 +72,6 @@ export class DeltaDecorations implements IEnhanceModelDeltaDecoration {
     return this.metadata.id;
   }
 
-  get decorationId(): string {
-    return this._decorationId;
-  }
-
   get editorDecoration(): IModelDeltaDecoration {
     return this.metadata.editorDecoration;
   }
@@ -110,6 +108,25 @@ export class DeltaDecorations implements IEnhanceModelDeltaDecoration {
     this._group = group;
   }
 
+  private changeVisibility(newClassName: string, newRange: Range): void {
+    if (!this.options.className) {
+      return;
+    }
+
+    const classList = this.options.className
+      .split(space)
+      .filter((s) => s !== styles.hidden && s !== styles.visible)
+      .filter(Boolean);
+    classList.push(newClassName);
+
+    this.options.className = classList.join(space);
+
+    this.codeEditor.changeDecorations((accessor) => {
+      accessor.changeDecorationOptions(this.id, this.options);
+      accessor.changeDecoration(this.id, newRange);
+    });
+  }
+
   setRange(newRange: IRange): void {
     this.range = newRange;
   }
@@ -119,45 +136,28 @@ export class DeltaDecorations implements IEnhanceModelDeltaDecoration {
   }
 
   dispose(): void {
-    this.hide();
     this.deltaData.dispose?.();
   }
 
-  show(): void {
-    this.codeEditor.changeDecorations((accessor) => {
-      this._decorationId = accessor.addDecoration(this.range, this.options);
-    });
-  }
-
   hide(): void {
     this.resumeRange = this.range;
     this._hidden = true;
-    if (this._decorationId) {
-      this.codeEditor.changeDecorations((accessor) => {
-        accessor.removeDecoration(this._decorationId);
-      });
-    }
+    const startPosition = { lineNumber: this.range.startLineNumber, column: 1 };
+    const newRange = Range.fromPositions(startPosition);
+    this.changeVisibility(styles.hidden, newRange);
   }
 
   resume(): void {
-    if (!this._hidden) {
-      return;
-    }
-
     this._hidden = false;
-    this.codeEditor.changeDecorations((accessor) => {
-      this._decorationId = accessor.addDecoration(this.resumeRange, this.options);
-    });
+    this.changeVisibility(styles.visible, Range.lift(this.resumeRange));
   }
 }
 
-export class EnhanceDecorationsCollection<
-  T extends IEnhanceModelDeltaDecoration = IEnhanceModelDeltaDecoration,
-> extends Disposable {
-  private deltaDecorations: T[] = [];
+export class EnhanceDecorationsCollection extends Disposable {
+  private deltaDecorations: IEnhanceModelDeltaDecoration[] = [];
 
-  protected readonly _onDidDecorationsChange = this.registerDispose(new Emitter<T[]>());
-  public readonly onDidDecorationsChange: Event<T[]> = this._onDidDecorationsChange.event;
+  protected readonly _onDidDecorationsChange = this.registerDispose(new Emitter<IEnhanceModelDeltaDecoration[]>());
+  public readonly onDidDecorationsChange: Event<IEnhanceModelDeltaDecoration[]> = this._onDidDecorationsChange.event;
 
   private get model(): ITextModel {
     return this.codeEditor.getModel()!;
@@ -182,11 +182,11 @@ export class EnhanceDecorationsCollection<
   private flush(): void {
     this.deltaDecorations = this.deltaDecorations.map((d) => {
       const {
-        decorationId,
+        id,
         editorDecoration: { range },
       } = d;
 
-      const newRange = this.model.getDecorationRange(decorationId);
+      const newRange = this.model.getDecorationRange(id);
       d.setRange(newRange ?? range);
 
       return d;
@@ -196,51 +196,66 @@ export class EnhanceDecorationsCollection<
   }
 
   private delete(id: string): void {
-    this.deltaDecorations = this.deltaDecorations.filter((d) => d.id !== id);
+    this.codeEditor.changeDecorations((accessor) => {
+      accessor.removeDecoration(id);
+
+      this.deltaDecorations = this.deltaDecorations.filter((d) => d.id !== id);
+    });
   }
 
   protected createDecorations(metaData: IDeltaDecorationsOptions) {
-    return new DeltaDecorations(metaData) as unknown as T;
+    return new DeltaDecorations(metaData);
   }
 
-  set(decorations: (IModelDeltaDecoration & Partial<Pick<T, 'length' | 'isHidden' | 'group'>>)[]): void {
+  set(
+    decorations: (IModelDeltaDecoration &
+      Partial<Pick<IEnhanceModelDeltaDecoration, 'length' | 'isHidden' | 'group'>>)[],
+  ): void {
     this.clear();
 
-    this.deltaDecorations = decorations.map((decoration) => {
-      const id = uuid(6);
-
-      const dec = this.createDecorations({
-        id,
-        editorDecoration: decoration,
-        codeEditor: this.codeEditor,
-        isHidden: decoration.isHidden,
-        group: decoration.group,
-        deltaData: {
-          dispose: () => this.delete(id),
-          length: decoration.length,
-        },
-      });
-
-      dec.show();
-
-      return dec;
+    this.codeEditor.changeDecorations((accessor: IModelDecorationsChangeAccessor) => {
+      const newDecorations: IEnhanceModelDeltaDecoration[] = [];
+
+      for (const decoration of decorations) {
+        const id = accessor.addDecoration(decoration.range, decoration.options);
+        newDecorations.push(
+          this.createDecorations({
+            id,
+            editorDecoration: decoration,
+            codeEditor: this.codeEditor,
+            isHidden: decoration.isHidden,
+            group: decoration.group,
+            deltaData: {
+              dispose: () => this.delete(id),
+              length: decoration.length,
+            },
+          }),
+        );
+      }
+
+      this.deltaDecorations = newDecorations;
     });
   }
 
-  getDecorations(): T[] {
+  getDecorations(): IEnhanceModelDeltaDecoration[] {
     return this.deltaDecorations;
   }
 
-  getDecorationByGroup(group: UndoRedoGroup): T | undefined {
+  getDecorationByGroup(group: UndoRedoGroup): IEnhanceModelDeltaDecoration | undefined {
     return this.deltaDecorations.find((d) => d.group === group);
   }
 
-  getDecorationByLineNumber(lineNumber: number): T | undefined {
+  getDecorationByLineNumber(lineNumber: number): IEnhanceModelDeltaDecoration | undefined {
     return this.deltaDecorations.find((d) => d.getRange().startLineNumber === lineNumber);
   }
 
   clear(): void {
-    this.deltaDecorations.map((d) => d.dispose());
-    this.deltaDecorations = [];
+    this.codeEditor.changeDecorations((accessor) => {
+      for (const decoration of this.deltaDecorations) {
+        accessor.removeDecoration(decoration.id);
+      }
+
+      this.deltaDecorations = [];
+    });
   }
 }

package/src/browser/model/styles.module.less

@@ -0,0 +1,7 @@
+.hidden {
+  visibility: hidden;
+}
+
+.visible {
+  visibility: visible;
+}

package/src/browser/types.ts

@@ -13,7 +13,7 @@ import {
   MaybePromise,
   MergeConflictEditorMode,
 } from '@opensumi/ide-core-common';
-import { ICodeEditor, IRange, ISelection, ITextModel, NewSymbolNamesProvider, Position } from '@opensumi/ide-monaco';
+import { ICodeEditor, IRange, ITextModel, NewSymbolNamesProvider, Position } from '@opensumi/ide-monaco';
 import { SumiReadableStream } from '@opensumi/ide-utils/lib/stream';
 import { IMarker } from '@opensumi/monaco-editor-core/esm/vs/platform/markers/common/markers';
 
@@ -44,7 +44,7 @@ interface IBaseInlineChatHandler<T extends any[]> {
 
 export type IEditorInlineChatHandler = IBaseInlineChatHandler<[editor: ICodeEditor, token: CancellationToken]>;
 export type IInteractiveInputHandler = IBaseInlineChatHandler<
-  [editor: ICodeEditor, selection: ISelection, value: string, token: CancellationToken]
+  [editor: ICodeEditor, value: string, token: CancellationToken]
 >;
 
 export enum ERunStrategy {

package/src/browser/widget/inline-chat/inline-chat-editor.controller.ts

@@ -15,7 +15,6 @@ import {
   Disposable,
   ErrorResponse,
   Event,
-  FRAME_THREE,
   IAIReporter,
   IDisposable,
   ILogServiceClient,
@@ -31,14 +30,14 @@ import * as monaco from '@opensumi/ide-monaco';
 import { ICodeEditor } from '@opensumi/ide-monaco';
 import { monacoApi } from '@opensumi/ide-monaco/lib/browser/monaco-api';
 
-import { AINativeContextKey } from '../../ai-core.contextkeys';
 import { BaseAIMonacoEditorController } from '../../contrib/base';
 import { CodeActionService } from '../../contrib/code-action/code-action.service';
+import { ERunStrategy } from '../../types';
 import { InlineDiffController } from '../inline-diff/inline-diff.controller';
 
 import { InlineChatController } from './inline-chat-controller';
 import { InlineChatFeatureRegistry } from './inline-chat.feature.registry';
-import { EInlineChatStatus, EResultKind, InlineChatService } from './inline-chat.service';
+import { AIInlineChatService, EInlineChatStatus, EResultKind } from './inline-chat.service';
 import { AIInlineContentWidget } from './inline-content-widget';
 
 export class InlineChatEditorController extends BaseAIMonacoEditorController {
@@ -52,7 +51,7 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
     return this.injector.get(AINativeConfigService);
   }
 
-  private get aiInlineChatService(): InlineChatService {
+  private get aiInlineChatService(): AIInlineChatService {
     return this.injector.get(IAIInlineChatService);
   }
 
@@ -87,13 +86,11 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
   private aiInlineContentWidget: AIInlineContentWidget;
   private aiInlineChatDisposable: Disposable = new Disposable();
   private aiInlineChatOperationDisposable: Disposable = new Disposable();
-  private aiNativeContextKey: AINativeContextKey;
   private inlineChatInUsing = false;
 
   private inlineDiffController: InlineDiffController;
 
   mount(): IDisposable {
-    this.aiNativeContextKey = this.injector.get(AINativeContextKey, [this.monacoEditor.contextKeyService]);
     this.inlineDiffController = InlineDiffController.get(this.monacoEditor)!;
 
     if (!this.monacoEditor) {
@@ -181,7 +178,7 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
       Event.debounce(
         Event.any<any>(this.monacoEditor.onDidChangeCursorSelection, this.monacoEditor.onMouseUp),
         (_, e) => e,
-        FRAME_THREE,
+        100,
       )(() => {
         if (!prefInlineChatAutoVisible || !needShowInlineChat) {
           return;
@@ -200,7 +197,7 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
     return this.featureDisposable;
   }
 
-  public disposeAllWidget() {
+  private disposeAllWidget() {
     [this.aiInlineContentWidget, this.aiInlineChatDisposable, this.aiInlineChatOperationDisposable].forEach(
       (widget) => {
         widget?.dispose();
@@ -227,21 +224,9 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
       return;
     }
 
-    // 如果 inline input 正在展示，则不展示 inline chat
-    const isInlineInputVisible = this.aiNativeContextKey.inlineInputWidgetIsVisible.get();
-    if (isInlineInputVisible) {
-      return;
-    }
-
-    const isInlineStreaming = this.aiNativeContextKey.inlineInputWidgetIsStreaming.get();
-    if (isInlineStreaming) {
-      return;
-    }
-
     if (!this.aiNativeConfigService.capabilities.supportsInlineChat) {
       return;
     }
-
     if (this.inlineChatInUsing) {
       return;
     }
@@ -258,6 +243,12 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
 
     this.showInlineContentWidget(monacoEditor, selection);
 
+    this.aiInlineChatDisposable.addDispose(
+      this.inlineChatFeatureRegistry.onChatClick(() => {
+        this.aiInlineChatService.launchInputVisible(true);
+      }),
+    );
+
     this.aiInlineChatDisposable.addDispose(
       this.aiInlineContentWidget.onActionClick(({ actionId, source }) => {
         const handler = this.inlineChatFeatureRegistry.getEditorHandler(actionId);
@@ -306,6 +297,49 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
         });
       }),
     );
+
+    this.aiInlineChatDisposable.addDispose(
+      this.aiInlineContentWidget.onInteractiveInputValue(async (value) => {
+        const handler = this.inlineChatFeatureRegistry.getInteractiveInputHandler();
+
+        if (!handler) {
+          return;
+        }
+
+        const strategy = await this.inlineChatFeatureRegistry.getInteractiveInputStrategyHandler()(monacoEditor, value);
+
+        const crossSelection = this.getCrossSelection(monacoEditor);
+        if (!crossSelection) {
+          return;
+        }
+
+        this.runAction({
+          monacoEditor,
+          crossSelection,
+          reporterFn: () => {
+            const relationId = this.aiReporter.start(AIServiceType.InlineChatInput, {
+              message: value,
+              type: AIServiceType.InlineChatInput,
+              source: 'input',
+              actionSource: ActionSourceEnum.InlineChatInput,
+            });
+            return relationId;
+          },
+          execute:
+            handler.execute && strategy === ERunStrategy.EXECUTE
+              ? handler.execute!.bind(this, monacoEditor, value, this.token)
+              : undefined,
+          providerPreview:
+            handler.providePreviewStrategy && strategy === ERunStrategy.PREVIEW
+              ? handler.providePreviewStrategy.bind(this, monacoEditor, value, this.token)
+              : undefined,
+          extraData: {
+            actionSource: ActionSourceEnum.InlineChatInput,
+            actionType: strategy,
+          },
+        });
+      }),
+    );
   }
 
   private getCrossSelection(monacoEditor: monaco.ICodeEditor) {
@@ -446,7 +480,7 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
     }
 
     const diffPreviewer = this.inlineDiffController.showPreviewerByStream(monacoEditor, options);
-    diffPreviewer.mountWidget(this.aiInlineContentWidget);
+    diffPreviewer.mount(this.aiInlineContentWidget);
   }
 
   private ensureInlineChatVisible(monacoEditor: monaco.ICodeEditor, crossSelection: monaco.Selection) {
@@ -472,6 +506,7 @@ export class InlineChatEditorController extends BaseAIMonacoEditorController {
     const { monacoEditor, strategy, crossSelection, relationId, isRetry, actionType, actionSource } = params;
     const model = monacoEditor.getModel();
 
+    this.inlineDiffController.destroyPreviewer(model!.uri.toString());
     this.aiInlineChatOperationDisposable.dispose();
 
     this.ensureInlineChatVisible(monacoEditor, crossSelection);

package/src/browser/widget/inline-chat/inline-chat.feature.registry.ts

@@ -2,18 +2,48 @@ import { Autowired, Injectable } from '@opensumi/di';
 import { KeybindingRegistry, Logger } from '@opensumi/ide-core-browser';
 import { AI_INLINE_CHAT_INTERACTIVE_INPUT_VISIBLE } from '@opensumi/ide-core-browser/lib/ai-native/command';
 import { AIActionItem } from '@opensumi/ide-core-browser/lib/components/ai-native';
-import { Disposable, Event, IDisposable, formatLocalize, isUndefined } from '@opensumi/ide-core-common';
+import { InteractiveInput } from '@opensumi/ide-core-browser/lib/components/ai-native/interactive-input/index';
+import { Disposable, Emitter, Event, IDisposable, MaybePromise, isUndefined, uuid } from '@opensumi/ide-core-common';
+import { ICodeEditor } from '@opensumi/ide-monaco';
 
 import { CodeActionService } from '../../contrib/code-action/code-action.service';
 import {
+  ERunStrategy,
   IEditorInlineChatHandler,
   IInlineChatFeatureRegistry,
   IInteractiveInputHandler,
   IInteractiveInputRunStrategy,
   ITerminalInlineChatHandler,
 } from '../../types';
-import { InlineInputService } from '../inline-input/inline-input.service';
-import { InteractiveInputModel } from '../inline-input/model';
+
+type TRunStrategyFn = (editor: ICodeEditor, value: string) => MaybePromise<ERunStrategy>;
+
+class InteractiveInputModel {
+  static ID: string = `${InteractiveInput.displayName}:${uuid(4)}`;
+
+  private _handler: IInteractiveInputHandler | undefined;
+  private _strategyHandler: TRunStrategyFn;
+
+  public setHandler(h: IInteractiveInputHandler): void {
+    this._handler = h;
+  }
+
+  public handler(): IInteractiveInputHandler | undefined {
+    return this._handler;
+  }
+
+  public setStrategyHandler(fn: TRunStrategyFn): void {
+    this._strategyHandler = fn;
+  }
+
+  public strategyHandler(): TRunStrategyFn {
+    return this._strategyHandler;
+  }
+
+  public dispose(): void {
+    this._handler = undefined;
+  }
+}
 
 @Injectable()
 export class InlineChatFeatureRegistry extends Disposable implements IInlineChatFeatureRegistry {
@@ -23,9 +53,6 @@ export class InlineChatFeatureRegistry extends Disposable implements IInlineChat
   @Autowired(CodeActionService)
   private readonly codeActionService: CodeActionService;
 
-  @Autowired(InlineInputService)
-  private readonly inlineInputService: InlineInputService;
-
   @Autowired(KeybindingRegistry)
   private readonly keybindingRegistry: KeybindingRegistry;
 
@@ -33,6 +60,11 @@ export class InlineChatFeatureRegistry extends Disposable implements IInlineChat
   private editorHandlerMap: Map<string, IEditorInlineChatHandler> = new Map();
   private terminalHandlerMap: Map<string, ITerminalInlineChatHandler> = new Map();
 
+  private interactiveInputModel: InteractiveInputModel = new InteractiveInputModel();
+
+  public readonly _onChatClick = new Emitter<void>();
+  public readonly onChatClick: Event<void> = this._onChatClick.event;
+
   override dispose() {
     super.dispose();
     this.actionsMap.clear();
@@ -40,6 +72,10 @@ export class InlineChatFeatureRegistry extends Disposable implements IInlineChat
     this.terminalHandlerMap.clear();
   }
 
+  private updateActions(id: string, operational: AIActionItem): void {
+    this.actionsMap.set(id, operational);
+  }
+
   private collectActions(operational: AIActionItem): boolean {
     const { id } = operational;
 
@@ -66,6 +102,10 @@ export class InlineChatFeatureRegistry extends Disposable implements IInlineChat
     this.codeActionService.deleteCodeActionById(operational.id);
   }
 
+  public getInteractiveInputId(): string {
+    return InteractiveInputModel.ID;
+  }
+
   public registerEditorInlineChat(operational: AIActionItem, handler: IEditorInlineChatHandler): IDisposable {
     const isCollect = this.collectActions(operational);
 
@@ -111,23 +151,29 @@ export class InlineChatFeatureRegistry extends Disposable implements IInlineChat
     runStrategy: IInteractiveInputRunStrategy,
     handler: IInteractiveInputHandler,
   ): IDisposable {
-    const doCollect = () => {
-      const keybindingStr = String(this.inlineInputService.getSequenceKeyString());
-      if (!keybindingStr) {
-        return;
-      }
+    this.interactiveInputModel.setHandler(handler);
 
-      const operational: AIActionItem = {
-        id: InteractiveInputModel.ID,
-        name: formatLocalize('aiNative.inline.chat.operate.chat.title', keybindingStr.toLocaleUpperCase()),
-        renderType: 'button',
-        order: Number.MAX_SAFE_INTEGER,
-      };
-
-      if (this.actionsMap.has(operational.id)) {
-        this.actionsMap.set(operational.id, operational);
-      } else {
-        this.collectActions(operational);
+    if (runStrategy.handleStrategy) {
+      this.interactiveInputModel.setStrategyHandler(runStrategy.handleStrategy);
+    } else {
+      this.interactiveInputModel.setStrategyHandler(() => runStrategy.strategy || ERunStrategy.EXECUTE);
+    }
+
+    const doCollect = () => {
+      const keybindingStr = String(this.getSequenceKeyString());
+      if (keybindingStr) {
+        const operational: AIActionItem = {
+          id: InteractiveInputModel.ID,
+          name: `Chat(${keybindingStr.toLocaleUpperCase()})`,
+          renderType: 'button',
+          order: Number.MAX_SAFE_INTEGER,
+        };
+
+        if (this.actionsMap.has(operational.id)) {
+          this.updateActions(operational.id, operational);
+        } else {
+          this.collectActions(operational);
+        }
       }
     };
 
@@ -139,7 +185,28 @@ export class InlineChatFeatureRegistry extends Disposable implements IInlineChat
 
     doCollect();
 
-    return this.inlineInputService.registerInlineInput(runStrategy, handler);
+    return {
+      dispose: () => {
+        this.interactiveInputModel.dispose();
+      },
+    };
+  }
+
+  private getSequenceKeyString() {
+    const keybindings = this.keybindingRegistry.getKeybindingsForCommand(AI_INLINE_CHAT_INTERACTIVE_INPUT_VISIBLE.id);
+    const resolved = keybindings[0]?.resolved;
+    if (!resolved) {
+      return '';
+    }
+    return this.keybindingRegistry.acceleratorForSequence(resolved, '+');
+  }
+
+  public getInteractiveInputHandler(): IInteractiveInputHandler | undefined {
+    return this.interactiveInputModel.handler();
+  }
+
+  public getInteractiveInputStrategyHandler(): TRunStrategyFn {
+    return this.interactiveInputModel.strategyHandler();
   }
 
   public getEditorActionButtons(): AIActionItem[] {

package/src/browser/widget/inline-chat/inline-chat.service.ts

@@ -1,11 +1,21 @@
 import { Injectable } from '@opensumi/di';
 import { IAIInlineChatService } from '@opensumi/ide-core-browser';
-import { Emitter, Event } from '@opensumi/ide-core-common';
+import { Emitter, Event, runWhenIdle } from '@opensumi/ide-core-common';
 
 export { EInlineChatStatus, EResultKind } from '../../../common';
 
 @Injectable({ multiple: false })
-export class InlineChatService implements IAIInlineChatService {
+export class AIInlineChatService implements IAIInlineChatService {
+  private _interactiveInputVisible: boolean = false;
+  public get interactiveInputVisible(): boolean {
+    const visible = this._interactiveInputVisible;
+    this._interactiveInputVisible = false;
+    return visible;
+  }
+
+  public readonly _onInteractiveInputVisible = new Emitter<boolean>();
+  public readonly onInteractiveInputVisible: Event<boolean> = this._onInteractiveInputVisible.event;
+
   public readonly _onInlineChatVisible = new Emitter<boolean>();
   public readonly onInlineChatVisible: Event<boolean> = this._onInlineChatVisible.event;
 
@@ -15,4 +25,11 @@ export class InlineChatService implements IAIInlineChatService {
   public fireThumbsEvent(isThumbsUp: boolean) {
     this._onThumbs.fire(isThumbsUp);
   }
+
+  public launchInputVisible(v: boolean) {
+    return runWhenIdle(() => {
+      this._interactiveInputVisible = v;
+      this._onInteractiveInputVisible.fire(v);
+    });
+  }
 }