@google/gemini-cli-core 0.0.8999999 → 0.0.77777773

package/dist/src/telemetry/types.js

@@ -7,6 +7,10 @@ import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
 import { AuthType } from '../core/contentGenerator.js';
 import { getDecisionFromOutcome, ToolCallDecision, } from './tool-call-decision.js';
 export { ToolCallDecision };
+import { getCommonAttributes } from './telemetryAttributes.js';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import { safeJsonStringify } from '../utils/safeJsonStringify.js';
+export const EVENT_CLI_CONFIG = 'gemini_cli.config';
 export class StartSessionEvent {
     'event.name';
     'event.timestamp';
@@ -36,6 +40,7 @@ export class StartSessionEvent {
             useVertex = generatorConfig.authType === AuthType.USE_VERTEX_AI;
         }
         this['event.name'] = 'cli_config';
+        this['event.timestamp'] = new Date().toISOString();
         this.model = config.getModel();
         this.embedding_model = config.getEmbeddingModel();
         this.sandbox_enabled =
@@ -63,6 +68,31 @@ export class StartSessionEvent {
                 .join(',');
         }
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_CLI_CONFIG,
+            'event.timestamp': this['event.timestamp'],
+            model: this.model,
+            embedding_model: this.embedding_model,
+            sandbox_enabled: this.sandbox_enabled,
+            core_tools_enabled: this.core_tools_enabled,
+            approval_mode: this.approval_mode,
+            api_key_enabled: this.api_key_enabled,
+            vertex_ai_enabled: this.vertex_ai_enabled,
+            log_user_prompts_enabled: this.telemetry_log_user_prompts_enabled,
+            file_filtering_respect_git_ignore: this.file_filtering_respect_git_ignore,
+            debug_mode: this.debug_enabled,
+            mcp_servers: this.mcp_servers,
+            mcp_servers_count: this.mcp_servers_count,
+            mcp_tools: this.mcp_tools,
+            mcp_tools_count: this.mcp_tools_count,
+            output_format: this.output_format,
+        };
+    }
+    toLogBody() {
+        return 'CLI configuration loaded.';
+    }
 }
 export class EndSessionEvent {
     'event.name';
@@ -74,6 +104,7 @@ export class EndSessionEvent {
         this.session_id = config?.getSessionId();
     }
 }
+export const EVENT_USER_PROMPT = 'gemini_cli.user_prompt';
 export class UserPromptEvent {
     'event.name';
     'event.timestamp';
@@ -89,7 +120,27 @@ export class UserPromptEvent {
         this.auth_type = auth_type;
         this.prompt = prompt;
     }
+    toOpenTelemetryAttributes(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_USER_PROMPT,
+            'event.timestamp': this['event.timestamp'],
+            prompt_length: this.prompt_length,
+            prompt_id: this.prompt_id,
+        };
+        if (this.auth_type) {
+            attributes['auth_type'] = this.auth_type;
+        }
+        if (config.getTelemetryLogPromptsEnabled()) {
+            attributes['prompt'] = this.prompt;
+        }
+        return attributes;
+    }
+    toLogBody() {
+        return `User prompt. Length: ${this.prompt_length}.`;
+    }
 }
