@opensumi/ide-ai-native 3.7.2-next-1740064823.0 → 3.7.2-next-1740107209.0

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

@@ -40,6 +40,7 @@ import {
   TokenMCPServerProxyService,
 } from '../../common';
 import { LLMContextService, LLMContextServiceToken } from '../../common/llm-context';
+import { ChatAgentPromptProvider } from '../../common/prompts/context-prompt-provider';
 import { ChatContext } from '../components/ChatContext';
 import { CodeBlockWrapperInput } from '../components/ChatEditor';
 import { ChatInput } from '../components/ChatInput';
@@ -50,7 +51,7 @@ import { MessageData, createMessageByAI, createMessageByUser } from '../componen
 import { WelcomeMessage } from '../components/WelcomeMsg';
 import { MCPServerProxyService } from '../mcp/mcp-server-proxy.service';
 import { MCPToolsDialog } from '../mcp/mcp-tools-dialog.view';
-import { ChatAgentPromptProvider, ChatViewHeaderRender, TSlashCommandCustomRender } from '../types';
+import { ChatViewHeaderRender, TSlashCommandCustomRender } from '../types';
 
 import { ChatRequestModel, ChatSlashCommandItemModel } from './chat-model';
 import { ChatProxyService } from './chat-proxy.service';

package/src/browser/components/ChatEditor.tsx

