Skip to content

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.tsx
index 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, openMo
const 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, openMo
title={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.md
new file mode 100644
index 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.md
index 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 one
diff --git a/src/acp.zig b/src/acp.zig
index 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.zig
index 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 cur
root.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.zig
index 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.zig
index 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/new
completion_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.zig
index 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.zig
index 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.zig
index 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 a
diff --git a/src/agent_request_body_responses.zig b/src/agent_request_body_responses.zig
index 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_too
try 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.zig
index 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: *st
for (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.zig
index 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 MiMo
if (!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 fo
try 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 refused
try 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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.zig
new file mode 100644
index 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.zig
index 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 model
try 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.zig
index 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.zig
index 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. Only
diff --git a/src/repl_turn.zig b/src/repl_turn.zig
index 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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: C
break :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.zig
index 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) {