fix plugin loads

Author: codelion

optillm/plugins/deepthink/__init__.py

@@ -3,4 +3,9 @@
 
 A plugin that combines SELF-DISCOVER framework with uncertainty-routed 
 chain-of-thought for enhanced reasoning capabilities.
-"""
+"""
+
+from .self_discover import SelfDiscover
+from .uncertainty_cot import UncertaintyRoutedCoT
+
+__all__ = ['SelfDiscover', 'UncertaintyRoutedCoT']

optillm/plugins/deepthink_plugin.py

@@ -5,11 +5,9 @@
 for enhanced reasoning in large language models.
 """
 
-import os
-import sys
-import importlib.util
 import logging
 from typing import Tuple, Dict, Any
+from optillm.plugins.deepthink import SelfDiscover, UncertaintyRoutedCoT
 
 # Plugin identifier for optillm
 SLUG = "deepthink"
@@ -41,98 +39,72 @@ def run(
     """
     logger.info("Starting Deep Think reasoning process")
 
-    # Get the directory where this plugin is located
-    plugin_dir = os.path.dirname(os.path.abspath(__file__))
-    deepthink_dir = os.path.join(plugin_dir, 'deepthink')
+    # Extract configuration parameters
+    config = _parse_config(request_config or {})
 
-    # Add the deepthink directory to the Python path temporarily
-    if deepthink_dir not in sys.path:
-        sys.path.insert(0, deepthink_dir)
+    # Initialize components
+    self_discover = SelfDiscover(
+        client=client,
+        model=model,
+        max_tokens=config["max_tokens"]
+    )
 
-    try:
-        # Load the modules dynamically
-        self_discover_file = os.path.join(deepthink_dir, 'self_discover.py')
-        uncertainty_cot_file = os.path.join(deepthink_dir, 'uncertainty_cot.py')
-        
-        spec1 = importlib.util.spec_from_file_location("self_discover", self_discover_file)
-        self_discover_module = importlib.util.module_from_spec(spec1)
-        spec1.loader.exec_module(self_discover_module)
-        
-        spec2 = importlib.util.spec_from_file_location("uncertainty_cot", uncertainty_cot_file)
-        uncertainty_cot_module = importlib.util.module_from_spec(spec2)
-        spec2.loader.exec_module(uncertainty_cot_module)
-        
-        # Extract configuration parameters
-        config = _parse_config(request_config or {})
-        
-        # Initialize components
-        self_discover = self_discover_module.SelfDiscover(
-            client=client,
-            model=model,
-            max_tokens=config["max_tokens"]
-        )
-        
-        uncertainty_cot = uncertainty_cot_module.UncertaintyRoutedCoT(
-            client=client,
-            model=model,
-            max_tokens=config["max_tokens"]
-        )
-        
-        total_tokens = 0
-        
-        # Stage 1: SELF-DISCOVER reasoning structure (if enabled)
-        reasoning_structure = None
-        if config["enable_self_discover"]:
-            logger.info("Discovering task-specific reasoning structure")
-            
-            discovery_result = self_discover.discover_reasoning_structure(
-                task_description=_extract_task_description(initial_query, system_prompt),
-                task_examples=None  # Could be enhanced to extract examples
-            )
-            
-            reasoning_structure = discovery_result["reasoning_structure"]
-            total_tokens += discovery_result["completion_tokens"]
-            
-            logger.info(f"Discovered reasoning structure with {len(reasoning_structure)} components")
-        
-        # Prepare enhanced prompt
-        enhanced_prompt = _create_enhanced_prompt(
-            system_prompt=system_prompt,
-            initial_query=initial_query,
-            reasoning_structure=reasoning_structure,
-            config=config
-        )
-        
-        # Stage 2: Uncertainty-routed generation
-        logger.info("Generating response with uncertainty routing")
+    uncertainty_cot = UncertaintyRoutedCoT(
+        client=client,
+        model=model,
+        max_tokens=config["max_tokens"]
+    )
+    
+    total_tokens = 0
+    
+    # Stage 1: SELF-DISCOVER reasoning structure (if enabled)
+    reasoning_structure = None
+    if config["enable_self_discover"]:
+        logger.info("Discovering task-specific reasoning structure")
 
