@office-ai/aioncli-core 0.1.21 → 0.2.2

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

@@ -15,6 +15,7 @@ import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
 import { setSimulate429 } from '../utils/testUtils.js';
 import { tokenLimit } from './tokenLimits.js';
 import { ideContext } from '../ide/ideContext.js';
+import { ClearcutLogger } from '../telemetry/clearcut-logger/clearcut-logger.js';
 // --- Mocks ---
 const mockChatCreateFn = vi.fn();
 const mockGenerateContentFn = vi.fn();
@@ -151,7 +152,7 @@ describe('Gemini Client (client.ts)', () => {
             getContentGeneratorConfig: vi
                 .fn()
                 .mockReturnValue(contentGeneratorConfig),
-            getToolRegistry: vi.fn().mockResolvedValue(mockToolRegistry),
+            getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
             getModel: vi.fn().mockReturnValue('test-model'),
             getEmbeddingModel: vi.fn().mockReturnValue('test-embedding-model'),
             getApiKey: vi.fn().mockReturnValue('test-key'),
@@ -170,12 +171,14 @@ describe('Gemini Client (client.ts)', () => {
             getUsageStatisticsEnabled: vi.fn().mockReturnValue(true),
             getIdeModeFeature: vi.fn().mockReturnValue(false),
             getIdeMode: vi.fn().mockReturnValue(true),
+            getDebugMode: vi.fn().mockReturnValue(false),
             getWorkspaceContext: vi.fn().mockReturnValue({
                 getDirectories: vi.fn().mockReturnValue(['/test/dir']),
             }),
             getGeminiClient: vi.fn(),
             setFallbackMode: vi.fn(),
             getChatCompression: vi.fn().mockReturnValue(undefined),
+            getSkipNextSpeakerCheck: vi.fn().mockReturnValue(false),
         };
         const MockedConfig = vi.mocked(Config, true);
         MockedConfig.mockImplementation(() => mockConfigObject);
@@ -315,7 +318,7 @@ describe('Gemini Client (client.ts)', () => {
                     systemInstruction: getCoreSystemPrompt(''),
                     temperature: 0,
                     topP: 1,
-                    responseSchema: schema,
+                    responseJsonSchema: schema,
                     responseMimeType: 'application/json',
                 },
                 contents,
@@ -341,7 +344,7 @@ describe('Gemini Client (client.ts)', () => {
                     temperature: 0.9,
                     topP: 1, // from default
                     topK: 20,
-                    responseSchema: schema,
+                    responseJsonSchema: schema,
                     responseMimeType: 'application/json',
                 },
                 contents,
@@ -353,7 +356,6 @@ describe('Gemini Client (client.ts)', () => {
             const mockChat = {
                 addHistory: vi.fn(),
             };
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             client['chat'] = mockChat;
             const newContent = {
                 role: 'user',
@@ -419,6 +421,33 @@ describe('Gemini Client (client.ts)', () => {
             expect(result).toBeNull();
             expect(newChat).toBe(initialChat);
         });
+        it('logs a telemetry event when compressing', async () => {
+            vi.spyOn(ClearcutLogger.prototype, 'logChatCompressionEvent');
+            const MOCKED_TOKEN_LIMIT = 1000;
+            const MOCKED_CONTEXT_PERCENTAGE_THRESHOLD = 0.5;
+            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+            vi.spyOn(client['config'], 'getChatCompression').mockReturnValue({
+                contextPercentageThreshold: MOCKED_CONTEXT_PERCENTAGE_THRESHOLD,
+            });
+            mockGetHistory.mockReturnValue([
+                { role: 'user', parts: [{ text: '...history...' }] },
+            ]);
+            const originalTokenCount = MOCKED_TOKEN_LIMIT * MOCKED_CONTEXT_PERCENTAGE_THRESHOLD;
+            const newTokenCount = 100;
+            mockCountTokens
+                .mockResolvedValueOnce({ totalTokens: originalTokenCount }) // First call for the check
+                .mockResolvedValueOnce({ totalTokens: newTokenCount }); // Second call for the new history
+            // Mock the summary response from the chat
+            mockSendMessage.mockResolvedValue({
+                role: 'model',
+                parts: [{ text: 'This is a summary.' }],
+            });
+            await client.tryCompressChat('prompt-id-3');
+            expect(ClearcutLogger.prototype.logChatCompressionEvent).toHaveBeenCalledWith(expect.objectContaining({
+                tokens_before: originalTokenCount,
+                tokens_after: newTokenCount,
+            }));
+        });
         it('should trigger summarization if token count is at threshold with contextPercentageThreshold setting', async () => {
             const MOCKED_TOKEN_LIMIT = 1000;
             const MOCKED_CONTEXT_PERCENTAGE_THRESHOLD = 0.5;
@@ -529,7 +558,7 @@ describe('Gemini Client (client.ts)', () => {
         });
     });
     describe('sendMessageStream', () => {
-        it('should include IDE context when ideModeFeature is enabled', async () => {
+        it('should include editor context when ideMode is enabled', async () => {
             // Arrange
             vi.mocked(ideContext.getIdeContext).mockReturnValue({
                 workspaceState: {
@@ -552,7 +581,7 @@ describe('Gemini Client (client.ts)', () => {
                     ],
                 },
             });
-            vi.spyOn(client['config'], 'getIdeModeFeature').mockReturnValue(true);
+            vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
             const mockStream = (async function* () {
                 yield { type: 'content', value: 'Hello' };
             })();
@@ -576,27 +605,35 @@ describe('Gemini Client (client.ts)', () => {
             // Assert
             expect(ideContext.getIdeContext).toHaveBeenCalled();
             const expectedContext = `
-This is the file that the user is looking at:
-- Path: /path/to/active/file.ts
-This is the cursor position in the file:
-- Cursor Position: Line 5, Character 10
-This is the selected text in the file:
-- hello
-Here are some other files the user has open, with the most recent at the top:
-- /path/to/recent/file1.ts
-- /path/to/recent/file2.ts
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify({
+                activeFile: {
+                    path: '/path/to/active/file.ts',
+                    cursor: {
+                        line: 5,
+                        character: 10,
+                    },
+                    selectedText: 'hello',
+                },
+                otherOpenFiles: ['/path/to/recent/file1.ts', '/path/to/recent/file2.ts'],
+            }, null, 2)}
+\`\`\`
       `.trim();
-            const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-            expect(mockTurnRunFn).toHaveBeenCalledWith(expectedRequest, expect.any(Object));
+            const expectedRequest = [{ text: expectedContext }];
+            expect(mockChat.addHistory).toHaveBeenCalledWith({
+                role: 'user',
+                parts: expectedRequest,
+            });
         });
-        it('should not add context if ideModeFeature is enabled but no open files', async () => {
+        it('should not add context if ideMode is enabled but no open files', async () => {
             // Arrange
             vi.mocked(ideContext.getIdeContext).mockReturnValue({
                 workspaceState: {
                     openFiles: [],
                 },
             });
-            vi.spyOn(client['config'], 'getIdeModeFeature').mockReturnValue(true);
+            vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
             const mockStream = (async function* () {
                 yield { type: 'content', value: 'Hello' };
             })();
@@ -621,7 +658,7 @@ Here are some other files the user has open, with the most recent at the top:
             expect(ideContext.getIdeContext).toHaveBeenCalled();
             expect(mockTurnRunFn).toHaveBeenCalledWith(initialRequest, expect.any(Object));
         });
-        it('should add context if ideModeFeature is enabled and there is one active file', async () => {
+        it('should add context if ideMode is enabled and there is one active file', async () => {
             // Arrange
             vi.mocked(ideContext.getIdeContext).mockReturnValue({
                 workspaceState: {
@@ -636,7 +673,7 @@ Here are some other files the user has open, with the most recent at the top:
                     ],
                 },
             });
-            vi.spyOn(client['config'], 'getIdeModeFeature').mockReturnValue(true);
+            vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
             const mockStream = (async function* () {
                 yield { type: 'content', value: 'Hello' };
             })();
@@ -660,17 +697,27 @@ Here are some other files the user has open, with the most recent at the top:
             // Assert
             expect(ideContext.getIdeContext).toHaveBeenCalled();
             const expectedContext = `
-This is the file that the user is looking at:
-- Path: /path/to/active/file.ts
-This is the cursor position in the file:
-- Cursor Position: Line 5, Character 10
-This is the selected text in the file:
-- hello
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify({
+                activeFile: {
+                    path: '/path/to/active/file.ts',
+                    cursor: {
+                        line: 5,
+                        character: 10,
+                    },
+                    selectedText: 'hello',
+                },
+            }, null, 2)}
+\`\`\`
       `.trim();
-            const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-            expect(mockTurnRunFn).toHaveBeenCalledWith(expectedRequest, expect.any(Object));
+            const expectedRequest = [{ text: expectedContext }];
+            expect(mockChat.addHistory).toHaveBeenCalledWith({
+                role: 'user',
+                parts: expectedRequest,
+            });
         });
-        it('should add context if ideModeFeature is enabled and there are open files but no active file', async () => {
+        it('should add context if ideMode is enabled and there are open files but no active file', async () => {
             // Arrange
             vi.mocked(ideContext.getIdeContext).mockReturnValue({
                 workspaceState: {
@@ -686,7 +733,7 @@ This is the selected text in the file:
                     ],
                 },
             });
-            vi.spyOn(client['config'], 'getIdeModeFeature').mockReturnValue(true);
+            vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
             const mockStream = (async function* () {
                 yield { type: 'content', value: 'Hello' };
             })();
@@ -710,12 +757,18 @@ This is the selected text in the file:
             // Assert
             expect(ideContext.getIdeContext).toHaveBeenCalled();
             const expectedContext = `
-Here are some files the user has open, with the most recent at the top:
-- /path/to/recent/file1.ts
-- /path/to/recent/file2.ts
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify({
+                otherOpenFiles: ['/path/to/recent/file1.ts', '/path/to/recent/file2.ts'],
+            }, null, 2)}
+\`\`\`
       `.trim();
-            const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-            expect(mockTurnRunFn).toHaveBeenCalledWith(expectedRequest, expect.any(Object));
+            const expectedRequest = [{ text: expectedContext }];
+            expect(mockChat.addHistory).toHaveBeenCalledWith({
+                role: 'user',
+                parts: expectedRequest,
+            });
         });
         it('should return the turn instance after the stream is complete', async () => {
             // Arrange
@@ -918,6 +971,488 @@ Here are some files the user has open, with the most recent at the top:
             console.log(`Infinite loop protection working: checkNextSpeaker called ${callCount} times, ` +
                 `${eventCount} events generated (properly bounded by MAX_TURNS)`);
         });
+        describe('Editor context delta', () => {
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })();
+            beforeEach(() => {
+                client['forceFullIdeContext'] = false; // Reset before each delta test
+                vi.spyOn(client, 'tryCompressChat').mockResolvedValue(null);
+                vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+                mockTurnRunFn.mockReturnValue(mockStream);
+                const mockChat = {
+                    addHistory: vi.fn(),
+                    setHistory: vi.fn(),
+                    sendMessage: vi.fn().mockResolvedValue({ text: 'summary' }),
+                    // Assume history is not empty for delta checks
+                    getHistory: vi
+                        .fn()
+                        .mockReturnValue([
+                        { role: 'user', parts: [{ text: 'previous message' }] },
+                    ]),
+                };
+                client['chat'] = mockChat;
+                const mockGenerator = {
+                    countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+                    generateContent: mockGenerateContentFn,
+                };
+                client['contentGenerator'] = mockGenerator;
+            });
+            const testCases = [
+                {
+                    description: 'sends delta when active file changes',
+                    previousActiveFile: {
+                        path: '/path/to/old/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when cursor line changes',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 1, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when cursor character changes',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 1 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when selected text changes',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'world',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when selected text is added',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when selected text is removed',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'does not send context when nothing changes',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: false,
+                },
+            ];
+            it.each(testCases)('$description', async ({ previousActiveFile, currentActiveFile, shouldSendContext, }) => {
+                // Setup previous context
+                client['lastSentIdeContext'] = {
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                path: previousActiveFile.path,
+                                cursor: previousActiveFile.cursor,
+                                selectedText: previousActiveFile.selectedText,
+                                isActive: true,
+                                timestamp: Date.now() - 1000,
+                            },
+                        ],
+                    },
+                };
+                // Setup current context
+                vi.mocked(ideContext.getIdeContext).mockReturnValue({
+                    workspaceState: {
+                        openFiles: [
+                            { ...currentActiveFile, isActive: true, timestamp: Date.now() },
+                        ],
+                    },
+                });
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-delta');
+                for await (const _ of stream) {
+                    // consume stream
+                }
+                const mockChat = client['chat'];
+                if (shouldSendContext) {
+                    expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({
+                        parts: expect.arrayContaining([
+                            expect.objectContaining({
+                                text: expect.stringContaining("Here is a summary of changes in the user's editor context"),
+                            }),
+                        ]),
+                    }));
+                }
+                else {
+                    expect(mockChat.addHistory).not.toHaveBeenCalled();
+                }
+            });
+            it('sends full context when history is cleared, even if editor state is unchanged', async () => {
+                const activeFile = {
+                    path: '/path/to/active/file.ts',
+                    cursor: { line: 5, character: 10 },
+                    selectedText: 'hello',
+                };
+                // Setup previous context
+                client['lastSentIdeContext'] = {
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                path: activeFile.path,
+                                cursor: activeFile.cursor,
+                                selectedText: activeFile.selectedText,
+                                isActive: true,
+                                timestamp: Date.now() - 1000,
+                            },
+                        ],
+                    },
+                };
+                // Setup current context (same as previous)
+                vi.mocked(ideContext.getIdeContext).mockReturnValue({
+                    workspaceState: {
+                        openFiles: [
+                            { ...activeFile, isActive: true, timestamp: Date.now() },
+                        ],
+                    },
+                });
+                // Make history empty
+                const mockChat = client['chat'];
+                mockChat.getHistory.mockReturnValue([]);
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-history-cleared');
+                for await (const _ of stream) {
+                    // consume stream
+                }
+                expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({
+                    parts: expect.arrayContaining([
+                        expect.objectContaining({
+                            text: expect.stringContaining("Here is the user's editor context"),
+                        }),
+                    ]),
+                }));
+                // Also verify it's the full context, not a delta.
+                const call = mockChat.addHistory.mock.calls[0][0];
+                const contextText = call.parts[0].text;
+                const contextJson = JSON.parse(contextText.match(/```json\n(.*)\n```/s)[1]);
+                expect(contextJson).toHaveProperty('activeFile');
+                expect(contextJson.activeFile.path).toBe('/path/to/active/file.ts');
+            });
+        });
+        describe('IDE context with pending tool calls', () => {
+            let mockChat;
+            beforeEach(() => {
+                vi.spyOn(client, 'tryCompressChat').mockResolvedValue(null);
+                const mockStream = (async function* () {
+                    yield { type: 'content', value: 'response' };
+                })();
+                mockTurnRunFn.mockReturnValue(mockStream);
+                mockChat = {
+                    addHistory: vi.fn(),
+                    getHistory: vi.fn().mockReturnValue([]), // Default empty history
+                    setHistory: vi.fn(),
+                    sendMessage: vi.fn().mockResolvedValue({ text: 'summary' }),
+                };
+                client['chat'] = mockChat;
+                const mockGenerator = {
+                    countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
+                };
+                client['contentGenerator'] = mockGenerator;
+                vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+                vi.mocked(ideContext.getIdeContext).mockReturnValue({
+                    workspaceState: {
+                        openFiles: [{ path: '/path/to/file.ts', timestamp: Date.now() }],
+                    },
+                });
+            });
+            it('should NOT add IDE context when a tool call is pending', async () => {
+                // Arrange: History ends with a functionCall from the model
+                const historyWithPendingCall = [
+                    { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+                    {
+                        role: 'model',
+                        parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+                    },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyWithPendingCall);
+                // Act: Simulate sending the tool's response back
+                const stream = client.sendMessageStream([
+                    {
+                        functionResponse: {
+                            name: 'some_tool',
+                            response: { success: true },
+                        },
+                    },
+                ], new AbortController().signal, 'prompt-id-tool-response');
+                for await (const _ of stream) {
+                    // consume stream to complete the call
+                }
+                // Assert: The IDE context message should NOT have been added to the history.
+                expect(mockChat.addHistory).not.toHaveBeenCalledWith(expect.objectContaining({
+                    parts: expect.arrayContaining([
+                        expect.objectContaining({
+                            text: expect.stringContaining("user's editor context"),
+                        }),
+                    ]),
+                }));
+            });
+            it('should add IDE context when no tool call is pending', async () => {
+                // Arrange: History is normal, no pending calls
+                const normalHistory = [
+                    { role: 'user', parts: [{ text: 'A normal message.' }] },
+                    { role: 'model', parts: [{ text: 'A normal response.' }] },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(normalHistory);
+                // Act
+                const stream = client.sendMessageStream([{ text: 'Another normal message' }], new AbortController().signal, 'prompt-id-normal');
+                for await (const _ of stream) {
+                    // consume stream
+                }
+                // Assert: The IDE context message SHOULD have been added.
+                expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({
+                    role: 'user',
+                    parts: expect.arrayContaining([
+                        expect.objectContaining({
+                            text: expect.stringContaining("user's editor context"),
+                        }),
+                    ]),
+                }));
+            });
+            it('should send the latest IDE context on the next message after a skipped context', async () => {
+                // --- Step 1: A tool call is pending, context should be skipped ---
+                // Arrange: History ends with a functionCall
+                const historyWithPendingCall = [
+                    { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+                    {
+                        role: 'model',
+                        parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+                    },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyWithPendingCall);
+                // Arrange: Set the initial IDE context
+                const initialIdeContext = {
+                    workspaceState: {
+                        openFiles: [{ path: '/path/to/fileA.ts', timestamp: Date.now() }],
+                    },
+                };
+                vi.mocked(ideContext.getIdeContext).mockReturnValue(initialIdeContext);
+                // Act: Send the tool response
+                let stream = client.sendMessageStream([
+                    {
+                        functionResponse: {
+                            name: 'some_tool',
+                            response: { success: true },
+                        },
+                    },
+                ], new AbortController().signal, 'prompt-id-tool-response');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: The initial context was NOT sent
+                expect(mockChat.addHistory).not.toHaveBeenCalledWith(expect.objectContaining({
+                    parts: expect.arrayContaining([
+                        expect.objectContaining({
+                            text: expect.stringContaining("user's editor context"),
+                        }),
+                    ]),
+                }));
+                // --- Step 2: A new message is sent, latest context should be included ---
+                // Arrange: The model has responded to the tool, and the user is sending a new message.
+                const historyAfterToolResponse = [
+                    ...historyWithPendingCall,
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    name: 'some_tool',
+                                    response: { success: true },
+                                },
+                            },
+                        ],
+                    },
+                    { role: 'model', parts: [{ text: 'The tool ran successfully.' }] },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyAfterToolResponse);
+                vi.mocked(mockChat.addHistory).mockClear(); // Clear previous calls for the next assertion
+                // Arrange: The IDE context has now changed
+                const newIdeContext = {
+                    workspaceState: {
+                        openFiles: [{ path: '/path/to/fileB.ts', timestamp: Date.now() }],
+                    },
+                };
+                vi.mocked(ideContext.getIdeContext).mockReturnValue(newIdeContext);
+                // Act: Send a new, regular user message
+                stream = client.sendMessageStream([{ text: 'Thanks!' }], new AbortController().signal, 'prompt-id-final');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: The NEW context was sent as a FULL context because there was no previously sent context.
+                const addHistoryCalls = vi.mocked(mockChat.addHistory).mock.calls;
+                const contextCall = addHistoryCalls.find((call) => JSON.stringify(call[0]).includes("user's editor context"));
+                expect(contextCall).toBeDefined();
+                expect(JSON.stringify(contextCall[0])).toContain("Here is the user's editor context as a JSON object");
+                // Check that the sent context is the new one (fileB.ts)
+                expect(JSON.stringify(contextCall[0])).toContain('fileB.ts');
+                // Check that the sent context is NOT the old one (fileA.ts)
+                expect(JSON.stringify(contextCall[0])).not.toContain('fileA.ts');
+            });
+            it('should send a context DELTA on the next message after a skipped context', async () => {
+                // --- Step 0: Establish an initial context ---
+                vi.mocked(mockChat.getHistory).mockReturnValue([]); // Start with empty history
+                const contextA = {
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                path: '/path/to/fileA.ts',
+                                isActive: true,
+                                timestamp: Date.now(),
+                            },
+                        ],
+                    },
+                };
+                vi.mocked(ideContext.getIdeContext).mockReturnValue(contextA);
+                // Act: Send a regular message to establish the initial context
+                let stream = client.sendMessageStream([{ text: 'Initial message' }], new AbortController().signal, 'prompt-id-initial');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: Full context for fileA.ts was sent and stored.
+                const initialCall = vi.mocked(mockChat.addHistory).mock.calls[0][0];
+                expect(JSON.stringify(initialCall)).toContain("user's editor context as a JSON object");
+                expect(JSON.stringify(initialCall)).toContain('fileA.ts');
+                // This implicitly tests that `lastSentIdeContext` is now set internally by the client.
+                vi.mocked(mockChat.addHistory).mockClear();
+                // --- Step 1: A tool call is pending, context should be skipped ---
+                const historyWithPendingCall = [
+                    { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+                    {
+                        role: 'model',
+                        parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+                    },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyWithPendingCall);
+                // Arrange: IDE context changes, but this should be skipped
+                const contextB = {
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                path: '/path/to/fileB.ts',
+                                isActive: true,
+                                timestamp: Date.now(),
+                            },
+                        ],
+                    },
+                };
+                vi.mocked(ideContext.getIdeContext).mockReturnValue(contextB);
+                // Act: Send the tool response
+                stream = client.sendMessageStream([
+                    {
+                        functionResponse: {
+                            name: 'some_tool',
+                            response: { success: true },
+                        },
+                    },
+                ], new AbortController().signal, 'prompt-id-tool-response');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: No context was sent
+                expect(mockChat.addHistory).not.toHaveBeenCalled();
+                // --- Step 2: A new message is sent, latest context DELTA should be included ---
+                const historyAfterToolResponse = [
+                    ...historyWithPendingCall,
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    name: 'some_tool',
+                                    response: { success: true },
+                                },
+                            },
+                        ],
+                    },
+                    { role: 'model', parts: [{ text: 'The tool ran successfully.' }] },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyAfterToolResponse);
+                // Arrange: The IDE context has changed again
+                const contextC = {
+                    workspaceState: {
+                        openFiles: [
+                            // fileA is now closed, fileC is open
+                            {
+                                path: '/path/to/fileC.ts',
+                                isActive: true,
+                                timestamp: Date.now(),
+                            },
+                        ],
+                    },
+                };
+                vi.mocked(ideContext.getIdeContext).mockReturnValue(contextC);
+                // Act: Send a new, regular user message
+                stream = client.sendMessageStream([{ text: 'Thanks!' }], new AbortController().signal, 'prompt-id-final');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: The DELTA context was sent
+                const finalCall = vi.mocked(mockChat.addHistory).mock.calls[0][0];
+                expect(JSON.stringify(finalCall)).toContain('summary of changes');
+                // The delta should reflect fileA being closed and fileC being opened.
+                expect(JSON.stringify(finalCall)).toContain('filesClosed');
+                expect(JSON.stringify(finalCall)).toContain('fileA.ts');
+                expect(JSON.stringify(finalCall)).toContain('activeFileChanged');
+                expect(JSON.stringify(finalCall)).toContain('fileC.ts');
+            });
+        });
     });
     describe('generateContent', () => {
         it('should use current model from config for content generation', async () => {
@@ -1004,5 +1539,65 @@ Here are some files the user has open, with the most recent at the top:
             expect(mockFallbackHandler).toHaveBeenCalledWith(currentModel, fallbackModel, undefined);
         });
     });
