Skip to content

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

Python
9.1 KB
Raw Blame
//! Where automatic compaction starts, as a percent of the model's context
//! window (default 80, capped at 300k tokens on Gemini; `Provider.compactAt`).
//! A set percentage applies as is. The first one set wins:
//!
//!   1. `--compact-at N` on the command line (the SDK's `compactAt` option)
//!   2. `GRAFF_COMPACT_PCT=N` (how Harness passes its setting)
//!   3. `compact_pct` in `.harness/settings.json`, written by `/compact-at`
//!
//! `/compact-at N` also applies to the running session at once: compactAt
//! reads the override on every check, including the server-side directive.
const std = @import("std");
const Io = std.Io;
const Allocator = std.mem.Allocator;
const Value = std.json.Value;
const provider_mod = @import("provider.zig");
const policy = @import("harness_policy.zig");
const Agent = @import("agent.zig").Agent;

pub const default_pct: u8 = 80;
/// Below 10% a session compacts on its own standing prompt; at 95% the
/// emergency trim (`Provider.nearContextLimit`) would fire first.
pub const min_pct: u8 = 10;
pub const max_pct: u8 = 95;

/// Set by `--compact-at`; applied over every other source at startup.
pub var g_cli: ?u8 = null;

/// "70" or "70%", within min_pct..max_pct.
pub fn parse(text: []const u8) ?u8 {
    const trimmed = std.mem.trimEnd(u8, std.mem.trim(u8, text, " \t"), "%");
    const pct = std.fmt.parseInt(u8, std.mem.trim(u8, trimmed, " \t"), 10) catch return null;
    return if (pct >= min_pct and pct <= max_pct) pct else null;
}

/// Startup, after the env knobs: the flag beats the env, which beats the
/// saved setting.
pub fn applyStartup(io: Io, arena: Allocator) void {
    if (g_cli) |pct| {
        provider_mod.g_compact_pct_override = pct;
        return;
    }
    if (provider_mod.g_compact_pct_override != null) return;
    if (loadSaved(io, arena)) |pct| provider_mod.g_compact_pct_override = pct;
}

fn loadSaved(io: Io, arena: Allocator) ?u8 {
    const data = Io.Dir.cwd().readFileAlloc(io, policy.settings_path, arena, .limited(1 << 20)) catch return null;
    const v = std.json.parseFromSliceLeaky(Value, arena, data, .{ .allocate = .alloc_always }) catch return null;
    if (v != .object) return null;
    const saved = v.object.get("compact_pct") orelse return null;
    if (saved != .integer or saved.integer < min_pct or saved.integer > max_pct) return null;
    return @intCast(saved.integer);
}

/// Write `compact_pct` (null removes it), keeping every other key.
fn save(io: Io, gpa: Allocator, pct: ?u8) bool {
    Io.Dir.cwd().createDir(io, policy.settings_dir, .default_dir) catch {};
    var arena_state = std.heap.ArenaAllocator.init(gpa);
    defer arena_state.deinit();
    const a = arena_state.allocator();
    var root_obj: std.json.ObjectMap = .empty;
    if (Io.Dir.cwd().readFileAlloc(io, policy.settings_path, a, .limited(1 << 20))) |data| {
        if (std.json.parseFromSliceLeaky(Value, a, data, .{ .allocate = .alloc_always })) |v| {
            if (v == .object) root_obj = v.object;
        } else |_| {}
    } else |_| {}
    if (pct) |p| {
        root_obj.put(a, "compact_pct", .{ .integer = p }) catch return false;
    } else _ = root_obj.orderedRemove("compact_pct");
    var aw: Io.Writer.Allocating = .init(gpa);
    defer aw.deinit();
    var s: std.json.Stringify = .{ .writer = &aw.writer, .options = .{ .whitespace = .indent_2 } };
    s.write(Value{ .object = root_obj }) catch return false;
    const f = Io.Dir.cwd().createFile(io, policy.settings_path, .{}) catch return false;
    defer f.close(io);
    var wbuf: [4096]u8 = undefined;
    var fw = f.writer(io, &wbuf);
    fw.interface.writeAll(aw.writer.buffered()) catch return false;
    fw.interface.writeAll("\n") catch return false;
    fw.interface.flush() catch return false;
    return true;
}

pub fn current() u8 {
    return if (provider_mod.g_compact_pct_override) |p| @min(p, 100) else default_pct;
}

/// The percent the threshold actually sits at: the default is capped in
/// tokens on some models (Provider.gemini_compact_tokens).
fn shownPct(p: provider_mod.Provider) u64 {
    if (p.context == 0) return current();
    return (p.compactAt() * 100 + p.context / 2) / p.context;
}

