use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use anyhow::{Result, bail};
use serde_json::{Value, json};
use tokio::sync::mpsc;
use super::rpc::{Incoming, Rpc};
use super::{AgentEvent, Decision, Events, Proc, StartSpec, Steer, clip, protocol_text};
use crate::ipc::Tier;
pub const ENV: [(&str, &str); 5] = [
("GROK_CLAUDE_MCPS_ENABLED", "0"),
("GROK_CLAUDE_HOOKS_ENABLED", "0"),
("GROK_CLAUDE_SKILLS_ENABLED", "0"),
("GROK_CLAUDE_RULES_ENABLED", "0"),
("GROK_CLAUDE_AGENTS_ENABLED", "0"),
];
const READ_TIER_DISALLOWED: [&str; 12] = [
"write",
"search_replace",
"spawn_subagent",
"workflow",
"scheduler_create",
"scheduler_delete",
"search_tool",
"use_tool",
"image_gen",
"image_edit",
"image_to_video",
"reference_to_video",
];
#[derive(Default)]
struct State {
active: bool,
outstanding: u32,
text: String,
response_complete: bool,
said: bool,
background: HashSet<String>,
loading: bool,
interjections: HashSet<String>,
tools: HashMap<String, ToolCall>,
}
struct ToolCall {
name: String,
summary: (String, String),
}
pub struct Grok {
pub proc: Proc,
rpc: Rpc,
session: String,
state: Arc<Mutex<State>>,
}
impl Grok {
pub async fn start(spec: &StartSpec, exe: &Path, events: Events) -> Result<Grok> {
let args = ["agent", "--no-leader", "stdio"].map(String::from);
let (proc, stdout) = Proc::spawn(exe, &args, spec)?;
let (rpc, incoming) = Rpc::start(stdout, proc.stdin.clone());
let state: Arc<Mutex<State>> = Arc::default();
tokio::spawn(pump(incoming, rpc.clone(), state.clone(), events.clone()));
rpc.call(
"initialize",
json!({
"protocolVersion": 1,
"clientCapabilities": {"fs": {"readTextFile": false, "writeTextFile": false}, "terminal": false},
"clientInfo": {"name": "axiopera", "version": env!("CARGO_PKG_VERSION")},
}),
)
.await?;
let mut meta = match spec.tier {
Tier::Read => json!({
"yoloMode": false,
"autoMode": false,
"agentProfile": {
"name": "axiopera-read",
"description": "Read-only sub-agent.",
"disallowedTools": READ_TIER_DISALLOWED,
},
}),
Tier::Work => json!({"yoloMode": false, "autoMode": true}),
Tier::Full => json!({"yoloMode": true}),
};
meta["rules"] = json!(protocol_text(spec));
let mut params = json!({"cwd": spec.cwd, "mcpServers": [], "_meta": meta});
let (session, reply) = match &spec.resume {
Some(id) => {
params["sessionId"] = json!(id);
state.lock().unwrap().loading = true;
let loaded = rpc.call("session/load", params).await;
{
let mut s = state.lock().unwrap();
s.loading = false;
s.text.clear();
}
(id.clone(), loaded?)
}
None => {
let created = rpc.call("session/new", params).await?;
let id = created["sessionId"].as_str().unwrap_or_default();
(id.to_string(), created)
}
};
let _ = events.send(AgentEvent::Session {
file: Some(session_file(spec, &session)),
id: session.clone(),
});
if spec.tier == Tier::Read
&& let Some(model) = &spec.model
{
keeps_read_profile(&reply, model)?;
}
for (option, what, value) in [
("model", "model", &spec.model),
("reasoning_effort", "reasoning effort", &spec.effort),
] {
let Some(value) = value else { continue };
let params = json!({"sessionId": session, "configId": option, "value": value});
match rpc
.request("session/set_config_option", params)
.await?
.await
{
Ok(Ok(_)) => {}
Ok(Err(e)) if e.code == -32602 => {
bail!("invalid value '{value}' for {what}: Grok rejected it ({e})")
}
Ok(Err(e)) => bail!("setting the {what} failed: {e}"),
Err(_) => bail!("grok exited while setting the {what}"),
}
}
Ok(Grok {
proc,
rpc,
session,
state,
})
}
pub async fn turn(&mut self, text: &str) -> Result<()> {
{
let mut s = self.state.lock().unwrap();
s.active = true;
s.outstanding += 1;
s.text.clear();
}
let params = json!({"sessionId": self.session, "prompt": [{"type": "text", "text": text}]});
self.rpc.request_in_order("session/prompt", params).await?;
Ok(())
}
pub async fn steer(&mut self, text: &str) -> Result<Steer> {
if !self.busy() {
return Ok(Steer::NoActiveTurn);
}
let id = uuid::Uuid::new_v4().to_string();
self.state.lock().unwrap().interjections.insert(id.clone());
self.rpc
.call(
"_x.ai/interject",
json!({"sessionId": self.session, "text": text, "interjectionId": id}),
)
.await?;
Ok(Steer::Accepted)
}
pub async fn interrupt(&mut self) -> Result<()> {
self.rpc
.notify("session/cancel", json!({"sessionId": self.session}))
.await?;
Ok(())
}
pub fn busy(&self) -> bool {
let s = self.state.lock().unwrap();
s.active || !s.background.is_empty() || !s.interjections.is_empty()
}
pub fn in_turn(&self) -> bool {
self.state.lock().unwrap().active
}
}
fn session_file(spec: &StartSpec, id: &str) -> PathBuf {
let home = spec
.env
.iter()
.find(|(k, _)| k == "GROK_HOME")
.map(|(_, v)| PathBuf::from(v))
.unwrap_or_else(|| super::home_dir().join(".grok"));
let cwd: String = spec
.cwd
.to_string_lossy()
.bytes()
.map(|b| match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
(b as char).to_string()
}
_ => format!("%{b:02X}"),
})
.collect();
home.join("sessions")
.join(cwd)
.join(id)
.join("chat_history.jsonl")
}
fn harness<'a>(session: &'a Value, model: &str) -> Option<&'a str> {
session["models"]["availableModels"]
.as_array()?
.iter()
.find(|m| m["modelId"] == model)?["_meta"]["agentType"]
.as_str()
}
fn keeps_read_profile(session: &Value, model: &str) -> Result<()> {
let current = session["models"]["currentModelId"].as_str();
let (Some(wanted), Some(now)) = (
harness(session, model),
current.and_then(|c| harness(session, c)),
) else {
return Ok(());
};
if wanted == now {
return Ok(());
}
let keeping: Vec<&str> = session["models"]["availableModels"]
.as_array()
.into_iter()
.flatten()
.filter(|m| m["_meta"]["agentType"] == now)
.filter_map(|m| m["modelId"].as_str())
.collect();
bail!(
"model '{model}' would make Grok drop the read tier's tool limits; for --tier read pick \
one of {}, or keep this model with --tier work or full",
keeping.join(", ")
)
}
async fn pump(
mut incoming: mpsc::UnboundedReceiver<Incoming>,
rpc: Rpc,
state: Arc<Mutex<State>>,
events: Events,
) {
while let Some(msg) = incoming.recv().await {
match msg {
Incoming::Notification { method, params } => {
on_notification(&method, ¶ms, &state, &events)
}
Incoming::Request { id, method, params } if method == "session/request_permission" => {
let option = |kind: &str| {
params["options"]
.as_array()
.into_iter()
.flatten()
.find(|o| o["kind"] == kind)
.and_then(|o| o["optionId"].as_str())
.map(str::to_string)
};
let command = params["toolCall"]["rawInput"]["command"].as_str();
if command.is_some_and(super::is_axiopera_command)
&& let Some(allow) = option("allow_once")
{
let reply = json!({"outcome": {"outcome": "selected", "optionId": allow}});
let _ = rpc.respond(id, reply).await;
continue;
}
let title = params["toolCall"]["title"].as_str().unwrap_or("tool call");
let summary = match command {
Some(c) => format!("{title}: {}", clip(c, 200)),
None => clip(title, 200),
};
let call = ¶ms["toolCall"];
let mut detail = format!("{title}\n{}", super::arguments(&call["rawInput"]));
for diff in call["content"].as_array().into_iter().flatten() {
if diff["type"] == "diff" {
detail.push_str(&format!(
"\nedit {}:\n--- old\n{}\n+++ new\n{}",
diff["path"].as_str().unwrap_or("?"),
diff["oldText"].as_str().unwrap_or(""),
diff["newText"].as_str().unwrap_or("")
));
}
}
let decision = super::ask_approval(&events, summary, detail);
let (allow, reject) = (
option("allow_once"),
option("reject_once").unwrap_or_else(|| "reject-once".into()),
);
let rpc = rpc.clone();
tokio::spawn(async move {
let reply = match (decision.await, allow) {
(Decision::Approve, Some(allow)) => {
json!({"outcome": {"outcome": "selected", "optionId": allow}})
}
(Decision::Deny(reason), _) => json!({
"outcome": {"outcome": "selected", "optionId": reject},
"_meta": {"followup_message": reason},
}),
(Decision::Approve, None) => json!({
"outcome": {"outcome": "selected", "optionId": reject},
"_meta": {"followup_message":
"Refused by axiopera: the backend offered no one-time approval option."},
}),
};
let _ = rpc.respond(id, reply).await;
});
}
Incoming::Request { id, method, .. } => {
let _ = events.send(AgentEvent::Blocked(format!("{method}: not supported")));
let _ = rpc.respond_error(id, "not supported by axiopera").await;
}
Incoming::Reply(reply) => {
let (ok, error) = match reply {
Ok(r) => {
super::report_model(&events, r["_meta"]["modelId"].as_str());
let stop = r["stopReason"].as_str().unwrap_or("").to_string();
(stop == "end_turn", (stop != "end_turn").then_some(stop))
}
Err(e) => (false, Some(e.to_string())),
};
let mut s = state.lock().unwrap();
s.outstanding = s.outstanding.saturating_sub(1);
s.active = s.outstanding > 0;
say(&mut s, &events);
let result = std::mem::take(&mut s.text);
let _ = events.send(AgentEvent::TurnEnded {
ok,
result,
error,
usage: None,
});
}
}
}
state.lock().unwrap().active = false;
let _ = events.send(AgentEvent::Exited("grok exited".into()));
}
fn on_notification(method: &str, p: &Value, state: &Mutex<State>, events: &Events) {
let was_active = state.lock().unwrap().active;
on_update(method, p, state, events);
if !was_active && state.lock().unwrap().active {
let _ = events.send(AgentEvent::TurnStarted);
}
}
fn on_update(method: &str, p: &Value, state: &Mutex<State>, events: &Events) {
if method == "_x.ai/queue/changed" {
if p["runningPromptId"]
.as_str()
.is_some_and(|id| !id.is_empty())
{
state.lock().unwrap().active = true;
}
return;
}
if method == "_x.ai/session/interjection" {
let mut s = state.lock().unwrap();
s.active = true;
if let Some(id) = p["interjectionId"].as_str() {
s.interjections.remove(id);
}
return;
}
let u = &p["update"];
if u["sessionUpdate"] == "model_changed" {
super::report_settings(
events,
u["model_id"].as_str(),
u["reasoning_effort"].as_str(),
);
return;
}
if !u["sessionUpdate"].is_string() || state.lock().unwrap().loading {
return;
}
match u["sessionUpdate"].as_str().unwrap_or("") {
"agent_message_chunk" => {
let mut s = state.lock().unwrap();
s.active = true;
if s.response_complete {
s.text.clear();
s.response_complete = false;
}
s.text.push_str(u["content"]["text"].as_str().unwrap_or(""));
s.said = false;
}
"response_completed" => {
let mut s = state.lock().unwrap();
s.response_complete = true;
say(&mut s, events);
}
"tool_call" => {
let mut s = state.lock().unwrap();
say(&mut s, events);
s.text.clear();
drop(s);
if u["kind"] == "edit" {
for loc in u["locations"].as_array().into_iter().flatten() {
if let Some(path) = loc["path"].as_str() {
let _ = events.send(AgentEvent::FileChanged(path.to_string()));
}
}
}
let name = u["title"]
.as_str()
.filter(|s| !s.is_empty())
.or_else(|| u["kind"].as_str())
.unwrap_or("tool");
let summary = tool_summary(name, u);
let id = u["toolCallId"].as_str().map(str::to_string);
if let Some(id) = &id {
state.lock().unwrap().tools.insert(
id.clone(),
ToolCall {
name: name.to_string(),
summary: summary.clone(),
},
);
}
let _ = events.send(AgentEvent::Tool {
id,
name: summary.0,
detail: summary.1,
});
}
"tool_call_update" => {
let mut s = state.lock().unwrap();
if let Some(id) = u["toolCallId"].as_str() {
if let Some(call) = s.tools.get_mut(id) {
if !u["rawInput"].is_null()
|| (call.summary.1.is_empty() && u["title"].is_string())
{
let summary = tool_summary(&call.name, u);
if summary != call.summary {
let _ = events.send(AgentEvent::ToolUpdated {
id: id.to_string(),
name: summary.0.clone(),
detail: summary.1.clone(),
});
call.summary = summary;
}
}
}
if matches!(u["status"].as_str(), Some("completed" | "failed")) {
s.tools.remove(id);
}
}
drop(s);
if u["kind"] == "edit" {
for loc in u["locations"].as_array().into_iter().flatten() {
if let Some(path) = loc["path"].as_str() {
let _ = events.send(AgentEvent::FileChanged(path.to_string()));
}
}
}
if u["status"] != "failed" {
return;
}
let text: String = u["content"]
.as_array()
.into_iter()
.flatten()
.filter_map(|c| c["content"]["text"].as_str())
.collect();
if text.contains("Auto mode blocked this action") {
let _ = events.send(AgentEvent::Blocked(clip(&text, 300)));
}
}
"task_backgrounded" => {
if let Some(id) = u["task_id"].as_str() {
state.lock().unwrap().background.insert(id.to_string());
}
}
"task_completed" => {
let mut s = state.lock().unwrap();
if let Some(id) = u["task_snapshot"]["task_id"].as_str()
&& s.background.remove(id)
{
s.active = true;
}
}
"turn_completed" => {
let mut s = state.lock().unwrap();
if s.outstanding > 0 {
return;
}
s.active = false;
say(&mut s, events);
let result = std::mem::take(&mut s.text);
let stop = u["stop_reason"].as_str().unwrap_or("end_turn");
let ok = stop == "end_turn";
let error = (!ok).then(|| stop.to_string());
let _ = events.send(AgentEvent::TurnEnded {
ok,
result,
error,
usage: u.get("usage").cloned(),
});
}
_ => {}
}
}
fn tool_summary(name: &str, update: &Value) -> (String, String) {
let raw = &update["rawInput"];
let target = (name == "use_tool")
.then(|| raw["tool_name"].as_str())
.flatten();
let input = if name == "use_tool" && raw["tool_input"].is_object() {
&raw["tool_input"]
} else {
raw
};
let detail = [
"command",
"query",
"pattern",
"url",
"file_path",
"path",
"target_file",
"target_directory",
"tool_input_file",
"file",
"description",
]
.iter()
.find_map(|key| input[*key].as_str().filter(|s| !s.is_empty()));
let detail = match detail {
Some(text) => text.to_string(),
None if !input.is_null() && input != &json!({}) => input.to_string(),
None => update["title"]
.as_str()
.filter(|title| *title != name)
.unwrap_or("")
.to_string(),
};
(clip(target.unwrap_or(name), 200), clip(&detail, 400))
}
fn say(s: &mut State, events: &Events) {
if !s.said && !s.text.trim().is_empty() {
let _ = events.send(AgentEvent::Said(s.text.clone()));
}
s.said = true;
}
#[cfg(test)]
mod tests {
use super::*;
fn update(state: &Mutex<State>, events: &Events, update: Value) {
let method = match update["sessionUpdate"].as_str() {
Some("response_completed" | "turn_completed") => "_x.ai/session_notification",
_ => "session/update",
};
on_notification(method, &json!({"update": update}), state, events);
}
fn mark(state: &Mutex<State>, events: &Events, kind: &str) {
update(state, events, json!({"sessionUpdate": kind}));
}
#[test]
fn tool_summaries_show_targets_and_mcp_arguments() {
for (name, input, expected_name, expected_detail) in [
(
"read_file",
json!({"target_file": "src/main.rs", "offset": 10}),
"read_file",
"src/main.rs",
),
(
"list_dir",
json!({"target_directory": "src"}),
"list_dir",
"src",
),
(
"grep",
json!({"pattern": "steer", "path": "src"}),
"grep",
"steer",
),
(
"run_terminal_command",
json!({"command": "cargo test", "description": "Run tests"}),
"run_terminal_command",
"cargo test",
),
(
"use_tool",
json!({"tool_name": "web__search", "tool_input": {"query": "pi rpc"}}),
"web__search",
"pi rpc",
),
(
"use_tool",
json!({"tool_name": "web__search", "tool_input_file": "args.json"}),
"web__search",
"args.json",
),
(
"use_tool",
json!({"file": "invocation.json"}),
"use_tool",
"invocation.json",
),
(
"search_tool",
json!({"query": "search web"}),
"search_tool",
"search web",
),
("unknown", json!({"count": 2}), "unknown", "{\"count\":2}"),
("read_file", Value::Null, "read_file", ""),
] {
let summary = tool_summary(name, &json!({"title": name, "rawInput": input}));
assert_eq!(summary, (expected_name.into(), expected_detail.into()));
}
}
#[test]
fn tool_updates_refine_one_call_and_keep_output_out_of_the_summary() {
let state = Mutex::new(State::default());
let (events, mut rx) = mpsc::unbounded_channel();
update(
&state,
&events,
json!({
"sessionUpdate": "tool_call", "toolCallId": "a", "title": "use_tool",
}),
);
assert!(
matches!(rx.try_recv(), Ok(AgentEvent::Tool { id: Some(id), name, detail })
if id == "a" && name == "use_tool" && detail.is_empty())
);
let refined = json!({
"sessionUpdate": "tool_call_update", "toolCallId": "a", "title": "web__search",
"rawInput": {"tool_name": "web__search", "tool_input": {"query": "steer"}},
});
update(&state, &events, refined.clone());
assert!(
matches!(rx.try_recv(), Ok(AgentEvent::ToolUpdated { id, name, detail })
if id == "a" && name == "web__search" && detail == "steer")
);
update(&state, &events, refined);
update(
&state,
&events,
json!({
"sessionUpdate": "tool_call_update", "toolCallId": "a", "status": "completed",
"rawOutput": {"text": "large result"},
}),
);
assert!(rx.try_recv().is_err());
assert!(state.lock().unwrap().tools.is_empty());
update(
&state,
&events,
json!({
"sessionUpdate": "tool_call_update", "toolCallId": "missing", "status": "failed",
"content": [{"content": {"text": "Auto mode blocked this action"}}],
}),
);
assert!(matches!(rx.try_recv(), Ok(AgentEvent::Blocked(_))));
}
fn chunk(state: &Mutex<State>, events: &Events, text: &str) {
let content = json!({"type": "text", "text": text});
update(
state,
events,
json!({"sessionUpdate": "agent_message_chunk", "content": content}),
);
}
#[test]
fn admission_is_not_consumption_and_background_completion_keeps_session_alive() {
let state = Mutex::new(State::default());
let (events, mut rx) = mpsc::unbounded_channel();
state.lock().unwrap().interjections.insert("one".into());
on_notification(
"_x.ai/session/interjection",
&json!({"interjectionId": "one"}),
&state,
&events,
);
assert!(state.lock().unwrap().interjections.is_empty());
assert!(matches!(rx.try_recv(), Ok(AgentEvent::TurnStarted)));
assert!(rx.try_recv().is_err());
update(
&state,
&events,
json!({"sessionUpdate": "task_backgrounded", "task_id": "bg"}),
);
mark(&state, &events, "turn_completed");
assert!(matches!(rx.try_recv(), Ok(AgentEvent::TurnEnded { .. })));
assert!(!state.lock().unwrap().background.is_empty());
update(
&state,
&events,
json!({"sessionUpdate": "task_completed", "task_snapshot": {"task_id": "bg"}}),
);
assert!(state.lock().unwrap().active);
assert!(matches!(rx.try_recv(), Ok(AgentEvent::TurnStarted)));
chunk(&state, &events, "background result");
mark(&state, &events, "turn_completed");
assert!(matches!(rx.try_recv(), Ok(AgentEvent::Said(t)) if t == "background result"));
assert!(
matches!(rx.try_recv(), Ok(AgentEvent::TurnEnded { result, .. }) if result == "background result")
);
}
#[test]
fn interjection_returns_only_last_response() {
let state = Mutex::new(State {
active: true,
..State::default()
});
let (events, mut rx) = mpsc::unbounded_channel();
chunk(&state, &events, "FIRST-");
on_notification("_x.ai/session/interjection", &json!({}), &state, &events);
chunk(&state, &events, "ANSWER");
mark(&state, &events, "response_completed");
assert_eq!(state.lock().unwrap().text, "FIRST-ANSWER");
chunk(&state, &events, "SECOND-");
chunk(&state, &events, "ANSWER");
mark(&state, &events, "response_completed");
mark(&state, &events, "turn_completed");
for said in ["FIRST-ANSWER", "SECOND-ANSWER"] {
assert!(matches!(rx.try_recv(), Ok(AgentEvent::Said(t)) if t == said));
}
match rx.try_recv().unwrap() {
AgentEvent::TurnEnded { ok, result, .. } => {
assert!(ok);
assert_eq!(result, "SECOND-ANSWER");
}
event => panic!("unexpected event: {event:?}"),
}
assert!(rx.try_recv().is_err());
}
#[test]
fn prompt_reply_keeps_completed_response_for_collection() {
let state = Mutex::new(State {
active: true,
outstanding: 1,
..State::default()
});
let (events, mut rx) = mpsc::unbounded_channel();
chunk(&state, &events, "old answer");
mark(&state, &events, "response_completed");
chunk(&state, &events, "final ");
chunk(&state, &events, "answer");
mark(&state, &events, "response_completed");
mark(&state, &events, "turn_completed");
for said in ["old answer", "final answer"] {
assert!(matches!(rx.try_recv(), Ok(AgentEvent::Said(t)) if t == said));
}
assert!(rx.try_recv().is_err());
assert_eq!(state.lock().unwrap().text, "final answer");
}
#[test]
fn tool_preamble_is_not_part_of_final_answer() {
let state = Mutex::new(State::default());
let (events, mut rx) = mpsc::unbounded_channel();
chunk(&state, &events, "Checking files.");
mark(&state, &events, "tool_call");
mark(&state, &events, "response_completed");
chunk(&state, &events, "Final ");
chunk(&state, &events, "answer.");
mark(&state, &events, "response_completed");
assert!(matches!(rx.try_recv(), Ok(AgentEvent::TurnStarted)));
assert!(matches!(rx.try_recv(), Ok(AgentEvent::Said(t)) if t == "Checking files."));
assert!(matches!(rx.try_recv(), Ok(AgentEvent::Tool { .. })));
assert!(matches!(rx.try_recv(), Ok(AgentEvent::Said(t)) if t == "Final answer."));
assert!(rx.try_recv().is_err());
assert_eq!(state.lock().unwrap().text, "Final answer.");
}
#[test]
fn model_changes_count_even_while_loading() {
let state = Mutex::new(State {
loading: true,
..State::default()
});
let (events, mut rx) = mpsc::unbounded_channel();
let update = json!({"update": {"sessionUpdate": "model_changed", "model_id": "grok-4.6",
"reasoning_effort": "low"}});
on_notification("_x.ai/session_notification", &update, &state, &events);
assert!(matches!(rx.try_recv(),
Ok(AgentEvent::Model { model: Some(m), effort: Some(Some(e)) }) if m == "grok-4.6" && e == "low"));
let update = json!({"update": {"sessionUpdate": "model_changed", "model_id": "plain"}});
on_notification("_x.ai/session_notification", &update, &state, &events);
assert!(matches!(
rx.try_recv(),
Ok(AgentEvent::Model {
effort: Some(None),
..
})
));
assert!(rx.try_recv().is_err());
}
#[test]
fn loading_ignores_response_boundaries_and_text() {
let state = Mutex::new(State {
loading: true,
..State::default()
});
let (events, _rx) = mpsc::unbounded_channel();
chunk(&state, &events, "History");
mark(&state, &events, "response_completed");
let s = state.lock().unwrap();
assert!(s.text.is_empty());
assert!(!s.response_complete);
}
#[test]
fn read_tier_refuses_a_model_on_another_harness() {
let session = json!({"models": {"currentModelId": "grok", "availableModels": [
{"modelId": "grok", "_meta": {"agentType": "grok-build-plan"}},
{"modelId": "grok-fast", "_meta": {"agentType": "grok-build-plan"}},
{"modelId": "grok-codex", "_meta": {"agentType": "codex"}},
]}});
assert!(keeps_read_profile(&session, "grok-fast").is_ok());
let refused = keeps_read_profile(&session, "grok-codex")
.unwrap_err()
.to_string();
assert_eq!(
refused,
"model 'grok-codex' would make Grok drop the read tier's tool limits; for --tier read \
pick one of grok, grok-fast, or keep this model with --tier work or full"
);
assert!(keeps_read_profile(&session, "unlisted").is_ok());
assert!(keeps_read_profile(&Value::Null, "grok-codex").is_ok());
}
}