Deploy Myco from CI

game/agent_controller.py

@@ -1,17 +1,12 @@
-from game import engine
+from . import engine
 import json
-import random
 
 class MycoController:
     def __init__(self):
-        self.position = [1, 1]  # 3x3 Grid (0-2)
+        self.position = [1, 1]
         self.history = []
 
     def get_agent_decision(self, current_mushroom, collection):
-        """
-        Queries Gemma for a decision. 
-        Note: We use engine._llm but provide a specific 'Agent' prompt.
-        """
         prompt = f"""
         Current Position: {self.position}
         Mushroom in clearing: {'Yes' if current_mushroom else 'No'}
@@ -20,44 +15,56 @@ class MycoController:
         Decide your next action: 'move', 'search', 'study', 'collect', or 'wait'.
         If 'move', provide target coordinate (e.g., [1, 2]).
         
-        Respond ONLY in JSON format:
+        Respond ONLY in valid JSON format:
         {{"action": "...", "target": [x, y], "thought": "..."}}
         """
         
-        # We reuse the existing engine._llm functionality
         response = engine._llm(prompt) 
         
-        # Simple parser
+        # FIX: Validate response exists before parsing
+        if not response:
+            return {"action": "wait", "target": None, "thought": "Engine returned no data."}
+            
         try:
-            # Extract JSON from potential markdown text
             start = response.find("{")
             end = response.rfind("}") + 1
+            if start == -1 or end == 0:
+                raise ValueError("No JSON found in response")
+                
             return json.loads(response[start:end])
-        except:
-            return {"action": "wait", "target": None, "thought": "Thinking..."}
+        except Exception as e:
+            print(f"[Myco] Controller Parse Error: {e}")
+            return {"action": "wait", "target": None, "thought": "Failed to parse JSON."}
 
     def run_tick(self, current_mushroom, collection):
-        """
-        This is the heartbeat of the AI. 
-        It decides and then executes via engine functions.
-        """
         decision = self.get_agent_decision(current_mushroom, collection)
         action = decision.get("action")
         
         result = {"action_taken": action, "thought": decision.get("thought")}
         
-        # EXECUTION LAYER (calling existing engine functions)
+        # EXECUTION LAYER
         if action == "move":
-            self.position = decision.get("target", self.position)
+            # Add basic validation for grid boundaries if necessary
+            target = decision.get("target")
+            if isinstance(target, list) and len(target) == 2:
+                self.position = target
         
         elif action == "search":
-            # We call the engine function directly
-            mushroom, current, history = engine.discover_mushroom(collection)
-            result["data"] = {"mushroom": mushroom, "current": current}
+            # Ensure engine functions exist and return expected values
+            try:
+                mushroom, current, history = engine.discover_mushroom(collection)
+                result["data"] = {"mushroom": mushroom, "current": current}
+            except AttributeError:
+                result["thought"] = "Search function not found in engine."
             
         elif action == "collect":
             if current_mushroom:
-                coll, hist = engine.collect_current(current_mushroom, collection, self.history)
-                result["data"] = {"collection": coll}
+                try:
+                    coll, hist = engine.collect_current(current_mushroom, collection, self.history)
+                    result["data"] = {"collection": coll}
+                    self.history = hist # Keep track of history
+                except AttributeError:
+                    
+                    result["thought"] = "Collect function not found in engine."
         
         return result