Update app.py

app.py

@@ -76,20 +76,6 @@ function sendMessage() {
 ######
 
 import asyncio
-import queue
-import threading
-import random
-import time
-from fastapi import FastAPI, WebSocket
-from fastapi.responses import HTMLResponse
-import uvicorn
-
-# FastAPI App
-app = FastAPI()
-
-import asyncio
-import queue
-import threading
 import random
 import time
 from fastapi import FastAPI, WebSocket
@@ -99,128 +85,82 @@ import uvicorn
 class AIStateManager:
     def __init__(self):
         self.state = "awake"
-        self.msg_queue = asyncio.Queue()  # Use asyncio.Queue for async operations
+        self.research_tasks = ["Explore AI Ethics", "Find latest AI models", "Investigate quantum computing"]
+        self.current_task = None
         self.heartbeat_count = 0
-        self.lock = asyncio.Lock()  # Use asyncio.Lock for async locking
-        self.clients = set()  # Set to store WebSocket clients
+        self.clients = set()
 
     async def set_state(self, new_state):
-        async with self.lock:
-            print(f"[STATE CHANGE] {self.state} → {new_state}")
-            self.state = new_state
-            await self.add_message("system", f"State changed to {new_state}")
-
-    async def receive_message(self, sender, message):
-        """Adds messages to queue and resets heartbeat if human sends input."""
-        async with self.lock:
-            await self.msg_queue.put((sender, message))
-            if sender == "human":
-                self.heartbeat_count = 0
-                if self.state != "awake":
-                    await self.set_state("awake")
-
-    async def add_message(self, sender, message):
-        """AI or System can add messages to queue."""
-        await self.msg_queue.put((sender, message))
-
-    async def process_messages(self):
-        """Processes messages in queue."""
-        while not self.msg_queue.empty():
-            sender, message = await self.msg_queue.get()
-            print(f"[{sender.upper()}] {message}")
-            await self.broadcast(f"[{sender.upper()}] {message}")
+        """Thread-safe state change with logging."""
+        print(f"[STATE CHANGE] {self.state} → {new_state}")
+        self.state = new_state
+        await self.broadcast(f"State changed to {new_state}")
 
     async def broadcast(self, message):
-        """Sends message to all connected WebSocket clients."""
-        print(f"Broadcasting: {message}")
-        for client in list(self.clients):  # Create a copy to avoid runtime modification
+        """Broadcast message to all connected clients."""
+        for client in list(self.clients):
             try:
                 await client.send_text(message)
             except Exception as e:
-                print(f"Error broadcasting to client: {e}")
+                print(f"Broadcast error: {e}")
                 self.clients.remove(client)
 
-    async def heartbeat(self):
-        """Basic heartbeat loop."""
+    async def research_cycle(self):
+        """Manages research state tasks."""
         while True:
-            await asyncio.sleep(1)  # One 'beat'
-            async with self.lock:
+            await asyncio.sleep(5)  # Longer interval for visibility
+            
+            # State-based logic
+            if self.state == "awake":
                 self.heartbeat_count += 1
-                await self.process_messages()
-
-    async def consciousness(self):
-        """Controls research/sleep cycle."""
-        while True:
-            print("Consciousness cycle")
-            await self.broadcast("Consciousness cycle...")
-            await asyncio.sleep(2)  # Consciousness checks every 2 sec
-            async with self.lock:
-                if self.state == "awake":
-                    if self.heartbeat_count >= 5:
-                        await self.set_state("research")
-                        asyncio.create_task(self.run_research())
-
-                elif self.state == "research":
-                    if not self.research_tasks:  # If no tasks left, move to sleep
-                        await self.set_state("sleeping")
-                        asyncio.create_task(self.run_sleeping())
-
-                elif self.state == "sleeping":
-                    if self.heartbeat_count >= 20:
-                        await self.set_state("research")  # Restart research after sleep
-                        asyncio.create_task(self.run_research())
-                print(self.state)
+                if self.heartbeat_count >= 3:
+                    await self.set_state("research")
+            
+            elif self.state == "research":
+                if self.research_tasks:
+                    task = self.research_tasks.pop(0)
+                    await self.broadcast(f"Researching: {task}")
+                    
+                    # Simulate task work
+                    await asyncio.sleep(3)
+                    
+                    # Random chance of generating follow-up
+                    if random.random() < 0.3:
+                        await self.broadcast(f"Question about {task}")
+                else:
+                    await self.set_state("sleeping")
+            
+            elif self.state == "sleeping":
+                await self.broadcast("System in sleep mode")
+                await asyncio.sleep(10)  # Longer sleep
                 
-    async def run_research(self):
-        """Runs research tasks in order."""
-        while self.state == "research" and self.research_tasks:
-            await asyncio.sleep(3)
-            self.current_task = self.research_tasks.pop(0)
-            self.add_message("ai", f"Researching: {self.current_task}")
-            if random.random() < 0.3:  # AI might ask a follow-up question
-                self.add_message("ai", f"Question: What do you think about {self.current_task}?")
-            self.process_messages()
-
-    async def run_sleeping(self):
-        """Runs self-training until state changes."""
-        while self.state == "sleeping":
-            await asyncio.sleep(5)
-            self.add_message("system", "Self-training in progress...")
-            self.process_messages()
-
-    def modify_research_tasks(self):
-        """Background process to edit research tasks dynamically (subconscious)."""
-        while True:
-            time.sleep(10)  # Runs every 10 seconds
-            with self.lock:
-                if self.state == "research" and random.random() < 0.5:
-                    new_task = f"Investigate {random.choice(['AI Bias', 'Neural Networks', 'Data Privacy'])}"
-                    self.research_tasks.append(new_task)
-                    self.add_message("system", f"New research task added: {new_task}")
-
-# Initialize AI Manager
-ai_manager = AIStateManager()
+                # Reset after sleep
+                self.research_tasks = ["Explore AI Ethics", "Find latest AI models", "Investigate quantum computing"]
+                await self.set_state("awake")
+                self.heartbeat_count = 0
 
-# Start Heartbeat and Consciousness in separate threads
-threading.Thread(target=lambda: asyncio.run(ai_manager.heartbeat()), daemon=True).start()
-threading.Thread(target=lambda: asyncio.run(ai_manager.consciousness()), daemon=True).start()
-threading.Thread(target=ai_manager.modify_research_tasks, daemon=True).start()
+# FastAPI Setup
+app = FastAPI()
+ai_manager = AIStateManager()
 
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
     await websocket.accept()
-    print("Initial message sent to WebSocket") 
-
-    ai_manager.clients.add(websocket)  # Add client to set
+    ai_manager.clients.add(websocket)
     try:
         while True:
             data = await websocket.receive_text()
-            print(f"BACKEND RECEIVED: {data}")
-            await ai_manager.receive_message("human", data)
+            await ai_manager.broadcast(f"Received: {data}")
     except Exception as e:
         print(f"WebSocket error: {e}")
     finally:
-        ai_manager.clients.remove(websocket)  # Remove client when connection closes
+        ai_manager.clients.remove(websocket)
+
+@app.on_event("startup")
+async def startup_event():
+    """Start research cycle on app startup."""
+    asyncio.create_task(ai_manager.research_cycle())
+     
 
 @app.get("/")
 async def get():