rho-coding-agent 1.1.0

A lightweight agent harness inspired by Pi
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

use crate::{
    model::{models_dev, ModelError},
    reasoning::ReasoningLevel,
};

#[derive(Debug, PartialEq, Eq)]
pub(super) struct OpenAiReasoningConfig {
    pub(super) effort: Option<String>,
    pub(super) summary: Option<String>,
}

pub(super) fn normalize_openai_reasoning_level(
    requested: ReasoningLevel,
    supported: Option<&[ReasoningLevel]>,
) -> Option<ReasoningLevel> {
    let Some(supported) = supported else {
        return Some(requested);
    };
    if requested == ReasoningLevel::Off {
        return Some(requested.normalize(Some(supported)));
    }
    let supported = supported
        .iter()
        .copied()
        .filter(|level| *level != ReasoningLevel::Off)
        .collect::<Vec<_>>();
    (!supported.is_empty()).then(|| requested.normalize(Some(&supported)))
}

pub(super) fn openai_reasoning_config(
    provider: &'static str,
    model: &str,
    requested: ReasoningLevel,
) -> Result<OpenAiReasoningConfig, ModelError> {
    let supported = models_dev::cached_reasoning_levels(provider, model);
    let Some(normalized_level) = normalize_openai_reasoning_level(requested, supported.as_deref())
    else {
        return Err(ModelError::UnsupportedReasoning {
            provider,
            model: model.to_string(),
            requested,
        });
    };
    Ok(OpenAiReasoningConfig {
        effort: models_dev::cached_reasoning_effort(provider, model, normalized_level),
        summary: normalized_level.summary().map(str::to_string),
    })
}