@llm-dev-ops/agentics-cli 1.4.27 → 1.4.29

package/dist/bundled-agents/latency-lens-agents/src/agents/latency_analysis/mod.rs

@@ -1,40 +0,0 @@
-//! Latency Analysis Agent
-//!
-//! Measures and analyzes end-to-end and token-level latency characteristics
-//! of LLM requests.
-//!
-//! # Classification: ANALYSIS
-//!
-//! This agent processes measurement data and produces analytical insights.
-//! It does NOT modify system behavior, trigger remediation, or apply optimizations.
-//!
-//! # Scope
-//!
-//! - Measure time-to-first-token (TTFT)
-//! - Measure per-token streaming latency
-//! - Measure end-to-end request duration
-//! - Produce latency distributions and percentiles
-//!
-//! # decision_type: "latency_analysis"
-//!
-//! # Contract Compliance
-//!
-//! - Input schema: [`LatencyAnalysisInput`] from agentics-contracts
-//! - Output schema: [`LatencyAnalysisOutput`] from agentics-contracts
-//! - Emits exactly ONE [`DecisionEvent`] per invocation
-//! - Persists to ruvector-service only
-//! - Telemetry compatible with LLM-Observatory
-
-mod agent;
-mod analyzer;
-mod telemetry;
-
-pub use agent::LatencyAnalysisAgent;
-pub use analyzer::LatencyAnalyzer;
-pub use telemetry::AgentTelemetry;
-
-/// Agent version (semver)
-pub const AGENT_VERSION: &str = "0.1.0";
-
-/// Agent identifier
-pub const AGENT_ID: &str = "latency-analysis-agent";

package/dist/bundled-agents/latency-lens-agents/src/agents/latency_analysis/telemetry.rs

@@ -1,134 +0,0 @@
-//! Telemetry emission for Latency Analysis Agent
-//!
-//! Emits telemetry compatible with LLM-Observatory.
-
-use opentelemetry::trace::{Span, SpanKind, Tracer};
-use opentelemetry::{global, KeyValue};
-use tracing::{debug, info, instrument};
-
-use crate::agents::contracts::{DecisionType, LatencyAnalysisInput, LatencyAnalysisOutput};
-
-/// Agent telemetry emitter
-pub struct AgentTelemetry {
-    /// Tracer name
-    tracer_name: String,
-}
-
-impl AgentTelemetry {
-    /// Create a new telemetry emitter
-    pub fn new(tracer_name: impl Into<String>) -> Self {
-        Self {
-            tracer_name: tracer_name.into(),
-        }
-    }
-
-    /// Create default telemetry emitter for latency analysis agent
-    pub fn default_latency_analysis() -> Self {
-        Self::new("latency-analysis-agent")
-    }
-
-    /// Emit span for agent invocation
-    #[instrument(skip(self, input, output))]
-    pub fn emit_analysis_span(
-        &self,
-        input: &LatencyAnalysisInput,
-        output: &LatencyAnalysisOutput,
-        decision_type: DecisionType,
-    ) {
-        let tracer_name = self.tracer_name.clone();
-        let tracer = global::tracer(tracer_name);
-
-        let mut span = tracer
-            .span_builder("latency_analysis")
-            .with_kind(SpanKind::Internal)
-            .start(&tracer);
-
-        // Add span attributes
-        span.set_attribute(KeyValue::new("agent.id", super::AGENT_ID));
-        span.set_attribute(KeyValue::new("agent.version", super::AGENT_VERSION));
-        span.set_attribute(KeyValue::new(
-            "decision.type",
-            format!("{:?}", decision_type),
-        ));
-        span.set_attribute(KeyValue::new(
-            "analysis.id",
-            input.analysis_id.to_string(),
-        ));
-        span.set_attribute(KeyValue::new(
-            "input.metrics_count",
-            input.metrics.len() as i64,
-        ));
-        span.set_attribute(KeyValue::new(
-            "output.included_requests",
-            output.summary.included_requests as i64,
-        ));
-        span.set_attribute(KeyValue::new(
-            "output.excluded_requests",
-            output.summary.excluded_requests as i64,
-        ));
-        span.set_attribute(KeyValue::new(
-            "output.success_rate",
-            output.summary.success_rate,
-        ));
-        span.set_attribute(KeyValue::new(
-            "output.anomalies_count",
-            output.anomalies.len() as i64,
-        ));
-        span.set_attribute(KeyValue::new(
-            "analysis.duration_ms",
-            output.metadata.analysis_duration_ms as i64,
-        ));
-
-        // Add distribution summary attributes
-        span.set_attribute(KeyValue::new(
-            "ttft.p50_ns",
-            output.ttft_analysis.distribution.p50.as_nanos() as i64,
-        ));
-        span.set_attribute(KeyValue::new(
-            "ttft.p99_ns",
-            output.ttft_analysis.distribution.p99.as_nanos() as i64,
-        ));
-        span.set_attribute(KeyValue::new(
-            "total_latency.p50_ns",
-            output.total_latency_analysis.distribution.p50.as_nanos() as i64,
-        ));
-        span.set_attribute(KeyValue::new(
-            "total_latency.p99_ns",
-            output.total_latency_analysis.distribution.p99.as_nanos() as i64,
-        ));
-        span.set_attribute(KeyValue::new(
-            "throughput.mean_tps",
-            output.throughput_analysis.stats.mean_tokens_per_second,
-        ));
-
-        span.end();
-
-        info!(
-            analysis_id = %input.analysis_id,
-            metrics_count = input.metrics.len(),
-            included = output.summary.included_requests,
-            anomalies = output.anomalies.len(),
-            "Telemetry emitted for latency analysis"
-        );
-    }
-
-    /// Emit metrics for the analysis
-    pub fn emit_metrics(&self, output: &LatencyAnalysisOutput) {
-        // Log key metrics
-        debug!(
-            ttft_p50_ms = output.ttft_analysis.distribution.p50.as_millis(),
-            ttft_p99_ms = output.ttft_analysis.distribution.p99.as_millis(),
-            total_latency_p50_ms = output.total_latency_analysis.distribution.p50.as_millis(),
-            total_latency_p99_ms = output.total_latency_analysis.distribution.p99.as_millis(),
-            throughput_mean = output.throughput_analysis.stats.mean_tokens_per_second,
-            anomalies = output.anomalies.len(),
-            "Latency analysis metrics"
-        );
-    }
-}
-
-impl Default for AgentTelemetry {
-    fn default() -> Self {
-        Self::default_latency_analysis()
-    }
-}

