wtagent 0.4.0 → 1.0.0

package/src/browser/chatgpt-dom.js

@@ -0,0 +1,179 @@
+// All supported ChatGPT DOM shapes live here. Text and localized headings must
+// never supply a role, message identity, or ordering key.
+const legacyUser = '[data-message-author-role="user"]';
+const legacyAssistant = '[data-message-author-role="assistant"]:not([id^="request-placeholder-"])';
+const modern = (role) => `[data-chatgpt-search-unit-key$=":${role}"]:not([id^="request-placeholder-"]):not(:has([data-message-author-role])):not([data-message-author-role] *)`;
+export const CHATGPT_DOM = {
+  user: { legacy: legacyUser, modern: modern("user") },
+  assistant: { legacy: legacyAssistant, modern: modern("assistant") },
+  conversationLegacy: '[data-message-author-role="user"], [data-message-author-role="assistant"]',
+  composers: [
+    { name: "prompt-textarea", selector: "#prompt-textarea" },
+    { name: "markdown-composer", selector: '[data-composer-markdown][contenteditable="true"][role="textbox"]' },
+    { name: "message-textarea-en", selector: 'textarea[placeholder*="Message" i]' },
+    { name: "message-textarea-zh", selector: 'textarea[placeholder*="消息"]' },
+    { name: "lexical-composer", selector: 'div[contenteditable="true"][data-lexical-editor="true"]' },
+    { name: "main-contenteditable", selector: 'main div[contenteditable="true"]' },
+  ],
+  send: '[data-testid="send-button"]',
+  stop: '[data-testid="stop-button"]',
+};
+CHATGPT_DOM.messages = [legacyUser, legacyAssistant, modern("user"), modern("assistant")].join(", ");
+
+// This function is serialized into the page. Keep it self-contained, and pass
+// the registry explicitly when requesting a capability sample.
+export function readChatGPTDom(input) {
+  const options = input?.selector ? input : null;
+  const elements = typeof input === "string" || options
+    ? [...document.querySelectorAll(options?.selector ?? input)]
+    : Array.isArray(input) ? input : [input];
+  const structure = { legacy: 0, modern: 0, unknown: 0, ambiguousIds: 0 };
+  const entries = elements.map((element, domIndex) => {
+    const legacyRole = element.getAttribute("data-message-author-role");
+    const key = element.getAttribute("data-chatgpt-search-unit-key") ?? "";
+    const modern = key.match(/^fallback-turn-(\d+):(\d+):(user|assistant)$/);
+    const role = legacyRole ?? modern?.[3] ?? null;
+    structure[legacyRole ? "legacy" : modern ? "modern" : "unknown"] += 1;
+    const wrapper = element.closest('[data-testid^="conversation-turn-"]');
+    const legacyTurn = wrapper?.getAttribute("data-testid")?.match(/^conversation-turn-(\d+)$/);
+    const messageIds = [...new Set((element.getAttribute("data-chatgpt-search-message-ids") ?? "").split(/\s+/).filter(Boolean))];
+    const legacyId = element.getAttribute("data-message-id");
+    if (legacyId == null && messageIds.length > 1) structure.ambiguousIds += 1;
+    const id = legacyId ?? (messageIds.length === 1 ? messageIds[0] : null);
+    // Thinking/tool blocks occupy positions too. Only the group and role define
+    // turn order; duplicate roles within a group are rejected by validation.
+    const turn = legacyTurn ? Number(legacyTurn[1])
+      : modern ? Number(modern[1]) * 2 + (role === "user" ? 1 : 2) : null;
+    let renderedText = element.innerText ?? element.textContent ?? "";
+    if (role === "assistant" && !renderedText.includes("<agent_response")) {
+      const codeTexts = [...element.querySelectorAll("pre code")].map((node) => node.innerText ?? node.textContent ?? "");
+      const envelope = codeTexts.find((text) => text.includes("<agent_response") && text.includes("</agent_response>"))
+        ?? codeTexts.find((text) => text.includes("<agent_response"));
+      const markdown = [...element.querySelectorAll('.markdown, [data-markdown-text-style="assistant-message"]')].at(-1);
+      if (envelope) renderedText = envelope;
+      else if (markdown) renderedText = markdown.innerText ?? markdown.textContent ?? "";
+    }
+    return { domIndex, role, id, turn, renderedText };
+  });
+  const snapshot = { url: globalThis.location?.href ?? null, entries, structure };
+  if (options?.registry) {
+    const visible = (element) => element.getClientRects().length > 0
+      && getComputedStyle(element).visibility !== "hidden";
+    const count = (selector) => [...document.querySelectorAll(selector)].filter(visible).length;
+    snapshot.capabilities = {
+      readyState: document.readyState,
+      composers: options.registry.composers.filter(({ selector }) => count(selector) > 0).map(({ name }) => name),
+      sendButton: count(options.registry.send) > 0,
+      stopButton: count(options.registry.stop) > 0,
+      placeholderCount: document.querySelectorAll('[id^="request-placeholder-"]').length,
+      // Unknown suffixes are evidence of a renderer change, not valid messages.
+      unknownSearchUnits: [...document.querySelectorAll('[data-chatgpt-search-unit-key]')]
+        .filter((element) => !/^fallback-turn-\d+:\d+:(user|assistant)$/.test(element.getAttribute("data-chatgpt-search-unit-key"))).length,
+    };
+  }
+  return snapshot;
+}
+
+// Deliberately excludes message text, IDs, composer content, and raw attributes.
+// This report may be collected even when screenshots/full HTML are disabled.
+export function summarizeChatGPTDom(snapshot) {
+  if (!snapshot || !Array.isArray(snapshot.entries)) return { status: "unavailable" };
+  const entries = snapshot.entries;
+  const issues = [];
+  const countMissing = (test) => entries.filter(test).length;
+  const missing = {
+    role: countMissing((entry) => !["user", "assistant"].includes(entry.role)),
+    id: countMissing((entry) => typeof entry.id !== "string" || !entry.id.trim()),
+    turn: countMissing((entry) => !Number.isSafeInteger(entry.turn) || entry.turn < 0),
+  };
+  for (const [field, count] of Object.entries(missing)) if (count) issues.push(`missing-${field}`);
+  const ids = entries.map((entry) => entry.id).filter(Boolean);
+  if (new Set(ids).size !== ids.length) issues.push("duplicate-message-id");
+  if (entries.some((entry, index) => index > 0 && entry.turn <= entries[index - 1].turn)) issues.push("non-monotonic-turns");
+  if (snapshot.structure?.ambiguousIds) issues.push("ambiguous-message-ids");
+  if (snapshot.capabilities?.unknownSearchUnits) issues.push("unknown-search-unit-format");
+  if (snapshot.capabilities && !snapshot.capabilities.composers.length) issues.push("composer-not-found");
+  return {
+    status: issues.length ? "incomplete" : entries.length ? "recognized" : "empty",
+    structure: snapshot.structure,
+    capabilities: snapshot.capabilities,
+    counts: { total: entries.length, user: countMissing((entry) => entry.role === "user"), assistant: countMissing((entry) => entry.role === "assistant") },
+    missing,
+    issues,
+  };
+}
+
+function parseConversationTurn(value) {
+  const match = String(value ?? "").match(/^conversation-turn-(\d+)$/);
+  return match ? Number.parseInt(match[1], 10) : null;
+}
+
+export async function readChatGPTMessageIdentity(message) {
+  if (await message.getAttribute("data-chatgpt-search-unit-key").catch(() => null)) {
+    const snapshot = await message.evaluate(readChatGPTDom).catch(() => null);
+    const entry = snapshot?.entries?.[0];
+    if (!entry || !["user", "assistant"].includes(entry.role)
+      || !entry.id || !Number.isSafeInteger(entry.turn) || entry.turn < 0) {
+      return { id: null, turn: null };
+    }
+    return { id: entry.id, turn: entry.turn };
+  }
+  const [id, turn] = await Promise.all([
+    message.getAttribute("data-message-id").catch(() => null),
+    readLegacyTurn(message),
+  ]);
+  return { id, turn };
+}
+
+async function readLegacyTurn(message) {
+  if (typeof message?.evaluate !== "function") {
+    return null;
+  }
+  const testId = await message.evaluate((element) => (
+    element.closest('[data-testid^="conversation-turn-"]')
+      ?.getAttribute("data-testid") ?? null
+  )).catch(() => null);
+  return parseConversationTurn(testId);
+}
+
+
+export async function readChatGPTAssistantText(message, hasCompleteAgentEnvelope) {
+  if (await message.getAttribute("data-chatgpt-search-unit-key").catch(() => null)) {
+    const snapshot = await message.evaluate(readChatGPTDom).catch(() => null);
+    return snapshot?.entries?.[0]?.renderedText ?? "";
+  }
+  // Read the whole assistant turn first. A long XML response can contain
+  // Markdown fences inside CDATA; ChatGPT then splits the rendered response
+  // into many <pre><code> nodes and the first node contains the opening tag
+  // but not the closing tag. The parent innerText keeps the complete envelope
+  // and avoids one CDP round trip per nested code block on every poll.
+  const fullText = await message.innerText().catch(() => "");
+  if (fullText.includes("<agent_response")) {
+    return fullText;
+  }
+
+  // Rare fallback for alternate renderers where the parent text omits code
+  // contents: prefer a complete code-block envelope, but retain a partial
+  // one so streaming progress remains visible until its closing tag arrives.
+  const codeBlocks = message.locator("pre code");
+  const codeBlockCount = await codeBlocks.count();
+  let partialEnvelope = "";
+  for (let index = 0; index < codeBlockCount; index += 1) {
+    const code = await codeBlocks.nth(index).innerText().catch(() => "");
+    if (hasCompleteAgentEnvelope(code)) {
+      return code;
+    }
+    if (!partialEnvelope && code.includes("<agent_response")) {
+      partialEnvelope = code;
+    }
+  }
+  if (partialEnvelope) {
+    return partialEnvelope;
+  }
+
+  const markdown = message.locator(".markdown");
+  if (await markdown.count()) {
+    return await markdown.last().innerText().catch(() => "");
+  }
+  return fullText;
+}

