npcpy 1.2.17__py3-none-any.whl → 1.2.19__py3-none-any.whl

npcpy/ft/memory_trainer.py

@@ -1,7 +1,10 @@
-import torch
-import torch.nn as nn
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
-from torch.utils.data import Dataset
+try:
+    from torch.utils.data import Dataset
+    import torch
+    import torch.nn as nn
+    from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
+except:
+    pass 
 import json
 from typing import List, Dict, Tuple
 import random

npcpy/memory/memory_processor.py

@@ -17,96 +17,6 @@ class MemoryItem:
     model: str
     provider: str
 
-class MemoryApprovalQueue:
-    def __init__(self, command_history):
-        self.command_history = command_history
-        self.pending_queue = queue.Queue()
-        self.approval_results = queue.Queue()
-        self.processing_thread = None
-        self.running = False
-
-    def add_memory(self, memory_item: MemoryItem):
-        """Add memory to processing queue (non-blocking)"""
-        self.pending_queue.put(memory_item)
-        
-    def start_background_processing(self):
-        """Start background thread for memory processing"""
-        if self.processing_thread and self.processing_thread.is_alive():
-            return
-            
-        self.running = True
-        self.processing_thread = threading.Thread(target=self._process_queue)
-        self.processing_thread.daemon = True
-        self.processing_thread.start()
-
-    def _process_queue(self):
-        """Background processing of memory queue"""
-        while self.running:
-            try:
-                
-                batch = []
-                try:
-                    
-                    memory = self.pending_queue.get(timeout=1.0)
-                    batch.append(memory)
-                    
-                    
-                    while len(batch) < 10:
-                        try:
-                            memory = self.pending_queue.get_nowait()
-                            batch.append(memory)
-                        except queue.Empty:
-                            break
-                    
-                    self._process_memory_batch(batch)
-                    
-                except queue.Empty:
-                    continue
-                    
-            except Exception as e:
-                print(f"Error in memory processing: {e}")
-                time.sleep(1)
-
-    def _process_memory_batch(self, memories: List[MemoryItem]):
-        """Process a batch of memories"""
-        for memory in memories:
-            
-            memory_id = self.command_history.add_memory_to_database(
-                message_id=memory.message_id,
-                conversation_id=memory.conversation_id,
-                npc=memory.npc,
-                team=memory.team,
-                directory_path=memory.directory_path,
-                initial_memory=memory.content,
-                status="pending_approval",
-                model=memory.model,
-                provider=memory.provider
-            )
-            
-            
-            self.approval_results.put({
-                "memory_id": memory_id,
-                "content": memory.content,
-                "context": memory.context,
-                "npc": memory.npc
-            })
-
-    def get_approval_batch(self, max_items: int = 5) -> List[Dict]:
-        """Get batch of memories ready for approval"""
-        batch = []
-        try:
-            while len(batch) < max_items:
-                item = self.approval_results.get_nowait()
-                batch.append(item)
-        except queue.Empty:
-            pass
-        return batch
-
-    def stop_processing(self):
-        """Stop background processing"""
-        self.running = False
-        if self.processing_thread:
-            self.processing_thread.join(timeout=2.0)
 
 def memory_approval_ui(memories: List[Dict]) -> List[Dict]:
     """Simple CLI interface for memory approval"""

npcpy/npc_compiler.py

@@ -26,7 +26,7 @@ from npcpy.npc_sysenv import (
     get_system_message, 
 
     )
-from npcpy.memory.command_history import CommandHistory
+from npcpy.memory.command_history import CommandHistory, generate_message_id
 
 class SilentUndefined(Undefined):
     def _fail_with_undefined_error(self, *args, **kwargs):
@@ -498,7 +498,7 @@ def load_jinxs_from_directory(directory):
     return jinxs
 
 def get_npc_action_space(npc=None, team=None):
-    """Get action space for NPC including memory search, db query, and core capabilities"""
+    """Get action space for NPC including memory CRUD and core capabilities"""
     actions = DEFAULT_ACTION_SPACE.copy()
     
     if npc:
@@ -510,24 +510,35 @@ def get_npc_action_space(npc=None, team=None):
         if npc.command_history:
             core_tools.extend([
                 npc.search_my_conversations,
-                npc.search_my_memories
+                npc.search_my_memories,
+                npc.create_memory,
+                npc.read_memory,
+                npc.update_memory,
+                npc.delete_memory,
+                npc.search_memories,
+                npc.get_all_memories,
+                npc.archive_old_memories,
+                npc.get_memory_stats
             ])
         
         if npc.db_conn:
             core_tools.append(npc.query_database)
         
         if hasattr(npc, 'tools') and npc.tools:
