graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
//! Line-composer image chips (#702).
//!
//! Ctrl-V / drop stage pixels on `Agent.pending_images` and insert `[Image #N]`.
//! Deleting a chip must drop that queue slot and rewrite remaining numbers so
//! the next paste is `#1` again — not a ghost `#2`. Content-derived paste
//! traces wait until submit (ADR 0056).
const std = @import("std");
const Allocator = std.mem.Allocator;
const Agent = @import("agent.zig").Agent;
const vision = @import("vision.zig");
const vision_queue = @import("vision_queue.zig");
const input_util = @import("input_util.zig");
const readline_keys = @import("readline_keys.zig");
const PasteStore = @import("readline_paste.zig").Store;
pub const Chip = struct { start: usize, end: usize, n: u8 };
/// `[Image #N]` starting at `i`, or null.
pub fn imageChipAt(text: []const u8, i: usize) ?Chip {
if (!std.mem.startsWith(u8, text[i..], "[Image #")) return null;
var p = i + "[Image #".len;
var num: u16 = 0;
while (p < text.len and text[p] >= '0' and text[p] <= '9') : (p += 1) {
num = num *% 10 + (text[p] - '0');
}
if (num < 1 or num > vision_queue.cap or p >= text.len or text[p] != ']') return null;
return .{ .start = i, .end = p + 1, .n = @intCast(num) };
}
/// Start of the image chip that `cur` is inside (including a trailing space).
pub fn left(text: []const u8, cur: usize) ?usize {
var i: usize = 0;
while (i < text.len) {
if (imageChipAt(text, i)) |chip| {
var end = chip.end;
if (end < text.len and text[end] == ' ') end += 1;
if (cur > chip.start and cur <= end) return chip.start;
i = chip.end;
continue;
}
i += 1;
}
return null;
}
/// End of the image chip that `cur` is inside (including a trailing space).
pub fn right(text: []const u8, cur: usize) ?usize {
var i: usize = 0;
while (i < text.len) {
if (imageChipAt(text, i)) |chip| {
var end = chip.end;
if (end < text.len and text[end] == ' ') end += 1;
if (cur >= chip.start and cur < end) return end;
i = chip.end;
continue;
}
i += 1;
}
return null;
}
/// Word motion/deletion must not enter an image chip. Modified Backspace used
/// the generic word boundary and turned `[Image #2] ` into literal `[Image`.
pub fn prevWord(text: []const u8, cur: usize, pastes: *const PasteStore) usize {
return left(text, cur) orelse pastes.prevWord(text, cur);
}
pub fn nextWord(text: []const u8, cur: usize, pastes: *const PasteStore) usize {
return right(text, cur) orelse pastes.nextWord(text, cur);
}
/// Drop composer slots the buffer no longer names and rewrite remaining `#N`s.
pub fn afterEdit(root: *Agent, gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize) void {
var composer_slots: u16 = 0;
for (root.pending_images[0..root.pending_image_len], 0..) |img, i| {
if (img.from_composer) composer_slots |= @as(u16, 1) << @intCast(i);
}
const remap = vision_queue.retainReferenced(root, buf.items);
rewriteChips(gpa, buf, cur, remap, composer_slots);
}
pub fn deleteAtom(root: *Agent, gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize, pastes: *PasteStore, from: usize, to: usize) void {
pastes.edited(gpa, from, to, 0);
input_util.delRange(buf, from, to);
afterEdit(root, gpa, buf, cur);
}
pub fn deleteModified(root: *Agent, gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize, pastes: *PasteStore, action: readline_keys.ModifiedDelete) bool {
const start = switch (action) {
.delete_word => prevWord(buf.items, cur.*, pastes),
.delete_to_start => 0,
};
if (start >= cur.*) return false;
const old_cur = cur.*;
deleteAtom(root, gpa, buf, cur, pastes, start, old_cur);
cur.* = start;
return true;
}
pub fn clearLine(root: *Agent, gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize, pastes: *PasteStore) void {
buf.clearRetainingCapacity();
pastes.clear(gpa);
cur.* = 0;
afterEdit(root, gpa, buf, cur);
}
/// Rewrite `[Image #old]` to the compacted chip numbers. Identity is a no-op.
pub fn rewriteChips(gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize, remap: vision_queue.Remap, composer_slots: u16) void {
var out: std.ArrayList(u8) = .empty;
defer out.deinit(gpa);
var i: usize = 0;
var new_cur = cur.*;
var changed = false;
while (i < buf.items.len) {
if (imageChipAt(buf.items, i)) |chip| {
const new_n: u8 = if (chip.n >= 1 and chip.n <= vision_queue.cap) remap[chip.n - 1] else 0;
const was_composer = chip.n >= 1 and chip.n <= vision_queue.cap and
(composer_slots & (@as(u16, 1) << @intCast(chip.n - 1))) != 0;
if (new_n == 0 and was_composer) {
changed = true;
var end = chip.end;
if (end < buf.items.len and buf.items[end] == ' ') end += 1;
if (cur.* >= end) {
new_cur -= end - chip.start;
} else if (cur.* > chip.start) {
new_cur = out.items.len;
}
i = end;
continue;
}
var tmp: [20]u8 = undefined;
const repl = if (new_n == 0 or new_n == chip.n)
buf.items[chip.start..chip.end]
else blk: {
changed = true;
break :blk std.fmt.bufPrint(&tmp, "[Image #{d}]", .{new_n}) catch buf.items[chip.start..chip.end];
};
const old_len = chip.end - chip.start;
if (cur.* >= chip.end) {
if (repl.len >= old_len) new_cur += repl.len - old_len else new_cur -= old_len - repl.len;
} else if (cur.* > chip.start) {
new_cur = out.items.len + repl.len;
}
out.appendSlice(gpa, repl) catch return;
i = chip.end;
continue;
}
out.append(gpa, buf.items[i]) catch return;
i += 1;
}
if (!changed) return;
buf.clearRetainingCapacity();
buf.appendSlice(gpa, out.items) catch return;
cur.* = @min(new_cur, buf.items.len);
}
pub fn insertComposerChip(
root: *Agent,
gpa: Allocator,
buf: *std.ArrayList(u8),
cur: *usize,
marks: *std.ArrayList([]const u8),
pastes: *PasteStore,
) void {
vision_queue.markLastComposer(root);
const at = cur.*;
input_util.insertImageChip(gpa, buf, cur, marks, root.pending_image_len);
if (cur.* > at) pastes.edited(gpa, at, at, cur.* - at);
}
fn testAgent(gpa: Allocator) Agent {
return .{
.gpa = gpa,
.arena = gpa,
.io = undefined,
.client = undefined,
.provider = .{ .id = "xai", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "grok-4", .context = 100_000 },
.messages = undefined,
.sub = false,
.label = "test",
.out = null,
};
}
test "Cmd Delete removes UTF-8 prompt prefixes and is idempotent (#981)" {
const gpa = std.testing.allocator;
var root = testAgent(gpa);
var pastes: PasteStore = .{};
defer pastes.deinit(gpa);
var buf: std.ArrayList(u8) = .empty;
defer buf.deinit(gpa);
try buf.appendSlice(gpa, "é alpha beta");
var cur = buf.items.len;
try std.testing.expect(deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_to_start));
try std.testing.expectEqualStrings("", buf.items);
try std.testing.expectEqual(@as(usize, 0), cur);
try std.testing.expect(!deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_to_start));
try buf.appendSlice(gpa, "é alpha beta");
cur = "é alpha".len;
try std.testing.expect(deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_to_start));
try std.testing.expectEqualStrings(" beta", buf.items);
try std.testing.expectEqual(@as(usize, 0), cur);
}
test "Option Delete still removes only the previous word (#981)" {
const gpa = std.testing.allocator;
var root = testAgent(gpa);
var pastes: PasteStore = .{};
defer pastes.deinit(gpa);
var buf: std.ArrayList(u8) = .empty;
defer buf.deinit(gpa);
try buf.appendSlice(gpa, "one two");
var cur = buf.items.len;
try std.testing.expect(deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_word));
try std.testing.expectEqualStrings("one ", buf.items);
try std.testing.expectEqual(@as(usize, 4), cur);
}
test "Cmd Delete removes a composer image prefix atomically (#981)" {
const gpa = std.testing.allocator;
var root = testAgent(gpa);
vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "one.png", .from_composer = true });
var pastes: PasteStore = .{};
defer pastes.deinit(gpa);
var buf: std.ArrayList(u8) = .empty;
defer buf.deinit(gpa);
try buf.appendSlice(gpa, "[Image #1] tail");
var cur: usize = "[Image #1] ".len;
try std.testing.expect(deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_to_start));
try std.testing.expectEqualStrings("tail", buf.items);
try std.testing.expectEqual(@as(usize, 0), cur);
try std.testing.expectEqual(@as(u8, 0), root.pending_image_len);
}
test "imageChipAt parses a numbered marker" {
const chip = imageChipAt("[Image #3] look", 0).?;
try std.testing.expectEqual(@as(usize, 0), chip.start);
try std.testing.expectEqual(@as(usize, 10), chip.end);
try std.testing.expectEqual(@as(u8, 3), chip.n);
try std.testing.expect(imageChipAt("see [Image #1]", 4) != null);
try std.testing.expect(imageChipAt("[Image]", 0) == null);
}
test "left/right treat an image chip as one atom (#702)" {
const text = "hi [Image #1] there";
try std.testing.expectEqual(@as(usize, 3), left(text, 13).?); // on the trailing space
try std.testing.expectEqual(@as(usize, 3), left(text, 12).?); // on ]
try std.testing.expect(left(text, 3) == null);
try std.testing.expectEqual(@as(usize, 14), right(text, 3).?);
try std.testing.expect(right(text, 14) == null);
}
test "word deletion keeps repeated image chips atomic" {
const gpa = std.testing.allocator;
var pastes: PasteStore = .{};
defer pastes.deinit(gpa);
const text = "[Image #1] [Image #2] ";
try std.testing.expectEqual(@as(usize, 11), prevWord(text, text.len, &pastes));
try std.testing.expectEqual(@as(usize, text.len), nextWord(text, 11, &pastes));
}
test "afterEdit drops an abandoned chip and remaps the rest (#702)" {
const gpa = std.testing.allocator;
var root: Agent = .{
.gpa = gpa,
.arena = gpa,
.io = undefined,
.client = undefined,
.provider = .{ .id = "xai", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "grok-4", .context = 100_000 },
.messages = undefined,
.sub = false,
.label = "test",
.out = null,
};
vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "one.png", .from_composer = true });
vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "BBB", .label = "two.png", .from_composer = true });
var buf: std.ArrayList(u8) = .empty;
defer buf.deinit(gpa);
try buf.appendSlice(gpa, "[Image #2] look");
var cur: usize = buf.items.len;
afterEdit(&root, gpa, &buf, &cur);
try std.testing.expectEqual(@as(u8, 1), root.pending_image_len);
try std.testing.expectEqualStrings("BBB", root.pending_images[0].b64);
try std.testing.expectEqualStrings("[Image #1] look", buf.items);
try std.testing.expectEqual(@as(u8, 2), vision_queue.nextChipNumber(&root));
}
test "duplicate composer payload drops its stale chip before #2 is reused" {
const gpa = std.testing.allocator;
var root: Agent = .{
.gpa = gpa,
.arena = gpa,
.io = undefined,
.client = undefined,
.provider = .{ .id = "xai", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "grok-4", .context = 100_000 },
.messages = undefined,
.sub = false,
.label = "test",
.out = null,
};
vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "same.png", .from_composer = true });
vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "same.png", .from_composer = true });
var buf: std.ArrayList(u8) = .empty;
defer buf.deinit(gpa);
try buf.appendSlice(gpa, "[Image #1] [Image #2] ");
var cur: usize = buf.items.len;
afterEdit(&root, gpa, &buf, &cur);
try std.testing.expectEqualStrings("[Image #1] ", buf.items);
try std.testing.expectEqual(@as(usize, buf.items.len), cur);
try std.testing.expectEqual(@as(u8, 1), root.pending_image_len);
vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "same.png" });
var marks: std.ArrayList([]const u8) = .empty;
defer {
for (marks.items) |mark| gpa.free(mark);
marks.deinit(gpa);
}
var pastes: PasteStore = .{};
defer pastes.deinit(gpa);
insertComposerChip(&root, gpa, &buf, &cur, &marks, &pastes);
try std.testing.expectEqualStrings("[Image #1] [Image #2] ", buf.items);
}
test "rewriteChips remaps #2 to #1 after the first slot is dropped (#702)" {
const gpa = std.testing.allocator;
var buf: std.ArrayList(u8) = .empty;
defer buf.deinit(gpa);
try buf.appendSlice(gpa, "[Image #2] look");
var cur: usize = buf.items.len;
var remap: vision_queue.Remap = @splat(0);
remap[1] = 1;
rewriteChips(gpa, &buf, &cur, remap, @as(u16, 1) << 1);
try std.testing.expectEqualStrings("[Image #1] look", buf.items);
try std.testing.expectEqual(@as(usize, buf.items.len), cur);
}