Skip to content

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

Python
10.0 KB
Raw Blame
//! 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");
}