feat: notify user when chat context is compressed (#724)

packages/cli/src/ui/hooks/useGeminiStream.ts

@@ -356,6 +356,18 @@ export const useGeminiStream = (
     [addItem, pendingHistoryItemRef, setPendingHistoryItem],
   );
 
+  const handleChatCompressionEvent = useCallback(
+    () =>
+      addItem(
+        {
+          type: 'info',
+          text: `IMPORTANT: this conversation approached the input token limit for ${config.getModel()}. We'll send a compressed context to the model for any future messages.`,
+        },
+        Date.now(),
+      ),
+    [addItem, config],
+  );
+
   const processGeminiStreamEvents = useCallback(
     async (
       stream: AsyncIterable<GeminiEvent>,
@@ -364,20 +376,35 @@ export const useGeminiStream = (
       let geminiMessageBuffer = '';
       const toolCallRequests: ToolCallRequestInfo[] = [];
       for await (const event of stream) {
-        if (event.type === ServerGeminiEventType.Content) {
+        switch (event.type) {
+          case ServerGeminiEventType.Content:
             geminiMessageBuffer = handleContentEvent(
               event.value,
               geminiMessageBuffer,
               userMessageTimestamp,
             );
-        } else if (event.type === ServerGeminiEventType.ToolCallRequest) {
+            break;
+          case ServerGeminiEventType.ToolCallRequest:
             toolCallRequests.push(event.value);
-        } else if (event.type === ServerGeminiEventType.UserCancelled) {
+            break;
+          case ServerGeminiEventType.UserCancelled:
             handleUserCancelledEvent(userMessageTimestamp);
-          return StreamProcessingStatus.UserCancelled;
+            break;
-        } else if (event.type === ServerGeminiEventType.Error) {
+          case ServerGeminiEventType.Error:
             handleErrorEvent(event.value, userMessageTimestamp);
-          return StreamProcessingStatus.Error;
+            break;
+          case ServerGeminiEventType.ChatCompressed:
+            handleChatCompressionEvent();
+            break;
+          case ServerGeminiEventType.ToolCallConfirmation:
+          case ServerGeminiEventType.ToolCallResponse:
+            // do nothing
+            break;
+          default: {
+            // enforces exhaustive switch-case
+            const unreachable: never = event;
+            return unreachable;
+          }
         }
       }
       if (toolCallRequests.length > 0) {
@@ -390,6 +417,7 @@ export const useGeminiStream = (
       handleUserCancelledEvent,
       handleErrorEvent,
       scheduleToolCalls,
+      handleChatCompressionEvent,
     ],
   );
 

packages/core/src/core/client.ts

@@ -16,7 +16,7 @@ import {
 } from '@google/genai';
 import process from 'node:process';
 import { getFolderStructure } from '../utils/getFolderStructure.js';
-import { Turn, ServerGeminiStreamEvent } from './turn.js';
+import { Turn, ServerGeminiStreamEvent, GeminiEventType } from './turn.js';
 import { Config } from '../config/config.js';
 import { getCoreSystemPrompt } from './prompts.js';
 import { ReadManyFilesTool } from '../tools/read-many-files.js';
@@ -173,7 +173,10 @@ export class GeminiClient {
       return;
     }
 
-    await this.tryCompressChat();
+    const compressed = await this.tryCompressChat();
+    if (compressed) {
+      yield { type: GeminiEventType.ChatCompressed };
+    }
     const chat = await this.chat;
     const turn = new Turn(chat);
     const resultStream = turn.run(request, signal);
@@ -325,7 +328,7 @@ export class GeminiClient {
     }
   }
 
-  private async tryCompressChat(): Promise<void> {
+  private async tryCompressChat(): Promise<boolean> {
     const chat = await this.chat;
     const history = chat.getHistory(true); // Get curated history
 
@@ -340,7 +343,7 @@ export class GeminiClient {
       console.warn(
         `Could not determine token count for model ${this.model}. Skipping compression check.`,
       );
-      return;
+      return false;
     }
     const tokenCount = totalTokens; // Now guaranteed to be a number
 
@@ -350,11 +353,11 @@ export class GeminiClient {
       console.warn(
         `No token limit defined for model ${this.model}. Skipping compression check.`,
       );
-      return;
+      return false;
     }
 
     if (tokenCount < 0.95 * limit) {
-      return;
+      return false;
     }
     const summarizationRequestMessage = {
       text: 'Summarize our conversation up to this point. The summary should be a concise yet comprehensive overview of all key topics, questions, answers, and important details discussed. This summary will replace the current chat history to conserve tokens, so it must capture everything essential to understand the context and continue our conversation effectively as if no information was lost.',
@@ -372,5 +375,7 @@ export class GeminiClient {
         parts: [{ text: response.text }],
       },
     ]);
+
+    return true;
   }
 }

packages/core/src/core/turn.ts

@@ -42,6 +42,7 @@ export enum GeminiEventType {
   ToolCallConfirmation = 'tool_call_confirmation',
   UserCancelled = 'user_cancelled',
   Error = 'error',
+  ChatCompressed = 'chat_compressed',
 }
 
 export interface GeminiErrorEventValue {
@@ -95,6 +96,10 @@ export type ServerGeminiErrorEvent = {
   value: GeminiErrorEventValue;
 };
 
+export type ServerGeminiChatCompressedEvent = {
+  type: GeminiEventType.ChatCompressed;
+};
+
 // The original union type, now composed of the individual types
 export type ServerGeminiStreamEvent =
   | ServerGeminiContentEvent
@@ -102,7 +107,8 @@ export type ServerGeminiStreamEvent =
   | ServerGeminiToolCallResponseEvent
   | ServerGeminiToolCallConfirmationEvent
   | ServerGeminiUserCancelledEvent
-  | ServerGeminiErrorEvent;
+  | ServerGeminiErrorEvent
+  | ServerGeminiChatCompressedEvent;
 
 // A turn manages the agentic loop turn within the server context.
 export class Turn {