@machina.ai/cell-cli-core 1.41.1-rc2 → 1.45.1-rc2

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

@@ -5,7 +5,7 @@
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { ApiError, ThinkingLevel, } from '@google/genai';
-import { GeminiChat, InvalidStreamError, StreamEventType, SYNTHETIC_THOUGHT_SIGNATURE, } from './geminiChat.js';
+import { GeminiChat, InvalidStreamError, StreamEventType, SYNTHETIC_THOUGHT_SIGNATURE, stripToolCallIdPrefixes, } from './geminiChat.js';
 import { CoreToolCallStatus, } from '../scheduler/types.js';
 import { MockTool } from '../test-utils/mock-tool.js';
 import { setSimulate429 } from '../utils/testUtils.js';
@@ -19,6 +19,7 @@ import { createAvailabilityServiceMock } from '../availability/testUtils.js';
 import * as policyHelpers from '../availability/policyHelpers.js';
 import { makeResolvedModelConfig } from '../services/modelConfigServiceTestUtils.js';
 import { LlmRole } from '../telemetry/types.js';
+import { BINARY_INJECTION_KEY } from '../utils/generateContentResponseUtilities.js';
 // Mock fs module to prevent actual file system operations during tests
 const mockFileSystem = new Map();
 vi.mock('node:fs', () => {
@@ -118,6 +119,7 @@ describe('GeminiChat', () => {
             getTelemetryLogPromptsEnabled: () => true,
             getTelemetryTracesEnabled: () => false,
             getUsageStatisticsEnabled: () => true,
+            hasGemini35FlashGAAccess: vi.fn().mockReturnValue(false),
             getDebugMode: () => false,
             getContentGeneratorConfig: vi.fn().mockImplementation(() => ({
                 authType: 'oauth-personal',
@@ -192,8 +194,8 @@ describe('GeminiChat', () => {
     describe('constructor', () => {
         it('should initialize lastPromptTokenCount based on history size', () => {
             const history = [
-                { role: 'user', parts: [{ text: 'Hello' }] },
-                { role: 'model', parts: [{ text: 'Hi there' }] },
+                { id: '1', content: { role: 'user', parts: [{ text: 'Hello' }] } },
+                { id: '2', content: { role: 'model', parts: [{ text: 'Hi there' }] } },
             ];
             const chatWithHistory = new GeminiChat(mockConfig, '', [], history);
             // 'Hello': 5 chars * 0.25 = 1.25
@@ -205,22 +207,69 @@ describe('GeminiChat', () => {
             const chatEmpty = new GeminiChat(mockConfig);
             expect(chatEmpty.getLastPromptTokenCount()).toBe(0);
         });
+        it('should prioritize in-memory history over resumedSessionData', () => {
+            // This test simulates a "hot restart" after a context management operation
+            // like compression, where the in-memory history is shorter and more up-to-date
+            // than the session data that might be on disk.
+            // 1. A stale, longer history from a persisted session record
+            const resumedSessionData = {
+                conversation: {
+                    messages: [
+                        {
+                            id: 'a',
+                            type: 'user',
+                            content: [{ text: 'turn 1' }],
+                            create_time: new Date(),
+                        },
+                        {
+                            id: 'b',
+                            type: 'gemini',
+                            content: [{ text: 'turn 2' }],
+                            create_time: new Date(),
+                        },
+                        {
+                            id: 'c',
+                            type: 'user',
+                            content: [{ text: 'turn 3' }],
+                            create_time: new Date(),
+                        },
+                    ],
+                },
+            };
+            // 2. A fresh, compressed in-memory history
+            const compressedHistory = [
+                {
+                    id: 'summary-1',
+                    content: { role: 'user', parts: [{ text: 'summary of turns 1-3' }] },
+                },
+            ];
+            // 3. Instantiate the chat, providing both.
+            const chat = new GeminiChat(mockConfig, '', [], compressedHistory, // This should be prioritized
+            resumedSessionData);
+            // 4. Assert that the shorter, in-memory history was used.
+            const finalHistory = chat.getHistoryTurns();
+            expect(finalHistory).toHaveLength(1);
+            expect(finalHistory[0].id).toBe('summary-1');
+        });
     });
     describe('setHistory', () => {
         it('should recalculate lastPromptTokenCount when history is updated', () => {
             const initialHistory = [
-                { role: 'user', parts: [{ text: 'Hello' }] },
+                { id: '1', content: { role: 'user', parts: [{ text: 'Hello' }] } },
             ];
             const chatWithHistory = new GeminiChat(mockConfig, '', [], initialHistory);
             const initialCount = chatWithHistory.getLastPromptTokenCount();
             const newHistory = [
                 {
-                    role: 'user',
-                    parts: [
-                        {
-                            text: 'This is a much longer history item that should result in more tokens than just hello.',
-                        },
-                    ],
+                    id: '2',
+                    content: {
+                        role: 'user',
+                        parts: [
+                            {
+                                text: 'This is a much longer history item that should result in more tokens than just hello.',
+                            },
+                        ],
+                    },
                 },
             ];
             chatWithHistory.setHistory(newHistory);
@@ -263,9 +312,9 @@ describe('GeminiChat', () => {
                 }
             })()).resolves.not.toThrow();
             // 3. Verify history was recorded correctly
-            const history = chat.getHistory();
+            const history = chat.getHistoryTurns();
             expect(history.length).toBe(2); // user turn + model turn
-            const modelTurn = history[1];
+            const modelTurn = history[1].content;
             expect(modelTurn?.parts?.length).toBe(1); // The empty part is discarded
             expect(modelTurn?.parts[0].functionCall).toBeDefined();
         });
@@ -338,9 +387,9 @@ describe('GeminiChat', () => {
                 }
             })()).resolves.not.toThrow();
             // 3. Verify history was recorded correctly with only the valid part.
-            const history = chat.getHistory();
+            const history = chat.getHistoryTurns();
             expect(history.length).toBe(2); // user turn + model turn
-            const modelTurn = history[1];
+            const modelTurn = history[1].content;
             expect(modelTurn?.parts?.length).toBe(1);
             expect(modelTurn?.parts[0].text).toBe('Initial valid content...');
         });
@@ -371,9 +420,9 @@ describe('GeminiChat', () => {
                 // Consume the stream
             }
             // 3. Assert: Check that the final history was correctly consolidated.
-            const history = chat.getHistory();
+            const history = chat.getHistoryTurns();
             expect(history.length).toBe(2);
-            const modelTurn = history[1];
+            const modelTurn = history[1].content;
             expect(modelTurn?.parts?.length).toBe(1);
             expect(modelTurn?.parts[0].text).toBe('Hello World!');
         });
@@ -419,10 +468,10 @@ describe('GeminiChat', () => {
                 // Consume the stream to trigger history recording.
             }
             // 3. Assert: Check that the final history was correctly consolidated.
-            const history = chat.getHistory();
+            const history = chat.getHistoryTurns();
             // The history should contain the user's turn and ONE consolidated model turn.
             expect(history.length).toBe(2);
-            const modelTurn = history[1];
+            const modelTurn = history[1].content;
             expect(modelTurn.role).toBe('model');
             // The model turn should have 3 distinct parts: the merged text, the function call, and the final text.
             expect(modelTurn?.parts?.length).toBe(3);
@@ -430,6 +479,86 @@ describe('GeminiChat', () => {
             expect(modelTurn.parts[1].functionCall).toBeDefined();
             expect(modelTurn.parts[2].text).toBe('This is the second part.');
         });
+        it('repro: should not overwrite parallel tool calls when they arrive in separate streaming chunks', async () => {
+            vi.mocked(mockConfig.isContextManagementEnabled).mockReturnValue(true);
+            // 1. Mock the API to return parallel tool calls in separate chunks.
+            const parallelCallsStream = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ functionCall: { name: 'tool_A' } }],
+                            },
+                        },
+                    ],
+                    functionCalls: [{ name: 'tool_A' }],
+                };
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ functionCall: { name: 'tool_B' } }],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                    functionCalls: [{ name: 'tool_B' }],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(parallelCallsStream);
+            // 2. Action: Send a message and consume the stream to trigger history recording.
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test parallel tools', 'prompt-parallel-tools', new AbortController().signal, LlmRole.MAIN);
+            for await (const _ of stream) {
+                // Consume
+            }
+            // 3. Assert: Check that the final history contains both function calls.
+            const history = chat.getHistoryTurns();
+            expect(history.length).toBe(2);
+            const modelTurn = history[1].content;
+            expect(modelTurn.role).toBe('model');
+            expect(modelTurn.parts?.length).toBe(2);
+            expect(modelTurn.parts[0].functionCall?.name).toBe('tool_A');
+            expect(modelTurn.parts[1].functionCall?.name).toBe('tool_B');
+        });
+        it('repro: should not collide when multiple tool calls with the same name arrive in the same chunk', async () => {
+            vi.mocked(mockConfig.isContextManagementEnabled).mockReturnValue(true);
+            const sameNameStream = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [
+                                    { functionCall: { name: 'tool_X', args: { id: 1 } } },
+                                    { functionCall: { name: 'tool_X', args: { id: 2 } } },
+                                ],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                    functionCalls: [
+                        { name: 'tool_X', args: { id: 1 } },
+                        { name: 'tool_X', args: { id: 2 } },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(sameNameStream);
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test same name tools', 'prompt-same-name', new AbortController().signal, LlmRole.MAIN);
+            for await (const _ of stream) {
+                // Consume the stream to trigger history recording
+            }
+            const history = chat.getHistoryTurns();
+            const modelTurn = history[1].content;
+            expect(modelTurn.parts?.length).toBe(2);
+            expect(modelTurn.parts[0].functionCall?.name).toBe('tool_X');
+            expect(modelTurn.parts[0].functionCall?.args).toEqual({ id: 1 });
+            expect(modelTurn.parts[1].functionCall?.name).toBe('tool_X');
+            expect(modelTurn.parts[1].functionCall?.args).toEqual({ id: 2 });
+            // If findIndex was used, both would likely point to index 0, and the second one might overwrite the first if consolidated incorrectly,
+            // or they both might end up with the same callIndex and thus the same args in final assembly.
+        });
         it('should preserve text parts that stream in the same chunk as a thought', async () => {
             // 1. Mock the API to return a single chunk containing both a thought and visible text.
             const mixedContentStream = (async function* () {
@@ -455,10 +584,10 @@ describe('GeminiChat', () => {
                 // This loop consumes the stream.
             }
             // 3. Assert: Check the final state of the history.
-            const history = chat.getHistory();
+            const history = chat.getHistoryTurns();
             // The history should contain two turns: the user's message and the model's response.
             expect(history.length).toBe(2);
-            const modelTurn = history[1];
+            const modelTurn = history[1].content;
             expect(modelTurn.role).toBe('model');
             // CRUCIAL ASSERTION:
             // The buggy code would fail here, resulting in parts.length being 0.
@@ -470,19 +599,25 @@ describe('GeminiChat', () => {
             // 1. Setup: A history where the model has just made a function call.
             const initialHistory = [
                 {
-                    role: 'user',
-                    parts: [{ text: 'Find a good Italian restaurant for me.' }],
+                    id: '1',
+                    content: {
+                        role: 'user',
+                        parts: [{ text: 'Find a good Italian restaurant for me.' }],
+                    },
                 },
                 {
-                    role: 'model',
-                    parts: [
-                        {
-                            functionCall: {
-                                name: 'find_restaurant',
-                                args: { cuisine: 'Italian' },
+                    id: '2',
+                    content: {
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    name: 'find_restaurant',
+                                    args: { cuisine: 'Italian' },
+                                },
                             },
-                        },
-                    ],
+                        ],
+                    },
                 },
             ];
             chat.setHistory(initialHistory);
@@ -566,28 +701,48 @@ describe('GeminiChat', () => {
                 }
             })()).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* () {
+        it('should throw InvalidStreamError without retrying when no tool call and empty response text', async () => {
+            vi.mocked(mockContentGenerator.generateContentStream)
+                .mockImplementationOnce(async () => 
+            // First attempt: finish reason is present, but the stream has no
+            // non-thought text, which is NO_RESPONSE_TEXT.
+            (async function* () {
                 yield {
                     candidates: [
                         {
                             content: {
                                 role: 'model',
-                                parts: [{ thought: 'thinking...' }],
+                                parts: [{ thought: true, text: 'thinking...' }],
                             },
                             finishReason: 'STOP',
                         },
                     ],
                 };
-            })();
-            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithEmptyResponse);
+            })())
+                .mockImplementationOnce(async () => 
+            // This would succeed if NO_RESPONSE_TEXT were retried.
+            (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [{ text: 'valid response after retry' }],
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })());
             const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test message', 'prompt-id-1', new AbortController().signal, LlmRole.MAIN);
             await expect((async () => {
                 for await (const _ of stream) {
                     // consume stream
                 }
             })()).rejects.toThrow(InvalidStreamError);
+            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(1);
+            expect(mockLogContentRetry).not.toHaveBeenCalled();
+            expect(mockLogContentRetryFailure).toHaveBeenCalledTimes(1);
         });
         it('should succeed when there is finish reason and response text', async () => {
             // Setup: Stream with both finish reason and text content
@@ -821,30 +976,39 @@ describe('GeminiChat', () => {
     });
     describe('addHistory', () => {
         it('should add a new content item to the history', () => {
-            const newContent = {
-                role: 'user',
-                parts: [{ text: 'A new message' }],
+            const newTurn = {
+                id: '1',
+                content: {
+                    role: 'user',
+                    parts: [{ text: 'A new message' }],
+                },
             };
-            chat.addHistory(newContent);
-            const history = chat.getHistory();
+            chat.addHistory(newTurn);
+            const history = chat.getHistoryTurns();
             expect(history.length).toBe(1);
-            expect(history[0]).toEqual(newContent);
+            expect(history[0]).toEqual(newTurn);
         });
         it('should add multiple items correctly', () => {
-            const content1 = {
-                role: 'user',
-                parts: [{ text: 'Message 1' }],
+            const turn1 = {
+                id: '1',
+                content: {
+                    role: 'user',
+                    parts: [{ text: 'Message 1' }],
+                },
             };
-            const content2 = {
-                role: 'model',
-                parts: [{ text: 'Message 2' }],
+            const turn2 = {
+                id: '2',
+                content: {
+                    role: 'model',
+                    parts: [{ text: 'Message 2' }],
+                },
             };
-            chat.addHistory(content1);
-            chat.addHistory(content2);
-            const history = chat.getHistory();
+            chat.addHistory(turn1);
+            chat.addHistory(turn2);
+            const history = chat.getHistoryTurns();
             expect(history.length).toBe(2);
-            expect(history[0]).toEqual(content1);
-            expect(history[1]).toEqual(content2);
+            expect(history[0]).toEqual(turn1);
+            expect(history[1]).toEqual(turn2);
         });
     });
     describe('sendMessageStream with retries', () => {
@@ -1448,7 +1612,13 @@ describe('GeminiChat', () => {
                     role: 'model',
                     parts: [
                         { text: 'thinking...' },
-                        { functionCall: { name: 'test', args: {} } },
+                        {
+                            functionCall: {
+                                name: 'test',
+                                args: {},
+                                id: expect.stringMatching(/^synth_test_/),
+                            },
+                        },
                     ],
                 },
             ]);
@@ -1817,6 +1987,117 @@ describe('GeminiChat', () => {
             });
         });
     });
+    describe('automated binary injection', () => {
+        it('should expand history with synthetic turns when __binary_injection__ is detected', async () => {
+            const audioParts = [
+                {
+                    functionResponse: {
+                        id: 'call-123',
+                        name: 'read_file',
+                        response: {
+                            output: 'Success',
+                            [BINARY_INJECTION_KEY]: [
+                                { inlineData: { mimeType: 'audio/mpeg', data: 'base64' } },
+                            ],
+                        },
+                    },
+                },
+            ];
+            // Mock API to capture the history it receives
+            let capturedContents = [];
+            vi.mocked(mockContentGenerator.generateContentStream).mockImplementation(async (req) => {
+                capturedContents = req.contents;
+                return (async function* () {
+                    yield {
+                        candidates: [
+                            {
+                                content: { parts: [{ text: 'Analysis done' }] },
+                                finishReason: 'STOP',
+                            },
+                        ],
+                    };
+                })();
+            });
+            const stream = await chat.sendMessageStream({ model: 'gemini-pro' }, audioParts, 'test-id', new AbortController().signal, LlmRole.MAIN);
+            for await (const _ of stream) {
+                // No-op
+            }
+            // Verify history expansion
+            // Turn 1: Tool response (cleaned)
+            // Turn 2: Model Ack (synthetic)
+            // Turn 3: User Binary data (current request)
+            expect(capturedContents).toHaveLength(3);
+            expect(capturedContents[0].role).toBe('user');
+            expect(capturedContents[0].parts[0].functionResponse.response).toEqual({
+                output: 'Success',
+            });
+            expect(capturedContents[1].role).toBe('model');
+            expect(capturedContents[1].parts[0].text).toContain('Binary content received');
+            expect(capturedContents[1].parts[0].thoughtSignature).toBe(SYNTHETIC_THOUGHT_SIGNATURE);
+            expect(capturedContents[2].role).toBe('user');
+            expect(capturedContents[2].parts[0].inlineData.mimeType).toBe('audio/mpeg');
+        });
+        it('should handle multiple parallel binary injections', async () => {
+            const parallelParts = [
+                {
+                    functionResponse: {
+                        id: 'call-1',
+                        name: 'read_file',
+                        response: {
+                            output: 'Success 1',
+                            [BINARY_INJECTION_KEY]: [
+                                { inlineData: { mimeType: 'audio/mpeg', data: 'audio1' } },
+                            ],
+                        },
+                    },
+                },
+                {
+                    functionResponse: {
+                        id: 'call-2',
+                        name: 'read_file',
+                        response: {
+                            output: 'Success 2',
+                            [BINARY_INJECTION_KEY]: [
+                                { inlineData: { mimeType: 'video/mp4', data: 'video2' } },
+                            ],
+                        },
+                    },
+                },
+            ];
+            let capturedContents = [];
+            vi.mocked(mockContentGenerator.generateContentStream).mockImplementation(async (req) => {
+                capturedContents = req.contents;
+                return (async function* () {
+                    yield {
+                        candidates: [
+                            {
+                                content: { parts: [{ text: 'Done' }] },
+                                finishReason: 'STOP',
+                            },
+                        ],
+                    };
+                })();
+            });
+            const stream = await chat.sendMessageStream({ model: 'gemini-pro' }, parallelParts, 'test-id', new AbortController().signal, LlmRole.MAIN);
+            for await (const _ of stream) {
+                // No-op
+            }
+            // Turn 1: Cleaned tool responses (both)
+            // Turn 2: Model Ack
+            // Turn 3: Both binary parts combined
+            expect(capturedContents).toHaveLength(3);
+            expect(capturedContents[0].parts).toHaveLength(2);
+            expect(capturedContents[0].parts[0].functionResponse.response).toEqual({
+                output: 'Success 1',
+            });
+            expect(capturedContents[0].parts[1].functionResponse.response).toEqual({
+                output: 'Success 2',
+            });
+            expect(capturedContents[2].parts).toHaveLength(2);
+            expect(capturedContents[2].parts[0].inlineData.mimeType).toBe('audio/mpeg');
+            expect(capturedContents[2].parts[1].inlineData.mimeType).toBe('video/mp4');
+        });
+    });
     describe('recordCompletedToolCalls', () => {
         it('should use originalRequestName and originalRequestArgs if present', () => {
             const completedCall = {
@@ -1883,5 +2164,118 @@ describe('GeminiChat', () => {
             ]);
         });
     });
+    describe('stripToolCallIdPrefixes', () => {
+        it('should strip tool name prefix matching the tool name', () => {
+            const contents = [
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            functionCall: {
+                                id: 'my_tool__call_123',
+                                name: 'my_tool',
+                                args: {},
+                            },
+                        },
+                    ],
+                },
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                id: 'my_tool__call_123',
+                                name: 'my_tool',
+                                response: { result: 'success' },
+                            },
+                        },
+                    ],
+                },
+            ];
+            const stripped = stripToolCallIdPrefixes(contents);
+            expect(stripped[0].parts[0].functionCall.id).toBe('call_123');
+            expect(stripped[1].parts[0].functionResponse.id).toBe('call_123');
+        });
+        it('should correctly handle tool names that contain double underscores', () => {
+            const contents = [
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            functionCall: {
+                                id: 'my__custom__tool__call_abc',
+                                name: 'my__custom__tool',
+                                args: {},
+                            },
+                        },
+                    ],
+                },
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                id: 'my__custom__tool__call_abc',
+                                name: 'my__custom__tool',
+                                response: { result: 'success' },
+                            },
+                        },
+                    ],
+                },
+            ];
+            const stripped = stripToolCallIdPrefixes(contents);
+            expect(stripped[0].parts[0].functionCall.id).toBe('call_abc');
+            expect(stripped[1].parts[0].functionResponse.id).toBe('call_abc');
+        });
+        it('should not strip if prefix does not match the tool name', () => {
+            const contents = [
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            functionCall: {
+                                id: 'other_tool__call_123',
+                                name: 'my_tool',
+                                args: {},
+                            },
+                        },
+                    ],
+                },
+            ];
+            const stripped = stripToolCallIdPrefixes(contents);
+            expect(stripped[0].parts[0].functionCall.id).toBe('other_tool__call_123');
+        });
+        it('should correctly handle fallback to generic_tool when name is missing or has whitespace', () => {
+            const contents = [
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            functionCall: {
+                                id: 'generic_tool__call_123',
+                                name: '  ',
+                                args: {},
+                            },
+                        },
+                    ],
+                },
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                id: 'generic_tool__call_123',
+                                name: undefined,
+                                response: { result: 'success' },
+                            },
+                        },
+                    ],
+                },
+            ];
+            const stripped = stripToolCallIdPrefixes(contents);
+            expect(stripped[0].parts[0].functionCall.id).toBe('call_123');
+            expect(stripped[1].parts[0].functionResponse.id).toBe('call_123');
+        });
+    });
 });
 //# sourceMappingURL=geminiChat.test.js.map