diff --git a/src/core/session/session.zig b/src/core/session/session.zig index 6e4c63b4..3883b6b5 100644 --- a/src/core/session/session.zig +++ b/src/core/session/session.zig @@ -2016,10 +2016,16 @@ pub fn dupeHistoryTurn(alloc: Allocator, turn: HistoryTurn) !HistoryTurn { switch (turn) { .compacted_summary => |entry| { const summary = try alloc.dupe(u8, entry.summary); + errdefer alloc.free(summary); + const root_user_messages = try core_types.dupeCompletedToolNames( + alloc, + entry.root_user_messages, + ); return .{ .compacted_summary = .{ .summary = summary, .removed_turn_count = entry.removed_turn_count, .compaction_count = entry.compaction_count, + .root_user_messages = root_user_messages, } }; }, .assistant => |entry| { @@ -2922,13 +2928,90 @@ fn buildCompactedSummaryTurn( existing: ?CompactedSummaryHistoryTurn, removed: []const HistoryTurn, ) !CompactedSummaryHistoryTurn { + const root_user_messages = try buildCompactedRootUserMessages(alloc, existing, removed); + errdefer core_types.freeCompletedToolNames(alloc, root_user_messages); return .{ .summary = try buildCompactedSummaryText(alloc, existing, removed), .removed_turn_count = (if (existing) |entry| entry.removed_turn_count else 0) + removed.len, .compaction_count = (if (existing) |entry| entry.compaction_count else 0) + 1, + .root_user_messages = root_user_messages, }; } +fn buildCompactedRootUserMessages( + alloc: Allocator, + existing: ?CompactedSummaryHistoryTurn, + removed: []const HistoryTurn, +) ![][]u8 { + var count: usize = if (existing) |entry| entry.root_user_messages.len else 0; + for (removed) |turn| switch (turn) { + .assistant, .background_command, .interrupted => count += 1, + .compacted_summary => |entry| count += entry.root_user_messages.len, + }; + if (count == 0) return &.{}; + + const messages = try alloc.alloc([]u8, count); + errdefer alloc.free(messages); + var copied: usize = 0; + errdefer for (messages[0..copied]) |root_message| alloc.free(root_message); + + if (existing) |entry| { + for (entry.root_user_messages) |root_message| { + messages[copied] = try alloc.dupe(u8, root_message); + copied += 1; + } + } + for (removed) |turn| switch (turn) { + .assistant => |entry| { + messages[copied] = try alloc.dupe(u8, entry.user.text); + copied += 1; + }, + .background_command => |entry| { + messages[copied] = try alloc.dupe(u8, entry.user.text); + copied += 1; + }, + .interrupted => |entry| { + messages[copied] = try alloc.dupe(u8, entry.user.text); + copied += 1; + }, + .compacted_summary => |entry| for (entry.root_user_messages) |root_message| { + messages[copied] = try alloc.dupe(u8, root_message); + copied += 1; + }, + }; + std.debug.assert(copied == messages.len); + return messages; +} + +test "history compaction preserves exact ordered root-user text separately from summary" { + const alloc = std.testing.allocator; + const removed = [_]HistoryTurn{ + .{ .assistant = .{ + .user = .{ .text = @constCast("first exact request") }, + .assistant = @constCast("first response"), + } }, + .{ .interrupted = .{ + .user = .{ .text = @constCast("second exact request") }, + } }, + }; + const first = try buildCompactedSummaryTurn(alloc, null, &removed); + defer freeHistoryTurn(alloc, .{ .compacted_summary = first }); + try std.testing.expectEqual(@as(usize, 2), first.root_user_messages.len); + try std.testing.expectEqualStrings("first exact request", first.root_user_messages[0]); + try std.testing.expectEqualStrings("second exact request", first.root_user_messages[1]); + + const later = [_]HistoryTurn{.{ .assistant = .{ + .user = .{ .text = @constCast("third exact request") }, + .assistant = @constCast("third response"), + } }}; + const second = try buildCompactedSummaryTurn(alloc, first, &later); + defer freeHistoryTurn(alloc, .{ .compacted_summary = second }); + try std.testing.expectEqual(@as(usize, 3), second.root_user_messages.len); + try std.testing.expectEqualStrings("first exact request", second.root_user_messages[0]); + try std.testing.expectEqualStrings("second exact request", second.root_user_messages[1]); + try std.testing.expectEqualStrings("third exact request", second.root_user_messages[2]); +} + fn buildCompactedSummaryText( alloc: Allocator, existing: ?CompactedSummaryHistoryTurn, diff --git a/src/core/session/session_codec.zig b/src/core/session/session_codec.zig index 2706bbda..6d328a75 100644 --- a/src/core/session/session_codec.zig +++ b/src/core/session/session_codec.zig @@ -266,6 +266,12 @@ pub fn writeHistoryTurn(writer: *std.Io.Writer, turn: session.HistoryTurn) !void entry.removed_turn_count, entry.compaction_count, }); + try writer.writeAll(",\"root_user_messages\":["); + for (entry.root_user_messages, 0..) |message, index| { + if (index > 0) try writer.writeByte(','); + try writeDurableBytes(writer, message); + } + try writer.writeByte(']'); try writer.writeByte('}'); }, .assistant => |entry| { @@ -336,18 +342,27 @@ pub fn writeHistoryTurn(writer: *std.Io.Writer, turn: session.HistoryTurn) !void pub fn parseHistoryTurn(alloc: Allocator, value: std.json.Value) !session.HistoryTurn { const kind = try requireString(try requireObject(value), "kind"); if (std.mem.eql(u8, kind, "compacted_summary")) { - const object = try exactObject(value, &.{ - "kind", - "summary", - "removed_turn_count", - "compaction_count", - }); + const shape = try exactVariantObject( + value, + &.{ "kind", "summary", "removed_turn_count", "compaction_count" }, + &.{ "kind", "summary", "removed_turn_count", "compaction_count", "root_user_messages" }, + ); + const object = shape.object; const summary = try parseRequiredDurableBytes(alloc, object, "summary"); errdefer alloc.free(summary); + const root_user_messages: [][]u8 = if (shape.extended) + try parseDurableBytesArray( + alloc, + object.get("root_user_messages") orelse return error.InvalidSessionFormat, + ) + else + &.{}; + errdefer types.freeCompletedToolNames(alloc, root_user_messages); return .{ .compacted_summary = .{ .summary = summary, .removed_turn_count = try requireUsize(object, "removed_turn_count"), .compaction_count = try requireUsize(object, "compaction_count"), + .root_user_messages = root_user_messages, } }; } if (std.mem.eql(u8, kind, "assistant")) { @@ -2066,6 +2081,7 @@ test "durable state round trips every live history byte field exactly" { .summary = @constCast(invalid_b[0..]), .removed_turn_count = 3, .compaction_count = 2, + .root_user_messages = completed_tool_names[0..], } }, }; var usage_runtime = session_usage.Usage.initFresh(); @@ -2781,6 +2797,10 @@ fn expectHistoryTurnEqual(expected: session.HistoryTurn, actual: session.History try std.testing.expectEqualSlices(u8, entry.summary, actual.compacted_summary.summary); try std.testing.expectEqual(entry.removed_turn_count, actual.compacted_summary.removed_turn_count); try std.testing.expectEqual(entry.compaction_count, actual.compacted_summary.compaction_count); + try std.testing.expectEqual(entry.root_user_messages.len, actual.compacted_summary.root_user_messages.len); + for (entry.root_user_messages, actual.compacted_summary.root_user_messages) |expected_message, actual_message| { + try std.testing.expectEqualSlices(u8, expected_message, actual_message); + } }, .assistant => |entry| { const got = actual.assistant; diff --git a/src/core/session/session_json.zig b/src/core/session/session_json.zig index 83a4548e..cc8b3a8d 100644 --- a/src/core/session/session_json.zig +++ b/src/core/session/session_json.zig @@ -82,6 +82,12 @@ fn writeHistoryTurnJson(writer: *std.Io.Writer, turn: session.HistoryTurn) !void try writer.writeAll("{\"kind\":\"compacted_summary\",\"summary\":"); try std.json.Stringify.value(entry.summary, .{}, writer); try writer.print(",\"removed_turn_count\":{d},\"compaction_count\":{d}", .{ entry.removed_turn_count, entry.compaction_count }); + try writer.writeAll(",\"root_user_messages\":["); + for (entry.root_user_messages, 0..) |message, index| { + if (index > 0) try writer.writeByte(','); + try std.json.Stringify.value(message, .{}, writer); + } + try writer.writeByte(']'); try writer.writeByte('}'); }, .assistant => |entry| { @@ -607,10 +613,25 @@ fn parseLegacyHistoryTurn(alloc: Allocator, value: std.json.Value) !session.Hist const kind = try requireString(object, "kind"); if (std.mem.eql(u8, kind, "compacted_summary")) { + const root_user_messages: [][]u8 = if (object.get("root_user_messages")) |messages_value| blk: { + if (messages_value != .array) return error.InvalidSessionFormat; + const messages = try alloc.alloc([]u8, messages_value.array.items.len); + errdefer alloc.free(messages); + var copied: usize = 0; + errdefer for (messages[0..copied]) |message| alloc.free(message); + for (messages_value.array.items, 0..) |item, index| { + if (item != .string) return error.InvalidSessionFormat; + messages[index] = try alloc.dupe(u8, item.string); + copied += 1; + } + break :blk messages; + } else &.{}; + errdefer session.freeCompletedToolNames(alloc, root_user_messages); return .{ .compacted_summary = .{ .summary = try alloc.dupe(u8, try requireString(object, "summary")), .removed_turn_count = try requireUsize(object, "removed_turn_count"), .compaction_count = try requireUsize(object, "compaction_count"), + .root_user_messages = root_user_messages, } }; } if (std.mem.eql(u8, kind, "assistant")) { @@ -1392,6 +1413,7 @@ test "session JSON round-trips images summaries and background commands" { .snapshot_sha256 = @constCast("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), }}; var completed_tool_names = [_][]u8{ @constCast("list_files"), @constCast("glob_files") }; + var root_user_messages = [_][]u8{ @constCast("first exact request"), @constCast("second exact request") }; const history = [_]session.HistoryTurn{ .{ .assistant = .{ .user = .{ .text = @constCast("hello"), .images = &images }, @@ -1401,6 +1423,7 @@ test "session JSON round-trips images summaries and background commands" { .summary = @constCast("summary text"), .removed_turn_count = 5, .compaction_count = 2, + .root_user_messages = &root_user_messages, } }, .{ .background_command = .{ .user = .{ .text = @constCast("run dev") }, @@ -1461,6 +1484,9 @@ test "session JSON round-trips images summaries and background commands" { try std.testing.expectEqualStrings("summary text", loaded.history[1].compacted_summary.summary); try std.testing.expectEqual(@as(usize, 5), loaded.history[1].compacted_summary.removed_turn_count); try std.testing.expectEqual(@as(usize, 2), loaded.history[1].compacted_summary.compaction_count); + try std.testing.expectEqual(@as(usize, 2), loaded.history[1].compacted_summary.root_user_messages.len); + try std.testing.expectEqualStrings("first exact request", loaded.history[1].compacted_summary.root_user_messages[0]); + try std.testing.expectEqualStrings("second exact request", loaded.history[1].compacted_summary.root_user_messages[1]); try std.testing.expectEqualStrings("run dev", loaded.history[2].background_command.user.text); try std.testing.expectEqualStrings("/tmp/server.log", loaded.history[2].background_command.log_path); try std.testing.expect(loaded.history[2].background_command.expect_url);