@google/gemini-cli-core 0.7.0-nightly.20250912.68035591 → 0.7.0-preview.0

package/dist/src/core/client.test.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import { findIndexAfterFraction, isThinkingDefault, isThinkingSupported, GeminiClient, } from './client.js';
+import { findCompressSplitPoint, isThinkingDefault, isThinkingSupported, GeminiClient, } from './client.js';
 import { AuthType, } from './contentGenerator.js';
 import {} from './geminiChat.js';
 import { CompressionStatus, GeminiEventType, Turn, } from './turn.js';
@@ -15,6 +15,7 @@ import { setSimulate429 } from '../utils/testUtils.js';
 import { tokenLimit } from './tokenLimits.js';
 import { ideContextStore } from '../ide/ideContext.js';
 import { ClearcutLogger } from '../telemetry/clearcut-logger/clearcut-logger.js';
+import { uiTelemetryService } from '../telemetry/uiTelemetry.js';
 // Mock fs module to prevent actual file system operations during tests
 const mockFileSystem = new Map();
 vi.mock('node:fs', () => {
@@ -76,6 +77,11 @@ vi.mock('../telemetry/index.js', () => ({
     logApiError: vi.fn(),
 }));
 vi.mock('../ide/ideContext.js');
+vi.mock('../telemetry/uiTelemetry.js', () => ({
+    uiTelemetryService: {
+        setLastPromptTokenCount: vi.fn(),
+    },
+}));
 /**
  * Array.fromAsync ponyfill, which will be available in es 2024.
  *
@@ -89,41 +95,59 @@ async function fromAsync(promise) {
     return results;
 }
 describe('findIndexAfterFraction', () => {
-    const history = [
-        { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66
-        { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68
-        { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66
-        { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68
-        { role: 'user', parts: [{ text: 'This is the fifth message.' }] }, // JSON length: 65
-    ];
-    // Total length: 333
     it('should throw an error for non-positive numbers', () => {
-        expect(() => findIndexAfterFraction(history, 0)).toThrow('Fraction must be between 0 and 1');
+        expect(() => findCompressSplitPoint([], 0)).toThrow('Fraction must be between 0 and 1');
     });
     it('should throw an error for a fraction greater than or equal to 1', () => {
-        expect(() => findIndexAfterFraction(history, 1)).toThrow('Fraction must be between 0 and 1');
+        expect(() => findCompressSplitPoint([], 1)).toThrow('Fraction must be between 0 and 1');
+    });
+    it('should handle an empty history', () => {
+        expect(findCompressSplitPoint([], 0.5)).toBe(0);
     });
     it('should handle a fraction in the middle', () => {
-        // 333 * 0.5 = 166.5
-        // 0: 66
-        // 1: 66 + 68 = 134
-        // 2: 134 + 66 = 200
-        // 200 >= 166.5, so index is 3
-        expect(findIndexAfterFraction(history, 0.5)).toBe(3);
+        const history = [
+            { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66 (19%)
+            { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68 (40%)
+            { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66 (60%)
+            { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68 (80%)
+            { role: 'user', parts: [{ text: 'This is the fifth message.' }] }, // JSON length: 65 (100%)
+        ];
+        expect(findCompressSplitPoint(history, 0.5)).toBe(2);
     });
-    it('should handle a fraction that results in the last index', () => {
-        // 333 * 0.9 = 299.7
-        // ...
-        // 3: 200 + 68 = 268
-        // 4: 268 + 65 = 333
-        // 333 >= 299.7, so index is 5
-        expect(findIndexAfterFraction(history, 0.9)).toBe(5);
+    it('should handle a fraction of last index', () => {
+        const history = [
+            { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66 (19%)
+            { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68 (40%)
+            { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66 (60%)
+            { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68 (80%)
+            { role: 'user', parts: [{ text: 'This is the fifth message.' }] }, // JSON length: 65 (100%)
+        ];
+        expect(findCompressSplitPoint(history, 0.9)).toBe(4);
     });
-    it('should handle an empty history', () => {
-        expect(findIndexAfterFraction([], 0.5)).toBe(0);
+    it('should handle a fraction of after last index', () => {
+        const history = [
+            { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66 (24%%)
+            { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68 (50%)
+            { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66 (74%)
+            { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68 (100%)
+        ];
+        expect(findCompressSplitPoint(history, 0.8)).toBe(4);
+    });
+    it('should return earlier splitpoint if no valid ones are after threshhold', () => {
+        const history = [
+            { role: 'user', parts: [{ text: 'This is the first message.' }] },
+            { role: 'model', parts: [{ text: 'This is the second message.' }] },
+            { role: 'user', parts: [{ text: 'This is the third message.' }] },
+            { role: 'model', parts: [{ functionCall: {} }] },
+        ];
+        // Can't return 4 because the previous item has a function call.
+        expect(findCompressSplitPoint(history, 0.99)).toBe(2);
     });
     it('should handle a history with only one item', () => {
-        expect(findIndexAfterFraction(history.slice(0, 1), 0.5)).toBe(1);
+        const historyWithEmptyParts = [
+            { role: 'user', parts: [{ text: 'Message 1' }] },
+        ];
+        expect(findCompressSplitPoint(historyWithEmptyParts, 0.5)).toBe(0);
     });
     it('should handle history with weird parts', () => {
         const historyWithEmptyParts = [
@@ -131,7 +155,7 @@ describe('findIndexAfterFraction', () => {
             { role: 'model', parts: [{ fileData: { fileUri: 'derp' } }] },
             { role: 'user', parts: [{ text: 'Message 2' }] },
         ];
-        expect(findIndexAfterFraction(historyWithEmptyParts, 0.5)).toBe(2);
+        expect(findCompressSplitPoint(historyWithEmptyParts, 0.5)).toBe(2);
     });
 });
 describe('isThinkingSupported', () => {
@@ -168,6 +192,7 @@ describe('Gemini Client (client.ts)', () => {
     let mockGenerateContentFn;
     beforeEach(async () => {
         vi.resetAllMocks();
+        vi.mocked(uiTelemetryService.setLastPromptTokenCount).mockClear();
         mockGenerateContentFn = vi.fn().mockResolvedValue({
             candidates: [{ content: { parts: [{ text: '{"key": "value"}' }] } }],
         });
@@ -177,7 +202,6 @@ describe('Gemini Client (client.ts)', () => {
             generateContent: mockGenerateContentFn,
             generateContentStream: vi.fn(),
             countTokens: vi.fn().mockResolvedValue({ totalTokens: 100 }),
-            embedContent: vi.fn(),
             batchEmbedContents: vi.fn(),
         };
         // Because the GeminiClient constructor kicks off an async process (startChat)
@@ -229,11 +253,18 @@ describe('Gemini Client (client.ts)', () => {
             getChatCompression: vi.fn().mockReturnValue(undefined),
             getSkipNextSpeakerCheck: vi.fn().mockReturnValue(false),
             getUseSmartEdit: vi.fn().mockReturnValue(false),
+            getUseModelRouter: vi.fn().mockReturnValue(false),
             getProjectRoot: vi.fn().mockReturnValue('/test/project/root'),
             storage: {
                 getProjectTempDir: vi.fn().mockReturnValue('/test/temp'),
             },
             getContentGenerator: vi.fn().mockReturnValue(mockContentGenerator),
+            getBaseLlmClient: vi.fn().mockReturnValue({
+                generateJson: vi.fn().mockResolvedValue({
+                    next_speaker: 'user',
+                    reasoning: 'test',
+                }),
+            }),
         };
         client = new GeminiClient(mockConfig);
         await client.initialize();
@@ -242,129 +273,6 @@ describe('Gemini Client (client.ts)', () => {
     afterEach(() => {
         vi.restoreAllMocks();
     });
-    describe('generateEmbedding', () => {
-        const texts = ['hello world', 'goodbye world'];
-        const testEmbeddingModel = 'test-embedding-model';
-        it('should call embedContent with correct parameters and return embeddings', async () => {
-            const mockEmbeddings = [
-                [0.1, 0.2, 0.3],
-                [0.4, 0.5, 0.6],
-            ];
-            vi.mocked(mockContentGenerator.embedContent).mockResolvedValue({
-                embeddings: [
-                    { values: mockEmbeddings[0] },
-                    { values: mockEmbeddings[1] },
-                ],
-            });
-            const result = await client.generateEmbedding(texts);
-            expect(mockContentGenerator.embedContent).toHaveBeenCalledTimes(1);
-            expect(mockContentGenerator.embedContent).toHaveBeenCalledWith({
-                model: testEmbeddingModel,
-                contents: texts,
-            });
-            expect(result).toEqual(mockEmbeddings);
-        });
-        it('should return an empty array if an empty array is passed', async () => {
-            const result = await client.generateEmbedding([]);
-            expect(result).toEqual([]);
-            expect(mockContentGenerator.embedContent).not.toHaveBeenCalled();
-        });
-        it('should throw an error if API response has no embeddings array', async () => {
-            vi.mocked(mockContentGenerator.embedContent).mockResolvedValue({});
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('No embeddings found in API response.');
-        });
-        it('should throw an error if API response has an empty embeddings array', async () => {
-            vi.mocked(mockContentGenerator.embedContent).mockResolvedValue({
-                embeddings: [],
-            });
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('No embeddings found in API response.');
-        });
-        it('should throw an error if API returns a mismatched number of embeddings', async () => {
-            vi.mocked(mockContentGenerator.embedContent).mockResolvedValue({
-                embeddings: [{ values: [1, 2, 3] }], // Only one for two texts
-            });
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('API returned a mismatched number of embeddings. Expected 2, got 1.');
-        });
-        it('should throw an error if any embedding has nullish values', async () => {
-            vi.mocked(mockContentGenerator.embedContent).mockResolvedValue({
-                embeddings: [{ values: [1, 2, 3] }, { values: undefined }], // Second one is bad
-            });
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('API returned an empty embedding for input text at index 1: "goodbye world"');
-        });
-        it('should throw an error if any embedding has an empty values array', async () => {
-            vi.mocked(mockContentGenerator.embedContent).mockResolvedValue({
-                embeddings: [{ values: [] }, { values: [1, 2, 3] }], // First one is bad
-            });
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('API returned an empty embedding for input text at index 0: "hello world"');
-        });
-        it('should propagate errors from the API call', async () => {
-            vi.mocked(mockContentGenerator.embedContent).mockRejectedValue(new Error('API Failure'));
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('API Failure');
-        });
-    });
-    describe('generateJson', () => {
-        it('should call generateContent with the correct parameters', async () => {
-            const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
-            const schema = { type: 'string' };
-            const abortSignal = new AbortController().signal;
-            vi.mocked(mockContentGenerator.countTokens).mockResolvedValue({
-                totalTokens: 1,
-            });
-            await client.generateJson(contents, schema, abortSignal, DEFAULT_GEMINI_FLASH_MODEL);
-            expect(mockContentGenerator.generateContent).toHaveBeenCalledWith({
-                model: DEFAULT_GEMINI_FLASH_MODEL,
-                config: {
-                    abortSignal,
-                    systemInstruction: getCoreSystemPrompt(''),
-                    temperature: 0,
-                    topP: 1,
-                    responseJsonSchema: schema,
-                    responseMimeType: 'application/json',
-                },
-                contents,
-            }, 'test-session-id');
-        });
-        it('should allow overriding model and config', async () => {
-            const contents = [
-                { role: 'user', parts: [{ text: 'hello' }] },
-            ];
-            const schema = { type: 'string' };
-            const abortSignal = new AbortController().signal;
-            const customModel = 'custom-json-model';
-            const customConfig = { temperature: 0.9, topK: 20 };
-            vi.mocked(mockContentGenerator.countTokens).mockResolvedValue({
-                totalTokens: 1,
-            });
-            await client.generateJson(contents, schema, abortSignal, customModel, customConfig);
-            expect(mockContentGenerator.generateContent).toHaveBeenCalledWith({
-                model: customModel,
-                config: {
-                    abortSignal,
-                    systemInstruction: getCoreSystemPrompt(''),
-                    temperature: 0.9,
-                    topP: 1, // from default
-                    topK: 20,
-                    responseJsonSchema: schema,
-                    responseMimeType: 'application/json',
-                },
-                contents,
-            }, 'test-session-id');
-        });
-        it('should use the Flash model when fallback mode is active', async () => {
-            const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
-            const schema = { type: 'string' };
-            const abortSignal = new AbortController().signal;
-            const requestedModel = 'gemini-2.5-pro'; // A non-flash model
-            // Mock config to be in fallback mode
-            // We access the mock via the client instance which holds the mocked config
-            vi.spyOn(client['config'], 'isInFallbackMode').mockReturnValue(true);
-            await client.generateJson(contents, schema, abortSignal, requestedModel);
-            // Assert that the Flash model was used, not the requested model
-            expect(mockContentGenerator.generateContent).toHaveBeenCalledWith(expect.objectContaining({
-                model: DEFAULT_GEMINI_FLASH_MODEL,
-            }), 'test-session-id');
-        });
-    });
     describe('addHistory', () => {
         it('should call chat.addHistory with the provided content', async () => {
             const mockChat = {
@@ -434,7 +342,7 @@ describe('Gemini Client (client.ts)', () => {
                 vi.mocked(mockContentGenerator.countTokens).mockResolvedValue({
                     totalTokens: 1000,
                 });
-                await client.tryCompressChat('prompt-id-4'); // Fails
+                await client.tryCompressChat('prompt-id-4', false); // Fails
                 const result = await client.tryCompressChat('prompt-id-4', true);
                 expect(result).toEqual({
                     compressionStatus: CompressionStatus.COMPRESSED,
@@ -447,16 +355,18 @@ describe('Gemini Client (client.ts)', () => {
                 vi.mocked(mockContentGenerator.countTokens).mockResolvedValue({
                     totalTokens: 1000,
                 });
-                const result = await client.tryCompressChat('prompt-id-4', true);
+                const result = await client.tryCompressChat('prompt-id-4', false);
                 expect(result).toEqual({
                     compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
                     newTokenCount: 5000,
                     originalTokenCount: 1000,
                 });
+                expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledWith(5000);
+                expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledTimes(1);
             });
             it('does not manipulate the source chat', async () => {
                 const { client, mockChat } = setup();
-                await client.tryCompressChat('prompt-id-4', true);
+                await client.tryCompressChat('prompt-id-4', false);
                 expect(client['chat']).toBe(mockChat); // a new chat session was not created
             });
             it('restores the history back to the original', async () => {
@@ -472,14 +382,14 @@ describe('Gemini Client (client.ts)', () => {
                 const { client } = setup({
                     chatHistory: originalHistory,
                 });
-                const { compressionStatus } = await client.tryCompressChat('prompt-id-4');
+                const { compressionStatus } = await client.tryCompressChat('prompt-id-4', false);
                 expect(compressionStatus).toBe(CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT);
                 expect(client['chat']?.setHistory).toHaveBeenCalledWith(originalHistory);
             });
             it('will not attempt to compress context after a failure', async () => {
                 const { client } = setup();
-                await client.tryCompressChat('prompt-id-4');
-                const result = await client.tryCompressChat('prompt-id-5');
+                await client.tryCompressChat('prompt-id-4', false);
+                const result = await client.tryCompressChat('prompt-id-5', false);
                 // it counts tokens for {original, compressed} and then never again
                 expect(mockContentGenerator.countTokens).toHaveBeenCalledTimes(2);
                 expect(result).toEqual({
@@ -499,7 +409,7 @@ describe('Gemini Client (client.ts)', () => {
                 totalTokens: MOCKED_TOKEN_LIMIT * 0.699, // TOKEN_THRESHOLD_FOR_SUMMARIZATION = 0.7
             });
             const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-2');
+            const result = await client.tryCompressChat('prompt-id-2', false);
             const newChat = client.getChat();
             expect(tokenLimit).toHaveBeenCalled();
             expect(result).toEqual({
@@ -536,11 +446,13 @@ describe('Gemini Client (client.ts)', () => {
                     },
                 ],
             });
-            await client.tryCompressChat('prompt-id-3');
+            await client.tryCompressChat('prompt-id-3', false);
             expect(ClearcutLogger.prototype.logChatCompressionEvent).toHaveBeenCalledWith(expect.objectContaining({
                 tokens_before: originalTokenCount,
                 tokens_after: newTokenCount,
             }));
+            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledWith(newTokenCount);
+            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledTimes(1);
         });
         it('should trigger summarization if token count is at threshold with contextPercentageThreshold setting', async () => {
             const MOCKED_TOKEN_LIMIT = 1000;
@@ -569,7 +481,7 @@ describe('Gemini Client (client.ts)', () => {
                 ],
             });
             const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-3');
+            const result = await client.tryCompressChat('prompt-id-3', false);
             const newChat = client.getChat();
             expect(tokenLimit).toHaveBeenCalled();
             expect(mockGenerateContentFn).toHaveBeenCalled();
@@ -620,7 +532,7 @@ describe('Gemini Client (client.ts)', () => {
                 ],
             });
             const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-3');
+            const result = await client.tryCompressChat('prompt-id-3', false);
             const newChat = client.getChat();
             expect(tokenLimit).toHaveBeenCalled();
             expect(mockGenerateContentFn).toHaveBeenCalled();
@@ -660,7 +572,7 @@ describe('Gemini Client (client.ts)', () => {
                 ],
             });
             const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-1', true); // force = true
+            const result = await client.tryCompressChat('prompt-id-1', false); // force = true
             const newChat = client.getChat();
             expect(mockGenerateContentFn).toHaveBeenCalled();
             expect(result).toEqual({
@@ -671,45 +583,6 @@ describe('Gemini Client (client.ts)', () => {
             // Assert that the chat was reset
             expect(newChat).not.toBe(initialChat);
         });
-        it('should use current model from config for token counting after sendMessage', async () => {
-            const initialModel = mockConfig.getModel();
-            // mock the model has been changed between calls of `countTokens`
-            const firstCurrentModel = initialModel + '-changed-1';
-            const secondCurrentModel = initialModel + '-changed-2';
-            vi.mocked(mockConfig.getModel)
-                .mockReturnValueOnce(firstCurrentModel)
-                .mockReturnValueOnce(secondCurrentModel);
-            vi.mocked(mockContentGenerator.countTokens)
-                .mockResolvedValueOnce({ totalTokens: 100000 })
-                .mockResolvedValueOnce({ totalTokens: 5000 });
-            const mockSendMessage = vi.fn().mockResolvedValue({ text: 'Summary' });
-            const mockChatHistory = [
-                { role: 'user', parts: [{ text: 'Long conversation' }] },
-                { role: 'model', parts: [{ text: 'Long response' }] },
-            ];
-            const mockChat = {
-                getHistory: vi.fn().mockReturnValue(mockChatHistory),
-                setHistory: vi.fn(),
-                sendMessage: mockSendMessage,
-            };
-            client['chat'] = mockChat;
-            client['startChat'] = vi.fn().mockResolvedValue(mockChat);
-            const result = await client.tryCompressChat('prompt-id-4', true);
-            expect(mockContentGenerator.countTokens).toHaveBeenCalledTimes(2);
-            expect(mockContentGenerator.countTokens).toHaveBeenNthCalledWith(1, {
-                model: firstCurrentModel,
-                contents: mockChatHistory,
-            });
-            expect(mockContentGenerator.countTokens).toHaveBeenNthCalledWith(2, {
-                model: secondCurrentModel,
-                contents: expect.any(Array),
-            });
-            expect(result).toEqual({
-                compressionStatus: CompressionStatus.COMPRESSED,
-                originalTokenCount: 100000,
-                newTokenCount: 5000,
-            });
-        });
     });
     describe('sendMessageStream', () => {
         it('emits a compression event when the context was automatically compressed', async () => {
@@ -785,6 +658,11 @@ describe('Gemini Client (client.ts)', () => {
                 },
             });
             vi.mocked(mockConfig.getIdeMode).mockReturnValue(true);
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.COMPRESSED,
+            });
             mockTurnRunFn.mockReturnValue((async function* () {
                 yield { type: 'content', value: 'Hello' };
             })());
@@ -870,6 +748,11 @@ ${JSON.stringify({
                 },
             });
             vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.COMPRESSED,
+            });
             const mockStream = (async function* () {
                 yield { type: 'content', value: 'Hello' };
             })();
@@ -925,6 +808,11 @@ ${JSON.stringify({
                 },
             });
             vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.COMPRESSED,
+            });
             const mockStream = (async function* () {
                 yield { type: 'content', value: 'Hello' };
             })();
@@ -1750,6 +1638,35 @@ ${JSON.stringify({
             // Assert
             expect(mockCheckNextSpeaker).not.toHaveBeenCalled();
         });
+        it('should abort linked signal when loop is detected', async () => {
+            // Arrange
+            vi.spyOn(client['loopDetector'], 'turnStarted').mockResolvedValue(false);
+            vi.spyOn(client['loopDetector'], 'addAndCheck')
+                .mockReturnValueOnce(false)
+                .mockReturnValueOnce(true);
+            let capturedSignal;
+            mockTurnRunFn.mockImplementation((model, request, signal) => {
+                capturedSignal = signal;
+                return (async function* () {
+                    yield { type: 'content', value: 'First event' };
+                    yield { type: 'content', value: 'Second event' };
+                })();
+            });
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            // Act
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-loop');
+            const events = [];
+            for await (const event of stream) {
+                events.push(event);
+            }
+            // Assert
+            expect(events).toContainEqual({ type: GeminiEventType.LoopDetected });
+            expect(capturedSignal.aborted).toBe(true);
+        });
     });
     describe('generateContent', () => {
         it('should call generateContent with the correct parameters', async () => {