+export const EVENT_TOOL_CALL = 'gemini_cli.tool_call';
 export class ToolCallEvent {
     'event.name';
     'event.timestamp';
@@ -106,48 +157,89 @@ export class ToolCallEvent {
     mcp_server_name;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     metadata;
-    constructor(call) {
+    constructor(call, function_name, function_args, duration_ms, success, prompt_id, tool_type, error) {
         this['event.name'] = 'tool_call';
         this['event.timestamp'] = new Date().toISOString();
-        this.function_name = call.request.name;
-        this.function_args = call.request.args;
-        this.duration_ms = call.durationMs ?? 0;
-        this.success = call.status === 'success';
-        this.decision = call.outcome
-            ? getDecisionFromOutcome(call.outcome)
-            : undefined;
-        this.error = call.response.error?.message;
-        this.error_type = call.response.errorType;
-        this.prompt_id = call.request.prompt_id;
-        this.content_length = call.response.contentLength;
-        if (typeof call.tool !== 'undefined' &&
-            call.tool instanceof DiscoveredMCPTool) {
-            this.tool_type = 'mcp';
-            this.mcp_server_name = call.tool.serverName;
+        if (call) {
+            this.function_name = call.request.name;
+            this.function_args = call.request.args;
+            this.duration_ms = call.durationMs ?? 0;
+            this.success = call.status === 'success';
+            this.decision = call.outcome
+                ? getDecisionFromOutcome(call.outcome)
+                : undefined;
+            this.error = call.response.error?.message;
+            this.error_type = call.response.errorType;
+            this.prompt_id = call.request.prompt_id;
+            this.content_length = call.response.contentLength;
+            if (typeof call.tool !== 'undefined' &&
+                call.tool instanceof DiscoveredMCPTool) {
+                this.tool_type = 'mcp';
+                this.mcp_server_name = call.tool.serverName;
+            }
+            else {
+                this.tool_type = 'native';
+            }
+            if (call.status === 'success' &&
+                typeof call.response.resultDisplay === 'object' &&
+                call.response.resultDisplay !== null &&
+                'diffStat' in call.response.resultDisplay) {
+                const diffStat = call.response.resultDisplay.diffStat;
+                if (diffStat) {
+                    this.metadata = {
+                        model_added_lines: diffStat.model_added_lines,
+                        model_removed_lines: diffStat.model_removed_lines,
+                        model_added_chars: diffStat.model_added_chars,
+                        model_removed_chars: diffStat.model_removed_chars,
+                        user_added_lines: diffStat.user_added_lines,
+                        user_removed_lines: diffStat.user_removed_lines,
+                        user_added_chars: diffStat.user_added_chars,
+                        user_removed_chars: diffStat.user_removed_chars,
+                    };
+                }
+            }
         }
         else {
-            this.tool_type = 'native';
+            this.function_name = function_name;
+            this.function_args = function_args;
+            this.duration_ms = duration_ms;
+            this.success = success;
+            this.prompt_id = prompt_id;
+            this.tool_type = tool_type;
+            this.error = error;
         }
-        if (call.status === 'success' &&
-            typeof call.response.resultDisplay === 'object' &&
-            call.response.resultDisplay !== null &&
-            'diffStat' in call.response.resultDisplay) {
-            const diffStat = call.response.resultDisplay.diffStat;
-            if (diffStat) {
-                this.metadata = {
-                    model_added_lines: diffStat.model_added_lines,
-                    model_removed_lines: diffStat.model_removed_lines,
-                    model_added_chars: diffStat.model_added_chars,
-                    model_removed_chars: diffStat.model_removed_chars,
-                    user_added_lines: diffStat.user_added_lines,
-                    user_removed_lines: diffStat.user_removed_lines,
-                    user_added_chars: diffStat.user_added_chars,
-                    user_removed_chars: diffStat.user_removed_chars,
-                };
+    }
+    toOpenTelemetryAttributes(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_TOOL_CALL,
+            'event.timestamp': this['event.timestamp'],
+            function_name: this.function_name,
+            function_args: safeJsonStringify(this.function_args, 2),
+            duration_ms: this.duration_ms,
+            success: this.success,
+            decision: this.decision,
+            prompt_id: this.prompt_id,
+            tool_type: this.tool_type,
+            content_length: this.content_length,
+            mcp_server_name: this.mcp_server_name,
+            metadata: this.metadata,
+        };
+        if (this.error) {
+            attributes['error'] = this.error;
+            attributes['error.message'] = this.error;
+            if (this.error_type) {
+                attributes['error_type'] = this.error_type;
+                attributes['error.type'] = this.error_type;
             }
         }
+        return attributes;
+    }
+    toLogBody() {
+        return `Tool call: ${this.function_name}${this.decision ? `. Decision: ${this.decision}` : ''}. Success: ${this.success}. Duration: ${this.duration_ms}ms.`;
     }
 }
+export const EVENT_API_REQUEST = 'gemini_cli.api_request';
 export class ApiRequestEvent {
     'event.name';
     'event.timestamp';
@@ -161,7 +253,21 @@ export class ApiRequestEvent {
         this.prompt_id = prompt_id;
         this.request_text = request_text;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_API_REQUEST,
+            'event.timestamp': this['event.timestamp'],
+            model: this.model,
+            prompt_id: this.prompt_id,
+            request_text: this.request_text,
+        };
+    }
+    toLogBody() {
+        return `API request to ${this.model}.`;
+    }
 }
+export const EVENT_API_ERROR = 'gemini_cli.api_error';
 export class ApiErrorEvent {
     'event.name';
     'event.timestamp';
@@ -183,7 +289,34 @@ export class ApiErrorEvent {
         this.prompt_id = prompt_id;
         this.auth_type = auth_type;
     }
+    toOpenTelemetryAttributes(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_API_ERROR,
+            'event.timestamp': this['event.timestamp'],
+            ['error.message']: this.error,
+            model_name: this.model,
+            duration: this.duration_ms,
+            model: this.model,
+            error: this.error,
+            status_code: this.status_code,
+            duration_ms: this.duration_ms,
+            prompt_id: this.prompt_id,
+            auth_type: this.auth_type,
+        };
+        if (this.error_type) {
+            attributes['error.type'] = this.error_type;
+        }
+        if (typeof this.status_code === 'number') {
+            attributes[SemanticAttributes.HTTP_STATUS_CODE] = this.status_code;
+        }
+        return attributes;
+    }
+    toLogBody() {
+        return `API error for ${this.model}. Error: ${this.error}. Duration: ${this.duration_ms}ms.`;
+    }
 }
+export const EVENT_API_RESPONSE = 'gemini_cli.api_response';
 export class ApiResponseEvent {
     'event.name';
     'event.timestamp';
@@ -215,7 +348,38 @@ export class ApiResponseEvent {
         this.prompt_id = prompt_id;
         this.auth_type = auth_type;
     }
+    toOpenTelemetryAttributes(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_API_RESPONSE,
+            'event.timestamp': this['event.timestamp'],
+            model: this.model,
+            duration_ms: this.duration_ms,
+            input_token_count: this.input_token_count,
+            output_token_count: this.output_token_count,
+            cached_content_token_count: this.cached_content_token_count,
+            thoughts_token_count: this.thoughts_token_count,
+            tool_token_count: this.tool_token_count,
+            total_token_count: this.total_token_count,
+            prompt_id: this.prompt_id,
+            auth_type: this.auth_type,
+            status_code: this.status_code,
+        };
+        if (this.response_text) {
+            attributes['response_text'] = this.response_text;
+        }
+        if (this.status_code) {
+            if (typeof this.status_code === 'number') {
+                attributes[SemanticAttributes.HTTP_STATUS_CODE] = this.status_code;
+            }
+        }
+        return attributes;
+    }
+    toLogBody() {
+        return `API response from ${this.model}. Status: ${this.status_code || 'N/A'}. Duration: ${this.duration_ms}ms.`;
+    }
 }
+export const EVENT_FLASH_FALLBACK = 'gemini_cli.flash_fallback';
 export class FlashFallbackEvent {
     'event.name';
     'event.timestamp';
@@ -225,7 +389,19 @@ export class FlashFallbackEvent {
         this['event.timestamp'] = new Date().toISOString();
         this.auth_type = auth_type;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_FLASH_FALLBACK,
+            'event.timestamp': this['event.timestamp'],
+            auth_type: this.auth_type,
+        };
+    }
+    toLogBody() {
+        return `Switching to flash as Fallback.`;
+    }
 }
