npcpy 1.2.15__tar.gz → 1.2.16__tar.gz

{npcpy-1.2.15/npcpy.egg-info → npcpy-1.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.15
+Version: 1.2.16
 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.16/npcpy/ft/diff.py

@@ -0,0 +1 @@
+# finetuning diffuser models

npcpy-1.2.16/npcpy/ft/ge.py

@@ -0,0 +1 @@
+# genetic engineering for using genetic algorithms with LLMs 

npcpy-1.2.16/npcpy/ft/memory_trainer.py

@@ -0,0 +1,161 @@
+import torch
+import torch.nn as nn
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
+from torch.utils.data import Dataset
+import json
+from typing import List, Dict, Tuple
+import random
+
+class MemoryDataset(Dataset):
+    def __init__(self, examples: List[Dict], tokenizer, max_length=512):
+        self.examples = examples
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+    
+    def __len__(self):
+        return len(self.examples)
+    
+    def __getitem__(self, idx):
+        example = self.examples[idx]
+        
+        
+        text = f"Memory: {example['memory']}\nContext: {example.get('context', '')}"
+        
+        encoding = self.tokenizer(
+            text,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_length,
+            return_tensors='pt'
+        )
+        
+        return {
+            'input_ids': encoding['input_ids'].flatten(),
+            'attention_mask': encoding['attention_mask'].flatten(),
+            'labels': torch.tensor(example['label'], dtype=torch.long)
+        }
+
+class MemoryTrainer:
+    def __init__(self, model_name="google/gemma-2b", device="cpu"):
+        self.device = device
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+        
+        
+        self.model = AutoModelForSequenceClassification.from_pretrained(
+            model_name, 
+            num_labels=3
+        ).to(device)
+    
+    def prepare_training_data(self, approved_memories: List[Dict], 
+                            rejected_memories: List[Dict]) -> List[Dict]:
+        """Prepare training data from memory examples"""
+        examples = []
+        
+        
+        for memory in approved_memories:
+            examples.append({
+                "memory": memory.get("final_memory") or memory.get("initial_memory"),
+                "context": memory.get("context", ""),
+                "label": 1
+            })
+        
+        
+        for memory in rejected_memories:
+            examples.append({
+                "memory": memory.get("initial_memory"),
+                "context": memory.get("context", ""),
+                "label": 0
+            })
+        
+        
+        edited_examples = []
+        for memory in approved_memories[:len(rejected_memories)//2]:
+            if memory.get("final_memory") and memory.get("initial_memory"):
+                
+                edited_examples.append({
+                    "memory": memory.get("initial_memory"),
+                    "context": memory.get("context", ""),
+                    "label": 2
+                })
+        
+        examples.extend(edited_examples)
+        random.shuffle(examples)
+        return examples
+
+    def train(self, approved_memories: List[Dict], rejected_memories: List[Dict], 
+              output_dir: str = "./memory_model", epochs: int = 3):
+        """Train the memory classification model"""
+        
+        if len(approved_memories) < 10 or len(rejected_memories) < 10:
+            print("Not enough training data. Need at least 10 approved and 10 rejected memories.")
+            return False
+        
+        training_data = self.prepare_training_data(approved_memories, rejected_memories)
+        
+        
+        split_idx = int(0.8 * len(training_data))
+        train_data = training_data[:split_idx]
+        val_data = training_data[split_idx:]
+        
+        train_dataset = MemoryDataset(train_data, self.tokenizer)
+        val_dataset = MemoryDataset(val_data, self.tokenizer)
+        
+        training_args = TrainingArguments(
+            output_dir=output_dir,
+            num_train_epochs=epochs,
+            per_device_train_batch_size=4,
+            per_device_eval_batch_size=4,
+            warmup_steps=100,
+            weight_decay=0.01,
+            logging_dir='./logs',
+            evaluation_strategy="epoch",
+            save_strategy="epoch",
+            load_best_model_at_end=True,
+        )
+        
+        trainer = Trainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=train_dataset,
+            eval_dataset=val_dataset,
+        )
+        
+        trainer.train()
+        trainer.save_model()
+        self.tokenizer.save_pretrained(output_dir)
+        
+        print(f"Model trained and saved to {output_dir}")
+        return True
+
+    def predict_memory_action(self, memory_content: str, context: str = "") -> Tuple[str, float]:
+        """Predict what action to take on a memory"""
+        text = f"Memory: {memory_content}\nContext: {context}"
+        
+        encoding = self.tokenizer(
+            text,
+            truncation=True,
+            padding=True,
+            max_length=512,
+            return_tensors='pt'
+        ).to(self.device)
+        
+        with torch.no_grad():
+            outputs = self.model(**encoding)
+            probabilities = torch.softmax(outputs.logits, dim=-1)
+            predicted_class = torch.argmax(probabilities, dim=-1).item()
+            confidence = probabilities[0][predicted_class].item()
+        
+        actions = {0: "model-rejected", 1: "model-approved", 2: "needs-editing"}
+        return actions[predicted_class], confidence
+
+    def auto_approve_memory(self, memory_content: str, context: str = "", 
+                          confidence_threshold: float = 0.8) -> Dict:
+        """Auto-approve memory if confidence is high enough"""
+        action, confidence = self.predict_memory_action(memory_content, context)
+        
+        if confidence >= confidence_threshold:
+            return {"action": action, "confidence": confidence, "auto_processed": True}
+        else:
+            return {"action": "pending_approval", "confidence": confidence, "auto_processed": False}

npcpy-1.2.16/npcpy/ft/rl.py

@@ -0,0 +1 @@
+# tools for reinforcement learning

npcpy-1.2.16/npcpy/ft/sft.py

@@ -0,0 +1 @@
+# structured fine tuning of LLMs to produce structured output

{npcpy-1.2.15 → npcpy-1.2.16}/npcpy/memory/command_history.py

@@ -8,7 +8,7 @@ import numpy as np
 
 try:
     import sqlalchemy
-    from sqlalchemy import create_engine, text, MetaData, Table, Column, Integer, String, Text, DateTime, LargeBinary, ForeignKey, Boolean
+    from sqlalchemy import create_engine, text, MetaData, Table, Column, Integer, String, Text, DateTime, LargeBinary, ForeignKey, Boolean, func
     from sqlalchemy.engine import Engine, Connection as SQLAlchemyConnection
     from sqlalchemy.exc import SQLAlchemyError
     from sqlalchemy.sql import select, insert, update, delete
@@ -477,6 +477,22 @@ class CommandHistory:
             Column('duration_ms', Integer)
         )
         
