magi-code 0.104.0

Repository-aware CLI coding agent for terminal work
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

use super::bodies::openai_compatible_chat_completions_body;
use super::*;
use crate::providers::{ChatMessage, ProviderConversationItem, ProviderToolResult};
use serde_json::json;

#[test]
#[ignore = "diagnostic-only optimization measurement; run explicitly with --ignored --nocapture"]
fn optimization_harness_measures_large_chat_body_construction() {
    // Large count is fixture data for optimization measurement, not a runtime ceiling.
    let tool_pair_count = 2_000;
    let mut items = vec![ProviderConversationItem::Message(ChatMessage::user(
        "measure body construction",
    ))];
    for index in 0..tool_pair_count {
        items.push(ProviderConversationItem::ResponseItem(json!({
            "type": "function_call",
            "call_id": format!("call_{index}"),
            "name": "read",
            "arguments": {"path": format!("fixtures/{index}.txt")},
            "status": "completed"
        })));
        items.push(ProviderConversationItem::ToolResult(ProviderToolResult {
            call_id: format!("call_{index}"),
            tool_name: "read".to_string(),
            success: true,
            output: format!("file contents {index}"),
            skill_reads: Vec::new(),
            file_reads: Vec::new(),
        }));
    }
    let request = ProviderRequest::from_conversation("model-a", items);

    let started = std::time::Instant::now();
    let body = openai_compatible_chat_completions_body("model-a", &request);
    let elapsed = started.elapsed();
    let messages = body["messages"].as_array().unwrap();

    println!(
        "optimization_harness chat_body tool_pairs={} messages={} elapsed={elapsed:?}",
        tool_pair_count,
        messages.len()
    );
    assert_eq!(messages.len(), 1 + tool_pair_count * 2);

    // Include request projection in a repeated-file workload, not just serialization.
    let mut reads = Vec::new();
    for index in 0..tool_pair_count {
        let path = format!("/fixtures/{}.txt", index % 128);
        let output = format!("[{path}#ABCD]\n1:{}", "read body ".repeat(100));
        let metadata = json!({
            "kind": "file", "path": path, "raw": false, "selector": null,
            "hashline_tag": "ABCD",
            "structured_result": {"files": [{"text": output, "success": true,
                "complete": true, "request_complete": true}]}
        });
        reads.push(ProviderConversationItem::ResponseItem(json!({
            "type": "function_call", "call_id": format!("read_{index}"),
            "name": "read", "arguments": "{}"
        })));
        reads.push(ProviderConversationItem::ToolResult(ProviderToolResult {
            call_id: format!("read_{index}"),
            tool_name: "read".into(),
            success: true,
            file_reads: crate::providers::file_read_provenance::validated_file_reads(
                "read", true, &output, &metadata,
            ),
            output,
            skill_reads: Vec::new(),
        }));
    }
    let mut raw = reads.clone();
    for item in &mut raw {
        if let ProviderConversationItem::ToolResult(result) = item {
            result.file_reads.clear();
        }
    }
    for (label, items) in [("raw_reads", raw), ("projected_reads", reads)] {
        let started = std::time::Instant::now();
        let request = ProviderRequest::from_conversation("model-a", items);
        let body = openai_compatible_chat_completions_body("model-a", &request);
        let elapsed = started.elapsed();
        let encoded = serde_json::to_string(&body).unwrap();
        println!(
            "optimization_harness {label} tool_pairs={tool_pair_count} bytes={} elapsed={elapsed:?}",
            encoded.len()
        );
        if label == "projected_reads" {
            assert_eq!(
                encoded.matches("[unchanged:").count(),
                tool_pair_count - 128
            );
        }
    }
}