batuta 0.7.3

Sovereign AI orchestration: autonomous agents, ML serving, code analysis, and transpilation pipelines
Documentation 
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

//! Model management handlers — load, unload, status.

use axum::{extract::State, http::StatusCode, response::Json};

use super::state::BancoState;
use super::types::{ErrorResponse, ModelLoadRequest, ModelStatusResponse};

/// POST /api/v1/models/load — Load a model from path or URI.
pub async fn model_load_handler(
    State(state): State<BancoState>,
    Json(request): Json<ModelLoadRequest>,
) -> Result<Json<ModelStatusResponse>, (StatusCode, Json<ErrorResponse>)> {
    let info = state.model.load(&request.model).map_err(|e| {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse::new(e.to_string(), "model_load_error", 500)),
        )
    })?;

    state.events.emit(&super::events::BancoEvent::ModelLoaded {
        model_id: info.model_id.clone(),
        format: format!("{:?}", info.format).to_lowercase(),
    });

    let tokenizer_mode = {
        #[cfg(feature = "aprender")]
        {
            if state.model.has_bpe_tokenizer() { "bpe" } else { "greedy" }.to_string()
        }
        #[cfg(not(feature = "aprender"))]
        {
            "greedy".to_string()
        }
    };
    Ok(Json(ModelStatusResponse {
        loaded: true,
        model: Some(info),
        uptime_secs: Some(0),
        tokenizer: Some(tokenizer_mode),
    }))
}

/// POST /api/v1/models/unload — Unload the current model.
pub async fn model_unload_handler(
    State(state): State<BancoState>,
) -> Result<StatusCode, (StatusCode, Json<ErrorResponse>)> {
    state
        .model
        .unload()
        .map(|()| {
            state.events.emit(&super::events::BancoEvent::ModelUnloaded);
            StatusCode::NO_CONTENT
        })
        .map_err(|e| {
            (StatusCode::BAD_REQUEST, Json(ErrorResponse::new(e.to_string(), "no_model", 400)))
        })
}

/// GET /api/v1/models/status — Current model status.
pub async fn model_status_handler(State(state): State<BancoState>) -> Json<ModelStatusResponse> {
    let info = state.model.info();
    let loaded = info.is_some();
    let tokenizer = if loaded {
        #[cfg(feature = "aprender")]
        {
            Some(if state.model.has_bpe_tokenizer() { "bpe" } else { "greedy" }.to_string())
        }
        #[cfg(not(feature = "aprender"))]
        {
            Some("greedy".to_string())
        }
    } else {
        None
    };
    Json(ModelStatusResponse {
        loaded,
        model: info,
        uptime_secs: if loaded { Some(state.model.uptime_secs()) } else { None },
        tokenizer,
    })
}