Merge pull request #5 from danghoangnhan/feat/crewai-server-cleanup

agents/crew_orchestrator.py

@@ -16,15 +16,20 @@ import logging
 import re
 from pathlib import Path
 
+from agents.base import BaseOrchestrator
 from agents.definitions import AGENTS
 from agents.design_state import DesignState, extract_decisions
-from agents.prompts import CAD_TRIGGER_KEYWORDS, route_by_keywords
 from agents.orchestrator import _format_response, _execute_cad_code
+from agents.routing import RoutingEngine
+from config.settings import settings
+from core.backend_factory import BackendFactory
 
 logger = logging.getLogger(__name__)
 
 DEFAULT_OUTPUT_DIR = Path(__file__).parent.parent / "output"
 
+_router = RoutingEngine()
+
 
 def _build_agent_context(
     message: str,
@@ -57,7 +62,7 @@ def _build_agent_context(
     return "\n\n".join(parts)
 
 
-class CrewOrchestrator:
+class CrewOrchestrator(BaseOrchestrator):
     """Multi-call orchestrator using CrewAI.
 
     Each selected agent gets its own LLM call with focused context and
@@ -66,14 +71,9 @@ class CrewOrchestrator:
     Falls back to SingleCallOrchestrator if CrewAI is not installed.
     """
 
-    def __init__(
-        self,
-        backend_name: str = "anthropic",
-        output_dir: Path | str = DEFAULT_OUTPUT_DIR,
-    ):
+    def __init__(self, backend_name: str = "anthropic", output_dir=None):
+        super().__init__(output_dir=output_dir or DEFAULT_OUTPUT_DIR)
         self.backend_name = backend_name
-        self.output_dir = Path(output_dir)
-        self.output_dir.mkdir(parents=True, exist_ok=True)
         self._crew_available = self._check_crewai()
 
     @staticmethod
@@ -123,12 +123,12 @@ class CrewOrchestrator:
         if mentions:
             active_ids = mentions
         else:
-            active_ids = route_by_keywords(message)
+            active_ids = _router.route(message)
 
         # Check CAD trigger
         include_cad = "cad" in active_ids
         if not include_cad:
-            include_cad = any(kw in message.lower() for kw in CAD_TRIGGER_KEYWORDS)
+            include_cad = _router.has_cad_trigger(message)
             if include_cad and "cad" not in active_ids:
                 active_ids.append("cad")
 
@@ -263,11 +263,7 @@ class CrewOrchestrator:
         from agents.llm_adapter import NeuralCADLLMAdapter
 
         backend = self._build_backend()
-        model_names = {
-            "anthropic": "claude-sonnet-4-20250514",
-            "openai": "gpt-4o",
-            "gemini": "gemini-2.5-flash",
-        }
+        model_names = settings.model_for
         return NeuralCADLLMAdapter(
             backend=backend,
             model=model_names.get(self.backend_name, "custom"),
@@ -275,15 +271,7 @@ class CrewOrchestrator:
 
     def _build_backend(self):
         """Build the underlying LLM backend."""
-        from core.backends import AnthropicBackend, OpenAIBackend, GeminiBackend
-
-        backends = {
-            "anthropic": AnthropicBackend,
-            "openai": OpenAIBackend,
-            "gemini": GeminiBackend,
-        }
-        backend_cls = backends.get(self.backend_name, AnthropicBackend)
-        return backend_cls()
+        return BackendFactory.create(self.backend_name)
 
     # ── Fallback ───────────────────────────────────────────────────────────
 

agents/llm_adapter.py

@@ -1,28 +1,22 @@
-"""CrewAI BaseLLM adapter for NeuralCAD's LLMBackend interface."""
+"""CrewAI LLM adapter — wraps NeuralCAD's LLMBackend for CrewAI compatibility."""
 
 from __future__ import annotations
+
+import logging
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
 try:
-    from crewai import LLM as BaseLLM
+    from crewai.llm import BaseLLM
 except ImportError:
-    # Fallback if crewai not installed — allows import without dependency
-    class BaseLLM:
-        def __init__(self, model: str, **kwargs):
-            self.model = model
-        def call(self, messages, **kwargs) -> str:
-            raise NotImplementedError
+    # Stub if crewai not installed
+    class BaseLLM:  # type: ignore[no-redef]
+        def __init__(self, **kwargs): pass
 
 
 class NeuralCADLLMAdapter(BaseLLM):
-    """Adapter that wraps NeuralCAD's LLMBackend for CrewAI compatibility.
-
-    Usage:
-        from core.backends import GeminiBackend
-        backend = GeminiBackend()
-        adapter = NeuralCADLLMAdapter(backend, model="gemini-2.5-flash")
-        # Now usable as CrewAI agent's llm parameter
-    """
+    """Wraps NeuralCAD's LLMBackend for CrewAI agent usage."""
 
     def __init__(self, backend, model: str = "custom", **kwargs):
         super().__init__(model=model, **kwargs)
@@ -36,13 +30,15 @@ class NeuralCADLLMAdapter(BaseLLM):
         available_functions: Any = None,
         **kwargs,
     ) -> str:
-        # If messages is a string, wrap it in standard format
         if isinstance(messages, str):
             messages = [{"role": "user", "content": messages}]
         return self.backend.generate(messages)
 
     def supports_function_calling(self) -> bool:
-        return False
+        return True  # Enable CrewAI tool usage
 
     def supports_stop_words(self) -> bool:
         return False
+
+    def supports_vision(self) -> bool:
+        return hasattr(self.backend, 'generate_with_image')

agents/tools.py

@@ -0,0 +1,56 @@
+"""CrewAI tools for CadQuery code execution and CNC validation.
+
+These tools allow the CAD Coder agent to execute code and validate
+manufacturability within its reasoning loop, enabling self-correction.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+try:
+    from crewai.tools import tool
+except ImportError:
+    # Stub if crewai not installed — tools won't be available
+    def tool(name):
+        def decorator(func):
+            return func
+        return decorator
+
+
+@tool("Execute CadQuery Code")
+def execute_cad_tool(code: str) -> str:
+    """Execute CadQuery Python code and return geometry info.
+
+    The code must assign result to a variable called `result` as cq.Workplane.
+    Returns JSON with: success, volume_mm3, bounding_box_mm, face_count, edge_count, error.
+    """
+    from core.executor import execute_cadquery
+    from core.serializers import ExecutionResultSerializer
+
+    result = execute_cadquery(code)
+    return json.dumps(ExecutionResultSerializer.to_dict(result), indent=2)
+
+
+@tool("Validate CNC Manufacturability")
+def validate_cad_tool(code: str) -> str:
+    """Run CNC manufacturability checks on CadQuery code.
+
+    Returns JSON with: machinable, axis_recommendation, issues list.
+    """
+    from core.executor import execute_cadquery
+    from core.validator import validate_for_cnc
+    from core.serializers import ExecutionResultSerializer, ValidationResultSerializer
+
+    exec_result = execute_cadquery(code)
+    if not exec_result.success:
+        return json.dumps({"success": False, "error": exec_result.error})
+
+    validation = validate_for_cnc(exec_result.result)
+    return json.dumps({
+        "execution": ExecutionResultSerializer.to_dict(exec_result),
+        "validation": ValidationResultSerializer.to_dict(validation),
+    }, indent=2)

server/mcp.py

@@ -37,26 +37,26 @@ mcp = FastMCP(
     ),
 )
 
-DEFAULT_OUTPUT_DIR = Path(__file__).parent.parent / "output"
+from config.settings import settings
+from core.backend_factory import BackendFactory
+
+DEFAULT_OUTPUT_DIR = settings.output_dir
+if not DEFAULT_OUTPUT_DIR.is_absolute():
+    DEFAULT_OUTPUT_DIR = Path(__file__).parent.parent / DEFAULT_OUTPUT_DIR
 DEFAULT_OUTPUT_DIR.mkdir(exist_ok=True)
 
 
 # ── Helper: LLM Backend Selection ────────────────────────────────────────
 
 def get_backend(backend_name: str = "mock"):
-    """Get the appropriate LLM backend."""
-    from core.backends import MockBackend, AnthropicBackend, OpenAIBackend, GeminiBackend, NeuralCADBackend
+    """Get LLM backend by name, using the factory registry.
 
+    NeuralCADBackend is a special case not registered in the factory.
+    """
     if backend_name == "neural":
+        from core.backends import NeuralCADBackend
         return NeuralCADBackend()
-    elif backend_name == "anthropic" and os.environ.get("ANTHROPIC_API_KEY"):
-        return AnthropicBackend()
-    elif backend_name == "openai" and os.environ.get("OPENAI_API_KEY"):
-        return OpenAIBackend()
-    elif backend_name == "gemini" and os.environ.get("GEMINI_API_KEY"):
-        return GeminiBackend()
-    else:
-        return MockBackend()
+    return BackendFactory.create_safe(backend_name)
 
 
 # ── Tool: generate_cnc_model ─────────────────────────────────────────────

server/routes.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
 
 from fastapi import APIRouter
 from fastapi.responses import JSONResponse
@@ -13,10 +12,13 @@ from agents.orchestrator import get_orchestrator
 from agents.crew_orchestrator import CrewOrchestrator
 from agents.prompts import parse_mentions
 from agents.definitions import AGENTS
+from config.settings import settings
 
 router = APIRouter()
 
-OUTPUT_DIR = Path(__file__).parent.parent / "output"
+OUTPUT_DIR = settings.output_dir
+if not OUTPUT_DIR.is_absolute():
+    OUTPUT_DIR = Path(__file__).parent.parent / OUTPUT_DIR
 
 
 # ── Request / response models ─────────────────────────────────────────────

server/web.py

@@ -38,10 +38,19 @@ from mcp.client.sse import sse_client
 
 # ── Config ───────────────────────────────────────────────────────────────
 
-MCP_SERVER_URL = os.environ.get("MCP_SERVER_URL", "http://localhost:8000/sse")
-OUTPUT_DIR = Path(__file__).parent.parent / "output"
-WEB_DIR = Path(__file__).parent.parent / "web"
-PORT = int(os.environ.get("WEB_PORT", "5000"))
+from config.settings import settings
+
+OUTPUT_DIR = settings.output_dir
+if not OUTPUT_DIR.is_absolute():
+    OUTPUT_DIR = Path(__file__).parent.parent / OUTPUT_DIR
+
+WEB_DIR = Path(settings.paths.get("web_dir", "./web"))
+if not WEB_DIR.is_absolute():
+    WEB_DIR = Path(__file__).parent.parent / WEB_DIR
+
+PORT = settings.web_port
+
+MCP_SERVER_URL = os.environ.get("MCP_SERVER_URL", f"http://localhost:{settings.mcp_port}/sse")
 
 # ── MCP Client Management ───────────────────────────────────────────────
 

tests/test_llm_adapter.py

@@ -0,0 +1,44 @@
+"""Tests for agents/llm_adapter.py."""
+
+from agents.llm_adapter import NeuralCADLLMAdapter
+
+
+class FakeBackend:
+    def generate(self, messages):
+        return "test response"
+
+
+class FakeVisionBackend:
+    def generate(self, messages):
+        return "test response"
+
+    def generate_with_image(self, messages, image_path):
+        return "vision response"
+
+
+class TestNeuralCADLLMAdapter:
+    def test_call_with_messages(self):
+        adapter = NeuralCADLLMAdapter(FakeBackend())
+        result = adapter.call([{"role": "user", "content": "hello"}])
+        assert result == "test response"
+
+    def test_call_with_string(self):
+        adapter = NeuralCADLLMAdapter(FakeBackend())
+        result = adapter.call("hello")
+        assert result == "test response"
+
+    def test_supports_function_calling(self):
+        adapter = NeuralCADLLMAdapter(FakeBackend())
+        assert adapter.supports_function_calling() is True
+
+    def test_supports_stop_words(self):
+        adapter = NeuralCADLLMAdapter(FakeBackend())
+        assert adapter.supports_stop_words() is False
+
+    def test_supports_vision_false(self):
+        adapter = NeuralCADLLMAdapter(FakeBackend())
+        assert adapter.supports_vision() is False
+
+    def test_supports_vision_true(self):
+        adapter = NeuralCADLLMAdapter(FakeVisionBackend())
+        assert adapter.supports_vision() is True

tests/test_tools.py

@@ -0,0 +1,45 @@
+"""Tests for agents/tools.py — CrewAI CadQuery tools.
+
+These tests require CadQuery to be installed.
+"""
+
+import json
+import pytest
+
+from agents.tools import execute_cad_tool, validate_cad_tool
+
+pytestmark = pytest.mark.requires_cadquery
+
+
+class TestExecuteCadTool:
+    def test_valid_code(self):
+        result = json.loads(execute_cad_tool.run("result = cq.Workplane('XY').box(10,10,10)"))
+        assert result["success"] is True
+        assert result["volume_mm3"] > 0
+        assert result["face_count"] == 6
+
+    def test_invalid_code(self):
+        result = json.loads(execute_cad_tool.run("result = bad_code"))
+        assert result["success"] is False
+        assert result["error"] is not None
+
+    def test_missing_result(self):
+        result = json.loads(execute_cad_tool.run("x = 42"))
+        assert result["success"] is False
+
+
+class TestValidateCadTool:
+    def test_valid_machinable(self):
+        result = json.loads(validate_cad_tool.run("result = cq.Workplane('XY').box(50, 30, 10)"))
+        assert "validation" in result
+        assert result["validation"]["machinable"] is True
+
+    def test_invalid_code(self):
+        result = json.loads(validate_cad_tool.run("result = bad_code"))
+        assert result["success"] is False
+
+    def test_returns_execution_and_validation(self):
+        result = json.loads(validate_cad_tool.run("result = cq.Workplane('XY').box(20, 20, 20)"))
+        assert "execution" in result
+        assert "validation" in result
+        assert result["execution"]["face_count"] == 6