Spaces:
Sleeping
Sleeping
| # 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}" |