package/src/browser/chatgpt-web-adapter.js

@@ -14,12 +14,15 @@ import { isUsageLimitNotice } from "../shared/usage-limit.js";
 // base module.
 export { isConnectionLostError } from "./base-web-adapter.js";
 
-const CHATGPT_URL = "https://chatgpt.com/";
+import {
+  CHATGPT_DOM,
+  readChatGPTDom,
+  summarizeChatGPTDom,
+  readChatGPTMessageIdentity,
+  readChatGPTAssistantText,
+} from "./chatgpt-dom.js";
 
-function parseConversationTurn(value) {
-  const match = String(value ?? "").match(/^conversation-turn-(\d+)$/);
-  return match ? Number.parseInt(match[1], 10) : null;
-}
+const CHATGPT_URL = "https://chatgpt.com/";
 
 function normalizedConversationUrl(value) {
   try {
@@ -101,11 +104,46 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
       return kind;
     }
     const parsed = value instanceof URL ? value : new URL(value);
-    return /^\/c\/WEB:/.test(parsed.pathname)
+    return /^\/c\/(?:WEB:|local-chatgpt(?::|%3[aA]))/.test(parsed.pathname)
       ? "provisional"
       : "restorable";
   }
 
+  async startConversation(...args) {
+    try {
+      const result = await super.startConversation(...args);
+      await this.collectStructuralDiagnostics();
+      return result;
+    } catch (error) {
+      const diagnostic = await this.writeDiagnostics("conversation-start-failed", { stage: "conversation-start" }).catch(() => null);
+      if (diagnostic?.filename) {
+        error.details = { ...error.details, diagnosticFile: diagnostic.filename, dom: diagnostic.report.dom };
+      }
+      throw error;
+    }
+  }
+
+  hasStructuralDiagnostics() {
+    return true;
+  }
+
+  recordConversationNavigation(url) {
+    if (url === this.lastDiagnosticUrl) return;
+    this.lastDiagnosticUrl = url;
+    this.diagnosticRoutes ??= [];
+    this.diagnosticRoutes.push({ kind: this.classifyConversationUrl(url), at: Date.now() });
+    this.diagnosticRoutes = this.diagnosticRoutes.slice(-12);
+  }
+
+  async structuralDiagnostics() {
+    const snapshot = await this.page.evaluate(readChatGPTDom, {
+      selector: CHATGPT_DOM.messages, registry: CHATGPT_DOM,
+    });
+    const report = summarizeChatGPTDom(snapshot);
+    this.lastDomReport = report;
+    return report;
+  }
+
   pendingAttachmentLocators() {
     return [
       this.page.locator(
@@ -118,25 +156,19 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
   }
 
   composerLocators() {
-    return [
-      this.page.locator("#prompt-textarea"),
-      this.page.locator('textarea[placeholder*="Message" i]'),
-      this.page.locator('textarea[placeholder*="消息"]'),
-      this.page.locator('div[contenteditable="true"][data-lexical-editor="true"]'),
-      this.page.locator('main div[contenteditable="true"]'),
-    ];
+    return CHATGPT_DOM.composers.map(({ selector }) => this.page.locator(selector));
   }
 
   sendButtonLocators() {
     return [
-      this.page.locator('[data-testid="send-button"]'),
+      this.page.locator(CHATGPT_DOM.send),
       this.page.getByRole("button", { name: /send|发送/i }),
     ];
   }
 
   stopButtonLocators() {
     return [
-      this.page.locator('[data-testid="stop-button"]'),
+      this.page.locator(CHATGPT_DOM.stop),
       this.page.getByRole("button", {
         name: /stop generating|stop|停止生成|停止/i,
       }),
@@ -182,19 +214,32 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
     // keeps a failed request from being read as an envelope-less reply and
     // burned through the protocol-error retry loop; the turn instead sees "no
     // reply" and recovers with the continuation nudge.
-    return this.page.locator(
-      '[data-message-author-role="assistant"]:not([id^="request-placeholder-"])',
-    );
+    const legacy = this.page.locator(CHATGPT_DOM.assistant.legacy);
+    return legacy.or ? legacy.or(this.page.locator(CHATGPT_DOM.assistant.modern)) : legacy;
   }
 
   userMessages() {
-    return this.page.locator('[data-message-author-role="user"]');
+    const legacy = this.page.locator(CHATGPT_DOM.user.legacy);
+    return legacy.or ? legacy.or(this.page.locator(CHATGPT_DOM.user.modern)) : legacy;
+  }
+
+  async userMessageSnapshot() {
+    const messages = this.userMessages();
+    if (typeof messages.evaluateAll !== "function") {
+      return super.userMessageSnapshot();
+    }
+    // ChatGPT unmounts older turns as a long thread advances. count() followed
+    // by nth() can then wait for a vanished index until the send deadline, or
+    // combine one bubble's identity with another bubble's text.
+    return await messages.evaluateAll(readChatGPTDom).then((snapshot) => (
+      snapshot.entries.every((entry) => entry.role === "user" && entry.id && Number.isSafeInteger(entry.turn))
+        ? snapshot.entries : null
+    )).catch(() => null);
   }
 
   conversationMessages() {
-    return this.page.locator(
-      '[data-message-author-role="user"], [data-message-author-role="assistant"]',
-    );
+    const legacy = this.page.locator(CHATGPT_DOM.conversationLegacy);
+    return legacy.or ? legacy.or(this.page.locator(`${CHATGPT_DOM.user.modern}, ${CHATGPT_DOM.assistant.modern}`)) : legacy;
   }
 
   requiresOrderedConversationSnapshotForFreshSend() {
@@ -205,54 +250,9 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
     if (typeof this.page?.evaluate !== "function") {
       return null;
     }
-    return await this.page.evaluate(() => {
-      const entries = [
-        ...document.querySelectorAll(
-          '[data-message-author-role="user"], [data-message-author-role="assistant"]',
-        ),
-      ].filter((element) => {
-        const role = element.getAttribute("data-message-author-role");
-        return role === "user"
-          || (role === "assistant" && !element.id.startsWith("request-placeholder-"));
-      }).map((element, domIndex) => {
-        const role = element.getAttribute("data-message-author-role");
-        const wrapper = element.closest('[data-testid^="conversation-turn-"]');
-        const turnMatch = wrapper?.getAttribute("data-testid")
-          ?.match(/^conversation-turn-(\d+)$/);
-        let renderedText = element.innerText ?? element.textContent ?? "";
-        if (role === "assistant" && !renderedText.includes("<agent_response")) {
-          const codeTexts = [...element.querySelectorAll("pre code")]
-            .map((code) => code.innerText ?? code.textContent ?? "");
-          const completeEnvelope = codeTexts.find((text) => {
-            const start = text.trim().indexOf("<agent_response");
-            const end = text.trim().lastIndexOf("</agent_response>");
-            return start >= 0 && end >= start;
-          });
-          const partialEnvelope = codeTexts.find(
-            (text) => text.includes("<agent_response"),
-          );
-          if (completeEnvelope) {
-            renderedText = completeEnvelope;
-          } else if (partialEnvelope) {
-            renderedText = partialEnvelope;
-          } else {
-            const markdown = [...element.querySelectorAll(".markdown")];
-            if (markdown.length > 0) {
-              const last = markdown.at(-1);
-              renderedText = last.innerText ?? last.textContent ?? "";
-            }
-          }
-        }
-        return {
-          domIndex,
-          role,
-          id: element.getAttribute("data-message-id"),
-          turn: turnMatch ? Number.parseInt(turnMatch[1], 10) : null,
-          renderedText,
-        };
-      });
-      return { url: window.location.href, entries };
-    }).catch(() => null);
+    return await this.page.evaluate(readChatGPTDom,
+      CHATGPT_DOM.messages,
+    ).catch(() => null);
   }
 
   async assertRecoveredTurnTopology({
@@ -523,7 +523,19 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
     return found;
   }
 
-  async reconcilePendingOutbound({
+  async reconcilePendingOutbound(options = {}) {
+    try {
+      return await this.#reconcilePendingOutbound(options);
+    } catch (error) {
+      const diagnostic = await this.writeDiagnostics("pending-outbound-recovery-failed", { stage: "recovery" }).catch(() => null);
+      if (diagnostic?.filename) {
+        error.details = { ...error.details, diagnosticFile: diagnostic.filename, dom: diagnostic.report.dom };
+      }
+      throw error;
+    }
+  }
+
+  async #reconcilePendingOutbound({
     pendingOutbound = null,
     conversationTargetId = null,
     lastUserMessageId = null,
@@ -718,7 +730,7 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
             );
             if (!generationError && !usageLimit) {
               rawResponse = assistant.renderedText;
-              if (rawResponse.trim()) {
+              if (rawResponse.trim() || priorHandoff?.nativeImages?.length > 0) {
                 responseHash = createHash("sha256")
                   .update(rawResponse)
                   .digest("hex");
@@ -904,22 +916,7 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
   }
 
   async messageIdentity(message) {
-    const [id, turn] = await Promise.all([
-      message.getAttribute("data-message-id").catch(() => null),
-      this.#messageTurn(message),
-    ]);
-    return { id, turn };
-  }
-
-  async #messageTurn(message) {
-    if (typeof message?.evaluate !== "function") {
-      return null;
-    }
-    const testId = await message.evaluate((element) => (
-      element.closest('[data-testid^="conversation-turn-"]')
-        ?.getAttribute("data-testid") ?? null
-    )).catch(() => null);
-    return parseConversationTurn(testId);
+    return readChatGPTMessageIdentity(message);
   }
 
   // The redesigned UI still exposes the stop button ([data-testid="stop-button"],
@@ -957,40 +954,7 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
   }
 
   async assistantText(message) {
-    // Read the whole assistant turn first. A long XML response can contain
-    // Markdown fences inside CDATA; ChatGPT then splits the rendered response
-    // into many <pre><code> nodes and the first node contains the opening tag
-    // but not the closing tag. The parent innerText keeps the complete envelope
-    // and avoids one CDP round trip per nested code block on every poll.
-    const fullText = await message.innerText().catch(() => "");
-    if (fullText.includes("<agent_response")) {
-      return fullText;
-    }
-
-    // Rare fallback for alternate renderers where the parent text omits code
-    // contents: prefer a complete code-block envelope, but retain a partial
-    // one so streaming progress remains visible until its closing tag arrives.
-    const codeBlocks = message.locator("pre code");
-    const codeBlockCount = await codeBlocks.count();
-    let partialEnvelope = "";
-    for (let index = 0; index < codeBlockCount; index += 1) {
-      const code = await codeBlocks.nth(index).innerText().catch(() => "");
-      if (hasCompleteAgentEnvelope(code)) {
-        return code;
-      }
-      if (!partialEnvelope && code.includes("<agent_response")) {
-        partialEnvelope = code;
-      }
-    }
-    if (partialEnvelope) {
-      return partialEnvelope;
-    }
-
-    const markdown = message.locator(".markdown");
-    if (await markdown.count()) {
-      return await markdown.last().innerText().catch(() => "");
-    }
-    return fullText;
+    return readChatGPTAssistantText(message, hasCompleteAgentEnvelope);
   }
 
   // A plan/usage limit renders as an error card: error-tinted token classes
@@ -1110,8 +1074,8 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
   // Scrolls the thread container to the bottom so the latest replies mount.
   // Best-effort — any failure is swallowed.
   async scrollConversationToBottom() {
-    await this.page.evaluate?.(() => {
-      const message = document.querySelector("[data-message-author-role]");
+    await this.page.evaluate?.((selector) => {
+      const message = document.querySelector(selector);
       if (!message) {
         return;
       }
@@ -1126,7 +1090,7 @@ export class ChatGPTWebAdapter extends BaseWebAdapter {
           return;
         }
       }
-    }).catch(() => null);
+    }, CHATGPT_DOM.messages).catch(() => null);
   }
 
 }

package/src/browser/fake-web-model-adapter.js

@@ -169,7 +169,11 @@ export class FakeWebModelAdapter {
     return this.conversationUrl;
   }
 
-  async sendMessage(text, { files = [], outboundId = null } = {}) {
+  async sendMessage(text, {
+    files = [],
+    outboundId = null,
+    requireAttachments = false,
+  } = {}) {
     const priorUserMessageId = this.lastUserMessageId;
     const priorAssistantMessageId = this.lastAssistantMessageId;
     this.lastSendStatus = "commit-unknown";
@@ -223,4 +227,15 @@ export class FakeWebModelAdapter {
   async getLastAssistantTurn() {
     return this.lastAssistantTurn;
   }
+
+  async captureAuxiliaryTurnCompletion() {
+    this.responseNumber += 1;
+    this.lastAssistantMessageId = `assistant-${this.responseNumber}`;
+    this.lastAssistantTurn = this.responseNumber * 2;
+    return {
+      assistantMessageId: this.lastAssistantMessageId,
+      assistantTurn: this.lastAssistantTurn,
+      conversationUrl: this.conversationUrl,
+    };
+  }
 }

package/src/browser/gemini-web-adapter.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { BaseWebAdapter, firstVisible } from "./base-web-adapter.js";
 import { BrowserAdapterError } from "../shared/errors.js";
 import { isUsageLimitNotice } from "../shared/usage-limit.js";
+import { readRenderedBlocks } from "./rendered-text.js";
 
 export { isConnectionLostError } from "./base-web-adapter.js";
 
@@ -124,24 +125,13 @@ export class GeminiWebAdapter extends BaseWebAdapter {
     // Read Gemini's rendered answer body before falling back to the enclosing
     // message-content. Attachment/source chips (for example a trailing "TXT")
     // live beside `.markdown` and are UI chrome, not model output.
-    const markdown = message.locator("message-content .markdown").last();
+    const markdown = message.locator("message-content .markdown");
     if (await markdown.count().catch(() => 0) > 0) {
-      const cleaned = await markdown.evaluate((element) => {
-        const clone = element.cloneNode(true);
-        clone.querySelectorAll(
-          "sources-carousel-inline, source-inline-chip, source-footnote, "
-            + ".hide-from-message-actions",
-        ).forEach((item) => item.remove());
-        return clone.innerText;
-      }).catch(() => null);
-      if (cleaned != null) {
-        return cleaned;
-      }
-      return await markdown.innerText().catch(() => "");
+      return await markdown.evaluateAll(readRenderedBlocks);
     }
-    const content = message.locator("message-content").last();
+    const content = message.locator("message-content");
     if (await content.count().catch(() => 0) > 0) {
-      return await content.innerText().catch(() => "");
+      return await content.evaluateAll(readRenderedBlocks);
     }
     return await message.innerText().catch(() => "");
   }
@@ -163,7 +153,6 @@ export class GeminiWebAdapter extends BaseWebAdapter {
     const completed = await firstVisible([
       message.locator('[data-test-id="regenerate-button"]'),
       message.getByRole("button", { name: /^(Redo|Regenerate|重做)$/i }),
-      message.getByRole("button", { name: /^(Copy|复制)$/i }),
     ]);
     return !completed;
   }
@@ -308,16 +297,66 @@ export class GeminiWebAdapter extends BaseWebAdapter {
     }
   }
 
-  async submitComposer(composer) {
+  async submitComposer(composer, options = {}) {
     const sendButton = await firstVisible(this.sendButtonLocators());
+    options.assertActive?.();
+    if (this.musicGeneration && sendButton && await sendButton.isEnabled()) {
+      // Gemini's current Music UI reliably activates through the focused
+      // button's keyboard handler. Submit once; never retry an unknown commit.
+      await sendButton.press("Space", { timeout: options.timeoutMs });
+      return;
+    }
     if (
       sendButton
       && await sendButton.isEnabled().catch(() => false)
-      && await this.#clickWithNativePointer(sendButton)
+      && await this.#clickWithNativePointer(sendButton, options.assertActive)
     ) {
       return;
     }
-    await super.submitComposer(composer);
+    await super.submitComposer(composer, options);
+  }
+
+  async prepareMusicGeneration() {
+    this.requirePage();
+    // Gemini may move Music from the regular chat tool menu to a dedicated
+    // creation screen. Its old tool chip then exists only in a hidden composer.
+    const prepareCreationPage = async () => {
+      if (typeof this.page.getByText !== "function") return false;
+      const heading = this.page.getByText("Create music", { exact: true });
+      if (!await heading.isVisible().catch(() => false)) return false;
+      const editor = this.page.locator('div.ql-editor[contenteditable="true"][role="textbox"]');
+      const template = this.page.getByRole("button", { name: "Background music", exact: true });
+      if (await template.isVisible().catch(() => false)) {
+        const placeholder = await editor.getAttribute("data-placeholder").catch(() => "");
+        if (!/background music/i.test(placeholder)) await template.click();
+      }
+      await editor.waitFor({ state: "visible", timeout: 15_000 });
+      this.musicGeneration = true;
+      return true;
+    };
+    if (await prepareCreationPage()) return;
+    try {
+      const selected = this.page.getByRole("button", {
+        name: /^(Deselect Music|取消选择音乐|取消選取音樂)$/i,
+      });
+      if (!await selected.isVisible().catch(() => false)) {
+        const tools = this.page.getByRole("button", { name: /^(Upload & tools|上传和工具|上傳和工具)$/i });
+        if (await tools.getAttribute("aria-expanded") !== "true") await tools.press("Space");
+        const music = this.page.locator('button[role="menuitemcheckbox"]:has([data-mat-icon-name="music"])');
+        await music.waitFor({ state: "visible", timeout: 10_000 });
+        if (await music.getAttribute("aria-disabled") === "true") {
+          throw new BrowserAdapterError("Gemini Music is unavailable for this account.", { code: "MUSIC_UNAVAILABLE", recoverable: false });
+        }
+        await music.press("Space");
+        await selected.waitFor({ state: "visible", timeout: 10_000 });
+      }
+    } catch (error) {
+      // Selecting Music in the old menu can navigate to the new screen before
+      // the old menu item appears. Reconcile the UI without sending twice.
+      if (await prepareCreationPage()) return;
+      throw error;
+    }
+    this.musicGeneration = true;
   }
 
   async dismissTransientOverlays() {
@@ -399,7 +438,8 @@ export class GeminiWebAdapter extends BaseWebAdapter {
     return normalized;
   }
 
-  async #clickWithNativePointer(locator) {
+  async #clickWithNativePointer(locator, assertActive = () => {}) {
+    assertActive();
     await locator.scrollIntoViewIfNeeded().catch(() => null);
     const box = await locator.boundingBox().catch(() => null);
     if (!box || !this.page.mouse) {
@@ -409,6 +449,7 @@ export class GeminiWebAdapter extends BaseWebAdapter {
     const y = box.y + box.height / 2;
     await this.page.mouse.move(x, y, { steps: 8 });
     await this.page.waitForTimeout(75);
+    assertActive();
     await this.page.mouse.down();
     await this.page.waitForTimeout(80);
     await this.page.mouse.up();