replysieve 0.1.0

Judge comments in a fraction of a second: approve, reject or needs-review with a reason, from small decision models on OpenRouter. CLI, MCP server and Rust library.
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
82
83

//! OpenRouter decisions endpoint client.

use serde::Deserialize;
use std::collections::HashMap;
use std::time::Duration;

/// Default OpenRouter base URL.
pub const DEFAULT_BASE_URL: &str = "https://openrouter.ai";

/// One typed answer from a decision model.
#[derive(Debug, Clone, Deserialize)]
#[serde(tag = "type", rename_all = "lowercase")]
pub(crate) enum Answer {
    Choice {
        #[allow(dead_code)]
        choice: String,
        probabilities: HashMap<String, f64>,
    },
    Noul {
        noul: f64,
    },
    #[serde(other)]
    Other,
}

#[derive(Debug, Deserialize)]
pub(crate) struct Response {
    pub model: String,
    pub answers: HashMap<String, Answer>,
}

#[derive(Debug, Clone)]
pub(crate) struct Client {
    http: reqwest::Client,
    url: String,
    key: String,
}

impl Client {
    pub fn new(base_url: &str, key: String) -> Self {
        let http = reqwest::Client::builder()
            .timeout(Duration::from_secs(10))
            .user_agent(concat!("replysieve/", env!("CARGO_PKG_VERSION")))
            .build()
            .expect("HTTP client builds with static settings");
        Client {
            http,
            url: format!("{}/api/alpha/decisions", base_url.trim_end_matches('/')),
            key,
        }
    }

    /// Ask one model. The error string never contains comment text.
    pub async fn decide(
        &self,
        model: &str,
        state: &str,
        questions: &serde_json::Value,
    ) -> Result<Response, String> {
        let body = serde_json::json!({ "model": model, "state": state, "questions": questions });
        let resp = self
            .http
            .post(&self.url)
            .bearer_auth(&self.key)
            .json(&body)
            .send()
            .await
            .map_err(|e| {
                if e.is_timeout() {
                    "timed out".to_string()
                } else {
                    "request failed".to_string()
                }
            })?;
        let status = resp.status();
        if !status.is_success() {
            return Err(format!("HTTP {}", status.as_u16()));
        }
        resp.json::<Response>()
            .await
            .map_err(|_| "unreadable response".to_string())
    }
}