@office-ai/aioncli-core 0.8.1 → 0.18.5

package/dist/src/telemetry/metrics.d.ts

@@ -5,13 +5,15 @@
  */
 import type { Attributes, Meter, Counter, Histogram } from '@opentelemetry/api';
 import { ValueType } from '@opentelemetry/api';
-import { EVENT_CHAT_COMPRESSION } from './constants.js';
 import type { Config } from '../config/config.js';
-import type { ModelRoutingEvent, ModelSlashCommandEvent } from './types.js';
+import type { ModelRoutingEvent, ModelSlashCommandEvent, AgentFinishEvent, RecoveryAttemptEvent } from './types.js';
+declare const EVENT_CHAT_COMPRESSION = "gemini_cli.chat_compression";
 declare const TOOL_CALL_COUNT = "gemini_cli.tool.call.count";
 declare const API_REQUEST_COUNT = "gemini_cli.api.request.count";
 declare const TOKEN_USAGE = "gemini_cli.token.usage";
 declare const FILE_OPERATION_COUNT = "gemini_cli.file.operation.count";
+declare const GEN_AI_CLIENT_TOKEN_USAGE = "gen_ai.client.token.usage";
+declare const GEN_AI_CLIENT_OPERATION_DURATION = "gen_ai.client.operation.duration";
 declare const STARTUP_TIME = "gemini_cli.startup.duration";
 declare const MEMORY_USAGE = "gemini_cli.memory.usage";
 declare const CPU_USAGE = "gemini_cli.cpu.usage";
@@ -70,6 +72,15 @@ declare const COUNTER_DEFINITIONS: {
             programming_language?: string;
         };
     };
+    readonly "gemini_cli.lines.changed": {
+        readonly description: "Number of lines changed (from file diffs).";
+        readonly valueType: ValueType.INT;
+        readonly assign: (c: Counter) => Counter<Attributes>;
+        readonly attributes: {
+            function_name?: string;
+            type: "added" | "removed";
+        };
+    };
     readonly "gemini_cli.chat.invalid_chunk.count": {
         readonly description: "Counts invalid chunks received from a stream.";
         readonly valueType: ValueType.INT;
@@ -114,6 +125,37 @@ declare const COUNTER_DEFINITIONS: {
             tokens_after: number;
         };
     };
