Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
9.5 KB
Raw Blame
//! #1686: a resumed session keeps the provider's count of its compaction state.

const std = @import("std");
const Value = std.json.Value;
const Agent = @import("agent.zig").Agent;
const context_tokens = @import("context_tokens.zig");
const persist = @import("opaque_state_persist.zig");
const session = @import("session.zig");

const window: u64 = 270_000;
const state_len: usize = 8_000_000;

fn history(a: std.mem.Allocator, fill: u8) !std.json.Array {
    const head = "{\"type\":\"compaction\",\"encrypted_content\":\"";
    const json = try a.alloc(u8, head.len + state_len + 2);
    @memcpy(json[0..head.len], head);
    @memset(json[head.len .. head.len + state_len], fill);
    @memcpy(json[head.len + state_len ..], "\"}");
    var msgs = std.json.Array.init(a);
    try msgs.append(try std.json.parseFromSliceLeaky(Value, a, json, .{}));
    try msgs.append(try std.json.parseFromSliceLeaky(Value, a, "{\"role\":\"user\",\"content\":\"hi\"}", .{}));
    return msgs;
}

fn agent(msgs: std.json.Array) Agent {
    var root: Agent = undefined;
    root.provider = .{ .id = "codex", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "gpt-5", .context = window };
    root.messages = msgs;
    root.sub = false;
    root.strict = false;
    root.sys_normal = "";
    root.sys_strict = "";
    root.tools_responses = "";
    root.last_cache_read = 0;
    return root;
}

/// What a warm process saves after the provider counted the state at 80k:
/// the meter pair and the persisted count, as one session object.
const Saved = struct { context: u64, local: u64, obj: std.json.ObjectMap };

fn countAndSave(a: std.mem.Allocator, root: *Agent) !Saved {
    context_tokens.learnState(state_len, 80_000, root.fullRequestEstimateTokens());
    const local = root.fullRequestEstimateTokens();
    var aw: std.Io.Writer.Allocating = .init(a);
    var s: std.json.Stringify = .{ .writer = &aw.writer };
    try s.beginObject();
    try persist.write(&s, root.provider, .{ .array = root.messages });
    try s.endObject();
    const parsed = try std.json.parseFromSliceLeaky(Value, a, aw.writer.buffered(), .{});
    return .{ .context = 80_001, .local = local, .obj = parsed.object };
}

/// A new process: empty calibration, then loadSession's restore order.
fn reload(root: *Agent, saved: Saved) void {
    context_tokens.resetStateCountsForTest();
    persist.restore(root.provider, .{ .array = root.messages }, saved.obj);
    session.restoreContextMeter(root, saved.context, saved.local);
}

test "a reloaded session keeps the provider's count of its compaction state (#1686)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    context_tokens.resetStateCountsForTest();
    defer context_tokens.resetStateCountsForTest();

    var root = agent(try history(a, 'A'));
    const saved = try countAndSave(a, &root);
    try std.testing.expect(saved.obj.get(persist.field) != null);

    // Without the record a new process reads the state at bytes/16 (the bug).
    var cold = saved;
    cold.obj = (try std.json.parseFromSliceLeaky(Value, a, "{}", .{})).object;
    reload(&root, cold);
    try std.testing.expect(root.effectiveContextTokens() > window);
    try std.testing.expect(root.inputOverCompactThreshold());

    // With it, the reload keeps the counted occupancy and needs no compaction.
    reload(&root, saved);
    try std.testing.expect(root.effectiveContextTokens() < 100_000);
    try std.testing.expect(!root.inputOverCompactThreshold());
}

test "a saved state count applies only to the same state, provider, and model (#1686)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    context_tokens.resetStateCountsForTest();
    defer context_tokens.resetStateCountsForTest();

    var counted = agent(try history(a, 'A'));
    const saved = try countAndSave(a, &counted);

    // Same length, different blob: the digest refuses it.
    var other = agent(try history(a, 'B'));
    reload(&other, saved);
    try std.testing.expect(context_tokens.calibratedState(state_len) == null);
    try std.testing.expect(other.inputOverCompactThreshold());

    var moved = agent(counted.messages);
    moved.provider.model = "gpt-6";
    reload(&moved, saved);
    try std.testing.expect(context_tokens.calibratedState(state_len) == null);
    moved.provider.model = "gpt-5";
    moved.provider.id = "openai";
    reload(&moved, saved);
    try std.testing.expect(context_tokens.calibratedState(state_len) == null);

    const malformed = [_][]const u8{
        "{\"opaque_state_count\":{\"provider\":\"codex\",\"model\":\"gpt-5\",\"state_bytes\":8000000,\"state_digest\":\"zz\",\"tokens\":72000}}",
        "{\"opaque_state_count\":{\"provider\":\"codex\",\"model\":\"gpt-5\",\"state_bytes\":8000000,\"state_digest\":\"0\",\"tokens\":-1}}",
        "{\"opaque_state_count\":\"codex\"}",
        "{}",
    };
    for (malformed) |text| {
        const parsed = try std.json.parseFromSliceLeaky(Value, a, text, .{});
        reload(&counted, .{ .context = saved.context, .local = saved.local, .obj = parsed.object });
        try std.testing.expect(context_tokens.calibratedState(state_len) == null);
    }
}