-        generation_result = uncertainty_cot.generate_with_uncertainty_routing(
-            prompt=enhanced_prompt,
-            num_samples=config["deepthink_samples"],
-            confidence_threshold=config["confidence_threshold"],
-            temperature=config["temperature"],
-            top_p=config["top_p"]
+        discovery_result = self_discover.discover_reasoning_structure(
+            task_description=_extract_task_description(initial_query, system_prompt),
+            task_examples=None  # Could be enhanced to extract examples
         )
 
-        total_tokens += generation_result["completion_tokens"]
+        reasoning_structure = discovery_result["reasoning_structure"]
+        total_tokens += discovery_result["completion_tokens"]
 
-        # Log routing decision
-        logger.info(f"Routing decision: {generation_result['routing_decision']} "
-                   f"(confidence: {generation_result['confidence_score']:.3f})")
-        
-        final_response = generation_result["final_response"]
-        
-        # Clean up the response if needed
-        final_response = _clean_response(final_response)
-        
-        logger.info(f"Deep Think completed successfully. Total tokens: {total_tokens}")
-        
-        return final_response, total_tokens
-        
-    finally:
-        # Remove from path after use
-        if deepthink_dir in sys.path:
-            sys.path.remove(deepthink_dir)
+        logger.info(f"Discovered reasoning structure with {len(reasoning_structure)} components")
+    
+    # Prepare enhanced prompt
+    enhanced_prompt = _create_enhanced_prompt(
+        system_prompt=system_prompt,
+        initial_query=initial_query,
+        reasoning_structure=reasoning_structure,
+        config=config
+    )
+    
+    # Stage 2: Uncertainty-routed generation
+    logger.info("Generating response with uncertainty routing")
+    
+    generation_result = uncertainty_cot.generate_with_uncertainty_routing(
+        prompt=enhanced_prompt,
+        num_samples=config["deepthink_samples"],
+        confidence_threshold=config["confidence_threshold"],
+        temperature=config["temperature"],
+        top_p=config["top_p"]
+    )
+    
+    total_tokens += generation_result["completion_tokens"]
+    
+    # Log routing decision
+    logger.info(f"Routing decision: {generation_result['routing_decision']} "
+               f"(confidence: {generation_result['confidence_score']:.3f})")
+    
+    final_response = generation_result["final_response"]
+    
+    # Clean up the response if needed
+    final_response = _clean_response(final_response)
+    
+    logger.info(f"Deep Think completed successfully. Total tokens: {total_tokens}")
+    
+    return final_response, total_tokens
 
 def _parse_config(request_config: Dict[str, Any]) -> Dict[str, Any]:
     """Parse and validate configuration parameters."""

optillm/plugins/longcepo/__init__.py

@@ -0,0 +1,10 @@
+"""LongCePO Plugin Package
+
+Implementation of Long-Context Cerebras Planning and Optimization method.
+"""
+
+from .main import run_longcepo
+
+__version__ = "1.0.0"
+__author__ = "Cerebras"
+__all__ = ['run_longcepo']

optillm/plugins/longcepo.py renamed to optillm/plugins/longcepo_plugin.py

@@ -1,3 +1,7 @@
 """
 System Prompt Learning (SPL) plugin module initialization.
 """
+
+from .main import run_spl
+
+__all__ = ['run_spl']

optillm/plugins/spl/__init__.py

@@ -30,6 +30,7 @@ cerebras_cloud_sdk
 outlines[transformers]
 sentencepiece
 adaptive-classifier
+datasets
 mcp
 # MLX support for Apple Silicon optimization
 mlx-lm>=0.24.0; platform_machine=="arm64" and sys_platform=="darwin"

optillm/plugins/spl.py renamed to optillm/plugins/spl_plugin.py

@@ -34,9 +34,25 @@
     import optillm.plugins.privacy_plugin
     import optillm.plugins.genselect_plugin
     import optillm.plugins.majority_voting_plugin
-    print("✅ Plugin modules exist and can be imported")
+    print("✅ Basic plugin modules exist and can be imported")
 except Exception as e:
-    print(f"❌ Plugin import test failed: {e}")
+    print(f"❌ Basic plugin import test failed: {e}")
+
+# Test plugin subdirectory imports (critical for issue #220)
+try:
+    from optillm.plugins.deepthink import SelfDiscover, UncertaintyRoutedCoT
+    from optillm.plugins.deep_research import DeepResearcher
+    from optillm.plugins.longcepo import run_longcepo
+    from optillm.plugins.spl import run_spl
+    print("✅ Plugin submodule imports working - no relative import errors")
+except ImportError as e:
+    if "attempted relative import" in str(e):
+        print(f"❌ Critical: Relative import error detected: {e}")
+        sys.exit(1)
+    else:
+        print(f"❌ Plugin submodule import error: {e}")
+except Exception as e:
+    print(f"❌ Plugin submodule import error: {e}")
 
 # Test approach parsing
 try:

requirements.txt

@@ -27,7 +27,10 @@ def test_plugin_module_imports():
         'optillm.plugins.genselect_plugin',
         'optillm.plugins.majority_voting_plugin',
         'optillm.plugins.web_search_plugin',
-        'optillm.plugins.deep_research_plugin'
+        'optillm.plugins.deep_research_plugin',
+        'optillm.plugins.deepthink_plugin',
+        'optillm.plugins.longcepo_plugin',
+        'optillm.plugins.spl_plugin'
     ]
 
     for module_name in plugin_modules:
@@ -48,7 +51,7 @@ def test_plugin_approach_detection():
     load_plugins()
 
     # Check if known plugins are loaded
