@machina.ai/cell-cli-core 1.0.13-rc9 → 1.0.21-rc1

package/dist/src/telemetry/clearcut-logger/clearcut-logger.js

@@ -3,34 +3,102 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Buffer } from 'buffer';
-import * as https from 'https';
 import { HttpsProxyAgent } from 'https-proxy-agent';
-import { EndSessionEvent, } from '../types.js';
 import { EventMetadataKey } from './event-metadata-key.js';
-import { getInstallationId } from '../../utils/user_id.js';
-import { getCachedGoogleAccount, getLifetimeGoogleAccounts, } from '../../utils/user_account.js';
 import { safeJsonStringify } from '../../utils/safeJsonStringify.js';
-const start_session_event_name = 'start_session';
-const new_prompt_event_name = 'new_prompt';
-const tool_call_event_name = 'tool_call';
-const api_request_event_name = 'api_request';
-const api_response_event_name = 'api_response';
-const api_error_event_name = 'api_error';
-const end_session_event_name = 'end_session';
-const flash_fallback_event_name = 'flash_fallback';
-const loop_detected_event_name = 'loop_detected';
+import { getCachedGoogleAccount, getLifetimeGoogleAccounts, } from '../../utils/user_account.js';
+import { getInstallationId } from '../../utils/user_id.js';
+import { FixedDeque } from 'mnemonist';
+import { GIT_COMMIT_INFO, CLI_VERSION } from '../../generated/git-commit.js';
+import { DetectedIde, detectIde } from '../../ide/detect-ide.js';
+export var EventNames;
+(function (EventNames) {
+    EventNames["START_SESSION"] = "start_session";
+    EventNames["NEW_PROMPT"] = "new_prompt";
+    EventNames["TOOL_CALL"] = "tool_call";
+    EventNames["API_REQUEST"] = "api_request";
+    EventNames["API_RESPONSE"] = "api_response";
+    EventNames["API_ERROR"] = "api_error";
+    EventNames["END_SESSION"] = "end_session";
+    EventNames["FLASH_FALLBACK"] = "flash_fallback";
+    EventNames["LOOP_DETECTED"] = "loop_detected";
+    EventNames["NEXT_SPEAKER_CHECK"] = "next_speaker_check";
+    EventNames["SLASH_COMMAND"] = "slash_command";
+    EventNames["MALFORMED_JSON_RESPONSE"] = "malformed_json_response";
+    EventNames["IDE_CONNECTION"] = "ide_connection";
+    EventNames["KITTY_SEQUENCE_OVERFLOW"] = "kitty_sequence_overflow";
+    EventNames["CHAT_COMPRESSION"] = "chat_compression";
+})(EventNames || (EventNames = {}));
+/**
+ * Determine the surface that the user is currently using.  Surface is effectively the
+ * distribution channel in which the user is using Gemini CLI.  Gemini CLI comes bundled
+ * w/ Firebase Studio and Cloud Shell.  Users that manually download themselves will
+ * likely be "SURFACE_NOT_SET".
+ *
+ * This is computed based upon a series of environment variables these distribution
+ * methods might have in their runtimes.
+ */
+function determineSurface() {
+    if (process.env['SURFACE']) {
+        return process.env['SURFACE'];
+    }
+    else if (process.env['GITHUB_SHA']) {
+        return 'GitHub';
+    }
+    else if (process.env['TERM_PROGRAM'] === 'vscode') {
+        return detectIde() || DetectedIde.VSCode;
+    }
+    else {
+        return 'SURFACE_NOT_SET';
+    }
+}
+/**
+ * Clearcut URL to send logging events to.
+ */
+const CLEARCUT_URL = 'https://play.googleapis.com/log?format=json&hasfast=true';
+/**
+ * Interval in which buffered events are sent to clearcut.
+ */
+const FLUSH_INTERVAL_MS = 1000 * 60;
+/**
+ * Maximum amount of events to keep in memory. Events added after this amount
+ * are dropped until the next flush to clearcut, which happens periodically as
+ * defined by {@link FLUSH_INTERVAL_MS}.
+ */
+const MAX_EVENTS = 1000;
+/**
+ * Maximum events to retry after a failed clearcut flush
+ */
+const MAX_RETRY_EVENTS = 100;
 // Singleton class for batch posting log events to Clearcut. When a new event comes in, the elapsed time
 // is checked and events are flushed to Clearcut if at least a minute has passed since the last flush.
 export class ClearcutLogger {
     static instance;
     config;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Clearcut expects this format.
-    events = [];
-    last_flush_time = Date.now();
-    flush_interval_ms = 1000 * 60; // Wait at least a minute before flushing events.
+    sessionData = [];
+    promptId = '';
+    /**
+     * Queue of pending events that need to be flushed to the server.  New events
+     * are added to this queue and then flushed on demand (via `flushToClearcut`)
+     */
+    events;
+    /**
+     * The last time that the events were successfully flushed to the server.
+     */
+    lastFlushTime = Date.now();
+    /**
+     * the value is true when there is a pending flush happening. This prevents
+     * concurrent flush operations.
+     */
+    flushing = false;
+    /**
+     * This value is true when a flush was requested during an ongoing flush.
+     */
+    pendingFlush = false;
     constructor(config) {
         this.config = config;
+        this.events = new FixedDeque(Array, MAX_EVENTS);
+        this.promptId = config?.getSessionId() ?? '';
     }
     static getInstance(config) {
         if (config === undefined || !config?.getUsageStatisticsEnabled())
@@ -40,27 +108,44 @@ export class ClearcutLogger {
         }
         return ClearcutLogger.instance;
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Clearcut expects this format.
+    /** For testing purposes only. */
+    static clearInstance() {
+        // @ts-expect-error - ClearcutLogger is a singleton, but we need to clear it for tests.
+        ClearcutLogger.instance = undefined;
+    }
     enqueueLogEvent(event) {
-        this.events.push([
-            {
-                event_time_ms: Date.now(),
-                source_extension_json: safeJsonStringify(event),
-            },
-        ]);
+        try {
+            // Manually handle overflow for FixedDeque, which throws when full.
+            const wasAtCapacity = this.events.size >= MAX_EVENTS;
+            if (wasAtCapacity) {
+                this.events.shift(); // Evict oldest element to make space.
+            }
+            this.events.push([
+                {
+                    event_time_ms: Date.now(),
+                    source_extension_json: safeJsonStringify(event),
+                },
+            ]);
+            if (wasAtCapacity && this.config?.getDebugMode()) {
+                console.debug(`ClearcutLogger: Dropped old event to prevent memory leak (queue size: ${this.events.size})`);
+            }
+        }
+        catch (error) {
+            if (this.config?.getDebugMode()) {
+                console.error('ClearcutLogger: Failed to enqueue log event.', error);
+            }
+        }
     }
-    createLogEvent(name, data) {
+    createLogEvent(eventName, data = []) {
         const email = getCachedGoogleAccount();
-        const totalAccounts = getLifetimeGoogleAccounts();
-        data.push({
-            gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
-            value: totalAccounts.toString(),
-        });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (eventName !== EventNames.START_SESSION) {
+            data.push(...this.sessionData);
+        }
+        data = this.addDefaultFields(data);
         const logEvent = {
             console_type: 'GEMINI_CLI',
-            application: 102,
-            event_name: name,
+            application: 102, // GEMINI_CLI
+            event_name: eventName,
             event_metadata: [data],
         };
         // Should log either email or install ID, not both. See go/cloudmill-1p-oss-instrumentation#define-sessionable-id
@@ -73,115 +158,86 @@ export class ClearcutLogger {
         return logEvent;
     }
     flushIfNeeded() {
-        if (Date.now() - this.last_flush_time < this.flush_interval_ms) {
+        if (Date.now() - this.lastFlushTime < FLUSH_INTERVAL_MS) {
             return;
         }
         this.flushToClearcut().catch((error) => {
             console.debug('Error flushing to Clearcut:', error);
         });
     }
-    flushToClearcut() {
+    async flushToClearcut() {
+        if (this.flushing) {
+            if (this.config?.getDebugMode()) {
+                console.debug('ClearcutLogger: Flush already in progress, marking pending flush.');
+            }
+            this.pendingFlush = true;
+            return Promise.resolve({});
+        }
+        this.flushing = true;
         if (this.config?.getDebugMode()) {
             console.log('Flushing log events to Clearcut.');
         }
-        const eventsToSend = [...this.events];
-        this.events.length = 0;
-        return new Promise((resolve, reject) => {
-            const request = [
-                {
-                    log_source_name: 'CONCORD',
-                    request_time_ms: Date.now(),
-                    log_event: eventsToSend,
-                },
-            ];
-            const body = safeJsonStringify(request);
-            const options = {
-                hostname: 'play.googleapis.com',
-                path: '/log',
+        const eventsToSend = this.events.toArray();
+        this.events.clear();
+        const request = [
+            {
+                log_source_name: 'CONCORD',
+                request_time_ms: Date.now(),
+                log_event: eventsToSend,
+            },
+        ];
+        let result = {};
+        try {
+            const response = await fetch(CLEARCUT_URL, {
                 method: 'POST',
-                headers: { 'Content-Length': Buffer.byteLength(body) },
-            };
-            const bufs = [];
-            const req = https.request({
-                ...options,
-                agent: this.getProxyAgent(),
-            }, (res) => {
-                res.on('data', (buf) => bufs.push(buf));
-                res.on('end', () => {
-                    resolve(Buffer.concat(bufs));
-                });
+                body: safeJsonStringify(request),
+                headers: {
+                    'Content-Type': 'application/json',
+                },
             });
-            req.on('error', (e) => {
+            const responseBody = await response.text();
+            if (response.status >= 200 && response.status < 300) {
+                this.lastFlushTime = Date.now();
+                const nextRequestWaitMs = Number(JSON.parse(responseBody)[0]);
+                result = {
+                    ...result,
+                    nextRequestWaitMs,
+                };
+            }
+            else {
                 if (this.config?.getDebugMode()) {
-                    console.log('Clearcut POST request error: ', e);
+                    console.error(`Error flushing log events: HTTP ${response.status}: ${response.statusText}`);
                 }
-                // Add the events back to the front of the queue to be retried.
-                this.events.unshift(...eventsToSend);
-                reject(e);
-            });
-            req.end(body);
-        })
-            .then((buf) => {
-            try {
-                this.last_flush_time = Date.now();
-                return this.decodeLogResponse(buf) || {};
-            }
-            catch (error) {
-                console.error('Error flushing log events:', error);
-                return {};
+                // Re-queue failed events for retry
+                this.requeueFailedEvents(eventsToSend);
             }
-        })
-            .catch((error) => {
-            // Handle all errors to prevent unhandled promise rejections
-            console.error('Error flushing log events:', error);
-            // Return empty response to maintain the Promise<LogResponse> contract
-            return {};
-        });
-    }
-    // Visible for testing. Decodes protobuf-encoded response from Clearcut server.
-    decodeLogResponse(buf) {
-        // TODO(obrienowen): return specific errors to facilitate debugging.
-        if (buf.length < 1) {
-            return undefined;
         }
-        // The first byte of the buffer is `field<<3 | type`. We're looking for field
-        // 1, with type varint, represented by type=0. If the first byte isn't 8, that
-        // means field 1 is missing or the message is corrupted. Either way, we return
-        // undefined.
-        if (buf.readUInt8(0) !== 8) {
-            return undefined;
-        }
-        let ms = BigInt(0);
-        let cont = true;
-        // In each byte, the most significant bit is the continuation bit. If it's
-        // set, we keep going. The lowest 7 bits, are data bits. They are concatenated
-        // in reverse order to form the final number.
-        for (let i = 1; cont && i < buf.length; i++) {
-            const byte = buf.readUInt8(i);
-            ms |= BigInt(byte & 0x7f) << BigInt(7 * (i - 1));
-            cont = (byte & 0x80) !== 0;
+        catch (e) {
+            if (this.config?.getDebugMode()) {
+                console.error('Error flushing log events:', e);
+            }
+            // Re-queue failed events for retry
+            this.requeueFailedEvents(eventsToSend);
         }
-        if (cont) {
-            // We have fallen off the buffer without seeing a terminating byte. The
-            // message is corrupted.
-            return undefined;
+        this.flushing = false;
+        // If a flush was requested while we were flushing, flush again
+        if (this.pendingFlush) {
+            this.pendingFlush = false;
+            // Fire and forget the pending flush
+            this.flushToClearcut().catch((error) => {
+                if (this.config?.getDebugMode()) {
+                    console.debug('Error in pending flush to Clearcut:', error);
+                }
+            });
         }
-        const returnVal = {
-            nextRequestWaitMs: Number(ms),
-        };
-        return returnVal;
+        return result;
     }
     logStartSessionEvent(event) {
-        const surface = process.env.SURFACE || 'SURFACE_NOT_SET';
         const data = [
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_MODEL,
                 value: event.model,
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: this.config?.getSessionId() ?? '',
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_EMBEDDING_MODEL,
                 value: event.embedding_model,
@@ -230,37 +286,23 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_TELEMETRY_LOG_USER_PROMPTS_ENABLED,
                 value: event.telemetry_log_user_prompts_enabled.toString(),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
-                value: surface,
-            },
         ];
+        this.sessionData = data;
         // Flush start event immediately
-        this.enqueueLogEvent(this.createLogEvent(start_session_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.START_SESSION, data));
         this.flushToClearcut().catch((error) => {
             console.debug('Error flushing to Clearcut:', error);
         });
     }
     logNewPromptEvent(event) {
+        this.promptId = event.prompt_id;
         const data = [
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_USER_PROMPT_LENGTH,
                 value: JSON.stringify(event.prompt_length),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: this.config?.getSessionId() ?? '',
-            },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
-                value: JSON.stringify(event.auth_type),
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(new_prompt_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.NEW_PROMPT, data));
         this.flushIfNeeded();
     }
     logToolCallEvent(event) {
@@ -269,10 +311,6 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_NAME,
                 value: JSON.stringify(event.function_name),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_DECISION,
                 value: JSON.stringify(event.decision),
@@ -293,8 +331,28 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_ERROR_TYPE,
                 value: JSON.stringify(event.error_type),
             },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_TYPE,
+                value: JSON.stringify(event.tool_type),
+            },
         ];
-        const logEvent = this.createLogEvent(tool_call_event_name, data);
+        if (event.metadata) {
+            const metadataMapping = {
+                ai_added_lines: EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+                ai_removed_lines: EventMetadataKey.GEMINI_CLI_AI_REMOVED_LINES,
+                user_added_lines: EventMetadataKey.GEMINI_CLI_USER_ADDED_LINES,
+                user_removed_lines: EventMetadataKey.GEMINI_CLI_USER_REMOVED_LINES,
+            };
+            for (const [key, gemini_cli_key] of Object.entries(metadataMapping)) {
+                if (event.metadata[key] !== undefined) {
+                    data.push({
+                        gemini_cli_key,
+                        value: JSON.stringify(event.metadata[key]),
+                    });
+                }
+            }
+        }
+        const logEvent = this.createLogEvent(EventNames.TOOL_CALL, data);
         this.enqueueLogEvent(logEvent);
         this.flushIfNeeded();
     }
@@ -304,12 +362,8 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_REQUEST_MODEL,
                 value: JSON.stringify(event.model),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(api_request_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.API_REQUEST, data));
         this.flushIfNeeded();
     }
     logApiResponseEvent(event) {
@@ -318,10 +372,6 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_MODEL,
                 value: JSON.stringify(event.model),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_STATUS_CODE,
                 value: JSON.stringify(event.status_code),
@@ -354,12 +404,8 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_TOOL_TOKEN_COUNT,
                 value: JSON.stringify(event.tool_token_count),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
-                value: JSON.stringify(event.auth_type),
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(api_response_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.API_RESPONSE, data));
         this.flushIfNeeded();
     }
     logApiErrorEvent(event) {
@@ -368,10 +414,6 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_MODEL,
                 value: JSON.stringify(event.model),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_TYPE,
                 value: JSON.stringify(event.error_type),
@@ -384,57 +426,155 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_DURATION_MS,
                 value: JSON.stringify(event.duration_ms),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
-                value: JSON.stringify(event.auth_type),
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(api_error_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.API_ERROR, data));
         this.flushIfNeeded();
     }
-    logFlashFallbackEvent(event) {
+    logChatCompressionEvent(event) {
         const data = [
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
-                value: JSON.stringify(event.auth_type),
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_COMPRESSION_TOKENS_BEFORE,
+                value: `${event.tokens_before}`,
             },
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: this.config?.getSessionId() ?? '',
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_COMPRESSION_TOKENS_AFTER,
+                value: `${event.tokens_after}`,
             },
         ];
-        this.enqueueLogEvent(this.createLogEvent(flash_fallback_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.CHAT_COMPRESSION, data));
+    }
+    logFlashFallbackEvent() {
+        this.enqueueLogEvent(this.createLogEvent(EventNames.FLASH_FALLBACK, []));
         this.flushToClearcut().catch((error) => {
             console.debug('Error flushing to Clearcut:', error);
         });
     }
     logLoopDetectedEvent(event) {
         const data = [
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: this.config?.getSessionId() ?? '',
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_LOOP_DETECTED_TYPE,
                 value: JSON.stringify(event.loop_type),
             },
         ];
-        this.enqueueLogEvent(this.createLogEvent(loop_detected_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.LOOP_DETECTED, data));
         this.flushIfNeeded();
     }
-    logEndSessionEvent(event) {
+    logNextSpeakerCheck(event) {
         const data = [
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: event?.session_id?.toString() ?? '',
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_RESPONSE_FINISH_REASON,
+                value: JSON.stringify(event.finish_reason),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_NEXT_SPEAKER_CHECK_RESULT,
+                value: JSON.stringify(event.result),
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.NEXT_SPEAKER_CHECK, data));
+        this.flushIfNeeded();
+    }
+    logSlashCommandEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SLASH_COMMAND_NAME,
+                value: JSON.stringify(event.command),
+            },
+        ];
+        if (event.subcommand) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SLASH_COMMAND_SUBCOMMAND,
+                value: JSON.stringify(event.subcommand),
+            });
+        }
+        if (event.status) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SLASH_COMMAND_STATUS,
+                value: JSON.stringify(event.status),
+            });
+        }
+        this.enqueueLogEvent(this.createLogEvent(EventNames.SLASH_COMMAND, data));
+        this.flushIfNeeded();
+    }
+    logMalformedJsonResponseEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_MALFORMED_JSON_RESPONSE_MODEL,
+                value: JSON.stringify(event.model),
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.MALFORMED_JSON_RESPONSE, data));
+        this.flushIfNeeded();
+    }
+    logIdeConnectionEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_IDE_CONNECTION_TYPE,
+                value: JSON.stringify(event.connection_type),
             },
         ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.IDE_CONNECTION, data));
