Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat(agent): support validated and replayable in-memory effort (#7156)

Eric Hayesaf9f9ba692d3
diff --git a/crates/agent/src/agent_loop.rs b/crates/agent/src/agent_loop.rs
index 7b2a0d0ae2..a5fea26bcc 100644
--- a/crates/agent/src/agent_loop.rs
+++ b/crates/agent/src/agent_loop.rs
@@ -1,9 +1,9 @@
/// The main entry point: [`AgentLoop`] and [`Session`].
use crate::error::AgentError;
use crate::hook::{BridgeInputs, RegisterFn, ToolRouter, UserToolFinisher};
-use crate::model::PredefinedModel;
use crate::model::metering::MeteringContext;
use crate::model::router::{ModelRouter, ProviderAgent};
+use crate::model::{PredefinedModel, ReasoningEffort};
use crate::stream::ChatCompletionStream;
use crate::telemetry::GenAiContext;
use crate::tool_adapter::DynToolSetAdapter;
@@ -31,6 +31,7 @@ const DEFAULT_MAX_TOKENS: u64 = 16_000;
/// (MCP tools are per-user, system prompt depends on toolset selection).
pub struct AgentLoop {
model: String,
+ reasoning_effort: Option<ReasoningEffort>,
max_turns: usize,
max_tokens: u64,
recorder: Arc<dyn UsageRecorder>,
@@ -56,6 +57,7 @@ impl AgentLoop {
pub fn new(recorder: Arc<dyn UsageRecorder>) -> Self {
Self {
model: PredefinedModel::default().to_string(),
+ reasoning_effort: None,
max_turns: DEFAULT_MAX_TURNS,
max_tokens: DEFAULT_MAX_TOKENS,
recorder,
@@ -89,6 +91,12 @@ impl AgentLoop {
self
}
+ /// Override the model provider's default reasoning effort.
+ pub fn with_reasoning_effort(mut self, effort: ReasoningEffort) -> Self {
+ self.reasoning_effort = Some(effort);
+ self
+ }
+
/// Override the default max tool-calling turns.
pub fn with_max_turns(mut self, n: usize) -> Self {
self.max_turns = n;
@@ -160,16 +168,18 @@ impl AgentLoop {
system_prompt,
usage_ctx,
|handle, prompt, max_turns, max_tokens, telemetry| {
- ModelRouter::shared()
+ let routed = ModelRouter::shared()
.expect("failed to initialize model router")
- .agent(
- &self.model,
- handle,
- prompt,
- max_turns,
- max_tokens,
- telemetry,
- )
+ .route_or_default(&self.model);
+ telemetry.set_model(routed.provider(), routed.model_name());
+ routed.into_agent(
+ self.reasoning_effort,
+ handle,
+ prompt,
+ max_turns,
+ max_tokens,
+ &telemetry,
+ )
},
)
.await
diff --git a/crates/agent/src/lib.rs b/crates/agent/src/lib.rs
index cccdf225b9..219e76da1a 100644
--- a/crates/agent/src/lib.rs
+++ b/crates/agent/src/lib.rs
@@ -25,8 +25,8 @@ pub use completion::{complete, complete_about_image, complete_with_history};
pub use convert::{merge_consecutive_parts, to_rig_messages};
pub use error::AgentError;
pub use hook::{FinishedUserTool, PendingUserTool, UserToolFinisher};
-pub use model::PredefinedModel;
pub use model::metering::{MeteringContext, MeteringError, ProviderSupport, WireProtocol};
+pub use model::{PredefinedModel, ReasoningEffort};
pub use stream::{ChatCompletionStream, McpInfo, StreamPart, ToolCall, ToolResponse, Usage};
pub use tool_adapter::{DynToolSetAdapter, ToolsetToolAdapter, normalize_request_schema};
diff --git a/crates/agent/src/model/anthropic.rs b/crates/agent/src/model/anthropic.rs
index a79ca52a6b..d3104b1552 100644
--- a/crates/agent/src/model/anthropic.rs
+++ b/crates/agent/src/model/anthropic.rs
@@ -1,3 +1,4 @@
+use crate::model::ReasoningEffort;
use crate::model::types::Model;
use rig_core::{client::CompletionClient, http_client::HttpClientExt, providers::anthropic};
use std::sync::Arc;
@@ -38,23 +39,37 @@ impl<'a, H: HttpClientExt + Clone + Default + 'static> AnthropicModel<'a, H> {
///
/// `temperature` is never set: it is rejected on Opus 4.7+ and constrained
/// to 1 with extended thinking elsewhere, so we let the API default apply.
- pub fn thinking_params(&self) -> Option<serde_json::Value> {
+ pub fn thinking_params(
+ &self,
+ reasoning_effort: Option<ReasoningEffort>,
+ ) -> Option<serde_json::Value> {
let model = self.model.name().to_lowercase();
- if model.contains("opus")
+ let mut params = if model.contains("opus")
|| model.contains("fable")
|| model.contains("mythos")
|| model.contains("sonnet")
{
- Some(serde_json::json!({
+ serde_json::json!({
"thinking": { "type": "adaptive", "display": "summarized" }
- }))
+ })
} else if model.contains("haiku") {
- Some(serde_json::json!({
+ serde_json::json!({
"thinking": { "type": "enabled", "budget_tokens": 10_000 }
- }))
+ })
} else {
- None
+ serde_json::json!({})
+ };
+
+ if let Some(effort) =
+ reasoning_effort.and_then(|effort| effort.explicit_for(&self.model.to_string()))
+ {
+ params["output_config"] = serde_json::json!({ "effort": effort.as_str() });
}
+
+ params
+ .as_object()
+ .is_some_and(|params| !params.is_empty())
+ .then_some(params)
}
}
diff --git a/crates/agent/src/model/mod.rs b/crates/agent/src/model/mod.rs
index d4fd3a697c..54545f91f7 100644
--- a/crates/agent/src/model/mod.rs
+++ b/crates/agent/src/model/mod.rs
@@ -2,8 +2,10 @@
//! AgentModel exists to help the backend use AI
//! Model routing takes a string and returns the appropriate client
mod predefined_model;
+mod reasoning_effort;
pub(crate) mod types;
pub use predefined_model::*;
+pub use reasoning_effort::*;
mod anthropic;
mod gemini;
pub mod metering;
diff --git a/crates/agent/src/model/openai.rs b/crates/agent/src/model/openai.rs
index dbdf4a449c..1248552c62 100644
--- a/crates/agent/src/model/openai.rs
+++ b/crates/agent/src/model/openai.rs
@@ -1,5 +1,6 @@
use std::sync::Arc;
+use crate::model::ReasoningEffort;
use crate::model::types::Model;
use rig_core::{client::CompletionClient, http_client::HttpClientExt, providers::openai};
@@ -59,7 +60,10 @@ impl<'a, H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static>
/// else returns `None`, since sending it elsewhere 400s. `mini` / `nano`
/// variants get a lower effort. `temperature` is never set (reasoning models
/// reject it).
- pub fn thinking_params(&self) -> Option<serde_json::Value> {
+ pub fn thinking_params(
+ &self,
+ reasoning_effort: Option<ReasoningEffort>,
+ ) -> Option<serde_json::Value> {
let model = self.model.name().to_lowercase();
let is_reasoning = model.contains("gpt-5")
@@ -71,11 +75,18 @@ impl<'a, H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static>
return None;
}
- let effort = if model.contains("mini") || model.contains("nano") {
- "low"
- } else {
- "high"
- };
+ let effort = reasoning_effort
+ .and_then(|effort| effort.explicit_for(&self.model.to_string()))
+ .map_or_else(
+ || {
+ if model.contains("mini") || model.contains("nano") {
+ "low"
+ } else {
+ "high"
+ }
+ },
+ ReasoningEffort::as_str,
+ );
Some(serde_json::json!({ "reasoning_effort": effort }))
}
@@ -116,7 +127,10 @@ impl<'a, H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static>
/// Best-effort reasoning config for OpenAI Responses models, or `None` if
/// the model doesn't support it.
- pub fn thinking_params(&self) -> Option<serde_json::Value> {
+ pub fn thinking_params(
+ &self,
+ reasoning_effort: Option<ReasoningEffort>,
+ ) -> Option<serde_json::Value> {
let model = self.model.name().to_lowercase();
let is_reasoning = model.contains("gpt-5")
@@ -128,11 +142,18 @@ impl<'a, H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static>
return None;
}
- let effort = if model.contains("mini") || model.contains("nano") {
- "low"
- } else {
- "high"
- };
+ let effort = reasoning_effort
+ .and_then(|effort| effort.explicit_for(&self.model.to_string()))
+ .map_or_else(
+ || {
+ if model.contains("mini") || model.contains("nano") {
+ "low"
+ } else {
+ "high"
+ }
+ },
+ ReasoningEffort::as_str,
+ );
Some(serde_json::json!({
"reasoning": {
diff --git a/crates/agent/src/model/reasoning_effort.rs b/crates/agent/src/model/reasoning_effort.rs
new file mode 100644
index 0000000000..22c1b5ac1a
--- /dev/null
+++ b/crates/agent/src/model/reasoning_effort.rs
@@ -0,0 +1,107 @@
+//! Native effort values. External harness settings remain opaque ACP values.
+
+use std::str::FromStr;
+
+/// A session override; Default preserves the model adapter's existing default.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum ReasoningEffort {
+ /// Do not override the model's configured effort.
+ #[default]
+ Default,
+ /// Disable reasoning where supported.
+ None,
+ /// Minimal reasoning.
+ Minimal,
+ /// Lower latency and token use.
+ Low,
+ /// Balanced reasoning.
+ Medium,
+ /// Thorough reasoning.
+ High,
+ /// Extended reasoning.
+ XHigh,
+ /// Maximum reasoning.
+ Max,
+}
+
+impl ReasoningEffort {
+ /// Explicit native capabilities, keyed by routed provider and model.
+ /// Unknown models deliberately have no advertised effort control.
+ #[must_use]
+ pub fn supported(model: &str) -> &'static [Self] {
+ use ReasoningEffort::*;
+ match model {
+ "anthropic/claude-sonnet-5" | "anthropic/claude-opus-5" => {
+ &[Default, Low, Medium, High, XHigh, Max]
+ }
+ "openai/gpt-5.5" => &[Default, None, Low, Medium, High, XHigh],
+ "openai/gpt-5-mini" => &[Default, Minimal, Low, Medium, High],
+ _ => &[],
+ }
+ }
+
+ /// Validate an explicit override without inferring capabilities from names.
+ #[must_use]
+ pub fn explicit_for(self, model: &str) -> Option<Self> {
+ (self != Self::Default && Self::supported(model).contains(&self)).then_some(self)
+ }
+
+ /// ACP value (Default is never serialized into a provider request).
+ #[must_use]
+ pub const fn as_str(self) -> &'static str {
+ match self {
+ Self::Default => "default",
+ Self::None => "none",
+ Self::Minimal => "minimal",
+ Self::Low => "low",
+ Self::Medium => "medium",
+ Self::High => "high",
+ Self::XHigh => "xhigh",
+ Self::Max => "max",
+ }
+ }
+
+ /// Human-readable ACP label.
+ #[must_use]
+ pub const fn display_name(self) -> &'static str {
+ match self {
+ Self::Default => "Default",
+ Self::None => "None",
+ Self::Minimal => "Minimal",
+ Self::Low => "Low",
+ Self::Medium => "Medium",
+ Self::High => "High",
+ Self::XHigh => "Extra high",
+ Self::Max => "Max",
+ }
+ }
+}
+
+impl std::fmt::Display for ReasoningEffort {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter.write_str(self.as_str())
+ }
+}
+
+/// An unrecognized native effort value.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[error("unknown reasoning effort `{0}`")]
+pub struct ParseReasoningEffortError(String);
+
+impl FromStr for ReasoningEffort {
+ type Err = ParseReasoningEffortError;
+
+ fn from_str(value: &str) -> Result<Self, Self::Err> {
+ match value {
+ "default" => Ok(Self::Default),
+ "none" => Ok(Self::None),
+ "minimal" => Ok(Self::Minimal),
+ "low" => Ok(Self::Low),
+ "medium" => Ok(Self::Medium),
+ "high" => Ok(Self::High),
+ "xhigh" => Ok(Self::XHigh),
+ "max" => Ok(Self::Max),
+ _ => Err(ParseReasoningEffortError(value.to_owned())),
+ }
+ }
+}
diff --git a/crates/agent/src/model/router.rs b/crates/agent/src/model/router.rs
index b980d64fae..6d5000560b 100644
--- a/crates/agent/src/model/router.rs
+++ b/crates/agent/src/model/router.rs
@@ -34,13 +34,13 @@ use rig_core::providers::{anthropic, gemini, openai};
use rig_core::streaming::StreamedAssistantContent;
use tracing::Instrument as _;
-use super::PredefinedModel;
use super::anthropic::AnthropicModel;
use super::gemini::GeminiModel;
use super::metering::{MeteringContext, WireProtocol};
use super::metering_http::MeteredHttpClient;
use super::openai::{OpenAiChatCompletionsModel, OpenAiResponsesModel};
use super::types::Model;
+use super::{PredefinedModel, ReasoningEffort};
use crate::error::AgentError;
use crate::hook::{BridgeInputs, StreamBridge};
use crate::stream::{ChatCompletionStream, StreamPart};
@@ -111,6 +111,7 @@ impl<'a, H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static> RoutedM
/// config. Pure construction — no model call is made here.
pub(crate) fn into_agent(
self,
+ reasoning_effort: Option<ReasoningEffort>,
handle: ToolServerHandle,
system_prompt: &str,
max_turns: usize,
@@ -119,7 +120,7 @@ impl<'a, H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static> RoutedM
) -> ProviderAgent<H> {
match self {
RoutedModel::Anthropic(m) => {
- let thinking = m.thinking_params();
+ let thinking = m.thinking_params(reasoning_effort);
ProviderAgent::Anthropic(build_agent(
m.completion(),
thinking,
@@ -143,7 +144,7 @@ impl<'a, H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static> RoutedM
))
}
RoutedModel::OpenAiChatCompletions(m) => {
- let thinking = m.thinking_params();
+ let thinking = m.thinking_params(reasoning_effort);
ProviderAgent::OpenAiChatCompletions(build_agent(
m.completion(),
thinking,
@@ -155,7 +156,7 @@ impl<'a, H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static> RoutedM
))
}
RoutedModel::OpenAiResponses(m) => {
- let thinking = m.thinking_params();
+ let thinking = m.thinking_params(reasoning_effort);
ProviderAgent::OpenAiResponses(build_agent(
m.completion(),
thinking,
@@ -442,24 +443,6 @@ impl ModelRouter<MeteredHttpClient> {
}
impl<H: HttpClientExt + Clone + Default + std::fmt::Debug + 'static> ModelRouter<H> {
- /// Route + build the agent in one step, falling back to the default model on
- /// an unroutable id. Tells `telemetry` which provider and model the session
- /// actually runs on, so its spans report the routed model, not the
- /// requested id.
- pub(crate) fn agent(
- &self,
- model: &str,
- handle: ToolServerHandle,
- system_prompt: &str,
- max_turns: usize,
- max_tokens: u64,
- telemetry: GenAiContext,
- ) -> ProviderAgent<H> {
- let routed = self.route_or_default(model);
- telemetry.set_model(routed.provider(), routed.model_name());
- routed.into_agent(handle, system_prompt, max_turns, max_tokens, &telemetry)
- }
-
/// Route a `provider/model` id to the provider that serves it.
///
/// Returns [`AgentError::UnknownModel`] if no provider claims it (and
diff --git a/crates/agent/src/test/test_router.rs b/crates/agent/src/test/test_router.rs
index 998a0982cb..c7f6192e39 100644
--- a/crates/agent/src/test/test_router.rs
+++ b/crates/agent/src/test/test_router.rs
@@ -1,6 +1,6 @@
-use crate::model::PredefinedModel;
use crate::model::router::*;
use crate::model::types::Model;
+use crate::model::{PredefinedModel, ReasoningEffort};
use rig_core::providers::{anthropic, gemini, openai};
fn test_router() -> ModelRouter {
@@ -110,3 +110,86 @@ fn google_provider_routes_to_native_gemini() {
fn google_provider_without_a_client_is_unroutable() {
assert!(test_router().route("google/gemini-3.8-flash").is_err());
}
+
+#[test]
+fn selected_effort_is_mapped_to_each_provider_request_shape() {
+ let router = test_router();
+
+ let RoutedModel::Anthropic(anthropic) = router.route("anthropic/claude-sonnet-5").unwrap()
+ else {
+ panic!("sonnet should use the native Anthropic client");
+ };
+ let params = anthropic
+ .thinking_params(Some(ReasoningEffort::Low))
+ .expect("sonnet supports thinking and effort");
+ assert_eq!(params["thinking"]["type"], "adaptive");
+ assert_eq!(params["output_config"]["effort"], "low");
+
+ let RoutedModel::OpenAiResponses(openai) = router.route("openai/gpt-5.5").unwrap() else {
+ panic!("GPT-5.5 should use OpenAI Responses");
+ };
+ let params = openai
+ .thinking_params(Some(ReasoningEffort::Medium))
+ .expect("GPT-5.5 supports reasoning effort");
+ assert_eq!(params["reasoning"]["effort"], "medium");
+}
+
+#[test]
+fn unsupported_anthropic_models_do_not_receive_effort() {
+ let router = test_router();
+ let RoutedModel::Anthropic(haiku) = router.route("anthropic/claude-haiku-4-5").unwrap() else {
+ panic!("haiku should use the native Anthropic client");
+ };
+
+ let params = haiku
+ .thinking_params(Some(ReasoningEffort::Low))
+ .expect("haiku retains its thinking configuration");
+ assert!(params.get("output_config").is_none());
+}
+
+#[test]
+fn native_effort_profiles_preserve_defaults_and_provider_boundaries() {
+ let router = test_router();
+ let RoutedModel::OpenAiResponses(mini) = router.route("openai/gpt-5-mini").unwrap() else {
+ panic!("Responses");
+ };
+ assert_eq!(
+ mini.thinking_params(Some(ReasoningEffort::Default))
+ .unwrap()["reasoning"]["effort"],
+ "low"
+ );
+ assert_eq!(
+ mini.thinking_params(Some(ReasoningEffort::Minimal))
+ .unwrap()["reasoning"]["effort"],
+ "minimal"
+ );
+ assert!(ReasoningEffort::supported("compatible/gpt-5-mini").is_empty());
+ assert!(ReasoningEffort::supported("anthropic/claude-haiku-4-5").is_empty());
+ assert!(ReasoningEffort::supported("openai/unknown").is_empty());
+ for model in [
+ "anthropic/claude-sonnet-5",
+ "anthropic/claude-opus-5",
+ "openai/gpt-5.5",
+ "openai/gpt-5-mini",
+ ] {
+ for effort in ReasoningEffort::supported(model) {
+ let params = match router.route(model).unwrap() {
+ RoutedModel::Anthropic(model) => model.thinking_params(Some(*effort)).unwrap(),
+ RoutedModel::OpenAiResponses(model) => {
+ model.thinking_params(Some(*effort)).unwrap()
+ }
+ _ => panic!("native model"),
+ };
+ if *effort != ReasoningEffort::Default {
+ let actual = if model.starts_with("anthropic/") {
+ &params["output_config"]["effort"]
+ } else {
+ &params["reasoning"]["effort"]
+ };
+ assert_eq!(actual, effort.as_str(), "{model}");
+ } else if model.starts_with("anthropic/") {
+ assert!(params.get("output_config").is_none());
+ }
+ }
+ }
+}
diff --git a/crates/agent_inmem/src/domain/agent.rs b/crates/agent_inmem/src/domain/agent.rs
index 454bff2412..f298129641 100644
--- a/crates/agent_inmem/src/domain/agent.rs
+++ b/crates/agent_inmem/src/domain/agent.rs
@@ -13,6 +13,7 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
+use agent::ReasoningEffort;
use agent::types::{AssistantMessagePart, ChatMessage};
use agent::{StreamAccumulator, StreamPart, ToolResponse};
use agent_client_protocol::schema::v1::{
@@ -43,6 +44,7 @@ use tracing::Instrument as _;
use crate::domain::engine::{AgentIdentity, TurnEngine, TurnRequest};
use crate::domain::mcp::{DynMcpToolConnector, dialable_servers};
+use crate::domain::model_options::REASONING_EFFORT_CONFIG_ID;
use crate::domain::session::{HistoryEntry, SessionStore, UserPrompt, messages_for_turn};
use crate::domain::user_input::{
SharedUserInputRequester, UserInputError, UserInputOutcome, UserInputRequest,
@@ -93,6 +95,8 @@ struct TurnInput {
messages: Vec<ChatMessage>,
/// Model the turn runs on.
model: String,
+ /// Reasoning effort the turn runs with.
+ reasoning_effort: ReasoningEffort,
/// Who this agent is, for the engine's system prompt.
identity: Option<AgentIdentity>,
/// The session's instructions, for the engine's system prompt.
@@ -179,19 +183,29 @@ impl AgentState {
fn set_model(&self, model: String) {
if let Some(mut state) = self.store.get_mut(&self.session_id) {
+ if !ReasoningEffort::supported(&model).contains(&state.reasoning_effort) {
+ state.reasoning_effort = ReasoningEffort::default();
+ }
state.model = model;
}
}
+ fn set_reasoning_effort(&self, reasoning_effort: ReasoningEffort) {
+ if let Some(mut state) = self.store.get_mut(&self.session_id) {
+ state.reasoning_effort = reasoning_effort;
+ }
+ }
+
/// ACP model configuration backed by the engine's supported-model source
/// and this session's current selection.
- fn model_config_options(&self) -> Vec<SessionConfigOption> {
+ fn session_config_options(&self) -> Vec<SessionConfigOption> {
let Some(session) = self.store.get(&self.session_id) else {
return Vec::new();
};
- crate::domain::model_options::model_config_options(
+ crate::domain::model_options::session_config_options(
&session.model,
self.engine.supported_models(),
+ session.reasoning_effort,
)
}
@@ -202,12 +216,14 @@ impl AgentState {
|| TurnInput {
messages: messages_for_turn(&[], prompt),
model: String::new(),
+ reasoning_effort: ReasoningEffort::default(),
identity: None,
instructions: None,
},
|state| TurnInput {
messages: messages_for_turn(&state.history, prompt),
model: state.model.clone(),
+ reasoning_effort: state.reasoning_effort,
identity: state.identity.clone(),
instructions: state.instructions.clone(),
},
@@ -524,7 +540,7 @@ pub async fn serve(state: Arc<AgentState>, acp: AcpChannel) -> Result<(), AcpErr
state.connect_mcp(request.mcp_servers).await;
let responded = responder.respond(
NewSessionResponse::new(acp_id.clone())
- .config_options(state.model_config_options()),
+ .config_options(state.session_config_options()),
);
advertise_commands(&state, &connection, acp_id);
responded
@@ -544,7 +560,7 @@ pub async fn serve(state: Arc<AgentState>, acp: AcpChannel) -> Result<(), AcpErr
state.bind_acp_session(request.session_id.clone(), true);
state.connect_mcp(request.mcp_servers).await;
let responded = responder.respond(
- ResumeSessionResponse::new().config_options(state.model_config_options()),
+ ResumeSessionResponse::new().config_options(state.session_config_options()),
);
advertise_commands(&state, &connection, request.session_id);
responded
@@ -633,20 +649,52 @@ pub async fn serve(state: Arc<AgentState>, acp: AcpChannel) -> Result<(), AcpErr
if let Err(error) = state.expect_session(&request.session_id) {
return responder.respond_with_error(error);
}
- if request.config_id.to_string() != MODEL_CONFIG_ID {
- return responder.respond_with_error(
- AcpError::invalid_params()
- .data(format!("unknown config option {}", request.config_id)),
- );
- }
- let Some(model) = request.value.as_value_id() else {
+ let Some(value) = request.value.as_value_id() else {
return responder.respond_with_error(
- AcpError::invalid_params().data("the model option takes a value id"),
+ AcpError::invalid_params().data("the config option takes a value id"),
);
};
- state.set_model(model.to_string());
+ match request.config_id.to_string().as_str() {
+ MODEL_CONFIG_ID => {
+ if !state
+ .engine
+ .supported_models()
+ .contains(&value.to_string().as_str())
+ {
+ return responder.respond_with_error(
+ AcpError::invalid_params().data("unsupported model"),
+ );
+ }
+ state.set_model(value.to_string());
+ }
+ REASONING_EFFORT_CONFIG_ID => {
+ let Ok(effort) = value.to_string().parse() else {
+ return responder.respond_with_error(
+ AcpError::invalid_params()
+ .data(format!("unknown reasoning effort {value}")),
+ );
+ };
+ let supported =
+ state.store.get(&state.session_id).is_some_and(|session| {
+ ReasoningEffort::supported(&session.model).contains(&effort)
+ });
+ if !supported {
+ return responder.respond_with_error(
+ AcpError::invalid_params()
+ .data("effort is not supported by this model"),
+ );
+ }
+ state.set_reasoning_effort(effort);
+ }
+ _ => {
+ return responder.respond_with_error(
+ AcpError::invalid_params()
+ .data(format!("unknown config option {}", request.config_id)),
+ );
+ }
+ }
responder.respond(SetSessionConfigOptionResponse::new(
- state.model_config_options(),
+ state.session_config_options(),
))
}
},
@@ -681,6 +729,7 @@ async fn run_turn(
let TurnInput {
messages,
model,
+ reasoning_effort,
identity,
instructions,
} = state.turn_input(&prompt);
@@ -689,6 +738,7 @@ async fn run_turn(
let mut parts = state.engine.run_turn(TurnRequest {
owner: state.owner.clone(),
model,
+ reasoning_effort,
identity,
instructions,
messages,
diff --git a/crates/agent_inmem/src/domain/agent/test.rs b/crates/agent_inmem/src/domain/agent/test.rs
index fa6dbc079a..0078deffd5 100644
--- a/crates/agent_inmem/src/domain/agent/test.rs
+++ b/crates/agent_inmem/src/domain/agent/test.rs
@@ -4,7 +4,8 @@ use agent::StreamPart;
use agent_client_protocol::schema::ProtocolVersion;
use agent_client_protocol::schema::v1::{
ContentBlock, InitializeRequest, NewSessionRequest, PromptRequest, ResourceLink,
- SessionNotification, TextContent,
+ SessionConfigKind, SessionConfigOptionCategory, SessionConfigSelectOptions,
+ SessionConfigValueId, SessionNotification, SetSessionConfigOptionRequest, TextContent,
};
use agent_client_protocol::{Client, ConnectionTo};
use rig_agent::agent::StreamingError;
@@ -57,7 +58,7 @@ where
let session_id = AgentSessionId::new();
store.insert(
session_id,
- crate::domain::session::SessionState::new("test-model".into()),
+ crate::domain::session::SessionState::new("anthropic/claude-sonnet-5".into()),
);
let state = Arc::new(AgentState {
session_id,
@@ -151,14 +152,68 @@ async fn new_session_advertises_the_engine_supported_models() {
let selection = agent_fold::domain::model_selection::model_selection(&config_options)
.expect("session/new should advertise a model select");
- assert_eq!(selection.current, "test-model");
+ assert_eq!(selection.current, "anthropic/claude-sonnet-5");
assert_eq!(
selection
.options
.iter()
.map(|model| (model.id.as_str(), model.name.as_str()))
.collect::<Vec<_>>(),
- vec![("test-model", "test-model"), ("other-model", "other-model")]
+ vec![
+ ("anthropic/claude-sonnet-5", "anthropic/claude-sonnet-5"),
+ ("other-model", "other-model")
+ ]
+ );
+
+ let effort = config_options
+ .iter()
+ .find(|option| option.id.to_string() == REASONING_EFFORT_CONFIG_ID)
+ .expect("session/new should advertise reasoning effort");
+ assert_eq!(
+ effort.category,
+ Some(SessionConfigOptionCategory::ThoughtLevel)
+ );
+ let SessionConfigKind::Select(effort) = &effort.kind else {
+ panic!("reasoning effort should be a select");
+ };
+ assert_eq!(effort.current_value.to_string(), "default");
+ let SessionConfigSelectOptions::Ungrouped(options) = &effort.options else {
+ panic!("reasoning effort should be ungrouped");
+ };
+ assert_eq!(
+ options
+ .iter()
+ .map(|option| option.value.to_string())
+ .collect::<Vec<_>>(),
+ ["default", "low", "medium", "high", "xhigh", "max"]
+ );
+}
+
+#[tokio::test]
+async fn changing_reasoning_effort_applies_to_the_next_turn() {
+ let engine = Arc::new(ScriptedEngine::new(vec![]));
+ let (_notifications, _config_options, ()) =
+ with_agent(Arc::clone(&engine), async |connection, session| {
+ connection
+ .send_request(SetSessionConfigOptionRequest::new(
+ session.clone(),
+ REASONING_EFFORT_CONFIG_ID,
+ SessionConfigValueId::new("low"),
+ ))
+ .block_task()
+ .await
+ .expect("the effort selection should be accepted");
+ connection
+ .send_request(text_prompt(&session, "be quick"))
+ .block_task()
+ .await
+ .expect("the prompt should complete");
+ })
+ .await;
+
+ assert_eq!(
+ engine.requests()[0].reasoning_effort,
+ agent::ReasoningEffort::Low
);
}
@@ -326,7 +381,7 @@ async fn turns_accumulate_history_and_send_the_model() {
let requests = engine.requests();
assert_eq!(requests.len(), 2);
- assert_eq!(requests[0].model, "test-model");
+ assert_eq!(requests[0].model, "anthropic/claude-sonnet-5");
assert_eq!(requests[0].messages, vec!["first".to_owned()]);
// The second turn carries the first turn's prompt and reply.
assert_eq!(
@@ -555,7 +610,7 @@ async fn session_new_dials_the_advertised_servers_except_macros_own() {
let session_id = AgentSessionId::new();
store.insert(
session_id,
- crate::domain::session::SessionState::new("test-model".into()),
+ crate::domain::session::SessionState::new("anthropic/claude-sonnet-5".into()),
);
let state = Arc::new(AgentState {
session_id,
@@ -648,7 +703,7 @@ where
let session_id = AgentSessionId::new();
store.insert(
session_id,
- crate::domain::session::SessionState::new("test-model".into()),
+ crate::domain::session::SessionState::new("anthropic/claude-sonnet-5".into()),
);
let state = Arc::new(AgentState {
session_id,
@@ -1171,3 +1226,78 @@ async fn ask_without_form_support_explains_instead_of_asking() {
mod model_selection;
mod telemetry;
+
+#[tokio::test]
+async fn effort_is_validated_and_model_changes_return_complete_options() {
+ let engine = Arc::new(ScriptedEngine::new(vec![]));
+ with_agent(engine, async |connection, session| {
+ let selected = connection
+ .send_request(SetSessionConfigOptionRequest::new(
+ session.clone(),
+ REASONING_EFFORT_CONFIG_ID,
+ "max",
+ ))
+ .block_task()
+ .await
+ .expect("Sonnet accepts max");
+ assert_eq!(
+ selected.config_options.len(),
+ 2,
+ "effort response retains model control"
+ );
+ let changed = connection
+ .send_request(SetSessionConfigOptionRequest::new(
+ session.clone(),
+ MODEL_CONFIG_ID,
+ "other-model",
+ ))
+ .block_task()
+ .await
+ .expect("model accepted");
+ assert_eq!(
+ changed.config_options.len(),
+ 1,
+ "unsupported model removes effort control"
+ );
+ assert!(
+ connection
+ .send_request(SetSessionConfigOptionRequest::new(
+ session.clone(),
+ REASONING_EFFORT_CONFIG_ID,
+ "low"
+ ))
+ .block_task()
+ .await
+ .is_err()
+ );
+ assert!(
+ connection
+ .send_request(SetSessionConfigOptionRequest::new(
+ session.clone(),
+ MODEL_CONFIG_ID,
+ "unknown-model"
+ ))
+ .block_task()
+ .await
+ .is_err()
+ );
+ let restored = connection
+ .send_request(SetSessionConfigOptionRequest::new(
+ session,
+ MODEL_CONFIG_ID,
+ "anthropic/claude-sonnet-5",
+ ))
+ .block_task()
+ .await
+ .unwrap();
+ let SessionConfigKind::Select(effort) = &restored.config_options[1].kind else {
+ panic!("effort select");
+ };
+ assert_eq!(
+ effort.current_value.to_string(),
+ "default",
+ "invalid effort is reset on model change"
+ );
+ })
+ .await;
+}
diff --git a/crates/agent_inmem/src/domain/engine.rs b/crates/agent_inmem/src/domain/engine.rs
index eb9325e79b..abe2991ebf 100644
--- a/crates/agent_inmem/src/domain/engine.rs
+++ b/crates/agent_inmem/src/domain/engine.rs
@@ -2,6 +2,7 @@
use std::sync::Arc;
+use agent::ReasoningEffort;
use agent::types::ChatMessage;
use agent::{AgentError, StreamPart};
use ai_tools::user_tool_review::UserToolReviewer;
@@ -39,6 +40,8 @@ pub struct TurnRequest {
/// Model id the turn runs on. Unknown ids fall back to the loop's
/// default model rather than failing the turn.
pub model: String,
+ /// Provider-independent effort selected for this session.
+ pub reasoning_effort: ReasoningEffort,
/// Who this agent is. Folded into every turn's system prompt so the
/// model can answer "who are you" even when the session has no
/// instructions. `None` leaves the standing prompt unnamed.
diff --git a/crates/agent_inmem/src/domain/mod.rs b/crates/agent_inmem/src/domain/mod.rs
index 669b5bd193..b8d863e727 100644
--- a/crates/agent_inmem/src/domain/mod.rs
+++ b/crates/agent_inmem/src/domain/mod.rs
@@ -4,7 +4,7 @@
pub mod agent;
pub mod engine;
pub mod mcp;
-/// ACP model configuration generated from the turn engine catalog.
+/// ACP session configuration generated from the turn engine catalog.
pub mod model_options;
/// Models this runtime advertises, including routed Fireworks and Gemini ids.
pub mod models;
diff --git a/crates/agent_inmem/src/domain/model_options.rs b/crates/agent_inmem/src/domain/model_options.rs
index afe4bc5dd1..2a61156f82 100644
--- a/crates/agent_inmem/src/domain/model_options.rs
+++ b/crates/agent_inmem/src/domain/model_options.rs
@@ -1,13 +1,19 @@
-//! ACP model configuration advertised by the in-memory agent.
+//! ACP session configuration advertised by the in-memory agent.
+use agent::ReasoningEffort;
use agent_client_protocol::schema::v1::{
- SessionConfigOption, SessionConfigSelectOption, SessionConfigValueId,
+ SessionConfigOption, SessionConfigOptionCategory, SessionConfigSelectOption,
+ SessionConfigValueId,
};
use agent_runtime_protocol::domain::action::MODEL_CONFIG_ID;
-/// Build model configuration from the actual turn engine catalog.
+/// Build session configuration from the actual turn engine catalog and state.
#[must_use]
-pub fn model_config_options(current: &str, models: &[&str]) -> Vec<SessionConfigOption> {
+pub fn session_config_options(
+ current_model: &str,
+ models: &[&str],
+ current_effort: ReasoningEffort,
+) -> Vec<SessionConfigOption> {
let options: Vec<_> = models
.iter()
.map(|model| {
@@ -17,12 +23,54 @@ pub fn model_config_options(current: &str, models: &[&str]) -> Vec<SessionConfig
)
})
.collect();
- vec![SessionConfigOption::select(
- MODEL_CONFIG_ID,
- "Model",
- SessionConfigValueId::new(current.to_owned()),
- options,
- )]
+ let mut config = vec![
+ SessionConfigOption::select(
+ MODEL_CONFIG_ID,
+ "Model",
+ SessionConfigValueId::new(current_model.to_owned()),
+ options,
+ )
+ .category(SessionConfigOptionCategory::Model),
+ ];
+ if !ReasoningEffort::supported(current_model).is_empty() {
+ config.push(reasoning_effort_config_option(
+ current_model,
+ current_effort,
+ ));
+ }
+ config
+}
+
+/// ACP id for Macro's portable reasoning-effort selector.
+pub const REASONING_EFFORT_CONFIG_ID: &str = "reasoning_effort";
+
+/// Build the effort option at its current value.
+#[must_use]
+pub fn reasoning_effort_config_option(
+ model: &str,
+ current: ReasoningEffort,
+) -> SessionConfigOption {
+ SessionConfigOption::select(
+ REASONING_EFFORT_CONFIG_ID,
+ "Reasoning effort",
+ SessionConfigValueId::new(current.to_string()),
+ ReasoningEffort::supported(model)
+ .iter()
+ .map(|effort| {
+ SessionConfigSelectOption::new(
+ SessionConfigValueId::new(effort.to_string()),
+ effort.display_name(),
+ )
+ })
+ .collect::<Vec<_>>(),
+ )
+ .category(SessionConfigOptionCategory::ThoughtLevel)
+}
+
+/// Model discovery uses the same default session configuration as session/new.
+#[must_use]
+pub fn model_config_options(current: &str, models: &[&str]) -> Vec<SessionConfigOption> {
+ session_config_options(current, models, ReasoningEffort::default())
}
#[cfg(test)]
diff --git a/crates/agent_inmem/src/domain/replay.rs b/crates/agent_inmem/src/domain/replay.rs
index 59b50768aa..41eaa651e3 100644
--- a/crates/agent_inmem/src/domain/replay.rs
+++ b/crates/agent_inmem/src/domain/replay.rs
@@ -15,16 +15,20 @@
//! and a tool call is rebuilt under the display title it was streamed with,
//! which for the Macro product toolset is the tool name itself.
+use agent::ReasoningEffort;
use agent::types::AssistantMessagePart;
use agent_client_protocol::schema::v1::{
ContentBlock, PromptRequest, SessionNotification, SessionUpdate, ToolCallStatus,
};
+use agent_client_protocol::schema::v1::{Response, SessionConfigKind, SessionConfigOption};
use agent_client_protocol::{JsonRpcMessage, RawJsonRpcMessage, RawJsonRpcParams};
use agent_runtime_protocol::domain::schema::v0::{ToRuntimeMessage, ToServerMessage};
use agent_session::domain::model::Message;
use futures::future::BoxFuture;
+use std::collections::HashSet;
use crate::domain::agent::close_dangling_tool_calls;
+use crate::domain::model_options::REASONING_EFFORT_CONFIG_ID;
use crate::domain::session::{HistoryEntry, UserPrompt};
#[cfg(test)]
@@ -104,6 +108,56 @@ pub fn replay_history(frames: impl IntoIterator<Item = Message>) -> Vec<HistoryE
history
}
+/// Rebuild the last valid reasoning-effort selection from durable frames.
+#[must_use]
+pub fn replay_reasoning_effort(frames: &[Message]) -> ReasoningEffort {
+ let mut pending = HashSet::new();
+ let mut current = ReasoningEffort::default();
+ for frame in frames {
+ match frame {
+ Message::ToRuntime(ToRuntimeMessage::Acp(acp)) => {
+ if let RawJsonRpcMessage::Request(request) = &acp.0
+ && matches!(
+ request.method.as_ref(),
+ "session/new"
+ | "session/load"
+ | "session/resume"
+ | "session/set_config_option"
+ )
+ {
+ pending.insert(request.id.clone());
+ }
+ }
+ Message::ToServer(ToServerMessage::Acp(acp)) => match &acp.0 {
+ RawJsonRpcMessage::Response(Response::Result { id, result })
+ if pending.remove(id) =>
+ {
+ if let Some(options) = result.get("configOptions").and_then(|options| {
+ serde_json::from_value::<Vec<SessionConfigOption>>(options.clone()).ok()
+ }) {
+ current = effort_from_options(&options);
+ }
+ }
+ RawJsonRpcMessage::Response(Response::Error { id, .. }) => {
+ pending.remove(id);
+ }
+ RawJsonRpcMessage::Notification(notification) => {
+ if let Some(SessionNotification {
+ update: SessionUpdate::ConfigOptionUpdate(update),
+ ..
+ }) = deserialize_params::<SessionNotification>(notification.params.as_ref())
+ {
+ current = effort_from_options(&update.config_options);
+ }
+ }
+ _ => {}
+ },
+ _ => {}
+ }
+ }
+ current
+}
+
/// Fold one `session/update` back into the open turn's parts.
fn apply_update(parts: &mut Vec<AssistantMessagePart>, update: SessionUpdate) {
match update {
@@ -216,3 +270,18 @@ fn deserialize_params<T: serde::de::DeserializeOwned>(
RawJsonRpcParams::Array(_) => None,
}
}
+
+fn effort_from_options(options: &[SessionConfigOption]) -> ReasoningEffort {
+ options
+ .iter()
+ .find_map(|option| {
+ if option.id.to_string() != REASONING_EFFORT_CONFIG_ID {
+ return None;
+ }
+ let SessionConfigKind::Select(select) = &option.kind else {
+ return None;
+ };
+ select.current_value.to_string().parse().ok()
+ })
+ .unwrap_or_default()
+}
diff --git a/crates/agent_inmem/src/domain/replay/test.rs b/crates/agent_inmem/src/domain/replay/test.rs
index 07a5e9cc25..4808f72811 100644
--- a/crates/agent_inmem/src/domain/replay/test.rs
+++ b/crates/agent_inmem/src/domain/replay/test.rs
@@ -1,6 +1,6 @@
use agent_client_protocol::schema::v1::{
- ContentChunk, ResourceLink, SessionId, TextContent, ToolCall as AcpToolCall, ToolCallStatus,
- ToolCallUpdate, ToolCallUpdateFields,
+ ContentChunk, ResourceLink, SessionConfigValueId, SessionId, SetSessionConfigOptionRequest,
+ TextContent, ToolCall as AcpToolCall, ToolCallStatus, ToolCallUpdate, ToolCallUpdateFields,
};
use agent_runtime_protocol::domain::schema::v0::AcpMessage;
@@ -58,6 +58,22 @@ fn prompt_frame_with_file(text: &str, name: &str, uri: &str) -> Message {
Message::ToRuntime(ToRuntimeMessage::Acp(AcpMessage(raw)))
}
+fn config_frame(config_id: &str, value: &str) -> Message {
+ let request = SetSessionConfigOptionRequest::new(
+ acp_session(),
+ config_id.to_owned(),
+ SessionConfigValueId::new(value.to_owned()),
+ );
+ let raw: RawJsonRpcMessage = serde_json::from_value(serde_json::json!({
+ "jsonrpc": "2.0",
+ "id": 2,
+ "method": "session/set_config_option",
+ "params": serde_json::to_value(request).expect("a config change should serialize"),
+ }))
+ .expect("a request frame should deserialize");
+ Message::ToRuntime(ToRuntimeMessage::Acp(AcpMessage(raw)))
+}
+
fn message_chunk(text: &str) -> SessionUpdate {
SessionUpdate::AgentMessageChunk(ContentChunk::new(ContentBlock::Text(TextContent::new(
text,
@@ -208,3 +224,37 @@ fn a_call_the_log_never_answered_is_closed_rather_than_left_dangling() {
fn an_empty_log_replays_to_an_empty_conversation() {
assert!(replay_history(Vec::new()).is_empty());
}
+
+fn config_response(result: serde_json::Value) -> Message {
+ Message::ToServer(ToServerMessage::Acp(AcpMessage(
+ serde_json::from_value(serde_json::json!({
+ "jsonrpc": "2.0", "id": 2, "result": result
+ }))
+ .unwrap(),
+ )))
+}
+
+#[test]
+fn only_confirmed_effort_replays_and_removal_resets_it() {
+ let mut frames = vec![config_frame(REASONING_EFFORT_CONFIG_ID, "low")];
+ assert_eq!(replay_reasoning_effort(&frames), ReasoningEffort::Default);
+ let options = crate::domain::model_options::session_config_options(
+ "anthropic/claude-sonnet-5",
+ &["anthropic/claude-sonnet-5"],
+ ReasoningEffort::Low,
+ );
+ frames.push(config_response(
+ serde_json::json!({ "configOptions": options }),
+ ));
+ frames.push(config_frame(REASONING_EFFORT_CONFIG_ID, "medium"));
+ frames.push(Message::ToServer(ToServerMessage::Acp(AcpMessage(
+ serde_json::from_value(serde_json::json!({
+ "jsonrpc": "2.0", "id": 2, "error": { "code": -32602, "message": "unsupported" }
+ }))
+ .unwrap(),
+ ))));
+ assert_eq!(replay_reasoning_effort(&frames), ReasoningEffort::Low);
+ frames.push(config_frame("model", "other-model"));
+ frames.push(config_response(serde_json::json!({ "configOptions": [] })));
+ assert_eq!(replay_reasoning_effort(&frames), ReasoningEffort::Default);
+}
diff --git a/crates/agent_inmem/src/domain/session.rs b/crates/agent_inmem/src/domain/session.rs
index e991df54b2..6ecae7335f 100644
--- a/crates/agent_inmem/src/domain/session.rs
+++ b/crates/agent_inmem/src/domain/session.rs
@@ -5,6 +5,7 @@
//! reattach within one process lifetime, and a cold attach after a restart
//! rebuilds it from the frame log (see [`crate::domain::replay`]).
+use agent::ReasoningEffort;
use agent::types::{AssistantMessagePart, ChatMessage, ChatMessageContent, Role};
use agent_client_protocol::schema::v1::{ContentBlock, PromptRequest, SessionId};
use agent_runtime_protocol::domain::action::{COMPACT_COMMAND, PromptAttachment};
@@ -185,6 +186,8 @@ pub struct SessionState {
pub acp_session_id: Option<SessionId>,
/// Model id turns run on; `session/set_config_option` moves it.
pub model: String,
+ /// Reasoning effort applied to subsequent turns.
+ pub reasoning_effort: ReasoningEffort,
/// Who this agent is, snapshotted from the session's bot at attach.
pub identity: Option<AgentIdentity>,
/// Instructions every turn runs under, snapshotted from the session row
@@ -203,6 +206,7 @@ impl SessionState {
Self {
acp_session_id: None,
model,
+ reasoning_effort: ReasoningEffort::default(),
identity: None,
instructions: None,
history: Vec::new(),
diff --git a/crates/agent_inmem/src/outbound/manager.rs b/crates/agent_inmem/src/outbound/manager.rs
index 34790aa074..29896b62f4 100644
--- a/crates/agent_inmem/src/outbound/manager.rs
+++ b/crates/agent_inmem/src/outbound/manager.rs
@@ -19,7 +19,7 @@ use model_owner::Owner;
use crate::domain::agent::{AgentState, serve};
use crate::domain::engine::{AgentIdentity, TurnEngine};
use crate::domain::mcp::DynMcpToolConnector;
-use crate::domain::replay::{FrameSource, replay_history};
+use crate::domain::replay::{FrameSource, replay_history, replay_reasoning_effort};
use crate::domain::session::{SessionState, SessionStore};
#[cfg(test)]
@@ -139,10 +139,19 @@ impl InMemAgentManager {
if !self.store.contains_key(&facts.id) {
// Loaded before taking the entry so the read never blocks the
// map; `or_insert_with` still wins any race to create it.
- let history = replay_history(self.frames.frames(facts.id).await);
+ let frames = self.frames.frames(facts.id).await;
+ let restored_effort = replay_reasoning_effort(&frames);
+ let reasoning_effort =
+ if agent::ReasoningEffort::supported(&facts.model).contains(&restored_effort) {
+ restored_effort
+ } else {
+ agent::ReasoningEffort::default()
+ };
+ let history = replay_history(frames);
self.store.entry(facts.id).or_insert_with(|| SessionState {
acp_session_id: facts.acp_session_id.clone(),
model: facts.model.clone(),
+ reasoning_effort,
identity: facts.identity.clone(),
instructions: facts.instructions.clone(),
history,
diff --git a/crates/agent_inmem/src/outbound/manager/test.rs b/crates/agent_inmem/src/outbound/manager/test.rs
index 6f561ac9a2..cd68c813fe 100644
--- a/crates/agent_inmem/src/outbound/manager/test.rs
+++ b/crates/agent_inmem/src/outbound/manager/test.rs
@@ -103,7 +103,7 @@ fn facts(id: AgentSessionId) -> SessionFacts {
SessionFacts {
id,
owner: Owner::User(owner()),
- model: "test-model".to_owned(),
+ model: "anthropic/claude-sonnet-5".to_owned(),
identity: None,
instructions: None,
acp_session_id: None,
@@ -175,7 +175,7 @@ async fn a_prompt_runs_end_to_end_through_the_real_session_machine() {
bot_id: BotId::TEST_A,
thread_id: None,
originating_message_id: None,
- model: "test-model".to_owned(),
+ model: "anthropic/claude-sonnet-5".to_owned(),
harness: "macro-inmem".to_owned(),
repo_url: None,
workspace: "/workspace".to_owned(),
@@ -315,7 +315,7 @@ async fn a_restarted_manager_rebuilds_the_conversation_from_the_log() {
bot_id: BotId::TEST_A,
thread_id: None,
originating_message_id: None,
- model: "test-model".to_owned(),
+ model: "anthropic/claude-sonnet-5".to_owned(),
harness: "macro-inmem".to_owned(),
repo_url: None,
workspace: "/workspace".to_owned(),
@@ -462,7 +462,7 @@ async fn instructions_reach_every_turn_including_after_a_reattach() {
bot_id: BotId::TEST_A,
thread_id: None,
originating_message_id: None,
- model: "test-model".to_owned(),
+ model: "anthropic/claude-sonnet-5".to_owned(),
harness: "macro-inmem".to_owned(),
repo_url: None,
workspace: "/workspace".to_owned(),
@@ -537,7 +537,7 @@ async fn a_session_without_instructions_hands_the_engine_none() {
bot_id: BotId::TEST_A,
thread_id: None,
originating_message_id: None,
- model: "test-model".to_owned(),
+ model: "anthropic/claude-sonnet-5".to_owned(),
harness: "macro-inmem".to_owned(),
repo_url: None,
workspace: "/workspace".to_owned(),
@@ -597,7 +597,7 @@ async fn identity_reaches_every_turn_including_after_a_reattach() {
bot_id: BotId::TEST_A,
thread_id: None,
originating_message_id: None,
- model: "test-model".to_owned(),
+ model: "anthropic/claude-sonnet-5".to_owned(),
harness: "macro-inmem".to_owned(),
repo_url: None,
workspace: "/workspace".to_owned(),
diff --git a/crates/agent_inmem/src/rig_engine.rs b/crates/agent_inmem/src/rig_engine.rs
index 0a1393ffe3..072f266b46 100644
--- a/crates/agent_inmem/src/rig_engine.rs
+++ b/crates/agent_inmem/src/rig_engine.rs
@@ -126,6 +126,7 @@ async fn drive_turn(
let TurnRequest {
owner,
model,
+ reasoning_effort,
identity,
instructions,
messages,
@@ -192,6 +193,7 @@ async fn drive_turn(
// rig's spans too would report each turn twice.
let mut agent_loop = AgentLoop::new(base_context.recorder.clone())
.with_model(&model)
+ .with_reasoning_effort(reasoning_effort)
.with_genai_telemetry(false);
if let Some(reviewer) = reviewer {
agent_loop = agent_loop.with_user_tool_finisher(user_tool_finisher(
diff --git a/crates/agent_inmem/src/testing.rs b/crates/agent_inmem/src/testing.rs
index 6422c2ac65..7c65db187f 100644
--- a/crates/agent_inmem/src/testing.rs
+++ b/crates/agent_inmem/src/testing.rs
@@ -6,7 +6,7 @@ use tokio::sync::mpsc;
use crate::domain::engine::{AgentIdentity, TurnEngine, TurnRequest};
/// Models advertised by shared test engines.
-pub(crate) const TEST_MODELS: &[&str] = &["test-model", "other-model"];
+pub(crate) const TEST_MODELS: &[&str] = &["anthropic/claude-sonnet-5", "other-model"];
/// An engine that plays back a script of parts for every turn.
pub(crate) struct ScriptedEngine {
@@ -20,6 +20,8 @@ pub(crate) struct ScriptedEngine {
pub(crate) struct RecordedTurn {
/// Model the turn was to run on.
pub(crate) model: String,
+ /// Reasoning effort the turn was to use.
+ pub(crate) reasoning_effort: agent::ReasoningEffort,
/// The conversation, flattened to text per message.
pub(crate) messages: Vec<String>,
/// Every image URL attached across the conversation, in order.
@@ -54,6 +56,7 @@ impl TurnEngine for ScriptedEngine {
.expect("requests lock")
.push(RecordedTurn {
model: request.model.clone(),
+ reasoning_effort: request.reasoning_effort,
messages: request
.messages
.iter()
diff --git a/docs/AGENT_EFFORT.md b/docs/AGENT_EFFORT.md
index fc250f827e..c31ce170f8 100644
--- a/docs/AGENT_EFFORT.md
+++ b/docs/AGENT_EFFORT.md
@@ -24,3 +24,30 @@ variant. Only effort values with identical remaining parameters are shown.
Changing effort preserves those parameters and selects an actual catalog variant.
Automatic selection, missing reasoning parameters, or fewer than two compatible
values produce no effort control. No static provider effort list is used.
+
+## In-memory
+
+The engine's model catalog controls model availability. Native effort profiles
+are defined in `crates/agent/src/model/reasoning_effort.rs`; adding a model to the
+catalog does not guess its effort support from its name. Update the profile and
+provider serialization tests when adding support.
+
+| Routed model | Explicit effort values |
+| --- | --- |
+| anthropic/claude-sonnet-5, anthropic/claude-opus-5 | low, medium, high, xhigh, max |
+| openai/gpt-5.5 | none, low, medium, high, xhigh |
+| openai/gpt-5-mini | minimal, low, medium, high |
+| Haiku and unknown models | No effort control |
+
+Every supported profile also offers **Default**, meaning no session override.
+It preserves Macro's existing adapter defaults (including low for GPT-5 mini).
+It is distinct from OpenAI's explicit `none` and is never sent as a provider
+value. Anthropic receives `output_config.effort`; OpenAI Responses receives
+`reasoning.effort`. A compatible Chat Completions endpoint does not inherit
+native OpenAI capabilities merely because its model name resembles GPT.
+Thinking token budgets are not exposed as effort levels.
+
+Sources checked September 21, 2026:
+[Anthropic effort](https://platform.claude.com/docs/en/build-with-claude/effort),
+[GPT-5.5](https://developers.openai.com/api/docs/models/gpt-5.5), and
+[OpenAI reasoning](https://developers.openai.com/api/docs/guides/reasoning).