graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
//! ACP v1 session/load for the live CLI Agent. Only a saved session in the
//! selected workspace can be loaded; session IDs are plain save basenames.
const std = @import("std");
const Io = std.Io;
const Allocator = std.mem.Allocator;
const proto = @import("acp_protocol.zig");
const engine = @import("acp_engine.zig");
const session = @import("session.zig");
const session_index = @import("session_index.zig");
const replay = @import("acp_replay.zig");
const transcript = @import("session_transcript.zig");
const LiveTurn = @import("acp_live_turn.zig").LiveTurn;
const util = @import("util.zig");
const v2 = @import("acp_v2.zig");
const acp_workspace = @import("acp_workspace.zig");
const workspace_switch = @import("workspace_switch.zig");
const invalid_params: i32 = -32602;
pub fn configure(d: *engine.Dispatch, live: *LiveTurn) void {
d.load_session = load;
d.config = @import("acp_config.zig").option;
d.set_config = @import("acp_config.zig").set;
d.model_config = @import("acp_model_option.zig").option;
d.set_model = @import("acp_model_option.zig").set;
d.durable_session_id = if (session.validSessionName(live.root.session_name)) live.root.session_name else null;
d.durable_name = durableName;
live.dispatch = d;
}
/// The save turns are written to (`acp_live_turn` saves under `session_name`).
fn durableName(ctx: *anyopaque) ?[]const u8 {
const live: *LiveTurn = @ptrCast(@alignCast(ctx));
const name = live.root.session_name;
return if (session.validSessionName(name)) name else null;
}
fn reject(w: *Io.Writer, req: proto.Request, message: []const u8) !void {
if (req.id != null) try proto.writeError(w, req.id, invalid_params, message);
}
pub fn replayHistory(arena: Allocator, root: *@import("agent.zig").Agent, w: *Io.Writer, sid: []const u8) !void {
// The provider context can be compacted. The append-only transcript keeps
// earlier visible turns; a legacy save without one uses current history.
var retained: std.ArrayList(std.json.Value) = .empty;
for ([_][]const u8{
try transcript.rotatedPath(arena, sid),
try transcript.transcriptPath(arena, sid),
}) |path| {
const bytes = Io.Dir.cwd().readFileAlloc(root.io, path, arena, .limited(transcript.cap_bytes + 1024)) catch continue;
var lines = std.mem.splitScalar(u8, bytes, '\n');
while (lines.next()) |line| {
if (line.len == 0) continue;
const value = std.json.parseFromSliceLeaky(std.json.Value, arena, line, .{ .allocate = .alloc_always }) catch continue;
try retained.append(arena, value);
}
}
try replay.replay(arena, w, sid, if (retained.items.len > 0) retained.items else root.messages.items);
}
pub fn load(ctx: *anyopaque, arena: Allocator, w: *Io.Writer, req: proto.Request) anyerror!void {
const live: *LiveTurn = @ptrCast(@alignCast(ctx));
const d = live.dispatch orelse return reject(w, req, "Session loading is unavailable");
const params = req.params orelse return reject(w, req, "Invalid session/load parameters");
if (params != .object) return reject(w, req, "Invalid session/load parameters");
const sid = util.strFieldObj(params.object, "sessionId") orelse return reject(w, req, "Invalid session ID");
if (util.strFieldObj(params.object, "cwd") == null) return reject(w, req, "Invalid session workspace");
if (!session.validSessionName(sid)) return reject(w, req, "Invalid session ID");
const env = d.workspace orelse return reject(w, req, "Session loading is unavailable");
// The client's cwd becomes the session's; naming the checkout that owns a
// `-w` or auto-isolated tree keeps that tree (acp_workspace.adopt).
acp_workspace.adopt(env, arena, params) catch |err| return reject(w, req, acp_workspace.errorText(err));
const provider = switch (savedHere(live, env, arena, sid)) {
.provider => |id| id,
.rejected => |message| return reject(w, req, message),
};
// Flush the outgoing conversation before replacing provider-native state.
session.saveSession(live.root, arena, live.root.session_name) catch |err| {
return proto.writeError(w, req.id, engine.err_internal, @errorName(err));
};
session.loadSession(live.root, live.keys, arena, sid) catch |err| {
return proto.writeError(w, req.id, invalid_params, loadErrorText(arena, err, provider));
};
// Same precedence as CLI resume: the host respawns with --model to switch.
if (live.model_override) |p| @import("session_branch.zig").applyModelOverride(live.root, arena, p);
live.root.session_name = try arena.dupe(u8, sid);
live.session_id = live.root.session_name;
d.session_id = live.session_id;
d.durable_session_id = live.session_id;
// Peers address this chat by its session id: re-register under the loaded one.
@import("presence.zig").noteLabelsFrom(live.root.io, live.root.gpa, arena, live.root.session_title, live.root.session_name);
// v2 session/resume replays only when asked (`replayFrom: {type: start}`).
if (!v2.on() or replayFromStart(params)) try replayHistory(arena, live.root, w, live.session_id);
const options = engine.configOptions(d, arena) catch |err| return proto.writeError(w, req.id, engine.err_internal, @errorName(err));
try proto.writeResult(w, req.id, .{ .configOptions = options, ._meta = acp_workspace.meta(env, arena) });
try proto.writeAvailableCommands(w, live.session_id, try @import("acp_t3.zig").commands(arena, proto.slashCommands()));
}
pub const Saved = union(enum) { provider: []const u8, rejected: []const u8 };
/// A save `sid` in the selected workspace that session/load (and session/fork)
/// may restore, or why not. Names its provider for a credential error.
pub fn savedHere(live: *LiveTurn, env: acp_workspace.Env, arena: Allocator, sid: []const u8) Saved {
// No discovery fallback to the user's home or a sibling checkout. A save
// with this basename in another workspace is a different conversation.
// The one exception is this checkout's own `.graff/worktrees/*` (ADR 0202).
const path = session.sessionPath(arena, sid) catch return .{ .rejected = "Invalid session ID" };
const stat = Io.Dir.cwd().statFile(live.root.io, path, .{}) catch blk: {
if (!acp_workspace.enterSavedTree(env, arena, sid)) return .{ .rejected = "Unknown session ID in the selected workspace" };
break :blk Io.Dir.cwd().statFile(live.root.io, path, .{}) catch
return .{ .rejected = "Unknown session ID in the selected workspace" };
};
const canonical_active = workspace_switch.currentAbs(live.root.io, arena);
if (stat.kind != .file) return .{ .rejected = "Unknown session ID in the selected workspace" };
const bytes = Io.Dir.cwd().readFileAlloc(live.root.io, path, arena, .limited(session_index.max_session_bytes)) catch |err|
return .{ .rejected = loadErrorText(arena, if (err == error.StreamTooLong) error.SessionTooLarge else err, "") };
const unloadable: Saved = .{ .rejected = "Saved session could not be loaded" };
const parsed = std.json.parseFromSliceLeaky(std.json.Value, arena, bytes, .{ .allocate = .alloc_always }) catch return unloadable;
if (parsed != .object) return unloadable;
const provider = parsed.object.get("provider") orelse return unloadable;
const model = parsed.object.get("model") orelse return unloadable;
const messages = parsed.object.get("messages") orelse return unloadable;
if (provider != .string or model != .string or messages != .array) return unloadable;
if (util.strFieldObj(parsed.object, "workspace")) |saved_workspace| {
const canonical_saved = Io.Dir.cwd().realPathFileAlloc(live.root.io, saved_workspace, arena) catch saved_workspace;
if (!session_index.sameWorkspace(canonical_saved, canonical_active))
return .{ .rejected = "Saved session belongs to another workspace" };
}
return .{ .provider = provider.string };
}
/// #1557: the save parsed and its fields are present, so a failure here is
/// rarely an unreadable file. Name the real cause — a missing credential most
/// of all, which the host would otherwise present as lost context.
fn loadErrorText(arena: Allocator, err: anyerror, provider_id: []const u8) []const u8 {
if (err == error.FileNotFound) return "Unknown session ID in the selected workspace";
if (err == error.SessionTooLarge) return "Saved session is larger than the session read limit and could not be loaded";
if (err == error.MissingKey and provider_id.len > 0)
return std.fmt.allocPrint(arena, "Saved session is intact, but its provider \"{s}\" has no credential in this process; run `graff login {s}` or `graff key set {s} <key>`, then load it again", .{ provider_id, provider_id, provider_id }) catch "Saved session is intact, but its provider has no credential in this process";
return std.fmt.allocPrint(arena, "Saved session could not be loaded ({s})", .{@errorName(err)}) catch "Saved session could not be loaded";
}
test "loadErrorText names a missing credential instead of blaming the save (#1557)" {
var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_state.deinit();
const a = arena_state.allocator();
const missing = loadErrorText(a, error.MissingKey, "deepseek");
try std.testing.expect(std.mem.indexOf(u8, missing, "is intact") != null);
try std.testing.expect(std.mem.indexOf(u8, missing, "graff login deepseek") != null);
try std.testing.expect(std.mem.indexOf(u8, missing, "could not be loaded") == null);
try std.testing.expectEqualStrings("Unknown session ID in the selected workspace", loadErrorText(a, error.FileNotFound, "x"));
try std.testing.expectEqualStrings("Saved session could not be loaded (BadSession)", loadErrorText(a, error.BadSession, "x"));
try std.testing.expect(std.mem.indexOf(u8, loadErrorText(a, error.SessionTooLarge, "x"), "read limit") != null);
}
pub fn replayFromStart(params: std.json.Value) bool {
const from = params.object.get("replayFrom") orelse return false;
if (from != .object) return false;
return std.mem.eql(u8, util.strFieldObj(from.object, "type") orelse "", "start");
}