Function coerce_value

src/tool_command/args.rs:578–639

Coerce a CLI string value to the JSON type declared in the property schema. Falls back to a JSON string when the schema is absent or specifies an unknown type.

(key: &str, prop_schema: Option<&Value>, raw: &str)

/// Falls back to a JSON string when the schema is absent or specifies an
/// unknown type.
fn coerce_value(key: &str, prop_schema: Option<&Value>, raw: &str) -> Result<Value> {
    let ty = prop_schema
        .and_then(|p| p.get("type"))
        .and_then(Value::as_str)
        .unwrap_or("string");

    match ty {
        "string" => Ok(Value::String(raw.to_string())),
        "boolean" => match raw {
            "true" | "1" | "yes" | "on" => Ok(Value::Bool(true)),
            "false" | "0" | "no" | "off" => Ok(Value::Bool(false)),
            other => {
                let flag = key.replace('_', "-");
                Err(TraceDecayError::Config {
                    message: format!(
                        "--{flag}: expected a boolean (true/false), got `{other}` — \
                         pass `--{flag} true` or `--{flag} false`"
                    ),
                })
            }
        },
        "integer" => raw
            .parse::<i64>()
            .map(Value::from)
            .map_err(|_| TraceDecayError::Config {
                message: format!("--{}: expected integer, got `{raw}`", key.replace('_', "-")),
            }),
        // `serde_json::Number::from_f64(25.0).as_u64()` returns `None`, so MCP
        // handlers that read counts via `.as_u64()` would silently fall back
        // to defaults. Prefer integer storage when the input is whole.
        "number" => {
            if let Ok(i) = raw.parse::<i64>() {
                Ok(Value::from(i))
            } else {
                raw.parse::<f64>()
                    .ok()
                    .and_then(serde_json::Number::from_f64)
                    .map(Value::Number)
                    .ok_or_else(|| TraceDecayError::Config {
                        message: format!(
                            "--{}: expected a finite number, got `{raw}`",
                            key.replace('_', "-")
                        ),
                    })
            }
        }
        // Array/object params accept inline JSON per-key (`--replacements
        // '[["old","new"]]'`, `--project-selector '{"project_id":"x"}'`).
        // Non-JSON strings fall through unchanged: arrays keep the
        // comma-split/repetition behavior via `finalize_arrays`, and objects
        // are caught by `validate_tool_args` with a corrective error.
        "array" | "object" => {
            if let Ok(parsed) = serde_json::from_str::<Value>(raw) {
                if value_matches_type(&parsed, ty) {
                    return Ok(parsed);
                }
            }
            Ok(Value::String(raw.to_string()))