wtagent 0.3.0 → 1.0.0

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

@@ -22,6 +22,19 @@ export class ClaudeWebAdapter extends BaseWebAdapter {
     return /^\/chat\//;
   }
 
+  freshConversationUrlPattern() {
+    return /^\/new\/?$/;
+  }
+
+  pendingAttachmentLocators() {
+    return [
+      this.page.locator(
+        'form [data-testid="file-thumbnail"], '
+          + 'form button[aria-label*="remove file" i]',
+      ),
+    ];
+  }
+
   composerLocators() {
     return [
       this.page.locator('[data-testid="chat-input"]'),

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

@@ -7,17 +7,110 @@ export class FakeWebModelAdapter {
     this.mode = null;
     this.conversationUrl = "https://chatgpt.com/";
     this.lastAssistantMessageId = null;
+    this.lastAssistantTurn = null;
     this.responseNumber = 0;
     this.startConversationCalls = [];
     this.startConversationOptions = [];
+    this.startConversationOutcome = null;
     this.sentAttachments = [];
+    this.sentOutboundIds = [];
+    this.targetId = "fake-target";
+    this.lastUserMessageId = null;
+    this.lastSendStatus = "not-submitted";
+    this.conversationIdentityListener = null;
+    this.pendingOutboundRecoverySupported = true;
+    this.recoveryTargetCalls = [];
+    this.reconciliationCalls = [];
+    this.reconciliationOutcome = null;
     // Records window-state calls so tests can assert restore/minimize ordering.
     this.windowStateCalls = [];
   }
 
-  async launch(preferredUrl = null) {
+  async launch(preferredUrl = null, options = {}) {
     this.launched = true;
     this.lastLaunchUrl = preferredUrl;
+    this.lastLaunchOptions = options;
+  }
+
+  supportsPendingOutboundRecovery() {
+    return this.pendingOutboundRecoverySupported;
+  }
+
+  async launchRecoveryTarget(targetId) {
+    this.launched = true;
+    this.recoveryTargetCalls.push(targetId);
+    if (!targetId || targetId !== this.targetId) {
+      const error = new Error("The fake recovery target is unavailable.");
+      error.code = "RECOVERY_TARGET_UNAVAILABLE";
+      throw error;
+    }
+    return {
+      conversationUrl: this.conversationUrl,
+      targetId,
+    };
+  }
+
+  async reconcilePendingOutbound(options = {}) {
+    this.reconciliationCalls.push(options);
+    const outcome = typeof this.reconciliationOutcome === "function"
+      ? await this.reconciliationOutcome(options)
+      : this.reconciliationOutcome;
+    if (!outcome) {
+      const error = new Error("The fake pending outbound remains uncertain.");
+      error.code = "OUTBOUND_COMMIT_UNCERTAIN";
+      throw error;
+    }
+    if (outcome.conversationUrl) {
+      this.conversationUrl = outcome.conversationUrl;
+    }
+    if (outcome.conversationTargetId) {
+      this.targetId = outcome.conversationTargetId;
+    }
+    this.lastUserMessageId = outcome.userMessageId ?? this.lastUserMessageId;
+    if (outcome.status === "complete") {
+      this.lastAssistantMessageId = outcome.assistantMessageId
+        ?? this.lastAssistantMessageId;
+      this.lastAssistantTurn = outcome.assistantTurn ?? this.lastAssistantTurn;
+    }
+    return outcome;
+  }
+
+  classifyConversationUrl(value) {
+    try {
+      const url = new URL(value);
+      if (url.protocol !== "https:" || url.origin !== "https://chatgpt.com") {
+        return "invalid";
+      }
+      if (/^\/c\/WEB:/.test(url.pathname)) {
+        return "provisional";
+      }
+      if (/^\/c\//.test(url.pathname)) {
+        return "restorable";
+      }
+      return url.pathname === "/" ? "fresh" : "unknown";
+    } catch {
+      return "invalid";
+    }
+  }
+
+  setConversationIdentityListener(listener) {
+    this.conversationIdentityListener = listener;
+  }
+
+  getConversationIdentity() {
+    return {
+      conversationUrl: this.conversationUrl,
+      targetId: this.targetId,
+      kind: this.classifyConversationUrl(this.conversationUrl),
+    };
+  }
+
+  getLastSendStatus() {
+    return this.lastSendStatus;
+  }
+
+  async getLastUserMessageId() {
+    return this.lastUserMessageId;
   }
 
   async close() {
@@ -46,6 +139,19 @@ export class FakeWebModelAdapter {
     } else {
       this.conversationUrl = "https://chatgpt.com/";
     }
+    const configuredOutcome = typeof this.startConversationOutcome === "function"
+      ? await this.startConversationOutcome(conversationUrl, options)
+      : this.startConversationOutcome;
+    const isConversation = /^\/c\//.test(new URL(this.conversationUrl).pathname);
+    const outcome = configuredOutcome ?? {
+      status: isConversation ? "restored-existing" : "verified-fresh",
+      conversationUrl: this.conversationUrl,
+      targetId: this.targetId,
+    };
+    if (outcome.conversationUrl) {
+      this.conversationUrl = outcome.conversationUrl;
+    }
+    return outcome;
   }
 
   async selectMode(mode) {
@@ -63,13 +169,40 @@ export class FakeWebModelAdapter {
     return this.conversationUrl;
   }
 
-  async sendMessage(text, { files = [] } = {}) {
+  async sendMessage(text, {
+    files = [],
+    outboundId = null,
+    requireAttachments = false,
+  } = {}) {
+    const priorUserMessageId = this.lastUserMessageId;
+    const priorAssistantMessageId = this.lastAssistantMessageId;
+    this.lastSendStatus = "commit-unknown";
     this.sentMessages.push(text);
     this.sentAttachments.push(files);
+    this.sentOutboundIds.push(outboundId);
     if (this.conversationUrl === "https://chatgpt.com/") {
       this.conversationUrl = "https://chatgpt.com/c/fake";
     }
-    return { attachment: files.length ? { attached: files, failed: [] } : null };
+    this.lastSendStatus = "confirmed";
+    this.lastUserMessageId = `user-${this.sentMessages.length}`;
+    await this.conversationIdentityListener?.(this.getConversationIdentity());
+    return {
+      attachment: files.length ? { attached: files, failed: [] } : null,
+      userMessageId: this.lastUserMessageId,
+      userTurn: (this.sentMessages.length * 2) - 1,
+      conversationUrl: this.conversationUrl,
+      conversationTargetId: this.targetId,
+      assistantBaseline: {
+        ids: priorAssistantMessageId ? [priorAssistantMessageId] : [],
+        count: priorAssistantMessageId ? 1 : 0,
+        maxTurn: priorAssistantMessageId ? (this.responseNumber * 2) : null,
+        lastText: "",
+      },
+      preOutboundMarkerIds: [
+        priorUserMessageId,
+        priorAssistantMessageId,
+      ].filter(Boolean),
+    };
   }
 
   async waitForTurnComplete({ onDelta } = {}) {
@@ -79,6 +212,7 @@ export class FakeWebModelAdapter {
     const response = this.responses.shift();
     this.responseNumber += 1;
     this.lastAssistantMessageId = `assistant-${this.responseNumber}`;
+    this.lastAssistantTurn = this.responseNumber * 2;
     if (response instanceof Error) {
       throw response;
     }
@@ -89,4 +223,19 @@ export class FakeWebModelAdapter {
   async getLastAssistantMessageId() {
     return this.lastAssistantMessageId;
   }
+
+  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";
 
@@ -25,6 +26,16 @@ export class GeminiWebAdapter extends BaseWebAdapter {
     return /^\/app\/[^/]+/;
   }
 
+  pendingAttachmentLocators() {
+    return [
+      this.page.locator(
+        '[data-test-id="textarea-wrapper"] .attachment-container, '
+          + '[data-test-id="textarea-wrapper"] '
+          + 'button[aria-label*="remove" i]',
+      ),
+    ];
+  }
+
   composerLocators() {
     return [
       this.page.locator(
@@ -114,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(() => "");
   }
@@ -153,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;
   }
@@ -298,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() {
@@ -389,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) {
@@ -399,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();

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

@@ -152,8 +152,8 @@ export class GLMWebAdapter extends BaseWebAdapter {
     return 5;
   }
 
-  sentUserWaitAttempts() {
-    return 120;
+  sendConfirmationTimeoutMs() {
+    return 30_000;
   }
 
 }

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

@@ -1,5 +1,6 @@
 import { BaseWebAdapter, firstVisible } from "./base-web-adapter.js";
 import { isUsageLimitNotice } from "../shared/usage-limit.js";
+import { readRenderedBlocks } from "./rendered-text.js";
 
 export { isConnectionLostError } from "./base-web-adapter.js";
 
@@ -20,7 +21,11 @@ export class GrokWebAdapter extends BaseWebAdapter {
 
   composerLocators() {
     return [
-      this.page.locator("main textarea").first(),
+      // Grok replaces its initial textarea with a role=textbox editor during
+      // hydration. Keep both variants in one live locator so a composer found
+      // just before that replacement does not become an empty stale selector
+      // by the time sendMessage fills it.
+      this.page.locator('main textarea, main [role="textbox"]').first(),
       this.page.locator("textarea[aria-label]").first(),
       this.page.locator('[role="textbox"]').first(),
     ];
@@ -84,13 +89,40 @@ export class GrokWebAdapter extends BaseWebAdapter {
     );
   }
 
+  async userMessageText(message) {
+    const markdown = message.locator(".response-content-markdown");
+    if (await markdown.count().catch(() => 0) > 0) {
+      const exact = await markdown.evaluateAll(readRenderedBlocks);
+      if (exact.trim()) return exact;
+    }
+    return await super.userMessageText(message);
+  }
+
   async messageIdentity(message) {
     const testId = await message.getAttribute("data-testid").catch(() => null);
     const aria = await message.getAttribute("aria-label").catch(() => null);
     const scope = testId === "user-message" || aria === "You"
       ? this.userMessages()
       : this.assistantMessages();
-    return { id: null, turn: await scope.count().catch(() => 0) };
+    // Grok wraps every visible user/assistant bubble in a stable response UUID:
+    //
+    //   <div id="response-..." data-scroll-anchor-root>
+    //     <div data-testid="user-message|assistant-message">...</div>
+    //   </div>
+    //
+    // Keep the count fallback for older DOM variants, but prefer the wrapper
+    // identity whenever it is present. Besides making normal multi-turn
+    // correlation stronger, this lets a fresh chat safely follow Grok's late
+    // root -> /c/... navigation after the user bubble has already committed.
+    const id = await message.evaluate((element) => (
+      element.closest('[data-scroll-anchor-root][id^="response-"]')?.id
+        ?? element.closest('[id^="response-"]')?.id
+        ?? null
+    )).catch(() => null);
+    return {
+      id: id || null,
+      turn: await scope.count().catch(() => 0),
+    };
   }
 
   isNewAssistantIdentity({ turn, text }) {
@@ -104,7 +136,7 @@ export class GrokWebAdapter extends BaseWebAdapter {
   async assistantText(message) {
     const response = message.locator(".response-content-markdown");
     if (await response.count().catch(() => 0) > 0) {
-      return await response.last().innerText().catch(() => "");
+      return await response.evaluateAll(readRenderedBlocks);
     }
     return await message.innerText().catch(() => "");
   }

package/src/browser/rendered-text.js

@@ -0,0 +1,11 @@
+// Passed directly to Locator.evaluateAll: keep this function self-contained.
+// Read connected nodes so innerText keeps layout whitespace and omits hidden
+// descendants. Cloning first changes innerText into textContent-like output.
+export function readRenderedBlocks(elements) {
+  const roots = elements.filter((element) => (
+    !elements.some((other) => other !== element && other.contains(element))
+  ));
+  return roots.filter((element) => element.getClientRects().length > 0)
+    .map((element) => element.innerText)
+    .join("\n");
+}