graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
//! Provider-aware /effort and /reasoning selector.
const std = @import("std");
const main_mod = @import("main.zig");
const Agent = @import("agent.zig").Agent;
const ReasoningEffort = main_mod.ReasoningEffort;
const pickers = @import("pickers.zig");
const er = @import("effort_route.zig");
const reasoning_levels = [_]pickers.PickItem{
.{ .name = "Low", .desc = "Fast responses with lighter reasoning" },
.{ .name = "Medium", .desc = "Balances speed and reasoning depth for everyday tasks" },
.{ .name = "High", .desc = "Greater reasoning depth for complex problems" },
.{ .name = "Extra high", .desc = "Extra high reasoning depth for complex problems" },
.{ .name = "Max", .desc = "Maximum reasoning depth for the hardest problems" },
.{ .name = "Ultra", .desc = "Maximum reasoning with automatic task delegation" },
.{ .name = "Off", .desc = "Disable model reasoning" },
};
fn display(root: *Agent, effort: ReasoningEffort) []const u8 {
if (er.mimoRoute(root.provider.id, root.provider.model) and effort == .high) return "On";
return reasoning_levels[@backingInt(effort)].name;
}
fn normalized(root: *Agent, requested: []const u8) ?ReasoningEffort {
const tag = er.normalize(root.provider.id, root.provider.model, requested);
const effort = std.meta.stringToEnum(ReasoningEffort, tag) orelse return null;
return if (er.allows(root.provider.id, root.provider.model, tag)) effort else .high;
}
pub fn handle(root: *Agent, arena: std.mem.Allocator, line: []const u8, out: *std.Io.Writer) !bool {
if (!std.mem.startsWith(u8, line, "/effort") and !std.mem.startsWith(u8, line, "/reasoning")) return false;
const prefix: []const u8 = if (std.mem.startsWith(u8, line, "/effort")) "/effort" else "/reasoning";
const arg = std.mem.trim(u8, line[prefix.len..], " \t");
const levels = er.levels(root.provider.id, root.provider.model);
if (arg.len == 0 and main_mod.use_color and root.in != null) {
const title = try std.fmt.allocPrint(arena, "Reasoning level for {s} ›", .{root.provider.model});
var rows: [reasoning_levels.len]pickers.PickItem = undefined;
var tags: [reasoning_levels.len]ReasoningEffort = undefined;
const current = normalized(root, @tagName(root.reasoning)).?;
var cur: usize = 0;
for (levels, 0..) |tag, i| {
const effort = std.meta.stringToEnum(ReasoningEffort, tag).?;
tags[i] = effort;
rows[i] = if (er.mimoRoute(root.provider.id, root.provider.model) and effort == .high)
.{ .name = "On", .desc = "Enable model reasoning" }
else
reasoning_levels[@backingInt(effort)];
if (effort == current) cur = i;
}
const idx = pickers.listPickerAt(root, arena, out, title, rows[0..levels.len], cur) orelse return true;
root.reasoning = tags[idx];
} else if (arg.len != 0) {
const requested = if (std.mem.eql(u8, arg, "med"))
"medium"
else if (std.mem.eql(u8, arg, "extra") or std.mem.eql(u8, arg, "extra-high") or std.mem.eql(u8, arg, "extra high"))
"xhigh"
else
arg;
root.reasoning = normalized(root, requested) orelse {
try out.writeAll("usage: /effort ");
for (levels, 0..) |tag, i| {
if (i != 0) try out.writeByte('|');
try out.writeAll(tag);
}
try out.writeByte('\n');
try out.flush();
return true;
};
} else {
const current = normalized(root, @tagName(root.reasoning)).?;
try out.print("reasoning effort: {s}\n", .{display(root, current)});
try out.flush();
return true;
}
root.jev_effort_pending.invalidate(root.io);
_ = @import("repl_glue.zig").saveThinkingSettings(root.io, root.gpa, root.reasoning, root.fast, root.ultracode_mode, root.show_thinking, root.ai_title);
try out.print("reasoning effort: {s}{s}\n", .{
display(root, root.reasoning),
if (!root.effortApplies()) " (current model ignores it — applies to supported reasoning models)" else "",
});
try out.flush();
return true;
}