+export const EVENT_RIPGREP_FALLBACK = 'gemini_cli.ripgrep_fallback';
 export class RipgrepFallbackEvent {
     error;
     'event.name';
@@ -235,6 +411,17 @@ export class RipgrepFallbackEvent {
         this['event.name'] = 'ripgrep_fallback';
         this['event.timestamp'] = new Date().toISOString();
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_RIPGREP_FALLBACK,
+            'event.timestamp': this['event.timestamp'],
+            error: this.error,
+        };
+    }
+    toLogBody() {
+        return `Switching to grep as fallback.`;
+    }
 }
 export var LoopType;
 (function (LoopType) {
@@ -253,6 +440,18 @@ export class LoopDetectedEvent {
         this.loop_type = loop_type;
         this.prompt_id = prompt_id;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': this['event.name'],
+            'event.timestamp': this['event.timestamp'],
+            loop_type: this.loop_type,
+            prompt_id: this.prompt_id,
+        };
+    }
+    toLogBody() {
+        return `Loop detected. Type: ${this.loop_type}.`;
+    }
 }
 export class LoopDetectionDisabledEvent {
     'event.name';
@@ -263,7 +462,19 @@ export class LoopDetectionDisabledEvent {
         this['event.timestamp'] = new Date().toISOString();
         this.prompt_id = prompt_id;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': this['event.name'],
+            'event.timestamp': this['event.timestamp'],
+            prompt_id: this.prompt_id,
+        };
+    }
+    toLogBody() {
+        return `Loop detection disabled.`;
+    }
 }
