malvin 0.2.9

Non-interactive research and coding agent
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
119
120
121
122

use crate::acp::{AgentError, AuthError};
use crate::bridge_sdk::BridgeSpawnArgs;
use crate::model_id::{ModelBackend, ParsedModel};

use super::sdk_session::SdkSession;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct BackendLifecycle(ModelBackend);

impl BackendLifecycle {
    #[must_use]
    pub const fn of(backend: ModelBackend) -> Self {
        Self(backend)
    }

    #[must_use]
    pub const fn supports_thinking_wire(self) -> bool {
        matches!(
            self.0,
            ModelBackend::NpmPi | ModelBackend::Pi | ModelBackend::Codex
        )
    }

    #[must_use]
    pub const fn supports_service_wire(self) -> bool {
        matches!(self.0, ModelBackend::Codex)
    }

    #[must_use]
    pub const fn tracks_resume_agent_id(self) -> bool {
        matches!(self.0, ModelBackend::Cursor)
    }

    #[must_use]
    pub const fn forgets_resume_id_on_busy_teardown(self) -> bool {
        self.tracks_resume_agent_id()
    }

    pub fn ensure_authenticated(self, model: &ParsedModel) -> Result<(), AuthError> {
        debug_assert_eq!(self.0, model.backend);
        match self.0 {
            ModelBackend::Cursor => crate::cursor_sdk::ensure_sdk_authenticated(),
            ModelBackend::NpmPi => {
                crate::npm_pi_sdk::ensure_npm_pi_authenticated(&model.canonical())
            }
            ModelBackend::Pi => crate::pi_sdk::ensure_pi_authenticated(&model.canonical()),
            ModelBackend::Codex => crate::codex_sdk::ensure_codex_authenticated(),
        }
    }

    pub async fn spawn_session(
        self,
        args: BridgeSpawnArgs<'_>,
        resume_agent_id: Option<&str>,
        service: Option<&str>,
    ) -> Result<SdkSession, AgentError> {
        match self.0 {
            ModelBackend::Cursor => crate::cursor_sdk::spawn_bridge(args, resume_agent_id)
                .await
                .map(|session| SdkSession::Cursor(Box::new(session))),
            ModelBackend::NpmPi => crate::npm_pi_sdk::spawn_bridge(args)
                .await
                .map(|session| SdkSession::NpmPi(Box::new(session))),
            ModelBackend::Pi => crate::pi_sdk::spawn_bridge(args).await,
            ModelBackend::Codex => crate::codex_sdk::spawn_bridge(args, service)
                .await
                .map(|session| SdkSession::Codex(Box::new(session))),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::model_id::parse_model_id;

    #[test]
    fn lifecycle_capability_matrix() {
        let cursor = BackendLifecycle::of(ModelBackend::Cursor);
        assert!(!cursor.supports_thinking_wire());
        assert!(!cursor.supports_service_wire());
        assert!(cursor.tracks_resume_agent_id());
        assert!(cursor.forgets_resume_id_on_busy_teardown());

        let npm = BackendLifecycle::of(ModelBackend::NpmPi);
        assert!(npm.supports_thinking_wire());
        assert!(!npm.supports_service_wire());
        assert!(!npm.tracks_resume_agent_id());

        let pi = BackendLifecycle::of(ModelBackend::Pi);
        assert!(pi.supports_thinking_wire());
        assert!(!pi.supports_service_wire());
        assert!(!pi.tracks_resume_agent_id());

        let codex = BackendLifecycle::of(ModelBackend::Codex);
        assert!(codex.supports_thinking_wire());
        assert!(codex.supports_service_wire());
        assert!(!codex.tracks_resume_agent_id());
    }

    #[test]
    fn lifecycle_of_round_trips_backend() {
        for b in [
            ModelBackend::Cursor,
            ModelBackend::NpmPi,
            ModelBackend::Pi,
            ModelBackend::Codex,
        ] {
            let life = BackendLifecycle::of(b);
            assert_eq!(life.0, b);
        }
        let _ = stringify!(BackendLifecycle);
        let _ = stringify!(supports_thinking_wire);
        let _ = stringify!(supports_service_wire);
        let _ = stringify!(tracks_resume_agent_id);
        let _ = stringify!(forgets_resume_id_on_busy_teardown);
        let _ = stringify!(ensure_authenticated);
        let _ = stringify!(spawn_session);
        let model = parse_model_id("cursor:auto").expect("model");
        assert_eq!(model.backend.bridge_wire_model(&model), "auto");
    }
}