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

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

@@ -1,440 +0,0 @@
-//! LLM Latency Lens - Library for programmatic use
-//!
-//! This library provides high-level APIs for LLM performance measurement
-//! that can be used in other Rust applications.
-//!
-//! # Example
-//!
-//! ```no_run
-//! use llm_latency_lens::{ProfileBuilder, BenchmarkBuilder};
-//! use llm_latency_lens_providers::OpenAIProvider;
-//!
-//! #[tokio::main]
-//! async fn main() -> anyhow::Result<()> {
-//!     // Create a provider
-//!     let provider = OpenAIProvider::new("sk-...");
-//!
-//!     // Profile a single request
-//!     let metrics = ProfileBuilder::new(provider.clone())
-//!         .model("gpt-4o")
-//!         .prompt("Explain quantum computing")
-//!         .max_tokens(500)
-//!         .execute()
-//!         .await?;
-//!
-//!     println!("TTFT: {:?}", metrics.ttft);
-//!     println!("Total: {:?}", metrics.total_latency);
-//!
-//!     // Run a benchmark
-//!     let results = BenchmarkBuilder::new(provider)
-//!         .model("gpt-4o")
-//!         .prompt("Hello, world!")
-//!         .requests(10)
-//!         .concurrency(2)
-//!         .execute()
-//!         .await?;
-//!
-//!     println!("Mean TTFT: {:?}", results.ttft_distribution.mean);
-//!     println!("P95 TTFT: {:?}", results.ttft_distribution.p95);
-//!
-//!     Ok(())
-//! }
-//! ```
-
-pub mod adapters;
-pub mod agents;
-pub mod benchmarks;
-pub mod config;
-pub mod consumers;
-pub mod orchestrator;
-pub mod phase2;
-
-// Re-export core types for convenience
-pub use llm_latency_lens_core::{
-    Provider as CoreProvider, RequestId, SessionId, TimingEngine,
-};
-pub use llm_latency_lens_exporters::{
-    ConsoleExporter, CsvExporter, Exporter, JsonExporter, PrometheusExporter,
-};
-pub use llm_latency_lens_metrics::{
-    AggregatedMetrics, CollectorConfig, LatencyDistribution, MetricsAggregator,
-    MetricsCollector, RequestMetrics, ThroughputStats,
-};
-pub use llm_latency_lens_providers::{
-    AnthropicProvider, CompletionResult, GoogleProvider, Message, MessageRole,
-    OpenAIProvider, Provider, ResponseMetadata, StreamingRequest, StreamingResponse,
-};
-
-// Re-export canonical benchmark interface
-pub use adapters::{all_targets, create_target, create_targets, BenchTarget, LLMTarget};
-pub use benchmarks::{
-    run_all_benchmarks, BenchmarkConfig, BenchmarkResult,
-    ensure_output_dirs, generate_summary, output_dir, raw_output_dir,
-    read_all_results, write_result, write_results, write_summary,
-};
-
-// Re-export agent infrastructure
-pub use agents::{
-    contracts::{
-        DecisionEvent, DecisionType, LatencyAnalysisConfig, LatencyAnalysisInput,
-        LatencyAnalysisOutput, MeasurementConstraints,
-    },
-    edge_function::{EdgeFunctionHandler, EdgeFunctionRequest, EdgeFunctionResponse, EdgeOperation},
-    execution_graph::{Artifact, ExecutionContext, ExecutionResult, ExecutionSpan},
-    latency_analysis::{LatencyAnalysisAgent, LatencyAnalyzer, AGENT_ID, AGENT_VERSION},
-    ruvector::{EventQuery, RuVectorClient, RuVectorConfig, RuVectorError},
-};
-
-// Re-export consumers
-pub use consumers::{
-    ConsumerError, ConsumerResult, DataConsumer, MergedConsumer, RetryConfig,
-    TestBenchFormat, TestBenchMetrics, TestBenchReader,
-};
-
-// Re-export upstream consumers (only with upstream feature)
-#[cfg(feature = "upstream")]
-pub use consumers::{
-    AnalyticsHubConsumer, AnalyticsHubConfig, BaselineComparison, HistoricalBaseline,
-    ObservatoryConsumer, ObservatoryConfig, RollingWindow, TelemetrySpan, TimeWindow,
-    TracedRequest,
-};
-
-// Re-export Phase 2 operational intelligence
-pub use phase2::{
-    AgentConfig, AnomalySignal, CacheConfig, DriftSignal, LatencySignal,
-    LineageCache, LineageSignal, PerformanceBudget, Phase2Config, Phase2Runtime,
-    RuntimeError, Signal, SignalEmitter, SignalMetadata, StartupValidation,
-};
-
-use anyhow::Result;
-use std::sync::Arc;
-
-use orchestrator::{ExecutionSummary, Orchestrator, OrchestratorConfig};
-
-/// Builder for profiling a single request
-pub struct ProfileBuilder<P: Provider> {
-    provider: Arc<P>,
-    model: String,
-    messages: Vec<Message>,
-    max_tokens: Option<u32>,
-    temperature: Option<f32>,
-    top_p: Option<f32>,
-    timeout_secs: Option<u64>,
-}
-
-impl<P: Provider + 'static> ProfileBuilder<P> {
-    /// Create a new profile builder
-    pub fn new(provider: P) -> Self {
-        Self {
-            provider: Arc::new(provider),
-            model: String::new(),
-            messages: Vec::new(),
-            max_tokens: None,
-            temperature: None,
-            top_p: None,
-            timeout_secs: None,
-        }
-    }
-
-    /// Set the model
-    pub fn model(mut self, model: impl Into<String>) -> Self {
-        self.model = model.into();
-        self
-    }
-
-    /// Set a simple prompt
-    pub fn prompt(mut self, prompt: impl Into<String>) -> Self {
-        self.messages = vec![Message {
-            role: MessageRole::User,
-            content: prompt.into(),
-        }];
-        self
-    }
-
-    /// Set messages
-    pub fn messages(mut self, messages: Vec<Message>) -> Self {
-        self.messages = messages;
-        self
-    }
-
-    /// Set max tokens
-    pub fn max_tokens(mut self, tokens: u32) -> Self {
-        self.max_tokens = Some(tokens);
-        self
-    }
-
-    /// Set temperature
-    pub fn temperature(mut self, temp: f32) -> Self {
-        self.temperature = Some(temp);
-        self
-    }
-
-    /// Set top_p
-    pub fn top_p(mut self, p: f32) -> Self {
-        self.top_p = Some(p);
-        self
-    }
-
-    /// Set timeout in seconds
-    pub fn timeout_secs(mut self, secs: u64) -> Self {
-        self.timeout_secs = Some(secs);
-        self
-    }
-
-    /// Execute the profile
-    pub async fn execute(self) -> Result<RequestMetrics> {
-        if self.model.is_empty() {
-            anyhow::bail!("Model is required");
-        }
-
-        if self.messages.is_empty() {
-            anyhow::bail!("Messages/prompt is required");
-        }
-
-        // Build request
-        let mut request_builder = StreamingRequest::builder()
-            .model(self.model)
-            .messages(self.messages);
-
-        if let Some(max_tokens) = self.max_tokens {
-            request_builder = request_builder.max_tokens(max_tokens);
-        }
-
-        if let Some(temperature) = self.temperature {
-            request_builder = request_builder.temperature(temperature);
-        }
-
-        if let Some(top_p) = self.top_p {
-            request_builder = request_builder.top_p(top_p);
-        }
-
-        if let Some(timeout) = self.timeout_secs {
-            request_builder = request_builder.timeout_secs(timeout);
-        }
-
-        let request = request_builder.build();
-
-        // Create orchestrator
-        let shutdown = Arc::new(tokio::sync::Notify::new());
-        let config = OrchestratorConfig::default();
-        let orchestrator = Orchestrator::new(config, shutdown);
-
-        // Execute single request
-        orchestrator.execute_single(&*self.provider, request).await
-    }
-}
-
-/// Builder for running benchmarks
-pub struct BenchmarkBuilder<P: Provider> {
-    provider: Arc<P>,
-    model: String,
-    messages: Vec<Message>,
-    max_tokens: Option<u32>,
-    temperature: Option<f32>,
-    top_p: Option<f32>,
-    timeout_secs: Option<u64>,
-    requests: u32,
-    concurrency: u32,
-    rate_limit: u32,
-    show_progress: bool,
-}
-
-impl<P: Provider + 'static> BenchmarkBuilder<P> {
-    /// Create a new benchmark builder
-    pub fn new(provider: P) -> Self {
-        Self {
-            provider: Arc::new(provider),
-            model: String::new(),
-            messages: Vec::new(),
-            max_tokens: None,
-            temperature: None,
-            top_p: None,
-            timeout_secs: None,
-            requests: 10,
-            concurrency: 1,
-            rate_limit: 0,
-            show_progress: true,
-        }
-    }
-
-    /// Set the model
-    pub fn model(mut self, model: impl Into<String>) -> Self {
-        self.model = model.into();
-        self
-    }
-
-    /// Set a simple prompt
-    pub fn prompt(mut self, prompt: impl Into<String>) -> Self {
-        self.messages = vec![Message {
-            role: MessageRole::User,
-            content: prompt.into(),
-        }];
-        self
-    }
-
-    /// Set messages
-    pub fn messages(mut self, messages: Vec<Message>) -> Self {
-        self.messages = messages;
-        self
-    }
-
-    /// Set max tokens
-    pub fn max_tokens(mut self, tokens: u32) -> Self {
-        self.max_tokens = Some(tokens);
-        self
-    }
-
-    /// Set temperature
-    pub fn temperature(mut self, temp: f32) -> Self {
-        self.temperature = Some(temp);
-        self
-    }
-
-    /// Set top_p
-    pub fn top_p(mut self, p: f32) -> Self {
-        self.top_p = Some(p);
-        self
-    }
-
-    /// Set timeout in seconds
-    pub fn timeout_secs(mut self, secs: u64) -> Self {
-        self.timeout_secs = Some(secs);
-        self
-    }
-
-    /// Set number of requests
-    pub fn requests(mut self, n: u32) -> Self {
-        self.requests = n;
-        self
-    }
-
-    /// Set concurrency level
-    pub fn concurrency(mut self, n: u32) -> Self {
-        self.concurrency = n;
-        self
-    }
-
-    /// Set rate limit (requests per second)
-    pub fn rate_limit(mut self, rps: u32) -> Self {
-        self.rate_limit = rps;
-        self
-    }
-
-    /// Show progress bars
-    pub fn show_progress(mut self, show: bool) -> Self {
-        self.show_progress = show;
-        self
-    }
-
-    /// Execute the benchmark
-    pub async fn execute(self) -> Result<BenchmarkResults> {
-        if self.model.is_empty() {
-            anyhow::bail!("Model is required");
-        }
-
-        if self.messages.is_empty() {
-            anyhow::bail!("Messages/prompt is required");
-        }
-
-        // Build request template
-        let mut request_builder = StreamingRequest::builder()
-            .model(self.model)
-            .messages(self.messages);
-
-        if let Some(max_tokens) = self.max_tokens {
-            request_builder = request_builder.max_tokens(max_tokens);
-        }
-
-        if let Some(temperature) = self.temperature {
-            request_builder = request_builder.temperature(temperature);
-        }
-
-        if let Some(top_p) = self.top_p {
-            request_builder = request_builder.top_p(top_p);
-        }
-
-        if let Some(timeout) = self.timeout_secs {
-            request_builder = request_builder.timeout_secs(timeout);
-        }
-
-        let request = request_builder.build();
-
-        // Create orchestrator
-        let shutdown = Arc::new(tokio::sync::Notify::new());
-        let config = OrchestratorConfig {
-            concurrency: self.concurrency,
-            total_requests: self.requests,
-            rate_limit: self.rate_limit,
-            show_progress: self.show_progress,
-            shutdown_timeout: std::time::Duration::from_secs(30),
-        };
-        let orchestrator = Orchestrator::new(config, shutdown);
-
-        // Create metrics collector
-        let session_id = orchestrator.session_id();
-        let collector = Arc::new(MetricsCollector::with_defaults(session_id)?);
-
-        // Execute benchmark
-        let summary = orchestrator
-            .execute(self.provider, request, Arc::clone(&collector))
-            .await?;
-
-        // Aggregate metrics
-        let aggregated = MetricsAggregator::aggregate(&collector)?;
-
-        Ok(BenchmarkResults {
-            summary,
-            metrics: aggregated,
-        })
-    }
-}
-
-/// Results from a benchmark run
-pub struct BenchmarkResults {
-    pub summary: ExecutionSummary,
-    pub metrics: AggregatedMetrics,
-}
-
-impl BenchmarkResults {
-    /// Get TTFT distribution
-    pub fn ttft_distribution(&self) -> &LatencyDistribution {
-        &self.metrics.ttft_distribution
-    }
-
-    /// Get inter-token latency distribution
-    pub fn inter_token_distribution(&self) -> &LatencyDistribution {
-        &self.metrics.inter_token_distribution
-    }
-
-    /// Get total latency distribution
-    pub fn total_latency_distribution(&self) -> &LatencyDistribution {
-        &self.metrics.total_latency_distribution
-    }
-
-    /// Get throughput stats
-    pub fn throughput(&self) -> &ThroughputStats {
-        &self.metrics.throughput
-    }
-
-    /// Get success rate
-    pub fn success_rate(&self) -> f64 {
-        self.metrics.success_rate()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_profile_builder() {
-        // This is a compile-time test to ensure the builder API works
-        // We can't actually execute it without a real provider
-    }
-
-    #[test]
-    fn test_benchmark_builder() {
-        // This is a compile-time test to ensure the builder API works
-        // We can't actually execute it without a real provider
-    }
-}

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

@@ -1,210 +0,0 @@
-//! LLM Latency Lens - Enterprise-grade CLI for LLM performance measurement
-//!
-//! This is the main entry point for the CLI application.
-
-use anyhow::Result;
-use clap::Parser;
-use colored::Colorize;
-use std::sync::Arc;
-use tokio::signal;
-use tracing::{error, info};
-
-mod adapters;
-mod agents;
-mod benchmarks;
-mod cli;
-mod config;
-mod orchestrator;
-
-use cli::{Cli, Commands};
-use config::Config;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    // Parse CLI arguments
-    let cli = Cli::parse();
-
-    // Initialize logging based on verbosity
-    init_logging(&cli)?;
-
-    // Print banner if not in quiet or JSON mode
-    if !cli.quiet && !cli.json {
-        print_banner();
-    }
-
-    // Setup Ctrl+C handler
-    let shutdown_signal = setup_shutdown_handler();
-
-    // Run the appropriate command
-    let result = match cli.command {
-        Commands::Profile(args) => {
-            let config = Config::load(&args.config)?;
-            cli::commands::profile::run(args, config, cli.json, cli.quiet, shutdown_signal).await
-        }
-        Commands::Benchmark(args) => {
-            let config = Config::load(&args.config)?;
-            cli::commands::benchmark::run(args, config, cli.json, cli.quiet, shutdown_signal).await
-        }
-        Commands::Compare(args) => {
-            let config = Config::load(&args.config)?;
-            cli::commands::compare::run(args, config, cli.json, cli.quiet, shutdown_signal).await
-        }
-        Commands::Validate(args) => {
-            let config = Config::load(&args.config)?;
-            cli::commands::validate::run(args, config, cli.json, cli.quiet).await
-        }
-        Commands::Export(args) => {
-            cli::commands::export::run(args, cli.json, cli.quiet).await
-        }
-        Commands::Run(args) => {
-            let config = Config::load(&args.config)?;
-            cli::commands::run::run(args, config, cli.json, cli.quiet).await
-        }
-        Commands::Analyze(args) => {
-            cli::commands::analyze::execute(&args, cli.json).await
-        }
-        Commands::Inspect(args) => {
-            cli::commands::inspect::execute(&args, cli.json).await
-        }
-        Commands::Replay(args) => {
-            cli::commands::replay::execute(&args, cli.json).await
-        }
-        Commands::Serve(args) => {
-            cli::commands::serve::run(args).await
-        }
-        Commands::ColdStart(args) => {
-            use cli::ColdStartSubcommand;
-            match args.subcommand {
-                ColdStartSubcommand::Profile(profile_args) => {
-                    let config = Config::load(&profile_args.config)?;
-                    cli::commands::cold_start::run_profile(profile_args, config, cli.json, cli.quiet, shutdown_signal).await
-                }
-                ColdStartSubcommand::Inspect(inspect_args) => {
-                    let config = Config::load(&None)?;
-                    cli::commands::cold_start::run_inspect(inspect_args, config, cli.json, cli.quiet).await
-                }
-                ColdStartSubcommand::Replay(replay_args) => {
-                    let config = Config::load(&None)?;
-                    cli::commands::cold_start::run_replay(replay_args, config, cli.json, cli.quiet).await
-                }
-            }
-        }
-    };
-
-    // Handle errors gracefully
-    if let Err(e) = result {
-        if !cli.quiet {
-            eprintln!("{} {}", "Error:".red().bold(), e);
-
-            // Print error chain
-            let mut source = e.source();
-            while let Some(err) = source {
-                eprintln!("  {} {}", "Caused by:".red(), err);
-                source = err.source();
-            }
-        }
-        std::process::exit(1);
-    }
-
-    Ok(())
-}
-
-/// Initialize logging based on verbosity level
-fn init_logging(cli: &Cli) -> Result<()> {
-    use tracing_subscriber::{fmt, EnvFilter, prelude::*};
-
-    let env_filter = if cli.verbose > 0 {
-        // Map verbose flags to log levels
-        match cli.verbose {
-            1 => EnvFilter::new("llm_latency_lens=debug"),
-            2 => EnvFilter::new("llm_latency_lens=trace,llm_latency_lens_providers=debug"),
-            _ => EnvFilter::new("trace"),
-        }
-    } else if cli.quiet {
-        EnvFilter::new("error")
-    } else {
-        EnvFilter::try_from_default_env()
-            .unwrap_or_else(|_| EnvFilter::new("llm_latency_lens=info"))
-    };
-
-    let fmt_layer = if cli.json {
-        fmt::layer()
-            .json()
-            .with_current_span(false)
-            .with_span_list(false)
-            .boxed()
-    } else {
-        fmt::layer()
-            .with_target(false)
-            .with_thread_ids(false)
-            .with_thread_names(false)
-            .compact()
-            .boxed()
-    };
-
-    tracing_subscriber::registry()
-        .with(env_filter)
-        .with(fmt_layer)
-        .init();
-
-    Ok(())
-}
-
-/// Setup graceful shutdown handler for Ctrl+C
-fn setup_shutdown_handler() -> Arc<tokio::sync::Notify> {
-    let notify = Arc::new(tokio::sync::Notify::new());
-    let notify_clone = Arc::clone(&notify);
-
-    tokio::spawn(async move {
-        if let Err(e) = signal::ctrl_c().await {
-            error!("Failed to listen for Ctrl+C: {}", e);
-            return;
-        }
-
-        info!("Received shutdown signal (Ctrl+C)");
-        notify_clone.notify_waiters();
-    });
-
-    notify
-}
-
-/// Print a beautiful banner
-fn print_banner() {
-    let banner = format!(
-        r#"
-╔═══════════════════════════════════════════════════════════════╗
-║                                                               ║
-║    {}  {}                           ║
-║                                                               ║
-║    {}                ║
-║    {}                     ║
-║                                                               ║
-╚═══════════════════════════════════════════════════════════════╝
-"#,
-        "LLM Latency Lens".bright_cyan().bold(),
-        format!("v{}", env!("CARGO_PKG_VERSION")).bright_black(),
-        "Enterprise-grade LLM performance profiler".bright_white(),
-        format!("Measure • Benchmark • Optimize").bright_green()
-    );
-
-    println!("{}", banner);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_cli_parsing() {
-        use clap::CommandFactory;
-
-        // Verify CLI can be built without errors
-        let _cli = Cli::command();
-    }
-
-    #[test]
-    fn test_version() {
-        let version = env!("CARGO_PKG_VERSION");
-        assert!(!version.is_empty());
-    }
-}