@jackwener/opencli 1.6.1 → 1.6.2

package/dist/clis/gemini/reply-state.test.js

@@ -0,0 +1,641 @@
+import { describe, expect, it, vi } from 'vitest';
+import { __test__, waitForGeminiResponse, waitForGeminiSubmission } from './utils.js';
+function snapshot(overrides = {}) {
+    return {
+        turns: [],
+        transcriptLines: [],
+        composerHasText: false,
+        isGenerating: false,
+        structuredTurnsTrusted: true,
+        ...overrides,
+    };
+}
+function createPageMock() {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn(),
+        getCookies: vi.fn().mockResolvedValue([]),
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({}),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+        nativeType: vi.fn().mockResolvedValue(undefined),
+        nativeKeyPress: vi.fn().mockResolvedValue(undefined),
+    };
+}
+describe('Gemini snapshot diff helpers', () => {
+    it('reports appended trusted turns when the current snapshot extends the baseline', () => {
+        const before = snapshot({
+            turns: [{ Role: 'Assistant', Text: '旧回答' }],
+        });
+        const current = snapshot({
+            turns: [
+                { Role: 'Assistant', Text: '旧回答' },
+                { Role: 'User', Text: '请只回复：OK' },
+            ],
+        });
+        expect(__test__.diffTrustedStructuredTurns(before, current)).toEqual({
+            appendedTurns: [{ Role: 'User', Text: '请只回复：OK' }],
+            hasTrustedAppend: true,
+            hasNewUserTurn: true,
+            hasNewAssistantTurn: false,
+        });
+    });
+    it('treats restored structured turns as untrusted when the pre-send snapshot had no trustworthy turns', () => {
+        const before = snapshot({
+            turns: [],
+            transcriptLines: ['旧问题', '旧回答'],
+            structuredTurnsTrusted: false,
+        });
+        const current = snapshot({
+            turns: [
+                { Role: 'User', Text: '旧问题' },
+                { Role: 'Assistant', Text: '旧回答' },
+            ],
+            transcriptLines: ['旧问题', '旧回答'],
+            structuredTurnsTrusted: true,
+        });
+        expect(__test__.diffTrustedStructuredTurns(before, current)).toEqual({
+            appendedTurns: [],
+            hasTrustedAppend: false,
+            hasNewUserTurn: false,
+            hasNewAssistantTurn: false,
+        });
+    });
+    it('keeps transcript delta lines raw for later conservative fallback checks', () => {
+        const before = snapshot({
+            transcriptLines: ['baseline'],
+        });
+        const current = snapshot({
+            transcriptLines: ['baseline', '关于“请只回复：OK”，这里是解释。'],
+            structuredTurnsTrusted: false,
+        });
+        expect(__test__.diffTranscriptLines(before, current)).toEqual([
+            '关于“请只回复：OK”，这里是解释。',
+        ]);
+    });
+});
+describe('Gemini submission state', () => {
+    it('confirms submission from a trusted appended user turn', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: '旧回答' },
+                { Role: 'User', Text: '请只回复：OK' },
+            ],
+            transcriptLines: ['baseline', '请只回复：OK'],
+            composerHasText: false,
+            isGenerating: true,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiSubmission(page, snapshot({
+            turns: [{ Role: 'Assistant', Text: '旧回答' }],
+            transcriptLines: ['baseline'],
+            composerHasText: true,
+            structuredTurnsTrusted: true,
+        }), 4);
+        expect(result).toEqual({
+            snapshot: {
+                turns: [
+                    { Role: 'Assistant', Text: '旧回答' },
+                    { Role: 'User', Text: '请只回复：OK' },
+                ],
+                transcriptLines: ['baseline', '请只回复：OK'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            },
+            preSendAssistantCount: 1,
+            userAnchorTurn: { Role: 'User', Text: '请只回复：OK' },
+            reason: 'user_turn',
+        });
+    });
+    it('confirms submission from composer cleared plus generating even when transcript has not changed yet', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: true,
+            structuredTurnsTrusted: false,
+        });
+        const result = await waitForGeminiSubmission(page, snapshot({
+            transcriptLines: ['baseline'],
+            composerHasText: true,
+            structuredTurnsTrusted: false,
+        }), 2);
+        expect(result).toEqual({
+            snapshot: {
+                turns: [],
+                transcriptLines: ['baseline'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: false,
+            },
+            preSendAssistantCount: 0,
+            userAnchorTurn: null,
+            reason: 'composer_generating',
+        });
+    });
+    it('confirms submission from generating state even when the pre-send baseline composer was empty', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'User', Text: '你说\n\n请只回复：DBG2' },
+                { Role: 'User', Text: '请只回复：DBG2' },
+            ],
+            transcriptLines: ['baseline', '请只回复：DBG2'],
+            composerHasText: false,
+            isGenerating: true,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiSubmission(page, snapshot({
+            turns: [{ Role: 'Assistant', Text: '需要我为你做些什么？' }],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            structuredTurnsTrusted: true,
+        }), 2);
+        expect(result).toEqual({
+            snapshot: {
+                turns: [
+                    { Role: 'User', Text: '你说\n\n请只回复：DBG2' },
+                    { Role: 'User', Text: '请只回复：DBG2' },
+                ],
+                transcriptLines: ['baseline', '请只回复：DBG2'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            },
+            preSendAssistantCount: 1,
+            userAnchorTurn: { Role: 'User', Text: '请只回复：DBG2' },
+            reason: 'composer_generating',
+        });
+    });
+    it('confirms submission from composer cleared plus transcript growth when generation state is unavailable', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        // This transcript delta may be only a prompt echo. It is allowed to confirm
+        // submission only because the composer has already cleared, and it must never
+        // be reused later as reply ownership evidence.
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [],
+            transcriptLines: ['baseline', '请只回复：OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: false,
+        });
+        const result = await waitForGeminiSubmission(page, snapshot({
+            transcriptLines: ['baseline'],
+            composerHasText: true,
+            structuredTurnsTrusted: false,
+        }), 2);
+        expect(result).toEqual({
+            snapshot: {
+                turns: [],
+                transcriptLines: ['baseline', '请只回复：OK'],
+                composerHasText: false,
+                isGenerating: false,
+                structuredTurnsTrusted: false,
+            },
+            preSendAssistantCount: 0,
+            userAnchorTurn: null,
+            reason: 'composer_transcript',
+        });
+    });
+    it('does not confirm submission when old structured turns only reappear after an untrusted pre-send snapshot', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'User', Text: '旧问题' },
+                { Role: 'Assistant', Text: '旧回答' },
+            ],
+            transcriptLines: ['旧问题', '旧回答'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'User', Text: '旧问题' },
+                { Role: 'Assistant', Text: '旧回答' },
+            ],
+            transcriptLines: ['旧问题', '旧回答'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiSubmission(page, snapshot({
+            turns: [],
+            transcriptLines: ['旧问题', '旧回答'],
+            composerHasText: true,
+            structuredTurnsTrusted: false,
+        }), 2);
+        expect(result).toBeNull();
+    });
+    it('does not confirm submission from transcript growth alone when the composer never clears', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [],
+            transcriptLines: ['baseline', '请只回复：OK'],
+            composerHasText: true,
+            isGenerating: false,
+            structuredTurnsTrusted: false,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [],
+            transcriptLines: ['baseline', '请只回复：OK'],
+            composerHasText: true,
+            isGenerating: false,
+            structuredTurnsTrusted: false,
+        });
+        const result = await waitForGeminiSubmission(page, snapshot({
+            transcriptLines: ['baseline'],
+            composerHasText: true,
+            structuredTurnsTrusted: false,
+        }), 2);
+        expect(result).toBeNull();
+    });
+    it('keeps polling past ten seconds when the overall timeout budget still allows submission confirmation', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        for (let index = 0; index < 10; index += 1) {
+            evaluate
+                .mockResolvedValueOnce('https://gemini.google.com/app')
+                .mockResolvedValueOnce({
+                turns: [],
+                transcriptLines: ['baseline'],
+                composerHasText: true,
+                isGenerating: false,
+                structuredTurnsTrusted: false,
+            });
+        }
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [],
+            transcriptLines: ['baseline', '请只回复：OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: false,
+        });
+        const result = await waitForGeminiSubmission(page, snapshot({
+            transcriptLines: ['baseline'],
+            composerHasText: true,
+            structuredTurnsTrusted: false,
+        }), 12);
+        expect(result?.reason).toBe('composer_transcript');
+    });
+});
+describe('Gemini reply state', () => {
+    it('does not reuse an older identical reply when the submission baseline has no structured user anchor', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'Assistant', Text: 'OK' }],
+            transcriptLines: ['baseline', 'OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: 'OK' },
+                { Role: 'Assistant', Text: 'OK' },
+            ],
+            transcriptLines: ['baseline', 'OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: 'OK' },
+                { Role: 'Assistant', Text: 'OK' },
+            ],
+            transcriptLines: ['baseline', 'OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiResponse(page, {
+            snapshot: snapshot({
+                turns: [{ Role: 'Assistant', Text: 'OK' }],
+                transcriptLines: ['baseline', 'OK'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            }),
+            preSendAssistantCount: 1,
+            userAnchorTurn: null,
+            reason: 'composer_generating',
+        }, '请只回复：OK', 6);
+        expect(result).toBe('OK');
+    });
+    it('does not treat prepended older history as the current round reply when reply ownership has no user anchor', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: '更早的问题' },
+                { Role: 'Assistant', Text: '旧回答' },
+            ],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: '更早的问题' },
+                { Role: 'Assistant', Text: '旧回答' },
+            ],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: '更早的问题' },
+                { Role: 'Assistant', Text: '旧回答' },
+            ],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiResponse(page, {
+            snapshot: snapshot({
+                turns: [{ Role: 'Assistant', Text: '旧回答' }],
+                transcriptLines: ['baseline'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            }),
+            preSendAssistantCount: 1,
+            userAnchorTurn: null,
+            reason: 'composer_generating',
+        }, '请只回复：OK', 6);
+        expect(result).toBe('');
+    });
+    it('accepts a reply when the submission snapshot contains only the current round user turns and later appends a new assistant', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'User', Text: '你说\n\n请只回复：DBGREG' },
+                { Role: 'User', Text: '请只回复：DBGREG' },
+                { Role: 'Assistant', Text: 'DBGREG' },
+            ],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'User', Text: '你说\n\n请只回复：DBGREG' },
+                { Role: 'User', Text: '请只回复：DBGREG' },
+                { Role: 'Assistant', Text: 'DBGREG' },
+            ],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiResponse(page, {
+            snapshot: snapshot({
+                turns: [
+                    { Role: 'User', Text: '你说\n\n请只回复：DBGREG' },
+                    { Role: 'User', Text: '请只回复：DBGREG' },
+                ],
+                transcriptLines: ['baseline'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            }),
+            preSendAssistantCount: 1,
+            userAnchorTurn: { Role: 'User', Text: '请只回复：DBGREG' },
+            reason: 'composer_generating',
+        }, '请只回复：DBGREG', 6);
+        expect(result).toBe('DBGREG');
+    });
+    it('does not trust an assistant-only submission snapshot without a stable post-submission owner', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'Assistant', Text: '完整回答' }],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'Assistant', Text: '完整回答' }],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiResponse(page, {
+            snapshot: snapshot({
+                turns: [{ Role: 'Assistant', Text: '半截回答' }],
+                transcriptLines: ['baseline'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            }),
+            preSendAssistantCount: 0,
+            userAnchorTurn: null,
+            reason: 'composer_generating',
+        }, '请解释', 4);
+        expect(result).toBe('');
+    });
+    it('accepts an assistant reply that appears after a structured user anchor only after it stabilizes and generation stops', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: '旧回答' },
+                { Role: 'User', Text: '请解释' },
+                { Role: 'Assistant', Text: '半截回答' },
+            ],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: true,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: '旧回答' },
+                { Role: 'User', Text: '请解释' },
+                { Role: 'Assistant', Text: '完整回答' },
+            ],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: true,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [
+                { Role: 'Assistant', Text: '旧回答' },
+                { Role: 'User', Text: '请解释' },
+                { Role: 'Assistant', Text: '完整回答' },
+            ],
+            transcriptLines: ['baseline'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiResponse(page, {
+            snapshot: snapshot({
+                turns: [
+                    { Role: 'Assistant', Text: '旧回答' },
+                    { Role: 'User', Text: '请解释' },
+                ],
+                transcriptLines: ['baseline'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            }),
+            preSendAssistantCount: 1,
+            userAnchorTurn: { Role: 'User', Text: '请解释' },
+            reason: 'user_turn',
+        }, '请解释', 6);
+        expect(result).toBe('完整回答');
+    });
+    it('uses transcript fallback only after two identical post-submission deltas and after generation stops', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'User', Text: '请只回复：OK' }],
+            transcriptLines: ['baseline', 'OK'],
+            composerHasText: false,
+            isGenerating: true,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'User', Text: '请只回复：OK' }],
+            transcriptLines: ['baseline', 'OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'User', Text: '请只回复：OK' }],
+            transcriptLines: ['baseline', 'OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiResponse(page, {
+            snapshot: snapshot({
+                turns: [{ Role: 'User', Text: '请只回复：OK' }],
+                transcriptLines: ['baseline'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            }),
+            preSendAssistantCount: 0,
+            userAnchorTurn: { Role: 'User', Text: '请只回复：OK' },
+            reason: 'user_turn',
+        }, '请只回复：OK', 6);
+        expect(result).toBe('OK');
+    });
+    it('ignores transcript lines that appeared before submission confirmation and only accepts post-submission transcript deltas', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'User', Text: '请只回复：OK' }],
+            transcriptLines: ['baseline', '早到的提示词回声', 'OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'User', Text: '请只回复：OK' }],
+            transcriptLines: ['baseline', '早到的提示词回声', 'OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            turns: [{ Role: 'User', Text: '请只回复：OK' }],
+            transcriptLines: ['baseline', '早到的提示词回声', 'OK'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        const result = await waitForGeminiResponse(page, {
+            snapshot: snapshot({
+                turns: [{ Role: 'User', Text: '请只回复：OK' }],
+                transcriptLines: ['baseline', '早到的提示词回声'],
+                composerHasText: false,
+                isGenerating: true,
+                structuredTurnsTrusted: true,
+            }),
+            preSendAssistantCount: 0,
+            userAnchorTurn: { Role: 'User', Text: '请只回复：OK' },
+            reason: 'composer_transcript',
+        }, '请只回复：OK', 6);
+        expect(result).toBe('OK');
+    });
+});