Create agentos_core_v3.py

agentos_core_v3.py

@@ -0,0 +1,84 @@
+import re
+from memory import MemoryManager
+from context_graph import ContextGraph
+from telemetry import Telemetry
+from identity_core import create_agent_identity
+from semantic_memory import SemanticMemory
+
+def _categorize(prompt: str) -> str:
+    p = prompt.lower()
+    if any(k in p for k in ["goal", "ambition", "plan", "target"]): return "goals"
+    if any(k in p for k in ["friend", "person", "mentor", "team", "contact"]): 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)  # 🔥 vector memory
+        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 run(self, prompt: str):
+        self.telemetry.log("run_start", "in_progress", {"prompt": prompt})
+        try:
+            category = _categorize(prompt)
+
+            # 1) If user is stating a fact → write to both memories
+            if _is_user_fact(prompt):
+                self.context.link_context(self.agent_id, category, prompt, "stored")
+                self.semantic.add(text=prompt, category=category)
+                response = f"Noted — I’ll remember that under {category}."
+            else:
+                # 2) Query vector memory (semantic) first
+                hits = self.semantic.query(query_text=prompt, category=None if "all" in prompt.lower() else category, top_k=5)
+
+                if hits:
+                    # Humanize top results
+                    phrasings = []
+                    for h in hits:
+                        t = h["text"].strip()
+                        # convert “My … is …” → “Your … is …”
+                        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 while preserving order
+                    seen = set(); nice = []
+                    for ptxt in phrasings:
+                        if ptxt not in seen:
+                            seen.add(ptxt); nice.append(ptxt)
+                    joined = "; ".join(nice[:3])
+                    response = f"From memory: {joined}."
+                else:
+                    # 3) Fallback to classic context graph keyword recall
+                    cg = self.context.query_context(self.agent_id, keyword=None, category=category) if hasattr(self.context, "query_context") else []
+                    if cg and cg != ["No context found."]:
+                        response = "From context: " + " ".join(cg[:3])
+                    else:
+                        response = f"Agent {self.agent_id} processed: {prompt}"
+
+            # 4) Persist trace + link
+            self.memory.save({"prompt": prompt, "response": response})
+            # keep a lightweight index of Q→A strings in the graph
+            try:
+                self.context.link_context(self.agent_id, category, prompt, response)
+            except TypeError:
+                # backward-compat signature (agent_id, key, value)
+                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}"