+        Table('memory_lifecycle', metadata,
+            Column('id', Integer, primary_key=True, autoincrement=True),
+            Column('message_id', String(50), nullable=False),
+            Column('conversation_id', String(100), nullable=False),
+            Column('npc', String(100), nullable=False),
+            Column('team', String(100), nullable=False),
+            Column('directory_path', Text, nullable=False),
+            Column('timestamp', String(50), nullable=False),
+            Column('initial_memory', Text, nullable=False),
+            Column('final_memory', Text),
+            Column('status', String(50), nullable=False),
+            Column('model', String(100)),
+            Column('provider', String(100)),
+            Column('created_at', DateTime, default=func.now())
+        )
+                
         
         metadata.create_all(self.engine, checkfirst=True)
         
@@ -580,6 +596,119 @@ class CommandHistory:
 
         return message_id
 
+    def add_memory_to_database(self, message_id: str, conversation_id: str, npc: str, team: str, 
+                            directory_path: str, initial_memory: str, status: str, 
+                            model: str = None, provider: str = None, final_memory: str = None):
+        """Store a memory entry in the database"""
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
+        stmt = """
+            INSERT INTO memory_lifecycle 
+            (message_id, conversation_id, npc, team, directory_path, datetime, 
+            initial_memory, final_memory, status, model, provider)
+            VALUES (:message_id, :conversation_id, :npc, :team, :directory_path, 
+                    :datetime, :initial_memory, :final_memory, :status, :model, :provider)
+        """
+        
+        params = {
+            "message_id": message_id, "conversation_id": conversation_id,
+            "npc": npc, "team": team, "directory_path": directory_path,
+            "datetime": timestamp, "initial_memory": initial_memory,
+            "final_memory": final_memory, "status": status,
+            "model": model, "provider": provider
+        }
+        
+        return self._execute_returning_id(stmt, params)
+
+    def search_memory(self, query: str, npc: str = None, team: str = None, 
+                    directory_path: str = None, status_filter: str = None, limit: int = 10):
+        """Search memories with hierarchical scope"""
+        conditions = ["LOWER(initial_memory) LIKE LOWER(:query) OR LOWER(final_memory) LIKE LOWER(:query)"]
+        params = {"query": f"%{query}%"}
+        
+        if status_filter:
+            conditions.append("status = :status")
+            params["status"] = status_filter
+        
+        
+        order_parts = []
+        if npc:
+            order_parts.append(f"CASE WHEN npc = '{npc}' THEN 1 ELSE 2 END")
+        if team:
+            order_parts.append(f"CASE WHEN team = '{team}' THEN 1 ELSE 2 END")
+        if directory_path:
+            order_parts.append(f"CASE WHEN directory_path = '{directory_path}' THEN 1 ELSE 2 END")
+        
+        order_clause = ", ".join(order_parts) + ", created_at DESC" if order_parts else "created_at DESC"
+        
+        stmt = f"""
+            SELECT * FROM memory_lifecycle 
+            WHERE {' AND '.join(conditions)}
+            ORDER BY {order_clause}
+            LIMIT :limit
+        """
+        params["limit"] = limit
+        
+        return self._fetch_all(stmt, params)
+
+    def get_memory_examples_for_context(self, npc: str, team: str, directory_path: str,
+                                    n_approved: int = 10, n_rejected: int = 10):
+        """Get recent approved and rejected memories for learning context"""
+        
+        approved_stmt = """
+            SELECT initial_memory, final_memory, status FROM memory_lifecycle
+            WHERE status IN ('human-approved', 'model-approved')
+            ORDER BY 
+                CASE WHEN npc = :npc AND team = :team AND directory_path = :path THEN 1
+                    WHEN npc = :npc AND team = :team THEN 2  
+                    WHEN team = :team THEN 3
+                    ELSE 4 END,
+                created_at DESC
+            LIMIT :n_approved
+        """
+        
+        rejected_stmt = """
+            SELECT initial_memory, status FROM memory_lifecycle
+            WHERE status IN ('human-rejected', 'model-rejected')
+            ORDER BY 
+                CASE WHEN npc = :npc AND team = :team AND directory_path = :path THEN 1
+                    WHEN npc = :npc AND team = :team THEN 2
+                    WHEN team = :team THEN 3  
+                    ELSE 4 END,
+                created_at DESC
+            LIMIT :n_rejected
+        """
+        
+        params = {"npc": npc, "team": team, "path": directory_path, 
+                "n_approved": n_approved, "n_rejected": n_rejected}
+        
+        approved = self._fetch_all(approved_stmt, params)
+        rejected = self._fetch_all(rejected_stmt, params)
+        
+        return {"approved": approved, "rejected": rejected}
+
+    def get_pending_memories(self, limit: int = 50):
+        """Get memories pending human approval"""
+        stmt = """
+            SELECT * FROM memory_lifecycle 
+            WHERE status = 'pending_approval'
+            ORDER BY created_at ASC
+            LIMIT :limit
+        """
+        return self._fetch_all(stmt, {"limit": limit})
+
+    def update_memory_status(self, memory_id: int, new_status: str, final_memory: str = None):
+        """Update memory status and optionally final_memory"""
+        stmt = """
+            UPDATE memory_lifecycle 
+            SET status = :status, final_memory = :final_memory
+            WHERE id = :memory_id
+        """
+        params = {"status": new_status, "final_memory": final_memory, "memory_id": memory_id}
+        
+        with self.engine.begin() as conn:
+            conn.execute(text(stmt), params)
+            
     def add_attachment(self, message_id, name, attachment_type, data, size, file_path=None):
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         stmt = """

{npcpy-1.2.15 → npcpy-1.2.16}/npcpy/memory/knowledge_graph.py

@@ -329,9 +329,9 @@ def kg_initial(content,
     }
 
 
-
 def kg_evolve_incremental(existing_kg, 
-                          new_content_text, 
+                          new_content_text=None,
+                          new_facts=None, 
                           model = None, 
                           provider=None, 
                           npc=None, 
@@ -340,15 +340,12 @@ def kg_evolve_incremental(existing_kg,
                           link_concepts_facts = False, 
                           link_concepts_concepts=False, 
                           link_facts_facts = False, 
-                          
                           ):
 
     current_gen = existing_kg.get('generation', 0)
     next_gen = current_gen + 1
     print(f"\n--- ABSORBING INFO: Gen {current_gen} -> Gen {next_gen} ---")
 
-    print('extracting facts...')
-
     newly_added_concepts = []
     concept_links = list(existing_kg.get('concept_links', []))
     fact_to_concept_links = defaultdict(list, 
@@ -360,25 +357,33 @@ def kg_evolve_incremental(existing_kg,
     existing_concept_names = {c['name'] for c in existing_concepts}
     existing_fact_statements = [f['statement'] for f in existing_facts]
     all_concept_names = list(existing_concept_names)
+    
     all_new_facts = []
-    if len(new_content_text) > 10000:
-        starting_point = random.randint(0, len(new_content_text)-10000)
-        for n in range(len(new_content_text)//10000):
-            content_to_sample = new_content_text[n*10000:(n+1)*10000]
-            facts = get_facts(content_to_sample, 
-                            model=model,
-                            provider=provider,
-                            npc = npc, 
-                            context=context)
-            all_new_facts.extend(facts)
+    
+    if new_facts:
+        all_new_facts = new_facts
+        print(f'using pre-approved facts: {len(all_new_facts)}')
+    elif new_content_text:
+        print('extracting facts from content...')
+        if len(new_content_text) > 10000:
+            starting_point = random.randint(0, len(new_content_text)-10000)
+            for n in range(len(new_content_text)//10000):
+                content_to_sample = new_content_text[n*10000:(n+1)*10000]
+                facts = get_facts(content_to_sample, 
+                                model=model,
+                                provider=provider,
+                                npc = npc, 
+                                context=context)
+                all_new_facts.extend(facts)
+        else:
+            all_new_facts = get_facts(new_content_text, 
+                                model=model,
+                                provider=provider,
+                                npc = npc, 
+                                context=context)
     else:
-        
-        all_new_facts = get_facts(new_content_text, 
-                            model=model,
-                            provider=provider,
-                            npc = npc, 
-                            context=context)
-
+        print("No new content or facts provided")
+        return existing_kg, {}
 
     for fact in all_new_facts: 
         fact['generation'] = next_gen
@@ -412,7 +417,6 @@ def kg_evolve_incremental(existing_kg,
                                                             context)
                 for related_name in related_concepts:
                     if related_name != cand_name: 
-                        
                         concept_links.append((cand_name, related_name))
             all_concept_names.append(cand_name)
 

npcpy-1.2.16/npcpy/memory/memory_processor.py

@@ -0,0 +1,155 @@
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import threading
+import queue
+import time
+
+@dataclass
+class MemoryItem:
+    message_id: str
+    conversation_id: str
+    npc: str
+    team: str
+    directory_path: str
+    content: str
+    context: str
+    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"""
+    if not memories:
+        return []
+    
+    print(f"\n📝 {len(memories)} memories ready for approval:")
+    
+    approvals = []
+    for i, memory in enumerate(memories, 1):
+        print(f"\n--- Memory {i}/{len(memories)} ---")
+        print(f"NPC: {memory['npc']}")
+        print(f"Content: {memory['content'][:200]}{'...' if len(memory['content']) > 200 else ''}")
+        
+        while True:
+            choice = input("(a)pprove, (r)eject, (e)dit, (s)kip, (q)uit, (A)pprove all: ").strip().lower()
+            
+            if choice == 'a':
+                approvals.append({"memory_id": memory['memory_id'], "decision": "human-approved"})
+                break
+            elif choice == 'r':
+                approvals.append({"memory_id": memory['memory_id'], "decision": "human-rejected"})
+                break
+            elif choice == 'e':
+                edited = input("Edit memory: ").strip()
+                if edited:
+                    approvals.append({
+                        "memory_id": memory['memory_id'], 
+                        "decision": "human-edited",
+                        "final_memory": edited
+                    })
+                break
+            elif choice == 's':
+                break
+            elif choice == 'q':
+                return approvals
+            elif choice == 'A':
+                
+                for remaining_memory in memories[i-1:]:
+                    approvals.append({
+                        "memory_id": remaining_memory['memory_id'], 
+                        "decision": "human-approved"
+                    })
+                return approvals
+    
+    return approvals