package/dist/bundled-agents/latency-lens-agents/src/agents/mod.rs

@@ -1,70 +0,0 @@
-//! LLM-Latency-Lens Agent Infrastructure
-//!
-//! This module contains agents for the LLM-Latency-Lens diagnostic layer.
-//! All agents are MEASUREMENT or ANALYSIS classified and follow the
-//! Agentics Dev platform constitution.
-//!
-//! # Agent Architecture
-//!
-//! ```text
-//! ┌─────────────────────────────────────────────────────────────┐
-//! │                    Edge Function Entry                       │
-//! │              (Google Cloud Edge Function)                    │
-//! └─────────────────────────┬───────────────────────────────────┘
-//!                           │
-//!                           ▼
-//! ┌─────────────────────────────────────────────────────────────┐
-//! │                    Agent Runtime                             │
-//! │  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
-//! │  │  Contracts  │  │   Agent     │  │  RuVector Client    │  │
-//! │  │ (agentics-  │  │   Logic     │  │  (persistence)      │  │
-//! │  │ contracts)  │  │             │  │                     │  │
-//! │  └─────────────┘  └─────────────┘  └─────────────────────┘  │
-//! └─────────────────────────────────────────────────────────────┘
-//!                           │
-//!                           ▼
-//! ┌─────────────────────────────────────────────────────────────┐
-//! │                    DecisionEvent                             │
-//! │              (persisted to ruvector-service)                 │
-//! └─────────────────────────────────────────────────────────────┘
-//! ```
-//!
-//! # Available Agents
-//!
-//! - [`cold_start_mitigation`]: Measure and characterize cold start behavior (MEASUREMENT)
-//! - [`latency_analysis`]: Measure and analyze end-to-end and token-level latency (ANALYSIS)
-//!
-//! # Agent Classifications
-//!
-//! All agents are classified as either:
-//! - **MEASUREMENT**: Captures raw timing data, does not interpret
-//! - **ANALYSIS**: Processes and interprets measurement data
-//!
-//! # What Agents MUST NEVER DO
-//!
-//! - Modify system behavior
-//! - Trigger remediation or retries
-//! - Change routing or apply optimizations
-//! - Enforce policies or orchestrate workflows
-//! - Connect directly to Google SQL or execute SQL
-//!
-//! # Edge Function Deployment
-//!
-//! The [`edge_function`] module provides HTTP handlers for Google Cloud Edge Functions.
-
-pub mod cold_start_mitigation;
-pub mod contracts;
-pub mod edge_function;
-pub mod execution_graph;
-pub mod latency_analysis;
-pub mod ruvector;
-
-pub use cold_start_mitigation::ColdStartMitigationAgent;
-pub use contracts::*;
-pub use edge_function::{EdgeFunctionHandler, EdgeFunctionRequest, EdgeFunctionResponse, EdgeOperation};
-pub use execution_graph::{
-    Artifact, ExecutionContext, ExecutionResult, ExecutionSpan, RepoExecution, SpanStatus, SpanType,
-    REPO_NAME,
-};
-pub use latency_analysis::LatencyAnalysisAgent;
-pub use ruvector::RuVectorClient;

