rowan-mcp 1.0.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

rowan_mcp/functions_v2/submit_docking_workflow.py

@@ -0,0 +1,244 @@
+"""
+Rowan v2 API: Docking Workflow
+Perform molecular docking simulations for drug discovery.
+"""
+
+from typing import Dict, Any, Union, List, Annotated
+import rowan
+import stjames
+import json
+from stjames.pdb import PDB, read_pdb
+
+def submit_docking_workflow(
+    protein: Annotated[str, "Protein UUID or PDB content/path for docking target"],
+    pocket: Annotated[str, "JSON string defining binding pocket coordinates or 'auto' for automatic detection"],
+    initial_molecule: Annotated[str, "SMILES string of the ligand molecule to dock"],
+    do_csearch: Annotated[bool, "Whether to perform conformer search before docking"] = True,
+    do_optimization: Annotated[bool, "Whether to optimize docked poses"] = True,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Docking Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0,
+    blocking: Annotated[bool, "Whether to wait for workflow completion before returning"] = False
+):
+    """Submits a Docking workflow to the API.
+    
+    Args:
+        protein: Protein for docking. Can be: 1) PDB ID string (e.g., '1HCK'), 2) Protein UUID string, 3) JSON string dict with 'pdb_id' and optional 'name'
+        pocket: Binding pocket as JSON string "[[x1,y1,z1], [x2,y2,z2]]" defining box corners for docking site
+        initial_molecule: SMILES string representing the ligand
+        do_csearch: Whether to perform conformational search on the ligand before docking
+        do_optimization: Whether to optimize the ligand geometry before docking
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+        blocking: Whether to wait for workflow completion before returning
+    
+    Automatically handles protein creation from PDB ID and sanitization if needed.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Examples:
+        # Example 1: Using PDB ID directly
+        result = submit_docking_workflow(
+            protein="1HCK",  # PDB ID
+            pocket="[[103.55, 100.59, 82.99], [27.76, 32.67, 48.79]]",
+            initial_molecule="CCC(C)(C)NC1=NCC2(CCC(=O)C2C)N1",
+            name="CDK2 Docking"
+        )
+        
+        # Example 2: Using dict with PDB ID and custom name
+        result = submit_docking_workflow(
+            protein='{"pdb_id": "1HCK", "name": "My CDK2 Protein"}',
+            pocket="[[103.55, 100.59, 82.99], [27.76, 32.67, 48.79]]",
+            initial_molecule="CCC(C)(C)NC1=NCC2(CCC(=O)C2C)N1"
+        )
+        
+        # Example 3: Using existing protein UUID
+        result = submit_docking_workflow(
+            protein="abc123-def456-...",  # Protein UUID
+            pocket="[[103.55, 100.59, 82.99], [27.76, 32.67, 48.79]]",
+            initial_molecule="CCC(C)(C)NC1=NCC2(CCC(=O)C2C)N1"
+        )
+    """
+    import logging
+    logger = logging.getLogger(__name__)
+    
+    # Handle protein parameter
+    protein_obj = None
+    
+    # Try to parse protein as JSON first
+    try:
+        protein_dict = json.loads(protein)
+        if isinstance(protein_dict, dict):
+            protein = protein_dict
+    except (json.JSONDecodeError, ValueError):
+        # Not JSON, keep as string
+        pass
+    
+    # Check if protein is a PDB ID or dict with PDB ID
+    if isinstance(protein, str):
+        # Check if it's a UUID (36 chars with dashes) or PDB ID (4 chars)
+        if len(protein) == 36 and '-' in protein:
+            # It's a UUID, retrieve the protein
+            logger.info(f"Using existing protein UUID: {protein}")
+            protein_obj = rowan.retrieve_protein(protein)
+        elif len(protein) <= 6:  # PDB IDs are typically 4 characters
+            # It's a PDB ID, create protein from it
+            logger.info(f"Creating protein from PDB ID: {protein}")
+            
+            # Get or create a project (REQUIRED for v2.1.1)
+            project_uuid = None
+            try:
+                # Try to get default project
+                project = rowan.default_project()
+                project_uuid = project.uuid
+                logger.info(f"Using default project: {project_uuid}")
+            except Exception as e:
+                logger.info(f"Could not get default project: {e}")
+                try:
+                    # List existing projects and use the first one
+                    projects = rowan.list_projects(size=1)
+                    if projects:
+                        project_uuid = projects[0].uuid
+                        logger.info(f"Using existing project: {project_uuid}")
+                    else:
+                        # Create a new project if none exist
+                        new_project = rowan.create_project(name="Docking Project")
+                        project_uuid = new_project.uuid
+                        logger.info(f"Created new project: {project_uuid}")
+                except Exception as e2:
+                    logger.error(f"Failed to get/create project: {e2}")
+                    raise ValueError(f"Cannot create protein without a valid project. Error: {e2}")
+            
+            # Create protein with REQUIRED project_uuid
+            protein_obj = rowan.create_protein_from_pdb_id(
+                name=f"Protein from {protein}",
+                code=protein,
+                project_uuid=project_uuid
+            )
+            logger.info(f"Created protein with UUID: {protein_obj.uuid}")
+            
+            # Sanitize the protein for docking
+            logger.info("Sanitizing protein for docking...")
+            try:
+                protein_obj.sanitize()
+                
+                # Wait for sanitization to complete
+                import time
+                max_wait = 30
+                start_time = time.time()
+                while time.time() - start_time < max_wait:
+                    time.sleep(2)
+                    protein_obj.refresh()
+                    if protein_obj.sanitized and protein_obj.sanitized != 0:
+                        logger.info(f"Protein sanitized successfully (sanitized={protein_obj.sanitized})")
+                        break
+                else:
+                    logger.warning(f"Sanitization may not be complete after {max_wait} seconds")
+            except Exception as e:
+                logger.warning(f"Sanitization failed: {e}")
+                logger.warning("Proceeding without sanitization - docking may fail if protein needs sanitization")
+        else:
+            raise ValueError(f"Invalid protein parameter: {protein}. Expected PDB ID (4 chars) or UUID (36 chars)")
+            
+    elif isinstance(protein, dict):
+        # Dict with PDB ID and optional name
+        pdb_id = protein.get('pdb_id')
+        protein_name = protein.get('name', f"Protein from {pdb_id}")
+        
+        if not pdb_id:
+            raise ValueError("Dict protein parameter must include 'pdb_id' key")
+            
+        logger.info(f"Creating protein '{protein_name}' from PDB ID: {pdb_id}")
+        
+        # Get or create a project (REQUIRED for v2.1.1)
+        project_uuid = None
+        try:
+            # Try to get default project
+            project = rowan.default_project()
+            project_uuid = project.uuid
+            logger.info(f"Using default project: {project_uuid}")
+        except Exception as e:
+            logger.info(f"Could not get default project: {e}")
+            try:
+                # List existing projects and use the first one
+                projects = rowan.list_projects(size=1)
+                if projects:
+                    project_uuid = projects[0].uuid
+                    logger.info(f"Using existing project: {project_uuid}")
+                else:
+                    # Create a new project if none exist
+                    new_project = rowan.create_project(name="Docking Project")
+                    project_uuid = new_project.uuid
+                    logger.info(f"Created new project: {project_uuid}")
+            except Exception as e2:
+                logger.error(f"Failed to get/create project: {e2}")
+                raise ValueError(f"Cannot create protein without a valid project. Error: {e2}")
+        
+        # Create protein with REQUIRED project_uuid
+        protein_obj = rowan.create_protein_from_pdb_id(
+            name=protein_name,
+            code=pdb_id,
+            project_uuid=project_uuid
+        )
+        logger.info(f"Created protein with UUID: {protein_obj.uuid}")
+        
+        # Sanitize the protein
+        logger.info("Sanitizing protein for docking...")
+        try:
+            protein_obj.sanitize()
+            
+            # Wait for sanitization
+            import time
+            max_wait = 30
+            start_time = time.time()
+            while time.time() - start_time < max_wait:
+                time.sleep(2)
+                protein_obj.refresh()
+                if protein_obj.sanitized and protein_obj.sanitized != 0:
+                    logger.info(f"Protein sanitized successfully (sanitized={protein_obj.sanitized})")
+                    break
+            else:
+                logger.warning(f"Sanitization may not be complete after {max_wait} seconds")
+        except Exception as e:
+            logger.warning(f"Sanitization failed: {e}")
+            logger.warning("Proceeding without sanitization - docking may fail if protein needs sanitization")
+            
+    else:
+        # Assume it's already a protein object
+        protein_obj = protein
+    
+    # Parse pocket parameter (always a string in simplified version)
+    try:
+        pocket = json.loads(pocket)
+    except (json.JSONDecodeError, ValueError) as e:
+        raise ValueError(f"Invalid pocket format: {pocket}. Expected JSON string like \"[[x1,y1,z1], [x2,y2,z2]]\"")
+    
+    # Ensure pocket is a list of lists
+    if not isinstance(pocket, list) or len(pocket) != 2:
+        raise ValueError(f"Pocket must be a list with exactly 2 coordinate lists")
+    
+    # Ensure each element is a list of floats
+    pocket = [list(coord) for coord in pocket]
+    
+    # Submit the workflow
+    logger.info(f"Submitting docking workflow: {name}")
+    workflow = rowan.submit_docking_workflow(
+        protein=protein_obj,
+        pocket=pocket,
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        do_csearch=do_csearch,
+        do_optimization=do_optimization,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )
+    
+    logger.info(f"Docking workflow submitted with UUID: {workflow.uuid}")
+    
+    # If blocking, wait for completion
+    if blocking:
+        workflow.wait_for_result()
+    
+    return workflow