+export const EVENT_NEXT_SPEAKER_CHECK = 'gemini_cli.next_speaker_check';
 export class NextSpeakerCheckEvent {
     'event.name';
     'event.timestamp';
@@ -277,7 +488,21 @@ export class NextSpeakerCheckEvent {
         this.finish_reason = finish_reason;
         this.result = result;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_NEXT_SPEAKER_CHECK,
+            'event.timestamp': this['event.timestamp'],
+            prompt_id: this.prompt_id,
+            finish_reason: this.finish_reason,
+            result: this.result,
+        };
+    }
+    toLogBody() {
+        return `Next speaker check.`;
+    }
 }
+export const EVENT_SLASH_COMMAND = 'gemini_cli.slash_command';
 export function makeSlashCommandEvent({ command, subcommand, status, }) {
     return {
         'event.name': 'slash_command',
@@ -285,6 +510,19 @@ export function makeSlashCommandEvent({ command, subcommand, status, }) {
         command,
         subcommand,
         status,
+        toOpenTelemetryAttributes(config) {
+            return {
+                ...getCommonAttributes(config),
+                'event.name': EVENT_SLASH_COMMAND,
+                'event.timestamp': this['event.timestamp'],
+                command: this.command,
+                subcommand: this.subcommand,
+                status: this.status,
+            };
+        },
+        toLogBody() {
+            return `Slash command: ${this.command}.`;
+        },
     };
 }
 export var SlashCommandStatus;
@@ -292,14 +530,28 @@ export var SlashCommandStatus;
     SlashCommandStatus["SUCCESS"] = "success";
     SlashCommandStatus["ERROR"] = "error";
 })(SlashCommandStatus || (SlashCommandStatus = {}));
+export const EVENT_CHAT_COMPRESSION = 'gemini_cli.chat_compression';
 export function makeChatCompressionEvent({ tokens_before, tokens_after, }) {
     return {
         'event.name': 'chat_compression',
         'event.timestamp': new Date().toISOString(),
         tokens_before,
         tokens_after,
+        toOpenTelemetryAttributes(config) {
+            return {
+                ...getCommonAttributes(config),
+                'event.name': EVENT_CHAT_COMPRESSION,
+                'event.timestamp': this['event.timestamp'],
+                tokens_before: this.tokens_before,
+                tokens_after: this.tokens_after,
+            };
+        },
+        toLogBody() {
+            return `Chat compression (Saved ${this.tokens_before - this.tokens_after} tokens)`;
+        },
     };
 }