package/dist/bundled-agents/latency-lens-agents/src/agents/ruvector/client.rs

@@ -1,335 +0,0 @@
-//! RuVector Service Client Implementation
-//!
-//! Async HTTP client for ruvector-service persistence.
-//! Handles retries, rate limiting, and batch operations.
-
-use super::{
-    error::RuVectorError,
-    types::{EventQuery, HealthStatus, PersistResponse, QueryResult, RuVectorConfig},
-};
-use crate::agents::contracts::DecisionEvent;
-use reqwest::Client;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::RwLock;
-use tracing::{debug, error, info, warn};
-
-/// RuVector service client
-///
-/// Provides async interface for persisting DecisionEvents to ruvector-service.
-/// This is the ONLY persistence mechanism for LLM-Latency-Lens agents.
-pub struct RuVectorClient {
-    /// HTTP client
-    client: Client,
-    /// Configuration
-    config: RuVectorConfig,
-    /// Connection state
-    connected: Arc<RwLock<bool>>,
-}
-
-impl RuVectorClient {
-    /// Create a new RuVector client with configuration
-    pub fn new(config: RuVectorConfig) -> Result<Self, RuVectorError> {
-        config
-            .validate()
-            .map_err(RuVectorError::InvalidConfig)?;
-
-        let client = Client::builder()
-            .timeout(Duration::from_millis(config.timeout_ms))
-            .gzip(config.compression)
-            .build()?;
-
-        Ok(Self {
-            client,
-            config,
-            connected: Arc::new(RwLock::new(false)),
-        })
-    }
-
-    /// Create client from environment variables
-    pub fn from_env() -> Result<Self, RuVectorError> {
-        Self::new(RuVectorConfig::from_env())
-    }
-
-    /// Check connection to ruvector-service
-    pub async fn connect(&self) -> Result<(), RuVectorError> {
-        let health = self.health_check().await?;
-
-        if !health.healthy {
-            return Err(RuVectorError::ServiceError {
-                status: 503,
-                message: "Service unhealthy".to_string(),
-            });
-        }
-
-        let mut connected = self.connected.write().await;
-        *connected = true;
-
-        info!(
-            endpoint = %self.config.endpoint,
-            version = %health.version,
-            "Connected to ruvector-service"
-        );
-
-        Ok(())
-    }
-
-    /// Check if client is connected
-    pub async fn is_connected(&self) -> bool {
-        *self.connected.read().await
-    }
-
-    /// Health check endpoint
-    pub async fn health_check(&self) -> Result<HealthStatus, RuVectorError> {
-        let url = format!("{}/health", self.config.endpoint);
-
-        let response = self.client.get(&url).send().await?;
-
-        if !response.status().is_success() {
-            return Err(RuVectorError::ServiceError {
-                status: response.status().as_u16(),
-                message: response.text().await.unwrap_or_default(),
-            });
-        }
-
-        let health: HealthStatus = response.json().await?;
-        Ok(health)
-    }
-
-    /// Persist a single DecisionEvent
-    ///
-    /// This is the primary method for agent persistence.
-    /// Every agent invocation MUST call this exactly once.
-    pub async fn persist_event(&self, event: &DecisionEvent) -> Result<PersistResponse, RuVectorError> {
-        // Validate event before sending
-        event
-            .validate()
-            .map_err(|e| RuVectorError::ValidationFailed(e.to_string()))?;
-
-        let url = format!("{}/api/v1/events", self.config.endpoint);
-
-        let mut attempts = 0;
-        loop {
-            attempts += 1;
-
-            let result = self.send_persist_request(&url, event).await;
-
-            match result {
-                Ok(response) => {
-                    debug!(
-                        event_id = %event.event_id,
-                        storage_ref = %response.storage_ref,
-                        latency_ms = response.latency_ms,
-                        "DecisionEvent persisted"
-                    );
-                    return Ok(response);
-                }
-                Err(e) if e.is_retryable() && attempts < self.config.max_retries => {
-                    let delay = e.retry_delay_ms().unwrap_or(1000);
-                    warn!(
-                        error = %e,
-                        attempt = attempts,
-                        max_retries = self.config.max_retries,
-                        retry_delay_ms = delay,
-                        "Retrying persist operation"
-                    );
-                    tokio::time::sleep(Duration::from_millis(delay)).await;
-                }
-                Err(e) => {
-                    error!(
-                        error = %e,
-                        event_id = %event.event_id,
-                        "Failed to persist DecisionEvent"
-                    );
-                    return Err(e);
-                }
-            }
-        }
-    }
-
-    /// Internal method to send persist request
-    async fn send_persist_request(
-        &self,
-        url: &str,
-        event: &DecisionEvent,
-    ) -> Result<PersistResponse, RuVectorError> {
-        let mut request = self.client.post(url).json(event);
-
-        if let Some(ref api_key) = self.config.api_key {
-            request = request.header("Authorization", format!("Bearer {}", api_key));
-        }
-
-        let response = request.send().await?;
-
-        if response.status().as_u16() == 429 {
-            // Rate limited
-            let retry_after = response
-                .headers()
-                .get("Retry-After")
-                .and_then(|v| v.to_str().ok())
-                .and_then(|s| s.parse::<u64>().ok())
-                .unwrap_or(1000);
-
-            return Err(RuVectorError::RateLimited {
-                retry_after_ms: retry_after,
-            });
-        }
-
-        if !response.status().is_success() {
-            return Err(RuVectorError::ServiceError {
-                status: response.status().as_u16(),
-                message: response.text().await.unwrap_or_default(),
-            });
-        }
-
-        let persist_response: PersistResponse = response.json().await?;
-        Ok(persist_response)
-    }
-
-    /// Persist multiple DecisionEvents in batch
-    pub async fn persist_batch(
-        &self,
-        events: &[DecisionEvent],
-    ) -> Result<Vec<PersistResponse>, RuVectorError> {
-        // Validate all events first
-        for event in events {
-            event
-                .validate()
-                .map_err(|e| RuVectorError::ValidationFailed(e.to_string()))?;
-        }
-
-        let url = format!("{}/api/v1/events/batch", self.config.endpoint);
-
-        let mut request = self.client.post(&url).json(events);
-
-        if let Some(ref api_key) = self.config.api_key {
-            request = request.header("Authorization", format!("Bearer {}", api_key));
-        }
-
-        let response = request.send().await?;
-
-        if !response.status().is_success() {
-            return Err(RuVectorError::ServiceError {
-                status: response.status().as_u16(),
-                message: response.text().await.unwrap_or_default(),
-            });
-        }
-
-        let responses: Vec<PersistResponse> = response.json().await?;
-
-        debug!(
-            count = events.len(),
-            "Batch persisted {} DecisionEvents",
-            events.len()
-        );
-
-        Ok(responses)
-    }
-
-    /// Query DecisionEvents
-    pub async fn query_events(&self, query: EventQuery) -> Result<QueryResult, RuVectorError> {
-        let url = format!("{}/api/v1/events/query", self.config.endpoint);
-
-        let mut request = self.client.post(&url).json(&query);
-
-        if let Some(ref api_key) = self.config.api_key {
-            request = request.header("Authorization", format!("Bearer {}", api_key));
-        }
-
-        let response = request.send().await?;
-
-        if !response.status().is_success() {
-            return Err(RuVectorError::ServiceError {
-                status: response.status().as_u16(),
-                message: response.text().await.unwrap_or_default(),
-            });
-        }
-
-        let result: QueryResult = response.json().await?;
-        Ok(result)
-    }
-
-    /// Get a single event by ID
-    pub async fn get_event(&self, event_id: uuid::Uuid) -> Result<Option<serde_json::Value>, RuVectorError> {
-        let url = format!("{}/api/v1/events/{}", self.config.endpoint, event_id);
-
-        let mut request = self.client.get(&url);
-
-        if let Some(ref api_key) = self.config.api_key {
-            request = request.header("Authorization", format!("Bearer {}", api_key));
-        }
-
-        let response = request.send().await?;
-
-        if response.status().as_u16() == 404 {
-            return Ok(None);
-        }
-
-        if !response.status().is_success() {
-            return Err(RuVectorError::ServiceError {
-                status: response.status().as_u16(),
-                message: response.text().await.unwrap_or_default(),
-            });
-        }
-
-        let event: serde_json::Value = response.json().await?;
-        Ok(Some(event))
-    }
-
-    /// Get configuration
-    pub fn config(&self) -> &RuVectorConfig {
-        &self.config
-    }
-}
-
-impl Clone for RuVectorClient {
-    fn clone(&self) -> Self {
-        Self {
-            client: self.client.clone(),
-            config: self.config.clone(),
-            connected: Arc::clone(&self.connected),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_config_validation() {
-        let config = RuVectorConfig::default();
-        assert!(config.validate().is_ok());
-
-        let invalid_config = RuVectorConfig {
-            endpoint: "".to_string(),
-            ..Default::default()
-        };
-        assert!(invalid_config.validate().is_err());
-
-        let invalid_config2 = RuVectorConfig {
-            endpoint: "ftp://invalid".to_string(),
-            ..Default::default()
-        };
-        assert!(invalid_config2.validate().is_err());
-    }
-
-    #[test]
-    fn test_client_creation() {
-        let config = RuVectorConfig::default();
-        let client = RuVectorClient::new(config);
-        assert!(client.is_ok());
-    }
-
-    #[test]
-    fn test_event_query_builder() {
-        let query = EventQuery::new()
-            .agent_id("latency-analysis-agent")
-            .decision_type("latency_analysis")
-            .limit(50);
-
-        assert_eq!(query.agent_id, Some("latency-analysis-agent".to_string()));
-        assert_eq!(query.decision_type, Some("latency_analysis".to_string()));
-        assert_eq!(query.limit, Some(50));
-    }
-}

package/dist/bundled-agents/latency-lens-agents/src/agents/ruvector/error.rs

@@ -1,61 +0,0 @@
-//! RuVector client errors
-
-use thiserror::Error;
-
-/// Errors from RuVector service client
-#[derive(Debug, Error)]
-pub enum RuVectorError {
-    /// Network/HTTP error
-    #[error("Network error: {0}")]
-    Network(#[from] reqwest::Error),
-
-    /// Serialization error
-    #[error("Serialization error: {0}")]
-    Serialization(#[from] serde_json::Error),
-
-    /// Service returned error response
-    #[error("Service error: {status} - {message}")]
-    ServiceError { status: u16, message: String },
-
-    /// Request timeout
-    #[error("Request timeout after {0}ms")]
-    Timeout(u64),
-
-    /// Rate limited
-    #[error("Rate limited, retry after {retry_after_ms}ms")]
-    RateLimited { retry_after_ms: u64 },
-
-    /// Invalid configuration
-    #[error("Invalid configuration: {0}")]
-    InvalidConfig(String),
-
-    /// Event validation failed
-    #[error("Event validation failed: {0}")]
-    ValidationFailed(String),
-
-    /// Client not connected
-    #[error("Client not connected to ruvector-service")]
-    NotConnected,
-}
-
-impl RuVectorError {
-    /// Check if this error is retryable
-    pub fn is_retryable(&self) -> bool {
-        matches!(
-            self,
-            RuVectorError::Network(_)
-                | RuVectorError::Timeout(_)
-                | RuVectorError::RateLimited { .. }
-        )
-    }
-
-    /// Get suggested retry delay in milliseconds
-    pub fn retry_delay_ms(&self) -> Option<u64> {
-        match self {
-            RuVectorError::RateLimited { retry_after_ms } => Some(*retry_after_ms),
-            RuVectorError::Network(_) => Some(1000), // 1 second default
-            RuVectorError::Timeout(_) => Some(2000), // 2 seconds for timeout
-            _ => None,
-        }
-    }
-}

package/dist/bundled-agents/latency-lens-agents/src/agents/ruvector/mod.rs

@@ -1,21 +0,0 @@
-//! RuVector Service Client
-//!
-//! Client for persisting data to ruvector-service.
-//! This is the ONLY way LLM-Latency-Lens persists data.
-//!
-//! # Architecture
-//!
-//! ```text
-//! LLM-Latency-Lens ──► RuVector Client ──► ruvector-service ──► Google SQL (Postgres)
-//! ```
-//!
-//! LLM-Latency-Lens NEVER connects directly to Google SQL.
-//! All persistence occurs via ruvector-service client calls.
-
-mod client;
-mod error;
-mod types;
-
-pub use client::RuVectorClient;
-pub use error::RuVectorError;
-pub use types::*;