use super::*;
#[test]
fn prepared_request_round_trips_through_serde() {
let spec = RunSpec {
preamble: Some("be brief".to_string()),
temperature: Some(0.2),
..RunSpec::default()
};
let prepared = prepare_request(
&spec,
&ProviderCapabilities::default(),
"hi",
&[Message::user("hi").into()],
vec![std::sync::Arc::new(ToolDefinition {
name: rig_core::message::ToolName::new("add").expect("tool name"),
description: "adds".to_string(),
parameters: serde_json::json!({"type": "object"}),
annotations: Default::default(),
})],
None,
None,
)
.expect("prepare");
let json = serde_json::to_string(&prepared).expect("serialize");
let restored: PreparedRequest = serde_json::from_str(&json).expect("deserialize");
assert_eq!(restored, prepared);
}
#[test]
fn resolve_output_mode_auto_keeps_native_when_provider_composes() {
assert_eq!(
resolve_output_mode(true, true, true, true, &OutputMode::Auto),
OutputMode::Native,
);
}
#[test]
fn resolve_output_mode_degrades_to_native_when_output_tool_not_callable() {
assert_eq!(
resolve_output_mode(true, true, false, false, &OutputMode::Auto),
OutputMode::Native,
);
assert_eq!(
resolve_output_mode(true, true, false, false, &OutputMode::Tool),
OutputMode::Native,
);
assert_eq!(
resolve_output_mode(true, true, false, false, &OutputMode::Prompted),
OutputMode::Prompted,
);
}
#[test]
fn hosted_tools_are_advertised_but_not_executable() {
use rig_core::completion::ProviderToolDefinition;
use rig_core::message::ToolChoice;
let spec = RunSpec {
additional_params: Some(serde_json::json!({"tools": [{"type": "spec"}]})),
provider_tools: vec![
ProviderToolDefinition::new("web_search"),
ProviderToolDefinition::new("code"),
],
tool_choice: Some(ToolChoice::Required),
output_schema: Some(
serde_json::from_value(serde_json::json!({"type": "object"})).expect("schema"),
),
..RunSpec::default()
};
let patch =
RequestPatch::new().additional_params(serde_json::json!({"tools": [{"type": "patch"}]}));
let prepared = prepare_request(
&spec,
&ProviderCapabilities::default(),
"hi",
&[],
vec![],
None,
Some(&patch),
)
.expect("hosted tools satisfy Required");
assert_eq!(prepared.output_mode, OutputMode::Tool);
assert!(prepared.policy.executable().is_empty());
assert_eq!(
prepared.request.additional_params,
Some(serde_json::json!({
"tools": [{"type": "patch"}, {"type": "web_search"}, {"type": "code"}],
}))
);
let raw = RunSpec {
additional_params: Some(serde_json::json!({"tools": [{"type": "web_search"}]})),
tool_choice: Some(ToolChoice::Required),
..RunSpec::default()
};
prepare_request(
&raw,
&ProviderCapabilities::default(),
"hi",
&[],
vec![],
None,
None,
)
.expect("raw hosted tools satisfy Required");
}
#[test]
fn non_object_additional_params_with_provider_tools_fail() {
for params in [
serde_json::json!("oops"),
serde_json::json!(["a", "b"]),
serde_json::json!(7),
] {
let spec = RunSpec {
additional_params: Some(params.clone()),
provider_tools: vec![rig_core::completion::ProviderToolDefinition::new(
"web_search",
)],
..RunSpec::default()
};
let prepared = prepare_request(
&spec,
&ProviderCapabilities::default(),
"hi",
&[],
vec![],
None,
None,
);
assert!(
matches!(prepared, Err(ProviderError::Request(_))),
"{params}: {prepared:?}"
);
}
}