+export const EVENT_MALFORMED_JSON_RESPONSE = 'gemini_cli.malformed_json_response';
 export class MalformedJsonResponseEvent {
     'event.name';
     'event.timestamp';
@@ -309,12 +561,24 @@ export class MalformedJsonResponseEvent {
         this['event.timestamp'] = new Date().toISOString();
         this.model = model;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_MALFORMED_JSON_RESPONSE,
+            'event.timestamp': this['event.timestamp'],
+            model: this.model,
+        };
+    }
+    toLogBody() {
+        return `Malformed JSON response from ${this.model}.`;
+    }
 }
 export var IdeConnectionType;
 (function (IdeConnectionType) {
     IdeConnectionType["START"] = "start";
     IdeConnectionType["SESSION"] = "session";
 })(IdeConnectionType || (IdeConnectionType = {}));
+export const EVENT_IDE_CONNECTION = 'gemini_cli.ide_connection';
 export class IdeConnectionEvent {
     'event.name';
     'event.timestamp';
@@ -324,7 +588,19 @@ export class IdeConnectionEvent {
         this['event.timestamp'] = new Date().toISOString();
         this.connection_type = connection_type;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_IDE_CONNECTION,
+            'event.timestamp': this['event.timestamp'],
+            connection_type: this.connection_type,
+        };
+    }
+    toLogBody() {
+        return `Ide connection. Type: ${this.connection_type}.`;
+    }
 }
+export const EVENT_CONVERSATION_FINISHED = 'gemini_cli.conversation_finished';
 export class ConversationFinishedEvent {
     'event_name';
     'event.timestamp'; // ISO 8601;
@@ -336,6 +612,18 @@ export class ConversationFinishedEvent {
         this.approvalMode = approvalMode;
         this.turnCount = turnCount;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_CONVERSATION_FINISHED,
+            'event.timestamp': this['event.timestamp'],
+            approvalMode: this.approvalMode,
+            turnCount: this.turnCount,
+        };
+    }
+    toLogBody() {
+        return `Conversation finished.`;
+    }
 }
 export class KittySequenceOverflowEvent {
     'event.name';
@@ -349,7 +637,20 @@ export class KittySequenceOverflowEvent {
         // Truncate to first 20 chars for logging (avoid logging sensitive data)
         this.truncated_sequence = truncated_sequence.substring(0, 20);
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': this['event.name'],
+            'event.timestamp': this['event.timestamp'],
+            sequence_length: this.sequence_length,
+            truncated_sequence: this.truncated_sequence,
+        };
+    }
+    toLogBody() {
+        return `Kitty sequence buffer overflow: ${this.sequence_length} bytes`;
+    }
 }
+export const EVENT_FILE_OPERATION = 'gemini_cli.file_operation';
 export class FileOperationEvent {
     'event.name';
     'event.timestamp';
@@ -369,7 +670,33 @@ export class FileOperationEvent {
         this.extension = extension;
         this.programming_language = programming_language;
     }
+    toOpenTelemetryAttributes(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_FILE_OPERATION,
+            'event.timestamp': this['event.timestamp'],
+            tool_name: this.tool_name,
+            operation: this.operation,
+        };
+        if (this.lines) {
+            attributes['lines'] = this.lines;
+        }
+        if (this.mimetype) {
+            attributes['mimetype'] = this.mimetype;
+        }
+        if (this.extension) {
+            attributes['extension'] = this.extension;
+        }
+        if (this.programming_language) {
+            attributes['programming_language'] = this.programming_language;
+        }
+        return attributes;
+    }
+    toLogBody() {
+        return `File operation: ${this.operation}. Lines: ${this.lines}.`;
+    }
 }
+export const EVENT_INVALID_CHUNK = 'gemini_cli.chat.invalid_chunk';
 // Add these new event interfaces
 export class InvalidChunkEvent {
     'event.name';
@@ -380,35 +707,84 @@ export class InvalidChunkEvent {
         this['event.timestamp'] = new Date().toISOString();
         this.error_message = error_message;
     }
+    toOpenTelemetryAttributes(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_INVALID_CHUNK,
+            'event.timestamp': this['event.timestamp'],
+        };
+        if (this.error_message) {
+            attributes['error.message'] = this.error_message;
+        }
+        return attributes;
+    }
+    toLogBody() {
+        return `Invalid chunk received from stream.`;
+    }
 }
