feat(crewai): rewrite orchestrator with native LLM, tools, structured output

agents/crew_orchestrator.py

@@ -1,17 +1,14 @@
-"""CrewAI multi-call orchestrator for paid API backends (Anthropic/OpenAI).
+"""CrewAI orchestrator for all LLM backends.
 
 Uses CrewAI's sequential process where each specialist agent gets its own
-focused LLM call. A routing step selects which agents respond, then each
-agent reasons independently with its own context.
+focused LLM call with tools, structured output, and knowledge sources.
 
-Better quality than single-call (agents can truly disagree / specialize)
-but uses 2-4 API calls per turn. Used for paid backends only.
-
-Falls back to SingleCallOrchestrator if CrewAI is not installed.
+Falls back to MockChatBackend if CrewAI is not installed.
 """
 
 from __future__ import annotations
 
+import json
 import logging
 import re
 from pathlib import Path
@@ -19,14 +16,14 @@ from pathlib import Path
 from agents.base import BaseOrchestrator
 from agents.definitions import AGENTS
 from agents.design_state import DesignState, extract_decisions
-from agents.orchestrator import _format_response, _execute_cad_code
+from agents.orchestrator import _format_response
 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"
+WIKI_DIR = Path(__file__).parent.parent / "docs" / "wiki"
 
 _router = RoutingEngine()
 
@@ -39,13 +36,10 @@ def _build_agent_context(
 ) -> str:
     """Build a shared context string that each CrewAI agent receives."""
     parts = []
-
-    # Design state
     spec = design_state.render()
     if spec:
         parts.append(f"## Current Design Spec\n{spec}")
 
-    # Recent conversation (compact)
     recent = history[-max_history:] if len(history) > max_history else history
     if recent:
         lines = []
@@ -62,16 +56,30 @@ def _build_agent_context(
     return "\n\n".join(parts)
 
 
+def _get_crewai_model(backend_name: str) -> str:
+    """Get the CrewAI model string for a backend name."""
+    crewai_models = settings.backends.get("crewai_models", {})
+    return crewai_models.get(backend_name, "gemini/gemini-2.5-flash")
+
+
+def _load_wiki(filename: str) -> str | None:
+    """Load a wiki file as a string, or None if it doesn't exist."""
+    path = WIKI_DIR / filename
+    if path.exists():
+        return path.read_text()
+    return None
+
+
 class CrewOrchestrator(BaseOrchestrator):
-    """Multi-call orchestrator using CrewAI.
+    """Multi-call orchestrator using CrewAI for all LLM backends.
 
-    Each selected agent gets its own LLM call with focused context and
-    persona, producing genuinely independent reasoning.
+    Each selected agent gets its own LLM call with focused context,
+    tools, and optional knowledge sources.
 
