feat(server): adapt gemini3.1 preview (#14583)

#### PR Dependency Tree


* **PR #14583** 👈

This tree was auto-generated by
[Charcoal](https://github.com/danerwilliams/charcoal)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Added Gemini 3.1 Pro Preview support (text, image, audio) and new
GPT‑5 variants as defaults; centralized persistent telemetry state for
more reliable client identity.

* **UX**
  * Improved model submenu placement in chat preferences.
* More robust mindmap parsing, preview, regeneration and replace
behavior.

* **Chores**
  * Bumped AI SDK and related dependencies.

* **Tests**
  * Expanded/updated tests and increased timeouts for flaky flows.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

tests/affine-cloud-copilot/e2e/chat-with/attachments.spec.ts

@@ -74,13 +74,13 @@ test.describe('AIChatWith/Attachments', () => {
           buffer: buffer2,
         },
       ],
-      `What is Attachment${randomStr1}? What is Attachment${randomStr2}?`
+      `Which animal is Attachment${randomStr1} and which animal is Attachment${randomStr2}? Answer with both attachment names.`
     );
 
     await utils.chatPanel.waitForHistory(page, [
       {
         role: 'user',
-        content: `What is Attachment${randomStr1}? What is Attachment${randomStr2}?`,
+        content: `Which animal is Attachment${randomStr1} and which animal is Attachment${randomStr2}? Answer with both attachment names.`,
       },
       {
         role: 'assistant',
@@ -89,14 +89,11 @@ test.describe('AIChatWith/Attachments', () => {
     ]);
 
     await expect(async () => {
-      const { content, message } =
-        await utils.chatPanel.getLatestAssistantMessage(page);
+      const { content } = await utils.chatPanel.getLatestAssistantMessage(page);
       expect(content).toMatch(new RegExp(`Attachment${randomStr1}`));
       expect(content).toMatch(new RegExp(`Attachment${randomStr2}`));
-      const footnoteCount = await message
-        .locator('affine-footnote-node')
-        .count();
-      expect(footnoteCount > 0 || /sources?/i.test(content)).toBe(true);
+      expect(content).toMatch(/cat/i);
+      expect(content).toMatch(/dog/i);
     }).toPass({ timeout: 20000 });
   });
 });

tests/affine-cloud-copilot/e2e/chat-with/edgeless-mindmap.spec.ts

@@ -4,21 +4,39 @@ import { expect } from '@playwright/test';
 
 import { test } from '../base/base-test';
 
