wiremux 0.2.1

Reserved.
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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

//! Usage field mapping. Zero cache counts omit cache keys on encode.

use serde_json::{Value, json};

use crate::ir::IrStreamEvent;

use super::u32_field;

pub(crate) fn from_chat(usage: &Value) -> IrStreamEvent {
    let cache_read = nested_u32(usage, "prompt_tokens_details", "cached_tokens")
        .filter(|&n| n > 0)
        .or_else(|| u32_field(usage, "cached_tokens").filter(|&n| n > 0))
        .or_else(|| u32_field(usage, "prompt_cache_hit_tokens"))
        .unwrap_or(0);
    let cache_write = nested_u32(usage, "prompt_tokens_details", "cache_write_tokens").unwrap_or(0);
    let reasoning = nested_u32(usage, "completion_tokens_details", "reasoning_tokens").unwrap_or(0);
    IrStreamEvent::Usage {
        prompt_tokens: u32_field(usage, "prompt_tokens")
            .unwrap_or(0)
            .saturating_sub(cache_read),
        completion_tokens: u32_field(usage, "completion_tokens")
            .unwrap_or(0)
            .saturating_sub(reasoning),
        cache_read_tokens: cache_read,
        cache_write_tokens: cache_write,
        reasoning_tokens: reasoning,
    }
}

pub(super) fn from_anthropic(usage: &Value) -> IrStreamEvent {
    let reasoning = nested_u32(usage, "output_tokens_details", "thinking_tokens").unwrap_or(0);
    IrStreamEvent::Usage {
        prompt_tokens: u32_field(usage, "input_tokens").unwrap_or(0),
        completion_tokens: u32_field(usage, "output_tokens")
            .unwrap_or(0)
            .saturating_sub(reasoning),
        cache_read_tokens: u32_field(usage, "cache_read_input_tokens").unwrap_or(0),
        cache_write_tokens: u32_field(usage, "cache_creation_input_tokens").unwrap_or(0),
        reasoning_tokens: reasoning,
    }
}

pub(super) fn from_responses(usage: &Value) -> IrStreamEvent {
    let cache_read = nested_u32(usage, "input_tokens_details", "cached_tokens").unwrap_or(0);
    let reasoning = nested_u32(usage, "output_tokens_details", "reasoning_tokens").unwrap_or(0);
    IrStreamEvent::Usage {
        prompt_tokens: u32_field(usage, "input_tokens")
            .unwrap_or(0)
            .saturating_sub(cache_read),
        completion_tokens: u32_field(usage, "output_tokens")
            .unwrap_or(0)
            .saturating_sub(reasoning),
        cache_read_tokens: cache_read,
        cache_write_tokens: 0,
        reasoning_tokens: reasoning,
    }
}

pub(super) fn from_gemini(usage: &Value) -> IrStreamEvent {
    let cache_read = u32_field(usage, "cachedContentTokenCount")
        .or_else(|| u32_field(usage, "cached_content_token_count"))
        .unwrap_or(0);
    let reasoning = u32_field(usage, "thoughtsTokenCount")
        .or_else(|| u32_field(usage, "thoughts_token_count"))
        .unwrap_or(0);
    let prompt = u32_field(usage, "promptTokenCount")
        .or_else(|| u32_field(usage, "prompt_token_count"))
        .unwrap_or(0);
    let completion = u32_field(usage, "candidatesTokenCount")
        .or_else(|| u32_field(usage, "candidates_token_count"))
        .unwrap_or(0);
    IrStreamEvent::Usage {
        prompt_tokens: prompt.saturating_sub(cache_read),
        completion_tokens: completion,
        cache_read_tokens: cache_read,
        cache_write_tokens: 0,
        reasoning_tokens: reasoning,
    }
}

pub(super) fn encode_chat(
    prompt_tokens: u32,
    completion_tokens: u32,
    cache_read_tokens: u32,
    cache_write_tokens: u32,
    reasoning_tokens: u32,
) -> Value {
    let prompt_wire = prompt_tokens.saturating_add(cache_read_tokens);
    let completion_wire = completion_tokens.saturating_add(reasoning_tokens);
    let mut usage = json!({
        "prompt_tokens": prompt_wire,
        "completion_tokens": completion_wire,
        "total_tokens": prompt_wire.saturating_add(completion_wire),
    });
    if cache_read_tokens > 0 || cache_write_tokens > 0 {
        let mut details = json!({});
        if cache_read_tokens > 0 {
            details["cached_tokens"] = json!(cache_read_tokens);
        }
        if cache_write_tokens > 0 {
            details["cache_write_tokens"] = json!(cache_write_tokens);
        }
        usage["prompt_tokens_details"] = details;
    }
    if reasoning_tokens > 0 {
        usage["completion_tokens_details"] = json!({ "reasoning_tokens": reasoning_tokens });
    }
    json!({ "choices": [], "usage": usage })
}

pub(super) fn encode_anthropic(
    prompt_tokens: u32,
    completion_tokens: u32,
    cache_read_tokens: u32,
    cache_write_tokens: u32,
    reasoning_tokens: u32,
) -> Value {
    let mut usage = json!({
        "input_tokens": prompt_tokens,
        "output_tokens": completion_tokens.saturating_add(reasoning_tokens),
    });
    if cache_read_tokens > 0 {
        usage["cache_read_input_tokens"] = json!(cache_read_tokens);
    }
    if cache_write_tokens > 0 {
        usage["cache_creation_input_tokens"] = json!(cache_write_tokens);
    }
    if reasoning_tokens > 0 {
        usage["output_tokens_details"] = json!({ "thinking_tokens": reasoning_tokens });
    }
    json!({
        "type": "message_delta",
        "delta": {},
        "usage": usage,
    })
}

pub(super) fn encode_responses(
    prompt_tokens: u32,
    completion_tokens: u32,
    cache_read_tokens: u32,
    reasoning_tokens: u32,
) -> Value {
    let mut usage = json!({
        "input_tokens": prompt_tokens.saturating_add(cache_read_tokens),
        "output_tokens": completion_tokens.saturating_add(reasoning_tokens),
    });
    if cache_read_tokens > 0 {
        usage["input_tokens_details"] = json!({ "cached_tokens": cache_read_tokens });
    }
    if reasoning_tokens > 0 {
        usage["output_tokens_details"] = json!({ "reasoning_tokens": reasoning_tokens });
    }
    json!({
        "type": "response.completed",
        "response": { "status": "completed", "usage": usage },
    })
}

pub(super) fn encode_gemini(
    prompt_tokens: u32,
    completion_tokens: u32,
    cache_read_tokens: u32,
    reasoning_tokens: u32,
) -> Value {
    let mut usage = json!({
        "promptTokenCount": prompt_tokens.saturating_add(cache_read_tokens),
        "candidatesTokenCount": completion_tokens,
    });
    if cache_read_tokens > 0 {
        usage["cachedContentTokenCount"] = json!(cache_read_tokens);
    }
    if reasoning_tokens > 0 {
        usage["thoughtsTokenCount"] = json!(reasoning_tokens);
    }
    json!({ "usageMetadata": usage })
}

fn nested_u32(value: &Value, object: &str, key: &str) -> Option<u32> {
    u32_field(value.get(object)?, key)
}