wtagent 0.2.2 → 0.4.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/deepseek-web-adapter.js

@@ -34,112 +34,6 @@ export class DeepSeekWebAdapter extends BaseWebAdapter {
     return /^\/a\/chat\/s\//;
   }
 
-  // DeepSeek has no ChatGPT-style model dropdown; instead a new conversation
-  // exposes mode chips (快速/专家/识图) and toggles (深度思考/智能搜索). The
-  // registry's defaultMode ("expert-thinking") asks for 专家模式 (Expert) +
-  // 深度思考 (Deep Thinking) — WTAgent's preferred DeepSeek setup, applied
-  // silently on every fresh conversation (no interactive picker). Any other
-  // requested value keeps the site's current setting.
-  //
-  // Selection is LANGUAGE-INDEPENDENT and idempotent:
-  //   - the chips are role="radio" in a fixed order (fast, expert, image), so
-  //     the expert chip is the second radio; visible labels are only used to
-  //     double-check the position when they match a locale we know
-  //   - after expert is active DeepSeek shows exactly ONE .ds-toggle-button
-  //     (deep thinking); fast mode shows two (deep thinking + web search), so
-  //     the toggle count itself proves the chip switch landed. Clicking the
-  //     single remaining toggle needs no label at all.
-  // Selection is best-effort — a UI change never aborts the run; it reports
-  // "unresolved" and keeps the current mode, like runModeSelection.
-  async selectMode(mode) {
-    this.requirePage();
-    if (mode !== "expert-thinking") {
-      return { status: "skipped", requested: mode, attempts: 0 };
-    }
-
-    const steps = [];
-    const chip = await this.#findExpertChip();
-    if (!chip) {
-      steps.push({ ok: false, label: "expert-chip" });
-    } else {
-      steps.push(await this.#ensureChipChecked(chip, "expert-chip"));
-      if (steps[0].ok) {
-        steps.push(await this.#ensureSingleThinkingToggle());
-      }
-    }
-
-    const failed = steps.filter((s) => !s.ok);
-    if (failed.length > 0) {
-      await this.writeDiagnostics("deepseek-mode-partial");
-      return {
-        status: "unresolved",
-        requested: mode,
-        selectedLabel: "expert + deep-thinking",
-        attempts: 1,
-        reason: `Could not confirm: ${failed.map((s) => s.label).join(", ")}.`,
-      };
-    }
-    return {
-      status: "select",
-      requested: mode,
-      selectedLabel: "expert + deep-thinking",
-      attempts: 1,
-      reason: "Selected expert mode with deep thinking.",
-    };
-  }
-
-  // Locates the expert chip without relying on its locale: try known labels
-  // first, then fall back to the fixed chip order (fast, expert, image).
-  async #findExpertChip() {
-    const radios = this.page.locator('[role="radio"]');
-    const count = await radios.count().catch(() => 0);
-    if (count === 0) {
-      return null;
-    }
-    const labelPattern = /专家|expert/i;
-    for (let index = 0; index < count; index += 1) {
-      const text = (await radios.nth(index).innerText().catch(() => "")).trim();
-      if (labelPattern.test(text)) {
-        return radios.nth(index);
-      }
-    }
-    // Positional fallback: 快速/专家/识图 — the expert chip is the 2nd radio.
-    return count >= 2 ? radios.nth(1) : null;
-  }
-
-  // Clicks a chip unless it is already aria-checked. Returns { ok, label }.
-  async #ensureChipChecked(chip, label) {
-    if (await chip.getAttribute("aria-checked").catch(() => null) === "true") {
-      return { ok: true, label };
-    }
-    await chip.click({ timeout: 5_000 }).catch(() => null);
-    await this.page.waitForTimeout(400);
-    const checked = await chip.getAttribute("aria-checked").catch(() => null);
-    return { ok: checked === "true", label };
-  }
-
-  // In expert mode exactly ONE toggle (deep thinking) exists; in fast mode
-  // there are two. Clicking the single remaining toggle therefore never needs
-  // a label. The toggle count also verifies the chip switch actually landed.
-  async #ensureSingleThinkingToggle() {
-    const toggles = this.page.locator(".ds-toggle-button");
-    const count = await toggles.count().catch(() => 0);
-    if (count !== 1) {
-      return { ok: false, label: "deep-thinking-toggle" };
-    }
-    const toggle = toggles.nth(0);
-    const isSelected = async () => (
-      (await toggle.getAttribute("class").catch(() => "") ?? "")
-        .includes("ds-toggle-button--selected")
-    );
-    if (await isSelected()) {
-      return { ok: true, label: "deep-thinking-toggle" };
-    }
-    await toggle.click({ timeout: 5_000 }).catch(() => null);
-    await this.page.waitForTimeout(400);
-    return { ok: await isSelected(), label: "deep-thinking-toggle" };
-  }
-
   composerLocators() {
     return [
       this.page.locator('textarea[name="search"]'),

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,36 @@ export class FakeWebModelAdapter {
     return this.conversationUrl;
   }
 
-  async sendMessage(text, { files = [] } = {}) {
+  async sendMessage(text, { files = [], outboundId = null } = {}) {
+    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 +208,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 +219,8 @@ export class FakeWebModelAdapter {
   async getLastAssistantMessageId() {
     return this.lastAssistantMessageId;
   }
+
+  async getLastAssistantTurn() {
+    return this.lastAssistantTurn;
+  }
 }

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

@@ -25,6 +25,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(

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

@@ -5,11 +5,6 @@ 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:
@@ -21,8 +16,8 @@ const PREFERRED_MODELS = ["GLM-5.3", "GLM-5.2"];
 //   - 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)
+//   - model choice is intentionally left to the user on chat.z.ai; WTAgent does
+//     not inspect or override the site's current model selection
 //   - 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)
@@ -157,90 +152,8 @@ export class GLMWebAdapter extends BaseWebAdapter {
     return 5;
   }
 
-  sentUserWaitAttempts() {
-    return 120;
+  sendConfirmationTimeoutMs() {
+    return 30_000;
   }
 
-  // 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/grok-web-adapter.js

@@ -0,0 +1,145 @@
+import { BaseWebAdapter, firstVisible } from "./base-web-adapter.js";
+import { isUsageLimitNotice } from "../shared/usage-limit.js";
+
+export { isConnectionLostError } from "./base-web-adapter.js";
+
+const GROK_URL = "https://grok.com/";
+
+export class GrokWebAdapter extends BaseWebAdapter {
+  constructor(options = {}) {
+    super({
+      ...options,
+      baseUrl: options.baseUrl ?? GROK_URL,
+      providerName: "Grok",
+    });
+  }
+
+  conversationUrlPattern() {
+    return /^\/c\//;
+  }
+
+  composerLocators() {
+    return [
+      this.page.locator("main textarea").first(),
+      this.page.locator("textarea[aria-label]").first(),
+      this.page.locator('[role="textbox"]').first(),
+    ];
+  }
+
+  sendButtonLocators() {
+    return [
+      this.page.locator('button[aria-label*="send" i]'),
+      this.page.locator('button[aria-label*="发送"]'),
+      this.page.locator('button[type="submit"]'),
+    ];
+  }
+
+  stopButtonLocators() {
+    return [
+      this.page.locator('button[aria-label*="停止模型响应"]'),
+      this.page.locator('button[aria-label*="stop" i]'),
+    ];
+  }
+
+  newConversationControls() {
+    return [
+      this.page.locator('[data-testid="new-chat"]'),
+      this.page.locator('a[href="/"]'),
+    ];
+  }
+
+  loginControlLocators() {
+    return [
+      this.page.getByRole("button", {
+        name: /^(log in|sign in|登录|登入|ログイン|로그인)$/i,
+      }),
+      this.page.getByRole("link", {
+        name: /^(log in|sign in|登录|登入|ログイン|로그인)$/i,
+      }),
+    ];
+  }
+
+  authUrlPattern() {
+    return /^\/(?:sign-in|signin|login|auth)(?:\/|$)/i;
+  }
+
+  authTextPattern() {
+    return /sign in to grok|log in to grok|continue with x|continue with google|登录 Grok|登入 Grok/i;
+  }
+
+  assistantMessages() {
+    return this.page.locator('[data-testid="assistant-message"]');
+  }
+
+  userMessages() {
+    return this.page.locator(
+      '[data-testid="user-message"], [role="article"][aria-label="You"]',
+    );
+  }
+
+  conversationMessages() {
+    return this.page.locator(
+      '[data-testid="user-message"], [data-testid="assistant-message"], '
+        + '[role="article"][aria-label="You"]',
+    );
+  }
+
+  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) };
+  }
+
+  isNewAssistantIdentity({ turn, text }) {
+    if (turn != null && turn > (this.assistantCountBeforeSend ?? 0)) {
+      return true;
+    }
+    const previous = String(this.lastAssistantTextBeforeSend ?? "");
+    return Boolean(previous && String(text ?? "") !== previous);
+  }
+
+  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 message.innerText().catch(() => "");
+  }
+
+  hasReliableCompletionSignal() {
+    return true;
+  }
+
+  async isAssistantGenerating() {
+    return Boolean(await firstVisible(this.stopButtonLocators()));
+  }
+
+  async findUsageLimitMarker(message) {
+    const text = await message.innerText().catch(() => "");
+    if (!isUsageLimitNotice(text)) return null;
+    const control = await firstVisible([
+      message.getByRole("button", { name: /retry|try again|upgrade|重试|升级/i }),
+      this.page.getByRole("button", { name: /retry|try again|upgrade|重试|升级/i }),
+    ]);
+    return control ? text.trim().slice(0, 120) : null;
+  }
+
+  async findGenerationErrorMarker(message) {
+    const text = await message.innerText().catch(() => "");
+    if (!/something went wrong|failed to generate|generation failed|try again|生成失败|出错了/i.test(text)) {
+      return null;
+    }
+    const control = await firstVisible([
+      message.getByRole("button", { name: /retry|try again|重试|重新生成/i }),
+      this.page.getByRole("button", { name: /retry|try again|重试|重新生成/i }),
+    ]);
+    return control ? text.trim().slice(0, 120) : null;
+  }
+
+  deadRequestGraceMultiplier() {
+    return 3;
+  }
+}

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

@@ -19,9 +19,8 @@ const KIMI_URL = "https://www.kimi.com/";
 //   - 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.
+// Model choice is intentionally left to the user on kimi.com; the adapter does
+// not inspect or change the site's current model selection.
 export class KimiWebAdapter extends BaseWebAdapter {
   constructor(options = {}) {
     super({
@@ -211,75 +210,4 @@ export class KimiWebAdapter extends BaseWebAdapter {
     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.",
-    };
-  }
 }