{npcpy-1.2.15 → npcpy-1.2.16}/npcpy/npc_compiler.py

@@ -1215,7 +1215,7 @@ class NPC:
     def write_code(self, task_description: str, language: str = "python", show=True) -> str:
         """Generate and execute code for a specific task, returning the result"""
         if language.lower() != "python":
-            # For non-Python languages, just generate the code
+            
             code_prompt = f"""Write {language} code for the following task:
     {task_description}
 
@@ -1224,7 +1224,7 @@ class NPC:
             response = self.get_llm_response(code_prompt, tool_choice=False )
             return response.get('response', 'Unable to generate code')
         
-        # For Python, generate and execute the code
+        
         code_prompt = f"""Write Python code for the following task:
     {task_description}
 
@@ -1245,7 +1245,7 @@ class NPC:
         response = self.get_llm_response(code_prompt, tool_choice= False)
         generated_code = response.get('response', '')
 
-        # Clean the code (remove markdown formatting if present)
+        
         if '```python' in generated_code:
             code_lines = generated_code.split('\n')
             start_idx = None
@@ -1265,7 +1265,7 @@ class NPC:
                     generated_code = '\n'.join(code_lines[start_idx:])
 
         try:
-            # Set up execution environment
+            
             exec_globals = {
                 "__builtins__": __builtins__,
                 "npc": self,
@@ -1290,21 +1290,21 @@ class NPC:
             
             exec_locals = {}
             
-            # Execute the generated code
+            
             exec(generated_code, exec_globals, exec_locals)
             
             if show:
                 print('Executing code', generated_code)
             
-            # Get the output
+            
             if "output" in exec_locals:
                 result = exec_locals["output"]
-                # Update shared context with any new variables
+                
                 self.shared_context.update({k: v for k, v in exec_locals.items() 
                                         if not k.startswith('_') and not callable(v)})
                 return f"Code executed successfully. Result: {result}"
             else:
-                # If no explicit output, return the last meaningful variable or confirmation
+                
                 meaningful_vars = {k: v for k, v in exec_locals.items() 
                                 if not k.startswith('_') and not callable(v)}
                 

{npcpy-1.2.15 → npcpy-1.2.16}/npcpy/serve.py

@@ -2023,6 +2023,28 @@ def stream():
 
 
 
+@app.route("/api/memory/approve", methods=["POST"])
+def approve_memories():
+    try:
+        data = request.json
+        approvals = data.get("approvals", [])
+        
+        command_history = CommandHistory(app.config.get('DB_PATH'))
+        
+        for approval in approvals:
+            command_history.update_memory_status(
+                approval['memory_id'],
+                approval['decision'],
+                approval.get('final_memory')
+            )
+        
+        return jsonify({"success": True, "processed": len(approvals)})
+        
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+
 
 @app.route("/api/execute", methods=["POST"])
 def execute():
@@ -2166,10 +2188,10 @@ def execute():
         dot_count = 0
         interrupted = False
         tool_call_data = {"id": None, "function_name": None, "arguments": ""}
+        memory_data = None
 
         try:
-            for response_chunk in response_gen['output']:
-                
+            for response_chunk in stream_response.get('response', stream_response.get('output')):
                 with cancellation_lock:
                     if cancellation_flags.get(current_stream_id, False):
                         print(f"Cancellation flag triggered for {current_stream_id}. Breaking loop.")
@@ -2179,28 +2201,7 @@ def execute():
                 print('.', end="", flush=True)
                 dot_count += 1
                 
-                chunk_content = ""
-                if isinstance(response_chunk, dict) and response_chunk.get("role") == "decision":
-                    
-                    chunk_data = {
-                        "id": None, "object": None, "created": None, "model": model,
-                        "choices": [
-                                {
-                                    "index": 0, 
-                                    "delta": 
-                                        {
-                                            "content": response_chunk.get('content', ''), 
-                                            "role": "assistant"
-                                            }, 
-                                    "finish_reason": None
-                                }
-                                     ]
-                    }
-                    complete_response.append(response_chunk.get('content', ''))
-                    yield f"data: {json.dumps(chunk_data)}\n\n"
-                    continue
-                    
-                elif "hf.co" in model or provider == 'ollama':
+                if "hf.co" in model or provider == 'ollama':
                     chunk_content = response_chunk["message"]["content"] if "message" in response_chunk and "content" in response_chunk["message"] else ""
                     if "message" in response_chunk and "tool_calls" in response_chunk["message"]:
                         for tool_call in response_chunk["message"]["tool_calls"]:
@@ -2210,46 +2211,41 @@ def execute():
                                 if "name" in tool_call["function"]:
                                     tool_call_data["function_name"] = tool_call["function"]["name"]
                                 if "arguments" in tool_call["function"]:
-                                    tool_call_data["arguments"] += tool_call["function"]["arguments"]
+                                    arg_val = tool_call["function"]["arguments"]
+                                    if isinstance(arg_val, dict):
+                                        arg_val = json.dumps(arg_val)
+                                    tool_call_data["arguments"] += arg_val
                     if chunk_content:
                         complete_response.append(chunk_content)
                     chunk_data = {
                         "id": None, "object": None, "created": response_chunk["created_at"], "model": response_chunk["model"],
                         "choices": [{"index": 0, "delta": {"content": chunk_content, "role": response_chunk["message"]["role"]}, "finish_reason": response_chunk.get("done_reason")}]
                     }
+                    yield f"data: {json.dumps(chunk_data)}\n\n"
                 else:
                     chunk_content = ""
                     reasoning_content = ""
-                    if not isinstance(response_chunk, str):
-                        for choice in response_chunk.choices:
-                            if hasattr(choice.delta, "tool_calls") and choice.delta.tool_calls:
-                                for tool_call in choice.delta.tool_calls:
-                                    if tool_call.id:
-                                        tool_call_data["id"] = tool_call.id
-                                    if tool_call.function:
-                                        if hasattr(tool_call.function, "name") and tool_call.function.name:
-                                            tool_call_data["function_name"] = tool_call.function.name
-                                        if hasattr(tool_call.function, "arguments") and tool_call.function.arguments:
-                                            tool_call_data["arguments"] += tool_call.function.arguments
-                        for choice in response_chunk.choices:
-                            if hasattr(choice.delta, "reasoning_content"):
-                                reasoning_content += choice.delta.reasoning_content
-                        chunk_content = "".join(choice.delta.content for choice in response_chunk.choices if choice.delta.content is not None)
-                        if chunk_content:
-                            complete_response.append(chunk_content)
-                        chunk_data = {
-                            "id": response_chunk.id, "object": response_chunk.object, "created": response_chunk.created, "model": response_chunk.model,
-                            "choices": [{"index": choice.index, "delta": {"content": choice.delta.content, "role": choice.delta.role, "reasoning_content": reasoning_content if hasattr(choice.delta, "reasoning_content") else None}, "finish_reason": choice.finish_reason} for choice in response_chunk.choices]
-                        }
-                    else: 
-                        chunk_content = response_chunk
+                    for choice in response_chunk.choices:
+                        if hasattr(choice.delta, "tool_calls") and choice.delta.tool_calls:
+                            for tool_call in choice.delta.tool_calls:
+                                if tool_call.id:
+                                    tool_call_data["id"] = tool_call.id
+                                if tool_call.function:
+                                    if hasattr(tool_call.function, "name") and tool_call.function.name:
+                                        tool_call_data["function_name"] = tool_call.function.name
+                                    if hasattr(tool_call.function, "arguments") and tool_call.function.arguments:
+                                        tool_call_data["arguments"] += tool_call.function.arguments
+                    for choice in response_chunk.choices:
+                        if hasattr(choice.delta, "reasoning_content"):
+                            reasoning_content += choice.delta.reasoning_content
+                    chunk_content = "".join(choice.delta.content for choice in response_chunk.choices if choice.delta.content is not None)
+                    if chunk_content:
                         complete_response.append(chunk_content)
-                        chunk_data = {
-                            "id": None, "object": None, "created": None, "model": model,
-                            "choices": [{"index": 0, "delta": {"content": chunk_content, "role": "assistant"}, "finish_reason": None}]
-                        }
-
-                yield f"data: {json.dumps(chunk_data)}\n\n"
+                    chunk_data = {
+                        "id": response_chunk.id, "object": response_chunk.object, "created": response_chunk.created, "model": response_chunk.model,
+                        "choices": [{"index": choice.index, "delta": {"content": choice.delta.content, "role": choice.delta.role, "reasoning_content": reasoning_content if hasattr(choice.delta, "reasoning_content") else None}, "finish_reason": choice.finish_reason} for choice in response_chunk.choices]
+                    }
+                    yield f"data: {json.dumps(chunk_data)}\n\n"
 
         except Exception as e:
             print(f"\nAn exception occurred during streaming for {current_stream_id}: {e}")
@@ -2261,13 +2257,74 @@ def execute():
             print('\r' + ' ' * dot_count*2 + '\r', end="", flush=True)
 
             final_response_text = ''.join(complete_response)
+            
+            conversation_turn_text = f"User: {commandstr}\nAssistant: {final_response_text}"
+            
+            try:
+                memory_examples = command_history.get_memory_examples_for_context(
+                    npc=npc_name,
+                    team=team,
+                    directory_path=current_path
+                )
+                
+                memory_context = format_memory_context(memory_examples)
+                
+                facts = get_facts(
+                    conversation_turn_text,
+                    model=npc_object.model if npc_object else model,
+                    provider=npc_object.provider if npc_object else provider,
+                    npc=npc_object,
+                    context=memory_context
+                )
+                
+                if facts:
+                    memories_for_approval = []
+                    for i, fact in enumerate(facts):
+                        memory_id = command_history.add_memory_to_database(
+                            message_id=f"{conversation_id}_{datetime.now().strftime('%H%M%S')}_{i}",
+                            conversation_id=conversation_id,
+                            npc=npc_name or "default",
+                            team=team or "default",
+                            directory_path=current_path or "/",
+                            initial_memory=fact['statement'],
+                            status="pending_approval",
+                            model=npc_object.model if npc_object else model,
+                            provider=npc_object.provider if npc_object else provider
+                        )
+                        
+                        memories_for_approval.append({
+                            "memory_id": memory_id,
+                            "content": fact['statement'],
+                            "context": f"Type: {fact.get('type', 'unknown')}, Source: {fact.get('source_text', '')}",
+                            "npc": npc_name or "default"
+                        })
+                    
+                    memory_data = {
+                        "type": "memory_approval",
+                        "memories": memories_for_approval,
+                        "conversation_id": conversation_id
+                    }
+                    
+            except Exception as e:
+                print(f"Memory generation error: {e}")
+
+            if memory_data:
+                yield f"data: {json.dumps(memory_data)}\n\n"
+
             yield f"data: {json.dumps({'type': 'message_stop'})}\n\n"
             
             npc_name_to_save = npc_object.name if npc_object else ''
             save_conversation_message(
-                command_history, conversation_id, "assistant", final_response_text,
-                wd=current_path, model=model, provider=provider,
-                npc=npc_name_to_save, team=team, message_id=message_id,
+                command_history, 
+                conversation_id, 
+                "assistant", 
+                final_response_text,
+                wd=current_path, 
+                model=model, 
+                provider=provider,
+                npc=npc_name_to_save, 
+                team=team, 
+                message_id=message_id,
             )
 
             with cancellation_lock:
@@ -2276,6 +2333,7 @@ def execute():
                     print(f"Cleaned up cancellation flag for stream ID: {current_stream_id}")
 
 
+
     return Response(event_stream(stream_id), mimetype="text/event-stream")
 
 @app.route("/api/interrupt", methods=["POST"])

{npcpy-1.2.15 → npcpy-1.2.16/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.15
+Version: 1.2.16
 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.15 → npcpy-1.2.16}/npcpy.egg-info/SOURCES.txt

@@ -23,6 +23,12 @@ npcpy/data/load.py
 npcpy/data/text.py
 npcpy/data/video.py
 npcpy/data/web.py
+npcpy/ft/__init__.py
+npcpy/ft/diff.py
+npcpy/ft/ge.py
+npcpy/ft/memory_trainer.py
+npcpy/ft/rl.py
+npcpy/ft/sft.py
 npcpy/gen/__init__.py
 npcpy/gen/audio_gen.py
 npcpy/gen/embeddings.py
@@ -33,6 +39,7 @@ npcpy/memory/__init__.py
 npcpy/memory/command_history.py
 npcpy/memory/kg_vis.py
 npcpy/memory/knowledge_graph.py
+npcpy/memory/memory_processor.py
 npcpy/memory/search.py
 npcpy/mix/__init__.py
 npcpy/mix/debate.py

{npcpy-1.2.15 → npcpy-1.2.16}/setup.py

@@ -82,7 +82,7 @@ extra_files = package_files("npcpy/npc_team/")
 
 setup(
     name="npcpy",
-    version="1.2.15",
+    version="1.2.16",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  
     extras_require={