coala-cli 0.2.1__tar.gz → 0.2.4__tar.gz

coala_cli-0.2.4/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: coala-cli
+Version: 0.2.4
+Summary: Command-line LLM-agent Adapter
+License: MIT
+Author: Qiang
+Requires-Python: >=3.12,<3.15
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: cwltool (>=3.2.20260413085819,<4.0.0)
+Requires-Dist: fastapi (>=0.115.0)
+Requires-Dist: mcp (>=1.12.0,<2.0.0)
+Requires-Dist: pydantic (>=2.10.0,<3.0.0)
+Requires-Dist: requests (>=2.33.0,<3.0.0)
+Requires-Dist: uvicorn (>=0.32.0,<0.33.0)
+Description-Content-Type: text/markdown
+
+# Coala: Command-line LLM-agent Adapter
+
+
+## Introduction
+
+Coala is a standards-based framework for turning command-line tools into reproducible, agent-accessible toolsets that support natural-language interaction.
+
+Coala integrates the [Common Workflow Language (CWL)](https://www.commonwl.org/specification/) with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) to standardize tool execution. This approach allows Large Language Model (LLM) agents to discover and run tools through structured interfaces, while strictly enforcing the containerized environments and deterministic results necessary for reproducible science.
+
+Please find Coala documuentations through [Coala website](https://coala.info/), including [overview](https://coala.info/guide/), [installation](https://coala.info/guide/installation.html), [quick start](https://coala.info/guide/quick-start.html), and [use cases](https://coala.info/use-cases/). 
+
+

coala_cli-0.2.4/README.md

@@ -0,0 +1,11 @@
+# Coala: Command-line LLM-agent Adapter
+
+
+## Introduction
+
+Coala is a standards-based framework for turning command-line tools into reproducible, agent-accessible toolsets that support natural-language interaction.
+
+Coala integrates the [Common Workflow Language (CWL)](https://www.commonwl.org/specification/) with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) to standardize tool execution. This approach allows Large Language Model (LLM) agents to discover and run tools through structured interfaces, while strictly enforcing the containerized environments and deterministic results necessary for reproducible science.
+
+Please find Coala documuentations through [Coala website](https://coala.info/), including [overview](https://coala.info/guide/), [installation](https://coala.info/guide/installation.html), [quick start](https://coala.info/guide/quick-start.html), and [use cases](https://coala.info/use-cases/). 
+

{coala_cli-0.2.1 → coala_cli-0.2.4}/coala/mcp_api.py

@@ -5,7 +5,7 @@ warnings.filterwarnings('ignore', message='.*default.*Field.*')
 warnings.filterwarnings('ignore', message='.*UnsupportedFieldAttributeWarning.*')
 
 from fastapi import FastAPI, UploadFile, File
-from pydantic import create_model, Field
+from pydantic import create_model, Field, ConfigDict
 from pydantic.warnings import UnsupportedFieldAttributeWarning
 import logging
 import uvicorn
@@ -29,6 +29,13 @@ logger.setLevel(logging.INFO)
 # Use stderr for logging to avoid interfering with stdio transport
 logger.addHandler(logging.StreamHandler(sys.stderr))
 
+# ponytail: pydantic forbids these as field names; alias + by_alias keeps CWL ids intact
+_PYDANTIC_RESERVED_FIELDS = frozenset({'model_config'})
+
+
+def _pydantic_field_name(cwl_name: str) -> str:
+    return f'{cwl_name}_' if cwl_name in _PYDANTIC_RESERVED_FIELDS else cwl_name
+
 
 class mcp_api():
     def __init__(self, host='0.0.0.0', port=8000, container_runner=None):
@@ -72,29 +79,69 @@ tool_version: <TOOL_VERSION>
         #         tmp.write(contents)
         #     return {"filename": file.filename, "filepath": tmp.name}
 
+    def _cwl_type_hint(self, type_val):
+        """
+        Render a human-readable type hint from a CWL type value.
+
+        Handles optional unions (list containing 'null'), dict-form arrays
+        ({'type': 'array', 'items': ...}) and string shorthand arrays
+        (e.g. 'float[]'). Returns an empty string when no hint can be
+        determined.
+        """
+        if type_val is None or type_val == '':
+            return ""
+
+        type_list = type_val if isinstance(type_val, list) else [type_val]
+        non_null_types = [t for t in type_list if t != 'null']
+
+        is_array = False
+        base_type = None
+
+        for t in non_null_types:
+            if isinstance(t, dict) and t.get('type') == 'array':
+                is_array = True
+                base_type = t.get('items', 'string')
+                break
+            t_str = str(t)
+            if '[]' in t_str:
+                is_array = True
+                base_type = t_str.replace('[]', '')
+                break
+
+        if base_type is None and non_null_types:
+            base_type = non_null_types[0]
+
+        base_str = str(base_type) if base_type is not None else ''
+
+        if 'Directory' in base_str:
+            base_hint = "directory path"
+        elif 'File' in base_str:
+            base_hint = "file path"
+        elif 'string' in base_str:
+            base_hint = "str"
+        elif 'double' in base_str or 'float' in base_str:
+            base_hint = "float"
+        elif 'int' in base_str:
+            base_hint = "int"
+        elif 'boolean' in base_str:
+            base_hint = "bool"
+        else:
+            base_hint = ""
+
+        if not base_hint:
+            return ""
+
+        return f"array of {base_hint}" if is_array else base_hint
+
     def _build_field_description(self, field_name, input_field, model_field):
         """
         Build field description with type hints.
         """
         doc = input_field.get('doc', '')
-        type_val = input_field.get('type', '')
-        type_list = type_val if isinstance(type_val, list) else [type_val]
-        type_str = ' '.join(str(t) for t in type_list)
-        
-        type_hint = ""
-        if 'File' in type_str:
-            type_hint = "file path"
-        elif 'string' in type_str:
-            type_hint = "str"
-        elif 'double' in type_str or 'float' in type_str:
-            type_hint = "float"
-        elif 'int' in type_str:
-            type_hint = "int"
-        elif 'boolean' in type_str:
-            type_hint = "bool"
-        
+        type_hint = self._cwl_type_hint(input_field.get('type', ''))
+
         annotation = model_field.annotation.__name__ if hasattr(model_field.annotation, '__name__') else str(model_field.annotation)
-        
+
         if type_hint:
             return f"{field_name}: {doc}, {annotation}, {type_hint}"
         else:
@@ -106,22 +153,8 @@ tool_version: <TOOL_VERSION>
         """
         field_name = output_field.get('name', '')
         doc = output_field.get('doc', '')
-        type_val = output_field.get('type', '')
-        type_list = type_val if isinstance(type_val, list) else [type_val]
-        type_str = ' '.join(str(t) for t in type_list)
-        
-        type_hint = ""
-        if 'File' in type_str:
-            type_hint = "file path"
-        elif 'string' in type_str:
-            type_hint = "str"
-        elif 'double' in type_str or 'float' in type_str:
-            type_hint = "float"
-        elif 'int' in type_str:
-            type_hint = "int"
-        elif 'boolean' in type_str:
-            type_hint = "bool"
-        
+        type_hint = self._cwl_type_hint(output_field.get('type', ''))
+
         if type_hint:
             return f"{field_name}: {doc}, {type_hint}"
         else:
@@ -132,6 +165,7 @@ tool_version: <TOOL_VERSION>
         Transform input values based on their expected type.
         
         - For File types: If value is just a filename, try to resolve to full path
+        - For Directory types: If value is a path, try to resolve to an absolute path
         - For string types: If value is a full path, extract just the filename
         - For array types: Transform each element in the array
         
@@ -173,7 +207,7 @@ tool_version: <TOOL_VERSION>
         type_str = str(base_type) if not isinstance(base_type, dict) else base_type.get('type', '')
         
         # Check if it's a File type
-        if 'File' in type_str and isinstance(value, str):
+        if 'File' in type_str and 'Directory' not in type_str and isinstance(value, str):
             # If it's already a file:// URI, return as is
             if value.startswith('file://'):
                 return value
@@ -194,6 +228,23 @@ tool_version: <TOOL_VERSION>
             
             # If not found, return as is (let run_tool handle it)
             return value
+
+        # Check if it's a Directory type
+        if 'Directory' in type_str and isinstance(value, str):
+            if value.startswith('file://'):
+                return value
+
+            if os.path.isabs(value) and os.path.isdir(value):
+                return value
+
+            if os.path.isdir(value):
+                return os.path.abspath(value)
+
+            cwd_path = os.path.join(os.getcwd(), value)
+            if os.path.isdir(cwd_path):
+                return os.path.abspath(cwd_path)
+
+            return value
         
         # Check if it's a string type
         elif 'string' in type_str and isinstance(value, str):
@@ -203,8 +254,12 @@ tool_version: <TOOL_VERSION>
                 dir_path = os.path.dirname(value)
                 # Only extract filename if the directory exists
                 if dir_path and os.path.isdir(dir_path):
-                    # Extract filename from path
-                    filename = os.path.basename(value)
+                    # Trailing slashes make os.path.basename return "" — normalize first.
+                    seps = os.path.sep + (os.path.altsep or "")
+                    trimmed = value.rstrip(seps)
+                    filename = os.path.basename(trimmed) if trimmed else value
+                    if not filename:
+                        return value
                     logger.info(f"Transformed string input '{field_name}': '{value}' -> '{filename}'")
                     return filename
                 # If directory doesn't exist, keep the full path as is
@@ -286,15 +341,26 @@ tool_version: <TOOL_VERSION>
                 items_type = raw_type.get('items', 'string')
                 base_type_str = str(items_type) if not isinstance(items_type, dict) else items_type.get('type', 'string')
             elif non_null_types:
-                # Check for array notation in string (e.g., 'float[]')
-                # Look through non-null types for array notation
+                # Look through non-null types for array notation.
+                # An array can appear either as dict form
+                # ({'type': 'array', 'items': <items_type>}) or as string shorthand
+                # with '[]' suffix (e.g. 'float[]').
                 for t in non_null_types:
+                    if isinstance(t, dict) and t.get('type') == 'array':
+                        is_array = True
+                        items_type = t.get('items', 'string')
+                        base_type_str = (
+                            str(items_type)
+                            if not isinstance(items_type, dict)
+                            else items_type.get('type', 'string')
+                        )
+                        break
                     t_str = str(t)
                     if '[]' in t_str:
                         is_array = True
                         base_type_str = t_str.replace('[]', '')
                         break
-                
+
                 if not is_array and non_null_types:
                     # Not an array, use the first non-null type
                     base_type_str = str(non_null_types[0])
@@ -306,7 +372,7 @@ tool_version: <TOOL_VERSION>
             field_doc = it.get('doc', '')
             
             # Determine base Python type
-            if 'File' in base_type_str:
+            if 'File' in base_type_str or 'Directory' in base_type_str:
                 base_py_type = str
             elif 'string' in base_type_str:
                 base_py_type = str
@@ -328,17 +394,35 @@ tool_version: <TOOL_VERSION>
             # Create Field with description
             # For optional fields, use (Optional[type], None) - Field() can't be used with Union types
             # For required fields, use Field directly
-            if is_optional:
+            # Reserved pydantic names (e.g. model_config) get a trailing _ and an alias
+            cwl_name = it['name']
+            field_name = _pydantic_field_name(cwl_name)
+            if field_name != cwl_name:
+                if is_optional:
+                    it_map[field_name] = (
+                        Optional[py_type],
+                        Field(default=None, alias=cwl_name, description=field_doc),
+                    )
+                else:
+                    it_map[field_name] = (py_type, Field(alias=cwl_name, description=field_doc))
+            elif is_optional:
                 # Use Optional type with None as default
                 # Note: We can't use Field() with Optional/Union types, so description will be set via field_doc in fields_desc
-                it_map[it['name']] = (Optional[py_type], None)
+                it_map[field_name] = (Optional[py_type], None)
             else:
-                it_map[it['name']] = (py_type, Field(description=field_doc))
+                it_map[field_name] = (py_type, Field(description=field_doc))
 
-        Base = create_model(f'Base_{tool_name}', **it_map)
+        create_kwargs = {}
+        if any(n in _PYDANTIC_RESERVED_FIELDS for n in inputs_by_name):
+            create_kwargs['__config__'] = ConfigDict(populate_by_name=True)
+        Base = create_model(f'Base_{tool_name}', **create_kwargs, **it_map)
 
         fields_desc = "\n\n".join(
-            self._build_field_description(k, inputs_by_name[k], v)
+            self._build_field_description(
+                (v.alias or k),
+                inputs_by_name[v.alias or k],
+                v,
+            )
             for k, v in Base.model_fields.items()
         )
 
@@ -384,7 +468,8 @@ tool_version: <TOOL_VERSION>
             {fields_desc}
             """
             logger.info(data)
-            params = data[0].model_dump()
+            # by_alias=True restores CWL input ids when pydantic reserved names were aliased
+            params = data[0].model_dump(by_alias=True)
             
             # Transform input values based on their types
             # Create a mapping from field name to input type

{coala_cli-0.2.1 → coala_cli-0.2.4}/coala/remote_api.py

@@ -1,5 +1,5 @@
 from fastapi import FastAPI, UploadFile, Body
-from pydantic import create_model
+from pydantic import create_model, Field, ConfigDict
 import logging
 import uvicorn
 from tempfile import NamedTemporaryFile, mkdtemp
@@ -15,6 +15,13 @@ logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 logger.addHandler(logging.StreamHandler())
 
+# ponytail: pydantic forbids these as field names; alias + by_alias keeps CWL ids intact
+_PYDANTIC_RESERVED_FIELDS = frozenset({'model_config'})
+
+
+def _pydantic_field_name(cwl_name: str) -> str:
+    return f'{cwl_name}_' if cwl_name in _PYDANTIC_RESERVED_FIELDS else cwl_name
+
 
 class tool_api():
     def __init__(self, cwl_file, tool_name='tool', host='0.0.0.0', port=8000, read_outs=False):
@@ -53,25 +60,34 @@ class tool_api():
             # it['type'] can be a list like ['null', 'org.w3id.cwl.cwl.File']
             type_list = it['type'] if isinstance(it['type'], list) else [it['type']]
             type_str = ' '.join(str(t) for t in type_list)  # Join for checking substrings
-            
+            cwl_name = it['name']
+            field_name = _pydantic_field_name(cwl_name)
+
             if 'File' in type_str:
-                it_map[it['name']] = (str, None)
+                py_type, default = str, None
             elif 'string' in type_str:
-                it_map[it['name']] = (str, None)
+                py_type, default = str, None
             elif 'double' in type_str:
-                it_map[it['name']] = (float, None)
+                py_type, default = float, None
             elif 'int' in type_str:
-                it_map[it['name']] = (int, None)
+                py_type, default = int, None
             elif 'boolean' in type_str:
-                it_map[it['name']] = (bool, None)
+                py_type, default = bool, None
             else:
-                it_map[it['name']] = (str, None)
+                py_type, default = str, None
 
             if 'null' in type_list:
-                type, v = it_map[it['name']]
-                it_map[it['name']] = (Optional[type], v)
-    
-        self.Base = create_model('Base', **it_map)
+                py_type = Optional[py_type]
+
+            if field_name != cwl_name:
+                it_map[field_name] = (py_type, Field(default=default, alias=cwl_name))
+            else:
+                it_map[field_name] = (py_type, default)
+
+        create_kwargs = {}
+        if any(it['name'] in _PYDANTIC_RESERVED_FIELDS for it in self.inputs):
+            create_kwargs['__config__'] = ConfigDict(populate_by_name=True)
+        self.Base = create_model('Base', **create_kwargs, **it_map)
 
         # define tool
         # fastapi
@@ -87,7 +103,7 @@ class tool_api():
         @self.app.post(f"/{self.tool_name}/")  
         def tool(data: List[self.Base] = Body(...)):
             logger.info(data)
-            params = data[0].model_dump()
+            params = data[0].model_dump(by_alias=True)
             outs = run_tool(self.tool, params, self.outputs, self.read_outs)
             logger.info(outs)
             return outs

coala_cli-0.2.4/coala/tool_logic.py

@@ -0,0 +1,222 @@
+# coala/tool_logic.py
+import os
+import os.path
+import gzip
+from pathlib import Path
+from urllib.parse import urlparse, unquote
+from urllib.request import url2pathname
+from cwltool.context import RuntimeContext
+
+
+def _canonical_file_uri(uri: str) -> str:
+    """Decode file:// to a local path, resolve it, return canonical file:// URI."""
+    parsed = urlparse(uri)
+    if parsed.scheme != "file":
+        raise ValueError("expected file URI")
+    path_part = unquote(parsed.path or "")
+    if os.name == "nt":
+        local = url2pathname(path_part)
+    else:
+        local = path_part
+    return Path(local).resolve().as_uri()
+
+
+def _local_path_to_file_uri(path: str) -> str:
+    """Build a file:// URI from a bare or relative local path (resolved)."""
+    p = Path(path).expanduser()
+    if not p.is_absolute():
+        p = Path(os.getcwd()) / p
+    return p.resolve().as_uri()
+
+
+def _remote_uri_string(s: str) -> bool:
+    """True if s is a non-file URI (http(s), ftp, s3, …) — CWL string, not File."""
+    if s.startswith(("http://", "https://", "ftp://")):
+        return True
+    return "://" in s and not s.startswith("file://")
+
+
+def configure_container_runner(runtime_context: RuntimeContext, container_runner: str) -> None:
+    """
+    Configure the runtime context with the specified container runner.
+
+    Parameters:
+        runtime_context: The RuntimeContext to configure
+        container_runner: 'docker', 'podman', 'singularity', 'udocker', or 'xcrunner'
+    """
+    runtime_context.default_container = container_runner
+    runtime_context.singularity = (container_runner == 'singularity')
+    runtime_context.podman = (container_runner == 'podman')
+    if container_runner == 'xcrunner':
+        import shutil
+        # xcrunner = xcodon-runtime; its command is `xcrunner` (the `xcodon` command is the agent).
+        import os, sys
+        beside_python = os.path.join(os.path.dirname(sys.executable), 'xcrunner')
+        runtime_context.user_space_docker_cmd = (
+            (beside_python if os.access(beside_python, os.X_OK) else None)
+            or shutil.which('xcrunner') or 'xcrunner'
+        )
+
+def _read_file_content(filepath):
+    """Read file content, handling gzipped files."""
+    try:
+        if filepath.endswith('.gz'):
+            with gzip.open(filepath, 'rt', encoding='utf-8') as f:
+                return f.read().replace('\n', '')
+        else:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                return f.read().replace('\n', '')
+    except (UnicodeDecodeError, OSError):
+        # If reading fails (binary file, etc.), return the filepath instead
+        return filepath
+
+def run_tool(tool, params, outputs, read_outs=False, container_runner=None):
+    """
+    Execute a CWL tool with the given parameters.
+    
+    Parameters:
+        tool: The CWL tool object (created via factory.Factory().make())
+        params: Dictionary of input parameters
+        outputs: List of output field definitions
+        read_outs: Whether to read output file contents (default: False)
+        container_runner: Container runtime to use (default: None, uses tool's default)
+                         Valid values: 'docker', 'podman', 'singularity', 'udocker', etc.
+    
+    Returns:
+        Dictionary mapping output field names to their values
+    """
+    # Prepare params for CWL tool
+    inputs = tool.t.inputs_record_schema['fields']
+    in_dict = {}
+    for i in inputs:
+        in_dict[i['name']] = i['type']
+
+    def path_to_file_obj(path_or_file):
+        """Local paths and file:// become CWL File; remote URIs stay plain strings."""
+        if path_or_file is None:
+            return None
+        if isinstance(path_or_file, dict):
+            loc = path_or_file.get("location")
+            if isinstance(loc, str):
+                if _remote_uri_string(loc):
+                    return loc
+                if loc.startswith("file://"):
+                    return {"class": "File", "location": _canonical_file_uri(loc)}
+                return {"class": "File", "location": _local_path_to_file_uri(loc)}
+            return path_or_file
+        if isinstance(path_or_file, str):
+            if _remote_uri_string(path_or_file):
+                return path_or_file
+            if path_or_file.startswith("file://"):
+                return {"class": "File", "location": _canonical_file_uri(path_or_file)}
+            return {"class": "File", "location": _local_path_to_file_uri(path_or_file)}
+        return None
+
+    def path_to_directory_obj(path_or_dir):
+        """Local paths and file:// become CWL Directory; remote URIs stay plain strings."""
+        if path_or_dir is None:
+            return None
+        if isinstance(path_or_dir, dict):
+            loc = path_or_dir.get("location")
+            if isinstance(loc, str):
+                if _remote_uri_string(loc):
+                    return loc
+                if loc.startswith("file://"):
+                    return {"class": "Directory", "location": _canonical_file_uri(loc)}
+                return {"class": "Directory", "location": _local_path_to_file_uri(loc)}
+            return path_or_dir
+        if isinstance(path_or_dir, str):
+            if _remote_uri_string(path_or_dir):
+                return path_or_dir
+            if path_or_dir.startswith("file://"):
+                return {"class": "Directory", "location": _canonical_file_uri(path_or_dir)}
+            return {"class": "Directory", "location": _local_path_to_file_uri(path_or_dir)}
+        return None
+
+    def _is_path_array_type(typ, path_kind):
+        """True if typ is array of File or Directory (dict-like or in a union list)."""
+        if hasattr(typ, 'get') and typ.get('type') == 'array':
+            items = typ.get('items', '')
+            return path_kind in str(items)
+        if isinstance(typ, list):
+            for t in typ:
+                if t == 'null':
+                    continue
+                if hasattr(t, 'get') and t.get('type') == 'array':
+                    if path_kind in str(t.get('items', '')):
+                        return True
+            return False
+        return False
+
+    def _is_single_path_type(typ, path_kind):
+        """True if typ is single File or Directory (not array)."""
+        if hasattr(typ, 'get') and typ.get('type') == 'array':
+            return False
+        if isinstance(typ, list):
+            for t in typ:
+                if t != 'null' and hasattr(t, 'get') and t.get('type') == 'array':
+                    return False
+            return path_kind in ' '.join(str(t) for t in typ)
+        return path_kind in str(typ) and '[]' not in str(typ)
+
+    path_converters = {
+        'File': path_to_file_obj,
+        'Directory': path_to_directory_obj,
+    }
+
+    for k, v in params.items():
+        if k not in in_dict or v is None:
+            continue
+        type_val = in_dict[k]
+        type_str = ' '.join(str(t) for t in type_val) if isinstance(type_val, list) else str(type_val)
+        for path_kind, converter in path_converters.items():
+            if path_kind not in type_str:
+                continue
+            is_path_array = _is_path_array_type(type_val, path_kind)
+            if is_path_array and isinstance(v, list):
+                converted = [converter(item) for item in v]
+                if all(x is not None for x in converted):
+                    params[k] = converted
+            elif _is_single_path_type(type_val, path_kind):
+                to_convert = v[0] if isinstance(v, list) and len(v) > 0 else v
+                path_obj = converter(to_convert)
+                if path_obj is not None:
+                    params[k] = path_obj
+            break
+    
+    # Modify the tool's runtime context if container runner is specified
+    if container_runner:
+        # Try to get the original runtime context from the tool
+        original_runtime_context = None
+        if hasattr(tool, 'runtime_context'):
+            original_runtime_context = tool.runtime_context
+        elif hasattr(tool, 't') and hasattr(tool.t, 'runtime_context'):
+            original_runtime_context = tool.t.runtime_context
+        
+        # If we found the runtime context, modify it in place
+        if original_runtime_context:
+            configure_container_runner(original_runtime_context, container_runner)
+    
+    # Execute tool (no need to pass runtime_context if we modified it in place)
+    res = tool(**params)
+    outs = {}
+    for ot in outputs:
+        out_content = res[ot['name']]
+        # Handle both list and string types (e.g., ['null', 'File'] or 'File?')
+        # Convert each item to str to handle CommentedMap from ruamel.yaml (enum types)
+        type_val = ot['type']
+        type_str = ' '.join(str(t) for t in type_val) if isinstance(type_val, list) else str(type_val)
+        if read_outs and 'File' in type_str:
+            # Handle both single File and File[] (array) outputs
+            file_result = res[ot['name']]
+            if isinstance(file_result, list):
+                # File[] - read first file
+                if len(file_result) > 0:
+                    out_file = file_result[0]['location'].replace('file://', '')
+                    out_content = _read_file_content(out_file)
+            else:
+                # Single File
+                out_file = file_result['location'].replace('file://', '')
+                out_content = _read_file_content(out_file)
+        outs[ot['name']] = out_content
+    return outs 

{coala_cli-0.2.1 → coala_cli-0.2.4}/pyproject.toml

@@ -1,20 +1,20 @@
 [tool.poetry]
 name = "coala-cli"
-version = "0.2.1"
-description = "Convert any CMD tool into a LLM agent"
+version = "0.2.4"
+description = "Command-line LLM-agent Adapter"
 authors = ["Qiang"]
 license = "MIT"
 readme = "README.md"
 packages = [{ include = "coala" }]
 
 [tool.poetry.dependencies]
-python = ">=3.12,<3.14"
-fastapi = ">=0.114.0"
-requests = "^2.32.3"
-pydantic = "^2.9.2"
-uvicorn = "^0.30.6"
-cwltool = "^3.1.20240909164951"
-mcp = "^1.9.0"
+python = ">=3.12,<3.15"
+fastapi = ">=0.115.0"
+requests = "^2.33.0"
+pydantic = "^2.10.0"
+uvicorn = "^0.32.0"
+cwltool = "^3.2.20260413085819"
+mcp = "^1.12.0"
 
 
 [build-system]

coala_cli-0.2.1/PKG-INFO

@@ -1,158 +0,0 @@
-Metadata-Version: 2.4
-Name: coala-cli
-Version: 0.2.1
-Summary: Convert any CMD tool into a LLM agent
-License: MIT
-Author: Qiang
-Requires-Python: >=3.12,<3.14
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: cwltool (>=3.1.20240909164951,<4.0.0)
-Requires-Dist: fastapi (>=0.114.0)
-Requires-Dist: mcp (>=1.9.0,<2.0.0)
-Requires-Dist: pydantic (>=2.9.2,<3.0.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: uvicorn (>=0.30.6,<0.31.0)
-Description-Content-Type: text/markdown
-
-# coala-cli
-======================
-
-## Overview
-
-Coala, implemented as a Python package, is a standards-based framework for turning command-line tools into reproducible, agent-accessible toolsets that support natural-language interaction.
-
-## How the Framework Works
-
-Coala integrates the [Common Workflow Language (CWL)](https://www.commonwl.org/specification/) with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) to standardize tool execution. This approach allows Large Language Model (LLM) agents to discover and run tools through structured interfaces, while strictly enforcing the containerized environments and deterministic results necessary for reproducible science.
-
-### Core Components
-- **Client Layer:** Any MCP-compliant client application (e.g., Claude Desktop, Cursor, or custom interfaces) that utilizes LLMs (such as Gemini, GPT-5, or Claude) to enable natural language interaction.
-- **Bridge Layer:** A local, generic MCP server that acts as a schema translator. Unlike standard MCP servers that require custom Python wrappers for each tool, the bridge layer automatically parses CWL definitions and exposes the CWL-described command-line tools as executable MCP utilities.
-- **Execution Layer:** A standard CWL runner that executes the underlying binaries within containerized environments (Docker). This ensures that analyses are reproducible and isolated from the host system's dependencies.
-
-### Quick Start
-
-1. **Initialize:** Create a local MCP server instance using `mcp_api()`.
-2. **Register:** Load your domain-specific tools described in CWL via `add_tool()` (supports local files or repositories).
-3. **Serve:** Start the MCP server using `mcp.serve()`.
- 
-### The Workflow
-
-- **Interact:** The user sends a natural language query to the MCP Client (e.g., Claude Desktop).
-- **Discover & Select:** The Client retrieves the tool list from the MCP server. The LLM selects the appropriate tool and sends a structured request for the analysis.
-- **Execute:** Coala translates this selection into a CWL job and executes it within a container (Docker), ensuring reproducibility.
-- **Respond:** The execution logs and results are returned to the LLM, which interprets them and presents the final answer to the user.
-
-## Get Started
-
-### Requirements
-
-* Python 3.12 or later
-* FastAPI
-* Requests
-* Pydantic
-* Uvicorn
-* cwltool
-* mcp (Model Context Protocol SDK)
-
-### Installation
-
-To install coala-cli, run the following command:
-```bash
-pip install coala-cli
-```
-
-### Use Cases
-
-
-<!-- This text is a hidden note and will not be displayed in the rendered README.
-
-### MCP server
-
-The framework allows you to set up an MCP server with predefined tools for specific domains. For example, to create a bioinformatics-focused MCP server, you can use the following setup (as shown in [`examples/bioinfo_question.py`](examples/bioinfo_question.py)):
-
-```python
-from cmdagent.mcp_api import mcp_api
-
-mcp = mcp_api(host='0.0.0.0', port=8000)
-mcp.add_tool('examples/ncbi_datasets_gene.cwl', 'ncbi_datasets_gene')
-mcp.add_tool('examples/bcftools_view.cwl', 'bcftools_view', read_outs=False)
-mcp.serve()
-```
-
-This creates an MCP server that exposes two bioinformatics tools:
-- `ncbi_datasets_gene`: Retrieves gene metadata from NCBI datasets
-- `bcftools_view`: Subsets and filters VCF/BCF files
-
-Once the server is running, you can configure your MCP client (e.g., in Cursor) to connect to it:
-
-```json
-{
-    "mcpServers": {
-        "cmdagent": {
-            "url": "http://localhost:8000/mcp",
-            "transport": "streamable-http"
-        }
-    }
-}
-```
-
-With this setup, you can ask the LLM natural language questions like:
-- "Give me a summary about gene BRCA1"
-- "Subset variants in the gene BRCA1 from the https://ftp.ncbi.nlm.nih.gov/pub/clinvar/vcf_GRCh38/clinvar.vcf.gz"
-
-The LLM will automatically discover the available tools, understand their parameters, invoke the appropriate tool with the correct arguments, and present the results in a user-friendly format.
-
-* Start MCP server
-```
-python examples/bioinfo_question.py
-```
-
-* Call by MCP client from Cursor
-[![Demo md5](tests/cmdagent.gif)](https://www.youtube.com/watch?v=QqevFmQbTDU)
-
-
-### Function call
-* Creating an API
-
-To create an API, import the `tool_api` function from `cmdagent.remote_api` and pass in the path to a CWL file and the name of the tool:
-```python
-from cmdagent.remote_api import tool_api
-
-api = tool_api(cwl_file='tests/dockstore-tool-md5sum.cwl', tool_name='md5sum')
-api.serve()
-```
-The `api.serve()` method will start a RESTful API as a service, allowing you to run the tool remotely from the cloud or locally.
-
-* Creating a Tool Agent
-
-To create a tool agent, import the `cmdagent` function from `cmdagent.agent` and pass in the API instance:
-```python
-from cmdagent.agent import tool_agent
-
-ta = tool_agent(api)
-md5 = ta.create_tool()
-md5(input_file="tests/dockstore-tool-md5sum.cwl")
-```
-Function `md5` is created automatically based on the `api`.
-
-* Function call with Gemini
-
-To integrate the tool agent with Gemini, import the `GenerativeModel` class from `google.generativeai` and create a new instance:
-```python
-import google.generativeai as genai
-
-genai.configure(api_key="******")
-model = genai.GenerativeModel(model_name='gemini-1.5-flash', tools=[md5])
-
-chat = model.start_chat(enable_automatic_function_calling=True)
-response = chat.send_message("what is md5 of tests/dockstore-tool-md5sum.cwl?")
-response.text
-```
-```
-'The md5sum of tests/dockstore-tool-md5sum.cwl is ad59d9e9ed6344f5c20ee7e0143c6c12. \n'
-```
--->

coala_cli-0.2.1/README.md

@@ -1,139 +0,0 @@
-# coala-cli
-======================
-
-## Overview
-
-Coala, implemented as a Python package, is a standards-based framework for turning command-line tools into reproducible, agent-accessible toolsets that support natural-language interaction.
-
-## How the Framework Works
-
-Coala integrates the [Common Workflow Language (CWL)](https://www.commonwl.org/specification/) with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) to standardize tool execution. This approach allows Large Language Model (LLM) agents to discover and run tools through structured interfaces, while strictly enforcing the containerized environments and deterministic results necessary for reproducible science.
-
-### Core Components
-- **Client Layer:** Any MCP-compliant client application (e.g., Claude Desktop, Cursor, or custom interfaces) that utilizes LLMs (such as Gemini, GPT-5, or Claude) to enable natural language interaction.
-- **Bridge Layer:** A local, generic MCP server that acts as a schema translator. Unlike standard MCP servers that require custom Python wrappers for each tool, the bridge layer automatically parses CWL definitions and exposes the CWL-described command-line tools as executable MCP utilities.
-- **Execution Layer:** A standard CWL runner that executes the underlying binaries within containerized environments (Docker). This ensures that analyses are reproducible and isolated from the host system's dependencies.
-
-### Quick Start
-
-1. **Initialize:** Create a local MCP server instance using `mcp_api()`.
-2. **Register:** Load your domain-specific tools described in CWL via `add_tool()` (supports local files or repositories).
-3. **Serve:** Start the MCP server using `mcp.serve()`.
- 
-### The Workflow
-
-- **Interact:** The user sends a natural language query to the MCP Client (e.g., Claude Desktop).
-- **Discover & Select:** The Client retrieves the tool list from the MCP server. The LLM selects the appropriate tool and sends a structured request for the analysis.
-- **Execute:** Coala translates this selection into a CWL job and executes it within a container (Docker), ensuring reproducibility.
-- **Respond:** The execution logs and results are returned to the LLM, which interprets them and presents the final answer to the user.
-
-## Get Started
-
-### Requirements
-
-* Python 3.12 or later
-* FastAPI
-* Requests
-* Pydantic
-* Uvicorn
-* cwltool
-* mcp (Model Context Protocol SDK)
-
-### Installation
-
-To install coala-cli, run the following command:
-```bash
-pip install coala-cli
-```
-
-### Use Cases
-
-
-<!-- This text is a hidden note and will not be displayed in the rendered README.
-
-### MCP server
-
-The framework allows you to set up an MCP server with predefined tools for specific domains. For example, to create a bioinformatics-focused MCP server, you can use the following setup (as shown in [`examples/bioinfo_question.py`](examples/bioinfo_question.py)):
-
-```python
-from cmdagent.mcp_api import mcp_api
-
-mcp = mcp_api(host='0.0.0.0', port=8000)
-mcp.add_tool('examples/ncbi_datasets_gene.cwl', 'ncbi_datasets_gene')
-mcp.add_tool('examples/bcftools_view.cwl', 'bcftools_view', read_outs=False)
-mcp.serve()
-```
-
-This creates an MCP server that exposes two bioinformatics tools:
-- `ncbi_datasets_gene`: Retrieves gene metadata from NCBI datasets
-- `bcftools_view`: Subsets and filters VCF/BCF files
-
-Once the server is running, you can configure your MCP client (e.g., in Cursor) to connect to it:
-
-```json
-{
-    "mcpServers": {
-        "cmdagent": {
-            "url": "http://localhost:8000/mcp",
-            "transport": "streamable-http"
-        }
-    }
-}
-```
-
-With this setup, you can ask the LLM natural language questions like:
-- "Give me a summary about gene BRCA1"
-- "Subset variants in the gene BRCA1 from the https://ftp.ncbi.nlm.nih.gov/pub/clinvar/vcf_GRCh38/clinvar.vcf.gz"
-
-The LLM will automatically discover the available tools, understand their parameters, invoke the appropriate tool with the correct arguments, and present the results in a user-friendly format.
-
-* Start MCP server
-```
-python examples/bioinfo_question.py
-```
-
-* Call by MCP client from Cursor
-[![Demo md5](tests/cmdagent.gif)](https://www.youtube.com/watch?v=QqevFmQbTDU)
-
-
-### Function call
-* Creating an API
-
-To create an API, import the `tool_api` function from `cmdagent.remote_api` and pass in the path to a CWL file and the name of the tool:
-```python
-from cmdagent.remote_api import tool_api
-
-api = tool_api(cwl_file='tests/dockstore-tool-md5sum.cwl', tool_name='md5sum')
-api.serve()
-```
-The `api.serve()` method will start a RESTful API as a service, allowing you to run the tool remotely from the cloud or locally.
-
-* Creating a Tool Agent
-
-To create a tool agent, import the `cmdagent` function from `cmdagent.agent` and pass in the API instance:
-```python
-from cmdagent.agent import tool_agent
-
-ta = tool_agent(api)
-md5 = ta.create_tool()
-md5(input_file="tests/dockstore-tool-md5sum.cwl")
-```
-Function `md5` is created automatically based on the `api`.
-
-* Function call with Gemini
-
-To integrate the tool agent with Gemini, import the `GenerativeModel` class from `google.generativeai` and create a new instance:
-```python
-import google.generativeai as genai
-
-genai.configure(api_key="******")
-model = genai.GenerativeModel(model_name='gemini-1.5-flash', tools=[md5])
-
-chat = model.start_chat(enable_automatic_function_calling=True)
-response = chat.send_message("what is md5 of tests/dockstore-tool-md5sum.cwl?")
-response.text
-```
-```
-'The md5sum of tests/dockstore-tool-md5sum.cwl is ad59d9e9ed6344f5c20ee7e0143c6c12. \n'
-```
--->

coala_cli-0.2.1/coala/tool_logic.py

@@ -1,109 +0,0 @@
-# coala/tool_logic.py
-import os.path
-import gzip
-from cwltool.context import RuntimeContext
-
-def configure_container_runner(runtime_context: RuntimeContext, container_runner: str) -> None:
-    """
-    Configure the runtime context with the specified container runner.
-    
-    Parameters:
-        runtime_context: The RuntimeContext to configure
-        container_runner: Container runtime to use ('docker', 'podman', 'singularity', 'udocker', etc.)
-    """
-    runtime_context.default_container = container_runner
-    # Set boolean flags for specific container runners
-    runtime_context.singularity = (container_runner == 'singularity')
-    runtime_context.podman = (container_runner == 'podman')
-
-def _read_file_content(filepath):
-    """Read file content, handling gzipped files."""
-    try:
-        if filepath.endswith('.gz'):
-            with gzip.open(filepath, 'rt', encoding='utf-8') as f:
-                return f.read().replace('\n', '')
-        else:
-            with open(filepath, 'r', encoding='utf-8') as f:
-                return f.read().replace('\n', '')
-    except (UnicodeDecodeError, OSError):
-        # If reading fails (binary file, etc.), return the filepath instead
-        return filepath
-
-def run_tool(tool, params, outputs, read_outs=False, container_runner=None):
-    """
-    Execute a CWL tool with the given parameters.
-    
-    Parameters:
-        tool: The CWL tool object (created via factory.Factory().make())
-        params: Dictionary of input parameters
-        outputs: List of output field definitions
-        read_outs: Whether to read output file contents (default: False)
-        container_runner: Container runtime to use (default: None, uses tool's default)
-                         Valid values: 'docker', 'podman', 'singularity', 'udocker', etc.
-    
-    Returns:
-        Dictionary mapping output field names to their values
-    """
-    # Prepare params for CWL tool
-    inputs = tool.t.inputs_record_schema['fields']
-    in_dict = {}
-    for i in inputs:
-        in_dict[i['name']] = i['type']
-
-    for k, v in params.items():
-        if k in in_dict:
-            type_val = in_dict[k]
-            # Handle both list and string types (e.g., ['null', 'File'] or 'File?')
-            # Convert each item to str to handle CommentedMap from ruamel.yaml (enum types)
-            type_str = ' '.join(str(t) for t in type_val) if isinstance(type_val, list) else str(type_val)
-            if 'File' in type_str and v is not None:
-                if type(v) is dict and 'location' in v:
-                    location = v['location']
-                elif isinstance(v, str) and v.startswith('file://'):
-                    location = v
-                elif isinstance(v, str) and os.path.isfile(v):
-                    location = f"file://{v}"
-                else:
-                    continue  # Do nothing if v is not a file
-                
-                params[k] = {
-                    "class": "File",
-                    "location": location
-                }
-    
-    # Modify the tool's runtime context if container runner is specified
-    if container_runner:
-        # Try to get the original runtime context from the tool
-        original_runtime_context = None
-        if hasattr(tool, 'runtime_context'):
-            original_runtime_context = tool.runtime_context
-        elif hasattr(tool, 't') and hasattr(tool.t, 'runtime_context'):
-            original_runtime_context = tool.t.runtime_context
-        
-        # If we found the runtime context, modify it in place
-        if original_runtime_context:
-            configure_container_runner(original_runtime_context, container_runner)
-    
-    # Execute tool (no need to pass runtime_context if we modified it in place)
-    res = tool(**params)
-    outs = {}
-    for ot in outputs:
-        out_content = res[ot['name']]
-        # Handle both list and string types (e.g., ['null', 'File'] or 'File?')
-        # Convert each item to str to handle CommentedMap from ruamel.yaml (enum types)
-        type_val = ot['type']
-        type_str = ' '.join(str(t) for t in type_val) if isinstance(type_val, list) else str(type_val)
-        if read_outs and 'File' in type_str:
-            # Handle both single File and File[] (array) outputs
-            file_result = res[ot['name']]
-            if isinstance(file_result, list):
-                # File[] - read first file
-                if len(file_result) > 0:
-                    out_file = file_result[0]['location'].replace('file://', '')
-                    out_content = _read_file_content(out_file)
-            else:
-                # Single File
-                out_file = file_result['location'].replace('file://', '')
-                out_content = _read_file_content(out_file)
-        outs[ot['name']] = out_content
-    return outs