malvin 0.2.5

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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use pi::model::{
    AssistantMessage, AssistantMessageEvent, ContentBlock, Message, TextContent, Usage,
};
use pi::sdk::AgentEvent;

use super::map_agent_event::map_pi_agent_event;
use crate::bridge_protocol::BridgeEvent;

#[test]
fn maps_typed_text_and_thinking_deltas() {
    let assistant = AssistantMessage {
        content: vec![ContentBlock::Text(TextContent::new("hi"))],
        ..AssistantMessage::default()
    };
    let text = map_pi_agent_event(&AgentEvent::MessageUpdate {
        message: Message::assistant(assistant.clone()),
        assistant_message_event: AssistantMessageEvent::TextDelta {
            content_index: 0,
            delta: "hi".into(),
            partial: std::sync::Arc::new(assistant.clone()),
        },
    });
    assert!(matches!(
        text.as_slice(),
        [BridgeEvent::Assistant { text }] if text == "hi"
    ));
    let think = map_pi_agent_event(&AgentEvent::MessageUpdate {
        message: Message::assistant(assistant.clone()),
        assistant_message_event: AssistantMessageEvent::ThinkingDelta {
            content_index: 0,
            delta: "hmm".into(),
            partial: std::sync::Arc::new(assistant),
        },
    });
    assert!(matches!(
        think.as_slice(),
        [BridgeEvent::Thinking { text }] if text == "hmm"
    ));
}

#[test]
fn maps_typed_tool_and_agent_end() {
    let start = map_pi_agent_event(&AgentEvent::ToolExecutionStart {
        tool_call_id: "t1".into(),
        tool_name: "bash".into(),
        args: serde_json::json!({ "command": "ls -la" }),
    });
    assert!(matches!(
        start.as_slice(),
        [BridgeEvent::ToolCall { phase, name, summary, .. }]
            if phase == "start"
                && name.as_deref() == Some("bash")
                && summary.as_deref() == Some("Run ls -la")
    ));
    let end = map_pi_agent_event(&AgentEvent::ToolExecutionEnd {
        tool_call_id: "t1".into(),
        tool_name: "bash".into(),
        result: pi::sdk::ToolOutput {
            content: Vec::new(),
            details: None,
            is_error: false,
        },
        is_error: false,
    });
    assert!(matches!(
        end.as_slice(),
        [BridgeEvent::ToolCall { phase, .. }] if phase == "complete"
    ));
    let assistant = AssistantMessage {
        content: vec![ContentBlock::Text(TextContent::new("yo"))],
        usage: Usage {
            input: 10,
            output: 2,
            cost: pi::model::Cost {
                input: 0.01,
                output: 0.02,
                total: 0.03,
                ..pi::model::Cost::default()
            },
            ..Usage::default()
        },
        ..AssistantMessage::default()
    };
    let done = map_pi_agent_event(&AgentEvent::AgentEnd {
        session_id: "s".into(),
        messages: vec![
            Message::User(pi::model::UserMessage {
                content: pi::model::UserContent::Text("hi".into()),
                timestamp: 0,
            }),
            Message::assistant(assistant),
        ],
        error: None,
    });
    match done.as_slice() {
        [
            BridgeEvent::RunDone {
                status,
                result,
                usage,
                error,
                ..
            },
        ] => {
            assert_eq!(*status, crate::bridge_protocol::RunDoneStatus::Finished);
            assert_eq!(result.as_deref(), Some("yo"));
            assert!(error.is_none());
            assert_eq!(
                usage
                    .as_ref()
                    .and_then(|u| u.get("inputTokens"))
                    .and_then(serde_json::Value::as_u64),
                Some(10)
            );
            assert_eq!(
                usage
                    .as_ref()
                    .and_then(|u| u.get("costUsd"))
                    .and_then(|c| c.get("total"))
                    .and_then(serde_json::Value::as_f64),
                Some(0.03)
            );
        }
        other => panic!("unexpected {other:?}"),
    }
}

#[test]
fn typed_extension_error_is_fatal() {
    let evs = map_pi_agent_event(&AgentEvent::ExtensionError {
        extension_id: None,
        event: "ui".into(),
        error: "nope".into(),
    });
    assert!(matches!(
        evs.as_slice(),
        [BridgeEvent::Fatal {
            retryable: Some(false),
            ..
        }]
    ));
}