rowan_mcp/functions_v2/submit_fukui_workflow.py

@@ -0,0 +1,114 @@
+"""
+Rowan v2 API: Fukui Workflow
+Calculate Fukui indices for reactivity analysis.
+"""
+
+from typing import Dict, Any, Annotated
+import rowan
+import stjames
+import json
+
+def submit_fukui_workflow(
+    initial_molecule: Annotated[str, "SMILES string of the molecule to calculate Fukui indices for"],
+    optimization_method: Annotated[str, "Method for geometry optimization (e.g., 'gfn2_xtb', 'uma_m_omol')"] = "gfn2_xtb",
+    fukui_method: Annotated[str, "Method for Fukui indices calculation (e.g., 'gfn1_xtb', 'gfn2_xtb')"] = "gfn1_xtb",
+    solvent_settings: Annotated[str, "JSON string for solvent settings. Empty string for vacuum"] = "",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Fukui Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a Fukui indices calculation workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string for Fukui analysis
+        optimization_method: Method for geometry optimization. Options: 'gfn2_xtb', 'r2scan_3c', 'aimnet2_wb97md3'
+        fukui_method: Method for Fukui calculation. Options: 'gfn1_xtb', 'gfn2_xtb'
+        solvent_settings: Solvent configuration JSON string, e.g., '{"solvent": "water", "model": "alpb"}'. Empty for gas phase.
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Calculates Fukui indices to predict molecular reactivity at different sites.
+    Fukui indices indicate susceptibility to nucleophilic/electrophilic attack.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Basic Fukui indices
+        result = submit_fukui_workflow(
+            initial_molecule="CC(=O)O"
+        )
+        
+        # With solvent and advanced methods
+        result = submit_fukui_workflow(
+            initial_molecule="c1ccccc1N",
+            optimization_method="r2scan_3c",
+            fukui_method="gfn2_xtb",
+            solvent_settings='{"solvent": "water", "model": "alpb"}'
+        )
+    """
+    # Parse solvent_settings if provided
+    parsed_solvent_settings = None
+    if solvent_settings:
+        try:
+            parsed_solvent_settings = json.loads(solvent_settings)
+        except (json.JSONDecodeError, ValueError):
+            pass
+    
+    try:
+        # Convert initial_molecule to StJamesMolecule
+        molecule = stjames.Molecule.from_smiles(initial_molecule)
+        initial_molecule_dict = molecule.model_dump()
+        
+        # Create Settings objects
+        optimization_settings = stjames.Settings(method=optimization_method)
+        fukui_settings = stjames.Settings(method=fukui_method, solvent_settings=parsed_solvent_settings)
+        
+        # Serialize to dicts
+        opt_settings_dict = optimization_settings.model_dump(mode="json")
+        fukui_settings_dict = fukui_settings.model_dump(mode="json")
+        
+        # Fix soscf boolean to string enum conversion for optimization settings
+        if 'scf_settings' in opt_settings_dict and 'soscf' in opt_settings_dict['scf_settings']:
+            soscf_val = opt_settings_dict['scf_settings']['soscf']
+            if isinstance(soscf_val, bool):
+                if soscf_val is False:
+                    opt_settings_dict['scf_settings']['soscf'] = 'never'
+                elif soscf_val is True:
+                    opt_settings_dict['scf_settings']['soscf'] = 'always'
+        
+        # Fix soscf boolean to string enum conversion for fukui settings
+        if 'scf_settings' in fukui_settings_dict and 'soscf' in fukui_settings_dict['scf_settings']:
+            soscf_val = fukui_settings_dict['scf_settings']['soscf']
+            if isinstance(soscf_val, bool):
+                if soscf_val is False:
+                    fukui_settings_dict['scf_settings']['soscf'] = 'never'
+                elif soscf_val is True:
+                    fukui_settings_dict['scf_settings']['soscf'] = 'always'
+        
+        workflow_data = {
+            "opt_settings": opt_settings_dict,
+            "opt_engine": stjames.Method(optimization_method).default_engine(),
+            "fukui_settings": fukui_settings_dict,
+            "fukui_engine": stjames.Method(fukui_method).default_engine(),
+        }
+        
+        # Build the API request payload
+        data = {
+            "name": name,
+            "folder_uuid": folder_uuid if folder_uuid else None,
+            "workflow_type": "fukui",
+            "workflow_data": workflow_data,
+            "initial_molecule": initial_molecule_dict,
+            "max_credits": max_credits if max_credits > 0 else None,
+        }
+        
+        # Submit to API
+        with rowan.api_client() as client:
+            response = client.post("/workflow", json=data)
+            response.raise_for_status()
+            return rowan.Workflow(**response.json())
+            
+    except Exception as e:
+        raise e

rowan_mcp/functions_v2/submit_irc_workflow.py

@@ -0,0 +1,58 @@
+"""
+Rowan v2 API: IRC Workflow
+Perform Intrinsic Reaction Coordinate calculations to trace reaction paths.
+"""
+
+from typing import Annotated
+import rowan
+import stjames
+
+def submit_irc_workflow(
+    initial_molecule: Annotated[str, "SMILES string for IRC calculation"],
+    method: Annotated[str, "Computational method for IRC (e.g., 'uma_m_omol', 'gfn2_xtb', 'r2scan_3c')"] = "uma_m_omol",
+    engine: Annotated[str, "Computational engine: 'omol25', 'xtb', 'psi4'"] = "omol25",
+    preopt: Annotated[bool, "Whether to pre-optimize the transition state before IRC step"] = True,
+    step_size: Annotated[float, "Step size for IRC path tracing in Bohr (typically 0.03-0.1)"] = 0.05,
+    max_irc_steps: Annotated[int, "Maximum number of IRC steps in each direction from TS"] = 30,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "IRC Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submits an Intrinsic Reaction Coordinate (IRC) workflow to the API.
+    
+    Args:
+        initial_molecule: SMILES string for IRC calculation
+        method: Computational method for IRC. Options: 'uma_m_omol', 'gfn2_xtb', 'r2scan_3c'
+        engine: Computational engine. Options: 'omol25', 'xtb', 'psi4'
+        preopt: Whether to pre-optimize the transition state before IRC
+        step_size: Step size for IRC path tracing in Bohr (typically 0.03-0.1)
+        max_irc_steps: Maximum number of IRC steps in each direction from TS
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Returns:
+        Workflow object representing the submitted IRC workflow
+        
+    Example:
+        # IRC from SMILES
+        result = submit_irc_workflow(
+            initial_molecule="N=C([O-])[OH2+]",  # Transition state SMILES
+            name="HNCO + H₂O - IRC",
+            preopt=True,  # Pre-optimize TS
+            method="gfn2_xtb",
+            engine="xtb"
+        )
+    """
+    
+    return rowan.submit_irc_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        method=method,
+        engine=engine,
+        preopt=preopt,
+        step_size=step_size,
+        max_irc_steps=max_irc_steps,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )

