[Rust Frontend] Relax schema-aware tool argument conversion (#59004)

Signed-off-by: Bugen Zhao <i@bugenzhao.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Bugen Zhao
2026-09-29 05:40:41 +00:00
committed by GitHub
co-authored by Claude Opus 5.5
parent ec5e0c352f
commit 28f6739576
+136 -9
View File
@@ -150,7 +150,33 @@ impl ToolSchema {
impl JsonParamType {
/// Normalize one parameter property schema.
///
/// `"nullable": true` (the OpenAPI spelling of an optional parameter) adds
/// `null` to the accepted types.
fn from_schema(schema: &Value) -> Option<Self> {
let param_type = Self::from_schema_ignoring_nullable(schema)?;
let nullable = schema.get("nullable").and_then(Value::as_bool) == Some(true);
Some(match param_type {
_ if !nullable || param_type.accepts_null() => param_type,
Self::OneOf(mut types) => {
types.push(Self::Null);
Self::OneOf(types)
}
param_type => Self::OneOf(vec![param_type, Self::Null]),
})
}
/// Return whether `null` is one of the accepted types.
fn accepts_null(&self) -> bool {
match self {
Self::Null => true,
Self::OneOf(types) => types.iter().any(Self::accepts_null),
_ => false,
}
}
/// Normalize one parameter property schema, without `nullable`.
fn from_schema_ignoring_nullable(schema: &Value) -> Option<Self> {
let schema = schema.as_object()?;
if let Some(type_value) = schema.get("type") {
@@ -284,8 +310,10 @@ impl JsonParamType {
}
}
/// Recognize JSON and Python null spellings emitted by chat templates.
/// Recognize JSON and Python null spellings emitted by chat templates,
/// ignoring surrounding whitespace.
fn is_null_literal(value: &str) -> bool {
let value = value.trim();
value.eq_ignore_ascii_case("null") || value.eq_ignore_ascii_case("none")
}
@@ -327,18 +355,24 @@ fn try_convert_value(param_type: &JsonParamType, input: &ParamInput) -> Option<V
}
/// Convert one raw string value to a normalized JSON type.
///
/// Only `string` keeps the value verbatim; the other types ignore surrounding
/// whitespace.
fn try_convert_text_value(param_type: &JsonParamType, value: &str) -> Option<Value> {
match param_type {
JsonParamType::String => Some(Value::String(value.to_string())),
JsonParamType::Integer => value.parse::<i64>().ok().map(Number::from).map(Value::Number),
JsonParamType::Number => try_convert_number(value),
JsonParamType::Integer => without_digit_separators(value.trim())?
.parse::<i64>()
.ok()
.map(Number::from)
.map(Value::Number),
JsonParamType::Number => try_convert_number(&without_digit_separators(value.trim())?),
JsonParamType::Boolean => try_convert_boolean(value),
JsonParamType::Object { .. } if value.is_empty() => Some(Value::Object(Map::new())),
JsonParamType::Array { .. } if value.is_empty() => Some(Value::Array(Vec::new())),
JsonParamType::Object { .. } | JsonParamType::Array { .. } => {
// For composite types with string input, simply interpret the string as JSON.
serde_json::from_str(value).ok()
}
JsonParamType::Object { .. } if value.trim().is_empty() => Some(Value::Object(Map::new())),
JsonParamType::Array { .. } if value.trim().is_empty() => Some(Value::Array(Vec::new())),
// For composite types with string input, interpret the string as JSON of that type.
JsonParamType::Object { .. } => serde_json::from_str(value).ok().filter(Value::is_object),
JsonParamType::Array { .. } => serde_json::from_str(value).ok().filter(Value::is_array),
JsonParamType::Null => is_null_literal(value).then_some(Value::Null),
JsonParamType::OneOf(types) => {
types.iter().find_map(|param_type| try_convert_text_value(param_type, value))
@@ -411,6 +445,22 @@ fn insert_object_value(object: &mut Map<String, Value>, key: String, value: Valu
}
}
/// Remove single underscores between digits (`1_000`), as Python numeric
/// literals allow; any other underscore makes the value invalid.
fn without_digit_separators(value: &str) -> Option<std::borrow::Cow<'_, str>> {
if !value.contains('_') {
return Some(value.into());
}
let bytes = value.as_bytes();
let valid = bytes.iter().enumerate().all(|(index, byte)| {
*byte != b'_'
|| (index > 0
&& bytes[index - 1].is_ascii_digit()
&& bytes.get(index + 1).is_some_and(u8::is_ascii_digit))
});
valid.then(|| value.replace('_', "").into())
}
/// Convert one raw string value to a JSON number.
fn try_convert_number(value: &str) -> Option<Value> {
serde_json::from_str::<Number>(value)
@@ -555,6 +605,83 @@ mod tests {
ParamInput::Elements(elements)
}
#[test]
fn non_string_values_ignore_surrounding_whitespace() {
let params = ToolSchema::from_schema(&json!({
"type": "object",
"properties": {
"text": { "type": "string" },
"count": { "type": "integer" },
"size": { "type": "number" },
"enabled": { "type": "boolean" },
"payload": { "type": "object" },
"items": { "type": "array" }
}
}));
assert_eq!(params.convert("text", text(" 7 ")), json!(" 7 "));
assert_eq!(params.convert("count", text(" 7\n")), json!(7));
assert_eq!(params.convert("size", text("\t2.5 ")), json!(2.5));
assert_eq!(params.convert("enabled", text(" false ")), json!(false));
assert_eq!(params.convert("count", text(" None ")), json!(null));
assert_eq!(params.convert("payload", text(" \n")), json!({}));
assert_eq!(params.convert("items", text(" [1] ")), json!([1]));
}
#[test]
fn numbers_accept_digit_separators() {
let params = ToolSchema::from_schema(&json!({
"type": "object",
"properties": {
"count": { "type": "integer" },
"size": { "type": "number" }
}
}));
assert_eq!(params.convert("count", text("1_000")), json!(1000));
assert_eq!(params.convert("size", text("1_000.5")), json!(1000.5));
for invalid in ["_1", "1_", "1__0", "1_.5"] {
assert_eq!(params.convert("size", text(invalid)), json!(invalid));
}
}
#[test]
fn nullable_schemas_accept_null() {
let params = ToolSchema::from_schema(&json!({
"type": "object",
"properties": {
"text": { "type": "string", "nullable": true },
"count": { "type": ["integer", "string"], "nullable": true }
}
}));
// Without `nullable`, a string parameter keeps the literal text "null".
assert_eq!(params.convert("text", text("null")), json!(null));
assert_eq!(params.convert("text", text("x")), json!("x"));
assert_eq!(params.convert("count", text("None")), json!(null));
assert_eq!(params.convert("count", text("7")), json!(7));
}
#[test]
fn composite_values_must_decode_to_their_type() {
let params = ToolSchema::from_schema(&json!({
"type": "object",
"properties": {
"payload": { "type": "object" },
"items": { "type": "array" },
"either": { "type": ["object", "array"] }
}
}));
assert_eq!(params.convert("payload", text("[1]")), json!("[1]"));
assert_eq!(params.convert("payload", text("5")), json!("5"));
assert_eq!(
params.convert("items", text(r#"{"k":1}"#)),
json!(r#"{"k":1}"#)
);
assert_eq!(params.convert("either", text("[1]")), json!([1]));
}
#[test]
fn converts_upstream_aliases() {
let params = ToolSchema::from_schema(&json!({