rowan-mcp 1.0.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

rowan_mcp/functions_v2/submit_conformer_search_workflow.py

@@ -0,0 +1,158 @@
+"""
+Rowan v2 API: Conformer Search Workflow
+Search for low-energy molecular conformations using various methods.
+"""
+
+from typing import Any, Dict, Annotated
+import rowan
+import stjames
+
+def submit_conformer_search_workflow(
+    initial_molecule: Annotated[str, "SMILES string representing the initial structure"],
+    conf_gen_mode: Annotated[str, "Conformer generation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)"] = "rapid",
+    final_method: Annotated[str, "Final optimization method (e.g., 'aimnet2_wb97md3', 'r2scan_3c', 'wb97x-d3_def2-tzvp')"] = "aimnet2_wb97md3",
+    solvent: Annotated[str, "Solvent for implicit solvation (SMILES or name). Empty string for vacuum"] = "",
+    transition_state: Annotated[bool, "Whether to search for transition state conformers"] = False,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Conformer Search 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 conformer search workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string representing the initial structure
+        conf_gen_mode: Conformer generation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)
+        final_method: Final optimization method (e.g., 'aimnet2_wb97md3', 'r2scan_3c', 'wb97x-d3_def2-tzvp')
+        solvent: Solvent for implicit solvation (e.g., 'water', 'ethanol', 'dmso'). Empty string for gas phase.
+        transition_state: Whether to search for transition state conformers
+        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.
+    
+    Conformer Generation Modes:
+    - 'rapid': RDKit/MMFF, 300 conformers, 0.10 Å RMSD cutoff (recommended for most work)
+    - 'careful': CREST/GFN-FF quick mode, 150 conformers max
+    - 'meticulous': CREST/GFN2-xTB normal mode, 500 conformers max
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Examples:
+        # Simple diethyl ether conformer search
+        result = submit_conformer_search_workflow(
+            initial_molecule="CCOCC"
+        )
+        
+        # Basic butane conformer search with rapid mode
+        result = submit_conformer_search_workflow(
+            initial_molecule="CCCC",
+            conf_gen_mode="rapid"
+        )
+        
+        # Careful search with solvent
+        result = submit_conformer_search_workflow(
+            initial_molecule="CC(C)CC(=O)O",
+            conf_gen_mode="careful",
+            solvent="water",
+            final_method="r2scan_3c"
+        )
+    """
+
+    try:
+        # Convert initial_molecule to appropriate format
+        if isinstance(initial_molecule, str):
+            # Try to parse as SMILES
+            try:
+                mol = stjames.Molecule.from_smiles(initial_molecule)
+                initial_molecule = mol.model_dump()
+            except Exception:
+                # If fails, pass as dict with smiles
+                initial_molecule = {"smiles": initial_molecule}
+        elif isinstance(initial_molecule, dict):
+            # Already in dict format
+            pass
+        elif hasattr(initial_molecule, 'model_dump'):
+            # StJamesMolecule
+            initial_molecule = initial_molecule.model_dump()
+        else:
+            # Assume RdkitMol or similar
+            try:
+                from rdkit import Chem
+                mol = stjames.Molecule.from_rdkit(initial_molecule, cid=0)
+                initial_molecule = mol.model_dump()
+            except:
+                pass
+        
+        # Convert final_method to Method if it's a string
+        if isinstance(final_method, str):
+            final_method = stjames.Method(final_method)
+        
+        # Determine solvent model based on method
+        solvent_model = None
+        if solvent:
+            solvent_model = "alpb" if final_method in stjames.XTB_METHODS else "cpcm"
+        
+        # Create optimization settings following official API
+        opt_settings = stjames.Settings(
+            method=final_method,
+            tasks=["optimize"],
+            mode=stjames.Mode.AUTO,
+            solvent_settings={"solvent": solvent, "model": solvent_model} if solvent else None,
+            opt_settings={"transition_state": transition_state, "constraints": []},
+        )
+        
+        # Create MultiStageOptSettings
+        msos = stjames.MultiStageOptSettings(
+            mode=stjames.Mode.MANUAL,
+            xtb_preopt=True,
+            optimization_settings=[opt_settings],
+        )
+        
+        # Convert to dict and fix the soscf field
+        msos_dict = msos.model_dump()
+        
+        # Fix soscf: convert boolean to string enum
+        if 'optimization_settings' in msos_dict:
+            for opt_setting in msos_dict['optimization_settings']:
+                if 'scf_settings' in opt_setting and 'soscf' in opt_setting['scf_settings']:
+                    soscf_val = opt_setting['scf_settings']['soscf']
+                    if isinstance(soscf_val, bool):
+                        if soscf_val is False:
+                            opt_setting['scf_settings']['soscf'] = 'never'
+                        elif soscf_val is True:
+                            opt_setting['scf_settings']['soscf'] = 'always'
+                    elif soscf_val is None:
+                        # Default to smart behavior
+                        opt_setting['scf_settings']['soscf'] = 'upon_failure'
+        
+        # Build workflow_data
+        workflow_data = {
+            "multistage_opt_settings": msos_dict,
+            "conf_gen_mode": conf_gen_mode,
+            "mso_mode": "manual",
+            "solvent": solvent if solvent else None,
+            "transition_state": transition_state,
+        }
+        
+        # Build the API request
+        data = {
+            "name": name,
+            "folder_uuid": folder_uuid if folder_uuid else None,
+            "workflow_type": "conformer_search",
+            "workflow_data": workflow_data,
+            "initial_molecule": initial_molecule,
+            "max_credits": max_credits if max_credits > 0 else None,
+        }
+        
+        # Submit to API
+        from rowan.utils import api_client
+        from rowan import Workflow
+        
+        with api_client() as client:
+            response = client.post("/workflow", json=data)
+            response.raise_for_status()
+            return Workflow(**response.json())
+        
+    except Exception as e:
+        # Re-raise the exception so MCP can handle it
+        raise e

rowan_mcp/functions_v2/submit_descriptors_workflow.py

@@ -0,0 +1,52 @@
+"""
+Rowan v2 API: Descriptors Workflow
+Calculate molecular descriptors for QSAR and molecular analysis.
+"""
+
+from typing import Annotated
+import rowan
+import stjames
+
+
+def submit_descriptors_workflow(
+    initial_molecule: Annotated[str, "SMILES string of the molecule to calculate descriptors for"],
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Descriptors 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 molecular descriptors calculation workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string or molecule object for descriptor calculation
+        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 a comprehensive set of molecular descriptors including:
+    - Physical properties (MW, logP, TPSA, etc.)
+    - Electronic properties (HOMO/LUMO, dipole moment, etc.)
+    - Structural features (rotatable bonds, H-bond donors/acceptors, etc.)
+    - Topological indices
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Basic descriptor calculation
+        result = submit_descriptors_workflow(
+            initial_molecule="CC(=O)Nc1ccc(O)cc1"
+        )
+        
+        # For complex molecule
+        result = submit_descriptors_workflow(
+            initial_molecule="CN1C=NC2=C1C(=O)N(C(=O)N2C)C",
+            name="Caffeine Descriptors"
+        )
+    """
+    
+    return rowan.submit_descriptors_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        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_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
+    )