whycodes-session 0.6.31

Conversation state, history and compaction for WhyCodes
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
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
143
144
145
146
147
148
149
150

use super::*;
use whycodes_core::types::{ContentBlock, ImageSource, MessageContent};

fn call(id: &str, name: &str) -> ToolCall {
    ToolCall {
        id: id.into(),
        name: name.into(),
        arguments: serde_json::json!({}),
    }
}

fn result(id: &str, is_error: bool) -> ToolResult {
    ToolResult {
        tool_call_id: id.into(),
        content: "out".into(),
        is_error,
    }
}

fn todo(status: TodoStatus) -> TodoItem {
    TodoItem {
        id: String::new(),
        content: "x".into(),
        status,
    }
}

#[test]
fn records_requests_per_model_and_tools_with_failures() {
    let mut run = RunStats::default();
    let usage = Usage {
        input_tokens: 1_500,
        output_tokens: 20,
        ..Default::default()
    };
    run.record_request("cf", "glm", &usage);
    run.record_request("cf", "glm", &Usage::default());
    run.record_request("cf", "kimi", &usage);
    run.record_tools(
        &[call("a", "bash"), call("b", "bash"), call("c", "read")],
        &[result("a", true), result("b", false), result("c", false)],
    );

    assert_eq!(run.requests(), 3);
    assert_eq!(
        run.models["cf/glm"],
        ModelTally {
            requests: 2,
            input_tokens: 1_500,
            output_tokens: 20
        }
    );
    assert_eq!(run.tool_calls(), 3);
    assert_eq!(run.tool_errors(), 1);
    assert_eq!(
        run.tools["bash"],
        ToolTally {
            calls: 2,
            errors: 1
        }
    );
}

#[test]
fn prompt_count_skips_notes_summaries_and_tool_carriers() {
    let mut s = Session::new("/p".into(), "sys".into());
    s.add_user_message("fix it");
    s.add_user_message("   ");
    s.add_user_message("[Compacted] 1. Primary Request: x");
    s.add_user_message("note");
    if let Some(m) = s.messages.last_mut() {
        m.name = Some(whycodes_core::types::AGENT_NOTE_NAME.into());
    }
    s.add_user_message("blocks");
    if let Some(m) = s.messages.last_mut() {
        m.content = MessageContent::Blocks(vec![ContentBlock::Image {
            source: ImageSource::Url {
                url: "a.png".into(),
            },
        }]);
    }
    s.add_user_message("carrier");
    if let Some(m) = s.messages.last_mut() {
        m.content = MessageContent::Blocks(vec![ContentBlock::ToolResult {
            tool_use_id: "t".into(),
            content: "r".into(),
            is_error: None,
        }]);
    }
    s.add_assistant_message(vec![ContentBlock::Text { text: "ok".into() }]);

    assert_eq!(s.prompt_count(), 2);
}

#[test]
fn report_lists_models_tools_subagents_and_todos() {
    let mut s = Session::new("/p".into(), "sys".into());
    s.add_user_message("go");
    s.usage.input_tokens = 2_500_000;
    s.usage.output_tokens = 999;
    s.run_stats.record_request("cf", "glm", &s.usage.clone());
    s.run_stats.record_tools(
        &[call("a", "task"), call("b", "bash"), call("c", "bash")],
        &[result("a", false), result("b", true), result("c", false)],
    );
    let todos = [
        todo(TodoStatus::Completed),
        todo(TodoStatus::InProgress),
        todo(TodoStatus::Pending),
        todo(TodoStatus::Cancelled),
    ];
    let now = s.created_at + chrono::Duration::minutes(75);

    let out = stats_report(&s, &todos, now);

    assert!(out.contains("duration:  1h 15m"), "{out}");
    assert!(out.contains("prompts:   1"), "{out}");
    assert!(out.contains("requests:  1 this run"), "{out}");
    assert!(
        out.contains("cf/glm: 1 request · 2.5M in / 999 out"),
        "{out}"
    );
    assert!(out.contains("tools:     3 calls · 1 failed"), "{out}");
    assert!(out.contains("bash 2 (1 failed) · task 1"), "{out}");
    assert!(out.contains("subagents: 1 launched"), "{out}");
    assert!(
        out.contains("todos:     1/4 done · 1 in progress · 1 pending · 1 cancelled"),
        "{out}"
    );
    assert!(out.contains("tokens:    2.5M in / 999 out"), "{out}");
}

#[test]
fn report_on_a_fresh_session_shows_zeroes() {
    let s = Session::new("/p".into(), "sys".into());
    let out = stats_report(&s, &[], s.created_at + chrono::Duration::seconds(30));

    assert!(out.contains("duration:  0m"), "{out}");
    assert!(out.contains("requests:  0 this run"), "{out}");
    assert!(out.contains("tools:     0 calls · 0 failed"), "{out}");
    assert!(out.contains("subagents: 0 launched"), "{out}");
    assert!(out.contains("todos:     0/0 done"), "{out}");
}

#[test]
fn compact_scales_thousands() {
    assert_eq!(compact(12_300), "12.3k");
    assert_eq!(compact(7), "7");
    assert_eq!(compact(3_000_000), "3.0M");
}