rowan_mcp/functions_v2/submit_macropka_workflow.py

@@ -0,0 +1,99 @@
+"""
+Rowan v2 API: MacropKa Workflow
+Calculate macroscopic pKa values across a pH range.
+"""
+
+from typing import Annotated
+import rowan
+
+def submit_macropka_workflow(
+    initial_smiles: Annotated[str, "SMILES string of the molecule for macropKa calculation"],
+    min_pH: Annotated[int, "Minimum pH value for the calculation range"] = 0,
+    max_pH: Annotated[int, "Maximum pH value for the calculation range"] = 14,
+    min_charge: Annotated[int, "Minimum molecular charge to consider"] = -2,
+    max_charge: Annotated[int, "Maximum molecular charge to consider"] = 2,
+    compute_solvation_energy: Annotated[bool, "Whether to compute solvation energy corrections"] = True,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Macropka Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a MacropKa workflow using Rowan v2 API.
+    
+    Args:
+        initial_smiles: SMILES string of the molecule for macropKa calculation
+        min_pH: Minimum pH value for the calculation range
+        max_pH: Maximum pH value for the calculation range
+        min_charge: Minimum molecular charge to consider
+        max_charge: Maximum molecular charge to consider
+        compute_solvation_energy: Whether to compute solvation energy for each species
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Calculates macroscopic pKa values across a pH range, determining the
+    protonation states and their populations at different pH values.
+    
+    The workflow will:
+    1. Identify all ionizable sites in the molecule
+    2. Calculate microscopic pKa values for each site
+    3. Determine macroscopic pKa values and species populations
+    4. Optionally compute solvation energies
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Examples:
+        # Simple molecule macropKa
+        result = submit_macropka_workflow(
+            initial_smiles="CC(=O)O",  # Acetic acid
+            min_pH=0,
+            max_pH=14
+        )
+        
+        # Complex molecule with custom charge range
+        result = submit_macropka_workflow(
+            initial_smiles="CC(C)CC(C(=O)O)N",  # Leucine
+            min_pH=0,
+            max_pH=14,
+            min_charge=-3,
+            max_charge=3,
+            compute_solvation_energy=True
+        )
+    """
+    
+    try:
+        # Build workflow_data
+        workflow_data = {
+            "min_pH": min_pH,
+            "max_pH": max_pH,
+            "min_charge": min_charge,
+            "max_charge": max_charge,
+            "compute_solvation_energy": compute_solvation_energy,
+        }
+        
+        # Build the API request
+        data = {
+            "name": name,
+            "folder_uuid": folder_uuid,
+            "workflow_type": "macropka",
+            "workflow_data": workflow_data,
+            "initial_smiles": initial_smiles,
+            "max_credits": max_credits,
+        }
+        
+        # Submit to API using rowan module
+        return rowan.submit_macropka_workflow(
+            initial_smiles=initial_smiles,
+            min_pH=min_pH,
+            max_pH=max_pH,
+            min_charge=min_charge,
+            max_charge=max_charge,
+            compute_solvation_energy=compute_solvation_energy,
+            name=name,
+            folder_uuid=folder_uuid if folder_uuid else None,
+            max_credits=max_credits if max_credits > 0 else None
+        )
+            
+    except Exception as e:
+        # Re-raise the exception so MCP can handle it
+        raise e

rowan_mcp/functions_v2/submit_pka_workflow.py

@@ -0,0 +1,72 @@
+"""
+Rowan v2 API: pKa Workflow
+Predict acid dissociation constants for ionizable groups in molecules.
+"""
+
+from typing import List, Dict, Any, Annotated
+import rowan
+import json
+import stjames
+
+def submit_pka_workflow(
+    initial_molecule: Annotated[str, "SMILES string of the molecule to calculate pKa"],
+    pka_range: Annotated[List[float], "pKa range [min, max] to search (e.g., [2, 12])"] = [2, 12],
+    deprotonate_elements: Annotated[str, "Comma-separated elements for deprotonation (e.g., 'N,O,S'). Empty for auto-detect"] = "",
+    protonate_elements: Annotated[str, "Comma-separated elements for protonation (e.g., 'N,O'). Empty for auto-detect"] = "",
+    mode: Annotated[str, "Calculation mode: 'rapid', 'careful', or 'meticulous'"] = "careful",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "pKa Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a pKa prediction workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: The molecule to calculate the pKa of. SMILES string.
+        pka_range: pKa range [min, max] to search, e.g., [2, 12]
+        deprotonate_elements: Atomic numbers to consider for deprotonation, e.g., "[7, 8, 16]" for N, O, S. Empty string uses defaults.
+        protonate_elements: Atomic numbers to consider for protonation, e.g., "[7, 8]" for N, O. Empty string uses defaults.
+        mode: Calculation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Examples:
+        # Phenol pKa
+        result = submit_pka_workflow(
+            initial_molecule="Oc1ccccc1",
+            name="pKa phenol",
+            deprotonate_elements="[8]"  # Only consider oxygen
+        )
+    """
+    
+    # Handle JSON string inputs for element lists
+    parsed_deprotonate_elements = None
+    if deprotonate_elements:
+        try:
+            parsed_deprotonate_elements = json.loads(deprotonate_elements)
+        except json.JSONDecodeError:
+            pass  # Keep as None if not valid JSON
+            
+    parsed_protonate_elements = None
+    if protonate_elements:
+        try:
+            parsed_protonate_elements = json.loads(protonate_elements)
+        except json.JSONDecodeError:
+            pass  # Keep as None if not valid JSON
+
+    # Convert List[float] to Tuple[float, float] for Rowan SDK compatibility
+    pka_range_tuple = tuple(pka_range) if len(pka_range) == 2 else (pka_range[0], pka_range[1] if len(pka_range) > 1 else pka_range[0])
+    
+    return rowan.submit_pka_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        pka_range=pka_range_tuple,
+        deprotonate_elements=parsed_deprotonate_elements,
+        protonate_elements=parsed_protonate_elements,
+        mode=mode,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )

