use super::*;
use rig_core::message::{ToolFunction, ToolResultContent};
use serde_json::json;
#[test]
fn initial_prompt_is_rewritable_only_before_the_run_starts() {
let mut run = AgentRun::new("original").max_turns(2);
assert!(run.initial_prompt().is_some());
run.rewrite_initial_prompt("rewritten")
.expect("rewrite before start");
let step = run.next_step().expect("first step");
let AgentRunStep::CallModel {
prompt, history, ..
} = step
else {
panic!("expected CallModel");
};
assert_eq!(prompt, Message::user("rewritten"));
assert!(history.is_empty());
assert!(run.initial_prompt().is_none());
assert!(run.rewrite_initial_prompt("too late").is_err());
}
#[test]
fn input_chat_history_reflects_the_configured_history() {
let run = AgentRun::new("p");
assert!(run.input_chat_history().is_empty());
let run = AgentRun::new("p").with_history(vec![Message::user("earlier")]);
assert_eq!(run.input_chat_history(), [Message::user("earlier")]);
}
fn entry(kind: &str, turn: usize, value: serde_json::Value) -> RunEntry {
RunEntry {
kind: kind.to_string(),
turn,
value,
}
}
#[test]
fn entries_round_trip_through_serialization_in_append_order() {
let mut run = AgentRun::new("p");
run.append_entry(entry("approval", 1, json!({"tool": "add"})));
run.append_entry(entry("counter", 1, json!(1)));
run.append_entry(entry("counter", 2, json!(2)));
let serialized = serde_json::to_string(&run).expect("run serializes");
let restored: AgentRun = serde_json::from_str(&serialized).expect("run deserializes");
assert_eq!(restored.entries(), run.entries());
assert_eq!(
restored.entries_of("counter").count(),
2,
"kind filter sees both counter snapshots"
);
assert_eq!(
restored.last_entry_of("counter"),
Some(&entry("counter", 2, json!(2)))
);
assert_eq!(restored.last_entry_of("absent"), None);
assert_eq!(restored.entries(), run.entries());
}
#[test]
fn runs_serialize_empty_entries_explicitly() {
let run = AgentRun::new("p");
let value = serde_json::to_value(&run).expect("serializes");
assert_eq!(
value["entries"],
json!([]),
"present, and empty, when empty"
);
let restored: AgentRun = serde_json::from_value(value).expect("deserializes");
assert!(restored.entries().is_empty());
}
#[test]
fn entries_never_reach_the_protocol_steps() {
let mut plain = AgentRun::new("p").max_turns(2);
let mut logged = AgentRun::new("p").max_turns(2);
logged.append_entry(entry("state", 0, json!({"visible": "never"})));
let plain_step = plain.next_step().expect("step");
let logged_step = logged.next_step().expect("step");
let (
AgentRunStep::CallModel {
prompt: plain_prompt,
history: plain_history,
turn: plain_turn,
},
AgentRunStep::CallModel {
prompt: logged_prompt,
history: logged_history,
turn: logged_turn,
},
) = (plain_step, logged_step)
else {
panic!("both runs emit CallModel first");
};
assert_eq!(plain_prompt, logged_prompt);
assert_eq!(plain_history, logged_history);
assert_eq!(plain_turn, logged_turn);
}
#[test]
fn run_step_and_outcome_round_trip_through_serde() {
let step = AgentRunStep::CallModel {
prompt: Message::user("hi"),
history: vec![Message::assistant("prior")],
turn: 1,
};
let json = serde_json::to_string(&step).expect("serialize step");
let restored: AgentRunStep = serde_json::from_str(&json).expect("deserialize step");
let AgentRunStep::CallModel { turn, .. } = restored else {
panic!("wrong variant");
};
assert_eq!(turn, 1);
let outcome = ModelTurnOutcome::Continue {
response_hook_suppressed: true,
};
let json = serde_json::to_string(&outcome).expect("serialize outcome");
assert!(matches!(
serde_json::from_str::<ModelTurnOutcome>(&json).expect("deserialize outcome"),
ModelTurnOutcome::Continue {
response_hook_suppressed: true
}
));
}
#[test]
fn from_response_matches_hand_assembly_field_for_field() {
let resp = {
let mut response = CompletionResponse::new(
vec![AssistantContent::text("hi"), tool_call("call_1", "add")],
usage(11, 7),
"openai",
json!({"provider": "payload"}),
)
.with_finish_reason(FinishReason::ToolCalls);
response.message_id = Some("msg_1".to_string());
response.response_id = Some("chatcmpl_1".to_string());
response.provider_request_id = Some("req_1".to_string());
response
};
let executable = tool_names(&["add"]);
let allowed = tool_names(&["add", "final_output"]);
let turn = ModelTurn::from_response_parts(&resp, executable.clone(), allowed.clone());
let expected = ModelTurn::new(
resp.message_id.clone(),
resp.choice.clone(),
resp.usage,
executable,
allowed,
resp.raw.clone(),
)
.with_identity(resp.response_id.clone(), resp.provider_request_id.clone())
.with_finish_reason(resp.finish_reason());
assert_eq!(turn.message_id, expected.message_id);
assert_eq!(turn.response_id, expected.response_id);
assert_eq!(turn.provider_request_id, expected.provider_request_id);
assert_eq!(turn.choice, expected.choice);
assert_eq!(turn.usage, expected.usage);
assert_eq!(turn.executable_tool_names, expected.executable_tool_names);
assert_eq!(turn.allowed_tool_names, expected.allowed_tool_names);
assert_eq!(turn.finish_reason, expected.finish_reason);
assert_eq!(turn.raw, expected.raw);
}
fn tool_names(names: &[&str]) -> BTreeSet<String> {
names.iter().map(|name| (*name).to_string()).collect()
}
fn usage(input_tokens: u64, output_tokens: u64) -> Usage {
Usage {
input_tokens: Some(input_tokens),
output_tokens: Some(output_tokens),
total_tokens: Some(input_tokens + output_tokens),
..Usage::default()
}
}
fn hand_raw() -> serde_json::Value {
json!({"origin": "hand-built test turn"})
}
fn text_turn(text: &str) -> ModelTurn {
text_turn_with_raw(text, hand_raw())
}
fn text_turn_with_raw(text: &str, raw: serde_json::Value) -> ModelTurn {
ModelTurn::new(
None,
vec![AssistantContent::text(text)],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add"]),
raw,
)
}
fn tool_call(id: &str, name: &str) -> AssistantContent {
AssistantContent::ToolCall(ToolCall::from_wire(
id,
ToolFunction::new(
rig_core::message::ToolName::new(name.to_string()).expect("tool name"),
json!({"x": 1}),
),
))
}
fn id_less_call(name: &str) -> AssistantContent {
AssistantContent::ToolCall(ToolCall::from_wire(
"",
ToolFunction::new(
rig_core::message::ToolName::new(name.to_string()).expect("tool name"),
json!({"x": 1}),
),
))
}
fn tool_call_turn(id: &str, name: &str) -> ModelTurn {
tool_call_turn_with_raw(id, name, hand_raw())
}
fn tool_call_turn_with_raw(id: &str, name: &str, raw: serde_json::Value) -> ModelTurn {
ModelTurn::new(
None,
vec![tool_call(id, name)],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add"]),
raw,
)
}
fn tool_result(id: &str, output: &str) -> UserContent {
UserContent::tool_result(
rig_core::message::CallId::from_wire(id),
rig_core::message::ToolName::new("add").expect("tool name"),
vec![ToolResultContent::text(output)],
)
}
fn expect_call_model(run: &mut AgentRun) -> (Message, Vec<Message>, usize) {
match run.next_step().expect("next_step should succeed") {
AgentRunStep::CallModel {
prompt,
history,
turn,
} => (prompt, history, turn),
step => panic!("expected CallModel, got {step:?}"),
}
}
fn expect_call_tools(run: &mut AgentRun) -> Vec<PendingToolCall> {
match run.next_step().expect("next_step should succeed") {
AgentRunStep::CallTools { calls } => calls,
step => panic!("expected CallTools, got {step:?}"),
}
}
fn expect_done(run: &mut AgentRun) -> PromptResponse {
match run.next_step().expect("next_step should succeed") {
AgentRunStep::Done(response) => response,
step => panic!("expected Done, got {step:?}"),
}
}
fn expect_continue(outcome: ModelTurnOutcome) -> bool {
match outcome {
ModelTurnOutcome::Continue {
response_hook_suppressed,
} => response_hook_suppressed,
outcome => panic!("expected Continue, got {outcome:?}"),
}
}
fn expect_needs_resolution(outcome: ModelTurnOutcome) -> InvalidToolCallContext {
match outcome {
ModelTurnOutcome::NeedsResolution(context) => context,
outcome => panic!("expected NeedsResolution, got {outcome:?}"),
}
}
#[test]
fn text_only_run_completes_in_one_turn() {
let mut run = AgentRun::new("hello");
let (prompt, history, turn) = expect_call_model(&mut run);
assert_eq!(prompt, Message::user("hello"));
assert!(history.is_empty());
assert_eq!(turn, 1);
let suppressed = expect_continue(
run.model_response(text_turn("hi there"))
.expect("model_response should succeed"),
);
assert!(!suppressed);
let response = expect_done(&mut run);
assert_eq!(response.output, "hi there");
let messages = response.messages.expect("messages should be recorded");
assert_eq!(messages.len(), 2);
assert!(run.is_done());
}
#[test]
fn input_history_prefixes_request_history() {
let mut run = AgentRun::new("question")
.with_history(vec![Message::user("earlier"), Message::assistant("reply")]);
let (_, history, _) = expect_call_model(&mut run);
assert_eq!(
history,
vec![Message::user("earlier"), Message::assistant("reply")]
);
expect_continue(
run.model_response(text_turn("answer"))
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
assert_eq!(
response
.messages
.expect("messages should be recorded")
.len(),
2
);
}
#[test]
fn repeated_model_turn_reuses_prompt_without_recording_rejected_response() {
let first_usage = usage(10, 3);
let second_usage = usage(7, 2);
let mut run = AgentRun::new("question").max_turns(2);
let (first_prompt, first_history, first_turn) = expect_call_model(&mut run);
assert_eq!(first_prompt, Message::user("question"));
assert!(first_history.is_empty());
assert_eq!(first_turn, 1);
expect_continue(
run.model_response(text_turn("rejected").with_usage_for_test(first_usage))
.expect("first response"),
);
run.retry_model_turn(RetryRequest::Repeat)
.expect("repeat should be accepted");
let (second_prompt, second_history, second_turn) = expect_call_model(&mut run);
assert_eq!(second_prompt, Message::user("question"));
assert!(second_history.is_empty());
assert_eq!(second_turn, 2);
assert_eq!(run.messages(), &[Message::user("question")]);
expect_continue(
run.model_response(text_turn("accepted").with_usage_for_test(second_usage))
.expect("second response"),
);
let response = expect_done(&mut run);
assert_eq!(response.output, "accepted");
assert_eq!(response.usage, first_usage + second_usage);
assert_eq!(response.completion_calls.len(), 2);
let messages = response.messages.expect("response history");
assert_eq!(messages.len(), 2);
assert!(!format!("{messages:?}").contains("rejected"));
}
#[test]
fn feedback_retry_records_rejected_response_and_corrective_prompt() {
let mut run = AgentRun::new("question").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(text_turn("rejected"))
.expect("first response"),
);
run.retry_model_turn(RetryRequest::Feedback("try another approach".to_string()))
.expect("feedback retry should be accepted");
let (prompt, history, turn) = expect_call_model(&mut run);
assert_eq!(prompt, Message::user("try another approach"));
assert_eq!(turn, 2);
assert_eq!(
history,
vec![Message::user("question"), Message::assistant("rejected")]
);
}
#[test]
fn repeated_model_turn_consumes_existing_max_turns_budget() {
let mut run = AgentRun::new("question");
expect_call_model(&mut run);
expect_continue(
run.model_response(text_turn("rejected"))
.expect("first response"),
);
run.retry_model_turn(RetryRequest::Repeat)
.expect("state transition itself should succeed");
let err = run.next_step().expect_err("second call must exceed budget");
assert!(matches!(
err,
PromptError::MaxTurnsError { max_turns: 1, .. }
));
assert_eq!(run.completion_calls().len(), 1);
}
#[test]
fn model_turn_retry_rejects_tool_calls_without_advancing_to_execution() {
let mut run = AgentRun::new("add things").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn("call_1", "add"))
.expect("tool response"),
);
let err = run
.retry_model_turn(RetryRequest::Feedback("do not call tools".to_string()))
.expect_err("tool-bearing retries must fail closed");
let PromptError::PromptCancelled {
chat_history,
reason,
} = err
else {
panic!("tool-bearing retry should return PromptCancelled");
};
assert!(reason.contains("tool-bearing model turns"));
assert!(reason.contains("tool-call hooks"));
assert_eq!(chat_history, vec![Message::user("add things")]);
assert!(run.next_step().is_err(), "failed run cannot execute tools");
}
#[test]
fn tool_roundtrip_threads_history_and_usage() {
let mut run = AgentRun::new("add things").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn("call_1", "add").with_usage_for_test(usage(10, 5)))
.expect("model_response should succeed"),
);
let calls = expect_call_tools(&mut run);
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].tool_call.function.name, "add");
assert!(calls[0].preresolved_result.is_none());
run.tool_results(vec![tool_result("call_1", "2")])
.expect("tool_results should succeed");
let (prompt, history, turn) = expect_call_model(&mut run);
assert_eq!(turn, 2);
assert!(matches!(prompt, Message::User { .. }));
assert_eq!(history.len(), 2);
expect_continue(
run.model_response(text_turn("the answer is 2").with_usage_for_test(usage(20, 7)))
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
assert_eq!(response.output, "the answer is 2");
assert_eq!(response.usage, usage(30, 12));
assert_eq!(response.completion_calls.len(), 2);
assert_eq!(response.completion_calls[0].call_index, 0);
assert_eq!(response.completion_calls[0].usage, usage(10, 5));
assert_eq!(response.completion_calls[1].usage, usage(20, 7));
assert_eq!(
response
.messages
.expect("messages should be recorded")
.len(),
4
);
}
#[test]
fn parallel_tool_calls_surface_in_emission_order() {
let mut run = AgentRun::new("do both").max_turns(2);
expect_call_model(&mut run);
let turn = ModelTurn::new(
None,
vec![tool_call("call_1", "add"), tool_call("call_2", "add")],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add"]),
hand_raw(),
);
expect_continue(
run.model_response(turn)
.expect("model_response should succeed"),
);
let calls = expect_call_tools(&mut run);
assert_eq!(calls.len(), 2);
assert_eq!(
calls[0]
.tool_call
.id
.provider()
.map(|provider| provider.call_id.as_str()),
Some("call_1")
);
assert_eq!(
calls[1]
.tool_call
.id
.provider()
.map(|provider| provider.call_id.as_str()),
Some("call_2")
);
run.tool_results(vec![tool_result("call_2", "b"), tool_result("call_1", "a")])
.expect("tool_results should succeed");
let messages = run.messages();
assert!(matches!(
messages.last(),
Some(Message::User { content }) if content.len() == 2
));
}
#[test]
fn max_turns_zero_rejects_initial_model_call() {
let mut run = AgentRun::new("do not call").max_turns(0);
let err = run
.next_step()
.expect_err("zero budget should emit no call");
assert!(matches!(
err,
PromptError::MaxTurnsError { max_turns: 0, .. }
));
assert_eq!(run.turn(), 0);
}
#[test]
fn new_implicitly_allows_one_model_call_and_rejects_tool_continuation() {
let mut run = AgentRun::new("add things");
let (_, _, turn) = expect_call_model(&mut run);
assert_eq!(turn, 1);
expect_continue(
run.model_response(tool_call_turn("call_1", "add"))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
run.tool_results(vec![tool_result("call_1", "2")])
.expect("tool_results should succeed");
let err = run
.next_step()
.expect_err("second model call should exceed budget");
assert!(matches!(
err,
PromptError::MaxTurnsError { max_turns: 1, .. }
));
assert_eq!(run.turn(), 1);
}
#[test]
fn max_turns_n_allows_exactly_n_model_calls() {
let mut run = AgentRun::new("loop").max_turns(3);
for (expected_turn, call_id) in [(1, "call_1"), (2, "call_2"), (3, "call_3")] {
let (_, _, turn) = expect_call_model(&mut run);
assert_eq!(turn, expected_turn);
expect_continue(
run.model_response(tool_call_turn(call_id, "add"))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
run.tool_results(vec![tool_result(call_id, "0")])
.expect("tool_results should succeed");
}
let err = run
.next_step()
.expect_err("fourth model call should exceed budget");
assert!(matches!(
err,
PromptError::MaxTurnsError { max_turns: 3, .. }
));
assert_eq!(run.turn(), 3);
}
#[test]
fn invalid_tool_call_fail_returns_unknown_tool_call() {
let mut run = AgentRun::new("call something");
expect_call_model(&mut run);
let context = expect_needs_resolution(
run.model_response(tool_call_turn("call_1", "unknown"))
.expect("model_response should succeed"),
);
assert_eq!(context.tool_name, "unknown");
assert_eq!(context.available_tools, vec!["add".to_string()]);
assert!(!context.is_streaming);
assert_eq!(context.chat_history.len(), 2);
let err = run
.resolve_invalid_tool_call(InvalidToolCallAction::fail())
.expect_err("fail action should error");
assert!(matches!(
err,
PromptError::UnknownToolCall { tool_name, .. } if tool_name == "unknown"
));
}
#[test]
fn invalid_tool_call_stop_leaves_run_terminal() {
let mut run = AgentRun::new("call something");
expect_call_model(&mut run);
expect_needs_resolution(
run.model_response(tool_call_turn("call_1", "unknown"))
.expect("model_response should succeed"),
);
let err = run
.resolve_invalid_tool_call(InvalidToolCallAction::stop("operator stop"))
.expect_err("stop should cancel the run");
assert!(matches!(
err,
PromptError::PromptCancelled { reason, .. } if reason == "operator stop"
));
let err = run
.next_step()
.expect_err("a stopped run must remain terminal");
assert!(matches!(
err,
PromptError::PromptCancelled { reason, .. }
if reason.contains("next_step called after the run already failed")
));
}
#[test]
fn invalid_tool_call_retry_rolls_back_with_feedback() {
let mut run = AgentRun::new("call something")
.max_turns(2)
.max_invalid_tool_call_retries(1);
expect_call_model(&mut run);
expect_needs_resolution(
run.model_response(tool_call_turn("call_1", "unknown"))
.expect("model_response should succeed"),
);
let outcome = run
.resolve_invalid_tool_call(InvalidToolCallAction::retry("use add instead"))
.expect("retry should be accepted");
assert!(matches!(outcome, ModelTurnOutcome::TurnRetried));
assert_eq!(run.messages().len(), 3);
let (prompt, _, turn) = expect_call_model(&mut run);
assert_eq!(turn, 2);
assert!(matches!(
prompt,
Message::User { ref content }
if matches!(content.first(), Some(UserContent::ToolResult(_)))
));
expect_needs_resolution(
run.model_response(tool_call_turn("call_2", "unknown"))
.expect("model_response should succeed"),
);
let err = run
.resolve_invalid_tool_call(InvalidToolCallAction::retry("again"))
.expect_err("budget exhausted");
assert!(matches!(err, PromptError::UnknownToolCall { .. }));
}
#[test]
fn invalid_tool_call_retry_cannot_emit_call_past_total_budget() {
let mut run = AgentRun::new("call something")
.max_turns(1)
.max_invalid_tool_call_retries(1);
expect_call_model(&mut run);
expect_needs_resolution(
run.model_response(tool_call_turn("call_1", "unknown"))
.expect("model_response should succeed"),
);
let outcome = run
.resolve_invalid_tool_call(InvalidToolCallAction::retry("use add instead"))
.expect("retry resolution should be accepted");
assert!(matches!(outcome, ModelTurnOutcome::TurnRetried));
assert_eq!(run.completion_calls().len(), 1);
let err = run
.next_step()
.expect_err("retry must not emit a second model call");
assert!(matches!(
err,
PromptError::MaxTurnsError { max_turns: 1, .. }
));
assert_eq!(run.turn(), 1);
}
#[test]
fn invalid_tool_call_repair_renames_and_suppresses_response_hook() {
let mut run = AgentRun::new("call something").max_turns(2);
expect_call_model(&mut run);
expect_needs_resolution(
run.model_response(tool_call_turn("call_1", "default_api"))
.expect("model_response should succeed"),
);
let suppressed = expect_continue(
run.resolve_invalid_tool_call(InvalidToolCallAction::repair("add"))
.expect("repair should be accepted"),
);
assert!(suppressed);
let calls = expect_call_tools(&mut run);
assert_eq!(calls[0].tool_call.function.name, "add");
assert!(calls[0].preresolved_result.is_none());
}
#[test]
fn invalid_tool_call_repair_to_disallowed_name_fails() {
let mut run = AgentRun::new("call something");
expect_call_model(&mut run);
expect_needs_resolution(
run.model_response(tool_call_turn("call_1", "unknown"))
.expect("model_response should succeed"),
);
let err = run
.resolve_invalid_tool_call(InvalidToolCallAction::repair("also_unknown"))
.expect_err("repair to disallowed name should fail");
assert!(matches!(
err,
PromptError::UnknownToolCall { tool_name, .. } if tool_name == "also_unknown"
));
}
#[test]
fn invalid_tool_call_skip_suppresses_all_peer_executions() {
let mut run = AgentRun::new("call things").max_turns(2);
expect_call_model(&mut run);
let turn = ModelTurn::new(
None,
vec![tool_call("call_1", "unknown"), tool_call("call_2", "add")],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add"]),
hand_raw(),
);
expect_needs_resolution(
run.model_response(turn)
.expect("model_response should succeed"),
);
let suppressed = expect_continue(
run.resolve_invalid_tool_call(InvalidToolCallAction::skip("not available"))
.expect("skip should be accepted"),
);
assert!(suppressed);
let calls = expect_call_tools(&mut run);
assert_eq!(calls.len(), 2);
assert!(calls.iter().all(|call| call.preresolved_result.is_some()));
}
#[test]
fn id_less_calls_keep_distinct_skip_results() {
let mut run = AgentRun::new("call things").max_turns(2);
expect_call_model(&mut run);
let turn = ModelTurn::new(
None,
vec![id_less_call("unknown"), id_less_call("add")],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add"]),
hand_raw(),
);
expect_needs_resolution(
run.model_response(turn)
.expect("model_response should succeed"),
);
let suppressed = expect_continue(
run.resolve_invalid_tool_call(InvalidToolCallAction::skip("not available"))
.expect("skip should be accepted"),
);
assert!(suppressed);
let calls = expect_call_tools(&mut run);
assert_eq!(calls.len(), 2);
assert_ne!(
calls[0].tool_call.id, calls[1].tool_call.id,
"id-less calls mint distinct correlation handles, never a shared sentinel"
);
assert!(
calls
.iter()
.all(|call| call.tool_call.id.is_local() && call.tool_call.id.provider().is_none()),
"minted handles are non-empty and record the provider's absence"
);
let results: Vec<String> = calls
.iter()
.map(|call| match call.preresolved_result.as_ref() {
Some(rig_core::message::UserContent::ToolResult(result)) => result
.content
.iter()
.filter_map(|content| match content {
rig_core::message::ToolResultContent::Text(text) => Some(text.text.clone()),
_ => None,
})
.collect(),
_ => panic!("both calls carry preresolved results"),
})
.collect();
assert_eq!(
results[0], "not available",
"the skipped call reads its own feedback"
);
assert_eq!(
results[1], TOOL_NOT_EXECUTED_DUE_TO_INVALID_PEER,
"the peer reads its own synthetic result, not the skipped one\'s"
);
}
#[test]
fn skip_under_tool_choice_none_fails() {
let mut run = AgentRun::new("call something").with_tool_choice(ToolChoice::None);
expect_call_model(&mut run);
expect_needs_resolution(
run.model_response(ModelTurn::new(
None,
vec![tool_call("call_1", "add")],
Usage::default(),
tool_names(&["add"]),
BTreeSet::new(),
hand_raw(),
))
.expect("model_response should succeed"),
);
let err = run
.resolve_invalid_tool_call(InvalidToolCallAction::skip("nope"))
.expect_err("skip under ToolChoice::None should fail");
assert!(matches!(err, PromptError::UnknownToolCall { .. }));
}
#[test]
fn empty_tool_results_cancel_the_run() {
let mut run = AgentRun::new("call something").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn("call_1", "add"))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
let err = run
.tool_results(Vec::new())
.expect_err("empty results should cancel");
assert!(matches!(
err,
PromptError::PromptCancelled { reason, .. }
if reason.contains("tool execution produced no tool results")
));
}
#[test]
fn out_of_protocol_calls_are_rejected_without_corrupting_state() {
let mut run = AgentRun::new("hello");
let err = run
.tool_results(vec![tool_result("call_1", "x")])
.expect_err("no CallTools pending");
assert!(matches!(err, PromptError::PromptCancelled { .. }));
expect_call_model(&mut run);
let err = run
.next_step()
.expect_err("model response is pending, next_step must be rejected");
assert!(matches!(err, PromptError::PromptCancelled { .. }));
expect_continue(
run.model_response(text_turn("hi"))
.expect("model_response should still succeed"),
);
assert_eq!(expect_done(&mut run).output, "hi");
}
#[test]
fn model_response_rejected_after_streamed_completion_call_record() {
let mut run = AgentRun::new("hello");
expect_call_model(&mut run);
run.record_streamed_completion_call(
Usage::default(),
ResponseIdentity::default(),
None,
hand_raw(),
)
.expect("record should succeed");
let err = run
.model_response(text_turn("hi"))
.expect_err("mixed streamed/non-streamed ingestion must be rejected");
assert!(matches!(err, PromptError::PromptCancelled { .. }));
assert_eq!(run.completion_calls().len(), 1);
}
#[test]
fn done_step_is_idempotent() {
let mut run = AgentRun::new("hello");
expect_call_model(&mut run);
expect_continue(
run.model_response(text_turn("hi"))
.expect("model_response should succeed"),
);
assert_eq!(expect_done(&mut run).output, "hi");
assert_eq!(expect_done(&mut run).output, "hi");
}
#[test]
fn serialized_run_alone_carries_pending_tool_calls() {
let mut run = AgentRun::new("add things").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn("call_1", "add"))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
let serialized = serde_json::to_string(&run).expect("mid-run state should serialize");
drop(run);
let mut resumed: AgentRun =
serde_json::from_str(&serialized).expect("mid-run state should deserialize");
let calls = expect_call_tools(&mut resumed);
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].tool_call.function.name, "add");
let calls_again = expect_call_tools(&mut resumed);
assert_eq!(calls_again[0].tool_call.id, calls[0].tool_call.id);
let results = calls
.iter()
.map(|call| {
UserContent::tool_result(
call.tool_call.id.clone(),
call.tool_call.function.name.clone(),
vec![ToolResultContent::text("2")],
)
})
.collect::<Vec<_>>();
resumed
.tool_results(results)
.expect("tool_results should succeed");
expect_call_model(&mut resumed);
expect_continue(
resumed
.model_response(text_turn("done"))
.expect("model_response should succeed"),
);
assert_eq!(expect_done(&mut resumed).output, "done");
}
#[test]
fn tool_results_validates_against_pending_calls() {
let drive_to_pending_tools = || {
let mut run = AgentRun::new("add things").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn("call_1", "add"))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
run
};
let mut run = drive_to_pending_tools();
let err = run
.tool_results(vec![tool_result("call_unknown", "2")])
.expect_err("unknown tool call id must be rejected");
assert!(matches!(err, PromptError::PromptCancelled { .. }));
run.tool_results(vec![tool_result("call_1", "2")])
.expect("valid results should still be accepted after a rejection");
let mut run = drive_to_pending_tools();
let err = run
.tool_results(vec![tool_result("call_1", "2"), tool_result("call_1", "3")])
.expect_err("answering one call twice must be rejected");
assert!(matches!(err, PromptError::PromptCancelled { .. }));
let mut run = drive_to_pending_tools();
let err = run
.tool_results(vec![UserContent::text("not a tool result")])
.expect_err("non-tool-result content must be rejected");
assert!(matches!(err, PromptError::PromptCancelled { .. }));
}
#[test]
fn agent_run_deserializes_suspended_state() {
let mut suspended = AgentRun::new("add things").max_turns(2);
expect_call_model(&mut suspended);
expect_continue(
suspended
.model_response(tool_call_turn("call_1", "add"))
.expect("model_response should succeed"),
);
expect_call_tools(&mut suspended);
let fixture = serde_json::to_string(&suspended).expect("suspended run should serialize");
let bare_ids = fixture.replace(
r#""id":{"provider":{"call_id":"call_1"}}"#,
r#""id":"call_1""#,
);
assert_ne!(bare_ids, fixture);
assert!(
serde_json::from_str::<AgentRun>(&bare_ids).is_err(),
"bare IDs must not be silently reinterpreted"
);
let mut restored: AgentRun =
serde_json::from_str(&fixture).expect("suspended run should deserialize");
assert_eq!(restored.completion_calls()[0].usage, Usage::default());
let calls = expect_call_tools(&mut restored);
assert_eq!(calls.len(), 1);
assert_eq!(
calls[0].tool_call.id,
rig_core::message::CallId::from_wire("call_1")
);
restored
.tool_results(vec![tool_result("call_1", "2")])
.expect("tool_results should succeed");
expect_call_model(&mut restored);
}
#[test]
fn serde_round_trip_at_exhausted_budget_preserves_boundary() {
let mut run = AgentRun::new("add things").max_turns(1);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn("call_1", "add"))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
run.tool_results(vec![tool_result("call_1", "2")])
.expect("tool_results should succeed");
let serialized = serde_json::to_string(&run).expect("exhausted run should serialize");
let mut restored: AgentRun =
serde_json::from_str(&serialized).expect("exhausted run should deserialize");
assert_eq!(restored.completion_calls().len(), 1);
let err = restored
.next_step()
.expect_err("restored run must not emit a second model call");
assert!(matches!(
err,
PromptError::MaxTurnsError { max_turns: 1, .. }
));
assert_eq!(restored.turn(), 1);
}
#[test]
fn serde_round_trip_mid_run_resumes_identically() {
let drive_to_pending_tools = || {
let mut run = AgentRun::new("add things").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn("call_1", "add").with_usage_for_test(usage(10, 5)))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
run
};
let finish = |mut run: AgentRun| {
run.tool_results(vec![tool_result("call_1", "2")])
.expect("tool_results should succeed");
expect_call_model(&mut run);
expect_continue(
run.model_response(text_turn("done").with_usage_for_test(usage(3, 4)))
.expect("model_response should succeed"),
);
expect_done(&mut run)
};
let uninterrupted = finish(drive_to_pending_tools());
let suspended = drive_to_pending_tools();
let serialized = serde_json::to_string(&suspended).expect("mid-run state should serialize");
assert!(
serialized.contains("\"call_1\""),
"the pending call persists its id: {serialized}"
);
let restored: AgentRun =
serde_json::from_str(&serialized).expect("mid-run state should deserialize");
let resumed = finish(restored);
assert_eq!(resumed.output, uninterrupted.output);
assert_eq!(resumed.usage, uninterrupted.usage);
assert_eq!(resumed.completion_calls, uninterrupted.completion_calls);
assert_eq!(resumed.messages, uninterrupted.messages);
}
#[test]
fn pending_invalid_tool_call_survives_serde_round_trip() {
let mut run = AgentRun::new("call something");
expect_call_model(&mut run);
let context = expect_needs_resolution(
run.model_response(tool_call_turn("call_1", "unknown"))
.expect("model_response should succeed"),
);
let serialized = serde_json::to_string(&run).expect("state should serialize");
let restored: AgentRun = serde_json::from_str(&serialized).expect("state should deserialize");
let restored_context = restored
.pending_invalid_tool_call()
.expect("pending resolution should survive serialization");
assert_eq!(restored_context.tool_name, context.tool_name);
assert_eq!(
restored_context.chat_history.len(),
context.chat_history.len()
);
assert_eq!(restored_context.tool_call_id, context.tool_call_id);
assert_eq!(
context
.tool_call_id
.as_ref()
.and_then(|id| id.provider().map(|provider| provider.call_id.as_str())),
Some("call_1")
);
assert_eq!(restored_context.tool_call_id, context.tool_call_id);
}
fn output_tool_turn(id: &str, name: &str) -> ModelTurn {
ModelTurn::new(
None,
vec![tool_call(id, name)],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add", name]),
hand_raw(),
)
}
fn output_tool_turn_with_args(id: &str, name: &str, arguments: serde_json::Value) -> ModelTurn {
ModelTurn::new(
None,
vec![AssistantContent::ToolCall(ToolCall::from_wire(
id,
ToolFunction::new(
rig_core::message::ToolName::new(name.to_string()).expect("tool name"),
arguments,
),
))],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add", name]),
hand_raw(),
)
}
fn assert_no_orphan_tool_use(messages: &[Message]) {
let mut pending = Vec::new();
for message in messages {
match message {
Message::Assistant { content, .. } => {
pending.extend(content.iter().filter_map(|item| match item {
AssistantContent::ToolCall(call) => Some(&call.id),
_ => None,
}));
}
Message::User { content } => {
for item in content {
if let UserContent::ToolResult(result) = item {
let index = pending
.iter()
.position(|id| *id == &result.call)
.expect("result must answer a preceding pending call");
pending.remove(index);
}
}
}
Message::System { .. } => {}
}
}
assert!(
pending.is_empty(),
"unanswered tool call occurrences: {pending:?}"
);
}
#[test]
fn output_tool_call_finalizes_run_with_arguments() {
let mut run = AgentRun::new("summarize").with_output_tool_name("final_result");
expect_call_model(&mut run);
expect_continue(
run.model_response(output_tool_turn("call_1", "final_result"))
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
assert_eq!(response.output, r#"{"x":1}"#);
assert!(run.is_done());
let messages = response.messages.expect("messages should be recorded");
assert_no_orphan_tool_use(&messages);
assert!(matches!(
messages.last(),
Some(Message::Assistant { content, .. })
if assistant_text_from_choice(content) == r#"{"x":1}"#
));
}
#[test]
fn scalar_output_tool_call_is_serialized_as_reparseable_json() {
let mut run = AgentRun::new("summarize").with_output_tool_name("final_result");
expect_call_model(&mut run);
expect_continue(
run.model_response(output_tool_turn_with_args(
"call_1",
"final_result",
json!("complete"),
))
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
assert_eq!(
serde_json::from_str::<serde_json::Value>(&response.output)
.expect("scalar output must remain valid JSON"),
json!("complete")
);
assert_eq!(response.output, r#""complete""#);
let messages = response.messages.expect("messages should be recorded");
assert_no_orphan_tool_use(&messages);
assert!(matches!(
messages.last(),
Some(Message::Assistant { content, .. })
if assistant_text_from_choice(content) == r#""complete""#
));
}
#[test]
fn output_tool_call_wins_over_sibling_real_tool_calls() {
let mut run = AgentRun::new("do it")
.max_turns(2)
.with_output_tool_name("final_result");
expect_call_model(&mut run);
let turn = ModelTurn::new(
None,
vec![
tool_call("call_1", "add"),
tool_call("call_2", "final_result"),
],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add", "final_result"]),
hand_raw(),
);
expect_continue(
run.model_response(turn)
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
assert_eq!(response.output, r#"{"x":1}"#);
assert!(run.is_done());
let messages = response.messages.expect("messages should be recorded");
assert_no_orphan_tool_use(&messages);
assert!(
messages.iter().all(|message| match message {
Message::Assistant { content, .. } => !content
.iter()
.any(|item| matches!(item, AssistantContent::ToolCall(_))),
_ => true,
}),
"no assistant tool calls should survive in the finalized history"
);
}
#[test]
fn real_tool_calls_still_execute_when_output_tool_unused() {
let mut run = AgentRun::new("add things")
.max_turns(2)
.with_output_tool_name("final_result");
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn("call_1", "add"))
.expect("model_response should succeed"),
);
let calls = expect_call_tools(&mut run);
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].tool_call.function.name, "add");
}
fn required_field_schema(field: &str) -> serde_json::Value {
json!({
"type": "object",
"required": [field],
"properties": { field: { "type": "string" } },
})
}
#[test]
fn tool_mode_reprompts_when_output_tool_not_called() {
let mut run = AgentRun::new("summarize")
.max_turns(2)
.with_output_tool_name("final_result")
.with_output_validation(Some(required_field_schema("summary")), 1);
expect_call_model(&mut run);
expect_continue(
run.model_response(text_turn("here is the answer"))
.expect("model_response should succeed"),
);
let (prompt, _history, turn) = expect_call_model(&mut run);
assert_eq!(turn, 2);
let prompt_json = serde_json::to_string(&prompt).expect("prompt should serialize");
assert!(
prompt_json.contains("final_result"),
"re-prompt feedback should name the output tool: {prompt_json}"
);
assert!(!run.is_done());
}
#[test]
fn tool_mode_reprompts_when_output_args_missing_required_fields() {
let mut run = AgentRun::new("summarize")
.max_turns(2)
.with_output_tool_name("final_result")
.with_output_validation(Some(required_field_schema("summary")), 1);
expect_call_model(&mut run);
expect_continue(
run.model_response(output_tool_turn("call_1", "final_result"))
.expect("model_response should succeed"),
);
let (_prompt, _history, turn) = expect_call_model(&mut run);
assert_eq!(turn, 2);
assert!(!run.is_done());
}
#[test]
fn tool_mode_accepts_valid_json_text_without_reprompting() {
let mut run = AgentRun::new("summarize")
.max_turns(3)
.with_output_tool_name("final_result")
.with_output_validation(Some(required_field_schema("summary")), 1);
expect_call_model(&mut run);
expect_continue(
run.model_response(text_turn(r#"{"summary":"all good"}"#))
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
assert_eq!(response.output, r#"{"summary":"all good"}"#);
assert!(run.is_done());
}
#[test]
fn tool_mode_finalizes_best_effort_when_model_call_budget_exhausted() {
let mut run = AgentRun::new("summarize")
.max_turns(1)
.with_output_tool_name("final_result")
.with_output_validation(Some(required_field_schema("summary")), 1);
expect_call_model(&mut run);
expect_continue(
run.model_response(text_turn("invalid output"))
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
assert_eq!(response.output, "invalid output");
assert_eq!(run.turn(), 1);
}
#[test]
fn tool_mode_finalizes_best_effort_when_output_retry_budget_exhausted() {
let mut run = AgentRun::new("summarize")
.max_turns(3)
.with_output_tool_name("final_result")
.with_output_validation(Some(required_field_schema("summary")), 0);
expect_call_model(&mut run);
expect_continue(
run.model_response(output_tool_turn("call_1", "final_result"))
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
assert_eq!(response.output, r#"{"x":1}"#);
let messages = response.messages.expect("messages should be recorded");
assert_no_orphan_tool_use(&messages);
}
#[test]
fn commit_output_tool_name_pins_the_first_name() {
let mut run = AgentRun::new("x").with_output_tool_name("first");
assert!(!run.commit_output_tool_name("second"));
assert_eq!(run.output_tool_name.as_deref(), Some("first"));
let mut run = AgentRun::new("x");
assert!(run.commit_output_tool_name("filled"));
assert!(!run.commit_output_tool_name("again"));
assert_eq!(run.output_tool_name.as_deref(), Some("filled"));
}
impl ModelTurn {
fn with_usage_for_test(mut self, usage: Usage) -> Self {
self.usage = usage;
self
}
}
#[test]
fn durable_human_in_the_loop_approval_survives_serialize_resume() {
let mut run = AgentRun::new("pay two invoices").max_turns(3);
let (_, _, turn) = expect_call_model(&mut run);
assert_eq!(turn, 1);
let two_calls = vec![tool_call("c1", "add"), tool_call("c2", "add")];
let outcome = run
.model_response(ModelTurn::new(
None,
two_calls,
Usage::default(),
tool_names(&["add"]),
tool_names(&["add"]),
hand_raw(),
))
.expect("model_response");
expect_continue(outcome);
let checkpoint = serde_json::to_string(&run).expect("serialize suspended run");
let mut resumed: AgentRun = serde_json::from_str(&checkpoint).expect("deserialize run");
let calls = expect_call_tools(&mut resumed);
assert_eq!(calls.len(), 2);
assert_eq!(
calls[0]
.tool_call
.id
.provider()
.map(|provider| provider.call_id.as_str()),
Some("c1")
);
assert_eq!(
calls[1]
.tool_call
.id
.provider()
.map(|provider| provider.call_id.as_str()),
Some("c2")
);
resumed
.tool_results(vec![
tool_result("c1", "approved-result"),
tool_result("c2", "denied by reviewer: second payment not authorized"),
])
.expect("tool_results on the resumed run");
let after = serde_json::to_string(&resumed).expect("serialize resumed run");
assert!(
after.contains("approved-result"),
"the approved call's result must be in the resumed run state"
);
assert!(
after.contains("denied by reviewer: second payment not authorized"),
"the denied call's reason must be in the resumed run state"
);
let (_, _, turn2) = expect_call_model(&mut resumed);
assert_eq!(turn2, 2);
expect_continue(
resumed
.model_response(text_turn("done"))
.expect("model_response 2"),
);
let response = expect_done(&mut resumed);
assert_eq!(response.output, "done");
}
fn raw_payload(attempt: &str) -> serde_json::Value {
json!({
"id": format!("resp-{attempt}"),
"provider_only": attempt,
})
}
#[test]
fn model_turn_raw_is_recorded_on_the_completion_call() {
let first = raw_payload("turn-1");
let second = raw_payload("turn-2");
let mut run = AgentRun::new("add things").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn_with_raw("call_1", "add", first.clone()))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
run.tool_results(vec![tool_result("call_1", "2")])
.expect("tool_results should succeed");
expect_call_model(&mut run);
expect_continue(
run.model_response(text_turn_with_raw("done", second.clone()))
.expect("model_response should succeed"),
);
let response = expect_done(&mut run);
let raws: Vec<_> = response
.completion_calls
.iter()
.map(|call| call.raw.clone())
.collect();
assert_eq!(
raws,
[first, second],
"each call carries its own turn's payload"
);
}
#[test]
fn streamed_completion_call_record_carries_raw() {
let raw = raw_payload("streamed");
let mut run = AgentRun::new("hello");
expect_call_model(&mut run);
let call = run
.record_streamed_completion_call(
usage(3, 4),
ResponseIdentity::default(),
None,
raw.clone(),
)
.expect("record should succeed");
assert_eq!(call.raw, raw);
assert_eq!(run.completion_calls()[0].raw, raw);
}
#[test]
fn recorded_raw_survives_serde_round_trip() {
let raw = raw_payload("suspended");
let mut run = AgentRun::new("add things").max_turns(2);
expect_call_model(&mut run);
expect_continue(
run.model_response(tool_call_turn_with_raw("call_1", "add", raw.clone()))
.expect("model_response should succeed"),
);
expect_call_tools(&mut run);
let serialized = serde_json::to_string(&run).expect("mid-run state should serialize");
let restored: AgentRun =
serde_json::from_str(&serialized).expect("mid-run state should deserialize");
assert_eq!(restored.completion_calls().len(), 1);
assert_eq!(restored.completion_calls()[0].raw, raw);
assert_eq!(restored.completion_calls(), run.completion_calls());
}
#[test]
fn raw_round_trips_and_a_missing_key_is_refused() {
let raw = raw_payload("turn");
let turn = text_turn_with_raw("hi", raw.clone());
let value = serde_json::to_value(&turn).expect("turn should serialize");
assert_eq!(value["raw"], raw);
let restored: ModelTurn =
serde_json::from_value(value.clone()).expect("turn should deserialize");
assert_eq!(restored.raw, raw);
let mut without_raw = value;
without_raw
.as_object_mut()
.expect("turn serializes as an object")
.remove("raw")
.expect("the raw key was present");
let error = serde_json::from_value::<ModelTurn>(without_raw)
.expect_err("a turn without a raw key is refused");
assert!(error.to_string().contains("raw"), "{error}");
let call = CompletionCall::new(0, usage(1, 2), raw_payload("call"));
let mut value = serde_json::to_value(&call).expect("call should serialize");
assert_eq!(value["raw"], raw_payload("call"));
let restored: CompletionCall =
serde_json::from_value(value.clone()).expect("call should deserialize");
assert_eq!(restored, call);
value
.as_object_mut()
.expect("call serializes as an object")
.remove("raw")
.expect("the raw key was present");
let error = serde_json::from_value::<CompletionCall>(value)
.expect_err("a call without a raw key is refused");
assert!(error.to_string().contains("raw"), "{error}");
}
#[test]
fn a_run_of_another_format_or_with_an_unknown_key_is_refused() {
let run = AgentRun::new("hello");
let mut value = serde_json::to_value(&run).expect("run should serialize");
assert_eq!(value["format"], RUN_FORMAT);
value["format"] = serde_json::json!(RUN_FORMAT + 1);
let error =
serde_json::from_value::<AgentRun>(value.clone()).expect_err("another format is refused");
assert_eq!(
error.to_string(),
format!(
"resume refused: the run is format {}, this rig reads format {RUN_FORMAT}",
RUN_FORMAT + 1
)
);
value["format"] = serde_json::json!(RUN_FORMAT);
value["retired_field"] = serde_json::json!(true);
let error = serde_json::from_value::<AgentRun>(value).expect_err("an unknown key is refused");
assert!(error.to_string().contains("retired_field"), "{error}");
}
#[test]
fn from_spec_matches_the_builder_chain() {
let spec = RunSpec {
max_turns: Some(4),
max_invalid_tool_call_retries: 2,
tool_choice: Some(ToolChoice::Auto),
..RunSpec::new()
};
let via_spec = AgentRun::from_spec(&spec, "hi", None);
let via_chain = AgentRun::new("hi")
.max_turns(4)
.max_invalid_tool_call_retries(2)
.with_output_validation(None, RunSpec::DEFAULT_OUTPUT_RETRIES)
.with_tool_choice(ToolChoice::Auto);
assert_eq!(
serde_json::to_value(&via_spec).expect("serialize"),
serde_json::to_value(&via_chain).expect("serialize")
);
}
fn assistant(content: Vec<AssistantContent>) -> Message {
Message::Assistant { id: None, content }
}
#[test]
fn with_validated_history_gates_construction() {
let bad = vec![
assistant(vec![AssistantContent::text("a")]),
assistant(vec![AssistantContent::text("b")]),
];
assert!(AgentRun::new("x").with_validated_history(bad).is_err());
assert!(
AgentRun::new("x")
.with_validated_history(vec![Message::user("ok")])
.is_ok()
);
}
#[test]
fn serde_round_trip_keeps_the_previous_model() {
let mut run = AgentRun::new("add things").max_turns(3);
assert!(run.previous_model().is_none());
run.set_previous_model(rig_core::completion::ModelRef::new("fast"));
let state = serde_json::to_string(&run).expect("the run serializes");
let restored: AgentRun = serde_json::from_str(&state).expect("the run restores");
assert_eq!(
restored.previous_model().map(|model| model.as_str()),
Some("fast")
);
}
#[test]
fn a_truncated_reasoning_only_turn_commits_nothing() {
let mut run = AgentRun::new("solve this");
let _ = expect_call_model(&mut run);
let turn = ModelTurn::new(
None,
vec![AssistantContent::Reasoning(
rig_core::message::Reasoning::new("thinking, never answering").sealed("test"),
)],
Usage::default(),
tool_names(&["add"]),
tool_names(&["add"]),
hand_raw(),
)
.with_finish_reason(Some(FinishReason::Length));
expect_continue(
run.model_response(turn)
.expect("the turn is taken into resolution"),
);
let error = run
.next_step()
.expect_err("an answerless truncated turn fails the run");
assert!(format!("{error:?}").contains("Length"), "{error:?}");
assert!(
run.new_messages
.iter()
.all(|message| !matches!(message, Message::Assistant { .. })),
"the reasoning-only turn is not history: {:?}",
run.new_messages
);
}
#[test]
fn transcript_helpers_build_no_message_from_nothing() {
assert_eq!(transcript::assistant_message(None, Vec::new()), None);
assert_eq!(transcript::assistant_turn(None, Vec::new()), None);
assert_eq!(
transcript::invalid_tool_retry_user_message(
&[AssistantContent::text("no calls here")],
&rig_core::message::CallId::from_wire("call_1"),
"feedback",
),
None
);
}