wtagent 0.1.0 → 0.2.0

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

@@ -0,0 +1,246 @@
+import { BaseWebAdapter, firstVisible } from "./base-web-adapter.js";
+import { isUsageLimitNotice } from "../shared/usage-limit.js";
+
+export { isConnectionLostError } from "./base-web-adapter.js";
+
+const GLM_URL = "https://chat.z.ai/";
+
+// Preferred models, newest first: try GLM-5.3 when present, else GLM-5.2. The
+// site sometimes exposes 5.3 and sometimes only 5.2, so selection walks this
+// list and clicks the first one present in the menu.
+const PREFERRED_MODELS = ["GLM-5.3", "GLM-5.2"];
+
+// GLM / Z.ai (chat.z.ai) adapter.
+//
+// chat.z.ai is an Open WebUI (Svelte) frontend, verified against the live app:
+//   - composer: `textarea#chat-input` (placeholder "有什么我能帮您的？" / "有什么我能帮您的?")
+//   - messages: `#messages-container [id^="message-<uuid>"]`, each id carrying a
+//     STABLE per-message UUID; the user row has class `user-message`, the
+//     assistant row instead contains `#response-content-container`. So identity
+//     uses the base's default id-based ladder (like Kimi, unlike DeepSeek).
+//   - assistant answer markdown is `.markdown-prose` / `.prose`; a "思考过程"
+//     (deep-thinking) block may precede it and is excluded when reading the reply
+//   - a live conversation URL is /c/<uuid>
+//   - model switcher: `button.modelSelectorButton`; the registry defaultMode
+//     "latest" picks the newest available model (GLM-5.3, else GLM-5.2)
+//   - Cloudflare guards the site; the base throwIfBlockedPage surfaces the
+//     window so the user can pass the check (wtagent's own CDP launch is not
+//     fingerprinted the way headless automation is)
+export class GLMWebAdapter extends BaseWebAdapter {
+  constructor(options = {}) {
+    super({
+      ...options,
+      baseUrl: options.baseUrl ?? GLM_URL,
+      providerName: "GLM",
+    });
+  }
+
+  conversationUrlPattern() {
+    return /^\/c\//;
+  }
+
+  composerLocators() {
+    return [
+      this.page.locator("#chat-input"),
+      this.page.locator('textarea[placeholder*="帮您"]'),
+      this.page.locator("main textarea"),
+    ];
+  }
+
+  sendButtonLocators() {
+    return [
+      this.page.locator("#send-message-button"),
+      this.page.getByRole("button", { name: /send|发送/i }),
+    ];
+  }
+
+  stopButtonLocators() {
+    return [
+      this.page.locator("#stop-response-button"),
+      this.page.getByRole("button", { name: /stop|停止|中断/i }),
+    ];
+  }
+
+  newConversationControls() {
+    return [
+      this.page.locator("#sidebar-new-chat-button"),
+      this.page.getByRole("button", { name: /新聊天|新建聊天|新对话|new chat/i }),
+    ];
+  }
+
+  loginControlLocators() {
+    return [
+      this.page.getByRole("button", { name: /^登录$|^log in$|^sign in$/i }),
+    ];
+  }
+
+  // Logged-out visitors are redirected to /auth — a locale-independent signal.
+  authUrlPattern() {
+    return /^\/auth/;
+  }
+
+  authTextPattern() {
+    return /手机号登录|发送验证码|欢迎回来|登录即表示同意|sign in|log in|send code|welcome back/i;
+  }
+
+  assistantMessages() {
+    // Assistant message rows: a stable-id message that is NOT the user row.
+    return this.page.locator(
+      '#messages-container [id^="message-"]:not([id$="-start"]):not(.user-message)',
+    );
+  }
+
+  userMessages() {
+    return this.page.locator(
+      '#messages-container [id^="message-"]:not([id$="-start"]).user-message',
+    );
+  }
+
+  conversationMessages() {
+    return this.page.locator(
+      '#messages-container [id^="message-"]:not([id$="-start"])',
+    );
+  }
+
+  // Each message row carries a stable UUID in its element id (message-<uuid>),
+  // so the base's default id-based identity ladder works directly.
+  async messageIdentity(message) {
+    const raw = await message.getAttribute("id").catch(() => null);
+    const id = raw ? raw.replace(/^message-/, "") : null;
+    return { id, turn: null };
+  }
+
+  async assistantText(message) {
+    // GLM (with 深度思考 on) often renders the whole reply — including the
+    // protocol XML — inside a `思考过程` thinking-chain block, and streams a
+    // "正在思考 / 跳过" placeholder first. Rather than try to isolate a separate
+    // answer node (there often isn't one), return the full message text: the
+    // protocol parser tolerates the leading 思考过程 text and extracts the
+    // <agent_response> envelope.
+    return await message.innerText().catch(() => "");
+  }
+
+  // Structural completion signal — the same idea as Kimi's action bar, and
+  // fully locale-independent: GLM renders the response action bar
+  // (.copy-response-button / .regenerate-response-button) under an assistant
+  // message only after it has FULLY finished streaming. While generating (or
+  // during the 深度思考 thinking phase), those Svelte slots stay empty, so no
+  // buttons exist yet. This also covers the blank row GLM mounts a few seconds
+  // before the first token: no buttons = still generating.
+  hasReliableCompletionSignal() {
+    return true;
+  }
+
+  async isAssistantGenerating(message) {
+    const buttons = message.locator(
+      ".copy-response-button, .regenerate-response-button",
+    );
+    return await buttons.count().catch(() => 0) === 0;
+  }
+
+  async findUsageLimitMarker(message) {
+    const text = await message.innerText().catch(() => "");
+    if (!isUsageLimitNotice(text)) {
+      return null;
+    }
+    const control = await firstVisible([
+      message.getByRole("button", { name: /重试|重新生成|retry|升级|upgrade/i }),
+      message.locator('[class*="error" i]'),
+    ]);
+    return control ? text.trim().slice(0, 120) : null;
+  }
+
+  // GLM keeps 深度思考 on and shows no persistent stop button, so — like DeepSeek
+  // and Kimi — the silent phase before the first token must not be misread as a
+  // dead request.
+  deadRequestGraceMultiplier() {
+    return 5;
+  }
+
+  sentUserWaitAttempts() {
+    return 120;
+  }
+
+  // Selects the newest available model. The registry's defaultMode "latest" maps
+  // to PREFERRED_MODELS (GLM-5.3, else GLM-5.2). Best-effort and non-throwing.
+  //
+  // The switcher is `button.modelSelectorButton`; opening it lists options whose
+  // visible text is the exact model name. After clicking, the switcher label
+  // becomes the selected model name.
+  async selectMode(mode) {
+    this.requirePage();
+    if (mode !== "latest") {
+      return { status: "skipped", requested: mode, attempts: 0 };
+    }
+
+    const switcher = this.page.locator("button.modelSelectorButton").first();
+    await switcher.waitFor({ state: "visible", timeout: 10_000 }).catch(() => null);
+    if (await switcher.count().catch(() => 0) === 0) {
+      await this.writeDiagnostics("glm-model-switcher-not-found");
+      return {
+        status: "switcher_not_found",
+        requested: mode,
+        attempts: 0,
+        reason: "Model switcher was not found.",
+      };
+    }
+
+    const current = (await switcher.innerText().catch(() => "")).trim();
+    // Already on the most-preferred model that exists? If the current label is
+    // the first preferred model, nothing to do.
+    if (current.startsWith(PREFERRED_MODELS[0])) {
+      return {
+        status: "already",
+        requested: mode,
+        selectedLabel: PREFERRED_MODELS[0],
+        attempts: 0,
+        reason: `Already using ${PREFERRED_MODELS[0]}.`,
+      };
+    }
+
+    for (const model of PREFERRED_MODELS) {
+      await switcher.click({ timeout: 5_000 }).catch(() => null);
+      await this.page.waitForTimeout(600);
+      const option = this.page.getByText(model, { exact: true }).first();
+      if (await option.count().catch(() => 0) === 0) {
+        // Not in the menu; close and try the next preferred model.
+        await this.page.keyboard.press("Escape").catch(() => null);
+        continue;
+      }
+      await option.click({ timeout: 5_000 }).catch(() => null);
+      await this.page.waitForTimeout(600);
+      const after = (await switcher.innerText().catch(() => "")).trim();
+      if (after.startsWith(model)) {
+        // The model menu stays open after a selection; a click in the page
+        // center dismisses it so it does not cover the composer.
+        await this.#dismissModelMenu();
+        return {
+          status: current.startsWith(model) ? "already" : "select",
+          requested: mode,
+          selectedLabel: model,
+          attempts: 1,
+          reason: `Selected ${model}.`,
+        };
+      }
+    }
+
+    await this.#dismissModelMenu();
+    await this.writeDiagnostics("glm-mode-latest-unresolved");
+    return {
+      status: "unresolved",
+      requested: mode,
+      attempts: 1,
+      reason: `Could not select any of: ${PREFERRED_MODELS.join(", ")}.`,
+    };
+  }
+
+  async #dismissModelMenu() {
+    const viewport = this.page.viewportSize?.() ?? { width: 1280, height: 800 };
+    await this.page.mouse.click(
+      Math.floor(viewport.width / 2),
+      Math.floor(viewport.height / 2),
+    ).catch(() => null);
+    await this.page.keyboard.press("Escape").catch(() => null);
+    await this.page.waitForTimeout(200);
+  }
+}

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