rowan_mcp/functions_v2/submit_protein_cofolding_workflow.py

@@ -0,0 +1,88 @@
+"""
+Rowan v2 API: Protein Cofolding Workflow
+Simulate protein-protein interactions and cofolding.
+"""
+
+from typing import List, Annotated
+import rowan
+import stjames
+import json
+
+
+def submit_protein_cofolding_workflow(
+    initial_protein_sequences: Annotated[str, "JSON string list of protein sequences for cofolding (e.g., '[\"MKLLV...\", \"MAHQR...\"]')"],
+    initial_smiles_list: Annotated[str, "JSON string list of SMILES for ligands to include in cofolding (e.g., '[\"CCO\", \"CC(=O)O\"]'). Empty for protein-only"] = "",
+    ligand_binding_affinity_index: Annotated[str, "JSON string mapping ligand indices to protein binding sites. Empty for automatic detection"] = "",
+    use_msa_server: Annotated[bool, "Whether to use multiple sequence alignment server for better structure prediction"] = True,
+    use_potentials: Annotated[bool, "Whether to include additional potentials in the calculation"] = False,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Cofolding Workflow",
+    model: Annotated[str, "Structure prediction model to use (e.g., 'boltz_2', 'alphafold3')"] = "boltz_2",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submits a protein cofolding workflow to the API.
+    
+    Args:
+        initial_protein_sequences: JSON string list of protein sequences (amino acid strings) to cofold
+        initial_smiles_list: JSON string list of ligand SMILES strings to include in cofolding. Empty string for protein-only
+        ligand_binding_affinity_index: Index of ligand in initial_smiles_list for binding affinity calculation (e.g., "0"). Empty string skips affinity
+        use_msa_server: Whether to use MSA (Multiple Sequence Alignment) server for improved accuracy
+        use_potentials: Whether to use statistical potentials in the calculation
+        name: Workflow name for identification and tracking
+        model: Cofolding model to use (e.g., 'boltz_2', 'alphafold3')
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Protein-ligand cofolding with CDK2 kinase (from test)
+        result = submit_protein_cofolding_workflow(
+            initial_protein_sequences='["MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVFEFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYTHEVVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSFPKWARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHLRL"]',
+            initial_smiles_list='["CCC(C)(C)NC1=NCC2(CCC(=O)C2C)N1"]',
+            ligand_binding_affinity_index="0",
+            name="Cofolding CDK2 with ligand"
+        )
+    """
+    # Parse initial_protein_sequences (always a string in simplified version)
+    try:
+        initial_protein_sequences = json.loads(initial_protein_sequences)
+    except (json.JSONDecodeError, ValueError):
+        # Try to parse as comma-separated
+        if ',' in initial_protein_sequences:
+            initial_protein_sequences = [s.strip() for s in initial_protein_sequences.split(',') if s.strip()]
+        else:
+            initial_protein_sequences = [initial_protein_sequences.strip()]
+    
+    # Parse initial_smiles_list if provided
+    parsed_initial_smiles_list = None
+    if initial_smiles_list:
+        try:
+            parsed_initial_smiles_list = json.loads(initial_smiles_list)
+        except (json.JSONDecodeError, ValueError):
+            # Try to parse as comma-separated
+            if ',' in initial_smiles_list:
+                parsed_initial_smiles_list = [s.strip() for s in initial_smiles_list.split(',') if s.strip()]
+            else:
+                parsed_initial_smiles_list = [initial_smiles_list.strip()]
+    
+    # Parse ligand_binding_affinity_index if provided
+    parsed_ligand_index = None
+    if ligand_binding_affinity_index:
+        try:
+            parsed_ligand_index = int(ligand_binding_affinity_index)
+        except (ValueError, TypeError):
+            raise ValueError(f"Invalid ligand_binding_affinity_index: '{ligand_binding_affinity_index}' must be an integer")
+    
+    return rowan.submit_protein_cofolding_workflow(
+        initial_protein_sequences=initial_protein_sequences,
+        initial_smiles_list=parsed_initial_smiles_list,
+        ligand_binding_affinity_index=parsed_ligand_index,
+        use_msa_server=use_msa_server,
+        use_potentials=use_potentials,
+        name=name,
+        model=model,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )