Function process_request

tests/format_runtime.rs:94–218

(
    config: &Value,
    path: &str,
    headers: &[(String, String)],
    body: Value,
)

}

pub fn process_request(
    config: &Value,
    path: &str,
    headers: &[(String, String)],
    body: Value,
) -> std::result::Result<RequestPlan, RequestProcessError> {
    let mut plan = RequestPlan {
        source_format: None,
        target_format: None,
        passthrough: false,
        moderation_text: None,
        stream: body.get("stream").and_then(Value::as_bool).unwrap_or(false),
        body,
        path: path.to_string(),
    };

    let transform_cfg = config
        .get("format_transform")
        .and_then(Value::as_object)
        .cloned()
        .unwrap_or_default();
    let transform_enabled = transform_cfg
        .get("enabled")
        .and_then(Value::as_bool)
        .unwrap_or(false);

    if !transform_enabled {
        return Ok(plan);
    }

    let strict_parse = transform_cfg
        .get("strict_parse")
        .and_then(Value::as_bool)
        .unwrap_or(false);
    let disable_tools = transform_cfg
        .get("disable_tools")
        .and_then(Value::as_bool)
        .unwrap_or(false);
    let from_cfg = transform_cfg.get("from");
    let candidates = configured_candidates(from_cfg);
    let detectable = detect_formats_from_candidates(&candidates, path, headers, &plan.body);
    let mut parse_errors = Vec::new();
    let mut parsed = None;

    for source in detectable.iter().copied() {
        match parse_request(source, &plan.body, path) {
            Ok(internal) => {
                parsed = Some((source, internal));
                break;
            }
            Err(error) => parse_errors.push(format!("{}: {error}", source.as_str())),
        }
    }

    if parsed.is_none() {
        if strict_parse {
            let excluded = all_request_formats()
                .into_iter()