vllora 0.1.23

AI gateway for managing and routing LLM requests - Govern, Secure, and Optimize your AI Traffic.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use crate::CliError;
use prettytable::{row, Table};
use vllora_core::mcp::server::tools::{GetRecentOverviewParams, GetRecentOverviewResponse};
use vllora_core::mcp::server::VlloraMcp;
use vllora_core::metadata::services::trace::TraceServiceImpl as MetadataTraceServiceImpl;
use vllora_core::rmcp;

type VlloraMcpInstance = VlloraMcp<MetadataTraceServiceImpl>;

pub fn format_recent_stats_table(response: &GetRecentOverviewResponse) {
    // Time window info
    let mut window_table = Table::new();
    window_table.add_row(row![bF=> "Field", "Value"]);
    window_table.add_row(row![
        "Window Size",
        format!("{} minutes", response.window_minutes)
    ]);
    window_table.add_row(row!["Window Start", response.window_start]);
    window_table.add_row(row!["Window End", response.window_end]);

    println!("Time Window:");
    window_table.printstd();

    // LLM calls statistics
    if !response.llm_calls.is_empty() {
        let mut llm_table = Table::new();
        llm_table.add_row(row![bF=> "Model", "OK", "Errors", "Total"]);

        for llm in &response.llm_calls {
            llm_table.add_row(row![
                llm.model,
                llm.ok_count,
                llm.error_count,
                llm.total_count,
            ]);
        }

        // Calculate totals
        let total_ok: i64 = response.llm_calls.iter().map(|l| l.ok_count).sum();
        let total_errors: i64 = response.llm_calls.iter().map(|l| l.error_count).sum();
        let total_calls: i64 = response.llm_calls.iter().map(|l| l.total_count).sum();

        llm_table.add_row(row![
            bF-> "TOTAL",
            total_ok,
            total_errors,
            total_calls,
        ]);

        println!(
            "\nLLM Calls by Model ({} models):",
            response.llm_calls.len()
        );
        llm_table.printstd();
    } else {
        println!("\nLLM Calls: None");
    }

    // Tool calls statistics
    if !response.tool_calls.is_empty() {
        let mut tools_table = Table::new();
        tools_table.add_row(row![bF=> "Tool Name", "OK", "Errors", "Total"]);

        for tool in &response.tool_calls {
            tools_table.add_row(row![
                tool.tool_name,
                tool.ok_count,
                tool.error_count,
                tool.total_count,
            ]);
        }

        // Calculate totals
        let total_ok: i64 = response.tool_calls.iter().map(|t| t.ok_count).sum();
        let total_errors: i64 = response.tool_calls.iter().map(|t| t.error_count).sum();
        let total_calls: i64 = response.tool_calls.iter().map(|t| t.total_count).sum();

        tools_table.add_row(row![
            bF-> "TOTAL",
            total_ok,
            total_errors,
            total_calls,
        ]);

        println!(
            "\nTool Calls by Tool ({} tools):",
            response.tool_calls.len()
        );
        tools_table.printstd();
    } else {
        println!("\nTool Calls: None");
    }
}

pub async fn handle_overview(
    vllora_mcp: &VlloraMcpInstance,
    last_n_minutes: i64,
    output: String,
) -> Result<(), CliError> {
    let params = GetRecentOverviewParams { last_n_minutes };

    // Call VlloraMcp::get_recent_stats
    let result = vllora_mcp
        .get_recent_stats(rmcp::handler::server::wrapper::Parameters(params))
        .await
        .map_err(|e| CliError::CustomError(e.to_string()))?;

    // Format output based on user preference
    match output.as_str() {
        "json" => {
            println!("{}", serde_json::to_string_pretty(&result.0)?);
        }
        _ => {
            format_recent_stats_table(&result.0);
        }
    }
    Ok(())
}