Function execute_production_tool_calls

python/src/workflow/node.rs:1119–1286

(
    py: Python<'_>,
    tool_calls_json: String,
    node_tools: Vec<String>,
)

/// Tool execution bridge for workflow integration
#[pyfunction]
pub(crate) fn execute_production_tool_calls(
    py: Python<'_>,
    tool_calls_json: String,
    node_tools: Vec<String>,
) -> PyResult<String> {
    use crate::tools::registry::ToolRegistry;

    // Parse tool calls
    let tool_calls: Vec<serde_json::Value> =
        serde_json::from_str(&tool_calls_json).map_err(|e| {
            PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
                "Failed to parse tool calls JSON: {}",
                e
            ))
        })?;

    // Create a tool registry with available tools
    let registry = ToolRegistry::new();

    // Register tools from the global registry that are available for this node
    TOOL_REGISTRY.with(|global_registry| {
        let global_registry = global_registry.borrow();
        for tool_name in &node_tools {
            if let Some(tool_func) = global_registry.get(tool_name) {
                let params_dict = pyo3::types::PyDict::new(py);
                let _ = registry.register_tool(
                    tool_name.clone(),
                    format!("Tool function: {}", tool_name),
                    tool_func.clone_ref(py),
                    &params_dict,
                    None,
                );
            }
        }
        Ok::<(), PyErr>(())
    })?;

    let mut tool_execution_results = Vec::new();

    // Execute each tool call
    for tool_call in tool_calls.iter() {
        if let (Some(tool_name), Some(parameters)) = (
            tool_call.get("tool_name").and_then(|v| v.as_str()),
            tool_call.get("parameters").and_then(|v| v.as_object()),
        ) {
            // Convert parameters to PyDict
            let params_dict = pyo3::types::PyDict::new(py);
            let mut param_conversion_error = None;

            for (key, value) in parameters {
                match json_to_python_value(value, py) {
                    Ok(py_value) => {
                        if let Err(e) = params_dict.set_item(key, py_value) {
                            param_conversion_error =
                                Some(format!("Failed to set parameter '{}': {}", key, e));
                            break;
                        }
                    }