Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864const std = @import("std");const types = @import("../shared/types.zig");const sort_utils = @import("../shared/sort_utils.zig");
const Allocator = std.mem.Allocator;
const max_model_bytes: usize = 1024;const max_models: usize = 128;
pub const Scope = enum { session, hours_24, days_7, days_30,
pub fn label(self: Scope) []const u8 { return switch (self) { .session => "Session", .hours_24 => "24 hours", .days_7 => "7 days", .days_30 => "30 days", }; }
pub fn cliValue(self: Scope) ?[]const u8 { return switch (self) { .session => null, .hours_24 => "24h", .days_7 => "7d", .days_30 => "30d", }; }
fn durationMs(self: Scope) ?i64 { return switch (self) { .session => null, .hours_24 => std.time.ms_per_hour * 24, .days_7 => std.time.ms_per_day * 7, .days_30 => std.time.ms_per_day * 30, }; }
pub fn previous(self: Scope) Scope { return switch (self) { .session => .session, .hours_24 => .session, .days_7 => .hours_24, .days_30 => .days_7, }; }
pub fn next(self: Scope) Scope { return switch (self) { .session => .hours_24, .hours_24 => .days_7, .days_7 => .days_30, .days_30 => .days_30, }; }};
pub fn formatUtcDate(buf: *[24]u8, timestamp_ms: i64) []const u8 { if (timestamp_ms < 0) return "Unknown"; const seconds: u64 = @intCast(@divFloor(timestamp_ms, std.time.ms_per_s)); const epoch_seconds: std.time.epoch.EpochSeconds = .{ .secs = seconds }; const year_day = epoch_seconds.getEpochDay().calculateYearDay(); const month_day = year_day.calculateMonthDay(); const month = switch (month_day.month.numeric()) { 1 => "Jan", 2 => "Feb", 3 => "Mar", 4 => "Apr", 5 => "May", 6 => "Jun", 7 => "Jul", 8 => "Aug", 9 => "Sep", 10 => "Oct", 11 => "Nov", 12 => "Dec", else => return "Unknown", }; return std.fmt.bufPrint( buf, "{s} {d}, {d}", .{ month, month_day.day_index + 1, year_day.year }, ) catch "Unknown";}
pub const Completeness = enum { complete, pending, incomplete, legacy,};
pub const Coverage = enum { not_started, partial, full,};
pub const Incident = struct { occurred_at_ms: i64, completeness: Completeness,};
pub const PendingMarker = struct { id: []u8, observed_at_ms: i64,
pub fn deinit(self: *PendingMarker, alloc: Allocator) void { alloc.free(self.id); self.* = undefined; }
pub fn dupe(self: PendingMarker, alloc: Allocator) Allocator.Error!PendingMarker { return .{ .id = try alloc.dupe(u8, self.id), .observed_at_ms = self.observed_at_ms, }; }
pub fn eql(first: PendingMarker, second: PendingMarker) bool { return std.mem.eql(u8, first.id, second.id) and first.observed_at_ms == second.observed_at_ms; }};
pub const GenerationFact = struct { id: []u8, created_at_ms: i64, model: []u8, input_tokens: u64, output_tokens: u64, cache_read_tokens: u64, cache_write_tokens: u64, reasoning_tokens: ?u64, billable_web_search_calls: u64 = 0, total_cost: f64,
pub fn deinit(self: *GenerationFact, alloc: Allocator) void { alloc.free(self.id); alloc.free(self.model); self.* = undefined; }
pub fn dupe(self: GenerationFact, alloc: Allocator) Allocator.Error!GenerationFact { const id = try alloc.dupe(u8, self.id); errdefer alloc.free(id); return .{ .id = id, .created_at_ms = self.created_at_ms, .model = try alloc.dupe(u8, self.model), .input_tokens = self.input_tokens, .output_tokens = self.output_tokens, .cache_read_tokens = self.cache_read_tokens, .cache_write_tokens = self.cache_write_tokens, .reasoning_tokens = self.reasoning_tokens, .billable_web_search_calls = self.billable_web_search_calls, .total_cost = self.total_cost, }; }
pub fn eql(first: GenerationFact, second: GenerationFact) bool { return std.mem.eql(u8, first.id, second.id) and first.created_at_ms == second.created_at_ms and std.mem.eql(u8, first.model, second.model) and first.input_tokens == second.input_tokens and first.output_tokens == second.output_tokens and first.cache_read_tokens == second.cache_read_tokens and first.cache_write_tokens == second.cache_write_tokens and first.reasoning_tokens == second.reasoning_tokens and first.billable_web_search_calls == second.billable_web_search_calls and first.total_cost == second.total_cost; }};
pub const ProfileEvent = union(enum) { generation: GenerationFact, pending: PendingMarker, incident: Incident,};
pub const Totals = struct { total_tokens: u64, input_tokens: u64, output_tokens: u64, cache_read_tokens: u64, cache_write_tokens: u64, reasoning_tokens: ?u64, request_count: ?u64, total_cost: f64,};
pub const ModelUsage = struct { model: []u8, totals: Totals,
pub fn deinit(self: *ModelUsage, alloc: Allocator) void { alloc.free(self.model); self.* = undefined; }};
pub const SessionActivity = struct { api_duration_complete: bool, wall_duration_complete: bool, code_complete: bool, api_duration_ms: u64, wall_duration_ms: u64, lines_added: u64, lines_removed: u64,};
pub const SessionModelSource = struct { model: []const u8, total_cost: f64, input_tokens: u64, output_tokens: u64, cache_read_tokens: u64, cache_write_tokens: u64, reasoning_tokens: ?u64, request_count: ?u64,};
pub const SessionSource = struct { snapshot_time_ms: i64, session_started_at_ms: i64, completeness: Completeness, total_cost: f64, input_tokens: u64, output_tokens: u64, cache_read_tokens: u64, cache_write_tokens: u64, reasoning_tokens: ?u64, request_count: ?u64, models: []const SessionModelSource, activity: SessionActivity,};
pub const Snapshot = struct { scope: Scope, snapshot_time_ms: i64, window_start_ms: i64, coverage_started_at_ms: ?i64, coverage: Coverage, completeness: Completeness, totals: ?Totals, models: []ModelUsage, session_activity: ?SessionActivity = null,
pub fn deinit(self: *Snapshot, alloc: Allocator) void { for (self.models) |*model| model.deinit(alloc); alloc.free(self.models); self.* = undefined; }};
pub const BuildError = Allocator.Error || error{ InvalidGenerationFact, InvalidSnapshotTime, UsageCapacityExceeded, UsageOverflow,};
const MutableTotals = struct { input_tokens: u64 = 0, output_tokens: u64 = 0, cache_read_tokens: u64 = 0, cache_write_tokens: u64 = 0, reasoning_tokens: ?u64 = 0, request_count: u64 = 0, total_cost: f64 = 0,
fn add(self: *MutableTotals, fact: GenerationFact) error{UsageOverflow}!void { self.input_tokens = std.math.add(u64, self.input_tokens, fact.input_tokens) catch return error.UsageOverflow; self.output_tokens = std.math.add(u64, self.output_tokens, fact.output_tokens) catch return error.UsageOverflow; self.cache_read_tokens = std.math.add( u64, self.cache_read_tokens, fact.cache_read_tokens, ) catch return error.UsageOverflow; self.cache_write_tokens = std.math.add( u64, self.cache_write_tokens, fact.cache_write_tokens, ) catch return error.UsageOverflow; self.request_count = std.math.add(u64, self.request_count, 1) catch return error.UsageOverflow; self.reasoning_tokens = if (self.reasoning_tokens) |current| if (fact.reasoning_tokens) |reasoning| std.math.add(u64, current, reasoning) catch return error.UsageOverflow else null else null; const next_cost = self.total_cost + fact.total_cost; if (!std.math.isFinite(next_cost)) return error.UsageOverflow; self.total_cost = next_cost; }
fn freeze(self: MutableTotals, request_count_available: bool) error{UsageOverflow}!Totals { return .{ .total_tokens = std.math.add( u64, self.input_tokens, self.output_tokens, ) catch return error.UsageOverflow, .input_tokens = self.input_tokens, .output_tokens = self.output_tokens, .cache_read_tokens = self.cache_read_tokens, .cache_write_tokens = self.cache_write_tokens, .reasoning_tokens = if (self.request_count == 0) null else self.reasoning_tokens, .request_count = if (request_count_available) self.request_count else null, .total_cost = self.total_cost, }; }};
const MutableModel = struct { model: []u8, totals: MutableTotals = .{},
fn deinit(self: *MutableModel, alloc: Allocator) void { alloc.free(self.model); self.* = undefined; }};
/// Converts an authoritative session aggregate into the same owned projection/// used by rolling usage. Session arithmetic is copied, never reconstructed/// from the model rows.pub fn buildSessionSnapshot( alloc: Allocator, source: SessionSource,) BuildError!Snapshot { if (source.snapshot_time_ms < 0 or source.session_started_at_ms < 0 or source.session_started_at_ms > source.snapshot_time_ms or !std.math.isFinite(source.total_cost) or source.total_cost < 0 or source.cache_read_tokens > source.input_tokens or source.cache_write_tokens > source.input_tokens) { return error.InvalidSnapshotTime; } if (source.reasoning_tokens) |reasoning| { if (reasoning > source.output_tokens) return error.InvalidGenerationFact; }
if (source.completeness == .legacy) { var snapshot = try emptySnapshot( alloc, .session, source.snapshot_time_ms, source.session_started_at_ms, source.session_started_at_ms, .full, source.completeness, ); snapshot.session_activity = source.activity; return snapshot; } if (source.models.len > max_models) return error.UsageCapacityExceeded;
const total_tokens = std.math.add( u64, source.input_tokens, source.output_tokens, ) catch return error.UsageOverflow; const models = try alloc.alloc(ModelUsage, source.models.len); errdefer alloc.free(models); var built_models: usize = 0; errdefer for (models[0..built_models]) |*model| model.deinit(alloc); for (source.models, 0..) |source_model, index| { if (source_model.model.len == 0 or source_model.model.len > max_model_bytes or !std.math.isFinite(source_model.total_cost) or source_model.total_cost < 0 or source_model.cache_read_tokens > source_model.input_tokens or source_model.cache_write_tokens > source_model.input_tokens) { return error.InvalidGenerationFact; } if (source_model.reasoning_tokens) |reasoning| { if (reasoning > source_model.output_tokens) { return error.InvalidGenerationFact; } } for (source_model.model) |byte| { if (byte < 0x21 or byte > 0x7e) { return error.InvalidGenerationFact; } } models[index] = .{ .model = try alloc.dupe(u8, source_model.model), .totals = .{ .total_tokens = std.math.add( u64, source_model.input_tokens, source_model.output_tokens, ) catch return error.UsageOverflow, .input_tokens = source_model.input_tokens, .output_tokens = source_model.output_tokens, .cache_read_tokens = source_model.cache_read_tokens, .cache_write_tokens = source_model.cache_write_tokens, .reasoning_tokens = source_model.reasoning_tokens, .request_count = source_model.request_count, .total_cost = source_model.total_cost, }, }; built_models += 1; } sort_utils.sort(ModelUsage, models, {}, modelUsageLessThan);
return .{ .scope = .session, .snapshot_time_ms = source.snapshot_time_ms, .window_start_ms = source.session_started_at_ms, .coverage_started_at_ms = source.session_started_at_ms, .coverage = .full, .completeness = source.completeness, .totals = .{ .total_tokens = total_tokens, .input_tokens = source.input_tokens, .output_tokens = source.output_tokens, .cache_read_tokens = source.cache_read_tokens, .cache_write_tokens = source.cache_write_tokens, .reasoning_tokens = source.reasoning_tokens, .request_count = source.request_count, .total_cost = source.total_cost, }, .models = models, .session_activity = source.activity, };}
pub fn validateFact(fact: GenerationFact) error{InvalidGenerationFact}!void { if (!types.validGatewayGenerationId(fact.id) or fact.created_at_ms < 0 or fact.model.len == 0 or fact.model.len > max_model_bytes or !std.math.isFinite(fact.total_cost) or fact.total_cost < 0 or fact.cache_read_tokens > fact.input_tokens or fact.cache_write_tokens > fact.input_tokens) { return error.InvalidGenerationFact; } if (fact.reasoning_tokens) |reasoning| { if (reasoning > fact.output_tokens) return error.InvalidGenerationFact; } for (fact.model) |byte| { if (byte < 0x21 or byte > 0x7e) return error.InvalidGenerationFact; }}
pub fn validatePendingMarker( marker: PendingMarker,) error{InvalidPendingMarker}!void { if (!types.validGatewayGenerationId(marker.id) or marker.observed_at_ms < 0) { return error.InvalidPendingMarker; }}
pub fn validateIncident(incident: Incident) error{InvalidUsageIncident}!void { if (incident.occurred_at_ms < 0 or (incident.completeness != .pending and incident.completeness != .incomplete)) { return error.InvalidUsageIncident; }}
/// Builds an owned rolling snapshot from validated facts and an explicit time./// The caller must call `Snapshot.deinit`.pub fn buildRollingSnapshot( alloc: Allocator, scope: Scope, snapshot_time_ms: i64, coverage_started_at_ms: ?i64, facts: []const GenerationFact, incidents: []const Incident,) BuildError!Snapshot { const duration_ms = scope.durationMs() orelse return error.InvalidSnapshotTime; if (snapshot_time_ms < 0) return error.InvalidSnapshotTime; const window_start_ms = std.math.sub(i64, snapshot_time_ms, duration_ms) catch return error.InvalidSnapshotTime; var visible_coverage_started_at_ms = coverage_started_at_ms; if (coverage_started_at_ms) |started_at_ms| { if (started_at_ms < 0) return error.InvalidSnapshotTime; if (started_at_ms > snapshot_time_ms) { visible_coverage_started_at_ms = null; } }
var completeness: Completeness = .complete; for (incidents) |incident| { if (incident.occurred_at_ms < window_start_ms or incident.occurred_at_ms >= snapshot_time_ms) { continue; } completeness = switch (incident.completeness) { .incomplete, .legacy => .incomplete, .pending => if (completeness == .complete) .pending else completeness, .complete => completeness, }; }
const coverage: Coverage = if (visible_coverage_started_at_ms) |started_at_ms| if (started_at_ms <= window_start_ms) .full else .partial else .not_started; if (coverage == .not_started) { return emptySnapshot( alloc, scope, snapshot_time_ms, window_start_ms, null, .not_started, completeness, ); }
var seen: std.StringHashMapUnmanaged(GenerationFact) = .empty; defer seen.deinit(alloc); var model_indexes: std.StringHashMapUnmanaged(usize) = .empty; defer model_indexes.deinit(alloc); var mutable_models: std.ArrayList(MutableModel) = .empty; defer { for (mutable_models.items) |*model| model.deinit(alloc); mutable_models.deinit(alloc); } var totals: MutableTotals = .{};
for (facts) |fact| { try validateFact(fact); if (fact.created_at_ms < window_start_ms or fact.created_at_ms >= snapshot_time_ms) { continue; } const seen_result = try seen.getOrPut(alloc, fact.id); if (seen_result.found_existing) { if (!GenerationFact.eql(seen_result.value_ptr.*, fact)) { completeness = .incomplete; } continue; } seen_result.value_ptr.* = fact;
try totals.add(fact); const model_result = try model_indexes.getOrPut(alloc, fact.model); if (!model_result.found_existing) { if (mutable_models.items.len == max_models) { return error.UsageCapacityExceeded; } const owned_model = try alloc.dupe(u8, fact.model); errdefer alloc.free(owned_model); try mutable_models.append(alloc, .{ .model = owned_model }); model_result.value_ptr.* = mutable_models.items.len - 1; } try mutable_models.items[model_result.value_ptr.*].totals.add(fact); }
const models = try alloc.alloc(ModelUsage, mutable_models.items.len); errdefer alloc.free(models); var built_models: usize = 0; errdefer for (models[0..built_models]) |*model| model.deinit(alloc); for (mutable_models.items, 0..) |*model, index| { models[index] = .{ .model = model.model, .totals = try model.totals.freeze(true), }; model.model = &.{}; built_models += 1; } sort_utils.sort(ModelUsage, models, {}, modelUsageLessThan);
return .{ .scope = scope, .snapshot_time_ms = snapshot_time_ms, .window_start_ms = window_start_ms, .coverage_started_at_ms = visible_coverage_started_at_ms, .coverage = coverage, .completeness = completeness, .totals = try totals.freeze(true), .models = models, };}
fn emptySnapshot( alloc: Allocator, scope: Scope, snapshot_time_ms: i64, window_start_ms: i64, coverage_started_at_ms: ?i64, coverage: Coverage, completeness: Completeness,) Allocator.Error!Snapshot { return .{ .scope = scope, .snapshot_time_ms = snapshot_time_ms, .window_start_ms = window_start_ms, .coverage_started_at_ms = coverage_started_at_ms, .coverage = coverage, .completeness = completeness, .totals = null, .models = try alloc.alloc(ModelUsage, 0), };}
fn modelUsageLessThan(_: void, first: ModelUsage, second: ModelUsage) bool { if (first.totals.total_tokens != second.totals.total_tokens) { return first.totals.total_tokens > second.totals.total_tokens; } if (first.totals.total_cost != second.totals.total_cost) { return first.totals.total_cost > second.totals.total_cost; } return std.mem.order(u8, first.model, second.model) == .lt;}
fn testFact( id: []u8, model: []u8, created_at_ms: i64, input_tokens: u64, output_tokens: u64, total_cost: f64,) GenerationFact { return .{ .id = id, .created_at_ms = created_at_ms, .model = model, .input_tokens = input_tokens, .output_tokens = output_tokens, .cache_read_tokens = 0, .cache_write_tokens = 0, .reasoning_tokens = 0, .total_cost = total_cost, };}
test "rolling snapshots use closed-open boundaries and stable usage-first ordering" { const alloc = std.testing.allocator; const now = std.time.ms_per_day * 40; var facts = [_]GenerationFact{ testFact( @constCast("gen_01ARZ3NDEKTSV4RRFFQ69G5FAV"), @constCast("z/model"), now - std.time.ms_per_day * 30, 3, 2, 1, ), testFact( @constCast("gen_01ARZ3NDEKTSV4RRFFQ69G5FAW"), @constCast("b/model"), now - 1, 5, 5, 2, ), testFact( @constCast("gen_01ARZ3NDEKTSV4RRFFQ69G5FAX"), @constCast("a/model"), now - 2, 5, 5, 2, ), testFact( @constCast("gen_01ARZ3NDEKTSV4RRFFQ69G5FAY"), @constCast("excluded/model"), now, 100, 100, 100, ), }; var snapshot = try buildRollingSnapshot( alloc, .days_30, now, 0, &facts, &.{}, ); defer snapshot.deinit(alloc);
try std.testing.expectEqual(Coverage.full, snapshot.coverage); try std.testing.expectEqual(@as(u64, 25), snapshot.totals.?.total_tokens); try std.testing.expectEqual(@as(usize, 3), snapshot.models.len); try std.testing.expectEqualStrings("a/model", snapshot.models[0].model); try std.testing.expectEqualStrings("b/model", snapshot.models[1].model); try std.testing.expectEqualStrings("z/model", snapshot.models[2].model);}
test "rolling snapshots dedupe exact facts and fail closed on conflicts and incidents" { const alloc = std.testing.allocator; const now = std.time.ms_per_day * 40; const original = testFact( @constCast("gen_01ARZ3NDEKTSV4RRFFQ69G5FAV"), @constCast("provider/model"), now - 1, 4, 2, 0.5, ); const duplicate = original; var conflict = original; conflict.output_tokens = 3;
var exact = try buildRollingSnapshot( alloc, .hours_24, now, 0, &.{ original, duplicate }, &.{}, ); defer exact.deinit(alloc); try std.testing.expectEqual(@as(u64, 6), exact.totals.?.total_tokens); try std.testing.expectEqual(@as(u64, 1), exact.totals.?.request_count.?);
var conflicted = try buildRollingSnapshot( alloc, .hours_24, now, 0, &.{ original, conflict }, &.{}, ); defer conflicted.deinit(alloc); try std.testing.expectEqual(Completeness.incomplete, conflicted.completeness); try std.testing.expectEqual(@as(u64, 6), conflicted.totals.?.total_tokens);
var pending = try buildRollingSnapshot( alloc, .hours_24, now, 0, &.{original}, &.{.{ .occurred_at_ms = now - 1, .completeness = .pending }}, ); defer pending.deinit(alloc); try std.testing.expectEqual(Completeness.pending, pending.completeness); try std.testing.expectEqual(@as(u64, 6), pending.totals.?.total_tokens);}
test "rolling snapshots distinguish tracking start from measured zero" { const alloc = std.testing.allocator; const now = std.time.ms_per_day * 40; var unstarted = try buildRollingSnapshot( alloc, .days_7, now, null, &.{}, &.{}, ); defer unstarted.deinit(alloc); try std.testing.expectEqual(Coverage.not_started, unstarted.coverage); try std.testing.expectEqual(Completeness.complete, unstarted.completeness); try std.testing.expect(unstarted.totals == null);
var concurrently_started = try buildRollingSnapshot( alloc, .days_7, now, now + 1, &.{}, &.{}, ); defer concurrently_started.deinit(alloc); try std.testing.expectEqual( Coverage.not_started, concurrently_started.coverage, ); try std.testing.expect(concurrently_started.coverage_started_at_ms == null); try std.testing.expect(concurrently_started.totals == null);
var unknown = try buildRollingSnapshot( alloc, .days_7, now, null, &.{}, &.{.{ .occurred_at_ms = now - 1, .completeness = .incomplete }}, ); defer unknown.deinit(alloc); try std.testing.expectEqual(Coverage.not_started, unknown.coverage); try std.testing.expectEqual(Completeness.incomplete, unknown.completeness); try std.testing.expect(unknown.totals == null);
var measured = try buildRollingSnapshot( alloc, .days_7, now, now - std.time.ms_per_day, &.{}, &.{}, ); defer measured.deinit(alloc); try std.testing.expectEqual(Coverage.partial, measured.coverage); try std.testing.expectEqual(@as(u64, 0), measured.totals.?.total_tokens);}
test "non-complete session snapshots preserve known totals and activity" { const alloc = std.testing.allocator; const activity = SessionActivity{ .api_duration_complete = true, .wall_duration_complete = false, .code_complete = true, .api_duration_ms = 1200, .wall_duration_ms = 3400, .lines_added = 5, .lines_removed = 2, }; for ([_]Completeness{ .pending, .incomplete }) |completeness| { var snapshot = try buildSessionSnapshot(alloc, .{ .snapshot_time_ms = 200, .session_started_at_ms = 100, .completeness = completeness, .total_cost = 0, .input_tokens = 0, .output_tokens = 0, .cache_read_tokens = 0, .cache_write_tokens = 0, .reasoning_tokens = null, .request_count = null, .models = &.{}, .activity = activity, }); defer snapshot.deinit(alloc); try std.testing.expectEqual(@as(u64, 0), snapshot.totals.?.total_tokens); try std.testing.expectEqual(activity, snapshot.session_activity.?); }
var legacy = try buildSessionSnapshot(alloc, .{ .snapshot_time_ms = 200, .session_started_at_ms = 100, .completeness = .legacy, .total_cost = 0, .input_tokens = 0, .output_tokens = 0, .cache_read_tokens = 0, .cache_write_tokens = 0, .reasoning_tokens = null, .request_count = null, .models = &.{}, .activity = activity, }); defer legacy.deinit(alloc); try std.testing.expect(legacy.totals == null); try std.testing.expectEqual(activity, legacy.session_activity.?);}