+    readonly "gemini_cli.agent.run.count": {
+        readonly description: "Counts agent runs, tagged by name and termination reason.";
+        readonly valueType: ValueType.INT;
+        readonly assign: (c: Counter) => Counter<Attributes>;
+        readonly attributes: {
+            agent_name: string;
+            terminate_reason: string;
+        };
+    };
+    readonly "gemini_cli.agent.recovery_attempt.count": {
+        readonly description: "Counts agent recovery attempts.";
+        readonly valueType: ValueType.INT;
+        readonly assign: (c: Counter) => Counter<Attributes>;
+        readonly attributes: {
+            agent_name: string;
+            reason: string;
+            success: boolean;
+        };
+    };
+    readonly "gemini_cli.ui.flicker.count": {
+        readonly description: "Counts UI frames that flicker (render taller than the terminal).";
+        readonly valueType: ValueType.INT;
+        readonly assign: (c: Counter) => Counter<Attributes>;
+        readonly attributes: Record<string, never>;
+    };
+    readonly "gemini_cli.exit.fail.count": {
+        readonly description: "Counts CLI exit failures.";
+        readonly valueType: ValueType.INT;
+        readonly assign: (c: Counter) => Counter<Attributes>;
+        readonly attributes: Record<string, never>;
+    };
 };
 declare const HISTOGRAM_DEFINITIONS: {
     readonly "gemini_cli.tool.call.latency": {
@@ -144,6 +186,70 @@ declare const HISTOGRAM_DEFINITIONS: {
             "routing.decision_source": string;
         };
     };
+    readonly "gemini_cli.agent.duration": {
+        readonly description: "Duration of agent runs in milliseconds.";
+        readonly unit: "ms";
+        readonly valueType: ValueType.INT;
+        readonly assign: (h: Histogram) => Histogram<Attributes>;
+        readonly attributes: {
+            agent_name: string;
+        };
+    };
+    readonly "gemini_cli.ui.slow_render.latency": {
+        readonly description: "Counts UI frames that take too long to render.";
+        readonly unit: "ms";
+        readonly valueType: ValueType.INT;
+        readonly assign: (h: Histogram) => Histogram<Attributes>;
+        readonly attributes: Record<string, never>;
+    };
+    readonly "gemini_cli.agent.turns": {
+        readonly description: "Number of turns taken by agents.";
+        readonly unit: "turns";
+        readonly valueType: ValueType.INT;
+        readonly assign: (h: Histogram) => Histogram<Attributes>;
+        readonly attributes: {
+            agent_name: string;
+        };
+    };
+    readonly "gemini_cli.agent.recovery_attempt.duration": {
+        readonly description: "Duration of agent recovery attempts in milliseconds.";
+        readonly unit: "ms";
+        readonly valueType: ValueType.INT;
+        readonly assign: (h: Histogram) => Histogram<Attributes>;
+        readonly attributes: {
+            agent_name: string;
+        };
+    };
+    readonly "gen_ai.client.token.usage": {
+        readonly description: "Number of input and output tokens used.";
+        readonly unit: "token";
+        readonly valueType: ValueType.INT;
+        readonly assign: (h: Histogram) => Histogram<Attributes>;
+        readonly attributes: {
+            "gen_ai.operation.name": string;
+            "gen_ai.provider.name": string;
+            "gen_ai.token.type": "input" | "output";
+            "gen_ai.request.model"?: string;
+            "gen_ai.response.model"?: string;
+            "server.address"?: string;
+            "server.port"?: number;
+        };
+    };
+    readonly "gen_ai.client.operation.duration": {
+        readonly description: "GenAI operation duration.";
+        readonly unit: "s";
+        readonly valueType: ValueType.DOUBLE;
+        readonly assign: (h: Histogram) => Histogram<Attributes>;
+        readonly attributes: {
+            "gen_ai.operation.name": string;
+            "gen_ai.provider.name": string;
+            "gen_ai.request.model"?: string;
+            "gen_ai.response.model"?: string;
+            "server.address"?: string;
+            "server.port"?: number;
+            "error.type"?: string;
+        };
+    };
 };
 declare const PERFORMANCE_COUNTER_DEFINITIONS: {
     readonly "gemini_cli.performance.regression": {
@@ -298,14 +404,40 @@ export declare enum ApiRequestPhase {
     RESPONSE_PROCESSING = "response_processing",
     TOKEN_PROCESSING = "token_processing"
 }
+export declare enum GenAiOperationName {
+    GENERATE_CONTENT = "generate_content"
+}
+export declare enum GenAiProviderName {
+    GCP_GEN_AI = "gcp.gen_ai",
+    GCP_VERTEX_AI = "gcp.vertex_ai"
+}
+export declare enum GenAiTokenType {
+    INPUT = "input",
+    OUTPUT = "output"
+}
 export declare function getMeter(): Meter | undefined;
 export declare function initializeMetrics(config: Config): void;
 export declare function recordChatCompressionMetrics(config: Config, attributes: MetricDefinitions[typeof EVENT_CHAT_COMPRESSION]['attributes']): void;
 export declare function recordToolCallMetrics(config: Config, durationMs: number, attributes: MetricDefinitions[typeof TOOL_CALL_COUNT]['attributes']): void;
-export declare function recordTokenUsageMetrics(config: Config, tokenCount: number, attributes: MetricDefinitions[typeof TOKEN_USAGE]['attributes']): void;
-export declare function recordApiResponseMetrics(config: Config, durationMs: number, attributes: MetricDefinitions[typeof API_REQUEST_COUNT]['attributes']): void;
+export declare function recordCustomTokenUsageMetrics(config: Config, tokenCount: number, attributes: MetricDefinitions[typeof TOKEN_USAGE]['attributes']): void;
+export declare function recordCustomApiResponseMetrics(config: Config, durationMs: number, attributes: MetricDefinitions[typeof API_REQUEST_COUNT]['attributes']): void;
 export declare function recordApiErrorMetrics(config: Config, durationMs: number, attributes: MetricDefinitions[typeof API_REQUEST_COUNT]['attributes']): void;
 export declare function recordFileOperationMetric(config: Config, attributes: MetricDefinitions[typeof FILE_OPERATION_COUNT]['attributes']): void;
+export declare function recordLinesChanged(config: Config, lines: number, changeType: 'added' | 'removed', attributes?: {
+    function_name?: string;
+}): void;
+/**
+ * Records a metric for when a UI frame flickers.
+ */
+export declare function recordFlickerFrame(config: Config): void;
+/**
+ * Records a metric for when user failed to exit
+ */
+export declare function recordExitFail(config: Config): void;
+/**
+ * Records a metric for when a UI frame is slow in rendering
+ */
+export declare function recordSlowRender(config: Config, renderLatency: number): void;
 /**
  * Records a metric for when an invalid chunk is received from a stream.
  */
@@ -320,6 +452,19 @@ export declare function recordContentRetry(config: Config): void;
 export declare function recordContentRetryFailure(config: Config): void;
 export declare function recordModelSlashCommand(config: Config, event: ModelSlashCommandEvent): void;
 export declare function recordModelRoutingMetrics(config: Config, event: ModelRoutingEvent): void;
+export declare function recordAgentRunMetrics(config: Config, event: AgentFinishEvent): void;
+export declare function recordRecoveryAttemptMetrics(config: Config, event: RecoveryAttemptEvent): void;
+export declare function recordGenAiClientTokenUsage(config: Config, tokenCount: number, attributes: MetricDefinitions[typeof GEN_AI_CLIENT_TOKEN_USAGE]['attributes']): void;
+export declare function recordGenAiClientOperationDuration(config: Config, durationSeconds: number, attributes: MetricDefinitions[typeof GEN_AI_CLIENT_OPERATION_DURATION]['attributes']): void;
+export declare function getConventionAttributes(event: {
+    model: string;
+    auth_type?: string;
+}): {
+    'gen_ai.operation.name': GenAiOperationName;
+    'gen_ai.provider.name': GenAiProviderName;
+    'gen_ai.request.model': string;
+    'gen_ai.response.model': string;
+};
 export declare function initializePerformanceMonitoring(config: Config): void;
 export declare function recordStartupPerformance(config: Config, durationMs: number, attributes: MetricDefinitions[typeof STARTUP_TIME]['attributes']): void;
 export declare function recordMemoryUsage(config: Config, bytes: number, attributes: MetricDefinitions[typeof MEMORY_USAGE]['attributes']): void;
@@ -332,4 +477,35 @@ export declare function recordPerformanceScore(config: Config, score: number, at
 export declare function recordPerformanceRegression(config: Config, attributes: MetricDefinitions[typeof REGRESSION_DETECTION]['attributes']): void;
 export declare function recordBaselineComparison(config: Config, attributes: MetricDefinitions[typeof BASELINE_COMPARISON]['attributes']): void;
 export declare function isPerformanceMonitoringActive(): boolean;
+/**
+ * Token usage recording that emits both custom and convention metrics.
+ */
+export declare function recordTokenUsageMetrics(config: Config, tokenCount: number, attributes: {
+    model: string;
+    type: 'input' | 'output' | 'thought' | 'cache' | 'tool';
+    genAiAttributes?: {
+        'gen_ai.operation.name': string;
+        'gen_ai.provider.name': string;
+        'gen_ai.request.model'?: string;
+        'gen_ai.response.model'?: string;
+        'server.address'?: string;
+        'server.port'?: number;
+    };
+}): void;
+/**
+ * Operation latency recording that emits both custom and convention metrics.
+ */
+export declare function recordApiResponseMetrics(config: Config, durationMs: number, attributes: {
+    model: string;
+    status_code?: number | string;
+    genAiAttributes?: {
+        'gen_ai.operation.name': string;
+        'gen_ai.provider.name': string;
+        'gen_ai.request.model'?: string;
+        'gen_ai.response.model'?: string;
+        'server.address'?: string;
+        'server.port'?: number;
+        'error.type'?: string;
+    };
+}): void;
 export {};

package/dist/src/telemetry/metrics.js

@@ -4,7 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { diag, metrics, ValueType } from '@opentelemetry/api';
-import { SERVICE_NAME, EVENT_CHAT_COMPRESSION } from './constants.js';
+import { SERVICE_NAME } from './constants.js';
+import { AuthType } from '../core/contentGenerator.js';
+import { getCommonAttributes } from './telemetryAttributes.js';
+const EVENT_CHAT_COMPRESSION = 'gemini_cli.chat_compression';
 const TOOL_CALL_COUNT = 'gemini_cli.tool.call.count';
 const TOOL_CALL_LATENCY = 'gemini_cli.tool.call.latency';
 const API_REQUEST_COUNT = 'gemini_cli.api.request.count';
@@ -12,12 +15,22 @@ const API_REQUEST_LATENCY = 'gemini_cli.api.request.latency';
 const TOKEN_USAGE = 'gemini_cli.token.usage';
 const SESSION_COUNT = 'gemini_cli.session.count';
 const FILE_OPERATION_COUNT = 'gemini_cli.file.operation.count';
+const LINES_CHANGED = 'gemini_cli.lines.changed';
 const INVALID_CHUNK_COUNT = 'gemini_cli.chat.invalid_chunk.count';
 const CONTENT_RETRY_COUNT = 'gemini_cli.chat.content_retry.count';
 const CONTENT_RETRY_FAILURE_COUNT = 'gemini_cli.chat.content_retry_failure.count';
 const MODEL_ROUTING_LATENCY = 'gemini_cli.model_routing.latency';
 const MODEL_ROUTING_FAILURE_COUNT = 'gemini_cli.model_routing.failure.count';
 const MODEL_SLASH_COMMAND_CALL_COUNT = 'gemini_cli.slash_command.model.call_count';
+// Agent Metrics
+const AGENT_RUN_COUNT = 'gemini_cli.agent.run.count';
+const AGENT_DURATION_MS = 'gemini_cli.agent.duration';
+const AGENT_TURNS = 'gemini_cli.agent.turns';
+const AGENT_RECOVERY_ATTEMPT_COUNT = 'gemini_cli.agent.recovery_attempt.count';
+const AGENT_RECOVERY_ATTEMPT_DURATION = 'gemini_cli.agent.recovery_attempt.duration';
+// OpenTelemetry GenAI Semantic Convention Metrics
+const GEN_AI_CLIENT_TOKEN_USAGE = 'gen_ai.client.token.usage';
+const GEN_AI_CLIENT_OPERATION_DURATION = 'gen_ai.client.operation.duration';
 // Performance Monitoring Metrics
 const STARTUP_TIME = 'gemini_cli.startup.duration';
 const MEMORY_USAGE = 'gemini_cli.memory.usage';
@@ -30,10 +43,11 @@ const PERFORMANCE_SCORE = 'gemini_cli.performance.score';
 const REGRESSION_DETECTION = 'gemini_cli.performance.regression';
 const REGRESSION_PERCENTAGE_CHANGE = 'gemini_cli.performance.regression.percentage_change';
 const BASELINE_COMPARISON = 'gemini_cli.performance.baseline.comparison';
+const FLICKER_FRAME_COUNT = 'gemini_cli.ui.flicker.count';
+const SLOW_RENDER_LATENCY = 'gemini_cli.ui.slow_render.latency';
+const EXIT_FAIL_COUNT = 'gemini_cli.exit.fail.count';
 const baseMetricDefinition = {
-    getCommonAttributes: (config) => ({
-        'session.id': config.getSessionId(),
-    }),
+    getCommonAttributes,
 };
 const COUNTER_DEFINITIONS = {
     [TOOL_CALL_COUNT]: {
@@ -66,6 +80,12 @@ const COUNTER_DEFINITIONS = {
         assign: (c) => (fileOperationCounter = c),
         attributes: {},
     },
+    [LINES_CHANGED]: {
+        description: 'Number of lines changed (from file diffs).',
+        valueType: ValueType.INT,
+        assign: (c) => (linesChangedCounter = c),
+        attributes: {},
+    },
     [INVALID_CHUNK_COUNT]: {
         description: 'Counts invalid chunks received from a stream.',
         valueType: ValueType.INT,
@@ -102,6 +122,30 @@ const COUNTER_DEFINITIONS = {
         assign: (c) => (chatCompressionCounter = c),
         attributes: {},
     },
+    [AGENT_RUN_COUNT]: {
+        description: 'Counts agent runs, tagged by name and termination reason.',
+        valueType: ValueType.INT,
+        assign: (c) => (agentRunCounter = c),
+        attributes: {},
+    },
+    [AGENT_RECOVERY_ATTEMPT_COUNT]: {
+        description: 'Counts agent recovery attempts.',
+        valueType: ValueType.INT,
+        assign: (c) => (agentRecoveryAttemptCounter = c),
+        attributes: {},
+    },
+    [FLICKER_FRAME_COUNT]: {
+        description: 'Counts UI frames that flicker (render taller than the terminal).',
+        valueType: ValueType.INT,
+        assign: (c) => (flickerFrameCounter = c),
+        attributes: {},
+    },
+    [EXIT_FAIL_COUNT]: {
+        description: 'Counts CLI exit failures.',
+        valueType: ValueType.INT,
+        assign: (c) => (exitFailCounter = c),
+        attributes: {},
+    },
 };
 const HISTOGRAM_DEFINITIONS = {
     [TOOL_CALL_LATENCY]: {
@@ -125,6 +169,48 @@ const HISTOGRAM_DEFINITIONS = {
         assign: (h) => (modelRoutingLatencyHistogram = h),
         attributes: {},
     },
+    [AGENT_DURATION_MS]: {
+        description: 'Duration of agent runs in milliseconds.',
+        unit: 'ms',
+        valueType: ValueType.INT,
+        assign: (h) => (agentDurationHistogram = h),
+        attributes: {},
+    },
+    [SLOW_RENDER_LATENCY]: {
+        description: 'Counts UI frames that take too long to render.',
+        unit: 'ms',
+        valueType: ValueType.INT,
+        assign: (h) => (slowRenderHistogram = h),
+        attributes: {},
+    },
+    [AGENT_TURNS]: {
+        description: 'Number of turns taken by agents.',
+        unit: 'turns',
+        valueType: ValueType.INT,
+        assign: (h) => (agentTurnsHistogram = h),
+        attributes: {},
+    },
+    [AGENT_RECOVERY_ATTEMPT_DURATION]: {
+        description: 'Duration of agent recovery attempts in milliseconds.',
+        unit: 'ms',
+        valueType: ValueType.INT,
+        assign: (h) => (agentRecoveryAttemptDurationHistogram = h),
+        attributes: {},
+    },
+    [GEN_AI_CLIENT_TOKEN_USAGE]: {
+        description: 'Number of input and output tokens used.',
+        unit: 'token',
+        valueType: ValueType.INT,
+        assign: (h) => (genAiClientTokenUsageHistogram = h),
+        attributes: {},
+    },
+    [GEN_AI_CLIENT_OPERATION_DURATION]: {
+        description: 'GenAI operation duration.',
+        unit: 's',
+        valueType: ValueType.DOUBLE,
+        assign: (h) => (genAiClientOperationDurationHistogram = h),
+        attributes: {},
+    },
 };
 const PERFORMANCE_COUNTER_DEFINITIONS = {
     [REGRESSION_DETECTION]: {
@@ -242,6 +328,20 @@ export var ApiRequestPhase;
     ApiRequestPhase["RESPONSE_PROCESSING"] = "response_processing";
     ApiRequestPhase["TOKEN_PROCESSING"] = "token_processing";
 })(ApiRequestPhase || (ApiRequestPhase = {}));
+export var GenAiOperationName;
+(function (GenAiOperationName) {
+    GenAiOperationName["GENERATE_CONTENT"] = "generate_content";
+})(GenAiOperationName || (GenAiOperationName = {}));
+export var GenAiProviderName;
+(function (GenAiProviderName) {
+    GenAiProviderName["GCP_GEN_AI"] = "gcp.gen_ai";
+    GenAiProviderName["GCP_VERTEX_AI"] = "gcp.vertex_ai";
+})(GenAiProviderName || (GenAiProviderName = {}));
+export var GenAiTokenType;
+(function (GenAiTokenType) {
+    GenAiTokenType["INPUT"] = "input";
+    GenAiTokenType["OUTPUT"] = "output";
+})(GenAiTokenType || (GenAiTokenType = {}));
 let cliMeter;
 let toolCallCounter;
 let toolCallLatencyHistogram;
@@ -250,6 +350,7 @@ let apiRequestLatencyHistogram;
 let tokenUsageCounter;
 let sessionCounter;
 let fileOperationCounter;
+let linesChangedCounter;
 let chatCompressionCounter;
 let invalidChunkCounter;
 let contentRetryCounter;
@@ -257,6 +358,17 @@ let contentRetryFailureCounter;
 let modelRoutingLatencyHistogram;
 let modelRoutingFailureCounter;
 let modelSlashCommandCallCounter;
+let agentRunCounter;
+let agentDurationHistogram;
+let agentTurnsHistogram;
+let agentRecoveryAttemptCounter;
+let agentRecoveryAttemptDurationHistogram;
+let flickerFrameCounter;
+let exitFailCounter;
+let slowRenderHistogram;
+// OpenTelemetry GenAI Semantic Convention Metrics
+let genAiClientTokenUsageHistogram;
+let genAiClientOperationDurationHistogram;
 // Performance Monitoring Metrics
 let startupTimeHistogram;
 let memoryUsageGauge; // Using Histogram until ObservableGauge is available
@@ -317,7 +429,7 @@ export function recordToolCallMetrics(config, durationMs, attributes) {
         function_name: attributes.function_name,
     });
 }
-export function recordTokenUsageMetrics(config, tokenCount, attributes) {
+export function recordCustomTokenUsageMetrics(config, tokenCount, attributes) {
     if (!tokenUsageCounter || !isMetricsInitialized)
         return;
     tokenUsageCounter.add(tokenCount, {
@@ -325,7 +437,7 @@ export function recordTokenUsageMetrics(config, tokenCount, attributes) {
         ...attributes,
     });
 }
-export function recordApiResponseMetrics(config, durationMs, attributes) {
+export function recordCustomApiResponseMetrics(config, durationMs, attributes) {
     if (!apiRequestCounter ||
         !apiRequestLatencyHistogram ||
         !isMetricsInitialized)
@@ -366,7 +478,44 @@ export function recordFileOperationMetric(config, attributes) {
         ...attributes,
     });
 }
+export function recordLinesChanged(config, lines, changeType, attributes) {
+    if (!linesChangedCounter || !isMetricsInitialized)
+        return;
+    if (!Number.isFinite(lines) || lines <= 0)
+        return;
+    linesChangedCounter.add(lines, {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        type: changeType,
+        ...(attributes ?? {}),
+    });
+}
 // --- New Metric Recording Functions ---
+/**
+ * Records a metric for when a UI frame flickers.
+ */
+export function recordFlickerFrame(config) {
+    if (!flickerFrameCounter || !isMetricsInitialized)
+        return;
+    flickerFrameCounter.add(1, baseMetricDefinition.getCommonAttributes(config));
+}
+/**
+ * Records a metric for when user failed to exit
+ */
+export function recordExitFail(config) {
+    if (!exitFailCounter || !isMetricsInitialized)
+        return;
+    exitFailCounter.add(1, baseMetricDefinition.getCommonAttributes(config));
+}
+/**
+ * Records a metric for when a UI frame is slow in rendering
+ */
+export function recordSlowRender(config, renderLatency) {
+    if (!slowRenderHistogram || !isMetricsInitialized)
+        return;
+    slowRenderHistogram.record(renderLatency, {
+        ...baseMetricDefinition.getCommonAttributes(config),
+    });
+}
 /**
  * Records a metric for when an invalid chunk is received from a stream.
  */
@@ -417,6 +566,90 @@ export function recordModelRoutingMetrics(config, event) {
         });
     }
 }
+export function recordAgentRunMetrics(config, event) {
+    if (!agentRunCounter ||
+        !agentDurationHistogram ||
+        !agentTurnsHistogram ||
+        !isMetricsInitialized)
+        return;
+    const commonAttributes = baseMetricDefinition.getCommonAttributes(config);
+    agentRunCounter.add(1, {
+        ...commonAttributes,
+        agent_name: event.agent_name,
+        terminate_reason: event.terminate_reason,
+    });
+    agentDurationHistogram.record(event.duration_ms, {
+        ...commonAttributes,
+        agent_name: event.agent_name,
+    });
+    agentTurnsHistogram.record(event.turn_count, {
+        ...commonAttributes,
+        agent_name: event.agent_name,
+    });
+}
+export function recordRecoveryAttemptMetrics(config, event) {
+    if (!agentRecoveryAttemptCounter ||
+        !agentRecoveryAttemptDurationHistogram ||
+        !isMetricsInitialized)
+        return;
+    const commonAttributes = baseMetricDefinition.getCommonAttributes(config);
+    agentRecoveryAttemptCounter.add(1, {
+        ...commonAttributes,
+        agent_name: event.agent_name,
+        reason: event.reason,
+        success: event.success,
+    });
+    agentRecoveryAttemptDurationHistogram.record(event.duration_ms, {
+        ...commonAttributes,
+        agent_name: event.agent_name,
+    });
+}
+// OpenTelemetry GenAI Semantic Convention Recording Functions
+export function recordGenAiClientTokenUsage(config, tokenCount, attributes) {
+    if (!genAiClientTokenUsageHistogram || !isMetricsInitialized)
+        return;
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
+    };
+    genAiClientTokenUsageHistogram.record(tokenCount, metricAttributes);
+}
+export function recordGenAiClientOperationDuration(config, durationSeconds, attributes) {
+    if (!genAiClientOperationDurationHistogram || !isMetricsInitialized)
+        return;
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
+    };
+    genAiClientOperationDurationHistogram.record(durationSeconds, metricAttributes);
+}
+export function getConventionAttributes(event) {
+    const operationName = getGenAiOperationName();
+    const provider = getGenAiProvider(event.auth_type);
+    return {
+        'gen_ai.operation.name': operationName,
+        'gen_ai.provider.name': provider,
+        'gen_ai.request.model': event.model,
+        'gen_ai.response.model': event.model,
+    };
+}
+/**
+ * Maps authentication type to GenAI provider name following OpenTelemetry conventions
+ */
+function getGenAiProvider(authType) {
+    switch (authType) {
+        case AuthType.USE_VERTEX_AI:
+        case AuthType.COMPUTE_ADC:
+        case AuthType.LOGIN_WITH_GOOGLE:
+            return GenAiProviderName.GCP_VERTEX_AI;
+        case AuthType.USE_GEMINI:
+        default:
+            return GenAiProviderName.GCP_GEN_AI;
+    }
+}
+function getGenAiOperationName() {
+    return GenAiOperationName.GENERATE_CONTENT;
+}
 // Performance Monitoring Functions
 export function initializePerformanceMonitoring(config) {
     const meter = getMeter();
@@ -542,4 +775,35 @@ export function recordBaselineComparison(config, attributes) {
 export function isPerformanceMonitoringActive() {
     return isPerformanceMonitoringEnabled && isMetricsInitialized;
 }
+/**
+ * Token usage recording that emits both custom and convention metrics.
+ */
+export function recordTokenUsageMetrics(config, tokenCount, attributes) {
+    recordCustomTokenUsageMetrics(config, tokenCount, {
+        model: attributes.model,
+        type: attributes.type,
+    });
+    if ((attributes.type === 'input' || attributes.type === 'output') &&
+        attributes.genAiAttributes) {
+        recordGenAiClientTokenUsage(config, tokenCount, {
+            ...attributes.genAiAttributes,
+            'gen_ai.token.type': attributes.type,
+        });
+    }
+}
+/**
+ * Operation latency recording that emits both custom and convention metrics.
+ */
+export function recordApiResponseMetrics(config, durationMs, attributes) {
+    recordCustomApiResponseMetrics(config, durationMs, {
+        model: attributes.model,
+        status_code: attributes.status_code,
+    });
+    if (attributes.genAiAttributes) {
+        const durationSeconds = durationMs / 1000;
+        recordGenAiClientOperationDuration(config, durationSeconds, {
+            ...attributes.genAiAttributes,
+        });
+    }
+}
 //# sourceMappingURL=metrics.js.map