@@ -31,9 +31,10 @@ interface Props {
   language?: string;
   agentId?: string;
   command?: string;
+  hideInsert?: boolean;
 }
 export const CodeEditorWithHighlight = (props: Props) => {
-  const { input, language, relationId, agentId, command } = props;
+  const { input, language, relationId, agentId, command, hideInsert } = props;
   const ref = React.useRef<HTMLDivElement | null>(null);
   const monacoCommandRegistry = useInjectable<MonacoCommandRegistry>(MonacoCommandRegistry);
   const clipboardService = useInjectable<IClipboardService>(IClipboardService);
@@ -101,15 +102,17 @@ export const CodeEditorWithHighlight = (props: Props) => {
   return (
     <div className={styles.monaco_wrapper}>
       <div className={styles.action_toolbar}>
-        <Popover id={`ai-chat-inser-${useUUID}`} title={localize('aiNative.chat.code.insert')}>
-          <EnhanceIcon
-            className={getIcon('insert')}
-            onClick={() => handleInsert()}
-            tabIndex={0}
-            role='button'
-            ariaLabel={localize('aiNative.chat.code.insert')}
-          />
-        </Popover>
+        {!hideInsert && (
+          <Popover id={`ai-chat-inser-${useUUID}`} title={localize('aiNative.chat.code.insert')}>
+            <EnhanceIcon
+              className={getIcon('insert')}
+              onClick={() => handleInsert()}
+              tabIndex={0}
+              role='button'
+              ariaLabel={localize('aiNative.chat.code.insert')}
+            />
+          </Popover>
+        )}
         <Popover
           id={`ai-chat-copy-${useUUID}`}
           title={localize(isCoping ? 'aiNative.chat.code.copy.success' : 'aiNative.chat.code.copy')}

package/src/browser/components/ChatMarkdown.tsx

@@ -17,6 +17,7 @@ interface MarkdownProps {
   className?: string;
   fillInIncompleteTokens?: boolean; // 补齐不完整的 token，如代码块或表格
   markedOptions?: IMarkedOptions;
+  hideInsert?: boolean;
 }
 
 export const ChatMarkdown = (props: MarkdownProps) => {
@@ -42,13 +43,14 @@ export const ChatMarkdown = (props: MarkdownProps) => {
         <div className={styles.code}>
           <ConfigProvider value={appConfig}>
             <div className={styles.code_block}>
-              <div className={styles.code_language}>{language}</div>
+              <div className={cls(styles.code_language, 'language-badge')}>{language}</div>
               <CodeEditorWithHighlight
                 input={code as string}
                 language={language}
                 relationId={props.relationId || ''}
                 agentId={props.agentId}
                 command={props.command}
+                hideInsert={props.hideInsert}
               />
             </div>
           </ConfigProvider>

package/src/browser/components/ChatReply.tsx

@@ -149,8 +149,8 @@ const TreeRenderer = (props: { treeData: IChatResponseProgressFileTreeData }) =>
   );
 };
 
-const ToolCallRender = (props: { toolCall: IChatToolContent['content'] }) => {
-  const { toolCall } = props;
+const ToolCallRender = (props: { toolCall: IChatToolContent['content']; messageId?: string }) => {
+  const { toolCall, messageId } = props;
   const chatAgentViewService = useInjectable<IChatAgentViewService>(ChatAgentViewServiceToken);
   const [node, setNode] = useState<React.JSX.Element | null>(null);
 
@@ -158,7 +158,7 @@ const ToolCallRender = (props: { toolCall: IChatToolContent['content'] }) => {
     const config = chatAgentViewService.getChatComponent('toolCall');
     if (config) {
       const { component: Component, initialProps } = config;
-      setNode(<Component {...initialProps} value={toolCall} />);
+      setNode(<Component {...initialProps} value={toolCall} messageId={messageId} />);
       return;
     }
     setNode(
@@ -169,14 +169,14 @@ const ToolCallRender = (props: { toolCall: IChatToolContent['content'] }) => {
     );
     const deferred = chatAgentViewService.getChatComponentDeferred('toolCall')!;
     deferred.promise.then(({ component: Component, initialProps }) => {
-      setNode(<Component {...initialProps} value={toolCall} />);
+      setNode(<Component {...initialProps} value={toolCall} messageId={messageId} />);
     });
   }, [toolCall.state]);
 
   return node;
 };
 
-const ComponentRender = (props: { component: string; value?: unknown }) => {
+const ComponentRender = (props: { component: string; value?: unknown; messageId?: string }) => {
   const chatAgentViewService = useInjectable<IChatAgentViewService>(ChatAgentViewServiceToken);
   const [node, setNode] = useState<React.JSX.Element | null>(null);
 
@@ -184,7 +184,7 @@ const ComponentRender = (props: { component: string; value?: unknown }) => {
     const config = chatAgentViewService.getChatComponent(props.component);
     if (config) {
       const { component: Component, initialProps } = config;
-      setNode(<Component {...initialProps} value={props.value} />);
+      setNode(<Component {...initialProps} value={props.value} messageId={props.messageId} />);
       return;
     }
     setNode(
@@ -224,7 +224,6 @@ export const ChatReply = (props: IChatReplyProps) => {
   const chatApiService = useInjectable<ChatService>(ChatServiceToken);
   const chatAgentService = useInjectable<IChatAgentService>(IChatAgentService);
   const chatRenderRegistry = useInjectable<ChatRenderRegistry>(ChatRenderRegistryToken);
-
   useEffect(() => {
     const disposableCollection = new DisposableCollection();
 
@@ -298,12 +297,6 @@ export const ChatReply = (props: IChatReplyProps) => {
     </div>
   );
 
-  const renderComponent = (componentId: string, value: unknown) => (
-    <ComponentRender component={componentId} value={value} />
-  );
-
-  const renderToolCall = (toolCall: IChatToolContent['content']) => <ToolCallRender toolCall={toolCall} />;
-
   const contentNode = React.useMemo(
     () =>
       request.response.responseContents.map((item, index) => {
@@ -313,9 +306,9 @@ export const ChatReply = (props: IChatReplyProps) => {
         } else if (item.kind === 'treeData') {
           node = renderTreeData(item.treeData);
         } else if (item.kind === 'component') {
-          node = renderComponent(item.component, item.value);
+          node = <ComponentRender component={item.component} value={item.value} messageId={msgId} />;
         } else if (item.kind === 'toolCall') {
-          node = renderToolCall(item.content);
+          node = <ToolCallRender toolCall={item.content} messageId={msgId} />;
         } else {
           node = renderMarkdown(item.content);
         }

package/src/browser/components/ChatToolRender.tsx

@@ -1,20 +1,27 @@
 import cls from 'classnames';
 import React, { useState } from 'react';
 
+import { useInjectable } from '@opensumi/ide-core-browser';
 import { Icon } from '@opensumi/ide-core-browser/lib/components';
 import { Loading } from '@opensumi/ide-core-browser/lib/components/ai-native';
 import { IChatToolContent, uuid } from '@opensumi/ide-core-common';
 
+import { IMCPServerRegistry, TokenMCPServerRegistry } from '../types';
+
 import { CodeEditorWithHighlight } from './ChatEditor';
 import styles from './ChatToolRender.module.less';
 
-export const ChatToolRender = (props: { value: IChatToolContent['content'] }) => {
-  const { value } = props;
+export const ChatToolRender = (props: { value: IChatToolContent['content']; messageId?: string }) => {
+  const { value, messageId } = props;
   const [isExpanded, setIsExpanded] = useState(false);
+  const mcpServerFeatureRegistry = useInjectable<IMCPServerRegistry>(TokenMCPServerRegistry);
 
   if (!value || !value.function || !value.id) {
     return null;
   }
+  const label = mcpServerFeatureRegistry.getMCPTool(value.function.name)?.label || value.function.name;
+
+  const ToolComponent = mcpServerFeatureRegistry.getToolComponent(value.function.name);
 
   const getStateInfo = (state?: string): { label: string; icon: React.ReactNode } => {
     switch (state) {
@@ -22,11 +29,22 @@ export const ChatToolRender = (props: { value: IChatToolContent['content'] }) =>
       case 'streaming':
         return { label: 'Generating', icon: <Loading /> };
       case 'complete':
-        return { label: 'Complete', icon: <Icon iconClass="codicon codicon-check" /> };
+        return { label: 'Complete', icon: <Icon iconClass='codicon codicon-check' /> };
       case 'result':
-        return { label: 'Result Ready', icon: <Icon iconClass="codicon codicon-check-all" /> };
+        return { label: 'Result Ready', icon: <Icon iconClass='codicon codicon-check-all' /> };
       default:
-        return { label: state || 'Unknown', icon: <Icon iconClass="codicon codicon-question" /> };
+        return { label: state || 'Unknown', icon: <Icon iconClass='codicon codicon-question' /> };
+    }
+  };
+  const getParsedArgs = () => {
+    try {
+      // TODO: 流式输出中function_call的参数还不完整，需要等待complete状态
+      if (value.state !== 'complete' && value.state !== 'result') {
+        return {};
+      }
+      return JSON.parse(value.function?.arguments || '{}');
+    } catch (error) {
+      return {};
     }
   };
 
@@ -36,12 +54,12 @@ export const ChatToolRender = (props: { value: IChatToolContent['content'] }) =>
 
   const stateInfo = getStateInfo(value.state);
 
-  return (
-    <div className={styles['chat-tool-render']}>
+  return [
+    <div className={styles['chat-tool-render']} key='chat-tool-render'>
       <div className={styles['tool-header']} onClick={toggleExpand}>
         <div className={styles['tool-name']}>
           <span className={cls(styles['expand-icon'], { [styles.expanded]: isExpanded })}>▶</span>
-          {value?.function?.name}
+          {label}
         </div>
         {value.state && (
           <div className={styles['tool-state']}>
@@ -54,24 +72,27 @@ export const ChatToolRender = (props: { value: IChatToolContent['content'] }) =>
         {value?.function?.arguments && (
           <div className={styles['tool-arguments']}>
             <div className={styles['section-label']}>Arguments</div>
-            <CodeEditorWithHighlight
-              input={value?.function?.arguments}
-              language={'json'}
-              relationId={uuid(4)}
-            />
+            <CodeEditorWithHighlight input={value?.function?.arguments} language={'json'} relationId={uuid(4)} />
           </div>
         )}
         {value?.result && (
           <div className={styles['tool-result']}>
             <div className={styles['section-label']}>Result</div>
-            <CodeEditorWithHighlight
-              input={value.result}
-              language={'json'}
-              relationId={uuid(4)}
-            />
+            <CodeEditorWithHighlight input={value.result} language={'json'} relationId={uuid(4)} />
           </div>
         )}
       </div>
-    </div>
-  );
+    </div>,
+    ToolComponent && (
+      <ToolComponent
+        key='tool-component'
+        state={value.state}
+        args={getParsedArgs()}
+        result={value.result}
+        index={value.index}
+        messageId={messageId}
+        toolCallId={value.id}
+      />
+    ),
+  ];
 };

package/src/browser/components/components.module.less

@@ -253,7 +253,7 @@
   .editor {
     border-radius: 8px;
     font-size: 12px;
-    padding: 32px 8px 8px 8px;
+    padding: 28px 8px 8px 8px;
     line-height: 18px;
     &::-webkit-scrollbar {
       width: auto;
@@ -265,7 +265,7 @@
     display: flex;
     position: absolute;
     right: 8px;
-    top: 6px;
+    top: 2px;
     z-index: 100;
     height: 20px;
     align-items: center;
@@ -300,6 +300,7 @@
     background-color: var(--design-language-background);
     border-radius: 8px 0px 8px 0;
     color: var(--design-text-foreground);
+    font-size: 12px;
   }
 }
 

package/src/browser/index.ts

@@ -30,6 +30,7 @@ import {
 } from '../common';
 import { LLMContextServiceToken } from '../common/llm-context';
 import { MCPServerManager, MCPServerManagerPath } from '../common/mcp-server-manager';
+import { ChatAgentPromptProvider, DefaultChatAgentPromptProvider } from '../common/prompts/context-prompt-provider';
 
 import { AINativeBrowserContribution } from './ai-core.contribution';
 import { ChatAgentService } from './chat/chat-agent.service';
@@ -57,6 +58,7 @@ import { LanguageParserService } from './languages/service';
 import { MCPServerProxyService } from './mcp/mcp-server-proxy.service';
 import { MCPServerRegistry } from './mcp/mcp-server.feature.registry';
 import { CreateNewFileWithTextTool } from './mcp/tools/createNewFileWithText';
+import { EditFileTool } from './mcp/tools/editFile';
 import { FindFilesByNameSubstringTool } from './mcp/tools/findFilesByNameSubstring';
 import { GetCurrentFilePathTool } from './mcp/tools/getCurrentFilePath';
 import { GetDiagnosticsByPathTool } from './mcp/tools/getDiagnosticsByPath';
@@ -97,6 +99,7 @@ export class AINativeModule extends BrowserModule {
     // MCP Server Contributions START
     ListDirTool,
     ReadFileTool,
+    EditFileTool,
     CreateNewFileWithTextTool,
     GetSelectedTextTool,
     GetOpenEditorFileDiagnosticsTool,
@@ -196,6 +199,10 @@ export class AINativeModule extends BrowserModule {
       token: InlineDiffService,
       useClass: InlineDiffService,
     },
+    {
+      token: ChatAgentPromptProvider,
+      useValue: DefaultChatAgentPromptProvider,
+    },
   ];
 
   backServices = [

package/src/browser/mcp/base-apply.service.ts

@@ -0,0 +1,349 @@
+import { createPatch } from 'diff';
+
+import { Autowired } from '@opensumi/di';
+import { AppConfig, ChatMessageRole, IMarker, MarkerSeverity, OnEvent, WithEventBus } from '@opensumi/ide-core-browser';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+import { EditorGroupCloseEvent } from '@opensumi/ide-editor/lib/browser';
+import { IMarkerService } from '@opensumi/ide-markers';
+import { Position, Range, Selection, SelectionDirection } from '@opensumi/ide-monaco';
+import { observableValue, transaction } from '@opensumi/ide-monaco/lib/common/observable';
+import { Deferred, URI, path } from '@opensumi/ide-utils';
+
+import { IChatInternalService } from '../../common';
+import { ChatInternalService } from '../chat/chat.internal.service';
+import {
+  BaseInlineDiffPreviewer,
+  InlineDiffController,
+  InlineDiffService,
+  LiveInlineDiffPreviewer,
+} from '../widget/inline-diff';
+import { InlineStreamDiffHandler } from '../widget/inline-stream-diff/inline-stream-diff.handler';
+
+import { FileHandler } from './tools/handlers/ReadFile';
+
+// 提供代码块的唯一索引，迭代轮次，生成状态管理（包括取消），关联文件位置这些信息的记录，后续并行 apply 的支持
+export abstract class BaseApplyService extends WithEventBus {
+  @Autowired(FileHandler)
+  protected fileHandler: FileHandler;
+
+  @Autowired(IChatInternalService)
+  protected chatInternalService: ChatInternalService;
+
+  @Autowired(AppConfig)
+  protected appConfig: AppConfig;
+
+  @Autowired(WorkbenchEditorService)
+  protected readonly editorService: WorkbenchEditorService;
+
+  @Autowired(InlineDiffService)
+  private readonly inlineDiffService: InlineDiffService;
+
+  @Autowired(IMarkerService)
+  private readonly markerService: IMarkerService;
+
+  constructor() {
+    super();
+    this.addDispose(
+      this.chatInternalService.onCancelRequest(() => {
+        this.cancelAllApply();
+      }),
+    );
+    this.addDispose(
+      this.chatInternalService.onRegenerateRequest(() => {
+        const messages = this.chatInternalService.sessionModel.history.getMessages();
+        const messageId = messages[messages.length - 1].id;
+        messageId && this.disposeApplyForMessage(messageId);
+      }),
+    );
+  }
+
+  public readonly codeBlockMapObservable = observableValue<Map<string, CodeBlockData>>(this, new Map());
+
+  private activePreviewer: BaseInlineDiffPreviewer<InlineStreamDiffHandler> | undefined;
+
+  private pendingApplyParams:
+    | {
+        relativePath: string;
+        newContent: string;
+        range?: Range;
+      }
+    | undefined;
+
+  @OnEvent(EditorGroupCloseEvent)
+  onEditorGroupClose(event: EditorGroupCloseEvent) {
+    if (this.activePreviewer?.getNode()?.uri.path.toString() === event.payload.resource.uri.path.toString()) {
+      this.activePreviewer.dispose();
+      this.activePreviewer = undefined;
+    }
+  }
+
+  /**
+   * Get the code block data by relative or absolute path of the last assistant message
+   */
+  getCodeBlock(relativeOrAbsolutePath: string, messageId?: string): CodeBlockData | undefined {
+    if (!relativeOrAbsolutePath) {
+      return undefined;
+    }
+    const blockId = this.generateBlockId(relativeOrAbsolutePath, messageId);
+    return this.codeBlockMapObservable.get().get(blockId);
+  }
+
+  getCodeBlockById(id: string): CodeBlockData | undefined {
+    return this.codeBlockMapObservable.get().get(id);
+  }
+
+  protected updateCodeBlock(codeBlock: CodeBlockData) {
+    const codeBlockMap = new Map(this.codeBlockMapObservable.get());
+    codeBlockMap.set(codeBlock.id, codeBlock);
+    transaction((tx) => {
+      this.codeBlockMapObservable.set(codeBlockMap, tx);
+    });
+  }
+
+  /**
+   * Register a new code block and return its unique ID
+   */
+  registerCodeBlock(relativePath: string, content: string): string {
+    const blockId = this.generateBlockId(relativePath);
+
+    if (!this.codeBlockMapObservable.get().has(blockId)) {
+      this.codeBlockMapObservable.get().set(blockId, {
+        id: blockId,
+        content,
+        relativePath,
+        status: 'generating',
+        iterationCount: 0,
+        createdAt: Date.now(),
+      });
+    }
+
+    return blockId;
+  }
+
+  initToolCallId(blockId: string, toolCallId: string): void {
+    const blockData = this.getCodeBlockById(blockId);
+    if (blockData && !blockData.initToolCallId) {
+      blockData.initToolCallId = toolCallId;
+    }
+  }
+
+  /**
+   * Apply changes of a code block
+   */
+  async apply(relativePath: string, newContent: string, instructions?: string): Promise<CodeBlockData> {
+    const blockData = this.getCodeBlock(relativePath);
+    if (!blockData) {
+      throw new Error('Code block not found');
+    }
+    try {
+      if (++blockData.iterationCount > 3) {
+        throw new Error('Max iteration count exceeded');
+      }
+      blockData.status = 'generating';
+      blockData.content = newContent;
+      this.updateCodeBlock(blockData);
+      const applyDiffResult = await this.doApply(relativePath, newContent, instructions);
+      blockData.applyResult = applyDiffResult;
+      this.updateCodeBlock(blockData);
+      return blockData;
+    } catch (err) {
+      blockData.status = 'failed';
+      this.updateCodeBlock(blockData);
+      throw err;
+    }
+  }
+
+  async reRenderPendingApply() {
+    if (!this.pendingApplyParams) {
+      throw new Error('No pending apply params');
+    }
+    const result = await this.renderApplyResult(
+      this.pendingApplyParams.relativePath,
+      this.pendingApplyParams.newContent,
+      this.pendingApplyParams.range,
+    );
+    if (result) {
+      const blockData = this.getCodeBlock(this.pendingApplyParams.relativePath)!;
+      blockData.applyResult = result;
+      this.updateCodeBlock(blockData);
+    }
+  }
+
+  async renderApplyResult(
+    relativePath: string,
+    newContent: string,
+    range?: Range,
+  ): Promise<{ diff: string; diagnosticInfos: IMarker[] } | undefined> {
+    // 用户可能会关闭编辑器，所以需要缓存参数
+    this.pendingApplyParams = {
+      relativePath,
+      newContent,
+      range,
+    };
+    const blockData = this.getCodeBlock(relativePath);
+    if (!blockData) {
+      throw new Error('Code block not found');
+    }
+    const openResult = await this.editorService.open(URI.file(path.join(this.appConfig.workspaceDir, relativePath)));
+    if (!openResult) {
+      throw new Error('Failed to open editor');
+    }
+    const editor = openResult.group.codeEditor.monacoEditor;
+    const inlineDiffController = InlineDiffController.get(editor)!;
+    blockData.status = 'pending';
+    this.updateCodeBlock(blockData);
+
+    range = range || editor.getModel()?.getFullModelRange()!;
+    // Create diff previewer
+    const previewer = inlineDiffController.createDiffPreviewer(
+      editor,
+      Selection.fromRange(range, SelectionDirection.LTR),
+      {
+        disposeWhenEditorClosed: true,
+        renderRemovedWidgetImmediately: true,
+      },
+    ) as LiveInlineDiffPreviewer;
+    this.activePreviewer = previewer;
+
+    const fullOriginalContent = editor.getModel()!.getValue();
+    const savedContent = editor.getModel()!.getValueInRange(range);
+    const deferred = new Deferred<{ diff: string; diagnosticInfos: IMarker[] }>();
+    if (newContent === savedContent) {
+      blockData.status = 'success';
+      deferred.resolve();
+    } else {
+      previewer.setValue(newContent);
+      this.addDispose(
+        this.inlineDiffService.onPartialEdit((event) => {
+          // TODO 支持自动保存
+          if (event.totalPartialEditCount === event.resolvedPartialEditCount) {
+            if (event.acceptPartialEditCount > 0) {
+              blockData.status = 'success';
+              const appliedResult = editor.getModel()!.getValue();
+              const diffResult = createPatch(relativePath, fullOriginalContent, appliedResult)
+                .split('\n')
+                .slice(4)
+                .join('\n');
+              const rangesFromDiffHunk = diffResult
+                .split('\n')
+                .map((line) => {
+                  if (line.startsWith('@@')) {
+                    const [, , , start, end] = line.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/)!;
+                    return new Range(parseInt(start, 10), 0, parseInt(end, 10), 0);
+                  }
+                  return null;
+                })
+                .filter((range) => range !== null);
+              const diagnosticInfos = this.getdiagnosticInfos(editor.getModel()!.uri.toString(), rangesFromDiffHunk);
+              // 移除开头的几个固定信息，避免浪费 tokens
+              deferred.resolve({
+                diff: diffResult,
+                diagnosticInfos,
+              });
+            } else {
+              // 用户全部取消
+              blockData.status = 'cancelled';
+              deferred.resolve();
+            }
+          }
+        }),
+      );
+    }
+    return deferred.promise;
+  }
+
+  /**
+   * Cancel an ongoing apply operation
+   */
+  cancelApply(relativePath: string): void {
+    const blockData = this.getCodeBlock(relativePath);
+    if (blockData && (blockData.status === 'generating' || blockData.status === 'pending')) {
+      if (this.activePreviewer) {
+        this.activePreviewer.getNode()?.livePreviewDiffDecorationModel.discardUnProcessed();
+        this.activePreviewer.dispose();
+      }
+      blockData.status = 'cancelled';
+      this.updateCodeBlock(blockData);
+    }
+  }
+
+  cancelAllApply(): void {
+    this.codeBlockMapObservable.get().forEach((blockData) => {
+      if (blockData.status === 'generating' || blockData.status === 'pending') {
+        this.cancelApply(blockData.relativePath);
+      }
+    });
+  }
+
+  disposeApplyForMessage(messageId: string): void {
+    this.codeBlockMapObservable.get().forEach((blockData) => {
+      if (blockData.id.endsWith(':' + messageId)) {
+        if (blockData.status === 'generating') {
+          this.cancelApply(blockData.relativePath);
+        }
+        this.codeBlockMapObservable.get().delete(blockData.id);
+      }
+    });
+  }
+
+  revealApplyPosition(blockId: string): void {
+    const blockData = this.codeBlockMapObservable.get().get(blockId);
+    if (blockData) {
+      const hunkInfo = blockData.applyResult?.diff.split('\n').find((line) => line.startsWith('@@'));
+      let startLine = 0;
+      let endLine = 0;
+      if (hunkInfo) {
+        // 取改动后的区间
+        const [, , , start, end] = hunkInfo.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/)!;
+        startLine = parseInt(start, 10) - 1;
+        endLine = parseInt(end, 10) - 1;
+      }
+      this.editorService.open(URI.file(path.join(this.appConfig.workspaceDir, blockData.relativePath)));
+      const editor = this.editorService.currentEditor;
+      if (editor) {
+        editor.setSelection(new Selection(startLine, 0, endLine, 0));
+      }
+    }
+  }
+
+  protected abstract doApply(
+    relativePath: string,
+    newContent: string,
+    instructions?: string,
+  ): Promise<{ diff: string; diagnosticInfos: IMarker[] } | undefined>;
+
+  protected generateBlockId(absoluteOrRelativePath: string, messageId?: string): string {
+    if (!absoluteOrRelativePath.startsWith('/')) {
+      absoluteOrRelativePath = path.join(this.appConfig.workspaceDir, absoluteOrRelativePath);
+    }
+    const sessionId = this.chatInternalService.sessionModel.sessionId;
+    const messages = this.chatInternalService.sessionModel.history.getMessages();
+    messageId = messageId || messages[messages.length - 1].id;
+    return `${sessionId}:${absoluteOrRelativePath}:${messageId || '-'}`;
+  }
+
+  protected getdiagnosticInfos(uri: string, ranges: Range[]) {
+    const markers = this.markerService.getManager().getMarkers({ resource: uri });
+    return markers.filter(
+      (marker) =>
+        marker.severity >= MarkerSeverity.Warning &&
+        ranges.some((range) => range.containsPosition(new Position(marker.startLineNumber, marker.startColumn))),
+    );
+  }
+}
+
+export interface CodeBlockData {
+  id: string;
+  initToolCallId?: string;
+  content: string;
+  relativePath: string;
+  status: CodeBlockStatus;
+  iterationCount: number;
+  createdAt: number;
+  applyResult?: {
+    diff: string;
+    diagnosticInfos: IMarker[];
+  };
+}
+
+export type CodeBlockStatus = 'generating' | 'pending' | 'success' | 'rejected' | 'failed' | 'cancelled';