Create agentos_core_v4.py

agentos_core_v4.py

@@ -0,0 +1,121 @@
+# agentos_core_v4.py
+import re
+from identity_core import create_agent_identity
+from telemetry import Telemetry
+from memory import MemoryManager
+from context_graph import ContextGraph
+from semantic_memory import SemanticMemory
+from summarizer import MemorySummarizer
+from emotion_core import EmotionAnalyzer
+from personality_state import PersonalityState
+
+def _categorize(prompt: str) -> str:
+    p = prompt.lower()
+    if any(k in p for k in ["goal","ambition","plan","target","dream"]): return "goals"
+    if any(k in p for k in ["friend","person","mentor","team","contact","customer"]): return "people"
+    if any(k in p for k in ["favorite","like","love","prefer"]): return "preferences"
+    if any(k in p for k in ["city","food","color","age","birthday"]): return "personal"
+    return "general"
+
+def _is_user_fact(p: str) -> bool:
+    return bool(re.match(r"^\s*(my|i|i'm|i am|i like)\b", p.strip().lower()))
+
+class AgentCore:
+    def __init__(self, model="gpt-4o-mini"):
+        self.agent_id = create_agent_identity()
+        self.telemetry = Telemetry(self.agent_id)
+        self.memory = MemoryManager(self.agent_id)
+        self.context = ContextGraph()
+        self.semantic = SemanticMemory(self.agent_id)
+        self.summarizer = MemorySummarizer("semantic_memory.json")
+        self.emotions = EmotionAnalyzer()
+        self.personality = PersonalityState(self.agent_id)
+        self.model = model
+        self.telemetry.log("init", "success", {"agent_id": self.agent_id})
+        print(f"[INIT] Agent {self.agent_id} initialized with model {self.model}")
+
+    def _humanize_hits(self, hits):
+        phrasings = []
+        for h in hits:
+            t = h["text"].strip()
+            t = t.replace("My ", "Your ").replace("my ", "your ")
+            t = t.replace("I am ", "You are ").replace("I'm ", "You're ")
+            phrasings.append(t.rstrip("."))
+        # dedupe keep order
+        seen = set(); nice = []
+        for p in phrasings:
+            if p not in seen:
+                seen.add(p); nice.append(p)
+        return nice
+
+    def run(self, prompt: str):
+        self.telemetry.log("run_start", "in_progress", {"prompt": prompt})
+
+        # Phase 4 triggers: summarization / personality profile
+        lower = prompt.lower()
+        if any(t in lower for t in ["summarize", "what do you know", "who am i", "list everything", "recall memory"]):
+            summary = self.summarizer.summarize()
+            prof = self.personality.summary()
+            response = f"{summary}\n\n{prof}"
+            self.memory.save({"prompt": prompt, "response": response})
+            self.telemetry.log("run_complete", "success", {"response": response})
+            print(f"[RUN] {response}")
+            return response
+
+        if any(t in lower for t in ["personality", "profile", "how do i come across", "what's my vibe", "what is my vibe"]):
+            response = self.personality.summary()
+            self.memory.save({"prompt": prompt, "response": response})
+            self.telemetry.log("run_complete", "success", {"response": response})
+            print(f"[RUN] {response}")
+            return response
+
+        try:
+            category = _categorize(prompt)
+
+            # 1) emotion analysis + personality update
+            emo = self.emotions.analyze(prompt)
+            if emo["trait_deltas"]:
+                note = f"tags={emo['tags']}, sentiment={emo['sentiment']:.2f}, arousal={emo['arousal']:.2f}"
+                self.personality.apply_deltas(emo["trait_deltas"], note=note)
+
+            # 2) fact intake → write to memories
+            if _is_user_fact(prompt):
+                # store in both graphs
+                try:
+                    self.context.link_context(self.agent_id, category, prompt, "stored")
+                except TypeError:
+                    self.context.link_context(self.agent_id, prompt, "stored")
+                self.semantic.add(text=prompt, category=category)
+                response = f"Noted — I’ll remember that under {category}."
+            else:
+                # 3) vector recall first
+                hits = self.semantic.query(query_text=prompt, category=None if "all" in lower else category, top_k=5)
+                if hits:
+                    nice = self._humanize_hits(hits)[:3]
+                    response = "From memory: " + "; ".join(nice) + "."
+                else:
+                    # 4) fallback to context graph
+                    if hasattr(self.context, "query_context"):
+                        cg = self.context.query_context(self.agent_id, keyword=None, category=category)
+                        if cg and cg != ["No context found."]:
+                            response = "From context: " + " ".join(cg[:3])
+                        else:
+                            response = f"Agent {self.agent_id} processed: {prompt}"
+                    else:
+                        response = f"Agent {self.agent_id} processed: {prompt}"
+
+            # 5) persist + telemetry
+            self.memory.save({"prompt": prompt, "response": response, "emotion": emo})
+            try:
+                self.context.link_context(self.agent_id, category, prompt, response)
+            except TypeError:
+                self.context.link_context(self.agent_id, prompt, response)
+
+            self.telemetry.log("run_complete", "success", {"response": response})
+            print(f"[RUN] {response}")
+            return response
+
+        except Exception as e:
+            self.telemetry.log("run_failed", "error", {"error": str(e)})
+            print(f"[ERROR] {e}")
+            return f"Error: {e}"