graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
//! Measured hot-path checks for reuse on the networks graff already speaks:
//! process-warmed WSS CA, MCP Streamable HTTP keep-alive, and the source
//! guards that keep those clients from becoming throwaways again.
const std = @import("std");
const builtin = @import("builtin");
const Io = std.Io;
const http_warm = @import("http_warm.zig");
const mcp_http = @import("mcp_http.zig");
const mcp_lifecycle = @import("mcp_lifecycle.zig");
const mcp_protocol = @import("mcp_protocol.zig");
const mcp_rpc = @import("mcp_rpc.zig");
test "WSS CA bundle is scanned from disk at most once per process" {
const io = std.testing.io;
const before = http_warm.process_ca_rescans;
try http_warm.ensureProcessCa(io);
const mid = http_warm.process_ca_rescans;
try http_warm.ensureProcessCa(io);
const after = http_warm.process_ca_rescans;
try std.testing.expect(mid == before or mid == before + 1);
try std.testing.expectEqual(mid, after);
try std.testing.expect(http_warm.processCa().map.count() > 0);
}
test "MCP initialized notify reuses the persistent HTTP client" {
const src = @embedFile("mcp_rpc.zig");
try std.testing.expect(std.mem.indexOf(u8, src, "fn httpInitializedTask(http: *mcp_http.HttpTransport") != null);
try std.testing.expect(std.mem.indexOf(u8, src, "http.client.io.concurrent(httpInitializedTask, .{ http,") != null);
const throwaway = "var transport: " ++ "mcp_http.HttpTransport";
try std.testing.expect(std.mem.indexOf(u8, src, throwaway) == null);
}
test "WS→SSE fallback latches the prewarmed Agent client, not a fresh pool" {
const src = @embedFile("agent_ws.zig");
const latch = std.mem.indexOf(u8, src, "return self.postStream(body);").?;
try std.testing.expect(std.mem.indexOf(u8, src, "postStreamFresh") == null);
try std.testing.expect(std.mem.indexOf(u8, src, "using persistent prewarmed SSE") != null);
_ = latch;
}
const ListSrv = struct {
accepts: *std.atomic.Value(u8),
posts: *std.atomic.Value(u8),
done: *std.atomic.Value(bool),
fn run(self: *ListSrv, io: Io, listener: *std.Io.net.Server) void {
while (!self.done.load(.acquire)) {
const stream = listener.accept(io) catch {
if (self.done.load(.acquire)) return;
continue;
};
_ = self.accepts.fetchAdd(1, .monotonic);
defer stream.close(io);
self.serveConn(io, stream) catch {};
}
}
fn serveConn(self: *ListSrv, io: Io, stream: std.Io.net.Stream) !void {
var rbuf: [4096]u8 = undefined;
var wbuf: [4096]u8 = undefined;
var rd = std.Io.net.Stream.Reader.init(stream, io, &rbuf);
var wr = std.Io.net.Stream.Writer.init(stream, io, &wbuf);
const r = &rd.interface;
const w = &wr.interface;
while (self.posts.load(.acquire) < 2) {
var content_len: usize = 0;
while (true) {
const line = (r.takeDelimiter('\n') catch return) orelse return;
if (line.len == 0 or (line.len == 1 and line[0] == '\r')) break;
if (std.ascii.startsWithIgnoreCase(line, "content-length:")) {
const raw = if (line[line.len - 1] == '\r') line[0 .. line.len - 1] else line;
const v = std.mem.trim(u8, raw["content-length:".len..], " \t");
content_len = std.fmt.parseInt(usize, v, 10) catch 0;
}
}
if (content_len > 0) _ = try r.take(content_len);
const n = self.posts.fetchAdd(1, .monotonic) + 1;
const body = if (n == 1)
\\{"jsonrpc":"2.0","id":1,"result":{"tools":[],"supportedVersions":["2026-07-28"]}}
else
\\{"jsonrpc":"2.0","id":2,"result":{"tools":[]}}
;
try w.print(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {d}\r\nConnection: keep-alive\r\n\r\n{s}",
.{ body.len, body },
);
try w.flush();
}
}
};
test "MCP modern connect + next list reuse one TCP connection" {
if (builtin.os.tag == .windows) return error.SkipZigTest;
const gpa = std.testing.allocator;
const io = std.testing.io;
var addr = try std.Io.net.IpAddress.parseLiteral("127.0.0.1:0");
var listener = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer listener.deinit(io);
var accepts: std.atomic.Value(u8) = .init(0);
var posts: std.atomic.Value(u8) = .init(0);
var done: std.atomic.Value(bool) = .init(false);
var srv: ListSrv = .{ .accepts = &accepts, .posts = &posts, .done = &done };
var fut = io.async(ListSrv.run, .{ &srv, io, &listener });
defer joinReuseServer(io, &listener, &done, &fut);
var url_buf: [64]u8 = undefined;
const url = try std.fmt.bufPrint(&url_buf, "http://127.0.0.1:{d}/mcp", .{listener.socket.address.getPort()});
var arena_state = std.heap.ArenaAllocator.init(gpa);
defer arena_state.deinit();
const arena = arena_state.allocator();
var server: mcp_rpc.Server = .{
.name = "loop",
.transport = .{ .http = .{
.url = url,
.client = .{ .allocator = gpa, .io = io },
} },
};
defer server.transport.http.client.deinit();
const first = try mcp_lifecycle.connectHttp(&server, arena, arena, .unknown);
try std.testing.expect(first.object.get("result") != null);
const second = try mcp_rpc.request(&server, arena, "{}", "tools/list", null);
try std.testing.expect(second.object.get("result") != null);
try std.testing.expectEqual(@as(u8, 1), accepts.load(.monotonic));
try std.testing.expectEqual(@as(u8, 2), posts.load(.monotonic));
}
test "MCP HTTP advertises gzip and decompresses a smaller wire body" {
if (builtin.os.tag == .windows) return error.SkipZigTest;
const gpa = std.testing.allocator;
const io = std.testing.io;
var plain_w: Io.Writer.Allocating = .init(gpa);
defer plain_w.deinit();
try plain_w.writer.writeAll("{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":{\"tools\":[");
for (0..40) |i| {
if (i != 0) try plain_w.writer.writeByte(',');
try plain_w.writer.print(
"{{\"name\":\"tool_{d}\",\"description\":\"search the workspace and return matching files\",\"inputSchema\":{{\"type\":\"object\",\"properties\":{{\"q\":{{\"type\":\"string\"}}}}}}}}",
.{i},
);
}
try plain_w.writer.writeAll("],\"supportedVersions\":[\"2026-07-28\"]}}");
const plain = plain_w.writer.buffered();
const gz = try gzipAlloc(gpa, plain);
defer gpa.free(gz);
try std.testing.expect(gz.len < plain.len);
var saw_accept_gzip = std.atomic.Value(bool).init(false);
var wire_len = std.atomic.Value(usize).init(0);
var addr = try std.Io.net.IpAddress.parseLiteral("127.0.0.1:0");
var listener = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer listener.deinit(io);
const Srv = struct {
fn run(
io_: Io,
listener_: *std.Io.net.Server,
gz_: []const u8,
saw: *std.atomic.Value(bool),
wire: *std.atomic.Value(usize),
) void {
const stream = listener_.accept(io_) catch return;
defer stream.close(io_);
var rbuf: [4096]u8 = undefined;
var rd = std.Io.net.Stream.Reader.init(stream, io_, &rbuf);
const r = &rd.interface;
var content_len: usize = 0;
var accept_enc: bool = false;
while (true) {
const line = (r.takeDelimiter('\n') catch return) orelse return;
if (line.len == 0 or (line.len == 1 and line[0] == '\r')) break;
if (std.ascii.startsWithIgnoreCase(line, "accept-encoding:") and
std.mem.indexOf(u8, line, "gzip") != null) accept_enc = true;
if (std.ascii.startsWithIgnoreCase(line, "content-length:")) {
const raw = if (line[line.len - 1] == '\r') line[0 .. line.len - 1] else line;
content_len = std.fmt.parseInt(usize, std.mem.trim(u8, raw["content-length:".len..], " \t"), 10) catch 0;
}
}
if (content_len > 0) _ = r.take(content_len) catch {};
saw.store(accept_enc, .release);
wire.store(gz_.len, .release);
var wbuf: [1024]u8 = undefined;
var wr = std.Io.net.Stream.Writer.init(stream, io_, &wbuf);
wr.interface.print(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Encoding: gzip\r\nContent-Length: {d}\r\nConnection: close\r\n\r\n",
.{gz_.len},
) catch return;
wr.interface.writeAll(gz_) catch return;
wr.interface.flush() catch {};
}
};
var fut = io.async(Srv.run, .{ io, &listener, gz, &saw_accept_gzip, &wire_len });
defer fut.await(io);
var url_buf: [64]u8 = undefined;
const url = try std.fmt.bufPrint(&url_buf, "http://127.0.0.1:{d}/mcp", .{listener.socket.address.getPort()});
var http: mcp_http.HttpTransport = .{
.url = url,
.client = .{ .allocator = gpa, .io = io },
};
defer http.client.deinit();
const body = (try mcp_http.post(&http, "{}", .{
.protocol_version = mcp_protocol.modern_protocol,
.method = "tools/list",
.modern = true,
}, 1)) orelse return error.TestUnexpectedResult;
defer gpa.free(body);
try std.testing.expect(saw_accept_gzip.load(.acquire));
try std.testing.expectEqual(gz.len, wire_len.load(.acquire));
try std.testing.expect(wire_len.load(.acquire) < plain.len);
try std.testing.expectEqualStrings(plain, body);
}
test "MCP HTTP no longer omits Accept-Encoding" {
const src = @embedFile("mcp_http.zig");
const omit = "accept_encoding = " ++ ".omit";
try std.testing.expect(std.mem.indexOf(u8, src, omit) == null);
try std.testing.expect(std.mem.indexOf(u8, src, "readerDecompressing") != null);
}
/// #849: Zig runs `defer` in reverse source order. Stop the accept loop
/// before the wake connect, then join. A wake-before-stop leaves the
/// server blocked on `accept` with no further connection. Extra wakes
/// after 2s keep a failed cleanup from stalling `zig build test`.
fn joinReuseServer(io: Io, listener: *std.Io.net.Server, done: *std.atomic.Value(bool), fut: anytype) void {
done.store(true, .release);
if (std.Io.net.IpAddress.connect(&listener.socket.address, io, .{ .mode = .stream })) |s| {
s.close(io);
} else |_| {}
const watchdog = struct {
fn run(io_: Io, finished: *std.atomic.Value(bool), listener_: *std.Io.net.Server) void {
var i: u32 = 0;
while (i < 40) : (i += 1) {
if (finished.load(.acquire)) return;
io_.sleep(.fromMilliseconds(50), .awake) catch return;
}
if (std.Io.net.IpAddress.connect(&listener_.socket.address, io_, .{ .mode = .stream })) |s| {
s.close(io_);
} else |_| {}
}
};
var finished: std.atomic.Value(bool) = .init(false);
var wd = io.async(watchdog.run, .{ io, &finished, listener });
fut.await(io);
finished.store(true, .release);
wd.await(io);
}
test "MCP reuse teardown stops the listener before the wake accept" {
const src = @embedFile("net_efficiency_test.zig");
const helper = std.mem.indexOf(u8, src, "fn joinReuseServer(").?;
const stop = std.mem.indexOfPos(u8, src, helper, "done.store(true, .release)").?;
const wake = std.mem.indexOfPos(u8, src, stop, "IpAddress.connect(&listener.socket.address").?;
const join = std.mem.indexOfPos(u8, src, wake, "fut.await(io)").?;
try std.testing.expect(stop < wake);
try std.testing.expect(wake < join);
}
test "#849: blocked accept loop joins within a bound after stop-then-wake" {
if (builtin.os.tag == .windows) return error.SkipZigTest;
const io = std.testing.io;
var addr = try std.Io.net.IpAddress.parseLiteral("127.0.0.1:0");
var listener = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer listener.deinit(io);
var accepts: std.atomic.Value(u8) = .init(0);
var posts: std.atomic.Value(u8) = .init(2);
var done: std.atomic.Value(bool) = .init(false);
var srv: ListSrv = .{ .accepts = &accepts, .posts = &posts, .done = &done };
var fut = io.async(ListSrv.run, .{ &srv, io, &listener });
const t0 = std.Io.Timestamp.now(io, .awake).nanoseconds;
joinReuseServer(io, &listener, &done, &fut);
const ms = @divTrunc(std.Io.Timestamp.now(io, .awake).nanoseconds - t0, std.time.ns_per_ms);
try std.testing.expect(ms < 2000);
}
fn gzipAlloc(gpa: std.mem.Allocator, plain: []const u8) ![]u8 {
var out_buf: [4096]u8 = undefined;
var out: Io.Writer = .fixed(&out_buf);
const window = try gpa.alloc(u8, std.compress.flate.max_window_len);
defer gpa.free(window);
const c = try gpa.create(std.compress.flate.Compress);
defer gpa.destroy(c);
c.* = try std.compress.flate.Compress.init(&out, window, .gzip, .default);
try c.writer.writeAll(plain);
try c.finish();
return gpa.dupe(u8, out.buffered());
}