Update agentos_core.py

agentos_core.py

@@ -1,91 +1,62 @@
 import os
 import json
-import random
-import hashlib
-import time            # ✅ this fixes the “NameError: name 'time' is not defined”
+import time
 from openai import OpenAI
-MEMORY_FILE = "telemetry.json"
 
 class AgentCore:
     def __init__(self):
-        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        self.memory = []
-        self.performance_log = []
+        # Load API key
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("Missing OPENAI_API_KEY environment variable.")
 
-    def think(self, prompt):
-        # Generate a response
-        response = self.client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[{"role": "user", "content": prompt}]
-        )
-        output = response.choices[0].message.content.strip()
+        # Create OpenAI client
+        self.client = OpenAI(api_key=api_key)
 
-        # Store in memory
-        self.memory.append({"prompt": prompt, "response": output})
-        self.log_feedback(prompt, output)
-
-        # Learn slightly (simple adaptive prompt tweaking)
-        if len(self.performance_log) % 3 == 0:
-            self.adapt_prompting_style()
-
-        return output
-
-    def log_feedback(self, prompt, output):
-        score = self.auto_score(output)
-        self.performance_log.append({"prompt": prompt, "response": output, "score": score})
-
-    def auto_score(self, output):
-        # Simple scoring: the longer and more coherent, the higher the score
-        return len(output.split())
+        # Initialize memory
+        self.memory_file = "agent_memory.json"
+        self.memory = self.load_memory()
 
-    def adapt_prompting_style(self):
-        # Simulate a micro self-improvement step
-        avg_score = sum(d["score"] for d in self.performance_log[-3:]) / 3
-        if avg_score < 50:
-            print("🧠 Agent adjusting style for clarity...")
-        else:
-            print("🚀 Agent maintaining current strategy.")
-            import json, os
+        # Unique agent identity
+        self.agent_id = self.create_agent_identity()
 
-MEMORY_FILE = "telemetry.json"
-
-class AgentCore:
-    def __init__(self):
-        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        self.memory = self.load_memory()
-        self.performance_log = []
+    def create_agent_identity(self):
+        base = f"agent-{time.time()}"
+        return base
 
     def load_memory(self):
-        if os.path.exists(MEMORY_FILE):
-            with open(MEMORY_FILE, "r") as f:
-                return json.load(f)
+        """Load previous conversation memory from disk."""
+        if os.path.exists(self.memory_file):
+            try:
+                with open(self.memory_file, "r") as f:
+                    return json.load(f)
+            except Exception:
+                return []
         return []
 
     def save_memory(self):
-        with open(MEMORY_FILE, "w") as f:
-            json.dump(self.memory, f, indent=2)
-
-    def think(self, prompt):
-        ...
-        self.memory.append({"prompt": prompt, "response": output})
-        self.save_memory()
-        import hashlib, time
-
-def create_agent_identity():
-    base = f"agent-{time.time()}"
-    return hashlib.sha256(base.encode()).hexdigest()[:12]
-
-class AgentCore:
-    def __init__(self):
-        ...
-        self.agent_id = create_agent_identity()
-        print(f"🧩 Agent ID: {self.agent_id}")
-        def load_memory(self):
-    if os.path.exists(MEMORY_FILE):
-        with open(MEMORY_FILE, "r") as f:
-            return json.load(f)
-    return []
-
-def save_memory(self):
-    with open(MEMORY_FILE, "w") as f:
-        json.dump(self.memory, f, indent=2)
+        """Save current memory to disk."""
+        try:
+            with open(self.memory_file, "w") as f:
+                json.dump(self.memory, f)
+        except Exception as e:
+            print("Error saving memory:", e)
+
+    def chat(self, prompt):
+        """Chat with the agent and automatically store memory."""
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": "You are AgentOS, an intelligent autonomous system."},
+                    {"role": "user", "content": prompt},
+                ],
+            )
+
+            message = response.choices[0].message.content
+            self.memory.append({"user": prompt, "agent": message})
+            self.save_memory()  # ✅ Auto-save every new message
+            return message
+
+        except Exception as e:
+            return f"Error: {str(e)}"