@google/gemini-cli-core 0.56.0 → 0.57.0-preview.0

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ApiError, ThinkingLevel, } from '@google/genai';
+import { ApiError, ThinkingLevel, Language, } from '@google/genai';
 import { GeminiChat, InvalidStreamError, StreamEventType, SYNTHETIC_THOUGHT_SIGNATURE, stripToolCallIdPrefixes, coalesceConsecutiveRoles, stripThoughts, } from './geminiChat.js';
 import { CoreToolCallStatus, } from '../scheduler/types.js';
 import { MockTool } from '../test-utils/mock-tool.js';
@@ -603,7 +603,7 @@ describe('GeminiChat', () => {
             expect(modelTurn?.parts?.length).toBe(1);
             expect(modelTurn?.parts[0].text).toBe('This is the visible text that should not be lost.');
         });
-        it('should throw an error when a tool call is followed by an empty stream response', async () => {
+        it('should succeed when a tool call is followed by an empty stream response', async () => {
             // 1. Setup: A history where the model has just made a function call.
             const initialHistory = [
                 {
@@ -648,12 +648,16 @@ describe('GeminiChat', () => {
                     response: { name: 'Vesuvio' },
                 },
             }, 'prompt-id-stream-1', new AbortController().signal, LlmRole.MAIN);
-            // 4. Assert: The stream processing should throw an InvalidStreamError.
+            // 4. Assert: The stream processing should succeed.
             await expect((async () => {
                 for await (const _ of stream) {
                     // This loop consumes the stream to trigger the internal logic.
                 }
-            })()).rejects.toThrow(InvalidStreamError);
+            })()).resolves.not.toThrow();
+            // Verify history now ends with a successful model turn (with empty parts)
+            const lastTurn = chat.agentHistory.get()[chat.agentHistory.length - 1];
+            expect(lastTurn.content.role).toBe('model');
+            expect(lastTurn.content.parts).toEqual([]);
         });
         it('should succeed when there is a tool call without finish reason', async () => {
             // Setup: Stream with tool call but no finish reason
@@ -715,7 +719,7 @@ describe('GeminiChat', () => {
             // Verify history has been rolled back to its initial state
             expect(chat.agentHistory.length).toBe(initialHistoryLength);
         });
-        it('should preserve function responses during rollback when InvalidStreamError is thrown', async () => {
+        it('should preserve function responses and matching model turn when empty stream response is received', async () => {
             // 1. Setup history ending with a model turn containing functionCall
             chat.agentHistory.push({
                 id: 'model-turn-1',
@@ -732,7 +736,7 @@ describe('GeminiChat', () => {
                 },
             });
             const initialHistoryLength = chat.agentHistory.length;
-            // Setup: Stream that will throw InvalidStreamError
+            // Setup: Stream with empty parts
             const streamWithNoResponseText = (async function* () {
                 yield {
                     candidates: [
@@ -758,11 +762,13 @@ describe('GeminiChat', () => {
                 for await (const _ of stream) {
                     // consume
                 }
-            })()).rejects.toThrow(InvalidStreamError);
-            // Verify that history was NOT rolled back, i.e., function response is preserved!
-            expect(chat.agentHistory.length).toBe(initialHistoryLength + 1);
-            const lastTurn = chat.agentHistory.get()[chat.agentHistory.length - 1];
-            expect(lastTurn.content.parts?.[0]?.functionResponse).toBeDefined();
+            })()).resolves.not.toThrow();
+            // Verify that history contains both the function response and the matched empty model response turn
+            expect(chat.agentHistory.length).toBe(initialHistoryLength + 2);
+            const turns = chat.agentHistory.get();
+            expect(turns[turns.length - 2].content.parts?.[0]?.functionResponse).toBeDefined();
+            expect(turns[turns.length - 1].content.role).toBe('model');
+            expect(turns[turns.length - 1].content.parts).toEqual([]);
         });
         it('should not fuse the next user message into a preserved tool-response turn', async () => {
             // Regression: when a stream fails mid tool-loop the tool response is
@@ -778,7 +784,7 @@ describe('GeminiChat', () => {
                     parts: [{ functionCall: { name: 'test_tool', args: {} } }],
                 },
             });
-            // 1. Tool response goes back, model returns nothing -> InvalidStreamError.
+            // 1. Tool response goes back, model returns nothing -> succeeds under Option 2.
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue((async function* () {
                 yield {
                     candidates: [
@@ -786,7 +792,7 @@ describe('GeminiChat', () => {
                     ],
                 };
             })());
-            const failingStream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, [
+            const successfulStream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, [
                 {
                     functionResponse: {
                         name: 'test_tool',
@@ -795,10 +801,10 @@ describe('GeminiChat', () => {
                 },
             ], 'prompt-id-fusion-setup', new AbortController().signal, LlmRole.MAIN);
             await expect((async () => {
-                for await (const _ of failingStream) {
+                for await (const _ of successfulStream) {
                     // consume
                 }
-            })()).rejects.toThrow(InvalidStreamError);
+            })()).resolves.not.toThrow();
             // 2. The user types a brand new instruction.
             let capturedContents = [];
             vi.mocked(mockContentGenerator.generateContentStream).mockImplementation(async (req) => {
@@ -937,7 +943,7 @@ describe('GeminiChat', () => {
                 },
             });
             const initialHistoryLength = chat.agentHistory.length;
-            // Setup: Stream that will throw InvalidStreamError
+            // Setup: Stream with empty parts
             const streamWithNoResponseText = (async function* () {
                 yield {
                     candidates: [
@@ -969,12 +975,14 @@ describe('GeminiChat', () => {
                 for await (const _ of stream) {
                     // consume
                 }
-            })()).rejects.toThrow(InvalidStreamError);
-            // Verify that history was NOT rolled back, i.e., function response and sibling fileData are preserved!
-            expect(chat.agentHistory.length).toBe(initialHistoryLength + 1);
-            const lastTurn = chat.agentHistory.get()[chat.agentHistory.length - 1];
-            expect(lastTurn.content.parts?.[0]?.functionResponse).toBeDefined();
-            expect(lastTurn.content.parts?.[1]?.fileData).toBeDefined();
+            })()).resolves.not.toThrow();
+            // Verify that history contains both the function response and the matched empty model response turn
+            expect(chat.agentHistory.length).toBe(initialHistoryLength + 2);
+            const turns = chat.agentHistory.get();
+            expect(turns[turns.length - 2].content.parts?.[0]?.functionResponse).toBeDefined();
+            expect(turns[turns.length - 2].content.parts?.[1]?.fileData).toBeDefined();
+            expect(turns[turns.length - 1].content.role).toBe('model');
+            expect(turns[turns.length - 1].content.parts).toEqual([]);
         });
         it('should restore the lastPromptTokenCount baseline on history rollback when InvalidStreamError is thrown', async () => {
             // Establish an initial token count baseline
@@ -1201,6 +1209,101 @@ describe('GeminiChat', () => {
             // Verify history has been rolled back to its initial state
             expect(chat.agentHistory.length).toBe(initialHistoryLength);
         });
+        it('should roll back the un-responded user turn from history when stream consumption is broken out of early', async () => {
+            const initialHistoryLength = chat.agentHistory.length;
+            // Setup: A multi-chunk stream that would succeed if fully consumed
+            const activeStream = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'chunk 1' }],
+                            },
+                        },
+                    ],
+                };
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'chunk 2' }],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(activeStream);
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test early exit message', 'prompt-id-early-exit', new AbortController().signal, LlmRole.MAIN);
+            // Verify the user turn WAS added during sendMessageStream
+            expect(chat.agentHistory.length).toBe(initialHistoryLength + 1);
+            // Consume only the first chunk and break out of the loop early!
+            for await (const chunk of stream) {
+                expect(chunk.type).toBe(StreamEventType.CHUNK);
+                break; // Trigger early exit, calling generator.return() under the hood
+            }
+            // Verify history has been rolled back to its initial state because of the early exit
+            expect(chat.agentHistory.length).toBe(initialHistoryLength);
+        });
+        it('should roll back the entire multi-turn request including function responses when a continuation stream is aborted/cancelled', async () => {
+            const initialHistoryLength = chat.agentHistory.length;
+            const abortController = new AbortController();
+            // 1. Send the first message of the prompt. This will succeed and register prompt-id-multi-turn-abort.
+            const streamFirst = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'model first response' }],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamFirst);
+            const s1 = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'user original prompt', 'prompt-id-multi-turn-abort', new AbortController().signal, LlmRole.MAIN);
+            for await (const _ of s1) {
+                // consume the stream
+            }
+            // Expect history to contain: user, model
+            expect(chat.agentHistory.length).toBe(initialHistoryLength + 2);
+            // 2. Send a continuation (functionResponse), which is cancelled mid-stream.
+            const streamSecond = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'partial model response before abort' }],
+                            },
+                        },
+                    ],
+                };
+                abortController.abort();
+                throw new Error('User aborted a continuation stream.');
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamSecond);
+            const s2 = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, [
+                {
+                    functionResponse: {
+                        id: 'call_id_1',
+                        name: 'my_tool',
+                        response: { result: 'success' },
+                    },
+                },
+            ], 'prompt-id-multi-turn-abort', abortController.signal, LlmRole.MAIN);
+            await expect((async () => {
+                for await (const _ of s2) {
+                    // consume the stream to trigger abort
+                }
+            })()).rejects.toThrow();
+            // Verify history has been rolled back entirely to initialHistoryLength (before the original prompt started)!
+            expect(chat.agentHistory.length).toBe(initialHistoryLength);
+        });
         it('should roll back the un-responded user turn from history when an ApiError is thrown', async () => {
             const initialHistoryLength = chat.agentHistory.length;
             // Setup: Stream that throws a standard API error
@@ -1646,6 +1749,43 @@ describe('GeminiChat', () => {
             });
             expect(geminiWrite).toBeDefined();
         });
