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

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

@@ -4,11 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { GeminiChat, EmptyStreamError, StreamEventType, } from './geminiChat.js';
+import { GeminiChat, InvalidStreamError, StreamEventType, } from './geminiChat.js';
 import { setSimulate429 } from '../utils/testUtils.js';
 import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { AuthType } from './contentGenerator.js';
 import {} from '../utils/retry.js';
+import { Kind } from '../tools/tools.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', () => {
@@ -45,16 +47,19 @@ vi.mock('../utils/retry.js', () => ({
 vi.mock('../fallback/handler.js', () => ({
     handleFallback: mockHandleFallback,
 }));
-const { mockLogInvalidChunk, mockLogContentRetry, mockLogContentRetryFailure } = vi.hoisted(() => ({
-    mockLogInvalidChunk: vi.fn(),
+const { mockLogContentRetry, mockLogContentRetryFailure } = vi.hoisted(() => ({
     mockLogContentRetry: vi.fn(),
     mockLogContentRetryFailure: vi.fn(),
 }));
 vi.mock('../telemetry/loggers.js', () => ({
-    logInvalidChunk: mockLogInvalidChunk,
     logContentRetry: mockLogContentRetry,
     logContentRetryFailure: mockLogContentRetryFailure,
 }));
+vi.mock('../telemetry/uiTelemetry.js', () => ({
+    uiTelemetryService: {
+        setLastPromptTokenCount: vi.fn(),
+    },
+}));
 describe('GeminiChat', () => {
     let mockContentGenerator;
     let chat;
@@ -62,6 +67,7 @@ describe('GeminiChat', () => {
     const config = {};
     beforeEach(() => {
         vi.clearAllMocks();
+        vi.mocked(uiTelemetryService.setLastPromptTokenCount).mockClear();
         mockContentGenerator = {
             generateContent: vi.fn(),
             generateContentStream: vi.fn(),
@@ -179,7 +185,7 @@ describe('GeminiChat', () => {
                 for await (const _ of stream) {
                     /* consume stream */
                 }
-            })()).rejects.toThrow(EmptyStreamError);
+            })()).rejects.toThrow(InvalidStreamError);
         });
         it('should succeed if the stream ends with an invalid part but has a finishReason and contained a valid part', async () => {
             // 1. Mock a stream that sends a valid chunk, then an invalid one, but has a finish reason.
@@ -222,55 +228,6 @@ describe('GeminiChat', () => {
             expect(modelTurn?.parts?.length).toBe(1);
             expect(modelTurn?.parts[0].text).toBe('Initial valid content...');
         });
-        it('should not consolidate text into a part that also contains a functionCall', async () => {
-            // 1. Mock the API to stream a malformed part followed by a valid text part.
-            const multiChunkStream = (async function* () {
-                // This malformed part has both text and a functionCall.
-                yield {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [
-                                    {
-                                        text: 'Some text',
-                                        functionCall: { name: 'do_stuff', args: {} },
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                };
-                // This valid text part should NOT be merged into the malformed one.
-                yield {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [{ text: ' that should not be merged.' }],
-                            },
-                        },
-                    ],
-                };
-            })();
-            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(multiChunkStream);
-            // 2. Action: Send a message and consume the stream.
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-malformed-chunk');
-            for await (const _ of stream) {
-                // Consume the stream to trigger history recording.
-            }
-            // 3. Assert: Check that the final history was not incorrectly consolidated.
-            const history = chat.getHistory();
-            expect(history.length).toBe(2);
-            const modelTurn = history[1];
-            // CRUCIAL ASSERTION: There should be two separate parts.
-            // The old, non-strict logic would incorrectly merge them, resulting in one part.
-            expect(modelTurn?.parts?.length).toBe(2);
-            // Verify the contents of each part.
-            expect(modelTurn?.parts[0].text).toBe('Some text');
-            expect(modelTurn?.parts[0].functionCall).toBeDefined();
-            expect(modelTurn?.parts[1].text).toBe(' that should not be merged.');
-        });
         it('should consolidate subsequent text chunks after receiving an empty text chunk', async () => {
             // 1. Mock the API to return a stream where one chunk is just an empty text part.
             const multiChunkStream = (async function* () {
@@ -393,7 +350,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 add a placeholder model turn when a tool call is followed by an empty stream response', async () => {
+        it('should throw an error 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 = [
                 {
@@ -434,20 +391,113 @@ describe('GeminiChat', () => {
                     },
                 },
             }, 'prompt-id-stream-1');
-            for await (const _ of stream) {
-                // This loop consumes the stream to trigger the internal logic.
-            }
-            // 4. Assert: The history should now have four valid, alternating turns.
-            const history = chat.getHistory();
-            expect(history.length).toBe(4);
-            // The final turn must be the empty model placeholder.
-            const lastTurn = history[3];
-            expect(lastTurn.role).toBe('model');
-            expect(lastTurn?.parts?.length).toBe(0);
-            // The second-to-last turn must be the function response we sent.
-            const secondToLastTurn = history[2];
-            expect(secondToLastTurn.role).toBe('user');
-            expect(secondToLastTurn?.parts[0].functionResponse).toBeDefined();
+            // 4. Assert: The stream processing should throw an InvalidStreamError.
+            await expect((async () => {
+                for await (const _ of stream) {
+                    // This loop consumes the stream to trigger the internal logic.
+                }
+            })()).rejects.toThrow(InvalidStreamError);
+        });
+        it('should succeed when there is a tool call without finish reason', async () => {
+            // Setup: Stream with tool call but no finish reason
+            const streamWithToolCall = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [
+                                    {
+                                        functionCall: {
+                                            name: 'test_function',
+                                            args: { param: 'value' },
+                                        },
+                                    },
+                                ],
+                            },
+                            // No finishReason
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithToolCall);
+            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-1');
+            // Should not throw an error
+            await expect((async () => {
+                for await (const _ of stream) {
+                    // consume stream
+                }
+            })()).resolves.not.toThrow();
+        });
+        it('should throw InvalidStreamError when no tool call and no finish reason', async () => {
+            // Setup: Stream with text but no finish reason and no tool call
+            const streamWithoutFinishReason = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'some response' }],
+                            },
+                            // No finishReason
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithoutFinishReason);
+            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-1');
+            await expect((async () => {
+                for await (const _ of stream) {
+                    // consume stream
+                }
+            })()).rejects.toThrow(InvalidStreamError);
+        });
+        it('should throw InvalidStreamError when no tool call and empty response text', async () => {
+            // Setup: Stream with finish reason but empty response (only thoughts)
+            const streamWithEmptyResponse = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ thought: 'thinking...' }],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithEmptyResponse);
+            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-1');
+            await expect((async () => {
+                for await (const _ of stream) {
+                    // consume stream
+                }
+            })()).rejects.toThrow(InvalidStreamError);
+        });
+        it('should succeed when there is finish reason and response text', async () => {
+            // Setup: Stream with both finish reason and text content
+            const validStream = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'valid response' }],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(validStream);
+            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-1');
+            // Should not throw an error
+            await expect((async () => {
+                for await (const _ of stream) {
+                    // consume stream
+                }
+            })()).resolves.not.toThrow();
         });
         it('should call generateContentStream with the correct parameters', async () => {
             const response = (async function* () {
@@ -464,6 +514,11 @@ describe('GeminiChat', () => {
                         },
                     ],
                     text: () => 'response',
+                    usageMetadata: {
+                        promptTokenCount: 42,
+                        candidatesTokenCount: 15,
+                        totalTokenCount: 57,
+                    },
                 };
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(response);
@@ -481,135 +536,9 @@ describe('GeminiChat', () => {
                 ],
                 config: {},
             }, 'prompt-id-1');
-        });
-    });
-    describe('recordHistory', () => {
-        const userInput = {
-            role: 'user',
-            parts: [{ text: 'User input' }],
-        };
-        it('should consolidate all consecutive model turns into a single turn', () => {
-            const userInput = {
-                role: 'user',
-                parts: [{ text: 'User input' }],
-            };
-            // This simulates a multi-part model response with different part types.
-            const modelOutput = [
-                { role: 'model', parts: [{ text: 'Thinking...' }] },
-                {
-                    role: 'model',
-                    parts: [{ functionCall: { name: 'do_stuff', args: {} } }],
-                },
-            ];
-            // @ts-expect-error Accessing private method for testing
-            chat.recordHistory(userInput, modelOutput);
-            const history = chat.getHistory();
-            // The history should contain the user's turn and ONE consolidated model turn.
-            // The old code would fail here, resulting in a length of 3.
-            //expect(history).toBe([]);
-            expect(history.length).toBe(2);
-            const modelTurn = history[1];
-            expect(modelTurn.role).toBe('model');
-            // The consolidated turn should contain both the text part and the functionCall part.
-            expect(modelTurn?.parts?.length).toBe(2);
-            expect(modelTurn?.parts[0].text).toBe('Thinking...');
-            expect(modelTurn?.parts[1].functionCall).toBeDefined();
-        });
-        it('should add a placeholder model turn when a tool call is followed by an empty response', () => {
-            // 1. Setup: A history where the model has just made a function call.
-            const initialHistory = [
-                { role: 'user', parts: [{ text: 'Initial prompt' }] },
-                {
-                    role: 'model',
-                    parts: [{ functionCall: { name: 'test_tool', args: {} } }],
-                },
-            ];
-            chat.setHistory(initialHistory);
-            // 2. Action: The user provides the tool's response, and the model's
-            // final output is empty (e.g., just a thought, which gets filtered out).
-            const functionResponse = {
-                role: 'user',
-                parts: [{ functionResponse: { name: 'test_tool', response: {} } }],
-            };
-            const emptyModelOutput = [];
-            // @ts-expect-error Accessing private method for testing
-            chat.recordHistory(functionResponse, emptyModelOutput, [
-                functionResponse,
-            ]);
-            // 3. Assert: The history should now have four valid, alternating turns.
-            const history = chat.getHistory();
-            expect(history.length).toBe(4);
-            // The final turn must be the empty model placeholder.
-            const lastTurn = history[3];
-            expect(lastTurn.role).toBe('model');
-            expect(lastTurn?.parts?.length).toBe(0);
-            // The second-to-last turn must be the function response we provided.
-            const secondToLastTurn = history[2];
-            expect(secondToLastTurn.role).toBe('user');
-            expect(secondToLastTurn?.parts[0].functionResponse).toBeDefined();
-        });
-        it('should add user input and a single model output to history', () => {
-            const modelOutput = [
-                { role: 'model', parts: [{ text: 'Model output' }] },
-            ];
-            // @ts-expect-error Accessing private method for testing
-            chat.recordHistory(userInput, modelOutput);
-            const history = chat.getHistory();
-            expect(history.length).toBe(2);
-            expect(history[0]).toEqual(userInput);
-            expect(history[1]).toEqual(modelOutput[0]);
-        });
-        it('should consolidate adjacent text parts from multiple content objects', () => {
-            const modelOutput = [
-                { role: 'model', parts: [{ text: 'Part 1.' }] },
-                { role: 'model', parts: [{ text: ' Part 2.' }] },
-                { role: 'model', parts: [{ text: ' Part 3.' }] },
-            ];
-            // @ts-expect-error Accessing private method for testing
-            chat.recordHistory(userInput, modelOutput);
-            const history = chat.getHistory();
-            expect(history.length).toBe(2);
-            expect(history[1].role).toBe('model');
-            expect(history[1].parts).toEqual([{ text: 'Part 1. Part 2. Part 3.' }]);
-        });
-        it('should add an empty placeholder turn if modelOutput is empty', () => {
-            // This simulates receiving a pre-filtered, thought-only response.
-            const emptyModelOutput = [];
-            // @ts-expect-error Accessing private method for testing
-            chat.recordHistory(userInput, emptyModelOutput);
-            const history = chat.getHistory();
-            expect(history.length).toBe(2);
-            expect(history[0]).toEqual(userInput);
-            expect(history[1].role).toBe('model');
-            expect(history[1].parts).toEqual([]);
-        });
-        it('should preserve model outputs with undefined or empty parts arrays', () => {
-            const malformedOutput = [
-                { role: 'model', parts: [{ text: 'Text part' }] },
-                { role: 'model', parts: undefined },
-                { role: 'model', parts: [] },
-            ];
-            // @ts-expect-error Accessing private method for testing
-            chat.recordHistory(userInput, malformedOutput);
-            const history = chat.getHistory();
-            expect(history.length).toBe(4); // userInput + 3 model turns
-            expect(history[1].parts).toEqual([{ text: 'Text part' }]);
-            expect(history[2].parts).toBeUndefined();
-            expect(history[3].parts).toEqual([]);
-        });
-        it('should not consolidate content with different roles', () => {
-            const mixedOutput = [
-                { role: 'model', parts: [{ text: 'Model 1' }] },
-                { role: 'user', parts: [{ text: 'Unexpected User' }] },
-                { role: 'model', parts: [{ text: 'Model 2' }] },
-            ];
-            // @ts-expect-error Accessing private method for testing
-            chat.recordHistory(userInput, mixedOutput);
-            const history = chat.getHistory();
-            expect(history.length).toBe(4); // userInput, model1, unexpected_user, model2
-            expect(history[1]).toEqual(mixedOutput[0]);
-            expect(history[2]).toEqual(mixedOutput[1]);
-            expect(history[3]).toEqual(mixedOutput[2]);
+            // Verify that token counting is called when usageMetadata is present
+            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledWith(42);
+            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledTimes(1);
         });
     });
     describe('addHistory', () => {
@@ -702,7 +631,6 @@ describe('GeminiChat', () => {
                 chunks.push(chunk);
             }
             // Assertions
-            expect(mockLogInvalidChunk).toHaveBeenCalledTimes(1);
             expect(mockLogContentRetry).toHaveBeenCalledTimes(1);
             expect(mockLogContentRetryFailure).not.toHaveBeenCalled();
             expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(2);
@@ -723,6 +651,8 @@ describe('GeminiChat', () => {
                 role: 'model',
                 parts: [{ text: 'Successful response' }],
             });
+            // Verify that token counting is not called when usageMetadata is missing
+            expect(uiTelemetryService.setLastPromptTokenCount).not.toHaveBeenCalled();
         });
         it('should fail after all retries on persistent invalid content and report metrics', async () => {
             vi.mocked(mockContentGenerator.generateContentStream).mockImplementation(async () => (async function* () {
@@ -742,11 +672,10 @@ describe('GeminiChat', () => {
                 for await (const _ of stream) {
                     // Must loop to trigger the internal logic that throws.
                 }
-            }).rejects.toThrow(EmptyStreamError);
-            // Should be called 3 times (initial + 2 retries)
-            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(3);
-            expect(mockLogInvalidChunk).toHaveBeenCalledTimes(3);
-            expect(mockLogContentRetry).toHaveBeenCalledTimes(2);
+            }).rejects.toThrow(InvalidStreamError);
+            // Should be called 2 times (initial + 1 retry)
+            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(2);
+            expect(mockLogContentRetry).toHaveBeenCalledTimes(1);
             expect(mockLogContentRetryFailure).toHaveBeenCalledTimes(1);
             // History should be clean, as if the failed turn never happened.
             const history = chat.getHistory();
@@ -922,6 +851,215 @@ describe('GeminiChat', () => {
         }
         expect(turn4.parts[0].text).toBe('second response');
     });
+    describe('stopBeforeSecondMutator', () => {
+        beforeEach(() => {
+            // Common setup for these tests: mock the tool registry.
+            const mockToolRegistry = {
+                getTool: vi.fn((toolName) => {
+                    if (toolName === 'edit') {
+                        return { kind: Kind.Edit };
+                    }
+                    return { kind: Kind.Other };
+                }),
+            };
+            vi.mocked(mockConfig.getToolRegistry).mockReturnValue(mockToolRegistry);
+        });
+        it('should stop streaming before a second mutator tool call', async () => {
+            const responses = [
+                {
+                    candidates: [
+                        { content: { role: 'model', parts: [{ text: 'First part. ' }] } },
+                    ],
+                },
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ functionCall: { name: 'edit', args: {} } }],
+                            },
+                        },
+                    ],
+                },
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ functionCall: { name: 'fetch', args: {} } }],
+                            },
+                        },
+                    ],
+                },
+                // This chunk contains the second mutator and should be clipped.
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [
+                                    { functionCall: { name: 'edit', args: {} } },
+                                    { text: 'some trailing text' },
+                                ],
+                            },
+                        },
+                    ],
+                },
+                // This chunk should never be reached.
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'This should not appear.' }],
+                            },
+                        },
+                    ],
+                },
+            ];
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue((async function* () {
+                for (const response of responses) {
+                    yield response;
+                }
+            })());
+            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-mutator-test');
+            for await (const _ of stream) {
+                // Consume the stream to trigger history recording.
+            }
+            const history = chat.getHistory();
+            expect(history.length).toBe(2);
+            const modelTurn = history[1];
+            expect(modelTurn.role).toBe('model');
+            expect(modelTurn?.parts?.length).toBe(3);
+            expect(modelTurn?.parts[0].text).toBe('First part. ');
+            expect(modelTurn.parts[1].functionCall?.name).toBe('edit');
+            expect(modelTurn.parts[2].functionCall?.name).toBe('fetch');
+        });
+        it('should not stop streaming if only one mutator is present', async () => {
+            const responses = [
+                {
+                    candidates: [
+                        { content: { role: 'model', parts: [{ text: 'Part 1. ' }] } },
+                    ],
+                },
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ functionCall: { name: 'edit', args: {} } }],
+                            },
+                        },
+                    ],
+                },
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'Part 2.' }],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                },
+            ];
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue((async function* () {
+                for (const response of responses) {
+                    yield response;
+                }
+            })());
+            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-one-mutator');
+            for await (const _ of stream) {
+                /* consume */
+            }
+            const history = chat.getHistory();
+            const modelTurn = history[1];
+            expect(modelTurn?.parts?.length).toBe(3);
+            expect(modelTurn.parts[1].functionCall?.name).toBe('edit');
+            expect(modelTurn.parts[2].text).toBe('Part 2.');
+        });
+        it('should clip the chunk containing the second mutator, preserving prior parts', async () => {
+            const responses = [
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ functionCall: { name: 'edit', args: {} } }],
+                            },
+                        },
+                    ],
+                },
+                // This chunk has a valid part before the second mutator.
+                // The valid part should be kept, the rest of the chunk discarded.
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [
+                                    { text: 'Keep this text. ' },
+                                    { functionCall: { name: 'edit', args: {} } },
+                                    { text: 'Discard this text.' },
+                                ],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                },
+            ];
+            const stream = (async function* () {
+                for (const response of responses) {
+                    yield response;
+                }
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(stream);
+            const resultStream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-clip-chunk');
+            for await (const _ of resultStream) {
+                /* consume */
+            }
+            const history = chat.getHistory();
+            const modelTurn = history[1];
+            expect(modelTurn?.parts?.length).toBe(2);
+            expect(modelTurn.parts[0].functionCall?.name).toBe('edit');
+            expect(modelTurn.parts[1].text).toBe('Keep this text. ');
+        });
+        it('should handle two mutators in the same chunk (parallel call scenario)', async () => {
+            const responses = [
+                {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [
+                                    { text: 'Some text. ' },
+                                    { functionCall: { name: 'edit', args: {} } },
+                                    { functionCall: { name: 'edit', args: {} } },
+                                ],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                },
+            ];
+            const stream = (async function* () {
+                for (const response of responses) {
+                    yield response;
+                }
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(stream);
+            const resultStream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-parallel-mutators');
+            for await (const _ of resultStream) {
+                /* consume */
+            }
+            const history = chat.getHistory();
+            const modelTurn = history[1];
+            expect(modelTurn?.parts?.length).toBe(2);
+            expect(modelTurn.parts[0].text).toBe('Some text. ');
+            expect(modelTurn.parts[1].functionCall?.name).toBe('edit');
+        });
+    });
     describe('Model Resolution', () => {
         const mockResponse = {
             candidates: [