@office-ai/aioncli-core 0.8.1 → 0.18.5

package/dist/src/telemetry/types.js

@@ -6,7 +6,13 @@
 import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
 import { AuthType } from '../core/contentGenerator.js';
 import { getDecisionFromOutcome, ToolCallDecision, } from './tool-call-decision.js';
+import { getConventionAttributes } from './metrics.js';
 export { ToolCallDecision };
+import { getCommonAttributes } from './telemetryAttributes.js';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import { safeJsonStringify } from '../utils/safeJsonStringify.js';
+import { toInputMessages, toOutputMessages, toFinishReasons, toOutputType, toSystemInstruction, } from './semantic.js';
+export const EVENT_CLI_CONFIG = 'gemini_cli.config';
 export class StartSessionEvent {
     'event.name';
     'event.timestamp';
@@ -26,9 +32,13 @@ export class StartSessionEvent {
     mcp_tools_count;
     mcp_tools;
     output_format;
+    extensions_count;
+    extensions;
+    extension_ids;
+    auth_type;
     constructor(config, toolRegistry) {
         const generatorConfig = config.getContentGeneratorConfig();
-        const mcpServers = config.getMcpServers();
+        const mcpServers = config.getMcpClientManager()?.getMcpServers() ?? config.getMcpServers();
         let useGemini = false;
         let useVertex = false;
         if (generatorConfig && generatorConfig.authType) {
@@ -36,6 +46,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 =
@@ -53,6 +64,11 @@ export class StartSessionEvent {
             config.getFileFilteringRespectGitIgnore();
         this.mcp_servers_count = mcpServers ? Object.keys(mcpServers).length : 0;
         this.output_format = config.getOutputFormat();
+        const extensions = config.getExtensions();
+        this.extensions_count = extensions.length;
+        this.extensions = extensions.map((e) => e.name).join(',');
+        this.extension_ids = extensions.map((e) => e.id).join(',');
+        this.auth_type = generatorConfig?.authType;
         if (toolRegistry) {
             const mcpTools = toolRegistry
                 .getAllTools()
@@ -63,6 +79,35 @@ 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,
+            extensions: this.extensions,
+            extensions_count: this.extensions_count,
+            extension_ids: this.extension_ids,
+            auth_type: this.auth_type,
+        };
+    }
+    toLogBody() {
+        return 'CLI configuration loaded.';
+    }
 }
 export class EndSessionEvent {
     'event.name';
@@ -73,7 +118,19 @@ export class EndSessionEvent {
         this['event.timestamp'] = new Date().toISOString();
         this.session_id = config?.getSessionId();
     }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': this['event.name'],
+            'event.timestamp': this['event.timestamp'],
+            session_id: this.session_id,
+        };
+    }
+    toLogBody() {
+        return 'Session ended.';
+    }
 }
+export const EVENT_USER_PROMPT = 'gemini_cli.user_prompt';
 export class UserPromptEvent {
     'event.name';
     'event.timestamp';
@@ -89,7 +146,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';
@@ -104,50 +181,97 @@ export class ToolCallEvent {
     tool_type;
     content_length;
     mcp_server_name;
+    extension_name;
+    extension_id;
     // 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;
+                this.extension_name = call.tool.extensionName;
+                this.extension_id = call.tool.extensionId;
+            }
+            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,
+            extension_name: this.extension_name,
+            extension_id: this.extension_id,
+            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,18 +285,32 @@ 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';
     model;
+    prompt;
     error;
     error_type;
     status_code;
     duration_ms;
-    prompt_id;
     auth_type;
-    constructor(model, error, duration_ms, prompt_id, auth_type, error_type, status_code) {
+    constructor(model, error, duration_ms, prompt_details, auth_type, error_type, status_code) {
         this['event.name'] = 'api_error';
         this['event.timestamp'] = new Date().toISOString();
         this.model = model;
@@ -180,42 +318,169 @@ export class ApiErrorEvent {
         this.error_type = error_type;
         this.status_code = status_code;
         this.duration_ms = duration_ms;
-        this.prompt_id = prompt_id;
+        this.prompt = prompt_details;
         this.auth_type = auth_type;
     }
+    toLogRecord(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.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;
+        }
+        const logRecord = {
+            body: `API error for ${this.model}. Error: ${this.error}. Duration: ${this.duration_ms}ms.`,
+            attributes,
+        };
+        return logRecord;
+    }
+    toSemanticLogRecord(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_GEN_AI_OPERATION_DETAILS,
+            'event.timestamp': this['event.timestamp'],
+            ...toGenerateContentConfigAttributes(this.prompt.generate_content_config),
+            ...getConventionAttributes(this),
+        };
+        if (this.prompt.server) {
+            attributes['server.address'] = this.prompt.server.address;
+            attributes['server.port'] = this.prompt.server.port;
+        }
+        if (config.getTelemetryLogPromptsEnabled() && this.prompt.contents) {
+            attributes['gen_ai.input.messages'] = JSON.stringify(toInputMessages(this.prompt.contents));
+        }
+        const logRecord = {
+            body: `GenAI operation error details from ${this.model}. Error: ${this.error}. Duration: ${this.duration_ms}ms.`,
+            attributes,
+        };
+        return logRecord;
+    }
+}
+export const EVENT_API_RESPONSE = 'gemini_cli.api_response';
+export const EVENT_GEN_AI_OPERATION_DETAILS = 'gen_ai.client.inference.operation.details';
+function toGenerateContentConfigAttributes(config) {
+    if (!config) {
+        return {};
+    }
+    return {
+        'gen_ai.request.temperature': config.temperature,
+        'gen_ai.request.top_p': config.topP,
+        'gen_ai.request.top_k': config.topK,
+        'gen_ai.request.choice.count': config.candidateCount,
+        'gen_ai.request.seed': config.seed,
+        'gen_ai.request.frequency_penalty': config.frequencyPenalty,
+        'gen_ai.request.presence_penalty': config.presencePenalty,
+        'gen_ai.request.max_tokens': config.maxOutputTokens,
+        'gen_ai.output.type': toOutputType(config.responseMimeType),
+        'gen_ai.request.stop_sequences': config.stopSequences,
+        'gen_ai.system_instructions': JSON.stringify(toSystemInstruction(config.systemInstruction)),
+    };
 }
 export class ApiResponseEvent {
     'event.name';
     'event.timestamp';
-    model;
     status_code;
     duration_ms;
-    input_token_count;
-    output_token_count;
-    cached_content_token_count;
-    thoughts_token_count;
-    tool_token_count;
-    total_token_count;
     response_text;
-    prompt_id;
     auth_type;
-    constructor(model, duration_ms, prompt_id, auth_type, usage_data, response_text) {
+    model;
+    prompt;
+    response;
+    usage;
+    constructor(model, duration_ms, prompt_details, response_details, auth_type, usage_data, response_text) {
         this['event.name'] = 'api_response';
         this['event.timestamp'] = new Date().toISOString();
-        this.model = model;
         this.duration_ms = duration_ms;
         this.status_code = 200;
-        this.input_token_count = usage_data?.promptTokenCount ?? 0;
-        this.output_token_count = usage_data?.candidatesTokenCount ?? 0;
-        this.cached_content_token_count = usage_data?.cachedContentTokenCount ?? 0;
-        this.thoughts_token_count = usage_data?.thoughtsTokenCount ?? 0;
-        this.tool_token_count = usage_data?.toolUsePromptTokenCount ?? 0;
-        this.total_token_count = usage_data?.totalTokenCount ?? 0;
         this.response_text = response_text;
-        this.prompt_id = prompt_id;
         this.auth_type = auth_type;
+        this.model = model;
+        this.prompt = prompt_details;
+        this.response = response_details;
+        this.usage = {
+            input_token_count: usage_data?.promptTokenCount ?? 0,
+            output_token_count: usage_data?.candidatesTokenCount ?? 0,
+            cached_content_token_count: usage_data?.cachedContentTokenCount ?? 0,
+            thoughts_token_count: usage_data?.thoughtsTokenCount ?? 0,
+            tool_token_count: usage_data?.toolUsePromptTokenCount ?? 0,
+            total_token_count: usage_data?.totalTokenCount ?? 0,
+        };
+    }
+    toLogRecord(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.usage.input_token_count,
+            output_token_count: this.usage.output_token_count,
+            cached_content_token_count: this.usage.cached_content_token_count,
+            thoughts_token_count: this.usage.thoughts_token_count,
+            tool_token_count: this.usage.tool_token_count,
+            total_token_count: this.usage.total_token_count,
+            prompt_id: this.prompt.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;
+            }
+        }
+        const logRecord = {
+            body: `API response from ${this.model}. Status: ${this.status_code || 'N/A'}. Duration: ${this.duration_ms}ms.`,
+            attributes,
+        };
+        return logRecord;
+    }
+    toSemanticLogRecord(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_GEN_AI_OPERATION_DETAILS,
+            'event.timestamp': this['event.timestamp'],
+            'gen_ai.response.id': this.response.response_id,
+            'gen_ai.response.finish_reasons': toFinishReasons(this.response.candidates),
+            'gen_ai.output.messages': JSON.stringify(toOutputMessages(this.response.candidates)),
+            ...toGenerateContentConfigAttributes(this.prompt.generate_content_config),
+            ...getConventionAttributes(this),
+        };
+        if (this.prompt.server) {
+            attributes['server.address'] = this.prompt.server.address;
+            attributes['server.port'] = this.prompt.server.port;
+        }
+        if (config.getTelemetryLogPromptsEnabled() && this.prompt.contents) {
+            attributes['gen_ai.input.messages'] = JSON.stringify(toInputMessages(this.prompt.contents));
+        }
+        if (this.usage) {
+            attributes['gen_ai.usage.input_tokens'] = this.usage.input_token_count;
+            attributes['gen_ai.usage.output_tokens'] = this.usage.output_token_count;
+        }
+        const logRecord = {
+            body: `GenAI operation details from ${this.model}. Status: ${this.status_code || 'N/A'}. Duration: ${this.duration_ms}ms.`,
+            attributes,
+        };
+        return logRecord;
     }
 }