+        it('should accept a completely empty response without throwing NO_RESPONSE_TEXT if the input is a tool response (isOriginalFunctionResponse is true)', async () => {
+            // Mock an empty stream response with no text/thoughts
+            const responseStream = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(responseStream);
+            // We send a functionResponse message so that isOriginalFunctionResponse is true
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, [
+                {
+                    functionResponse: {
+                        name: 'edit_file',
+                        response: { success: true },
+                    },
+                },
+            ], 'prompt-id-empty-tool-response', new AbortController().signal, LlmRole.MAIN);
+            let error = undefined;
+            try {
+                for await (const _ of stream) {
+                    // consume
+                }
+            }
+            catch (err) {
+                error = err;
+            }
+            // It should NOT throw InvalidStreamError NO_RESPONSE_TEXT
+            expect(error).toBeUndefined();
+        });
     });
     describe('addHistory', () => {
         it('should add a new content item to the history', () => {
@@ -3346,5 +3486,76 @@ describe('GeminiChat', () => {
             expect(stripped[0]).toHaveProperty('metadata', { some: 'value' });
         });
     });
+    describe('isValidContent via curated history', () => {
+        it('should strip turns with truly empty text parts and no other keys', () => {
+            const chat = new GeminiChat(mockConfig, '', [], []);
+            chat.setHistory([
+                { role: 'user', parts: [{ text: 'User prompt' }] },
+                { role: 'model', parts: [{ text: '' }] },
+            ]);
+            // Curated history should strip the invalid model turn
+            const history = chat.getHistory(true);
+            expect(history).toHaveLength(1);
+            expect(history[0].role).toBe('user');
+        });
+        it('should preserve turns with empty text parts that contain functionCall', () => {
+            const chat = new GeminiChat(mockConfig, '', [], []);
+            chat.setHistory([
+                { role: 'user', parts: [{ text: 'User prompt' }] },
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            text: '',
+                            functionCall: { name: 'test_tool', args: {} },
+                        },
+                    ],
+                },
+            ]);
+            // Curated history should preserve the valid model turn because of functionCall
+            const history = chat.getHistory(true);
+            expect(history).toHaveLength(2);
+            expect(history[1].role).toBe('model');
+        });
+        it('should preserve turns with empty text parts that contain functionResponse, inlineData, or fileData', () => {
+            const chat = new GeminiChat(mockConfig, '', [], []);
+            chat.setHistory([
+                { role: 'user', parts: [{ text: 'User prompt' }] },
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            text: '',
+                            functionResponse: { name: 'test_tool', response: {} },
+                        },
+                    ],
+                },
+            ]);
+            const history = chat.getHistory(true);
+            expect(history).toHaveLength(2);
+            expect(history[1].role).toBe('model');
+        });
+        it('should preserve turns with empty text parts that contain executableCode or codeExecutionResult', () => {
+            const chat = new GeminiChat(mockConfig, '', [], []);
+            chat.setHistory([
+                { role: 'user', parts: [{ text: 'User prompt' }] },
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            text: '',
+                            executableCode: {
+                                language: Language.PYTHON,
+                                code: 'print("test")',
+                            },
+                        },
+                    ],
+                },
+            ]);
+            const history = chat.getHistory(true);
+            expect(history).toHaveLength(2);
+            expect(history[1].role).toBe('model');
+        });
+    });
 });
 //# sourceMappingURL=geminiChat.test.js.map