+    describe('setHistory', () => {
+        it('should strip thought signatures when stripThoughts is true', () => {
+            const mockChat = {
+                setHistory: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const historyWithThoughts = [
+                {
+                    role: 'user',
+                    parts: [{ text: 'hello' }],
+                },
+                {
+                    role: 'model',
+                    parts: [
+                        { text: 'thinking...', thoughtSignature: 'thought-123' },
+                        {
+                            functionCall: { name: 'test', args: {} },
+                            thoughtSignature: 'thought-456',
+                        },
+                    ],
+                },
+            ];
+            client.setHistory(historyWithThoughts, { stripThoughts: true });
+            const expectedHistory = [
+                {
+                    role: 'user',
+                    parts: [{ text: 'hello' }],
+                },
+                {
+                    role: 'model',
+                    parts: [
+                        { text: 'thinking...' },
+                        { functionCall: { name: 'test', args: {} } },
+                    ],
+                },
+            ];
+            expect(mockChat.setHistory).toHaveBeenCalledWith(expectedHistory);
+        });
+        it('should not strip thought signatures when stripThoughts is false', () => {
+            const mockChat = {
+                setHistory: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const historyWithThoughts = [
+                {
+                    role: 'user',
+                    parts: [{ text: 'hello' }],
+                },
+                {
+                    role: 'model',
+                    parts: [
+                        { text: 'thinking...', thoughtSignature: 'thought-123' },
+                        { text: 'ok', thoughtSignature: 'thought-456' },
+                    ],
+                },
+            ];
+            client.setHistory(historyWithThoughts, { stripThoughts: false });
+            expect(mockChat.setHistory).toHaveBeenCalledWith(historyWithThoughts);
+        });
+    });
 });
 //# sourceMappingURL=client.test.js.map