-    Falls back to SingleCallOrchestrator if CrewAI is not installed.
+    Falls back to MockChatBackend if CrewAI is not installed.
     """
 
-    def __init__(self, backend_name: str = "anthropic", output_dir=None):
+    def __init__(self, backend_name: str = "gemini", output_dir=None):
         super().__init__(output_dir=output_dir or DEFAULT_OUTPUT_DIR)
         self.backend_name = backend_name
         self._crew_available = self._check_crewai()
@@ -84,8 +92,6 @@ class CrewOrchestrator(BaseOrchestrator):
         except (ImportError, ModuleNotFoundError):
             return False
 
-    # ── Public interface ───────────────────────────────────────────────────
-
     def chat_turn(
         self,
         message: str,
@@ -94,14 +100,13 @@ class CrewOrchestrator(BaseOrchestrator):
         max_history: int = 30,
         design_state: dict | None = None,
     ) -> dict:
-        """Run one chat turn.  Returns the standard response envelope."""
         if not self._crew_available:
             return self._fallback(message, history, mentions, max_history, design_state)
 
         try:
             return self._run_crew(message, history, mentions, max_history, design_state)
         except Exception as exc:
-            logger.warning("CrewAI run failed (%s), falling back to single-call", exc, exc_info=True)
+            logger.warning("CrewAI run failed (%s), falling back", exc, exc_info=True)
             try:
                 return self._fallback(message, history, mentions, max_history, design_state)
             except Exception as fallback_exc:
@@ -116,8 +121,6 @@ class CrewOrchestrator(BaseOrchestrator):
                     "design_state": design_state or {},
                 }
 
-    # ── CrewAI implementation ──────────────────────────────────────────────
-
     def _run_crew(
         self,
         message: str,
@@ -126,28 +129,39 @@ class CrewOrchestrator(BaseOrchestrator):
         max_history: int,
         design_state_dict: dict | None,
     ) -> dict:
-        from crewai import Agent, Task, Crew, Process
+        from crewai import Agent, Task, Crew, Process, LLM
+        from agents.tools import execute_cad_tool, validate_cad_tool, generate_gcode_tool
+        from core.cam import CAMPlan
 
         state = DesignState(**(design_state_dict or {}))
         context = _build_agent_context(message, history, state, max_history)
 
         # Select which agents should respond
         if mentions:
-            active_ids = mentions
+            active_ids = list(mentions)
         else:
             active_ids = _router.route(message)
 
         # Check CAD trigger
-        include_cad = "cad" in active_ids
-        if not include_cad:
-            include_cad = _router.has_cad_trigger(message)
-            if include_cad and "cad" not in active_ids:
-                active_ids.append("cad")
+        if "cad" not in active_ids and _router.has_cad_trigger(message):
+            active_ids.append("cad")
 
-        # Build the LLM adapter
-        llm = self._build_llm()
+        # Build native CrewAI LLM
+        model_str = _get_crewai_model(self.backend_name)
+        llm = LLM(model=model_str, temperature=settings.temperature)
 
-        # Create CrewAI agents + tasks for selected agents
+        # Load knowledge sources
+        knowledge_sources = []
+        try:
+            from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
+            for filename in ["cutting-parameters.md", "gcode-reference.md"]:
+                content = _load_wiki(filename)
+                if content:
+                    knowledge_sources.append(StringKnowledgeSource(content=content))
+        except ImportError:
+            pass
+
+        # Build CrewAI agents + tasks
         crew_agents = []
         crew_tasks = []
 
@@ -156,24 +170,37 @@ class CrewOrchestrator(BaseOrchestrator):
                 continue
             agent_def = AGENTS[agent_id]
 
-            # Special instructions for CAD Coder
-            extra = ""
+            # Agent-specific configuration
+            tools = []
+            extra_backstory = ""
+            task_output_pydantic = None
+
             if agent_id == "cad":
+                tools = [execute_cad_tool, validate_cad_tool]
                 from core.cadquery_prompts import CADQUERY_SYSTEM_PROMPT
-                extra = (
-                    "\n\nWhen generating code, output ONLY valid CadQuery Python. "
-                    "The code must assign the result to a variable called `result` "
-                    "as a cq.Workplane object. Import cadquery as cq.\n\n"
+                extra_backstory = (
+                    "\n\nWhen generating code, use the Execute CadQuery Code tool "
+                    "to test your code. If it fails, fix the errors and try again. "
+                    "Use the Validate CNC Manufacturability tool to check the result. "
+                    "Output ONLY valid CadQuery Python that assigns result to a "
+                    "cq.Workplane. Import cadquery as cq.\n\n"
                     f"CadQuery reference:\n{CADQUERY_SYSTEM_PROMPT}"
                 )
+            elif agent_id == "cam":
+                tools = [generate_gcode_tool]
+                task_output_pydantic = CAMPlan
+
+            agent_knowledge = knowledge_sources if agent_id in ("cnc", "cam") else []
 
             crew_agent = Agent(
                 role=agent_def.role,
                 goal=agent_def.goal,
-                backstory=agent_def.backstory + extra,
+                backstory=agent_def.backstory + extra_backstory,
                 llm=llm,
+                tools=tools,
                 verbose=False,
                 allow_delegation=False,
+                knowledge_sources=agent_knowledge if agent_knowledge else None,
             )
 
             task_description = (
@@ -182,42 +209,39 @@ class CrewOrchestrator(BaseOrchestrator):
                 f"Keep your response concise (2-4 sentences). "
                 f"Do NOT repeat anything from the conversation history. "
                 f"Add NEW information from your expertise.\n\n"
-                f"You can see what previous agents on the team said in this turn. "
-                f"Build on their input — agree, disagree, refine, or add to their "
-                f"points. Reference their suggestions when relevant (e.g. 'Building "
-                f"on the designer\\'s L-bracket suggestion, I\\'d recommend...'). "
-                f"Do NOT repeat what they already covered."
+                f"Build on other agents' input — agree, disagree, refine, or add."
             )
-            if agent_id != "cad":
+
+            if agent_id == "cad":
+                task_description += (
+                    "\n\nEvaluate if there is enough info to generate a 3D model "
+                    "(shape, dimensions, features). If NOT, start with 'NOT READY:' "
+                    "and list missing items. If enough, generate CadQuery code and "
+                    "use the Execute CadQuery Code tool to verify it works."
+                )
+            elif agent_id == "cam":
                 task_description += (
-                    "\n\nEvaluate if the user's request has enough detail in YOUR "
-                    "domain. If key information is missing, ask a SPECIFIC "
-                    "clarifying question (not generic). For example, a designer "
-                    "should ask about shape/form, an engineer about dimensions/"
-                    "material, a CNC advisor about machining constraints. "
-                    "Only provide recommendations when you have enough context."
+                    "\n\nAnalyze the part geometry and create an optimal machining "
+                    "strategy. Select operations in order (roughing before finishing). "
+                    "Use the Generate G-code Toolpath tool to create the G-code."
                 )
             else:
                 task_description += (
-                    "\n\nReview what the other agents have discussed in this turn. "
-                    "Use their suggestions and specs to evaluate whether there is "
-                    "enough information to generate a 3D model. You need at minimum: "
-                    "a clear shape/type, key dimensions, and major features. "
-                    "If NOT enough info, start your response with 'NOT READY:' "
-                    "followed by a short list of what is still needed. "
-                    "If enough info IS available, generate CadQuery Python code. "
-                    "Output ONLY the Python code, nothing else."
+                    "\n\nIf key information is missing in YOUR domain, ask a "
+                    "SPECIFIC clarifying question."
                 )
 
+            expected_output = (
+                "A concise response from your expert perspective (2-4 sentences)."
+                if agent_id != "cad"
+                else "Valid CadQuery Python code or a 'NOT READY:' message."
+            )
+
             task = Task(
                 description=task_description,
-                expected_output=(
-                    "A concise response from your expert perspective (2-4 sentences)."
-                    if agent_id != "cad"
-                    else "Valid CadQuery Python code that assigns result to a cq.Workplane, "
-                         "OR a 'NOT READY:' message listing missing information."
-                ),
+                expected_output=expected_output,
                 agent=crew_agent,
+                output_pydantic=task_output_pydantic,
             )
 
             crew_agents.append(crew_agent)
@@ -226,7 +250,6 @@ class CrewOrchestrator(BaseOrchestrator):
         if not crew_agents:
             return {"responses": [], "preview": None, "design_state": state.model_dump()}
 
-        # Run the crew — sequential process so each agent runs independently
         crew = Crew(
             agents=crew_agents,
             tasks=crew_tasks,
@@ -236,11 +259,11 @@ class CrewOrchestrator(BaseOrchestrator):
 
         crew_result = crew.kickoff()
 
-        # Parse results into standard response format
+        # Parse results
         responses = []
         preview = None
+        cam_plan = None
 
-        # crew_result.tasks_output gives per-task results
         task_outputs = crew_result.tasks_output if hasattr(crew_result, 'tasks_output') else []
 
         for i, agent_id in enumerate(active_ids):
@@ -248,7 +271,8 @@ class CrewOrchestrator(BaseOrchestrator):
                 continue
 
             if i < len(task_outputs):
-                raw_output = str(task_outputs[i])
+                task_output = task_outputs[i]
+                raw_output = str(task_output)
             else:
                 raw_output = str(crew_result) if i == 0 else ""
 
@@ -258,21 +282,71 @@ class CrewOrchestrator(BaseOrchestrator):
             if agent_id == "cad":
                 stripped = raw_output.strip()
                 if stripped.upper().startswith("NOT READY:"):
-                    # CAD agent says not enough info — show the message, no code
                     responses.append(_format_response(agent_id, stripped))
                 else:
                     code = self._extract_code(raw_output)
                     if code:
                         responses.append(_format_response(agent_id, "Model generated.", code=code))
-                        backend = self._build_backend()
-                        preview = _execute_cad_code(
-                            code, message, self.output_dir, backend=backend,
-                        )
+                        from agents.tools import get_last_shape
+                        shape = get_last_shape()
+                        if shape is not None:
+                            from core.executor import export_all
+                            from core.validator import validate_for_cnc
+                            from core.serializers import ValidationResultSerializer
+
+                            part_name = message[:40].strip().replace(" ", "_").lower()
+                            part_name = "".join(c for c in part_name if c.isalnum() or c == "_") or "part"
+                            base_path = self.output_dir / part_name
+                            try:
+                                export_all(shape, base_path)
+                            except Exception:
+                                pass
+
+                            validation = validate_for_cnc(shape, part_name=part_name)
+                            preview = {
+                                "success": True,
+                                "part_name": part_name,
+                                "stl_url": f"/api/models/{part_name}.stl",
+                                "step_url": f"/api/models/{part_name}.step",
+                                "execution": {"success": True},
+                                "validation": ValidationResultSerializer.to_dict(validation),
+                            }
                     else:
                         responses.append(_format_response(agent_id, stripped))
+
+            elif agent_id == "cam":
+                if i < len(task_outputs) and hasattr(task_outputs[i], 'pydantic') and task_outputs[i].pydantic:
+                    cam_plan = task_outputs[i].pydantic
+                    responses.append(_format_response(
+                        agent_id,
+                        f"Machining plan: {', '.join(cam_plan.operations)} | "
+                        f"{cam_plan.tool_diameter}mm endmill | {cam_plan.post_processor}",
+                    ))
+                else:
+                    responses.append(_format_response(agent_id, raw_output.strip()))
             else:
                 responses.append(_format_response(agent_id, raw_output.strip()))
 
+        # If we have both a preview and a CAM plan, generate G-code
+        if preview and preview.get("success") and cam_plan:
+            from core.cam import generate_gcode, CAMResultSerializer
+            from agents.tools import get_last_shape
+
+            shape = get_last_shape()
+            if shape is not None:
+                cam_result = generate_gcode(
+                    shape=shape,
+                    operations=cam_plan.operations,
+                    tool_config=cam_plan.to_tool_config(),
+                    post_processor=cam_plan.post_processor,
+                )
+                preview["cam"] = CAMResultSerializer.to_dict(cam_result)
+                if cam_result.success and cam_result.gcode:
+                    part_name = preview["part_name"]
+                    gcode_path = self.output_dir / f"{part_name}.gcode"
+                    gcode_path.write_text(cam_result.gcode)
+                    preview["gcode_url"] = f"/api/models/{part_name}.gcode"
+
         # Update design state
         agent_msgs = [{"message": r.get("message", "")} for r in responses]
         updated_state = extract_decisions(agent_msgs, state, message)
@@ -284,35 +358,14 @@ class CrewOrchestrator(BaseOrchestrator):
         }
 
     def _extract_code(self, text: str) -> str | None:
-        """Extract Python code from LLM output, handling code fences."""
-        # Try to extract from code fences
+        """Extract Python code from LLM output."""
         match = re.search(r"```(?:python)?\s*\n(.*?)```", text, re.DOTALL)
         if match:
             return match.group(1).strip()
-
-        # If the whole output looks like code (has 'import' or 'cq.' or 'result =')
         if any(marker in text for marker in ["import cadquery", "cq.", "result ="]):
             return text.strip()
-
         return None
 
-    def _build_llm(self):
-        """Build the CrewAI-compatible LLM from our backend."""
-        from agents.llm_adapter import NeuralCADLLMAdapter
-
-        backend = self._build_backend()
-        model_names = settings.model_for
-        return NeuralCADLLMAdapter(
-            backend=backend,
-            model=model_names.get(self.backend_name, "custom"),
-        )
-
-    def _build_backend(self):
-        """Build the underlying LLM backend."""
-        return BackendFactory.create(self.backend_name)
-
-    # ── Fallback ───────────────────────────────────────────────────────────
-
     def _fallback(
         self,
         message: str,
@@ -321,17 +374,7 @@ class CrewOrchestrator(BaseOrchestrator):
         max_history: int,
         design_state: dict | None,
     ) -> dict:
-        """Fall back to SingleCallOrchestrator."""
-        from agents.orchestrator import SingleCallOrchestrator, MockChatBackend
-
-        try:
-            backend = self._build_backend()
-        except Exception:
-            logger.warning("Backend %r unavailable, falling back to mock", self.backend_name)
-            mock = MockChatBackend()
-            return mock.chat_turn(message, history, mentions, design_state=design_state)
-
-        orchestrator = SingleCallOrchestrator(backend=backend, output_dir=self.output_dir)
-        return orchestrator.chat_turn(
-            message, history, mentions, max_history, design_state=design_state,
-        )
+        """Fall back to MockChatBackend."""
+        from agents.orchestrator import MockChatBackend
+        mock = MockChatBackend(output_dir=self.output_dir)
+        return mock.chat_turn(message, history, mentions, design_state=design_state)