trusty-mpm 0.9.0

trusty-mpm: unified multi-agent orchestration platform (core, daemon, CLI, TUI, Telegram)
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

//! Tests for [`SessionManagerAgent::health`] (SM-STDIO `sm.health` source).
//!
//! Why: `sm.health` must report `{ ok, provider, degraded, model_tiers }` without
//! a network call. These tests pin the three states — no runtime (inert),
//! degraded resolver, and a healthy mock provider — plus the tier reporting,
//! deterministically with the mock resolver.
//! What: builds the agent feature-aware over a [`MockResolver`] and asserts the
//! [`SmHealth`] shape.
//! Test: this is the test module.

use std::sync::Arc;

use super::super::mock::{MockChatProvider, MockResolver};
use crate::core::sm::agent::SessionManagerAgent;
use crate::core::sm::config::SessionManagerConfig;

/// An enabled SM config (health does not require enablement, but mirrors prod).
fn enabled_config() -> SessionManagerConfig {
    SessionManagerConfig {
        enabled: true,
        ..SessionManagerConfig::default()
    }
}

/// Build an agent over the mock resolver, feature-aware (no memory in tests).
fn agent_with(cfg: SessionManagerConfig, resolver: Arc<MockResolver>) -> SessionManagerAgent {
    let data_root = std::env::temp_dir();
    #[cfg(feature = "sm-memory")]
    {
        SessionManagerAgent::with_runtime(cfg, resolver, data_root, None)
    }
    #[cfg(not(feature = "sm-memory"))]
    {
        SessionManagerAgent::with_runtime(cfg, resolver, data_root)
    }
}

/// Why: an inert agent (built via `new`, no runtime) has no provider, so health
/// must report degraded with `provider = "none"` and `ok = false`.
/// What: builds a `new()` agent and asserts the degraded health shape.
/// Test: this is the test.
#[tokio::test]
async fn health_no_runtime_is_degraded() {
    let agent = SessionManagerAgent::new(enabled_config());
    let health = agent.health().await;
    assert!(!health.ok);
    assert!(health.degraded);
    assert_eq!(health.provider, "none");
}

/// Why: when the resolver reports degraded (no credentials), health must surface
/// graceful degraded mode rather than ok.
/// What: builds an agent over a degraded resolver and asserts degraded health.
/// Test: this is the test.
#[tokio::test]
async fn health_degraded_resolver_is_degraded() {
    let agent = agent_with(enabled_config(), Arc::new(MockResolver::degraded()));
    let health = agent.health().await;
    assert!(!health.ok);
    assert!(health.degraded);
    assert_eq!(health.provider, "none");
}

/// Why: with a resolvable provider, health must report ok + the resolved
/// provider name and NOT degraded.
/// What: builds an agent over a provider resolver; asserts `ok` + provider name.
/// Test: this is the test.
#[tokio::test]
async fn health_with_provider_is_ok() {
    let provider = MockChatProvider::new("unused", 0.0);
    let resolver = Arc::new(MockResolver::with_provider(provider));
    let agent = agent_with(enabled_config(), resolver);
    let health = agent.health().await;
    assert!(health.ok);
    assert!(!health.degraded);
    // The mock resolver tags resolved calls as Anthropic.
    assert_eq!(health.provider, "anthropic");
}

/// Why: health must surface the configured per-tier model ids so an operator can
/// confirm the deployment is wired as intended.
/// What: asserts the orchestration/summary/compaction model ids match the
/// default config tiers.
/// Test: this is the test.
#[tokio::test]
async fn health_reports_model_tiers() {
    let provider = MockChatProvider::new("unused", 0.0);
    let resolver = Arc::new(MockResolver::with_provider(provider));
    let agent = agent_with(enabled_config(), resolver);
    let health = agent.health().await;
    assert_eq!(
        health.model_tiers.orchestration,
        "anthropic/claude-sonnet-4-6"
    );
    assert_eq!(health.model_tiers.summary, "anthropic/claude-haiku");
    // Compaction falls back to summary when unset.
    assert_eq!(health.model_tiers.compaction, "anthropic/claude-haiku");
}