+export const EVENT_CONTENT_RETRY = 'gemini_cli.chat.content_retry';
 export class ContentRetryEvent {
     'event.name';
     'event.timestamp';
     attempt_number;
     error_type; // e.g., 'EmptyStreamError'
     retry_delay_ms;
-    constructor(attempt_number, error_type, retry_delay_ms) {
+    model;
+    constructor(attempt_number, error_type, retry_delay_ms, model) {
         this['event.name'] = 'content_retry';
         this['event.timestamp'] = new Date().toISOString();
         this.attempt_number = attempt_number;
         this.error_type = error_type;
         this.retry_delay_ms = retry_delay_ms;
+        this.model = model;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_CONTENT_RETRY,
+            'event.timestamp': this['event.timestamp'],
+            attempt_number: this.attempt_number,
+            error_type: this.error_type,
+            retry_delay_ms: this.retry_delay_ms,
+            model: this.model,
+        };
+    }
+    toLogBody() {
+        return `Content retry attempt ${this.attempt_number} due to ${this.error_type}.`;
     }
 }
+export const EVENT_CONTENT_RETRY_FAILURE = 'gemini_cli.chat.content_retry_failure';
 export class ContentRetryFailureEvent {
     'event.name';
     'event.timestamp';
     total_attempts;
     final_error_type;
     total_duration_ms; // Optional: total time spent retrying
-    constructor(total_attempts, final_error_type, total_duration_ms) {
+    model;
+    constructor(total_attempts, final_error_type, model, total_duration_ms) {
         this['event.name'] = 'content_retry_failure';
         this['event.timestamp'] = new Date().toISOString();
         this.total_attempts = total_attempts;
         this.final_error_type = final_error_type;
         this.total_duration_ms = total_duration_ms;
+        this.model = model;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_CONTENT_RETRY_FAILURE,
+            'event.timestamp': this['event.timestamp'],
+            total_attempts: this.total_attempts,
+            final_error_type: this.final_error_type,
+            total_duration_ms: this.total_duration_ms,
+            model: this.model,
+        };
+    }
+    toLogBody() {
+        return `All content retries failed after ${this.total_attempts} attempts.`;
     }
 }
+export const EVENT_MODEL_ROUTING = 'gemini_cli.model_routing';
 export class ModelRoutingEvent {
     'event.name';
     'event.timestamp';
@@ -428,7 +804,24 @@ export class ModelRoutingEvent {
         this.failed = failed;
         this.error_message = error_message;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_MODEL_ROUTING,
+            'event.timestamp': this['event.timestamp'],
+            decision_model: this.decision_model,
+            decision_source: this.decision_source,
+            routing_latency_ms: this.routing_latency_ms,
+            reasoning: this.reasoning,
+            failed: this.failed,
+            error_message: this.error_message,
+        };
+    }
+    toLogBody() {
+        return `Model routing decision. Model: ${this.decision_model}, Source: ${this.decision_source}`;
+    }
 }
+export const EVENT_EXTENSION_INSTALL = 'gemini_cli.extension_install';
 export class ExtensionInstallEvent {
     'event.name';
     'event.timestamp';
@@ -444,7 +837,22 @@ export class ExtensionInstallEvent {
         this.extension_source = extension_source;
         this.status = status;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_EXTENSION_INSTALL,
+            'event.timestamp': this['event.timestamp'],
+            extension_name: this.extension_name,
+            extension_version: this.extension_version,
+            extension_source: this.extension_source,
+            status: this.status,
+        };
+    }
+    toLogBody() {
+        return `Installed extension ${this.extension_name}`;
+    }
 }
+export const EVENT_TOOL_OUTPUT_TRUNCATED = 'gemini_cli.tool_output_truncated';
 export class ToolOutputTruncatedEvent {
     eventName = 'tool_output_truncated';
     'event.timestamp' = new Date().toISOString();
@@ -464,7 +872,25 @@ export class ToolOutputTruncatedEvent {
         this.threshold = details.threshold;
         this.lines = details.lines;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_TOOL_OUTPUT_TRUNCATED,
+            eventName: this.eventName,
+            'event.timestamp': this['event.timestamp'],
+            tool_name: this.tool_name,
+            original_content_length: this.original_content_length,
+            truncated_content_length: this.truncated_content_length,
+            threshold: this.threshold,
+            lines: this.lines,
+            prompt_id: this.prompt_id,
+        };
+    }
+    toLogBody() {
+        return `Tool output truncated for ${this.tool_name}.`;
+    }
 }
