graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
Expose binary thinking controls for supported models
Rach Pradhan1461462fe9eb
diff --git a/apps/native/components/primitives/ModelEffortButtons.tsx b/apps/native/components/primitives/ModelEffortButtons.tsxindex 507b3179..45c0d0f6 100644--- a/apps/native/components/primitives/ModelEffortButtons.tsx+++ b/apps/native/components/primitives/ModelEffortButtons.tsx@@ -4,7 +4,7 @@ import { createPortal } from "react-dom";import type { ModelChoice } from "@/lib/acp-client";import styles from "./EffortPicker.module.css";import ContextMeter from "./ContextMeter";-const labels: Record<string, string> = { low: "Light", medium: "Medium", high: "High", xhigh: "Extra high", max: "Max", ultra: "Ultra" };+const labels: Record<string, string> = { none: "Off", low: "Light", medium: "Medium", high: "High", xhigh: "Extra high", max: "Max", ultra: "Ultra" };const effortPanelWidth = 200;const effortPanelMargin = 12;function Bolt({ filled = false }: { filled?: boolean }) {@@ -29,13 +29,16 @@ export default function ModelEffortButtons({ model, buttonRef, modelOpen, openMoconst panel = useRef<HTMLDivElement>(null);const effortButton = useRef<HTMLButtonElement>(null);const levels = model.effortLevels ?? [];- const index = Math.max(0, levels.indexOf(model.effort ?? "medium"));+ const binaryThinking = levels.length === 2 && levels[0] === "none" && levels[1] === "high";+ const label = (level: string) => binaryThinking && level === "high" ? "On" : labels[level] ?? level;+ const defaultEffort = binaryThinking ? "high" : "medium";+ const index = Math.max(0, levels.indexOf(model.effort ?? defaultEffort));const confirmed = useRef(index); confirmed.current = index;const show = () => {const rect = effortButton.current?.getBoundingClientRect();if (rect) setPosition({ left: Math.max(effortPanelMargin, Math.min(window.innerWidth - effortPanelWidth - effortPanelMargin, rect.right - effortPanelWidth)), bottom: window.innerHeight - rect.top + 10 });if (modelOpen) openModel();- setDraft(Math.max(0, levels.indexOf(desired ?? model.effort ?? "medium"))); setOpen(true);+ setDraft(Math.max(0, levels.indexOf(desired ?? model.effort ?? defaultEffort))); setOpen(true);};useEffect(() => {if (desired === null) setDraft(index);@@ -85,7 +88,7 @@ export default function ModelEffortButtons({ model, buttonRef, modelOpen, openMo<span className="truncate" title={pending ? `Next message: ${displayName}` : displayName}>{displayName}{pending && <span className="text-ink-3"> · Next</span>}</span><span className="shrink-0"><Chevron /></span></button>{levels.length > 0 && <button ref={effortButton} type="button" aria-label="Select effort" aria-expanded={open} onClick={show}- className="flex h-7 shrink-0 items-center gap-1.5 rounded-full px-2 text-xs text-ink-3 hover:bg-hover">{labels[desired ?? model.effort ?? ""] ?? "Effort"}<Chevron /></button>}+ className="flex h-7 shrink-0 items-center gap-1.5 rounded-full px-2 text-xs text-ink-3 hover:bg-hover">{label(desired ?? model.effort ?? defaultEffort)}<Chevron /></button>}{model.key && levels.length === 0 && <span className="shrink-0 px-2 text-xs text-ink-3" title={model.effortLevels ? "This model does not offer configurable reasoning effort." : "Reasoning settings will appear after this model's capabilities are loaded."}>{model.effortLevels ? "Fixed reasoning" : "Reasoning pending"}</span>}{showContextMeter && <ContextMeter reading={contextMeter} />}{open && createPortal(<div ref={panel} role="dialog" aria-label="Reasoning effort" style={{ ...position, width: effortPanelWidth }}@@ -95,13 +98,13 @@ export default function ModelEffortButtons({ model, buttonRef, modelOpen, openMotitle={model.fastSupported ? "Priority service for lower latency; may use more of your allowance" : "Fast mode is available for Codex models"}onClick={() => void change(`/fast ${model.fast ? "off" : "on"}`)}className={`flex size-5 shrink-0 items-center justify-center rounded-full transition-colors disabled:opacity-30 [&_svg]:size-3.5 ${model.fast ? "bg-accent-tint text-accent" : "text-ink-3 hover:bg-hover"}`}><Bolt filled={!!model.fast} /></button>- <div className="min-w-0 text-center"><div className="text-xs font-medium leading-3 text-accent">{labels[levels[draft]] ?? levels[draft]}</div><div className="mt-px truncate text-[9px] leading-2.5 text-ink-3">{saving ? <span role="status">Saving…</span> : displayName}</div></div>- <button type="button" aria-label="Reset effort to medium" title="Reset effort to medium" disabled={blocked || !levels.includes("medium")} onClick={() => { setDraft(levels.indexOf("medium")); void change("/effort medium"); }} className="flex size-5 shrink-0 items-center justify-center rounded-full text-ink-3 hover:bg-hover disabled:opacity-30 [&_svg]:size-3.5"><svg aria-hidden="true" width="19" height="19" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.7" strokeLinecap="round" strokeLinejoin="round"><path d="M4 10a8 8 0 1 1 0 5M4 4v6h6" /></svg></button>+ <div className="min-w-0 text-center"><div className="text-xs font-medium leading-3 text-accent">{label(levels[draft])}</div><div className="mt-px truncate text-[9px] leading-2.5 text-ink-3">{saving ? <span role="status">Saving…</span> : displayName}</div></div>+ <button type="button" aria-label={`Reset effort to ${label(defaultEffort)}`} title={`Reset effort to ${label(defaultEffort)}`} disabled={blocked || !levels.includes(defaultEffort)} onClick={() => { setDraft(levels.indexOf(defaultEffort)); void change(`/effort ${defaultEffort}`); }} className="flex size-5 shrink-0 items-center justify-center rounded-full text-ink-3 hover:bg-hover disabled:opacity-30 [&_svg]:size-3.5"><svg aria-hidden="true" width="19" height="19" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.7" strokeLinecap="round" strokeLinejoin="round"><path d="M4 10a8 8 0 1 1 0 5M4 4v6h6" /></svg></button></div><div className={styles.slider}><div aria-hidden="true" className={styles.track}><div className={styles.fill} style={{ width: draft === 0 ? 0 : `calc(10px + (100% - 20px) * ${progress})` }} /></div><div aria-hidden="true" className={styles.stops}>{levels.map((level, i) => <span key={level} className={`${styles.stop} ${i < draft ? styles.passed : ""}`} style={{ left: `${i / Math.max(1, levels.length - 1) * 100}%` }} />)}</div>- <input type="range" aria-label="Reasoning effort level" aria-valuetext={labels[levels[draft]] ?? levels[draft]} min={0} max={Math.max(0, levels.length - 1)} step={1} value={draft} disabled={blocked}+ <input type="range" aria-label="Reasoning effort level" aria-valuetext={label(levels[draft])} min={0} max={Math.max(0, levels.length - 1)} step={1} value={draft} disabled={blocked}onChange={event => setDraft(Number(event.target.value))} onPointerUp={event => apply(event.currentTarget.value)} onKeyUp={event => apply(event.currentTarget.value)}className={styles.range} /></div>diff --git a/docs/adr/0192-mimo-thinking-is-a-binary-setting.md b/docs/adr/0192-mimo-thinking-is-a-binary-setting.mdnew file mode 100644index 00000000..70841939--- /dev/null+++ b/docs/adr/0192-mimo-thinking-is-a-binary-setting.md@@ -0,0 +1,34 @@+# 0192. MiMo thinking is Off or On++Status: accepted 2026-09-23++## Context++MiMo's [Responses API](https://mimo.mi.com/docs/en-US/api/chat/responses)+documents `reasoning.effort=none` as Off and every positive effort as the same+On mode. Its [Chat API](https://mimo.mi.com/docs/en-US/api/chat/openai-api)+controls the same choice with `thinking.type=disabled|enabled`. Showing Low,+Medium, and High as distinct MiMo intensities claims a control the API does not+provide. The generic flash default-to-low rule in ADR 0046 applies to other+models; for MiMo, Low still means On.++## Decision++Expose only Off (`none`) and On (`high`) for MiMo on the direct Xiaomi and+Codegraff gateway routes in the REPL, ACP, and desktop model controls. An+unrelated provider's MiMo-named alias retains its existing controls until its+wire format is verified. Existing saved or typed positive effort values still mean On;+they display as On and use the canonical wire value. Direct and gateway Chat+requests send `thinking.type`; Responses requests use `reasoning.effort`. Keep+assistant `reasoning_content` alongside tool calls in subsequent Chat requests.++An explicit Off selection, including a worker override, is rejected on other+routes before inference. If a model switch+leaves Off unsupported, reset to Medium with a notice; loading a stale saved+Off setting for another model does the same before inference.++## Consequences++The UI no longer promises a MiMo reasoning-intensity ladder. Existing positive+preferences continue to run with thinking enabled. A model switch may reset+the global effort setting, and the notice makes that change visible.diff --git a/docs/adr/README.md b/docs/adr/README.mdindex f46a4e41..3ea46f0f 100644--- a/docs/adr/README.md+++ b/docs/adr/README.md@@ -217,6 +217,7 @@ record only when you need the evidence or the edge cases.| [0189](0189-bounded-buffered-http2-posts.md) | Buffered HTTP/2 posts cap body growth, use exclusive pooled leases with durable transport allocation, join deadlines, and never replay ambiguous sends. || [0190](0190-catalog-gets-share-bounded-http2-transport.md) | Catalog GETs use bounded HTTP/2 pages with joined deadlines, shared redirect limits, and credentials scoped to the original origin. || [0191](0191-acp-effort-is-session-configuration.md) | ACP thought-level options follow the active model and share `/effort` state; changes received during a turn apply after that turn. |+| [0192](0192-mimo-thinking-is-a-binary-setting.md) | MiMo exposes Off/On, preserves legacy positive settings as On, and uses the documented thinking control on each wire. |## When to write onediff --git a/src/acp.zig b/src/acp.zigindex 54d69de1..67178e8a 100644--- a/src/acp.zig+++ b/src/acp.zig@@ -246,9 +246,9 @@ pub fn runAcpCommand(gpa: Allocator, io: Io, environ_map: anytype, root: *agent_.tick => @import("acp_idle.zig").maybeWake(&d, arena, out, io, root.session_name) catch |err| {std.debug.print("acp: idle wake failed: {t}\n", .{err});},- .line => |line| handleLine(&d, arena, out, line) catch |err| {- std.debug.print("acp: dispatch failed: {t}\n", .{err});- break;+ .line => |line| {+ handleLine(&d, arena, out, line) catch |err| { std.debug.print("acp: dispatch failed: {t}\n", .{err}); break; };+ @import("acp_idle.zig").startupEffortNotice(&d, root, out) catch break;},}out.flush() catch break;diff --git a/src/acp_config.zig b/src/acp_config.zigindex 5babfa48..0d91301a 100644--- a/src/acp_config.zig+++ b/src/acp_config.zig@@ -6,7 +6,9 @@ const er = @import("effort_route.zig");const LiveTurn = @import("acp_live_turn.zig").LiveTurn;const ReasoningEffort = @import("main.zig").ReasoningEffort;-fn label(tag: []const u8) []const u8 {+fn label(tag: []const u8, mimo: bool) []const u8 {+ if (mimo and std.mem.eql(u8, tag, "none")) return "Off";+ if (mimo and std.mem.eql(u8, tag, "high")) return "On";if (std.mem.eql(u8, tag, "low")) return "Low";if (std.mem.eql(u8, tag, "medium")) return "Medium";if (std.mem.eql(u8, tag, "high")) return "High";@@ -19,9 +21,10 @@ pub fn option(ctx: *anyopaque, arena: Allocator) anyerror!?engine.ConfigOption {const live: *LiveTurn = @ptrCast(@alignCast(ctx));const root = live.root;if (!root.effortApplies()) return null;+ if (root.reasoning == .none and !er.mimoRoute(root.provider.id, root.provider.model)) return error.ReasoningOffUnsupported;const levels = er.levels(root.provider.id, root.provider.model);const values = try arena.alloc(engine.ConfigValue, levels.len);- for (levels, values) |tag, *value| value.* = .{ .value = tag, .name = label(tag) };+ for (levels, values) |tag, *value| value.* = .{ .value = tag, .name = label(tag, er.mimoRoute(root.provider.id, root.provider.model)) };const normalized = er.normalize(root.provider.id, root.provider.model, @tagName(root.reasoning));return .{ .currentValue = if (er.allows(root.provider.id, root.provider.model, normalized)) normalized else "high", .options = values };}@@ -29,8 +32,9 @@ pub fn option(ctx: *anyopaque, arena: Allocator) anyerror!?engine.ConfigOption {pub fn set(ctx: *anyopaque, value: []const u8) anyerror!bool {const live: *LiveTurn = @ptrCast(@alignCast(ctx));const root = live.root;- if (!root.effortApplies() or !er.allows(root.provider.id, root.provider.model, value)) return false;- root.reasoning = std.meta.stringToEnum(ReasoningEffort, value) orelse return false;+ const canonical = er.normalize(root.provider.id, root.provider.model, value);+ if (!root.effortApplies() or !er.allows(root.provider.id, root.provider.model, canonical)) return false;+ root.reasoning = std.meta.stringToEnum(ReasoningEffort, canonical) orelse return false;_ = @import("repl_glue.zig").saveThinkingSettings(root.io, root.gpa, root.reasoning, root.fast, root.ultracode_mode, root.show_thinking, root.ai_title);return true;}@@ -58,3 +62,28 @@ test "thought-level options follow the active model allowlist and normalized curroot.provider.model = "claude-opus-4-8";try std.testing.expect((try option(&live, arena)) == null);}++test "MiMo thought-level discovery names Off and On and normalizes saved positive levels" {+ var state = std.heap.ArenaAllocator.init(std.testing.allocator);+ defer state.deinit();+ const arena = state.allocator();+ var root = try @import("agent_request_body_responses.zig").testAgentFor(arena, "xiaomi", .openai, "mimo-v2.6-flash");+ var keys: @import("provider.zig").Keys = .{ .values = @splat(null) };+ var live: LiveTurn = .{ .root = &root, .keys = &keys, .out = undefined };+ root.reasoning = .low;+ const on = (try option(&live, arena)).?;+ try std.testing.expectEqualStrings("high", on.currentValue);+ try std.testing.expectEqual(@as(usize, 2), on.options.len);+ try std.testing.expectEqualStrings("none", on.options[0].value);+ try std.testing.expectEqualStrings("Off", on.options[0].name);+ try std.testing.expectEqualStrings("high", on.options[1].value);+ try std.testing.expectEqualStrings("On", on.options[1].name);+ try std.testing.expect(er.allows("xiaomi", "mimo-v2.6-flash", "none"));+ root.reasoning = .none;+ try std.testing.expectEqualStrings("none", (try option(&live, arena)).?.currentValue);+ root.provider.id = "openai";+ root.provider.kind = .responses;+ root.provider.model = "gpt-6-astra";+ try std.testing.expectError(error.ReasoningOffUnsupported, option(&live, arena));+ try std.testing.expect(!er.allows("openai", "gpt-6-astra", "none"));+}diff --git a/src/acp_idle.zig b/src/acp_idle.zigindex 55d86059..fbb3c444 100644--- a/src/acp_idle.zig+++ b/src/acp_idle.zig@@ -12,6 +12,26 @@ const idle_wake = @import("idle_wake_sources.zig");const peer_idle = @import("peer_idle.zig");const peer_inbox = @import("peer_inbox.zig");+pub fn startupEffortNotice(d: *engine.Dispatch, root: anytype, w: *Io.Writer) !void {+ const sid = d.session_id orelse return;+ const notice = root.startup_effort_notice orelse return;+ try engine.writeSessionUpdate(w, sid, notice);+ root.startup_effort_notice = null;+}++test "stale effort reset reaches ACP once after session creation" {+ var root = struct { startup_effort_notice: ?[]const u8 = "Off reset to Medium." }{};+ var d: engine.Dispatch = .{ .turn = echoTurn, .ctx = undefined, .session_id = "s" };+ var buf: [512]u8 = undefined;+ var writer: Io.Writer = .fixed(&buf);+ try startupEffortNotice(&d, &root, &writer);+ try std.testing.expect(std.mem.indexOf(u8, writer.buffered(), "Off reset to Medium.") != null);+ try std.testing.expect(root.startup_effort_notice == null);+ const first_len = writer.buffered().len;+ try startupEffortNotice(&d, &root, &writer);+ try std.testing.expectEqual(first_len, writer.buffered().len);+}+pub fn maybeWake(d: *engine.Dispatch, arena: Allocator, w: *Io.Writer, io: Io, session_name: []const u8) !void {const sid = d.session_id orelse return;if (sid.len == 0) return;diff --git a/src/agent.zig b/src/agent.zigindex d29783c0..fc27488a 100644--- a/src/agent.zig+++ b/src/agent.zig@@ -162,6 +162,7 @@ pub const Agent = struct {goal_note_fp: u64 = 0, // last-injected standing-goal note fingerprint (goal_state.steeringGate, #318)goal_note_age: u32 = 0, // turns since that note was last injected (refresh interval)pending_goal_note: ?[]const u8 = null, // one-shot supersession note for the next turn (/goal replace|clear)+ startup_effort_notice: ?[]const u8 = null, // ACP presents a corrected stale effort setting after session/newcompletion_gate_armed: bool = false, // attempt_completion was refused; the promised second call closes the goal. Persists ACROSS turns (a model emits one per turn) until the checklist or goal changes (#318)completion_refused: bool = false, // a refused attempt_completion this turn: work the model must react to, so /loop must not read the turn as zero-tool (#318)todos_dirty: bool = false, // todo_write ran in THIS process: a checklist restored from disk is persisted state, never evidence that the current prompt is done (#318)@@ -267,8 +268,8 @@ pub const Agent = struct {/// Whether the active provider honors a reasoning-effort hint: the/// Responses API (codex, native xAI) via reasoning.effort, and the- /// OpenAI-compatible providers that normalize reasoning_effort — native- /// xAI chat, the codegraff gateway, and deepseek. Everything else ignores it.+ /// OpenAI-compatible providers that expose a thinking or effort control,+ /// including native xAI chat, MiMo, the codegraff gateway, and deepseek.pub fn effortApplies(self: *const Agent) bool {return schema.providerTakesEffort(self.provider.kind, self.provider.id, self.provider.model);}diff --git a/src/agent_prompt.zig b/src/agent_prompt.zigindex fdf69f88..9d38e849 100644--- a/src/agent_prompt.zig+++ b/src/agent_prompt.zig@@ -122,6 +122,7 @@ fn effortTier(effort: main_mod.ReasoningEffort) engine_events.ReasoningEffort {.xhigh => .xhigh,.max => .max,.ultra => .ultra,+ .none => .none,};}@@ -138,7 +139,7 @@ fn effectiveEffort(self: *Agent) ?engine_events.ReasoningEffort {}if (!self.effortApplies()) return null;const er = @import("effort_route.zig");- const wire = er.wireEffort(self.provider.model, @tagName(self.reasoning));+ const wire = er.wireEffort(self.provider.id, self.provider.model, @tagName(self.reasoning));const display = er.normalize(self.provider.id, self.provider.model, wire);inline for (std.meta.tags(main_mod.ReasoningEffort)) |tag| {if (std.mem.eql(u8, @tagName(tag), display)) return effortTier(tag);diff --git a/src/agent_prompt_render.zig b/src/agent_prompt_render.zigindex 29c3280a..3741151f 100644--- a/src/agent_prompt_render.zig+++ b/src/agent_prompt_render.zig@@ -28,6 +28,7 @@ pub fn reasoningLabel(effort: anytype) []const u8 {.xhigh => "Extra high",.max => "Max",.ultra => "Ultra",+ .none => "Off",};}@@ -39,6 +40,7 @@ pub fn reasoningColor(effort: anytype) []const u8 {.xhigh => style.accent,.max => style.red,.ultra => style.accent,+ .none => style.green,};}@@ -165,13 +167,14 @@ fn line(w: *Io.Writer, st: PromptStatus, cols: usize) !void {}test "reasoning prompt label uses picker wording" {- const Effort = enum { low, medium, high, xhigh, max, ultra };+ const Effort = enum { low, medium, high, xhigh, max, ultra, none };try std.testing.expectEqualStrings("Low", reasoningLabel(Effort.low));try std.testing.expectEqualStrings("Medium", reasoningLabel(Effort.medium));try std.testing.expectEqualStrings("High", reasoningLabel(Effort.high));try std.testing.expectEqualStrings("Extra high", reasoningLabel(Effort.xhigh));try std.testing.expectEqualStrings("Max", reasoningLabel(Effort.max));try std.testing.expectEqualStrings("Ultra", reasoningLabel(Effort.ultra));+ try std.testing.expectEqualStrings("Off", reasoningLabel(Effort.none));}test "compact token counts keep prompt usage readable" {diff --git a/src/agent_request_body.zig b/src/agent_request_body.zigindex 70e69f81..cfaf6dfd 100644--- a/src/agent_request_body.zig+++ b/src/agent_request_body.zig@@ -1,5 +1,4 @@//! Provider-specific request-body serialization.-const std = @import("std");const Io = std.Io;const Value = std.json.Value;@@ -23,6 +22,7 @@ pub fn responsesOutputLimit(self: *const Agent) u32 {}pub fn buildBody(self: *Agent, tools_in: ?[]const u8, force_tool: bool, stream: bool, stream_usage: bool) ![]u8 {+ if (self.reasoning == .none and !@import("effort_route.zig").mimoRoute(self.provider.id, self.provider.model)) return error.ReasoningOffUnsupported;// #695: an EMPTY catalog string means "omit tools" — `""` serialized the malformed `"tools":,` that 400s every provider (0.0.280).const tools: ?[]const u8 = if (tools_in) |t| (if (t.len == 0) null else t) else null;var aw: Io.Writer.Allocating = .init(self.gpa);@@ -173,8 +173,8 @@ pub fn buildBody(self: *Agent, tools_in: ?[]const u8, force_tool: bool, stream:// official maximize-hits). Root is the project id; children// share a role lane so sibling scouts reuse system+tools.try http_headers.writeRequestCacheKey(&s, self.io, self.label, self, self.provider.id);- // reasoning_effort (codegraff/deepseek/zai) + Z.AI thinking + Vercel reasoning.effort.- try @import("zai_wire.zig").writeChatExtras(&s, self.provider.id, self.provider.model, self.sendReasoningEffort(), @import("effort_route.zig").wireEffort(self.provider.model, @tagName(self.reasoning)));+ // Provider-specific thinking controls and reasoning effort.+ try @import("zai_wire.zig").writeChatExtras(&s, self.provider.id, self.provider.model, self.sendReasoningEffort(), @import("effort_route.zig").wireEffort(self.provider.id, self.provider.model, @tagName(self.reasoning)));// --output-schema: structured outputs (xAI docs' response_format).// A provider that rejected json_schema (#543, deepseek) degrades// dsh-style: the tools-off formatting turn carries the schema as adiff --git a/src/agent_request_body_responses.zig b/src/agent_request_body_responses.zigindex 6ad76d07..f97639e7 100644--- a/src/agent_request_body_responses.zig+++ b/src/agent_request_body_responses.zig@@ -90,7 +90,7 @@ pub fn write(self: *Agent, s: *std.json.Stringify, tools: ?[]const u8, force_tootry s.objectField("effort");// #379: compaction summaries run at low — a high-effort reasoner can// complete with only reasoning items and zero output text.- try s.write(if (self.compaction_request or self.server_compaction_request) "low" else @import("effort_route.zig").wireEffort(self.provider.model, @tagName(self.reasoning)));+ try s.write(if ((self.compaction_request or self.server_compaction_request) and !@import("effort_route.zig").mimoRoute(self.provider.id, self.provider.model)) "low" else @import("effort_route.zig").wireEffort(self.provider.id, self.provider.model, @tagName(self.reasoning)));// summary:auto streams reasoning_summary_text.delta (reasoningDelta already parses it); without it silent reasoning emits NO frames — the stall watchdog cannot tell thinking from a dead socket.if (is_codex) {try s.objectField("summary");diff --git a/src/commands_effort.zig b/src/commands_effort.zigindex 8ee84cf4..f14b3bea 100644--- a/src/commands_effort.zig+++ b/src/commands_effort.zig@@ -13,8 +13,14 @@ const reasoning_levels = [_]pickers.PickItem{.{ .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[@intFromEnum(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;@@ -35,7 +41,10 @@ pub fn handle(root: *Agent, arena: std.mem.Allocator, line: []const u8, out: *stfor (levels, 0..) |tag, i| {const effort = std.meta.stringToEnum(ReasoningEffort, tag).?;tags[i] = effort;- rows[i] = reasoning_levels[@intFromEnum(effort)];+ rows[i] = if (er.mimoRoute(root.provider.id, root.provider.model) and effort == .high)+ .{ .name = "On", .desc = "Enable model reasoning" }+ else+ reasoning_levels[@intFromEnum(effort)];if (effort == current) cur = i;}const idx = pickers.listPickerAt(root, arena, out, title, rows[0..levels.len], cur) orelse return true;@@ -59,14 +68,14 @@ pub fn handle(root: *Agent, arena: std.mem.Allocator, line: []const u8, out: *st};} else {const current = normalized(root, @tagName(root.reasoning)).?;- try out.print("reasoning effort: {s}\n", .{reasoning_levels[@intFromEnum(current)].name});+ try out.print("reasoning effort: {s}\n", .{display(root, current)});try out.flush();return true;}_ = @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", .{- reasoning_levels[@intFromEnum(root.reasoning)].name,- if (!root.effortApplies()) " (current model ignores it — applies to xai, codex, deepseek, codegraff)" else "",+ display(root, root.reasoning),+ if (!root.effortApplies()) " (current model ignores it — applies to supported reasoning models)" else "",});try out.flush();return true;diff --git a/src/effort_route.zig b/src/effort_route.zigindex 42b3a397..dcc4dd6e 100644--- a/src/effort_route.zig+++ b/src/effort_route.zig@@ -65,6 +65,17 @@ pub fn grokFamily(model: []const u8) bool {return std.mem.startsWith(u8, model, "grok");}+/// MiMo's current APIs expose thinking as a binary switch. Gateway catalog+/// rows may include a family prefix; inspect the final model component.+pub fn mimoFamily(model: []const u8) bool {+ const name = if (std.mem.lastIndexOfScalar(u8, model, '/')) |slash| model[slash + 1 ..] else model;+ return std.ascii.startsWithIgnoreCase(name, "mimo-");+}++pub fn mimoRoute(provider_id: []const u8, model: []const u8) bool {+ return (std.mem.eql(u8, provider_id, "xiaomi") or std.mem.eql(u8, provider_id, "codegraff")) and mimoFamily(model);+}+/// Hide Max/Ultra in the picker when the current seat cannot take them.pub fn hidesMax(provider_id: []const u8, model: []const u8) bool {return std.mem.eql(u8, provider_id, "xai") or grokFamily(model);@@ -78,6 +89,7 @@ fn openaiFamily(provider_id: []const u8, model: []const u8) bool {/// Picker tags, not API values: OpenAI's maximum is exposed as Ultra./// Keep xAI's stricter allow-list ahead of model-family detection.pub fn levels(provider_id: []const u8, model: []const u8) []const []const u8 {+ if (mimoRoute(provider_id, model)) return &.{ "none", "high" };if (hidesMax(provider_id, model)) return &.{ "low", "medium", "high", "xhigh" };if (openaiFamily(provider_id, model)) return &.{ "low", "medium", "high", "xhigh", "ultra" };return &.{ "low", "medium", "high", "xhigh", "max", "ultra" };@@ -86,6 +98,13 @@ pub fn levels(provider_id: []const u8, model: []const u8) []const []const u8 {/// Accept old saved/typed Max settings without putting Max back in the UI./// Ultra keeps its existing wire mapping to `max` and delegation guidance.pub fn normalize(provider_id: []const u8, model: []const u8, requested: []const u8) []const u8 {+ if (mimoRoute(provider_id, model)) {+ if (std.mem.eql(u8, requested, "none") or std.mem.eql(u8, requested, "off")) return "none";+ for ([_][]const u8{ "minimal", "low", "medium", "high", "xhigh", "max", "ultra", "on" }) |positive|+ if (std.mem.eql(u8, requested, positive)) return "high";+ return requested;+ }+ if (std.mem.eql(u8, requested, "none")) return ""; // unsupported outside MiMoif (!hidesMax(provider_id, model) and openaiFamily(provider_id, model) and std.mem.eql(u8, requested, "max")) return "ultra";return requested;}@@ -98,7 +117,8 @@ pub fn allows(provider_id: []const u8, model: []const u8, tag: []const u8) bool/// Wire `reasoning_effort` for an effort-capable provider. Flash / Gemini/// default `medium` becomes `low`. grok maps max/ultra → high (xAI rejects/// `max`). Other seats still send ultra as `max` (including OpenAI).-pub fn wireEffort(model: []const u8, requested: []const u8) []const u8 {+pub fn wireEffort(provider_id: []const u8, model: []const u8, requested: []const u8) []const u8 {+ if (mimoRoute(provider_id, model)) return if (std.mem.eql(u8, requested, "none")) "none" else "high";if (std.mem.eql(u8, requested, "medium") and omitsDefaultFlashEffort(model)) return "low";if (grokFamily(model)) {if (std.mem.eql(u8, requested, "max") or std.mem.eql(u8, requested, "ultra")) return "high";@@ -132,17 +152,17 @@ test "flash and Gemini map default medium to low; grok and glm-5.3 stay medium"try std.testing.expect(!omitsDefaultFlashEffort("glm-5.3"));try std.testing.expect(!omitsDefaultFlashEffort("deepseek-v4-pro"));try std.testing.expect(!omitsDefaultFlashEffort("gpt-6-astra"));- try std.testing.expectEqualStrings("medium", wireEffort("gpt-6-astra", "medium"));- try std.testing.expectEqualStrings("high", wireEffort("gpt-5.6-sol", "high"));- try std.testing.expectEqualStrings("high", wireEffort("gpt-6-astra", "high"));- try std.testing.expectEqualStrings("low", wireEffort("glm-5.3-flash", "medium"));- try std.testing.expectEqualStrings("high", wireEffort("glm-5.3-flash", "high"));- try std.testing.expectEqualStrings("medium", wireEffort("grok-4.6", "medium"));- try std.testing.expectEqualStrings("high", wireEffort("grok-4.6", "ultra"));- try std.testing.expectEqualStrings("high", wireEffort("grok-4.6", "max"));- try std.testing.expectEqualStrings("xhigh", wireEffort("grok-4.6", "xhigh"));- try std.testing.expectEqualStrings("xhigh", wireEffort("grok-4.7", "xhigh"));- try std.testing.expectEqualStrings("high", wireEffort("grok-4.7", "ultra"));+ try std.testing.expectEqualStrings("medium", wireEffort("openai", "gpt-6-astra", "medium"));+ try std.testing.expectEqualStrings("high", wireEffort("openai", "gpt-5.6-sol", "high"));+ try std.testing.expectEqualStrings("high", wireEffort("openai", "gpt-6-astra", "high"));+ try std.testing.expectEqualStrings("low", wireEffort("zai", "glm-5.3-flash", "medium"));+ try std.testing.expectEqualStrings("high", wireEffort("zai", "glm-5.3-flash", "high"));+ try std.testing.expectEqualStrings("medium", wireEffort("xai", "grok-4.6", "medium"));+ try std.testing.expectEqualStrings("high", wireEffort("xai", "grok-4.6", "ultra"));+ try std.testing.expectEqualStrings("high", wireEffort("xai", "grok-4.6", "max"));+ try std.testing.expectEqualStrings("xhigh", wireEffort("xai", "grok-4.6", "xhigh"));+ try std.testing.expectEqualStrings("xhigh", wireEffort("xai", "grok-4.7", "xhigh"));+ try std.testing.expectEqualStrings("high", wireEffort("xai", "grok-4.7", "ultra"));try std.testing.expect(hidesMax("xai", "grok-4.6"));try std.testing.expect(hidesMax("xai", "grok-4.7"));try std.testing.expect(!hidesMax("codex", "gpt-5.6-sol"));@@ -167,11 +187,33 @@ test "GPT-5.6 family: max is accepted (as Ultra) and wired as max; grok still fotry std.testing.expectEqualStrings("ultra", normalize(s.id, s.model, "max"));try std.testing.expect(allows(s.id, s.model, "ultra"));try std.testing.expect(allows(s.id, s.model, "xhigh"));- try std.testing.expectEqualStrings("max", wireEffort(s.model, "ultra"));- try std.testing.expectEqualStrings("xhigh", wireEffort(s.model, "xhigh"));- try std.testing.expectEqualStrings("medium", wireEffort(s.model, "medium")); // not a flash/Astra seat: default medium is sent as-is+ try std.testing.expectEqualStrings("max", wireEffort("openai", s.model, "ultra"));+ try std.testing.expectEqualStrings("xhigh", wireEffort("openai", s.model, "xhigh"));+ try std.testing.expectEqualStrings("medium", wireEffort("openai", s.model, "medium")); // not a flash/Astra seat: default medium is sent as-is}try std.testing.expectEqualStrings("max", normalize("xai", "grok-4.6", "max")); // untouched, then refusedtry std.testing.expect(!allows("xai", "grok-4.6", "max"));try std.testing.expect(!allows("xai", "grok-4.6", "ultra"));}++test "MiMo exposes only Off and On while legacy positive settings remain On" {+ for ([_][]const u8{ "mimo-v2.6-flash", "MiMo-V2.6-Pro", "xiaomi/mimo-v2.6-pro" }) |model| {+ try std.testing.expect(mimoFamily(model));+ const offered = levels("codegraff", model);+ try std.testing.expectEqual(@as(usize, 2), offered.len);+ try std.testing.expectEqualStrings("none", offered[0]);+ try std.testing.expectEqualStrings("high", offered[1]);+ try std.testing.expectEqualStrings("none", normalize("xiaomi", model, "off"));+ try std.testing.expectEqualStrings("none", wireEffort("codegraff", model, "none"));+ for ([_][]const u8{ "low", "medium", "high", "xhigh", "max", "ultra" }) |legacy| {+ try std.testing.expectEqualStrings("high", normalize("xiaomi", model, legacy));+ try std.testing.expectEqualStrings("high", wireEffort("codegraff", model, legacy));+ }+ }+ try std.testing.expectEqualStrings("", normalize("openai", "gpt-6-astra", "none"));+ try std.testing.expect(!allows("openai", "gpt-6-astra", "none"));+ try std.testing.expect(!allows("custom", "mimo-v2.6-flash", "none"));+ try std.testing.expectEqualStrings("", normalize("custom", "mimo-v2.6-flash", "none"));+ try std.testing.expectEqualStrings("low", wireEffort("custom", "mimo-v2.6-flash", "low"));+ try std.testing.expectEqualStrings("low", wireEffort("zai", "glm-5.3-flash", "medium"));+}diff --git a/src/engine_events.zig b/src/engine_events.zigindex cbb39266..eb418905 100644--- a/src/engine_events.zig+++ b/src/engine_events.zig@@ -178,7 +178,7 @@ pub const SessionSaved = struct { name: []const u8, ext: []const u8 };// mistranslation./// Reasoning depth, when the provider takes one at all (main.ReasoningEffort).-pub const ReasoningEffort = enum { low, medium, high, xhigh, max, ultra };+pub const ReasoningEffort = enum { low, medium, high, xhigh, max, ultra, none };/// The federated-learning privacy ceiling (learning_privacy.Mode).pub const PrivacyTier = enum { local, aggregate, templates, examples };diff --git a/src/http_client_trajectory_tests.zig b/src/http_client_trajectory_tests.zigindex bbe87856..da149a3c 100644--- a/src/http_client_trajectory_tests.zig+++ b/src/http_client_trajectory_tests.zig@@ -7,6 +7,43 @@ const support = @import("http_client_integration_tests.zig");const subagent = @import("subagent.zig");const tools = @import("tools.zig");+test "unsupported explicit worker Off returns an error before any child request" {+ const gpa = std.testing.allocator;+ const io = std.testing.io;+ var runtime: http_client.Runtime = undefined;+ runtime.init(gpa, io);+ defer runtime.deinit(io);+ var address = try std.Io.net.IpAddress.parseLiteral("127.0.0.1:0");+ var server = try std.Io.net.IpAddress.listen(&address, io, .{});+ defer server.deinit(io);+ const replies = [_]support.Reply{.{ .body = support.chat_body }};+ var accepted: std.atomic.Value(usize) = .init(0);+ var server_future = io.async(support.serveReplies, .{ io, &server, @as([]const support.Reply, &replies), &accepted });+ defer server_future.await(io);+ defer support.releaseAccept(io, &server);+ var url_buf: [64]u8 = undefined;+ const url = try std.fmt.bufPrint(&url_buf, "http://127.0.0.1:{d}/v1/test", .{server.socket.address.getPort()});+ const ctx: tools.ToolCtx = .{+ .gpa = gpa,+ .io = io,+ .client = &runtime.client,+ .provider = support.provider(url),+ .registry = null,+ .from_sub = false,+ .approvals = null,+ .tracer = null,+ };+ const parsed = try std.json.parseFromSlice(std.json.Value, gpa,+ \\{"description":"offline worker","prompt":"reply once","effort":"none","run_in_background":true}+ , .{});+ defer parsed.deinit();+ const result = try subagent.execSubagent(ctx, parsed.value);+ defer gpa.free(result.text);+ try std.testing.expect(result.is_error);+ try std.testing.expect(std.mem.indexOf(u8, result.text, "Off is unsupported") != null);+ try std.testing.expectEqual(@as(usize, 0), accepted.load(.acquire));+}+test "background subagent tool recovers TLS and completes through agent_output" {const gpa = std.testing.allocator;const io = std.testing.io;diff --git a/src/main.zig b/src/main.zigindex 9f43a840..b6c304d8 100644--- a/src/main.zig+++ b/src/main.zig@@ -158,7 +158,7 @@ const telemetry = @import("telemetry.zig");pub var g_fleet: bool = true;const unixMs = util.unixMs;/// Reasoning depth for codex/responses (OpenAI Responses `reasoning.effort`).-pub const ReasoningEffort = enum { low, medium, high, xhigh, max, ultra };+pub const ReasoningEffort = enum { low, medium, high, xhigh, max, ultra, none };pub const repl_commands = command_catalog.names;// Lifecycle hooks (Hook/Hooks config types + settings loader + per-hook subprocess runner) live in hooks.zig; g_hooks below, dispatch, and the codedb-guard cache stay here.const hooks = @import("hooks.zig");@@ -579,7 +579,7 @@ test { // ── Unit tests (`zig build test`): pull in tests from imported modu_ = .{ @import("http2_pool.zig"), @import("agent_stream_h2.zig"), @import("agent_stream_h2_transport_test.zig") }; // h2 stream path, and graff's request/response contract over the pinned http-zig_ = @import("tui_acp_updates.zig");_ = @import("acp_preauth.zig"); // credential-free ACP loop must stay in the test root- _ = .{ @import("acp_protocol.zig"), @import("subagent_mimo_tests.zig"), @import("gateway_picker_catalog.zig") };+ _ = .{ @import("acp_protocol.zig"), @import("subagent_mimo_tests.zig"), @import("mimo_effort_tests.zig"), @import("gateway_picker_catalog.zig") };_ = @import("task_outcome.zig"); // goal-outcome telemetry events_ = @import("learn_delete.zig"); // #303: its tests were dead until listed here_ = .{ @import("additional_tests.zig"), @import("req_stats.zig"), @import("exact_reply.zig"), @import("rlm_order_tests.zig"), @import("async_tool_policy.zig"), @import("agent_async_tools.zig"), @import("request_usage_attempts.zig") };diff --git a/src/mainloop.zig b/src/mainloop.zigindex 75136bef..6be5a599 100644--- a/src/mainloop.zig+++ b/src/mainloop.zig@@ -239,7 +239,7 @@ pub fn run(ctx: *Ctx) !void {if (std.mem.eql(u8, rtype, "set_effort")) {const level = if (parsed.object.get("level")) |v| (if (v == .string) v.string else "") else "";ctx.root.reasoning = std.meta.stringToEnum(main_mod.ReasoningEffort, @import("effort_route.zig").normalize(ctx.root.provider.id, ctx.root.provider.model, level)) orelse {- ctx.root.emit(.{ .type = "error", .message = "set_effort needs level low|medium|high|xhigh|max|ultra" });+ ctx.root.emit(.{ .type = "error", .message = "set_effort needs a level supported by the current model" });continue;};_ = repl_glue.saveThinkingSettings(ctx.root.io, ctx.root.gpa, ctx.root.reasoning, ctx.root.fast, ctx.root.ultracode_mode, ctx.root.show_thinking, ctx.root.ai_title);diff --git a/src/mimo_effort_tests.zig b/src/mimo_effort_tests.zignew file mode 100644index 00000000..8df70f49--- /dev/null+++ b/src/mimo_effort_tests.zig@@ -0,0 +1,48 @@+const std = @import("std");+const provider = @import("provider.zig");+const schema = @import("schema.zig");+const fixtures = @import("agent_request_body_responses.zig");++test "MiMo Chat uses the documented binary thinking switch on direct and gateway routes" {+ var state = std.heap.ArenaAllocator.init(std.testing.allocator);+ defer state.deinit();+ for ([_][]const u8{ "xiaomi", "codegraff" }) |id| {+ var agent = try fixtures.testAgentFor(state.allocator(), id, .openai, "mimo-v2.6-flash");+ try std.testing.expect(schema.providerTakesEffort(agent.provider.kind, id, agent.provider.model));+ agent.reasoning = .none;+ const off = try agent.buildBody(null, false, true, true);+ defer std.testing.allocator.free(off);+ try std.testing.expect(std.mem.indexOf(u8, off, "\"thinking\":{\"type\":\"disabled\"}") != null);+ try std.testing.expect(std.mem.indexOf(u8, off, "reasoning_effort") == null);+ agent.reasoning = .low; // a saved positive level still means On+ const on = try agent.buildBody(null, false, true, true);+ defer std.testing.allocator.free(on);+ try std.testing.expect(std.mem.indexOf(u8, on, "\"thinking\":{\"type\":\"enabled\"}") != null);+ try std.testing.expect(std.mem.indexOf(u8, on, "reasoning_effort") == null);+ }+}++test "MiMo Responses sends none or high, including internal summaries" {+ var state = std.heap.ArenaAllocator.init(std.testing.allocator);+ defer state.deinit();+ var agent = try fixtures.testAgentFor(state.allocator(), "xiaomi", .responses, "mimo-v2.6-pro");+ agent.reasoning = .none;+ agent.compaction_request = true;+ const off = try agent.buildBody(null, false, true, true);+ defer std.testing.allocator.free(off);+ try std.testing.expect(std.mem.indexOf(u8, off, "\"reasoning\":{\"effort\":\"none\"}") != null);+ agent.compaction_request = false;+ agent.reasoning = .medium;+ const on = try agent.buildBody(null, false, true, true);+ defer std.testing.allocator.free(on);+ try std.testing.expect(std.mem.indexOf(u8, on, "\"reasoning\":{\"effort\":\"high\"}") != null);+}++test "Off is refused before serialization for unrelated providers" {+ var state = std.heap.ArenaAllocator.init(std.testing.allocator);+ defer state.deinit();+ var agent = try fixtures.testAgentFor(state.allocator(), "openai", .responses, "gpt-6-astra");+ agent.reasoning = .none;+ try std.testing.expectError(error.ReasoningOffUnsupported, agent.buildBody(null, false, true, true));+ try std.testing.expect(!schema.providerTakesEffort(provider.Provider.Kind.openai, "xiaomi", "unrelated"));+}diff --git a/src/prompt_astra.zig b/src/prompt_astra.zigindex d49539eb..eb4a8b1a 100644--- a/src/prompt_astra.zig+++ b/src/prompt_astra.zig@@ -112,7 +112,7 @@ test "GPT6 emitted requests keep one stable guidance block and refresh on modeltry testing.expect(std.mem.indexOf(u8, instructions, "# Astra working guidance") == null);try testing.expect(std.mem.indexOf(u8, instructions, "# GPT-6 Sol working guidance") == null);}- try testing.expectEqualStrings(if (std.mem.eql(u8, model, "mimo-v2.6-flash")) "low" else "medium", parsed.value.object.get("reasoning").?.object.get("effort").?.string);+ try testing.expectEqualStrings(if (std.mem.eql(u8, model, "mimo-v2.6-flash")) (if (std.mem.eql(u8, provider, "codegraff")) "high" else "low") else "medium", parsed.value.object.get("reasoning").?.object.get("effort").?.string);var followup: std.json.ObjectMap = .empty;try followup.put(a, "role", .{ .string = "user" });try followup.put(a, "content", .{ .string = "continue with the requested work" });diff --git a/src/providers.zig b/src/providers.zigindex 0a51bb17..065bb367 100644--- a/src/providers.zig+++ b/src/providers.zig@@ -18,7 +18,6 @@ const router_catalog = @import("router_catalog.zig");const serde = @import("serde.zig");const saveModel = serde.saveModel;-const messages_mod = @import("messages.zig");const textMessage = messages_mod.textMessage;const engine_sink = @import("engine_sink.zig"); // #429: the failover notice is a typed event, not a print@@ -93,11 +92,12 @@ pub fn applyProviderInner(root: *Agent, arena: Allocator, p: Provider, persist:}}@import("jev_tool.zig").updateProvider(root, p);- // #371: the #291 worker default resolved once at startup; without this a- // /model switch left children on the OLD provider's rung (root on codex,- // workers silently still on kimi — a cost and consent surprise) or with- // no ladder descent at all. Only the DERIVED default follows the root;- // explicit --subagent-* choices stay exactly as the user stated them.+ if (root.reasoning == .none and !@import("effort_route.zig").mimoRoute(p.id, p.model)) {+ root.reasoning = .medium;+ if (persist) _ = @import("repl_glue.zig").saveThinkingSettings(root.io, root.gpa, root.reasoning, root.fast, root.ultracode_mode, root.show_thinking, root.ai_title);+ note = try std.fmt.allocPrint(arena, "{s}; reasoning reset to Medium (Off unsupported by this model)", .{note});+ }+ // #371: only a derived worker default follows a model switch; explicit pins remain.if (!root.subagent_provider_explicit) if (@import("bench_priors.zig").g_keys) |k| {root.subagent_provider = @import("subagent_selection.zig").resolveSubagentProvider(k.*, p, null, null, false, false);};diff --git a/src/repl_glue.zig b/src/repl_glue.zigindex 8ecc37ad..326a7166 100644--- a/src/repl_glue.zig+++ b/src/repl_glue.zig@@ -505,7 +505,7 @@ pub fn saveThinkingSettings(io: Io, gpa: Allocator, effort: ReasoningEffort, fas}/// Load persisted thinking controls into the root agent at startup:-/// {"effort": "low|medium|high|xhigh|max|ultra"} and {"fast": true}. Best-effort — a missing+/// {"effort": "none|low|medium|high|xhigh|max|ultra"} and {"fast": true}. Best-effort — a missing/// or garbled file just leaves the defaults (medium, off).pub fn loadThinkingSettings(io: Io, arena: Allocator, root: *Agent) void {root.fallback_allow = fallback_config.load(io, arena);@@ -530,6 +530,12 @@ pub fn loadThinkingSettings(io: Io, arena: Allocator, root: *Agent) void {if (v.object.get("session_recap")) |rv| {if (rv == .bool) root.ai_recap = rv.bool;}+ if (root.reasoning == .none and !@import("effort_route.zig").mimoRoute(root.provider.id, root.provider.model)) {+ root.reasoning = .medium;+ root.startup_effort_notice = "Saved reasoning Off is unsupported by this model; reset to Medium.";+ std.log.warn("{s}", .{root.startup_effort_notice.?});+ _ = saveThinkingSettings(io, root.gpa, root.reasoning, root.fast, root.ultracode_mode, root.show_thinking, root.ai_title);+ }}/// REPL slash commands share the leading `/` with absolute POSIX paths. Onlydiff --git a/src/repl_turn.zig b/src/repl_turn.zigindex d9fcfcc7..5bc9f476 100644--- a/src/repl_turn.zig+++ b/src/repl_turn.zig@@ -100,6 +100,7 @@ pub fn turnAgent(.xhigh => .xhigh,.max => .max,.ultra => .ultra,+ .none => .none,},.fast = params.fast,.fallback_allow = c.fallback_allow,diff --git a/src/repl_types.zig b/src/repl_types.zigindex 651b884e..2f9927d9 100644--- a/src/repl_types.zig+++ b/src/repl_types.zig@@ -12,7 +12,7 @@const std = @import("std");-pub const Effort = enum { low, medium, high, xhigh, max, ultra };+pub const Effort = enum { low, medium, high, xhigh, max, ultra, none };pub const Turn = struct {role: Role,diff --git a/src/schema.zig b/src/schema.zigindex 96105bfc..3fd7c8e6 100644--- a/src/schema.zig+++ b/src/schema.zig@@ -379,6 +379,7 @@ fn providerLoginKind(id: []const u8) []const u8 {/// turns out to reject it.pub fn providerTakesEffort(kind: Provider.Kind, id: []const u8, model: []const u8) bool {if (std.mem.startsWith(u8, model, "grok")) return std.mem.eql(u8, id, "xai");+ if (@import("effort_route.zig").mimoRoute(id, model)) return true;return kind == .responses or(std.mem.eql(u8, id, "kimi") and pricing.kimiSupportsThinking(model)) or(if (provider_mod.specFor(id)) |spec| spec.takes_effort else false);diff --git a/src/spec_prompt_cache_conformance.zig b/src/spec_prompt_cache_conformance.zigindex 3891174a..e8e6ea7c 100644--- a/src/spec_prompt_cache_conformance.zig+++ b/src/spec_prompt_cache_conformance.zig@@ -171,7 +171,7 @@ test "prompt cache: effort is never auto-flipped (prefix stays)" {defer std.testing.allocator.free(b1);const b2 = try root.buildBody(null, false, true, true);defer std.testing.allocator.free(b2);- try std.testing.expect(std.mem.indexOf(u8, b1, "\"reasoning_effort\":\"medium\"") != null);- try std.testing.expect(std.mem.indexOf(u8, b2, "\"reasoning_effort\":\"medium\"") != null);+ try std.testing.expect(std.mem.indexOf(u8, b1, "\"thinking\":{\"type\":\"enabled\"}") != null);+ try std.testing.expect(std.mem.indexOf(u8, b2, "\"thinking\":{\"type\":\"enabled\"}") != null);try std.testing.expectEqualStrings(cacheKeyIn(b1).?, cacheKeyIn(b2).?);}diff --git a/src/subagent.zig b/src/subagent.zigindex 9689f345..94d0f8ea 100644--- a/src/subagent.zig+++ b/src/subagent.zig@@ -71,6 +71,7 @@ pub fn execSubagent(ctx: ToolCtx, input: Value) !ToolOutput {const cell: route_policy.Cell = .{ .role = route_policy.roleOf(label, niche) };// #380: vision-aware seat + honesty flag (this file is at the cap).const ask = vision_ask.seat(ctx, base, obj, cell, label, prompt, sys_override, niche);+ if (ask.pin.effort_outcome == .unsupported_effort) return .{ .text = try ctx.gpa.dupe(u8, "subagent: Off is unsupported by this model; choose a supported effort"), .is_error = true };if (ask.blocked) return .{ .text = try vision_ask.blockMessage(ctx.gpa, ask), .is_error = true };const keep = tools.json_args.flag(input, "retained");if (ctx.interactive_children or tools.json_args.flag(input, "run_in_background")) {diff --git a/src/subagent_pin.zig b/src/subagent_pin.zigindex 84ca9979..f3308229 100644--- a/src/subagent_pin.zig+++ b/src/subagent_pin.zig@@ -140,12 +140,14 @@ pub const EffortOutcome = enum {none,pinned,unknown_effort,+ unsupported_effort,pub fn describe(self: EffortOutcome) []const u8 {return switch (self) {.none => "",.pinned => "effort pin applied",.unknown_effort => "effort pin ignored: expected low, medium, high, xhigh or max — kept the session default",+ .unsupported_effort => "Off is unsupported by this model; choose a supported effort",};}};@@ -433,8 +435,12 @@ pub fn forSpawnIn(base: Provider, obj: std.json.ObjectMap, sub_ok: bool, cell: Cbreak :blk resolveIn(base, pin, cell);};if (pin.effort) |e| {- out.effort = e;- out.effort_outcome = .pinned;+ if (e == .none and !@import("effort_route.zig").mimoRoute((out.provider orelse base).id, (out.provider orelse base).model)) {+ out.effort_outcome = .unsupported_effort;+ } else {+ out.effort = e;+ out.effort_outcome = .pinned;+ }} else if (pin.bad_effort) out.effort_outcome = .unknown_effort;return out;}diff --git a/src/zai_wire.zig b/src/zai_wire.zigindex e686e7d1..2e453156 100644--- a/src/zai_wire.zig+++ b/src/zai_wire.zig@@ -44,6 +44,14 @@ pub fn isDeepseekFamily(provider_id: []const u8, model: []const u8) bool {/// OpenAI-chat extras after `prompt_cache_key`: Z.AI thinking, Vercel/// `reasoning.effort`, DeepSeek thinking on/off, then `reasoning_effort`.pub fn writeChatExtras(s: *std.json.Stringify, provider_id: []const u8, model: []const u8, send_effort: bool, requested: []const u8) !void {+ if (@import("effort_route.zig").mimoRoute(provider_id, model)) {+ try s.objectField("thinking");+ try s.beginObject();+ try s.objectField("type");+ try s.write(if (std.mem.eql(u8, requested, "none")) "disabled" else "enabled");+ try s.endObject();+ return;+ }const is_zai = std.mem.eql(u8, provider_id, "zai");const is_vercel = std.mem.eql(u8, provider_id, "vercel");if (is_zai) {