+            core_tools.extend([func for func in npc.tool_map.values() if callable(func)])
+        
+        if core_tools:
             tools_schema, tool_map = auto_tools(core_tools)
             actions.update({
                 f"use_{tool.__name__}": {
-                    "description": extract_function_info(tool).get('description'),
+                    "description": f"Use {tool.__name__} capability",
                     "handler": tool,
                     "context": lambda **_: f"Available as automated capability",
                     "output_keys": {"result": {"description": "Tool execution result", "type": "string"}}
                 }
                 for tool in core_tools
             })
-        
+    
     if team and hasattr(team, 'npcs') and len(team.npcs) > 1:
         available_npcs = [name for name in team.npcs.keys() if name != (npc.name if npc else None)]
         
@@ -537,13 +548,11 @@ def get_npc_action_space(npc=None, team=None):
             return agent_pass_handler(command, extracted_data, **kwargs)
         
         actions["pass_to_npc"] = {
-            "description": "Pass the request to another NPC in the team - BUT ONLY if the task truly requires their specific expertise and you cannot handle it yourself",
+            "description": "Pass request to another NPC - only when task requires their specific expertise",
             "handler": team_aware_handler,
             "context": lambda npc=npc, team=team, **_: (
-                f"Use this SPARINGLY when the request absolutely requires another team member's expertise. "
                 f"Available NPCs: {', '.join(available_npcs)}. "
-                f"IMPORTANT: If you can handle the task yourself with your {npc.name if npc else 'current'} skills, DO NOT pass it. "
-                f"Only pass when you genuinely cannot complete the task due to lack of domain expertise."
+                f"Only pass when you genuinely cannot complete the task."
             ),
             "output_keys": {
                 "target_npc": {
@@ -556,8 +565,6 @@ def get_npc_action_space(npc=None, team=None):
     return actions
 
 
-
-
 def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
     inputs = {}
 
@@ -1074,14 +1081,14 @@ class NPC:
         
     def get_llm_response(self, 
                             request,
-                            jinxs= None,
+                            jinxs=None,
                             tools=None,
-                            tool_map= None,
+                            tool_map=None,
                             tool_choice=None, 
-                            messages: Optional[List[Dict[str, str]]] = None,
-                            auto_process_tool_calls: bool = True,
+                            messages=None,
+                            auto_process_tool_calls=True,
                             **kwargs):
-        """Get a response from the LLM with automatic tool integration"""
+        """Get response from LLM with automatic tool integration including memory CRUD"""
         
         if tools is None and tool_map is None and tool_choice is None:
             core_tools = [
@@ -1092,7 +1099,15 @@ class NPC:
             if self.command_history:
                 core_tools.extend([
                     self.search_my_conversations,
-                    self.search_my_memories
+                    self.search_my_memories,
+                    self.create_memory,
+                    self.read_memory, 
+                    self.update_memory,
+                    self.delete_memory,
+                    self.search_memories,
+                    self.get_all_memories,
+                    self.archive_old_memories,
+                    self.get_memory_stats
                 ])
             
             if self.db_conn:
@@ -1122,6 +1137,7 @@ class NPC:
         )        
         
         return response
+
     
 
 
@@ -1674,7 +1690,7 @@ class NPC:
 
 
 
-    def execute_jinx_command(
+    def execute_jinx_command(self, 
         jinx: Jinx,
         args: List[str],
         messages=None,
@@ -1695,6 +1711,159 @@ class NPC:
         )
 
         return {"messages": messages, "output": jinx_output}
+    def create_memory(self, content: str, memory_type: str = "observation") -> Optional[int]:
+        """Create a new memory entry"""
+        if not self.command_history:
+            return None
+        
+        message_id = generate_message_id()
+        conversation_id = self.command_history.get_most_recent_conversation_id()
+        conversation_id = conversation_id.get('conversation_id') if conversation_id else 'direct_memory'
+        
+        team_name = getattr(self.team, 'name', 'default_team') if self.team else 'default_team'
+        directory_path = os.getcwd()
+        
+        return self.command_history.add_memory_to_database(
+            message_id=message_id,
+            conversation_id=conversation_id,
+            npc=self.name,
+            team=team_name,
+            directory_path=directory_path,
+            initial_memory=content,
+            status='active',
+            model=self.model,
+            provider=self.provider
+        )
+
+    def read_memory(self, memory_id: int) -> Optional[Dict[str, Any]]:
+        """Read a specific memory by ID"""
+        if not self.command_history:
+            return None
+        
+        stmt = "SELECT * FROM memory_lifecycle WHERE id = :memory_id"
+        return self.command_history._fetch_one(stmt, {"memory_id": memory_id})
+
+    def update_memory(self, memory_id: int, new_content: str = None, status: str = None) -> bool:
+        """Update memory content or status"""
+        if not self.command_history:
+            return False
+        
+        updates = []
+        params = {"memory_id": memory_id}
+        
+        if new_content is not None:
+            updates.append("final_memory = :final_memory")
+            params["final_memory"] = new_content
+        
+        if status is not None:
+            updates.append("status = :status") 
+            params["status"] = status
+        
+        if not updates:
+            return False
+        
+        stmt = f"UPDATE memory_lifecycle SET {', '.join(updates)} WHERE id = :memory_id"
+        
+        try:
+            with self.command_history.engine.begin() as conn:
+                conn.execute(text(stmt), params)
+            return True
+        except Exception as e:
+            print(f"Error updating memory {memory_id}: {e}")
+            return False
+
+    def delete_memory(self, memory_id: int) -> bool:
+        """Delete a memory by ID"""
+        if not self.command_history:
+            return False
+        
+        stmt = "DELETE FROM memory_lifecycle WHERE id = :memory_id AND npc = :npc"
+        
+        try:
+            with self.command_history.engine.begin() as conn:
+                result = conn.execute(text(stmt), {"memory_id": memory_id, "npc": self.name})
+                return result.rowcount > 0
+        except Exception as e:
+            print(f"Error deleting memory {memory_id}: {e}")
+            return False
+
+    def search_memories(self, query: str, limit: int = 10, status_filter: str = None) -> List[Dict[str, Any]]:
+        """Search memories with optional status filtering"""
+        if not self.command_history:
+            return []
+        
+        team_name = getattr(self.team, 'name', 'default_team') if self.team else 'default_team'
+        directory_path = os.getcwd()
+        
+        return self.command_history.search_memory(
+            query=query,
+            npc=self.name,
+            team=team_name,
+            directory_path=directory_path,
+            status_filter=status_filter,
+            limit=limit
+        )
+
+    def get_all_memories(self, limit: int = 50, status_filter: str = None) -> List[Dict[str, Any]]:
+        """Get all memories for this NPC with optional status filtering"""
+        if not self.command_history:
+            return []
+        
+        if limit is None:
+            limit = 50
+        
+        conditions = ["npc = :npc"]
+        params = {"npc": self.name, "limit": limit}
+        
+        if status_filter:
+            conditions.append("status = :status")
+            params["status"] = status_filter
+        
+        stmt = f"""
+            SELECT * FROM memory_lifecycle 
+            WHERE {' AND '.join(conditions)}
+            ORDER BY created_at DESC 
+            LIMIT :limit
+            """
+        
+        return self.command_history._fetch_all(stmt, params)
+
+
+    def archive_old_memories(self, days_old: int = 30) -> int:
+        """Archive memories older than specified days"""
+        if not self.command_history:
+            return 0
+        
+        stmt = """
+            UPDATE memory_lifecycle 
+            SET status = 'archived' 
+            WHERE npc = :npc 
+            AND status = 'active'
+            AND datetime(created_at) < datetime('now', '-{} days')
+        """.format(days_old)
+        
+        try:
+            with self.command_history.engine.begin() as conn:
+                result = conn.execute(text(stmt), {"npc": self.name})
+                return result.rowcount
+        except Exception as e:
+            print(f"Error archiving memories: {e}")
+            return 0
+
+    def get_memory_stats(self) -> Dict[str, int]:
+        """Get memory statistics for this NPC"""
+        if not self.command_history:
+            return {}
+        
+        stmt = """
+            SELECT status, COUNT(*) as count
+            FROM memory_lifecycle 
+            WHERE npc = :npc
+            GROUP BY status
+        """
+        
+        results = self.command_history._fetch_all(stmt, {"npc": self.name})
+        return {row['status']: row['count'] for row in results}
 
 
 class Team:

{npcpy-1.2.17.dist-info → npcpy-1.2.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.17
+Version: 1.2.19
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.2.17.dist-info → npcpy-1.2.19.dist-info}/RECORD

@@ -1,7 +1,7 @@
 npcpy/__init__.py,sha256=9imxFtK74_6Rw9rz0kyMnZYl_voPb569tkTlYLt0Urg,131
 npcpy/llm_funcs.py,sha256=tvcZuQEcIUJClwEJQXBF6ArEVjSuXt1jAcZOcnYWsVQ,85101
 npcpy/main.py,sha256=RWoRIj6VQLxKdOKvdVyaq2kwG35oRpeXPvp1CAAoG-w,81
-npcpy/npc_compiler.py,sha256=kTkfhxc-B5r0O4DpUIqk51WWkmn3FMJNddp-Npanx60,86218
+npcpy/npc_compiler.py,sha256=BpNlrjwkxhERTrFeFtvv9CUqzULoD2JQuEwRtqwQHLY,92107
 npcpy/npc_sysenv.py,sha256=lPYlKM_TeR4l4-Jcgiqq3CCge8b2oFHdfISD4L_G7eo,30308
 npcpy/npcs.py,sha256=eExuVsbTfrRobTRRptRpDm46jCLWUgbvy4_U7IUQo-c,744
 npcpy/serve.py,sha256=RPYT3ZMu-OmO6dg3Ss04wZQNlZQive5cm2UPUbtToV0,100271
@@ -17,7 +17,7 @@ npcpy/data/web.py,sha256=ARGoVKUlQmaiX0zJbSvvFmRCwOv_Z7Pcan9c5GxYObQ,5117
 npcpy/ft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 npcpy/ft/diff.py,sha256=R3Qo6v0-6M1iI0wiXhUzyuYI2ja0q_0i9bE0z3coxzU,28
 npcpy/ft/ge.py,sha256=my5LtGyVTT40V0i1h9FR-tFFA1FHSga-PeCCgUX1UUI,61
-npcpy/ft/memory_trainer.py,sha256=9FLZPfVB1Ibi1IWf498U_T9sGC7GlBBuYl6BYO5Y27s,5865
+npcpy/ft/memory_trainer.py,sha256=410BtNj308c7V45E809ILbDjCnVRy7n0mdIp2DKOCNY,5904
 npcpy/ft/rl.py,sha256=l3RUkEJe4b2yB6pildveu2LJymtNq0F17COwf_CCq3U,34
 npcpy/ft/sft.py,sha256=i4ENygRPArbLWN4XZZuBnPWaehs8M-J68JB_mewGJHI,62
 npcpy/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,7 +30,7 @@ npcpy/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 npcpy/memory/command_history.py,sha256=Ww7vZTSjQDuElQXuOjsvu7NTljOLAg07QIFrfKARpVg,45562
 npcpy/memory/kg_vis.py,sha256=TrQQCRh_E7Pyr-GPAHLSsayubAfGyf4HOEFrPB6W86Q,31280
 npcpy/memory/knowledge_graph.py,sha256=2XpIlsyPdAOnzQ6kkwP6MWPGwL3P6V33_3suNJYMMJE,48681
-npcpy/memory/memory_processor.py,sha256=nK5vWTLeevAQDXM15wF9MSTK6Yr-qYCjgiwmCKXWTSI,5288
+npcpy/memory/memory_processor.py,sha256=bLfzT-uDgwNegs1hVBqW3Hl2fYtdmFQbdc5To_f4i5E,2106
 npcpy/memory/search.py,sha256=glN6WYzaixcoDphTEHAXSMX3vKZGjR12Jx9YVL_gYfE,18433
 npcpy/mix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 npcpy/mix/debate.py,sha256=lQXxC7nl6Rwyf7HIYrsVQILMUmYYx55Tjt2pkTg56qY,9019
@@ -41,8 +41,8 @@ npcpy/work/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 npcpy/work/desktop.py,sha256=F3I8mUtJp6LAkXodsh8hGZIncoads6c_2Utty-0EdDA,2986
 npcpy/work/plan.py,sha256=QyUwg8vElWiHuoS-xK4jXTxxHvkMD3VkaCEsCmrEPQk,8300
 npcpy/work/trigger.py,sha256=P1Y8u1wQRsS2WACims_2IdkBEar-iBQix-2TDWoW0OM,9948
-npcpy-1.2.17.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcpy-1.2.17.dist-info/METADATA,sha256=-WglQgBsbujF70Yr1Zp1HTzPPGzJ28iHxLUetPgLs34,26084
-npcpy-1.2.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcpy-1.2.17.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
-npcpy-1.2.17.dist-info/RECORD,,
+npcpy-1.2.19.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.2.19.dist-info/METADATA,sha256=dnJPjMvml-0yrEJXUt9g-Rf-UT9mIXuQR3HJZzYgm18,26084
+npcpy-1.2.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcpy-1.2.19.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.2.19.dist-info/RECORD,,