+        this.flushIfNeeded();
+    }
+    logKittySequenceOverflowEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_KITTY_SEQUENCE_LENGTH,
+                value: event.sequence_length.toString(),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_KITTY_TRUNCATED_SEQUENCE,
+                value: event.truncated_sequence,
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.KITTY_SEQUENCE_OVERFLOW, data));
+        this.flushIfNeeded();
+    }
+    logEndSessionEvent() {
         // Flush immediately on session end.
-        this.enqueueLogEvent(this.createLogEvent(end_session_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.END_SESSION, []));
         this.flushToClearcut().catch((error) => {
             console.debug('Error flushing to Clearcut:', error);
         });
     }
+    /**
+     * Adds default fields to data, and returns a new data array.  This fields
+     * should exist on all log events.
+     */
+    addDefaultFields(data) {
+        const totalAccounts = getLifetimeGoogleAccounts();
+        const surface = determineSurface();
+        const defaultLogMetadata = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
+                value: this.config?.getSessionId() ?? '',
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
+                value: JSON.stringify(this.config?.getContentGeneratorConfig()?.authType),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
+                value: `${totalAccounts}`,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
+                value: surface,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_VERSION,
+                value: CLI_VERSION,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_GIT_COMMIT_HASH,
+                value: GIT_COMMIT_INFO,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
+                value: this.promptId,
+            },
+        ];
+        return [...data, ...defaultLogMetadata];
+    }
     getProxyAgent() {
         const proxyUrl = this.config?.getProxy();
         if (!proxyUrl)
@@ -449,8 +589,42 @@ export class ClearcutLogger {
         }
     }
     shutdown() {
-        const event = new EndSessionEvent(this.config);
-        this.logEndSessionEvent(event);
+        this.logEndSessionEvent();
+    }
+    requeueFailedEvents(eventsToSend) {
+        // Add the events back to the front of the queue to be retried, but limit retry queue size
+        const eventsToRetry = eventsToSend.slice(-MAX_RETRY_EVENTS); // Keep only the most recent events
+        // Log a warning if we're dropping events
+        if (eventsToSend.length > MAX_RETRY_EVENTS && this.config?.getDebugMode()) {
+            console.warn(`ClearcutLogger: Dropping ${eventsToSend.length - MAX_RETRY_EVENTS} events due to retry queue limit. Total events: ${eventsToSend.length}, keeping: ${MAX_RETRY_EVENTS}`);
+        }
+        // Determine how many events can be re-queued
+        const availableSpace = MAX_EVENTS - this.events.size;
+        const numEventsToRequeue = Math.min(eventsToRetry.length, availableSpace);
+        if (numEventsToRequeue === 0) {
+            if (this.config?.getDebugMode()) {
+                console.debug(`ClearcutLogger: No events re-queued (queue size: ${this.events.size})`);
+            }
+            return;
+        }
+        // Get the most recent events to re-queue
+        const eventsToRequeue = eventsToRetry.slice(eventsToRetry.length - numEventsToRequeue);
+        // Prepend events to the front of the deque to be retried first.
+        // We iterate backwards to maintain the original order of the failed events.
+        for (let i = eventsToRequeue.length - 1; i >= 0; i--) {
+            this.events.unshift(eventsToRequeue[i]);
+        }
+        // Clear any potential overflow
+        while (this.events.size > MAX_EVENTS) {
+            this.events.pop();
+        }
+        if (this.config?.getDebugMode()) {
+            console.debug(`ClearcutLogger: Re-queued ${numEventsToRequeue} events for retry (queue size: ${this.events.size})`);
+        }
     }
 }
+export const TEST_ONLY = {
+    MAX_RETRY_EVENTS,
+    MAX_EVENTS,
+};
 //# sourceMappingURL=clearcut-logger.js.map