xonecas.io
79113
Ma

mini-coding-agent / files

mini-coding-agent / src / tui / usage.zig

4.1 KB
1const std = @import("std");
2const message_mod = @import("../message.zig");
3const models = @import("../models.zig");
4const styles = @import("styles.zig");
5
6fn lastAssistantIndex(messages: []const message_mod.Message) ?usize {
7    var found: ?usize = null;
8    for (messages, 0..) |m, i| {
9        if (m != .assistant) continue;
10        const am = m.assistant;
11        if (am.stop_reason == .aborted or am.stop_reason == .err) continue;
12        if (am.usage.total_tokens == 0) continue;
13        found = i;
14    }
15    return found;
16}
17
18pub fn estimateContextTokens(messages: []const message_mod.Message, system_prompt: []const u8, tools_json: []const u8) u64 {
19    if (lastAssistantIndex(messages)) |idx| {
20        var trailing: u64 = 0;
21        for (messages[idx + 1 ..]) |m| trailing += estimateMessageTokens(m);
22        return messages[idx].assistant.usage.total_tokens + trailing;
23    }
24    var total: u64 = 0;
25    for (messages) |m| total += estimateMessageTokens(m);
26    return total + estimateTextTokens(system_prompt) + estimateTextTokens(tools_json);
27}
28
29fn estimateTextTokens(text: []const u8) u64 {
30    return (text.len + 3) / 4;
31}
32
33fn estimateMessageTokens(m: message_mod.Message) u64 {
34    return switch (m) {
35        .user => |u| estimateTextTokens(u.content),
36        .tool_result => |t| estimateTextTokens(t.text),
37        .assistant => |am| blk: {
38            var chars: usize = 0;
39            for (am.content.items) |b| switch (b) {
40                .text => |t| chars += t.len,
41                .thinking => |t| chars += t.text.len,
42                .tool_call => |tc| chars += tc.name.len + tc.arguments.len,
43            };
44            break :blk (chars + 3) / 4;
45        },
46    };
47}
48
49pub fn formatTokens(a: std.mem.Allocator, n: u64) []const u8 {
50    if (n < 1000) return std.fmt.allocPrint(a, "{d}", .{n}) catch "";
51    const millions = n >= 1_000_000;
52    const div: f64 = if (millions) 1_000_000.0 else 1000.0;
53    const unit: []const u8 = if (millions) "M" else "k";
54    var buf: [64]u8 = undefined;
55    var num = std.fmt.bufPrint(&buf, "{d:.[1]}", .{ @as(f64, @floatFromInt(n)) / div, if (millions) @as(usize, 2) else 1 }) catch return unit;
56    while (num.len > 0 and num[num.len - 1] == '0') num = num[0 .. num.len - 1];
57    if (num.len > 0 and num[num.len - 1] == '.') num = num[0 .. num.len - 1];
58    return std.fmt.allocPrint(a, "{s}{s}", .{ num, unit }) catch unit;
59}
60
61pub fn contextUsageLine(a: std.mem.Allocator, used: u64, model: *const models.Model) []const u8 {
62    const cw = @max(model.context_window, 1);
63    const percent = @as(f64, @floatFromInt(used)) / @as(f64, @floatFromInt(cw)) * 100.0;
64    const sizes = std.fmt.allocPrint(a, "{s}/{s}", .{ formatTokens(a, used), formatTokens(a, cw) }) catch "";
65    if (used + model.max_tokens > cw) return styles.err(a, std.fmt.allocPrint(a, "ctx full/{s}", .{sizes}) catch "ctx full");
66    const text = std.fmt.allocPrint(a, "ctx {s} {d}%", .{ sizes, @as(u64, @intFromFloat(percent + 0.5)) }) catch "ctx";
67    return if (percent >= 85) styles.warn(a, text) else styles.comment(a, text);
68}
69
70pub fn lastUsage(messages: []const message_mod.Message) message_mod.Usage {
71    const idx = lastAssistantIndex(messages) orelse return .{};
72    return messages[idx].assistant.usage;
73}
74
75pub fn turnUsage(messages: []const message_mod.Message, from: usize) message_mod.Usage {
76    var out: message_mod.Usage = .{};
77    for (messages[@min(from, messages.len)..]) |m| {
78        if (m != .assistant) continue;
79        const am = m.assistant;
80        if (am.stop_reason == .aborted or am.stop_reason == .err) continue;
81        out.input += am.usage.input;
82        out.output += am.usage.output;
83        out.cache_read += am.usage.cache_read;
84        out.cache_write += am.usage.cache_write;
85    }
86    return out;
87}
88
89pub fn cacheLine(a: std.mem.Allocator, usage: message_mod.Usage) []const u8 {
90    const prompt = usage.input + usage.cache_read + usage.cache_write;
91    const pct: u64 = if (prompt == 0)
92        0
93    else
94        @intFromFloat(@as(f64, @floatFromInt(usage.cache_read)) / @as(f64, @floatFromInt(prompt)) * 100.0 + 0.5);
95    return styles.comment(a, std.fmt.allocPrint(a, "cache {d}%", .{pct}) catch "cache");
96}