snapshot of https://github.com/toeverything/AFFiNE.git (canary, 2026-09-16; blobs > 131072B omitted)

tests/affine-cloud-copilot/e2e/ai-action/brainstorm-ideas-with-mind-map.spec.ts

@@ -0,0 +1,53 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/BrainstormIdeasWithMindMap', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate a mind map for the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { brainstormMindMap } = await utils.editor.askAIWithText(
+      page,
+      'Panda'
+    );
+    const { answer, responses } = await brainstormMindMap();
+    await expect(answer.locator('mini-mindmap-preview')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate a mind map for the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { brainstormMindMap } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(page, 'Panda');
+      }
+    );
+    const { answer, responses } = await brainstormMindMap();
+    await expect(answer.locator('mini-mindmap-preview')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate a mind map for the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { brainstormMindMap } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(page, 'Panda');
+      }
+    );
+    const { answer, responses } = await brainstormMindMap();
+    await expect(answer.locator('mini-mindmap-preview')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/change-tone.spec.ts

@@ -0,0 +1,87 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/ChangeTone', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support changing the tone of the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { changeTone } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a great note-taking app'
+    );
+    const { answer, responses } = await changeTone('informal');
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support changing the tone of the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { changeTone } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a great note-taking app'
+        );
+      }
+    );
+
+    const { answer, responses } = await changeTone('informal');
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support changing the tone of the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { changeTone } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a great note-taking app'
+        );
+      }
+    );
+
+    const { answer, responses } = await changeTone('informal');
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { changeTone } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a great note-taking app'
+    );
+    const { answer } = await changeTone('informal');
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Change tone/);
+    await expect(actionName).toHaveText(/Change tone/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/check-code-error.spec.ts

@@ -0,0 +1,55 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/CheckCodeError', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support check code error', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { checkCodeError } = await utils.editor.askAIWithCode(
+      page,
+      'console.log("Hello,World!"',
+      'javascript'
+    );
+    const { answer, responses } = await checkCodeError();
+    const answerText = await answer.innerText();
+    expect(answerText).toMatch(/syntax|parenthesis|unexpected|missing/i);
+    expect(answerText).not.toMatch(/No syntax errors were found/i);
+    await expect(responses).toEqual(
+      new Set(['insert-below', 'replace-selection'])
+    );
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { checkCodeError } = await utils.editor.askAIWithCode(
+      page,
+      'consloe.log("Hello,World!");',
+      'javascript'
+    );
+    const { answer } = await checkCodeError();
+    const insert = answer.getByTestId('answer-insert-below');
+    await insert.click();
+    await utils.chatPanel.waitForHistory(page, [{ role: 'action' }]);
+    const {
+      message,
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(
+      message.getByTestId('original-text').locator('affine-code')
+    ).toBeVisible();
+    await expect(panelAnswer).toHaveText(/console/);
+    await expect(prompt).toHaveText(/Check the code error of the follow code/);
+    await expect(actionName).toHaveText(/Check code error/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/continue-with-ai.spec.ts

@@ -0,0 +1,20 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/ContinueWithAI', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+  });
+
+  test('should support continue in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { continueWithAi } = await utils.editor.askAIWithText(page, 'Apple');
+    await continueWithAi();
+    const chatPanelInput = await page.getByTestId('chat-panel-input-container');
+    const quote = await chatPanelInput.getByTestId('chat-selection-quote');
+    await expect(quote).toHaveText(/Apple/, { timeout: 10000 });
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/continue-writing.spec.ts

@@ -0,0 +1,92 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/ContinueWriting', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support continue writing the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    await page.setViewportSize({ width: 1280, height: 2000 });
+    const { continueWriting } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await continueWriting();
+    await expect(answer).toHaveText(/,*/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support continue writing the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { continueWriting } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+
+    const { answer, responses } = await continueWriting();
+    await expect(answer).toHaveText(/,*/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support continue writing the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { continueWriting } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+
+    const { answer, responses } = await continueWriting();
+    await expect(answer).toHaveText(/,*/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { continueWriting } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await continueWriting();
+    const insert = answer.getByTestId('answer-insert-below');
+    await insert.click();
+    await utils.chatPanel.waitForHistory(
+      page,
+      [
+        {
+          role: 'action',
+        },
+      ],
+      10000
+    );
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/,*/);
+    await expect(prompt).toHaveText(/Continue the following text/);
+    await expect(actionName).toHaveText(/Continue writing/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/expand-mindmap-node.spec.ts

@@ -0,0 +1,38 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('expand mindmap node', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should expand the mindmap node', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    let id: string;
+    const { expandMindMapNode } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        id = await utils.editor.createMindmap(page);
+      },
+      async () => {
+        // Select the first child in the mindmap
+        const { id: childId } = await utils.editor.getMindMapNode(
+          page,
+          id!,
+          [0, 0]
+        );
+        await utils.editor.selectElementInEdgeless(page, [childId]);
+      }
+    );
+    await expandMindMapNode();
+    // Child node should be expanded
+    await expect(async () => {
+      const newChild = await utils.editor.getMindMapNode(page, id!, [0, 0, 0]);
+      expect(newChild).toBeDefined();
+    }).toPass({ timeout: 60000 });
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/explain-code.spec.ts

@@ -0,0 +1,47 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/ExplainCode', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support explain code', async ({ loggedInPage: page, utils }) => {
+    const { explainCode } = await utils.editor.askAIWithCode(
+      page,
+      'console.log("Hello, World!");',
+      'javascript'
+    );
+    const { answer } = await explainCode();
+    await expect(answer).toContainText(/(console\.log|Hello,\s*World)/i);
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { explainCode } = await utils.editor.askAIWithCode(
+      page,
+      'console.log("Hello, World!");',
+      'javascript'
+    );
+    const { answer } = await explainCode();
+    const insert = answer.getByTestId('answer-insert-below');
+    await insert.click();
+    await utils.chatPanel.waitForHistory(page, [{ role: 'action' }]);
+    const {
+      message,
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(
+      message.getByTestId('original-text').locator('affine-code')
+    ).toBeVisible();
+    await expect(panelAnswer).toHaveText(/console.log/);
+    await expect(prompt).toHaveText(/Analyze and explain the follow code/);
+    await expect(actionName).toHaveText(/Explain this code/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/explain-selection.spec.ts

@@ -0,0 +1,87 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/ExplainSelection', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support explaining the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { explainSelection } = await utils.editor.askAIWithText(
+      page,
+      'LLM(AI)'
+    );
+    const { answer, responses } = await explainSelection();
+    await expect(answer).toHaveText(
+      /Large Language Model|LLM|artificial intelligence/i,
+      { timeout: 20000 }
+    );
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support explaining the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { explainSelection } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(page, 'LLM(AI)');
+      }
+    );
+
+    const { answer, responses } = await explainSelection();
+    await expect(answer).toHaveText(
+      /Large Language Model|LLM|artificial intelligence/i,
+      { timeout: 20000 }
+    );
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support explaining the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { explainSelection } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(page, 'LLM(AI)');
+      }
+    );
+
+    const { answer, responses } = await explainSelection();
+    await expect(answer).toHaveText(
+      /Large Language Model|LLM|artificial intelligence/i,
+      { timeout: 20000 }
+    );
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { explainSelection } = await utils.editor.askAIWithText(page, 'LLM');
+    const { answer } = await explainSelection();
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/Large Language Model/);
+    await expect(prompt).toHaveText(/Analyze and explain the follow text/);
+    await expect(actionName).toHaveText(/Explain this/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/find-actions.spec.ts

@@ -0,0 +1,146 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/FindActions', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should find actions for selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { findActions } = await utils.editor.askAIWithText(
+      page,
+      `Choose a Booking Platform
+Enter Travel Details
+Compare and Select Flights`
+    );
+    const { answer, responses } = await findActions();
+    const todos = await answer.locator('affine-list').all();
+
+    const expectedTexts = [
+      /Choose a Booking Platform/i,
+      /Enter Travel Details/i,
+      /Compare and Select Flights/i,
+    ];
+
+    await Promise.all(
+      todos.map(async (todo, index) => {
+        await expect(
+          todo.locator('.affine-list-block__todo-prefix')
+        ).toBeVisible();
+        await expect(todo).toHaveText(expectedTexts[index]);
+      })
+    );
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should find actions for selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { findActions } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'Choose a Booking Platform'
+        );
+      }
+    );
+
+    const { answer, responses } = await findActions();
+    const todos = await answer.locator('affine-list').all();
+    const expectedTexts = [
+      /Choose a Booking Platform/i,
+      /Enter Travel Details/i,
+      /Compare and Select Flights/i,
+    ];
+    await Promise.all(
+      todos.map(async (todo, index) => {
+        await expect(
+          todo.locator('.affine-list-block__todo-prefix')
+        ).toBeVisible();
+        await expect(todo).toHaveText(expectedTexts[index]);
+      })
+    );
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should find actions for selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { findActions } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'Choose a Booking Platform'
+        );
+      }
+    );
+
+    const { answer, responses } = await findActions();
+    const todos = await answer.locator('affine-list').all();
+    const expectedTexts = [
+      /Choose a Booking Platform/i,
+      /Enter Travel Details/i,
+      /Compare and Select Flights/i,
+    ];
+    await Promise.all(
+      todos.map(async (todo, index) => {
+        await expect(
+          todo.locator('.affine-list-block__todo-prefix')
+        ).toBeVisible();
+        await expect(todo).toHaveText(expectedTexts[index]);
+      })
+    );
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { findActions } = await utils.editor.askAIWithText(
+      page,
+      `Choose a Booking Platform
+Enter Travel Details
+Compare and Select Flights`
+    );
+    const { answer } = await findActions();
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    const todos = await panelAnswer.locator('affine-list').all();
+
+    const expectedTexts = [
+      /Choose a Booking Platform/i,
+      /Enter Travel Details/i,
+      /Compare and Select Flights/i,
+    ];
+    await Promise.all(
+      todos.map(async (todo, index) => {
+        await expect(
+          todo.locator('.affine-list-block__todo-prefix')
+        ).toBeVisible();
+        await expect(todo).toHaveText(expectedTexts[index]);
+      })
+    );
+    await expect(prompt).toHaveText(/Find action items of the follow text/);
+    await expect(actionName).toHaveText(/Find action items from it/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/fix-grammar.spec.ts

@@ -0,0 +1,84 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/FixGrammar', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support fixing grammatical errors in the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { fixGrammar } = await utils.editor.askAIWithText(
+      page,
+      'I is a student'
+    );
+    const { answer, responses } = await fixGrammar();
+    await expect(answer).toHaveText(/I am a student/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support fixing grammatical errors in the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { fixGrammar } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(page, 'I is a student');
+      }
+    );
+
+    const { answer, responses } = await fixGrammar();
+    await expect(answer).toHaveText(/I am a student/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support fixing grammatical errors in the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { fixGrammar } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(page, 'I is a student');
+      }
+    );
+
+    const { answer, responses } = await fixGrammar();
+    await expect(answer).toHaveText(/I am a student/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { fixGrammar } = await utils.editor.askAIWithText(
+      page,
+      'I is a student'
+    );
+    const { answer } = await fixGrammar();
+    await expect(answer).toHaveText(/I am a student/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/I am a student/);
+    await expect(prompt).toHaveText(
+      /Improve the grammar of the following text/
+    );
+    await expect(actionName).toHaveText(/Improve grammar for it/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/fix-spelling.spec.ts

@@ -0,0 +1,78 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/FixSpelling', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support fixing spelling errors in the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { fixSpelling } = await utils.editor.askAIWithText(page, 'Appel');
+    const { answer, responses } = await fixSpelling();
+    await expect(answer).toHaveText(/Apple/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support fixing spelling errors in the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { fixSpelling } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(page, 'Appel');
+      }
+    );
+
+    const { answer, responses } = await fixSpelling();
+    await expect(answer).toHaveText(/Apple/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support fixing spelling errors in the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { fixSpelling } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(page, 'Appel');
+      }
+    );
+
+    const { answer, responses } = await fixSpelling();
+    await expect(answer).toHaveText(/Apple/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { fixSpelling } = await utils.editor.askAIWithText(page, 'Appel');
+    const { answer } = await fixSpelling();
+    await expect(answer).toHaveText(/Apple/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/Apple/);
+    await expect(prompt).toHaveText(
+      /Correct the spelling of the following text/
+    );
+    await expect(actionName).toHaveText(/Fix spelling for it/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/generate-an-image-with-text.spec.ts

@@ -0,0 +1,90 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/GenerateAnImageWithText', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate an image for the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateImage } = await utils.editor.askAIWithText(page, 'Panda');
+    const { answer, responses } = await generateImage();
+    await expect(answer.getByTestId('ai-answer-image')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate an image for the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateImage } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(page, 'Panda');
+      }
+    );
+    const { answer, responses } = await generateImage();
+    await expect(answer.getByTestId('ai-answer-image')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate an image for the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateImage } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(page, 'Panda');
+      }
+    );
+    const { answer, responses } = await generateImage();
+    await expect(answer.getByTestId('ai-answer-image')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate an image for the selected shape in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateImage } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createShape(page, 'HelloWorld');
+      }
+    );
+    const { answer, responses } = await generateImage();
+    await expect(answer.getByTestId('ai-answer-image')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateImage } = await utils.editor.askAIWithText(page, 'Panda');
+    const { answer } = await generateImage();
+    const insert = answer.getByTestId('answer-insert-below');
+    await insert.click();
+    await page.waitForSelector('.affine-image-container');
+    await page.reload();
+
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+
+    const { answer: panelAnswer, actionName } =
+      await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(
+      panelAnswer.getByTestId('generated-image').locator('img')
+    ).toBeVisible();
+    await expect(actionName).toHaveText(/image/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/generate-headings.spec.ts

@@ -0,0 +1,108 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/GenerateHeadings', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate headings for selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateHeadings } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await generateHeadings();
+    await Promise.race([
+      answer.locator('h1').isVisible(),
+      answer.locator('h2').isVisible(),
+      answer.locator('h3').isVisible(),
+    ]);
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-above', 'replace-selection']));
+  });
+
+  test('should generate headings for selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateHeadings } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+
+    const { answer, responses } = await generateHeadings();
+    await Promise.race([
+      answer.locator('h1').isVisible(),
+      answer.locator('h2').isVisible(),
+      answer.locator('h3').isVisible(),
+    ]);
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate headings for selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateHeadings } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+
+    const { answer, responses } = await generateHeadings();
+    await Promise.race([
+      answer.locator('h1').isVisible(),
+      answer.locator('h2').isVisible(),
+      answer.locator('h3').isVisible(),
+    ]);
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateHeadings } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await generateHeadings();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await Promise.race([
+      panelAnswer.locator('h1').isVisible(),
+      panelAnswer.locator('h2').isVisible(),
+      panelAnswer.locator('h3').isVisible(),
+    ]);
+    await expect(prompt).toHaveText(/Create headings of the follow text/);
+    await expect(actionName).toHaveText(/Create headings/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/generate-outline.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/GenerateOutline', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate outline for selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateOutline } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await generateOutline();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should generate outline for selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateOutline } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await generateOutline();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate outline for selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateOutline } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await generateOutline();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generateOutline } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await generateOutline();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Write an outline about this/);
+    await expect(actionName).toHaveText(/Write outline/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/generate-presentation.spec.ts

@@ -0,0 +1,61 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/GeneratePresentation', () => {
+  test.describe.configure({ timeout: 240000 });
+
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate a presentation for the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generatePresentation } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await generatePresentation();
+    await expect(answer.locator('ai-slides-renderer')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate a presentation for the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generatePresentation } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await generatePresentation();
+    await expect(answer.locator('ai-slides-renderer')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate a presentation for the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { generatePresentation } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await generatePresentation();
+    await expect(answer.locator('ai-slides-renderer')).toBeVisible();
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/improve-writing.spec.ts

@@ -0,0 +1,80 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/ImproveWriting', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support improving the writing of the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { improveWriting } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is so smart'
+    );
+    const { answer, responses } = await improveWriting();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support improving the writing of the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { improveWriting } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(page, 'AFFiNE is so smart');
+      }
+    );
+    const { answer, responses } = await improveWriting();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support improving the writing of the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { improveWriting } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(page, 'AFFiNE is so smart');
+      }
+    );
+    const { answer, responses } = await improveWriting();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { improveWriting } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is so smart'
+    );
+    const { answer } = await improveWriting();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Improve the follow text/);
+    await expect(actionName).toHaveText(/Improve writing for it/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/make-it-longer.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/MakeItLonger', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support making the selected content longer', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItLonger } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await makeItLonger();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support making the selected text block longer in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItLonger } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await makeItLonger();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support making the selected note block longer in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItLonger } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await makeItLonger();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItLonger } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await makeItLonger();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Expand the following text/);
+    await expect(actionName).toHaveText(/Make it longer/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/make-it-real.spec.ts

@@ -0,0 +1,91 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/MakeItReal', () => {
+  test.describe.configure({ timeout: 180000 });
+
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support making the selected content to real', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItReal } = await utils.editor.askAIWithText(page, 'Hello');
+    const { answer, responses } = await makeItReal();
+    await expect(answer.locator('iframe')).toBeVisible({ timeout: 30000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support making the selected text block to real in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItReal } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(page, 'Hello');
+      }
+    );
+    const { answer, responses } = await makeItReal();
+    await expect(answer.locator('iframe')).toBeVisible({ timeout: 30000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support making the selected note block to real in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItReal } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(page, 'Hello');
+      }
+    );
+    const { answer, responses } = await makeItReal();
+    await expect(answer.locator('iframe')).toBeVisible({ timeout: 30000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support making the selected element to real in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItReal } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createShape(page, 'HelloWorld');
+      }
+    );
+
+    const { answer, responses } = await makeItReal();
+    await expect(answer.locator('iframe')).toBeVisible({ timeout: 30000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItReal } = await utils.editor.askAIWithText(page, 'Hello');
+    const { answer } = await makeItReal();
+    const insert = answer.getByTestId('answer-insert-below');
+    await insert.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer.locator('affine-code')).toBeVisible();
+    await expect(prompt).toHaveText(/Write a web page of follow text/);
+    await expect(actionName).toHaveText(/Make it real with text/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/make-it-shorter.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/MakeItShorter', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support making the selected content shorter', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItShorter } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await makeItShorter();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support making the selected text block shorter in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItShorter } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await makeItShorter();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support making the selected note block shorter in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItShorter } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await makeItShorter();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { makeItShorter } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await makeItShorter();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Shorten the follow text/);
+    await expect(actionName).toHaveText(/Make it shorter/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/regenerate-mindmap.spec.ts

@@ -0,0 +1,35 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/RegenerateMindMap', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support regenerate the mind map for mindmap root', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    let id: string;
+    const { regenerateMindMap } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        id = await utils.editor.createMindmap(page);
+      },
+      async () => {
+        const { id: rootId } = await utils.editor.getMindMapNode(
+          page,
+          id!,
+          [0]
+        );
+        await utils.editor.selectElementInEdgeless(page, [rootId]);
+      }
+    );
+
+    const { answer, responses } = await regenerateMindMap();
+    await expect(answer.locator('mini-mindmap-preview')).toBeVisible();
+    expect(responses).toEqual(new Set(['replace-selection']));
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/summarize.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/Summarize', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support summarizing the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { summarize } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await summarize();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support summarizing the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { summarize } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await summarize();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support summarizing the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { summarize } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await summarize();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { summarize } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await summarize();
+    await expect(answer).toHaveText(/AFFiNE/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Summary the follow text/);
+    await expect(actionName).toHaveText(/Summary/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/translate.spec.ts

@@ -0,0 +1,74 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/Translate', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should support translating the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { translate } = await utils.editor.askAIWithText(page, 'Apple');
+    const { answer, responses } = await translate('Simplified Chinese');
+    await expect(answer).toHaveText(/苹果/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support translating the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { translate } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(page, 'Apple');
+      }
+    );
+    const { answer, responses } = await translate('Simplified Chinese');
+    await expect(answer).toHaveText(/苹果/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support translating the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { translate } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(page, 'Apple');
+      }
+    );
+    const { answer, responses } = await translate('Simplified Chinese');
+    await expect(answer).toHaveText(/苹果/, { timeout: 10000 });
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { translate } = await utils.editor.askAIWithText(page, 'Apple');
+    const { answer } = await translate('Simplified Chinese');
+    await expect(answer).toHaveText(/苹果/, { timeout: 10000 });
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/苹果/);
+    await expect(prompt).toHaveText(/Translate/);
+    await expect(actionName).toHaveText(/Translate/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/write-an-article.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/WriteAnArticleAboutThis', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate an article for the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeArticle } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await writeArticle();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support writing an article for the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeArticle } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await writeArticle();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support writing an article for the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeArticle } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await writeArticle();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeArticle } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await writeArticle();
+    await expect(answer).toHaveText(/AFFiNE/);
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Write an article about this/);
+    await expect(actionName).toHaveText(/Write an article about this/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/write-an-blog.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/WriteAnBlogPostAboutThis', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate an blog post for the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeBlogPost } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await writeBlogPost();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should support writing an blog post for the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeBlogPost } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await writeBlogPost();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should support writing an blog post for the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeBlogPost } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await writeBlogPost();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeBlogPost } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await writeBlogPost();
+    await expect(answer).toHaveText(/AFFiNE/);
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Write a blog post about this/);
+    await expect(actionName).toHaveText(/Write a blog post about this/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/write-an-poem.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/WriteAnPoemAboutThis', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate an poem for the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writePoem } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await writePoem();
+    await expect(answer.locator('text-renderer')).toContainText(/\S/);
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should generate an poem for the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writePoem } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await writePoem();
+    await expect(answer.locator('text-renderer')).toContainText(/\S/);
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate an poem for the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writePoem } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await writePoem();
+    await expect(answer.locator('text-renderer')).toContainText(/\S/);
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writePoem } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await writePoem();
+    await expect(answer).toHaveText(/AFFiNE/);
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Write a poem about this/);
+    await expect(actionName).toHaveText(/Write a poem about this/);
+  });
+});