/// `/compact-at` shows the point, `/compact-at N` sets it (and persists it
/// for this workspace), `/compact-at default` goes back to 80%.
pub fn handle(root: *Agent, line: []const u8, out: *Io.Writer) !bool {
    const name = "/compact-at";
    if (!std.mem.startsWith(u8, line, name)) return false;
    if (line.len > name.len and line[name.len] != ' ' and line[name.len] != '\t') return false;
    const arg = std.mem.trim(u8, line[name.len..], " \t");
    if (arg.len == 0) {
        try out.print("compaction starts at {d}% of the context window ({d}k of {d}k tokens){s}\n", .{
            shownPct(root.provider),
            root.provider.compactAt() / 1000,
            root.provider.context / 1000,
            if (provider_mod.g_compact_pct_override == null) " · default" else "",
        });
    } else if (std.ascii.eqlIgnoreCase(arg, "default") or std.ascii.eqlIgnoreCase(arg, "reset")) {
        provider_mod.g_compact_pct_override = null;
        const saved = save(root.io, root.gpa, null);
        try out.print("compaction starts at the default {d}% of the context window ({d}k of {d}k tokens){s}\n", .{
            shownPct(root.provider),
            root.provider.compactAt() / 1000,
            root.provider.context / 1000,
            if (saved) "" else " (not persisted)",
        });
    } else if (parse(arg)) |pct| {
        provider_mod.g_compact_pct_override = pct;
        const saved = save(root.io, root.gpa, pct);
        try out.print("compaction starts at {d}% of the context window ({d}k of {d}k tokens){s}\n", .{
            pct,
            root.provider.compactAt() / 1000,
            root.provider.context / 1000,
            if (saved) "" else " (not persisted)",
        });
    } else {
        try out.print("usage: /compact-at <{d}-{d}>[%] | default\n", .{ min_pct, max_pct });
    }
    try out.flush();
    return true;
}

test "parse accepts a bare or percent-suffixed value inside the safe range" {
    try std.testing.expectEqual(@as(?u8, 70), parse("70"));
    try std.testing.expectEqual(@as(?u8, 70), parse(" 70% "));
    try std.testing.expectEqual(@as(?u8, 10), parse("10"));
    try std.testing.expectEqual(@as(?u8, 95), parse("95%"));
    for ([_][]const u8{ "9", "96", "100", "0", "-5", "seventy", "", "%", "70.5" }) |bad|
        try std.testing.expectEqual(@as(?u8, null), parse(bad));
}

test "the flag beats the env, and the env beats nothing" {
    const saved_override = provider_mod.g_compact_pct_override;
    const saved_cli = g_cli;
    defer provider_mod.g_compact_pct_override = saved_override;
    defer g_cli = saved_cli;
    provider_mod.g_compact_pct_override = 55; // GRAFF_COMPACT_PCT
    g_cli = 70;
    applyStartup(std.testing.io, std.testing.allocator);
    try std.testing.expectEqual(@as(?u8, 70), provider_mod.g_compact_pct_override);
    g_cli = null;
    provider_mod.g_compact_pct_override = 55;
    applyStartup(std.testing.io, std.testing.allocator);
    try std.testing.expectEqual(@as(?u8, 55), provider_mod.g_compact_pct_override);
}

test "the threshold follows the setting in both directions" {
    const saved_override = provider_mod.g_compact_pct_override;
    defer provider_mod.g_compact_pct_override = saved_override;
    const p: provider_mod.Provider = .{ .id = "t", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "t", .context = 200_000 };
    provider_mod.g_compact_pct_override = null;
    try std.testing.expectEqual(@as(u64, 160_000), p.compactAt());
    provider_mod.g_compact_pct_override = parse("60%");
    try std.testing.expectEqual(@as(u64, 120_000), p.compactAt());
    provider_mod.g_compact_pct_override = parse("90");
    try std.testing.expectEqual(@as(u64, 180_000), p.compactAt());
}

test "Gemini's default stops at 300k tokens; a set percentage still applies" {
    const saved_override = provider_mod.g_compact_pct_override;
    defer provider_mod.g_compact_pct_override = saved_override;
    provider_mod.g_compact_pct_override = null;
    for ([_][]const u8{ "gemini-3.8-flash", "google/gemini-3.8-flash" }) |model| {
        const p: provider_mod.Provider = .{ .id = "t", .kind = .interactions, .auth = .goog_api_key, .url = "", .api_key = "", .model = model, .context = 1_048_576 };
        try std.testing.expectEqual(@as(u64, 300_000), p.compactAt());
        try std.testing.expectEqual(@as(u64, 29), shownPct(p));
    }
    const small: provider_mod.Provider = .{ .id = "t", .kind = .openai, .auth = .bearer, .url = "", .api_key = "", .model = "gemini-small", .context = 200_000 };
    try std.testing.expectEqual(@as(u64, 160_000), small.compactAt()); // 80% is already under the cap
    const other: provider_mod.Provider = .{ .id = "t", .kind = .openai, .auth = .bearer, .url = "", .api_key = "", .model = "gpt-6", .context = 1_000_000 };
    try std.testing.expectEqual(@as(u64, 800_000), other.compactAt());
    provider_mod.g_compact_pct_override = 80;
    const g: provider_mod.Provider = .{ .id = "t", .kind = .interactions, .auth = .goog_api_key, .url = "", .api_key = "", .model = "gemini-3.8-flash", .context = 1_000_000 };
    try std.testing.expectEqual(@as(u64, 800_000), g.compactAt());
}