+type MindmapSnapshot = {
+  childCount: number;
+  count: number;
+  id: string | null;
+};
+
 test.describe('AIChatWith/EdgelessMindMap', () => {
+  test.describe.configure({ timeout: 180000 });
+
   test.beforeEach(async ({ loggedInPage: page, utils }) => {
     await utils.testUtils.setupTestEnvironment(page);
     await utils.chatPanel.openChatPanel(page);
   });
 
-  test('should support replace mindmap with the regenerated one', async ({
+  test('should preview the regenerated mindmap before replacing it', async ({
     loggedInPage: page,
     utils,
   }) => {
     let id: string;
+    let originalChildCount: number;
     const { regenerateMindMap } = await utils.editor.askAIWithEdgeless(
       page,
       async () => {
         id = await utils.editor.createMindmap(page);
+        originalChildCount = await page.evaluate(mindmapId => {
+          const edgelessBlock = document.querySelector(
+            'affine-edgeless-root'
+          ) as EdgelessRootBlockComponent;
+          const mindmap = edgelessBlock.gfx.getElementById(mindmapId) as {
+            tree: { children?: unknown[] };
+          } | null;
+          return mindmap?.tree.children?.length ?? 0;
+        }, id);
       },
       async () => {
         const { id: rootId } = await utils.editor.getMindMapNode(
@@ -30,22 +48,134 @@ test.describe('AIChatWith/EdgelessMindMap', () => {
       }
     );
 
-    const { answer } = await regenerateMindMap();
-    await expect(answer.locator('mini-mindmap-preview')).toBeVisible();
-    const replace = answer.getByTestId('answer-replace');
-    await replace.click();
+    const { answer, responses } = await regenerateMindMap();
+    expect(responses).toEqual(new Set(['replace-selection']));
+    await expect
+      .poll(
+        async () => {
+          return answer
+            .locator('mini-mindmap-preview')
+            .evaluate(async preview => {
+              const walk = (root: ParentNode): Element[] => {
+                const results: Element[] = [];
 
-    // Expect original mindmap to be replaced
-    const mindmaps = await page.evaluate(() => {
+                for (const element of root.querySelectorAll('*')) {
+                  results.push(element);
+                  if (element.shadowRoot) {
+                    results.push(...walk(element.shadowRoot));
+                  }
+                }
+
+                return results;
+              };
+
+              await customElements.whenDefined('mini-mindmap-preview');
+
+              const previewElement =
+                preview instanceof HTMLElement
+                  ? (preview as HTMLElement & {
+                      updateComplete?: Promise<unknown>;
+                    })
+                  : null;
+
+              await previewElement?.updateComplete;
+              await new Promise(resolve =>
+                requestAnimationFrame(() => resolve(null))
+              );
+
+              const shadowRoot = previewElement?.shadowRoot ?? null;
+              const descendants = walk(shadowRoot ?? preview);
+              const surface = descendants.find(
+                element =>
+                  element instanceof HTMLElement &&
+                  element.classList.contains('affine-mini-mindmap-surface')
+              ) as HTMLElement | undefined;
+              const surfaceRect = surface?.getBoundingClientRect();
+
+              return {
+                hasShadowRoot: !!shadowRoot,
+                hasRootBlock: descendants.some(
+                  element =>
+                    element.tagName.toLowerCase() === 'mini-mindmap-root-block'
+                ),
+                hasSurfaceBlock: descendants.some(
+                  element =>
+                    element.tagName.toLowerCase() ===
+                    'mini-mindmap-surface-block'
+                ),
+                surfaceReady:
+                  !!surface &&
+                  (surfaceRect?.width ?? 0) > 0 &&
+                  (surfaceRect?.height ?? 0) > 0,
+              };
+            });
+        },
+        { timeout: 15_000 }
+      )
+      .toEqual({
+        hasShadowRoot: true,
+        hasRootBlock: true,
+        hasSurfaceBlock: true,
+        surfaceReady: true,
+      });
+    const replace = answer.getByTestId('answer-replace');
+    await expect(replace).toBeVisible();
+    await replace.click({ force: true });
+
+    await expect
+      .poll(
+        async () => {
+          return page.evaluate<MindmapSnapshot>(() => {
+            const edgelessBlock = document.querySelector(
+              'affine-edgeless-root'
+            ) as EdgelessRootBlockComponent;
+            const mindmaps = edgelessBlock?.gfx.gfxElements.filter(
+              (el: GfxModel) => 'type' in el && el.type === 'mindmap'
+            ) as unknown as Array<{
+              id: string;
+              tree: {
+                children?: unknown[];
+                element: { text?: { toString(): string } };
+              };
+            }>;
+
+            const mindmap = mindmaps?.[0];
+            return {
+              count: mindmaps?.length ?? 0,
+              id: mindmap?.id ?? null,
+              childCount: mindmap?.tree.children?.length ?? 0,
+            };
+          });
+        },
+        { timeout: 15_000 }
+      )
+      .toMatchObject({
+        count: 1,
+      });
+
+    const replacedMindmap = await page.evaluate<MindmapSnapshot>(() => {
       const edgelessBlock = document.querySelector(
         'affine-edgeless-root'
       ) as EdgelessRootBlockComponent;
-      const mindmaps = edgelessBlock?.gfx.gfxElements
-        .filter((el: GfxModel) => 'type' in el && el.type === 'mindmap')
-        .map((el: GfxModel) => el.id);
-      return mindmaps;
+      const mindmaps = edgelessBlock?.gfx.gfxElements.filter(
+        (el: GfxModel) => 'type' in el && el.type === 'mindmap'
+      ) as unknown as Array<{
+        id: string;
+        tree: {
+          children?: unknown[];
+          element: { text?: { toString(): string } };
+        };
+      }>;
+      const mindmap = mindmaps?.[0];
+
+      return {
+        count: mindmaps?.length ?? 0,
+        id: mindmap?.id ?? null,
+        childCount: mindmap?.tree.children?.length ?? 0,
+      };
     });
-    expect(mindmaps).toHaveLength(1);
-    expect(mindmaps?.[0]).not.toBe(id!);
+
+    expect(replacedMindmap.childCount).toBeGreaterThan(originalChildCount!);
+    expect(replacedMindmap.childCount).toBeGreaterThan(0);
   });
 });