@@ -0,0 +1,285 @@
+import { BaseWebAdapter, firstVisible, hasCompleteAgentEnvelope } from "./base-web-adapter.js";
+import { isUsageLimitNotice } from "../shared/usage-limit.js";
+
+export { isConnectionLostError } from "./base-web-adapter.js";
+
+const KIMI_URL = "https://www.kimi.com/";
+
+// Kimi (www.kimi.com, Moonshot) adapter.
+//
+// Kimi's chat DOM is clean and semantic, verified against the live app:
+//   - composer: a Lexical contenteditable `.chat-input-editor` (like ChatGPT),
+//     so the base fill/keyboard path works; the send control is
+//     `.send-button-container` (disabled when empty), and Enter also sends
+//   - messages: `.chat-content-item.chat-content-item-user` and
+//     `.chat-content-item.chat-content-item-assistant`
+//   - every message carries a STABLE per-message UUID in `data-archer-id`, so
+//     the base's default id-based identity ladder works directly (no volatile
+//     virtual-list key like DeepSeek)
+//   - assistant replies may include a `.thinking-container` reasoning block
+//     before the answer; assistantText reads the answer markdown outside it
+//   - a live conversation URL is /chat/<uuid>
+//   - a model switcher (`.current-model`) opens a Naive-UI popover
+//     (`.models-container .model-item`); WTAgent defaults it to K3 — see
+//     selectMode.
+export class KimiWebAdapter extends BaseWebAdapter {
+  constructor(options = {}) {
+    super({
+      ...options,
+      baseUrl: options.baseUrl ?? KIMI_URL,
+      providerName: "Kimi",
+    });
+  }
+
+  conversationUrlPattern() {
+    return /^\/chat\//;
+  }
+
+  composerLocators() {
+    return [
+      this.page.locator(".chat-input-editor"),
+      this.page.locator('div[contenteditable="true"][data-lexical-editor="true"]'),
+      this.page.locator('main div[contenteditable="true"]'),
+      this.page.locator('textarea'),
+    ];
+  }
+
+  sendButtonLocators() {
+    // The send control is a div, not a <button>; it carries `disabled` in its
+    // class when the composer is empty. firstVisible + isEnabled won't detect
+    // the class-based disable, so the base's Enter fallback is the reliable
+    // path — these are best-effort only.
+    return [
+      this.page.locator(".send-button-container:not(.disabled)"),
+      this.page.getByRole("button", { name: /send|发送/i }),
+    ];
+  }
+
+  // Kimi shows no persistent labeled stop button; generation liveness is not
+  // proven by a stop control, so the wider dead-request grace applies (below).
+  stopButtonLocators() {
+    return [
+      this.page.getByRole("button", { name: /stop|停止|中断/i }),
+    ];
+  }
+
+  newConversationControls() {
+    return [
+      this.page.getByRole("button", { name: /新建会话|新对话|new chat/i }),
+      this.page.getByRole("link", { name: /新建会话|新对话|new chat/i }),
+    ];
+  }
+
+  loginControlLocators() {
+    return [
+      this.page.getByRole("button", { name: /^(登录|log in|sign in)$/i }),
+    ];
+  }
+
+  authTextPattern() {
+    return /手机号快捷登录|手机号登录|发送验证码|登录以同步|log in to sync|sign in/i;
+  }
+
+  assistantMessages() {
+    return this.page.locator(".chat-content-item-assistant");
+  }
+
+  userMessages() {
+    return this.page.locator(".chat-content-item-user");
+  }
+
+  conversationMessages() {
+    return this.page.locator(".chat-content-item");
+  }
+
+  // Kimi tags every message with a stable UUID in data-archer-id — a genuine
+  // per-message id, so the base id-based identity ladder works unchanged.
+  async messageIdentity(message) {
+    const id = await message.getAttribute("data-archer-id").catch(() => null);
+    return { id, turn: null };
+  }
+
+  async assistantText(message) {
+    // Prefer the visible answer markdown. Native-tool cards and thinking
+    // blocks share `.markdown` too, so exclude those first; if the only text
+    // left is a mid-tool failure such as "文件阅读失败", keep waiting for the
+    // later protocol envelope instead of treating that card as the reply.
+    // `.markdown` is nested inside `.markdown-container`. Selecting both
+    // duplicates the same reply (Kimi then looks like it emitted two envelopes).
+    const answer = message.locator(
+      ".markdown:not(.thinking-container .markdown):not(.toolcall-container .markdown)",
+    );
+    if (await answer.count().catch(() => 0)) {
+      const chunks = [];
+      const seen = new Set();
+      const count = await answer.count();
+      for (let index = 0; index < count; index += 1) {
+        const text = (await answer.nth(index).innerText().catch(() => "")).trim();
+        if (!text || seen.has(text)) {
+          continue;
+        }
+        seen.add(text);
+        chunks.push(text);
+      }
+      const joined = chunks.join("\n");
+      if (joined.includes("<agent_response") || !this.#isNativeToolPlaceholder(joined)) {
+        return joined;
+      }
+    }
+    return await message.innerText().catch(() => "");
+  }
+
+  #isNativeToolPlaceholder(text) {
+    const trimmed = String(text ?? "").trim();
+    if (!trimmed || trimmed.includes("<agent_response")) {
+      return false;
+    }
+    return /文件阅读失败|文件读取失败|阅读失败|read file failed|tool (?:call )?failed/i.test(trimmed);
+  }
+
+  hasReliableCompletionSignal() {
+    return true;
+  }
+
+  async isAssistantGenerating(message) {
+    if (await this.#isNativeToolRunning(message)) {
+      return true;
+    }
+    // Kimi renders the action bar (.segment-assistant-actions — copy/share/…
+    // icons) under a reply only once it has FULLY finished streaming. Its
+    // absence is the reliable completion signal: a structural DOM check that
+    // does not depend on localized status text ("思考中" vs "思考已完成"), so
+    // a mid-stream pause can never read as a finished reply.
+    return await message
+      .locator(".segment-assistant-actions")
+      .count()
+      .catch(() => 0) === 0;
+  }
+
+  async extraStableWindowMs(message, text) {
+    if (hasCompleteAgentEnvelope(text)) {
+      return 0;
+    }
+    if (await this.#hasNativeToolCard(message) || this.#isNativeToolPlaceholder(text)) {
+      return 8_000;
+    }
+    return 0;
+  }
+
+  async #isNativeToolRunning(message) {
+    // Completed cards show completion markers: 已完成/失败, or a result count
+    // ("9 个结果" / "N 条结果" / "N results") for a finished web search. Only a
+    // card free of ALL markers can be in flight.
+    const running = message.locator(
+      ".toolcall-container:not(.thinking-container):not(:has-text('已完成')):not(:has-text('失败'))"
+      + ":not(:has-text('个结果')):not(:has-text('条结果')):not(:has-text('results')), "
+      + ".toolcall-title-container:not(.thinking-container .toolcall-title-container)",
+    );
+    if (await running.count().catch(() => 0) === 0) {
+      return false;
+    }
+    const title = await running.first().innerText().catch(() => "");
+    if (/已完成|失败|failed|个结果|条结果|results/i.test(title)) {
+      return false;
+    }
+    return /阅读|读取|搜索|执行|运行中|running|reading|searching/i.test(title);
+  }
+
+  async #hasNativeToolCard(message) {
+    const cards = message.locator(
+      ".toolcall-container:not(.thinking-container), "
+      + ".toolcall-title-container:not(.thinking-container .toolcall-title-container)",
+    );
+    return await cards.count().catch(() => 0) > 0;
+  }
+
+  async findUsageLimitMarker(message) {
+    const text = await message.innerText().catch(() => "");
+    if (!isUsageLimitNotice(text)) {
+      return null;
+    }
+    const control = await firstVisible([
+      message.getByRole("button", { name: /重试|重新生成|retry|升级|upgrade/i }),
+      message.locator('[class*="error" i]'),
+    ]);
+    return control ? text.trim().slice(0, 120) : null;
+  }
+
+  // Kimi does not expose a persistent stop button, so — like DeepSeek — the
+  // silent phase before the first token must not be misread as a dead request.
+  deadRequestGraceMultiplier() {
+    return 5;
+  }
+
+  // Kimi has a model switcher (快速 / K3 / K3 集群). The registry's defaultMode
+  // "k3" asks to switch to K3 ("擅长对话与 Agent 任务，全能旗舰") on every fresh
+  // conversation, silently. Any other value keeps the current model.
+  //
+  // The switcher is `.current-model`; it opens a Naive-UI popover whose rows are
+  // `.models-container .model-item`, the selected one carrying `checked`. After
+  // selecting, the switcher label starts with the model name (e.g. "K3 进阶").
+  // Best-effort and non-throwing, mirroring runModeSelection's contract.
+  async selectMode(mode) {
+    this.requirePage();
+    if (mode !== "k3") {
+      return { status: "skipped", requested: mode, attempts: 0 };
+    }
+
+    const switcher = this.page.locator(".current-model").first();
+    // The switcher can mount a beat after the composer on a fresh conversation;
+    // wait briefly before concluding it is absent.
+    await switcher.waitFor({ state: "visible", timeout: 10_000 }).catch(() => null);
+    if (await switcher.count().catch(() => 0) === 0) {
+      await this.writeDiagnostics("kimi-model-switcher-not-found");
+      return {
+        status: "switcher_not_found",
+        requested: mode,
+        attempts: 0,
+        reason: "Model switcher was not found.",
+      };
+    }
+
+    // Already on K3? The switcher label starts with "K3" (but not "K3 集群").
+    const label = (await switcher.innerText().catch(() => "")).trim();
+    if (/^K3(?!\s*集群)/.test(label)) {
+      return {
+        status: "already",
+        requested: mode,
+        selectedLabel: "K3",
+        attempts: 0,
+        reason: "Already using K3.",
+      };
+    }
+
+    await switcher.click({ timeout: 5_000 }).catch(() => null);
+    await this.page.locator(".models-container .model-item")
+      .first().waitFor({ state: "visible", timeout: 5_000 }).catch(() => null);
+
+    // Click the row whose title line is exactly "K3" (not "快速" / "K3 集群").
+    const k3 = this.page.locator(".models-container .model-item").filter({
+      hasText: /^K3(?!\s*集群)/,
+    }).first();
+    const clicked = await k3.count().catch(() => 0) > 0
+      && await k3.click({ timeout: 5_000 }).then(() => true).catch(() => false);
+    await this.page.waitForTimeout(500);
+
+    const after = (await switcher.innerText().catch(() => "")).trim();
+    if (clicked && /^K3(?!\s*集群)/.test(after)) {
+      return {
+        status: "select",
+        requested: mode,
+        selectedLabel: "K3",
+        attempts: 1,
+        reason: "Selected K3.",
+      };
+    }
+    await this.page.keyboard.press("Escape").catch(() => null);
+    await this.writeDiagnostics("kimi-mode-k3-unresolved");
+    return {
+      status: "unresolved",
+      requested: mode,
+      attempts: 1,
+      reason: "Could not confirm K3 was selected.",
+    };
+  }
+}