tests/affine-cloud-copilot/e2e/ai-action/write-an-tweet.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from '@playwright/test';
+
+import { test } from '../base/base-test';
+
+test.describe('AIAction/WriteAnTweetAboutThis', () => {
+  test.beforeEach(async ({ loggedInPage: page, utils }) => {
+    await utils.testUtils.setupTestEnvironment(page);
+    await utils.chatPanel.openChatPanel(page);
+  });
+
+  test('should generate an tweet for the selected content', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeTwitterPost } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer, responses } = await writeTwitterPost();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below', 'replace-selection']));
+  });
+
+  test('should generate an tweet for the selected text block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeTwitterPost } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessText(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await writeTwitterPost();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test('should generate an tweet for the selected note block in edgeless', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeTwitterPost } = await utils.editor.askAIWithEdgeless(
+      page,
+      async () => {
+        await utils.editor.createEdgelessNote(
+          page,
+          'AFFiNE is a workspace with fully merged docs'
+        );
+      }
+    );
+    const { answer, responses } = await writeTwitterPost();
+    await expect(answer).toHaveText(/AFFiNE/);
+    expect(responses).toEqual(new Set(['insert-below']));
+  });
+
+  test.skip('should show chat history in chat panel', async ({
+    loggedInPage: page,
+    utils,
+  }) => {
+    const { writeTwitterPost } = await utils.editor.askAIWithText(
+      page,
+      'AFFiNE is a workspace with fully merged docs'
+    );
+    const { answer } = await writeTwitterPost();
+    await expect(answer).toHaveText(/AFFiNE/);
+    const replace = answer.getByTestId('answer-replace');
+    await replace.click();
+    await utils.chatPanel.waitForHistory(page, [
+      {
+        role: 'action',
+      },
+    ]);
+    const {
+      answer: panelAnswer,
+      prompt,
+      actionName,
+    } = await utils.chatPanel.getLatestAIActionMessage(page);
+    await expect(panelAnswer).toHaveText(/AFFiNE/);
+    await expect(prompt).toHaveText(/Write a twitter about this/);
+    await expect(actionName).toHaveText(/Write a twitter about this/);
+  });
+});