Skip to content

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

Python
3.4 KB
Raw Blame
//! #1654: saveSession writes no size limit, but every reader used to cap a
//! session file at 8 MiB. One opaque provider compaction item can exceed that
//! alone, so a long session saved fine and then could not be listed or loaded.

const std = @import("std");
const Agent = @import("agent.zig").Agent;
const provider_mod = @import("provider.zig");
const session_index = @import("session_index.zig");

/// A save past the old 8 MiB cap: one large opaque message before the tail.
fn writeLargeSave(gpa: std.mem.Allocator, dir: std.Io.Dir, sub_path: []const u8) !void {
    const blob = try gpa.alloc(u8, 9 * 1024 * 1024);
    defer gpa.free(blob);
    @memset(blob, 'a');
    const data = try std.fmt.allocPrint(gpa, "{{\"provider\":\"anthropic\",\"model\":\"sonnet\",\"title\":\"Long chat\",\"updated_ms\":7,\"messages\":[{{\"role\":\"user\",\"content\":\"{s}\"}},{{\"role\":\"user\",\"content\":\"remember 1654\"}}]}}", .{blob});
    defer gpa.free(data);
    try dir.writeFile(std.testing.io, .{ .sub_path = sub_path, .data = data });
}

test "#1654 a session save larger than 8 MiB still lists and loads" {
    const session = @import("session.zig");
    const writer = @import("session_writer.zig");
    const transcript = @import("session_transcript.zig");
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    writer.resetForTest();
    defer writer.resetForTest();
    transcript.resetForTest();
    defer transcript.resetForTest();

    var arena_state = std.heap.ArenaAllocator.init(gpa);
    defer arena_state.deinit();
    const arena = arena_state.allocator();
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    var home_buf: [std.fs.max_path_bytes]u8 = undefined;
    const home = home_buf[0..try tmp.dir.realPath(io, &home_buf)];
    try tmp.dir.createDirPath(io, ".graff/sessions");
    try writeLargeSave(gpa, tmp.dir, ".graff/sessions/large-1654.session.json");

    var sessions = try tmp.dir.openDir(io, ".graff/sessions", .{ .iterate = true });
    defer sessions.close(io);
    const listed = session_index.listFromDir(io, arena, sessions, home, false);
    try std.testing.expectEqual(@as(usize, 1), listed.items.len);
    try std.testing.expectEqualStrings("Long chat", listed.items[0].title.?);

    var keys: provider_mod.Keys = .{ .values = @splat(null) };
    for (provider_mod.provider_specs, &keys.values, &keys.sources) |spec, *value, *source| {
        if (!std.mem.eql(u8, spec.id, "anthropic")) continue;
        value.* = "launch-key";
        source.* = .environment;
    }
    var client: std.http.Client = .{ .allocator = gpa, .io = io };
    defer client.deinit();
    var root: Agent = .{
        .gpa = gpa,
        .arena = arena,
        .io = io,
        .client = &client,
        .provider = try keys.providerById("anthropic", "sonnet"),
        .messages = .init(arena),
        .sub = false,
        .label = "root",
        .out = null,
        .home = home,
        .stored_keys_loaded = true,
    };
    try session.loadSession(&root, &keys, arena, "large-1654");
    try std.testing.expectEqual(@as(usize, 2), root.messages.items.len);

    // Past the shared limit the save is reported as too large, not as missing.
    const saved_limit = session_index.max_session_bytes;
    defer session_index.max_session_bytes = saved_limit;
    session_index.max_session_bytes = 1024 * 1024;
    try std.testing.expectError(error.SessionTooLarge, session.loadSession(&root, &keys, arena, "large-1654"));
}