fix(qwen): anchor waitForAnswer to stop returning the previous answer (#1982)

jackwener · codex-mini0 · web-flow · commit de2ef4ca56ce · 2026-06-21T15:18:36.000+08:00
* fix(qwen): anchor waitForAnswer on pre-send turn to stop returning the previous answer

qwen `waitForAnswer` took no baseline and never skipped stale turns — the
`seenAssistantId` variable was assigned but never read (dead code). Since
`getMessageBubbles` returns every turn including the already-complete
previous answer, a follow-up `qwen ask` into an existing conversation
(persistent site session, no --new) saw that prior answer on the first
polls. It was already stable, so the stability check returned it as if it
were the reply to the new prompt — silently wrong output, no error.

Mirror grok's reference fix: capture the last assistant turn's id before
sending (`getBaselineLastAssistantId` in ask.js) and `continue` in
waitForAnswer while the latest assistant id equals that baseline. Removes
the dead `seenAssistantId`.

Tests: getBaselineLastAssistantId helper (mirrors grok), plus a direct
waitForAnswer test asserting the pre-send turn is skipped (times out
rather than returning the stale answer) — reverse-validated.

* fix(qwen): bind answer wait to sent prompt turn

* fix(audit): bump undici in lockfile

* fix(qwen): fail closed when answer anchor is not visible

---------

Co-authored-by: codex-mini0 &lt;codex-mini0@slock.local&gt;
diff --git a/clis/qwen/ask.js b/clis/qwen/ask.js
@@ -59,13 +59,17 @@ cli({
         if (useThink) await setFeatureToggle(page, 'think', true);
         if (useResearch) await setFeatureToggle(page, 'research', true);
 
+        // Anchor on the visible transcript BEFORE sending so waitForAnswer can
+        // bind the reply to the newly sent prompt instead of an older answer.
+        const baselineAnchor = await getBaselineChatAnchor(page);
+
         const send = await sendMessage(page, prompt);
         if (!send?.ok) {
             if (await hasLoginGate(page)) throw authRequired();
             throw new CommandExecutionError(send?.reason || 'Failed to send Qianwen prompt');
         }
 
-        const result = await waitForAnswer(page, prompt, timeout);
+        const result = await waitForAnswer(page, prompt, timeout, baselineAnchor);
         if (result.status === 'auth_required') throw authRequired();
         if (result.status === 'timeout') {
             throw new TimeoutError('qianwen ask', timeout, 'No Qianwen reply observed before timeout. Retry with --timeout increased.');
@@ -83,3 +87,18 @@ cli({
         ];
     },
 });
+
+async function getBaselineChatAnchor(page) {
+    const bubbles = await getMessageBubbles(page);
+    const lastBubbleId = bubbles.length ? bubbles[bubbles.length - 1].id : '';
+    let lastAssistantId = '';
+    for (let i = bubbles.length - 1; i >= 0; i -= 1) {
+        if (bubbles[i].role === 'Assistant') {
+            lastAssistantId = bubbles[i].id;
+            break;
+        }
+    }
+    return { lastBubbleId, lastAssistantId };
+}
+
+export const __test__ = { getBaselineChatAnchor };
diff --git a/clis/qwen/ask.test.js b/clis/qwen/ask.test.js
@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './ask.js';
+
+describe('qwen ask helpers', () => {
+    describe('getBaselineChatAnchor', () => {
+        // getMessageBubbles drives a page.evaluate that returns the raw bubble
+        // array; in tests we route page.evaluate straight to an in-memory array.
+        const fakePage = (bubbles) => ({ evaluate: () => Promise.resolve(bubbles) });
+
+        it('returns the last visible bubble and most recent Assistant bubble', async () => {
+            const bubbles = [
+                { id: 'a1', role: 'Assistant', text: 'first answer', html: '' },
+                { id: 'u1', role: 'User', text: 'follow-up', html: '' },
+                { id: 'a2', role: 'Assistant', text: 'second answer', html: '' },
+                { id: 'u2', role: 'User', text: 'newest user turn', html: '' },
+            ];
+            expect(await __test__.getBaselineChatAnchor(fakePage(bubbles))).toEqual({
+                lastBubbleId: 'u2',
+                lastAssistantId: 'a2',
+            });
+        });
+
+        it('returns empty assistant id when no Assistant bubble exists yet (fresh chat)', async () => {
+            expect(await __test__.getBaselineChatAnchor(fakePage([]))).toEqual({
+                lastBubbleId: '',
+                lastAssistantId: '',
+            });
+            expect(await __test__.getBaselineChatAnchor(fakePage([
+                { id: 'u1', role: 'User', text: 'hello', html: '' },
+            ]))).toEqual({
+                lastBubbleId: 'u1',
+                lastAssistantId: '',
+            });
+        });
+    });
+});
diff --git a/clis/qwen/utils.js b/clis/qwen/utils.js
@@ -284,12 +284,62 @@ function stripNoise(text) {
         .trim();
 }
 
-export async function waitForAnswer(page, prompt, timeoutSeconds) {
+function normalizePromptText(text) {
+    return stripNoise(text).replace(/\s+/g, ' ').trim();
+}
+
+function normalizeWaitAnchor(anchor) {
+    if (typeof anchor === 'string') {
+        return { lastBubbleId: '', lastAssistantId: anchor };
+    }
+    return {
+        lastBubbleId: String(anchor?.lastBubbleId || ''),
+        lastAssistantId: String(anchor?.lastAssistantId || ''),
+    };
+}
+
+function findAssistantAfterPrompt(bubbles, prompt, anchor) {
+    const normalizedPrompt = normalizePromptText(prompt);
+    let startIndex = -1;
+    const hasAnchor = Boolean(anchor.lastBubbleId || anchor.lastAssistantId);
+    let foundAnchor = false;
+    if (anchor.lastBubbleId) {
+        const lastBubbleIndex = bubbles.findIndex((bubble) => bubble.id === anchor.lastBubbleId);
+        if (lastBubbleIndex >= 0) {
+            startIndex = lastBubbleIndex;
+            foundAnchor = true;
+        }
+    }
+    if (anchor.lastAssistantId) {
+        const lastAssistantIndex = bubbles.findIndex((bubble) => bubble.id === anchor.lastAssistantId);
+        if (lastAssistantIndex >= 0) {
+            startIndex = Math.max(startIndex, lastAssistantIndex);
+            foundAnchor = true;
+        }
+    }
+    if (hasAnchor && !foundAnchor) return null;
+
+    let promptIndex = -1;
+    for (let i = startIndex + 1; i < bubbles.length; i += 1) {
+        if (bubbles[i].role === 'User' && normalizePromptText(bubbles[i].text) === normalizedPrompt) {
+            promptIndex = i;
+        }
+    }
+    if (promptIndex < 0) return null;
+
+    for (let i = promptIndex + 1; i < bubbles.length; i += 1) {
+        if (bubbles[i].role === 'Assistant') return bubbles[i];
+    }
+    return null;
+}
+
+export async function waitForAnswer(page, prompt, timeoutSeconds, baselineAnchor) {
+    const anchor = normalizeWaitAnchor(baselineAnchor);
     const startTime = Date.now();
     let previousText = '';
     let stableCount = 0;
     let lastCandidate = '';
-    let seenAssistantId = '';
+    let lastAssistantCandidate = null;
 
     while (Date.now() - startTime < timeoutSeconds * 1000) {
         await page.wait(POLL_INTERVAL_SECONDS);
@@ -299,14 +349,18 @@ export async function waitForAnswer(page, prompt, timeoutSeconds) {
         }
 
         const bubbles = await getMessageBubbles(page);
-        const lastAssistant = [...bubbles].reverse().find((b) => b.role === 'Assistant');
+        const lastAssistant = findAssistantAfterPrompt(bubbles, prompt, anchor);
         if (!lastAssistant) continue;
 
+        // Guard against stale assistant turns that existed before our send even
+        // if the DOM briefly reorders or rehydrates while the new turn loads.
+        if (anchor.lastAssistantId && lastAssistant.id === anchor.lastAssistantId) continue;
+
         const text = stripNoise(lastAssistant.text);
         if (!text || text === prompt) continue;
 
-        if (!seenAssistantId) seenAssistantId = lastAssistant.id;
         lastCandidate = text;
+        lastAssistantCandidate = lastAssistant;
 
         const waitedLongEnough = Date.now() - startTime >= MIN_WAIT_MS;
         if (text === previousText) {
@@ -321,9 +375,7 @@ export async function waitForAnswer(page, prompt, timeoutSeconds) {
     }
 
     if (lastCandidate) {
-        const bubbles = await getMessageBubbles(page);
-        const lastAssistant = [...bubbles].reverse().find((b) => b.role === 'Assistant');
-        return { status: 'partial', assistant: lastAssistant };
+        return { status: 'partial', assistant: lastAssistantCandidate };
     }
     return { status: 'timeout' };
 }
diff --git a/clis/qwen/utils.test.js b/clis/qwen/utils.test.js
@@ -1,6 +1,89 @@
 import { describe, expect, it } from 'vitest';
 import { ArgumentError } from '@jackwener/opencli/errors';
-import { parseQianwenSessionId } from './utils.js';
+import { parseQianwenSessionId, waitForAnswer } from './utils.js';
+
+describe('qwen waitForAnswer baseline anchoring', () => {
+    // page.evaluate serves both getMessageBubbles (data-chat-question-wrap) and
+    // hasLoginGate (alert-biz-modal); route by inspecting the injected JS.
+    const fakePage = (bubbles) => ({
+        wait: () => new Promise((r) => setTimeout(r, 5)),
+        evaluate: (js) => Promise.resolve(
+            String(js).includes('alert-biz-modal') ? false : bubbles,
+        ),
+    });
+
+    it('does not return the pre-send assistant turn (it is skipped via baseline id)', async () => {
+        // Only the previous, already-complete answer is present. With the
+        // baseline anchored to its id, waitForAnswer must skip it and time out
+        // rather than return the stale answer as the new reply.
+        const bubbles = [{ id: 'a1', role: 'Assistant', text: 'old answer', html: '' }];
+        const result = await waitForAnswer(fakePage(bubbles), 'new question', 0.05, 'a1');
+        expect(result.status).toBe('timeout');
+        expect(result.assistant).toBeUndefined();
+    });
+
+    it('returns only an assistant turn after the newly sent prompt', async () => {
+        const bubbles = [
+            { id: 'u1', role: 'User', text: 'old question', html: '' },
+            { id: 'a1', role: 'Assistant', text: 'old answer', html: '' },
+            { id: 'u2', role: 'User', text: 'new question', html: '' },
+            { id: 'a2', role: 'Assistant', text: 'new answer', html: '<p>new answer</p>' },
+        ];
+        const result = await waitForAnswer(
+            fakePage(bubbles),
+            'new question',
+            0.2,
+            { lastBubbleId: 'a1', lastAssistantId: 'a1' },
+        );
+        expect(result.status).toBe('partial');
+        expect(result.assistant).toEqual(bubbles[3]);
+    });
+
+    it('does not match a repeated prompt that existed before the pre-send anchor', async () => {
+        const bubbles = [
+            { id: 'u1', role: 'User', text: 'same prompt', html: '' },
+            { id: 'a1', role: 'Assistant', text: 'old answer', html: '' },
+        ];
+        const result = await waitForAnswer(
+            fakePage(bubbles),
+            'same prompt',
+            0.05,
+            { lastBubbleId: 'a1', lastAssistantId: 'a1' },
+        );
+        expect(result.status).toBe('timeout');
+        expect(result.assistant).toBeUndefined();
+    });
+
+    it('does not scan the visible transcript when a non-empty baseline anchor is missing', async () => {
+        const bubbles = [
+            { id: 'u1-new-visible-id', role: 'User', text: 'same prompt', html: '' },
+            { id: 'a1-new-visible-id', role: 'Assistant', text: 'old answer', html: '' },
+        ];
+        const result = await waitForAnswer(
+            fakePage(bubbles),
+            'same prompt',
+            0.05,
+            { lastBubbleId: 'a-anchor-missing', lastAssistantId: 'a-anchor-missing' },
+        );
+        expect(result.status).toBe('timeout');
+        expect(result.assistant).toBeUndefined();
+    });
+
+    it('supports a fresh chat with no baseline anchor', async () => {
+        const bubbles = [
+            { id: 'u1', role: 'User', text: 'fresh question', html: '' },
+            { id: 'a1', role: 'Assistant', text: 'fresh answer', html: '' },
+        ];
+        const result = await waitForAnswer(
+            fakePage(bubbles),
+            'fresh question',
+            0.2,
+            { lastBubbleId: '', lastAssistantId: '' },
+        );
+        expect(result.status).toBe('partial');
+        expect(result.assistant).toEqual(bubbles[1]);
+    });
+});
 
 describe('qwen parseQianwenSessionId', () => {
     const id = 'abcd1234ef567890abcd1234ef567890';