-    expected_plugins = ["memory", "readurls", "privacy", "web_search", "deep_research"]
+    expected_plugins = ["memory", "readurls", "privacy", "web_search", "deep_research", "deepthink", "longcepo", "spl"]
     for plugin_name in expected_plugins:
         assert plugin_name in plugin_approaches, f"Plugin {plugin_name} not loaded"
 
@@ -100,6 +103,96 @@ def test_deep_research_plugin():
     assert plugin.SLUG == "deep_research"
 
 
+def test_deepthink_plugin_imports():
+    """Test deepthink plugin and its submodules can be imported"""
+    # Test main plugin
+    import optillm.plugins.deepthink_plugin as plugin
+    assert hasattr(plugin, 'run')
+    assert hasattr(plugin, 'SLUG')
+    assert plugin.SLUG == "deepthink"
+    
+    # Test submodules can be imported
+    from optillm.plugins.deepthink import SelfDiscover, UncertaintyRoutedCoT
+    assert SelfDiscover is not None
+    assert UncertaintyRoutedCoT is not None
+
+
+def test_longcepo_plugin():
+    """Test longcepo plugin module"""
+    import optillm.plugins.longcepo_plugin as plugin
+    assert hasattr(plugin, 'run')
+    assert hasattr(plugin, 'SLUG')
+    assert plugin.SLUG == "longcepo"
+    
+    # Test submodule can be imported
+    from optillm.plugins.longcepo import run_longcepo
+    assert run_longcepo is not None
+
+
+def test_spl_plugin():
+    """Test spl plugin module"""
+    import optillm.plugins.spl_plugin as plugin
+    assert hasattr(plugin, 'run')
+    assert hasattr(plugin, 'SLUG')
+    assert plugin.SLUG == "spl"
+    
+    # Test submodule can be imported
+    from optillm.plugins.spl import run_spl
+    assert run_spl is not None
+
+
+def test_plugin_subdirectory_imports():
+    """Test all plugins with subdirectories can import their submodules"""
+    # Test deep_research
+    from optillm.plugins.deep_research import DeepResearcher
+    assert DeepResearcher is not None
+    
+    # Test deepthink
+    from optillm.plugins.deepthink import SelfDiscover, UncertaintyRoutedCoT
+    assert SelfDiscover is not None
+    assert UncertaintyRoutedCoT is not None
+    
+    # Test longcepo
+    from optillm.plugins.longcepo import run_longcepo
+    assert run_longcepo is not None
+    
+    # Test spl
+    from optillm.plugins.spl import run_spl
+    assert run_spl is not None
+
+
+def test_no_relative_import_errors():
+    """Test that plugins load without relative import errors"""
+    import importlib
+    import sys
+    
+    plugins_with_subdirs = [
+        'optillm.plugins.deepthink_plugin',
+        'optillm.plugins.deep_research_plugin',
+        'optillm.plugins.longcepo_plugin',
+        'optillm.plugins.spl_plugin'
+    ]
+    
+    for plugin_name in plugins_with_subdirs:
+        # Clear any previously loaded modules to test fresh import
+        modules_to_clear = [k for k in sys.modules.keys() if k.startswith(plugin_name)]
+        for mod in modules_to_clear:
+            del sys.modules[mod]
+        
+        try:
+            module = importlib.import_module(plugin_name)
+            # Try to access the run function to ensure full initialization works
+            assert hasattr(module, 'run'), f"{plugin_name} missing run function"
+        except ImportError as e:
+            if "attempted relative import" in str(e):
+                if pytest:
+                    pytest.fail(f"Relative import error in {plugin_name}: {e}")
+                else:
+                    raise AssertionError(f"Relative import error in {plugin_name}: {e}")
+            else:
+                raise
+
+
 if __name__ == "__main__":
     print("Running plugin tests...")
 
@@ -145,4 +238,34 @@ def test_deep_research_plugin():
     except Exception as e:
         print(f"❌ Deep research plugin test failed: {e}")
 
+    try:
+        test_deepthink_plugin_imports()
+        print("✅ Deepthink plugin imports test passed")
+    except Exception as e:
+        print(f"❌ Deepthink plugin imports test failed: {e}")
+    
+    try:
+        test_longcepo_plugin()
+        print("✅ LongCePO plugin test passed")
+    except Exception as e:
+        print(f"❌ LongCePO plugin test failed: {e}")
+    
+    try:
+        test_spl_plugin()
+        print("✅ SPL plugin test passed")
+    except Exception as e:
+        print(f"❌ SPL plugin test failed: {e}")
+    
+    try:
+        test_plugin_subdirectory_imports()
+        print("✅ Plugin subdirectory imports test passed")
+    except Exception as e:
+        print(f"❌ Plugin subdirectory imports test failed: {e}")
+    
+    try:
+        test_no_relative_import_errors()
+        print("✅ No relative import errors test passed")
+    except Exception as e:
+        print(f"❌ Relative import errors test failed: {e}")
+    
     print("\nDone!")