Function extract_comprehensive_function_schema

python/src/workflow/node.rs:567–658

Extract comprehensive function parameter schema using introspection and docstring parsing

(
    func: &Bound<'_, PyAny>,
    py: Python<'_>,
)

/// Extract comprehensive function parameter schema using introspection and docstring parsing
fn extract_comprehensive_function_schema(
    func: &Bound<'_, PyAny>,
    py: Python<'_>,
) -> PyResult<serde_json::Value> {
    let inspect = py.import("inspect")?;
    let signature = inspect.call_method1("signature", (func,))?;
    let parameters = signature.getattr("parameters")?;

    // Extract docstring for parameter descriptions
    let docstring = func
        .getattr("__doc__")
        .and_then(|doc| doc.extract::<Option<String>>())
        .unwrap_or(None)
        .unwrap_or_else(|| String::new());

    let param_descriptions = parse_docstring_parameters(&docstring);

    let mut properties = serde_json::Map::new();
    let mut required = Vec::new();

    // Iterate through function parameters using Python dict iteration
    let param_items = parameters.call_method0("items")?;
    for item in param_items.try_iter()? {
        let item_tuple = item?;
        let param_name = item_tuple.get_item(0)?.extract::<String>()?;
        let param_obj = item_tuple.get_item(1)?;

        // Skip 'self' and 'cls' parameters
        if param_name == "self" || param_name == "cls" {
            continue;
        }

        // Get parameter annotation for type information
        let annotation = param_obj.getattr("annotation")?;
        let param_type =
            if annotation.is_none() || annotation.to_string() == "<class 'inspect._empty'>" {
                "string" // Default type
            } else {
                map_python_type_to_json_schema(&annotation.to_string())
            };

        let mut param_info = serde_json::Map::new();
        param_info.insert(
            "type".to_string(),
            serde_json::Value::String(param_type.to_string()),
        );

        // Add description from docstring if available, otherwise use a default
        let description = param_descriptions
            .get(&param_name)
            .cloned()
            .unwrap_or_else(|| format!("Parameter {}", param_name));
        param_info.insert(
            "description".to_string(),
            serde_json::Value::String(description),
        );

        // Check if parameter has a default value