Skip to content

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

Python

Start loopback regression peers eagerly

justrach0f6b7f5617ad
diff --git a/src/agent_stream_stall_test.zig b/src/agent_stream_stall_test.zig
index 2458bd2a..874eee9e 100644
--- a/src/agent_stream_stall_test.zig
+++ b/src/agent_stream_stall_test.zig
@@ -114,7 +114,7 @@ test "#682: a subagent-shaped agent streams — completes on the terminal event,
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
// Connection 1 finishes its stream; connection 2 goes quiet after the prose.
- var fut = io.async(Srv.runTwo, .{ io, &server, &done });
+ var fut = try io.concurrent(Srv.runTwo, .{ io, &server, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -170,7 +170,7 @@ test "#680: each stall reconnect widens the between-lines wait the SSE reader ar
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io); // registered first → torn down LAST, after the task is joined
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Srv.run, .{ io, &server, @as(usize, 3), &done });
+ var fut = try io.concurrent(Srv.run, .{ io, &server, @as(usize, 3), &done });
defer fut.await(io);
defer done.store(true, .release); // …so the LIFO order is: signal, join, close
@@ -269,7 +269,7 @@ test "Chat terminal marker keeps delayed usage and completes silent trailer; non
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(TrailerSrv.run, .{ io, &server, mode, &done });
+ var fut = try io.concurrent(TrailerSrv.run, .{ io, &server, mode, &done });
defer fut.await(io);
defer done.store(true, .release);
var arena_state = std.heap.ArenaAllocator.init(gpa);
@@ -346,7 +346,7 @@ fn thinkPastTightenedBudget(head: []const u8, tail: []const u8) !void {
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(ResponsesSrv.run, .{ io, &server, &done });
+ var fut = try io.concurrent(ResponsesSrv.run, .{ io, &server, &done });
defer fut.await(io);
defer done.store(true, .release);
diff --git a/src/agent_ws_reuse_test.zig b/src/agent_ws_reuse_test.zig
index f21ae287..ea6df486 100644
--- a/src/agent_ws_reuse_test.zig
+++ b/src/agent_ws_reuse_test.zig
@@ -44,7 +44,7 @@ test "#401: silence after streamed tool-argument prose trips the tightened budge
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.arg_prose_then_silence, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.arg_prose_then_silence, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -110,7 +110,7 @@ test "#401: a reused socket that answers nothing fails on the head budget as a t
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.read_then_silence, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.read_then_silence, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -185,7 +185,7 @@ test "#401: a fresh connect keeps the full pre-first-token budget for a slow fir
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.slow_first_frame, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.slow_first_frame, &done });
defer fut.await(io);
defer done.store(true, .release);
diff --git a/src/agent_ws_stall_test.zig b/src/agent_ws_stall_test.zig
index 4af059c1..218122b9 100644
--- a/src/agent_ws_stall_test.zig
+++ b/src/agent_ws_stall_test.zig
@@ -48,7 +48,7 @@ test "#401: silence after frames trips the tightened read budget, not the full p
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io); // registered first → torn down LAST, after the task is joined
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.frame_then_silence, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.frame_then_silence, &done });
defer fut.await(io);
defer done.store(true, .release); // …so the LIFO order is: signal, join, close
@@ -130,7 +130,7 @@ test "ADR 0241: a closed prose item gets the full budget back for a silent think
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.prose_close_then_think, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.prose_close_then_think, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -184,7 +184,7 @@ test "ADR 0248: a commentary heads-up held open keeps the full budget" {
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.commentary_then_think, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.commentary_then_think, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -237,7 +237,7 @@ test "#401 control: a mock that completes the response still finishes the turn c
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.frame_then_complete, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.frame_then_complete, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -301,7 +301,7 @@ test "#401: protocol and reasoning frames do NOT tighten the read budget (SSE pa
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.protocol_then_silence, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.protocol_then_silence, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -367,7 +367,7 @@ test "#401: a peer that stops draining fails the send fast, tears down, and does
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.never_drain, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.never_drain, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -438,7 +438,7 @@ test "#401: a stalled dial fails the turn fast and traces `connect stall` (produ
var server = try std.Io.net.IpAddress.listen(&addr, io, .{});
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
- var fut = io.async(Mock.run, .{ io, &server, Mock.Mode.no_upgrade, &done });
+ var fut = try io.concurrent(Mock.run, .{ io, &server, Mock.Mode.no_upgrade, &done });
defer fut.await(io);
defer done.store(true, .release);
@@ -499,7 +499,7 @@ test "#401: the idle-expiry teardown FINs a suspect socket instead of writing a
defer server.deinit(io);
var done: std.atomic.Value(bool) = .init(false);
var seen: std.atomic.Value(u8) = .init(mock.saw_nothing);
- var fut = io.async(mock.closeObserver, .{ io, &server, &seen, &done });
+ var fut = try io.concurrent(mock.closeObserver, .{ io, &server, &seen, &done });
defer fut.await(io);
defer done.store(true, .release);
diff --git a/src/http_send_test.zig b/src/http_send_test.zig
index 9cf3b349..d944958d 100644
--- a/src/http_send_test.zig
+++ b/src/http_send_test.zig
@@ -67,7 +67,7 @@ fn exercise(mode: Peer.Mode, body_len: usize) !void {
if (builtin.os.tag != .windows) std.posix.setsockopt(listener.socket.handle, std.posix.SOL.SOCKET, std.posix.SO.RCVBUF, std.mem.asBytes(&rcvbuf)) catch {};
var got: std.atomic.Value(usize) = .init(0);
var done: std.atomic.Value(bool) = .init(false);
- var peer = io.async(Peer.run, .{ io, &listener, mode, &got, &done });
+ var peer = try io.concurrent(Peer.run, .{ io, &listener, mode, &got, &done });
defer peer.await(io);
defer done.store(true, .release);