+export const EVENT_FLASH_FALLBACK = 'gemini_cli.flash_fallback';
 export class FlashFallbackEvent {
     'event.name';
     'event.timestamp';
@@ -225,7 +490,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 +512,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) {
@@ -247,11 +535,29 @@ export class LoopDetectedEvent {
     'event.timestamp';
     loop_type;
     prompt_id;
-    constructor(loop_type, prompt_id) {
+    confirmed_by_model;
+    constructor(loop_type, prompt_id, confirmed_by_model) {
         this['event.name'] = 'loop_detected';
         this['event.timestamp'] = new Date().toISOString();
         this.loop_type = loop_type;
         this.prompt_id = prompt_id;
+        this.confirmed_by_model = confirmed_by_model;
+    }
+    toOpenTelemetryAttributes(config) {
+        const attributes = {
+            ...getCommonAttributes(config),
+            'event.name': this['event.name'],
+            'event.timestamp': this['event.timestamp'],
+            loop_type: this.loop_type,
+            prompt_id: this.prompt_id,
+        };
+        if (this.confirmed_by_model) {
+            attributes['confirmed_by_model'] = this.confirmed_by_model;
+        }
+        return attributes;
+    }
+    toLogBody() {
+        return `Loop detected. Type: ${this.loop_type}.${this.confirmed_by_model ? ` Confirmed by: ${this.confirmed_by_model}` : ''}`;
     }
 }
 export class LoopDetectionDisabledEvent {
@@ -263,7 +569,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,14 +595,43 @@ 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 function makeSlashCommandEvent({ command, subcommand, status, }) {
+export const EVENT_SLASH_COMMAND = 'gemini_cli.slash_command';
+export function makeSlashCommandEvent({ command, subcommand, status, extension_id, }) {
     return {
         'event.name': 'slash_command',
         'event.timestamp': new Date().toISOString(),
         command,
         subcommand,
         status,
+        extension_id,
+        toOpenTelemetryAttributes(config) {
+            return {
+                ...getCommonAttributes(config),
+                'event.name': EVENT_SLASH_COMMAND,
+                'event.timestamp': this['event.timestamp'],
+                command: this.command,
+                subcommand: this.subcommand,
+                status: this.status,
+                extension_id: this.extension_id,
+            };
+        },
+        toLogBody() {
+            return `Slash command: ${this.command}.`;
+        },
     };
 }
 export var SlashCommandStatus;
@@ -292,14 +639,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 +670,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 +697,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,20 +721,20 @@ export class ConversationFinishedEvent {
         this.approvalMode = approvalMode;
         this.turnCount = turnCount;
     }
-}
-export class KittySequenceOverflowEvent {
-    'event.name';
-    'event.timestamp'; // ISO 8601
-    sequence_length;
-    truncated_sequence;
-    constructor(sequence_length, truncated_sequence) {
-        this['event.name'] = 'kitty_sequence_overflow';
-        this['event.timestamp'] = new Date().toISOString();
-        this.sequence_length = sequence_length;
-        // 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': EVENT_CONVERSATION_FINISHED,
+            'event.timestamp': this['event.timestamp'],
+            approvalMode: this.approvalMode,
+            turnCount: this.turnCount,
+        };
+    }
+    toLogBody() {
+        return `Conversation finished.`;
     }
 }
+export const EVENT_FILE_OPERATION = 'gemini_cli.file_operation';
 export class FileOperationEvent {
     'event.name';
     'event.timestamp';
@@ -369,7 +754,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,7 +791,22 @@ 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';
@@ -396,7 +822,22 @@ export class ContentRetryEvent {
         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';
@@ -412,7 +853,22 @@ export class ContentRetryFailureEvent {
         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';
@@ -432,23 +888,57 @@ 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';
     extension_name;
+    extension_id;
     extension_version;
     extension_source;
     status;
-    constructor(extension_name, extension_version, extension_source, status) {
+    constructor(extension_name, extension_id, extension_version, extension_source, status) {
         this['event.name'] = 'extension_install';
         this['event.timestamp'] = new Date().toISOString();
         this.extension_name = extension_name;
+        this.extension_id = extension_id;
         this.extension_version = extension_version;
         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();
@@ -468,31 +958,115 @@ 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';
     extension_name;
+    extension_id;
     status;
-    constructor(extension_name, status) {
+    constructor(extension_name, extension_id, status) {
         this['event.name'] = 'extension_uninstall';
         this['event.timestamp'] = new Date().toISOString();
         this.extension_name = extension_name;
+        this.extension_id = extension_id;
+        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_id;
+    extension_previous_version;
+    extension_version;
+    extension_source;
+    status;
+    constructor(extension_name, extension_id, 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_id = extension_id;
+        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';
     extension_name;
+    extension_id;
     setting_scope;
-    constructor(extension_name, settingScope) {
+    constructor(extension_name, extension_id, settingScope) {
         this['event.name'] = 'extension_enable';
         this['event.timestamp'] = new Date().toISOString();
         this.extension_name = extension_name;
+        this.extension_id = extension_id;
         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';
@@ -502,17 +1076,229 @@ export class ModelSlashCommandEvent {
         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_LLM_LOOP_CHECK = 'gemini_cli.llm_loop_check';
+export class LlmLoopCheckEvent {
+    'event.name';
+    'event.timestamp';
+    prompt_id;
+    flash_confidence;
+    main_model;
+    main_model_confidence;
+    constructor(prompt_id, flash_confidence, main_model, main_model_confidence) {
+        this['event.name'] = 'llm_loop_check';
+        this['event.timestamp'] = new Date().toISOString();
+        this.prompt_id = prompt_id;
+        this.flash_confidence = flash_confidence;
+        this.main_model = main_model;
+        this.main_model_confidence = main_model_confidence;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.name': EVENT_LLM_LOOP_CHECK,
+            'event.timestamp': this['event.timestamp'],
+            prompt_id: this.prompt_id,
+            flash_confidence: this.flash_confidence,
+            main_model: this.main_model,
+            main_model_confidence: this.main_model_confidence,
+        };
+    }
+    toLogBody() {
+        return this.main_model_confidence === -1
+            ? `LLM loop check. Flash confidence: ${this.flash_confidence.toFixed(2)}. Main model (${this.main_model}) check skipped`
+            : `LLM loop check. Flash confidence: ${this.flash_confidence.toFixed(2)}. Main model (${this.main_model}) confidence: ${this.main_model_confidence.toFixed(2)}`;
+    }
 }
+export const EVENT_EXTENSION_DISABLE = 'gemini_cli.extension_disable';
 export class ExtensionDisableEvent {
     'event.name';
     'event.timestamp';
     extension_name;
+    extension_id;
     setting_scope;
-    constructor(extension_name, settingScope) {
+    constructor(extension_name, extension_id, settingScope) {
         this['event.name'] = 'extension_disable';
         this['event.timestamp'] = new Date().toISOString();
         this.extension_name = extension_name;
+        this.extension_id = extension_id;
         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}`;
+    }
+}
+class BaseAgentEvent {
+    'event.timestamp';
+    agent_id;
+    agent_name;
+    constructor(agent_id, agent_name) {
+        this['event.timestamp'] = new Date().toISOString();
+        this.agent_id = agent_id;
+        this.agent_name = agent_name;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...getCommonAttributes(config),
+            'event.timestamp': this['event.timestamp'],
+            agent_id: this.agent_id,
+            agent_name: this.agent_name,
+        };
+    }
+}
+export const EVENT_AGENT_START = 'gemini_cli.agent.start';
+export class AgentStartEvent extends BaseAgentEvent {
+    'event.name' = 'agent_start';
+    constructor(agent_id, agent_name) {
+        super(agent_id, agent_name);
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...super.toOpenTelemetryAttributes(config),
+            'event.name': EVENT_AGENT_START,
+        };
+    }
+    toLogBody() {
+        return `Agent ${this.agent_name} started. ID: ${this.agent_id}`;
+    }
+}
+export const EVENT_AGENT_FINISH = 'gemini_cli.agent.finish';
+export class AgentFinishEvent extends BaseAgentEvent {
+    'event.name' = 'agent_finish';
+    duration_ms;
+    turn_count;
+    terminate_reason;
+    constructor(agent_id, agent_name, duration_ms, turn_count, terminate_reason) {
+        super(agent_id, agent_name);
+        this.duration_ms = duration_ms;
+        this.turn_count = turn_count;
+        this.terminate_reason = terminate_reason;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...super.toOpenTelemetryAttributes(config),
+            'event.name': EVENT_AGENT_FINISH,
+            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_AGENT_RECOVERY_ATTEMPT = 'gemini_cli.agent.recovery_attempt';
+export class RecoveryAttemptEvent extends BaseAgentEvent {
+    'event.name' = 'agent_recovery_attempt';
+    reason;
+    duration_ms;
+    success;
+    turn_count;
+    constructor(agent_id, agent_name, reason, duration_ms, success, turn_count) {
+        super(agent_id, agent_name);
+        this.reason = reason;
+        this.duration_ms = duration_ms;
+        this.success = success;
+        this.turn_count = turn_count;
+    }
+    toOpenTelemetryAttributes(config) {
+        return {
+            ...super.toOpenTelemetryAttributes(config),
+            'event.name': EVENT_AGENT_RECOVERY_ATTEMPT,
+            reason: this.reason,
+            duration_ms: this.duration_ms,
+            success: this.success,
+            turn_count: this.turn_count,
+        };
+    }
+    toLogBody() {
+        return `Agent ${this.agent_name} recovery attempt. Reason: ${this.reason}. Success: ${this.success}. Duration: ${this.duration_ms}ms.`;
+    }
+}
+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