+export const EVENT_EXTENSION_UNINSTALL = 'gemini_cli.extension_uninstall';
 export class ExtensionUninstallEvent {
     'event.name';
     'event.timestamp';
@@ -476,7 +902,54 @@ export class ExtensionUninstallEvent {
         this.extension_name = extension_name;
         this.status = status;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_EXTENSION_UNINSTALL,
+            'event.timestamp': this['event.timestamp'],
+            extension_name: this.extension_name,
+            status: this.status,
+        };
+    }
+    toLogBody() {
+        return `Uninstalled extension ${this.extension_name}`;
+    }
 }
+export const EVENT_EXTENSION_UPDATE = 'gemini_cli.extension_update';
+export class ExtensionUpdateEvent {
+    'event.name';
+    'event.timestamp';
+    extension_name;
+    extension_previous_version;
+    extension_version;
+    extension_source;
+    status;
+    constructor(extension_name, extension_version, extension_previous_version, extension_source, status) {
+        this['event.name'] = 'extension_update';
+        this['event.timestamp'] = new Date().toISOString();
+        this.extension_name = extension_name;
+        this.extension_version = extension_version;
+        this.extension_previous_version = extension_previous_version;
+        this.extension_source = extension_source;
+        this.status = status;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_EXTENSION_UPDATE,
+            'event.timestamp': this['event.timestamp'],
+            extension_name: this.extension_name,
+            extension_version: this.extension_version,
+            extension_previous_version: this.extension_previous_version,
+            extension_source: this.extension_source,
+            status: this.status,
+        };
+    }
+    toLogBody() {
+        return `Updated extension ${this.extension_name}`;
+    }
+}
+export const EVENT_EXTENSION_ENABLE = 'gemini_cli.extension_enable';
 export class ExtensionEnableEvent {
     'event.name';
     'event.timestamp';
@@ -488,5 +961,189 @@ export class ExtensionEnableEvent {
         this.extension_name = extension_name;
         this.setting_scope = settingScope;
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_EXTENSION_ENABLE,
+            'event.timestamp': this['event.timestamp'],
+            extension_name: this.extension_name,
+            setting_scope: this.setting_scope,
+        };
+    }
+    toLogBody() {
+        return `Enabled extension ${this.extension_name}`;
+    }
+}
+export const EVENT_MODEL_SLASH_COMMAND = 'gemini_cli.slash_command.model';
+export class ModelSlashCommandEvent {
+    'event.name';
+    'event.timestamp';
+    model_name;
+    constructor(model_name) {
+        this['event.name'] = 'model_slash_command';
+        this['event.timestamp'] = new Date().toISOString();
+        this.model_name = model_name;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_MODEL_SLASH_COMMAND,
+            'event.timestamp': this['event.timestamp'],
+            model_name: this.model_name,
+        };
+    }
+    toLogBody() {
+        return `Model slash command. Model: ${this.model_name}`;
+    }
+}
+export const EVENT_EXTENSION_DISABLE = 'gemini_cli.extension_disable';
+export class ExtensionDisableEvent {
+    'event.name';
+    'event.timestamp';
+    extension_name;
+    setting_scope;
+    constructor(extension_name, settingScope) {
+        this['event.name'] = 'extension_disable';
+        this['event.timestamp'] = new Date().toISOString();
+        this.extension_name = extension_name;
+        this.setting_scope = settingScope;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_EXTENSION_DISABLE,
+            'event.timestamp': this['event.timestamp'],
+            extension_name: this.extension_name,
+            setting_scope: this.setting_scope,
+        };
+    }
+    toLogBody() {
+        return `Disabled extension ${this.extension_name}`;
+    }
+}
+export const EVENT_SMART_EDIT_STRATEGY = 'gemini_cli.smart_edit_strategy';
+export class SmartEditStrategyEvent {
+    'event.name';
+    'event.timestamp';
+    strategy;
+    constructor(strategy) {
+        this['event.name'] = 'smart_edit_strategy';
+        this['event.timestamp'] = new Date().toISOString();
+        this.strategy = strategy;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_SMART_EDIT_STRATEGY,
+            'event.timestamp': this['event.timestamp'],
+            strategy: this.strategy,
+        };
+    }
+    toLogBody() {
+        return `Smart Edit Tool Strategy: ${this.strategy}`;
+    }
+}
+export const EVENT_SMART_EDIT_CORRECTION = 'gemini_cli.smart_edit_correction';
+export class SmartEditCorrectionEvent {
+    'event.name';
+    'event.timestamp';
+    correction;
+    constructor(correction) {
+        this['event.name'] = 'smart_edit_correction';
+        this['event.timestamp'] = new Date().toISOString();
+        this.correction = correction;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_SMART_EDIT_CORRECTION,
+            'event.timestamp': this['event.timestamp'],
+            correction: this.correction,
+        };
+    }
+    toLogBody() {
+        return `Smart Edit Tool Correction: ${this.correction}`;
+    }
+}
+export const EVENT_AGENT_START = 'gemini_cli.agent.start';
+export class AgentStartEvent {
+    'event.name';
+    'event.timestamp';
+    agent_id;
+    agent_name;
+    constructor(agent_id, agent_name) {
+        this['event.name'] = 'agent_start';
+        this['event.timestamp'] = new Date().toISOString();
+        this.agent_id = agent_id;
+        this.agent_name = agent_name;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_AGENT_START,
+            'event.timestamp': this['event.timestamp'],
+            agent_id: this.agent_id,
+            agent_name: this.agent_name,
+        };
+    }
+    toLogBody() {
+        return `Agent ${this.agent_name} started. ID: ${this.agent_id}`;
+    }
+}
+export const EVENT_AGENT_FINISH = 'gemini_cli.agent.finish';
+export class AgentFinishEvent {
+    'event.name';
+    'event.timestamp';
+    agent_id;
+    agent_name;
+    duration_ms;
+    turn_count;
+    terminate_reason;
+    constructor(agent_id, agent_name, duration_ms, turn_count, terminate_reason) {
+        this['event.name'] = 'agent_finish';
+        this['event.timestamp'] = new Date().toISOString();
+        this.agent_id = agent_id;
+        this.agent_name = agent_name;
+        this.duration_ms = duration_ms;
+        this.turn_count = turn_count;
+        this.terminate_reason = terminate_reason;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_AGENT_FINISH,
+            'event.timestamp': this['event.timestamp'],
+            agent_id: this.agent_id,
+            agent_name: this.agent_name,
+            duration_ms: this.duration_ms,
+            turn_count: this.turn_count,
+            terminate_reason: this.terminate_reason,
+        };
+    }
+    toLogBody() {
+        return `Agent ${this.agent_name} finished. Reason: ${this.terminate_reason}. Duration: ${this.duration_ms}ms. Turns: ${this.turn_count}.`;
+    }
+}
+export const EVENT_WEB_FETCH_FALLBACK_ATTEMPT = 'gemini_cli.web_fetch_fallback_attempt';
+export class WebFetchFallbackAttemptEvent {
+    'event.name';
+    'event.timestamp';
+    reason;
+    constructor(reason) {
+        this['event.name'] = 'web_fetch_fallback_attempt';
+        this['event.timestamp'] = new Date().toISOString();
+        this.reason = reason;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_WEB_FETCH_FALLBACK_ATTEMPT,
+            'event.timestamp': this['event.timestamp'],
+            reason: this.reason,
+        };
+    }
+    toLogBody() {
+        return `Web fetch fallback attempt. Reason: ${this.reason}`;
+    }
 }
 //# sourceMappingURL=types.js.map