test "an uncounted compaction state writes no record (#1686)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    context_tokens.resetStateCountsForTest();
    defer context_tokens.resetStateCountsForTest();

    const root = agent(try history(a, 'A'));
    var aw: std.Io.Writer.Allocating = .init(a);
    var s: std.json.Stringify = .{ .writer = &aw.writer };
    try s.beginObject();
    try persist.write(&s, root.provider, .{ .array = root.messages });
    try s.endObject();
    try std.testing.expectEqualStrings("{}", aw.writer.buffered());
}

test "session save and load both carry the compaction-state count (#1686)" {
    const src = @embedFile("session.zig");
    try std.testing.expect(std.mem.indexOf(u8, src, "opaque_state_persist.zig\").write(&s, root.provider, Value{ .array = saved_msgs })") != null);
    // Restore runs before the meter is rebased, or the rebase reads bytes/16.
    const restore_at = std.mem.indexOf(u8, src, "opaque_state_persist.zig\").restore(root.provider") orelse return error.TestUnexpectedResult;
    const rebase_at = std.mem.indexOf(u8, src, "    restoreContextMeter(root, saved_context_tokens, saved_local_tokens);") orelse return error.TestUnexpectedResult;
    try std.testing.expect(restore_at < rebase_at);
}

test "a session saved after a counted request loads without a forced compaction (#1686)" {
    const writer = @import("session_writer.zig");
    const transcript = @import("session_transcript.zig");
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var arena_state = std.heap.ArenaAllocator.init(gpa);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    writer.resetForTest();
    defer writer.resetForTest();
    transcript.resetForTest();
    defer transcript.resetForTest();
    context_tokens.resetStateCountsForTest();
    defer context_tokens.resetStateCountsForTest();
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    var client: std.http.Client = .{ .allocator = gpa, .io = io };
    defer client.deinit();
    var keys: @import("provider.zig").Keys = .{ .values = @splat("test-key") };
    var provider = try keys.providerById("openai", "gpt-6-sol");
    provider.context = window;
    var root: Agent = .{
        .gpa = gpa,
        .arena = a,
        .io = io,
        .client = &client,
        .provider = provider,
        .messages = try history(a, 'A'),
        .sub = false,
        .label = "root",
        .out = null,
        .home = try std.fmt.allocPrint(a, ".zig-cache/tmp/{s}", .{tmp.sub_path}),
    };
    try root.ensureRootTools(root.provider.kind);

    // Warm process: the provider counted a full request carrying the state at 80k.
    context_tokens.learnState(state_len, 80_000, root.fullRequestEstimateTokens());
    root.last_context_tokens = 80_001;
    root.context_local_tokens = root.fullRequestEstimateTokens();
    try std.testing.expect(!root.inputOverCompactThreshold());
    try session.saveSessionTo(&root, a, tmp.dir, "reload-1686");
    session.flushSaves();

    // New process: no calibration in memory, then the real load path.
    context_tokens.resetStateCountsForTest();
    root.last_context_tokens = 0;
    root.context_local_tokens = 0;
    try session.loadSession(&root, &keys, a, "reload-1686");
    root.provider.context = window;
    try std.testing.expect(root.effectiveContextTokens() < 100_000);
    try std.testing.expect(!root.inputOverCompactThreshold());
}

test "a chained response teaches the compaction-state count (#1686)" {
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    context_tokens.resetStateCountsForTest();
    defer context_tokens.resetStateCountsForTest();

    // previous_response_id still bills the whole chain as input (OpenAI), so a
    // WebSocket delta's usage counts the state like a full request's does.
    var root = agent(try history(a, 'A'));
    root.codex_prev_id = "resp_1";
    const response = try std.json.parseFromSliceLeaky(Value, a, "{\"usage\":{\"input_tokens\":80000}}", .{});
    @import("opaque_state_usage.zig").learn(&root, response.object);
    try std.testing.expect(context_tokens.calibratedState(state_len) != null);
    try std.testing.expect(!root.inputOverCompactThreshold());
}