npcpy 1.1.28__py3-none-any.whl → 1.2.32__py3-none-any.whl

npcpy/serve.py

@@ -4,7 +4,9 @@ from flask_sse import sse
 import redis
 import threading
 import uuid
+import sys 
 import traceback
+import glob
 
 
 from flask_cors import CORS
@@ -41,6 +43,7 @@ from npcpy.npc_sysenv import get_locally_available_models
 from npcpy.memory.command_history import (
     CommandHistory,
     save_conversation_message,
+    generate_message_id,
 )
 from npcpy.npc_compiler import  Jinx, NPC, Team 
 
@@ -57,11 +60,11 @@ import os
 from pathlib import Path
 from flask_cors import CORS
 
-# Path for storing settings
-# instead of a static path relative to server launch directory
 
 
-# --- NEW: Global dictionary to track stream cancellation requests ---
+
+
+
 cancellation_flags = {}
 cancellation_lock = threading.Lock()
 
@@ -79,9 +82,10 @@ def get_project_npc_directory(current_path=None):
     if current_path:
         return os.path.join(current_path, "npc_team")
     else:
-        # Fallback to the old behavior if no path provided
+        
         return os.path.abspath("./npc_team")
 
+
 def load_project_env(current_path):
     """
     Load environment variables from a project's .env file
@@ -100,12 +104,12 @@ def load_project_env(current_path):
     
     if os.path.exists(env_path):
         print(f"Loading project environment from {env_path}")
-        # Load the environment variables into the current process
-        # Note: load_dotenv returns a boolean, not a dictionary
+        
+        
         success = load_dotenv(env_path, override=True)
         
         if success:
-            # Manually build a dictionary of loaded variables
+            
             with open(env_path, "r") as f:
                 for line in f:
                     line = line.strip()
@@ -122,7 +126,9 @@ def load_project_env(current_path):
     
     return loaded_vars
 
-# Initialize components
+
+
+
 def load_kg_data(generation=None):
     """Helper function to load data up to a specific generation."""
     engine = create_engine('sqlite:///' + app.config.get('DB_PATH'))
@@ -132,7 +138,7 @@ def load_kg_data(generation=None):
     concepts_df = pd.read_sql_query(f"SELECT * FROM kg_concepts{query_suffix}", engine)
     facts_df = pd.read_sql_query(f"SELECT * FROM kg_facts{query_suffix}", engine)
     
-    # Links don't have generation, so we filter them based on the loaded nodes
+    
     all_links_df = pd.read_sql_query("SELECT * FROM kg_links", engine)
     valid_nodes = set(concepts_df['name']).union(set(facts_df['statement']))
     links_df = all_links_df[all_links_df['source'].isin(valid_nodes) & all_links_df['target'].isin(valid_nodes)]
@@ -143,7 +149,7 @@ def load_kg_data(generation=None):
 app = Flask(__name__)
 app.config["REDIS_URL"] = "redis://localhost:6379"
 app.config['DB_PATH'] = ''
-
+app.jinx_conversation_contexts ={}
 
 redis_client = redis.Redis(host="localhost", port=6379, decode_responses=True)
 
@@ -210,15 +216,15 @@ def load_npc_by_name_and_source(name, source, db_conn=None, current_path=None):
     if not db_conn:
         db_conn = get_db_connection()
     
-    # Determine which directory to search
+    
     if source == 'project':
         npc_directory = get_project_npc_directory(current_path)
         print(f"Looking for project NPC in: {npc_directory}")
-    else:  # Default to global if not specified or unknown
+    else:  
         npc_directory = app.config['user_npc_directory']
         print(f"Looking for global NPC in: {npc_directory}")
     
-    # Look for the NPC file in the appropriate directory
+    
     npc_path = os.path.join(npc_directory, f"{name}.npc")
     
     if os.path.exists(npc_path):
@@ -252,9 +258,9 @@ def get_conversation_history(conversation_id):
 
             return [
                 {
-                    "role": msg[0],  # role
-                    "content": msg[1],  # content
-                    "timestamp": msg[2],  # timestamp
+                    "role": msg[0],  
+                    "content": msg[1],  
+                    "timestamp": msg[2],  
                 }
                 for msg in messages
             ]
@@ -279,9 +285,9 @@ def fetch_messages_for_conversation(conversation_id):
 
             return [
                 {
-                    "role": message[0],  # role
-                    "content": message[1],  # content
-                    "timestamp": message[2],  # timestamp
+                    "role": message[0],  
+                    "content": message[1],  
+                    "timestamp": message[2],  
                 }
                 for message in messages
             ]
@@ -296,13 +302,13 @@ def fetch_messages_for_conversation(conversation_id):
 def list_generations():
     try:
         engine = create_engine('sqlite:///' + app.config.get('DB_PATH'))
-        # Combine generations from both tables to be safe
+        
         query = "SELECT DISTINCT generation FROM kg_concepts UNION SELECT DISTINCT generation FROM kg_facts"
         generations_df = pd.read_sql_query(query, engine)
         generations = generations_df.iloc[:, 0].tolist()
         return jsonify({"generations": sorted([g for g in generations if g is not None])})
     except Exception as e:
-        # If tables don't exist yet, return empty list
+        
         print(f"Error listing generations (likely new DB): {e}")
         return jsonify({"generations": []})
 
@@ -399,7 +405,7 @@ def get_attachment(attachment_id):
         data, name, type = command_history.get_attachment_data(attachment_id)
 
         if data:
-            # Convert binary data to base64 for sending
+            
             base64_data = base64.b64encode(data).decode("utf-8")
             return jsonify(
                 {"data": base64_data, "name": name, "type": type, "error": None}
@@ -411,10 +417,10 @@ def get_attachment(attachment_id):
 
 @app.route("/api/capture_screenshot", methods=["GET"])
 def capture():
-    # Capture screenshot using NPC-based method
+    
     screenshot = capture_screenshot(None, full=True)
 
-    # Ensure screenshot was captured successfully
+    
     if not screenshot:
         print("Screenshot capture failed")
         return None
@@ -430,14 +436,14 @@ def get_global_settings():
     try:
         npcshrc_path = os.path.expanduser("~/.npcshrc")
 
-        # Default settings
+        
         global_settings = {
             "model": "llama3.2",
             "provider": "ollama",
             "embedding_model": "nomic-embed-text",
             "embedding_provider": "ollama",
             "search_provider": "perplexity",
-            "NPCSH_LICENSE_KEY": "",
+            "NPC_STUDIO_LICENSE_KEY": "",
             "default_folder": os.path.expanduser("~/.npcsh/"),
         }
         global_vars = {}
@@ -445,7 +451,7 @@ def get_global_settings():
         if os.path.exists(npcshrc_path):
             with open(npcshrc_path, "r") as f:
                 for line in f:
-                    # Skip comments and empty lines
+                    
                     line = line.split("#")[0].strip()
                     if not line:
                         continue
@@ -453,27 +459,27 @@ def get_global_settings():
                     if "=" not in line:
                         continue
 
-                    # Split on first = only
+                    
                     key, value = line.split("=", 1)
                     key = key.strip()
                     if key.startswith("export "):
                         key = key[7:]
 
-                    # Clean up the value - handle quoted strings properly
+                    
                     value = value.strip()
                     if value.startswith('"') and value.endswith('"'):
                         value = value[1:-1]
                     elif value.startswith("'") and value.endswith("'"):
                         value = value[1:-1]
 
-                    # Map environment variables to settings
+                    
                     key_mapping = {
                         "NPCSH_MODEL": "model",
                         "NPCSH_PROVIDER": "provider",
                         "NPCSH_EMBEDDING_MODEL": "embedding_model",
                         "NPCSH_EMBEDDING_PROVIDER": "embedding_provider",
                         "NPCSH_SEARCH_PROVIDER": "search_provider",
-                        "NPCSH_LICENSE_KEY": "NPCSH_LICENSE_KEY",
+                        "NPC_STUDIO_LICENSE_KEY": "NPC_STUDIO_LICENSE_KEY",
                         "NPCSH_STREAM_OUTPUT": "NPCSH_STREAM_OUTPUT",
                         "NPC_STUDIO_DEFAULT_FOLDER": "default_folder",
                     }
@@ -496,7 +502,325 @@ def get_global_settings():
     except Exception as e:
         print(f"Error in get_global_settings: {str(e)}")
         return jsonify({"error": str(e)}), 500
+def _get_jinx_files_recursively(directory):
+    """Helper to recursively find all .jinx file paths."""
+    jinx_paths = []
+    if os.path.exists(directory):
+        for root, _, files in os.walk(directory):
+            for filename in files:
+                if filename.endswith(".jinx"):
+                    jinx_paths.append(os.path.join(root, filename))
+    return jinx_paths
+
+@app.route("/api/jinxs/available", methods=["GET"])
+def get_available_jinxs():
+    try:
+        current_path = request.args.get('currentPath')
+        jinx_names = set()
+
+        if current_path:
+            team_jinxs_dir = os.path.join(current_path, 'npc_team', 'jinxs')
+            jinx_paths = _get_jinx_files_recursively(team_jinxs_dir)
+            for path in jinx_paths:
+                jinx_names.add(os.path.basename(path)[:-5])
+
+        global_jinxs_dir = os.path.expanduser('~/.npcsh/npc_team/jinxs')
+        jinx_paths = _get_jinx_files_recursively(global_jinxs_dir)
+        for path in jinx_paths:
+            jinx_names.add(os.path.basename(path)[:-5])
+
+        return jsonify({'jinxs': sorted(list(jinx_names)), 'error': None})
+    except Exception as e:
+        print(f"Error getting available jinxs: {str(e)}")
+        traceback.print_exc()
+        return jsonify({'jinxs': [], 'error': str(e)}), 500
+
+@app.route("/api/jinxs/global", methods=["GET"])
+def get_global_jinxs():
+    jinxs_dir = os.path.join(os.path.expanduser("~"), ".npcsh", "npc_team", "jinxs")
+    jinx_paths = _get_jinx_files_recursively(jinxs_dir)
+    jinxs = []
+    for path in jinx_paths:
+        try:
+            with open(path, "r") as f:
+                jinx_data = yaml.safe_load(f)
+                jinxs.append(jinx_data)
+        except Exception as e:
+            print(f"Error loading global jinx {path}: {e}")
+    return jsonify({"jinxs": jinxs})
+
+@app.route("/api/jinxs/project", methods=["GET"])
+def get_project_jinxs():
+    current_path = request.args.get("currentPath")
+    if not current_path:
+        return jsonify({"jinxs": []})
+
+    if not current_path.endswith("npc_team"):
+        current_path = os.path.join(current_path, "npc_team")
+
+    jinxs_dir = os.path.join(current_path, "jinxs")
+    jinx_paths = _get_jinx_files_recursively(jinxs_dir)
+    jinxs = []
+    for path in jinx_paths:
+        try:
+            with open(path, "r") as f:
+                jinx_data = yaml.safe_load(f)
+                jinxs.append(jinx_data)
+        except Exception as e:
+            print(f"Error loading project jinx {path}: {e}")
+    return jsonify({"jinxs": jinxs})
 
+@app.route("/api/jinx/execute", methods=["POST"])
+def execute_jinx():
+    """
+    Execute a specific jinx with provided arguments.
+    Streams the output back to the client.
+    """
+    data = request.json
+    
+    stream_id = data.get("streamId")
+    if not stream_id:
+        stream_id = str(uuid.uuid4())
+    
+    with cancellation_lock:
+        cancellation_flags[stream_id] = False
+    
+    print(f"--- Jinx Execution Request for streamId: {stream_id} ---")
+    print(f"Request Data: {json.dumps(data, indent=2)}")
+
+    jinx_name = data.get("jinxName")
+    jinx_args = data.get("jinxArgs", [])
+    print(f"Jinx Name: {jinx_name}, Jinx Args: {jinx_args}")
+    conversation_id = data.get("conversationId")
+    model = data.get("model")
+    provider = data.get("provider")
+
+    # --- IMPORTANT: Ensure conversation_id is present for context persistence ---
+    if not conversation_id:
+        print("ERROR: conversationId is required for Jinx execution with persistent variables")
+        return jsonify({"error": "conversationId is required for Jinx execution with persistent variables"}), 400
+
+    npc_name = data.get("npc")
+    npc_source = data.get("npcSource", "global")
+    current_path = data.get("currentPath")
+    
+    if not jinx_name:
+        print("ERROR: jinxName is required")
+        return jsonify({"error": "jinxName is required"}), 400
+    
+    # Load project environment if applicable
+    if current_path:
+        load_project_env(current_path)
+    
+    # Load the NPC
+    npc_object = None
+    if npc_name:
+        db_conn = get_db_connection()
+        npc_object = load_npc_by_name_and_source(npc_name, npc_source, db_conn, current_path)
+        if not npc_object and npc_source == 'project':
+            npc_object = load_npc_by_name_and_source(npc_name, 'global', db_conn)
+    
+    # Try to find the jinx
+    jinx = None
+    
+    # Check NPC's jinxs
+    if npc_object and hasattr(npc_object, 'jinxs_dict') and jinx_name in npc_object.jinxs_dict:
+        jinx = npc_object.jinxs_dict[jinx_name]
+    
+    # Check team jinxs
+    if not jinx and current_path:
+        team_jinx_path = os.path.join(current_path, 'npc_team', 'jinxs', f'{jinx_name}.jinx')
+        if os.path.exists(team_jinx_path):
+            jinx = Jinx(jinx_path=team_jinx_path)
+    
+    # Check global jinxs
+    if not jinx:
+        global_jinx_path = os.path.expanduser(f'~/.npcsh/npc_team/jinxs/{jinx_name}.jinx')
+        if os.path.exists(global_jinx_path):
+            jinx = Jinx(jinx_path=global_jinx_path)
+    
+    if not jinx:
+        print(f"ERROR: Jinx '{jinx_name}' not found")
+        return jsonify({"error": f"Jinx '{jinx_name}' not found"}), 404
+    
+    # Extract inputs from args
+    from npcpy.npc_compiler import extract_jinx_inputs
+
+    # Re-assemble arguments that were incorrectly split by spaces.
+    fixed_args = []
+    i = 0
+    while i < len(jinx_args):
+        arg = jinx_args[i]
+        if arg.startswith('-'):
+            fixed_args.append(arg)
+            value_parts = []
+            i += 1
+            # Collect all subsequent parts until the next flag or the end of the list.
+            while i < len(jinx_args) and not jinx_args[i].startswith('-'):
+                value_parts.append(jinx_args[i])
+                i += 1
+            
+            if value_parts:
+                # Join the parts back into a single string.
+                full_value = " ".join(value_parts)
+                # Clean up the extraneous quotes that the initial bad split left behind.
+                if full_value.startswith("'") and full_value.endswith("'"):
+                    full_value = full_value[1:-1]
+                elif full_value.startswith('"') and full_value.endswith('"'):
+                    full_value = full_value[1:-1]
+                fixed_args.append(full_value)
+            # The 'i' counter is already advanced, so the loop continues from the next flag.
+        else:
+            # This handles positional arguments, just in case.
+            fixed_args.append(arg)
+            i += 1
+
+    # Now, use the corrected arguments to extract inputs.
+    input_values = extract_jinx_inputs(fixed_args, jinx)
+
+    print(f'Executing jinx with input_values: {input_values}')
+    # Get conversation history
+    command_history = CommandHistory(app.config.get('DB_PATH'))
+    messages = fetch_messages_for_conversation(conversation_id)
+    
+    # Prepare jinxs_dict for execution
+    all_jinxs = {}
+    if npc_object and hasattr(npc_object, 'jinxs_dict'):
+        all_jinxs.update(npc_object.jinxs_dict)
+    
+    # --- IMPORTANT: Retrieve or initialize the persistent Jinx context for this conversation ---
+    if conversation_id not in app.jinx_conversation_contexts:
+        app.jinx_conversation_contexts[conversation_id] = {}
+    jinx_local_context = app.jinx_conversation_contexts[conversation_id]
+
+    print(f"--- CONTEXT STATE (conversationId: {conversation_id}) ---")
+    print(f"jinx_local_context BEFORE Jinx execution: {jinx_local_context}")
+
+    def event_stream(current_stream_id):
+        try:
+            # --- IMPORTANT: Pass the persistent context as 'extra_globals' ---
+            result = jinx.execute(
+                input_values=input_values,
+                jinxs_dict=all_jinxs,
+                jinja_env=npc_object.jinja_env if npc_object else None,
+                npc=npc_object,
+                messages=messages,
+                extra_globals=jinx_local_context # <--- THIS IS WHERE THE PERSISTENT CONTEXT IS PASSED
+            )
+            
+            # --- CRITICAL FIX: Capture and update local_vars from the Jinx's result ---
+            # The Jinx.execute method returns its internal 'context' dictionary.
+            # We need to update our persistent 'jinx_local_context' with the new variables
+            # from the Jinx's returned context.
+            if isinstance(result, dict):
+                # We need to be careful not to overwrite core Jinx/NPC context keys
+                # that are not meant for variable persistence.
+                keys_to_exclude = ['output', 'llm_response', 'messages', 'results', 'npc', 'context', 'jinxs', 'team']
+                
+                # Update jinx_local_context with all non-excluded keys from the result
+                for key, value in result.items():
+                    if key not in keys_to_exclude and not key.startswith('_'): # Exclude internal/temporary keys
+                        jinx_local_context[key] = value
+                
+                print(f"jinx_local_context UPDATED from Jinx result: {jinx_local_context}") # NEW LOG
+            
+            # Get output (this still comes from the 'output' key in the result)
+            output = result.get('output', str(result))
+            messages_updated = result.get('messages', messages)
+
+            print(f"jinx_local_context AFTER Jinx execution (final state): {jinx_local_context}")
+            print(f"Jinx execution result output: {output}")
+            
+            # Check for interruption
+            with cancellation_lock:
+                if cancellation_flags.get(current_stream_id, False):
+                    yield f"data: {json.dumps({'type': 'interrupted'})}\n\n"
+                    return
+            
+            # Stream the output in chunks for consistent UI experience
+            if isinstance(output, str):
+                chunk_size = 50  # Characters per chunk
+                for i in range(0, len(output), chunk_size):
+                    chunk = output[i:i + chunk_size]
+                    chunk_data = {
+                        "id": None,
+                        "object": None,
+                        "created": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {
+                                "content": chunk,
+                                "role": "assistant"
+                            },
+                            "finish_reason": None
+                        }]
+                    }
+                    yield f"data: {json.dumps(chunk_data)}\n\n"
+            else:
+                # Non-string output, send as single chunk
+                chunk_data = {
+                    "id": None,
+                    "object": None,
+                    "created": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                    "model": model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {
+                            "content": str(output),
+                            "role": "assistant"
+                        },
+                        "finish_reason": None
+                    }]
+                }
+                yield f"data: {json.dumps(chunk_data)}\n\n"
+            
+            # Send completion message
+            yield f"data: {json.dumps({'type': 'message_stop'})}\n\n"
+            
+            # Save to conversation history
+            message_id = generate_message_id()
+            save_conversation_message(
+                command_history,
+                conversation_id,
+                "user",
+                f"/{jinx_name} {' '.join(jinx_args)}",
+                wd=current_path,
+                model=model,
+                provider=provider,
+                npc=npc_name,
+                message_id=message_id
+            )
+            
+            message_id = generate_message_id()
+            save_conversation_message(
+                command_history,
+                conversation_id,
+                "assistant",
+                str(output),
+                wd=current_path,
+                model=model,
+                provider=provider,
+                npc=npc_name,
+                message_id=message_id
+            )
+            
+        except Exception as e:
+            print(f"ERROR: Exception during jinx execution {jinx_name}: {str(e)}")
+            traceback.print_exc()
+            error_data = {
+                "type": "error",
+                "error": str(e)
+            }
+            yield f"data: {json.dumps(error_data)}\n\n"
+        
+        finally:
+            with cancellation_lock:
+                if current_stream_id in cancellation_flags:
+                    del cancellation_flags[current_stream_id]
+            print(f"--- Jinx Execution Finished for streamId: {stream_id} ---")
+    
+    return Response(event_stream(stream_id), mimetype="text/event-stream")
 
 @app.route("/api/settings/global", methods=["POST", "OPTIONS"])
 def save_global_settings():
@@ -513,7 +837,7 @@ def save_global_settings():
             "embedding_model": "NPCSH_EMBEDDING_MODEL",
             "embedding_provider": "NPCSH_EMBEDDING_PROVIDER",
             "search_provider": "NPCSH_SEARCH_PROVIDER",
-            "NPCSH_LICENSE_KEY": "NPCSH_LICENSE_KEY",
+            "NPC_STUDIO_LICENSE_KEY": "NPC_STUDIO_LICENSE_KEY",
             "NPCSH_STREAM_OUTPUT": "NPCSH_STREAM_OUTPUT",
             "default_folder": "NPC_STUDIO_DEFAULT_FOLDER",
         }
@@ -521,15 +845,15 @@ def save_global_settings():
         os.makedirs(os.path.dirname(npcshrc_path), exist_ok=True)
         print(data)
         with open(npcshrc_path, "w") as f:
-            # Write settings as environment variables
+            
             for key, value in data.get("global_settings", {}).items():
                 if key in key_mapping and value:
-                    # Quote value if it contains spaces
+                    
                     if " " in str(value):
                         value = f'"{value}"'
                     f.write(f"export {key_mapping[key]}={value}\n")
 
-            # Write custom variables
+            
             for key, value in data.get("global_vars", {}).items():
                 if key and value:
                     if " " in str(value):
@@ -542,8 +866,7 @@ def save_global_settings():
         print(f"Error in save_global_settings: {str(e)}")
         return jsonify({"error": str(e)}), 500
 
-
-@app.route("/api/settings/project", methods=["GET", "OPTIONS"])  # Add OPTIONS
+@app.route("/api/settings/project", methods=["GET", "OPTIONS"])  
 def get_project_settings():
     if request.method == "OPTIONS":
         return "", 200
@@ -572,7 +895,7 @@ def get_project_settings():
         return jsonify({"error": str(e)}), 500
 
 
-@app.route("/api/settings/project", methods=["POST", "OPTIONS"])  # Add OPTIONS
+@app.route("/api/settings/project", methods=["POST", "OPTIONS"])  
 def save_project_settings():
     if request.method == "OPTIONS":
         return "", 200
@@ -607,35 +930,35 @@ def get_models():
     global available_models
     current_path = request.args.get("currentPath")
     if not current_path:
-        # Fallback to a default path or user home if needed,
-        # but ideally the frontend should always provide it.
-        current_path = os.path.expanduser("~/.npcsh")  # Or handle error
+        
+        
+        current_path = os.path.expanduser("~/.npcsh")  
         print("Warning: No currentPath provided for /api/models, using default.")
-        # return jsonify({"error": "currentPath parameter is required"}), 400
+        
 
     try:
-        # Reuse the existing function to detect models
+        
         available_models = get_locally_available_models(current_path)
 
-        # Optionally, add more details or format the response if needed
-        # Example: Add a display name
+        
+        
         formatted_models = []
         for m, p in available_models.items():
-            # Basic formatting, customize as needed
+            
             text_only = (
                 "(text only)"
                 if p == "ollama"
-                and m in ["llama3.2", "deepseek-v3", "phi4"]
+                and m in ["llama3.2", "deepseek-v3", "phi4", "gemma3:1b"]
                 else ""
             )
-            # Handle specific known model names for display
+            
             display_model = m
             if "claude-3-5-haiku-latest" in m:
                 display_model = "claude-3.5-haiku"
             elif "claude-3-5-sonnet-latest" in m:
                 display_model = "claude-3.5-sonnet"
             elif "gemini-1.5-flash" in m:
-                display_model = "gemini-1.5-flash"  # Handle multiple versions if neede
+                display_model = "gemini-1.5-flash"  
             elif "gemini-2.0-flash-lite-preview-02-05" in m:
                 display_model = "gemini-2.0-flash-lite-preview"
 
@@ -643,7 +966,7 @@ def get_models():
 
             formatted_models.append(
                 {
-                    "value": m,  # Use the actual model ID as the value
+                    "value": m,  
                     "provider": p,
                     "display_name": display_name,
                 }
@@ -655,29 +978,29 @@ def get_models():
         print(f"Error getting available models: {str(e)}")
 
         traceback.print_exc()
-        # Return an empty list or a specific error structure
+        
         return jsonify({"models": [], "error": str(e)}), 500
 
 @app.route('/api/<command>', methods=['POST'])
 def api_command(command):
     data = request.json or {}
     
-    # Check if command exists
+    
     handler = router.get_route(command)
     if not handler:
         return jsonify({"error": f"Unknown command: {command}"})
     
-    # Check if it's shell-only
+    
     if router.shell_only.get(command, False):
         return jsonify({"error": f"Command {command} is only available in shell mode"})
     
-    # Execute the command handler
+    
     try:
-        # Convert positional args from JSON 
+        
         args = data.get('args', [])
         kwargs = data.get('kwargs', {})
         
-        # Add command name back to the command string
+        
         command_str = command
         if args:
             command_str += " " + " ".join(str(arg) for arg in args)
@@ -694,13 +1017,13 @@ def get_npc_team_global():
 
         npc_data = []
 
-        # Use existing helper to get NPCs from the global directory
+        
         for file in os.listdir(global_npc_directory):
             if file.endswith(".npc"):
                 npc_path = os.path.join(global_npc_directory, file)
                 npc = NPC(file=npc_path, db_conn=db_conn)
 
-                # Serialize the NPC data - updated for the new Jinx structure
+                
                 serialized_npc = {
                     "name": npc.name,
                     "primary_directive": npc.primary_directive,
@@ -733,49 +1056,6 @@ def get_npc_team_global():
         return jsonify({"npcs": [], "error": str(e)})
 
 
-@app.route("/api/jinxs/global", methods=["GET"])
-def get_global_jinxs():
-    # try:
-    user_home = os.path.expanduser("~")
-    jinxs_dir = os.path.join(user_home, ".npcsh", "npc_team", "jinxs")
-    jinxs = []
-    if os.path.exists(jinxs_dir):
-        for file in os.listdir(jinxs_dir):
-            if file.endswith(".jinx"):
-                with open(os.path.join(jinxs_dir, file), "r") as f:
-                    jinx_data = yaml.safe_load(f)
-                    jinxs.append(jinx_data)
-            print("file", file)
-
-    return jsonify({"jinxs": jinxs})
-
-
-# except Exception as e:
-#    return jsonify({"error": str(e)}), 500
-
-
-@app.route("/api/jinxs/project", methods=["GET"])
-def get_project_jinxs():
-    current_path = request.args.get(
-        "currentPath"
-    )  # Correctly retrieves `currentPath` from query params
-    if not current_path:
-        return jsonify({"jinxs": []})
-
-    if not current_path.endswith("npc_team"):
-        current_path = os.path.join(current_path, "npc_team")
-
-    jinxs_dir = os.path.join(current_path, "jinxs")
-    jinxs = []
-    if os.path.exists(jinxs_dir):
-        for file in os.listdir(jinxs_dir):
-            if file.endswith(".jinx"):
-                with open(os.path.join(jinxs_dir, file), "r") as f:
-                    jinx_data = yaml.safe_load(f)
-                    jinxs.append(jinx_data)
-    return jsonify({"jinxs": jinxs})
-
-
 @app.route("/api/jinxs/save", methods=["POST"])
 def save_jinx():
     try:
@@ -799,7 +1079,7 @@ def save_jinx():
 
         os.makedirs(jinxs_dir, exist_ok=True)
 
-        # Full jinx structure
+        
         jinx_yaml = {
             "description": jinx_data.get("description", ""),
             "inputs": jinx_data.get("inputs", []),
@@ -826,16 +1106,16 @@ def save_npc():
         if not npc_data or "name" not in npc_data:
             return jsonify({"error": "Invalid NPC data"}), 400
 
-        # Determine the directory based on whether it's global or project
+        
         if is_global:
             npc_directory = os.path.expanduser("~/.npcsh/npc_team")
         else:
             npc_directory = os.path.join(current_path, "npc_team")
 
-        # Ensure the directory exists
+        
         os.makedirs(npc_directory, exist_ok=True)
 
-        # Create the YAML content
+        
         yaml_content = f"""name: {npc_data['name']}
 primary_directive: "{npc_data['primary_directive']}"
 model: {npc_data['model']}
@@ -844,7 +1124,7 @@ api_url: {npc_data.get('api_url', '')}
 use_global_jinxs: {str(npc_data.get('use_global_jinxs', True)).lower()}
 """
 
-        # Save the file
+        
         file_path = os.path.join(npc_directory, f"{npc_data['name']}.npc")
         with open(file_path, "w") as f:
             f.write(yaml_content)
@@ -873,7 +1153,7 @@ def get_npc_team_project():
                 npc_path = os.path.join(project_npc_directory, file)
                 npc = NPC(file=npc_path, db_conn=db_conn)
 
-                # Serialize the NPC data, updated for new Jinx structure
+                
                 serialized_npc = {
                     "name": npc.name,
                     "primary_directive": npc.primary_directive,
@@ -949,7 +1229,7 @@ def get_last_used_model_and_npc_in_conversation(conversation_id):
         print(f"Error getting last used model/NPC for conversation {conversation_id}: {e}")
         return {"model": None, "npc": None, "error": str(e)}
 
-# Add these new API routes:
+
 
 @app.route("/api/last_used_in_directory", methods=["GET"])
 def api_get_last_used_in_directory():
@@ -970,18 +1250,20 @@ def api_get_last_used_in_conversation():
     
     result = get_last_used_model_and_npc_in_conversation(conversation_id)
     return jsonify(result)
-# Add this near your other utility functions
+
 def get_ctx_path(is_global, current_path=None):
     """Determines the path to the .ctx file."""
     if is_global:
-        # Assuming the global team context is in the root of the npc_team folder.
-        # Let's call it 'team.ctx' for consistency.
-        return os.path.join(os.path.expanduser("~/.npcsh/npc_team/"), "npcsh.ctx")
+        ctx_dir = os.path.join(os.path.expanduser("~/.npcsh/npc_team/"))
+        ctx_files = glob.glob(os.path.join(ctx_dir, "*.ctx"))
+        return ctx_files[0] if ctx_files else None
     else:
         if not current_path:
             return None
-        # Project context is in the project's npc_team folder
-        return os.path.join(current_path, "npc_team", "team.ctx")
+        
+        ctx_dir = os.path.join(current_path, "npc_team")
+        ctx_files = glob.glob(os.path.join(ctx_dir, "*.ctx"))
+        return ctx_files[0] if ctx_files else None
 
 
 def read_ctx_file(file_path):
@@ -991,15 +1273,15 @@ def read_ctx_file(file_path):
             try:
                 data = yaml.safe_load(f) or {}
 
-                # Normalize 'databases'
+                
                 if 'databases' in data and isinstance(data['databases'], list):
                     data['databases'] = [{"value": item} for item in data['databases']]
                 
-                # Normalize 'mcp_servers'
+                
                 if 'mcp_servers' in data and isinstance(data['mcp_servers'], list):
                     data['mcp_servers'] = [{"value": item} for item in data['mcp_servers']]
 
-                # Normalize 'preferences'
+                
                 if 'preferences' in data and isinstance(data['preferences'], list):
                     data['preferences'] = [{"value": item} for item in data['preferences']]
 
@@ -1007,25 +1289,25 @@ def read_ctx_file(file_path):
             except yaml.YAMLError as e:
                 print(f"YAML parsing error in {file_path}: {e}")
                 return {"error": "Failed to parse YAML."}
-    return {} # Return empty dict if file doesn't exist
+    return {} 
 
 def write_ctx_file(file_path, data):
     """Writes a dictionary to a YAML .ctx file, denormalizing list of objects back to strings."""
     if not file_path:
         return False
     
-    # Create a deep copy to avoid modifying the original data object
+    
     data_to_save = json.loads(json.dumps(data)) 
 
-    # Denormalize 'databases'
+    
     if 'databases' in data_to_save and isinstance(data_to_save['databases'], list):
         data_to_save['databases'] = [item.get("value", "") for item in data_to_save['databases'] if isinstance(item, dict)]
     
-    # Denormalize 'mcp_servers'
+    
     if 'mcp_servers' in data_to_save and isinstance(data_to_save['mcp_servers'], list):
         data_to_save['mcp_servers'] = [item.get("value", "") for item in data_to_save['mcp_servers'] if isinstance(item, dict)]
 
-    # Denormalize 'preferences'
+    
     if 'preferences' in data_to_save and isinstance(data_to_save['preferences'], list):
         data_to_save['preferences'] = [item.get("value", "") for item in data_to_save['preferences'] if isinstance(item, dict)]
 
@@ -1097,7 +1379,7 @@ def save_project_context():
 
 
 
-### RESPONSE HANDLING
+
 
 @app.route("/api/get_attachment_response", methods=["POST"])
 def get_attachment_response():
@@ -1114,12 +1396,12 @@ def get_attachment_response():
     provider = data.get("provider")
     message_id = data.get("messageId")
     
-    # Load project-specific environment variables if currentPath is provided
+    
     if current_path:
         loaded_vars = load_project_env(current_path)
         print(f"Loaded project env variables for attachment response: {list(loaded_vars.keys())}")
     
-    # Load the NPC if a name was provided
+    
     npc_object = None
     if npc_name:
         db_conn = get_db_connection()
@@ -1171,17 +1453,32 @@ def get_attachment_response():
     messages = response["messages"]
     response = response["response"]
 
-    # Save new messages
+    
     save_conversation_message(
-        command_history, conversation_id, "user", message_to_send, 
-        wd=current_path, team=team, model=model, provider=provider, 
-        npc=npc_name, attachments=attachments_loaded
+        command_history, 
+        conversation_id, 
+        "user", 
+        message_to_send, 
+        wd=current_path, 
+        team=team, 
+        model=model, 
+        provider=provider, 
+        npc=npc_name, 
+        attachments=attachments_loaded
     )
 
     save_conversation_message(
-        command_history, conversation_id, "assistant", response,
-        wd=current_path, team=team, model=model, provider=provider,
-        npc=npc_name, attachments=attachments_loaded, message_id=message_id
+        command_history, 
+        conversation_id, 
+        "assistant", 
+        response,
+        wd=current_path, 
+        team=team, 
+        model=model, 
+        provider=provider,
+        npc=npc_name, 
+        attachments=attachments_loaded, 
+        message_id=message_id
     )
     
     return jsonify({
@@ -1200,7 +1497,7 @@ IMAGE_MODELS = {
     ],
     "gemini": [
         {"value": "gemini-2.5-flash-image-preview", "display_name": "Gemini 2.5 Flash Image"},
-        {"value": "imagen-3.0-generate-002", "display_name": "Imagen 3.0 Generate (Preview)"}, # ADDED MODEL
+        {"value": "imagen-3.0-generate-002", "display_name": "Imagen 3.0 Generate (Preview)"}, 
     ],
     "diffusers": [
         {"value": "runwayml/stable-diffusion-v1-5", "display_name": "Stable Diffusion v1.5"},
@@ -1212,13 +1509,13 @@ def get_available_image_models(current_path=None):
     Retrieves available image generation models based on environment variables
     and predefined configurations.
     """
-    # Load project-specific environment variables (or rely on load_dotenv in server start)
+    
     if current_path:
-        load_project_env(current_path) # Reloads into os.environ
+        load_project_env(current_path) 
     
     all_image_models = []
 
-    # --- Prioritize models from NPCSH_IMAGE_MODEL/PROVIDER environment variables ---
+    
     env_image_model = os.getenv("NPCSH_IMAGE_MODEL")
     env_image_provider = os.getenv("NPCSH_IMAGE_PROVIDER")
 
@@ -1229,9 +1526,9 @@ def get_available_image_models(current_path=None):
             "display_name": f"{env_image_model} | {env_image_provider} (Configured)"
         })
 
-    # Add models from predefined IMAGE_MODELS
+    
     for provider_key, models_list in IMAGE_MODELS.items():
-        # Check if API keys/configs are available for cloud providers
+        
         if provider_key == "openai":
             if os.environ.get("OPENAI_API_KEY"):
                 all_image_models.extend([
@@ -1239,21 +1536,21 @@ def get_available_image_models(current_path=None):
                     for model in models_list
                 ])
         elif provider_key == "gemini":
-            if os.environ.get("GEMINI_API_KEY"): # Assuming GEMINI_API_KEY is used
+            if os.environ.get("GEMINI_API_KEY"): 
                 all_image_models.extend([
                     {**model, "provider": provider_key, "display_name": f"{model['display_name']} | {provider_key}"}
                     for model in models_list
                 ])
         elif provider_key == "diffusers":
-            # For diffusers, we'll assume they are always potentially available
-            # as `gen_image` is expected to handle the download/local inference.
+            
+            
             all_image_models.extend([
                 {**model, "provider": provider_key, "display_name": f"{model['display_name']} | {provider_key}"}
                 for model in models_list
             ])
-        # Add other providers here with their respective checks
+        
 
-    # Ensure uniqueness based on (value, provider) tuple
+    
     seen_models = set()
     unique_models = []
     for model_entry in all_image_models:
@@ -1264,6 +1561,187 @@ def get_available_image_models(current_path=None):
 
     return unique_models
 
+@app.route('/api/generative_fill', methods=['POST'])
+def generative_fill():
+    data = request.get_json()
+    image_path = data.get('imagePath')
+    mask_data = data.get('mask')
+    prompt = data.get('prompt')
+    model = data.get('model')
+    provider = data.get('provider')
+    
+    if not all([image_path, mask_data, prompt, model, provider]):
+        return jsonify({"error": "Missing required fields"}), 400
+    
+    try:
+        image_path = os.path.expanduser(image_path)
+        
+        mask_b64 = mask_data.split(',')[1] if ',' in mask_data else mask_data
+        mask_bytes = base64.b64decode(mask_b64)
+        mask_image = Image.open(BytesIO(mask_bytes))
+        
+        original_image = Image.open(image_path)
+        
+        if provider == 'openai':
+            result = inpaint_openai(original_image, mask_image, prompt, model)
+        elif provider == 'gemini':
+            result = inpaint_gemini(original_image, mask_image, prompt, model)
+        elif provider == 'diffusers':
+            result = inpaint_diffusers(original_image, mask_image, prompt, model)
+        else:
+            return jsonify({"error": f"Provider {provider} not supported"}), 400
+        
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"inpaint_{timestamp}.png"
+        save_dir = os.path.dirname(image_path)
+        result_path = os.path.join(save_dir, filename)
+        
+        result.save(result_path)
+        
+        return jsonify({"resultPath": result_path, "error": None})
+        
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+def inpaint_openai(image, mask, prompt, model):
+    import io
+    from openai import OpenAI
+    from PIL import Image
+    import base64
+    
+    client = OpenAI()
+    
+    original_size = image.size
+    
+    if model == 'dall-e-2':
+        valid_sizes = ['256x256', '512x512', '1024x1024']
+        max_dim = max(image.width, image.height)
+        
+        if max_dim <= 256:
+            target_size = (256, 256)
+            size_str = '256x256'
+        elif max_dim <= 512:
+            target_size = (512, 512)
+            size_str = '512x512'
+        else:
+            target_size = (1024, 1024)
+            size_str = '1024x1024'
+    else:
+        valid_sizes = {
+            (1024, 1024): "1024x1024",
+            (1024, 1536): "1024x1536", 
+            (1536, 1024): "1536x1024"
+        }
+        
+        target_size = (1024, 1024)
+        for size in valid_sizes.keys():
+            if image.width > image.height and size == (1536, 1024):
+                target_size = size
+                break
+            elif image.height > image.width and size == (1024, 1536):
+                target_size = size
+                break
+        
+        size_str = valid_sizes[target_size]
+    
+    resized_image = image.resize(target_size, Image.Resampling.LANCZOS)
+    resized_mask = mask.resize(target_size, Image.Resampling.LANCZOS)
+    
+    img_bytes = io.BytesIO()
+    resized_image.save(img_bytes, format='PNG')
+    img_bytes.seek(0)
+    img_bytes.name = 'image.png'
+    
+    mask_bytes = io.BytesIO()
+    resized_mask.save(mask_bytes, format='PNG')
+    mask_bytes.seek(0)
+    mask_bytes.name = 'mask.png'
+    
+    response = client.images.edit(
+        model=model,
+        image=img_bytes,
+        mask=mask_bytes,
+        prompt=prompt,
+        n=1,
+        size=size_str
+    )
+    
+    if response.data[0].url:
+        import requests
+        img_data = requests.get(response.data[0].url).content
+    elif hasattr(response.data[0], 'b64_json'):
+        img_data = base64.b64decode(response.data[0].b64_json)
+    else:
+        raise Exception("No image data in response")
+    
+    result_image = Image.open(io.BytesIO(img_data))
+    return result_image.resize(original_size, Image.Resampling.LANCZOS)
+
+def inpaint_diffusers(image, mask, prompt, model):
+    from diffusers import StableDiffusionInpaintPipeline
+    import torch
+    
+    pipe = StableDiffusionInpaintPipeline.from_pretrained(
+        model,
+        torch_dtype=torch.float16
+    )
+    pipe = pipe.to("cuda" if torch.cuda.is_available() else "cpu")
+    
+    result = pipe(
+        prompt=prompt,
+        image=image,
+        mask_image=mask
+    ).images[0]
+    
+    return result
+def inpaint_gemini(image, mask, prompt, model):
+    from npcpy.gen.image_gen import generate_image
+    import io
+    import numpy as np
+    
+    mask_np = np.array(mask.convert('L'))
+    ys, xs = np.where(mask_np > 128)
+    
+    if len(xs) == 0:
+        return image
+    
+    x_center = int(np.mean(xs))
+    y_center = int(np.mean(ys))
+    width_pct = (xs.max() - xs.min()) / image.width * 100
+    height_pct = (ys.max() - ys.min()) / image.height * 100
+    
+    position = "center"
+    if y_center < image.height / 3:
+        position = "top"
+    elif y_center > 2 * image.height / 3:
+        position = "bottom"
+    
+    if x_center < image.width / 3:
+        position += " left"
+    elif x_center > 2 * image.width / 3:
+        position += " right"
+    
+    img_bytes = io.BytesIO()
+    image.save(img_bytes, format='PNG')
+    img_bytes.seek(0)
+    
+    full_prompt =  f"""Using the provided image, change only the region in the {position} 
+        approximately {int(width_pct)}% wide by {int(height_pct)}% tall) to: {prompt}. 
+        
+        Keep everything else exactly the same, matching the original lighting and style.
+        You are in-painting the image. You should not be changing anything other than what was requested in prompt: {prompt}
+        """    
+    results = generate_image(
+        prompt=full_prompt,
+        model=model,
+        provider='gemini',
+        attachments=[img_bytes],
+        n_images=1
+    )
+    
+    return results[0] if results else None
 
 @app.route('/api/generate_images', methods=['POST'])
 def generate_images():
@@ -1282,11 +1760,11 @@ def generate_images():
     if not model_name or not provider_name:
         return jsonify({"error": "Image model and provider are required."}), 400
 
-    # Expand save directory path
+    
     save_dir = os.path.expanduser(save_dir)
     os.makedirs(save_dir, exist_ok=True)
 
-    # Add datetime to base filename
+    
     timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
     base_filename_with_time = f"{base_filename}_{timestamp}"
 
@@ -1295,7 +1773,7 @@ def generate_images():
     command_history = CommandHistory(app.config.get('DB_PATH'))
     
     try:
-        # Process attachments if any
+        
         input_images = []
         attachments_loaded = []
         
@@ -1309,7 +1787,7 @@ def generate_images():
                             pil_img = Image.open(image_path)
                             input_images.append(pil_img)
                             
-                            # Load attachment for database storage
+                            
                             with open(image_path, 'rb') as f:
                                 img_data = f.read()
                             attachments_loaded.append({
@@ -1321,7 +1799,7 @@ def generate_images():
                         except Exception as e:
                             print(f"Warning: Could not load attachment image {image_path}: {e}")
 
-        # Call gen_image with input_images parameter
+        
         images_list = gen_image(
             prompt, 
             model=model_name, 
@@ -1336,16 +1814,16 @@ def generate_images():
         generated_attachments = []
         for i, pil_image in enumerate(images_list):
             if isinstance(pil_image, Image.Image):
-                # Generate filename with datetime and index
+                
                 filename = f"{base_filename_with_time}_{i+1:03d}.png" if n > 1 else f"{base_filename_with_time}.png"
                 filepath = os.path.join(save_dir, filename)
                 print(f'saved file to {filepath}')
                 
-                # Save the image to disk
+                
                 pil_image.save(filepath, format="PNG")
                 generated_filenames.append(filepath)
                 
-                # Prepare attachment data for database
+                
                 buffered = BytesIO()
                 pil_image.save(buffered, format="PNG")
                 img_data = buffered.getvalue()
@@ -1357,19 +1835,19 @@ def generate_images():
                     "size": len(img_data)
                 })
                 
-                # Also return base64 for preview
+                
                 img_str = base64.b64encode(img_data).decode("utf-8")
                 generated_images_base64.append(f"data:image/png;base64,{img_str}")
             else:
                 print(f"Warning: gen_image returned non-PIL object ({type(pil_image)}). Skipping image conversion.")
 
-        # Save generation record to database
-        generation_id = command_history.generate_message_id()
         
-        # Save input prompt as user message
+        generation_id = generate_message_id()
+        
+        
         save_conversation_message(
             command_history,
-            generation_id,  # Use as conversation ID
+            generation_id,  
             "user",
             f"Generate {n} image(s): {prompt}",
             wd=save_dir,
@@ -1380,11 +1858,11 @@ def generate_images():
             message_id=generation_id
         )
         
-        # Save generated images as assistant response
+        
         response_message = f"Generated {len(generated_images_base64)} image(s) saved to {save_dir}"
         save_conversation_message(
             command_history,
-            generation_id,  # Same conversation ID
+            generation_id,  
             "assistant", 
             response_message,
             wd=save_dir,
@@ -1392,20 +1870,77 @@ def generate_images():
             provider=provider_name,
             npc="vixynt",
             attachments=generated_attachments,
-            message_id=command_history.generate_message_id()
+            message_id=generate_message_id()
         )
         
         return jsonify({
             "images": generated_images_base64, 
             "filenames": generated_filenames,
-            "generation_id": generation_id,  # Return for potential future reference
+            "generation_id": generation_id,  
             "error": None
         })
     except Exception as e:
         print(f"Image generation error: {str(e)}")
         traceback.print_exc()
         return jsonify({"images": [], "filenames": [], "error": str(e)}), 500
+
+
+
+@app.route("/api/mcp_tools", methods=["GET"])
+def get_mcp_tools():
+    """
+    API endpoint to retrieve the list of tools available from a given MCP server script.
+    It will try to use an existing client from corca_states if available and matching,
+    otherwise it creates a temporary client.
+    """
+    server_path = request.args.get("mcpServerPath")
+    conversation_id = request.args.get("conversationId")
+    npc_name = request.args.get("npc")
+    
+    if not server_path:
+        return jsonify({"error": "mcpServerPath parameter is required."}), 400
+
     
+    try:
+        from npcsh.corca import MCPClientNPC
+    except ImportError:
+        return jsonify({"error": "MCP Client (npcsh.corca) not available. Ensure npcsh.corca is installed and importable."}), 500
+
+    temp_mcp_client = None
+    try:
+        
+        if conversation_id and npc_name and hasattr(app, 'corca_states'):
+            state_key = f"{conversation_id}_{npc_name or 'default'}"
+            if state_key in app.corca_states:
+                existing_corca_state = app.corca_states[state_key]
+                if hasattr(existing_corca_state, 'mcp_client') and existing_corca_state.mcp_client \
+                   and existing_corca_state.mcp_client.server_script_path == server_path:
+                    print(f"Using existing MCP client for {state_key} to fetch tools.")
+                    temp_mcp_client = existing_corca_state.mcp_client
+                    return jsonify({"tools": temp_mcp_client.available_tools_llm, "error": None})
+
+        
+        print(f"Creating a temporary MCP client to fetch tools for {server_path}.")
+        temp_mcp_client = MCPClientNPC()
+        if temp_mcp_client.connect_sync(server_path):
+            return jsonify({"tools": temp_mcp_client.available_tools_llm, "error": None})
+        else:
+            return jsonify({"error": f"Failed to connect to MCP server at {server_path}."}), 500
+    except FileNotFoundError as e:
+        return jsonify({"error": f"MCP Server script not found: {e}"}), 404
+    except ValueError as e:
+        return jsonify({"error": f"Invalid MCP Server script: {e}"}), 400
+    except Exception as e:
+        print(f"Error getting MCP tools for {server_path}: {traceback.format_exc()}")
+        return jsonify({"error": f"An unexpected error occurred: {e}"}), 500
+    finally:
+        
+        if temp_mcp_client and temp_mcp_client.session and (
+            not (conversation_id and npc_name and hasattr(app, 'corca_states') and state_key in app.corca_states and getattr(app.corca_states[state_key], 'mcp_client', None) == temp_mcp_client)
+        ):
+            print(f"Disconnecting temporary MCP client for {server_path}.")
+            temp_mcp_client.disconnect_sync()
+
 
 @app.route("/api/image_models", methods=["GET"]) 
 def get_image_models_api():
@@ -1421,6 +1956,12 @@ def get_image_models_api():
         traceback.print_exc()
         return jsonify({"models": [], "error": str(e)}), 500
 
+
+
+
+
+
+
 @app.route("/api/stream", methods=["POST"])
 def stream():
     data = request.json
@@ -1451,22 +1992,16 @@ def stream():
     
     npc_object = None
     team_object = None
-    team = None  # Initialize team as None, will be inferred
-    
+    team = None  
     if npc_name:
-        # First check registered teams and capture team name if found
-        print('checking')
         if hasattr(app, 'registered_teams'):
-            print('has registered teams')
             for team_name, team_object in app.registered_teams.items():
-                print('team', team_object)
-
                 if hasattr(team_object, 'npcs'):
                     team_npcs = team_object.npcs
                     if isinstance(team_npcs, dict):
                         if npc_name in team_npcs:
                             npc_object = team_npcs[npc_name]
-                            team = team_name  # Capture the team name
+                            team = team_name 
                             npc_object.team = team_object
                             print(f"Found NPC {npc_name} in registered team {team_name}")
                             break
@@ -1474,7 +2009,7 @@ def stream():
                         for npc in team_npcs:
                             if hasattr(npc, 'name') and npc.name == npc_name:
                                 npc_object = npc
-                                team = team_name  # Capture the team name
+                                team = team_name  
                                 npc_object.team = team_object
                                 print(f"Found NPC {npc_name} in registered team {team_name}")
                                 break
@@ -1484,7 +2019,7 @@ def stream():
                         npc_object = team_object.forenpc
                         npc_object.team = team_object
 
-                        team = team_name  # Capture the team name
+                        team = team_name
                         print(f"Found NPC {npc_name} as forenpc in team {team_name}")
                         break
                 
@@ -1515,18 +2050,16 @@ def stream():
                     print('team', team_object)
 
                 else:
-                    # Create team with just this NPC
                     team_object = Team(npcs=[npc_object], db_conn=db_conn)
                     team_object.name = os.path.basename(team_directory) if team_directory else f"{npc_name}_team"
                     npc_object.team = team_object
                     print('team', team_object)                    
                 team_name = team_object.name
-                # Register the team in the app
+                
                 if not hasattr(app, 'registered_teams'):
                     app.registered_teams = {}
                 app.registered_teams[team_name] = team_object
                 
-                # Set the team variable for this request
                 team = team_name
                 
                 print(f"Created and registered team '{team_name}' with NPC {npc_name}")
@@ -1551,10 +2084,9 @@ def stream():
     attachments_for_db = []
     attachment_paths_for_llm = []
 
-    message_id = command_history.generate_message_id()
+    message_id = generate_message_id()
     if attachments:
-        # Create a unique directory for this message's attachments for auditing
-        attachment_dir = os.path.expanduser(f"~/.npcsh/attachments/{conversation_id}/{message_id}")
+        attachment_dir = os.path.expanduser(f"~/.npcsh/attachments/{conversation_id+message_id}/")
         os.makedirs(attachment_dir, exist_ok=True)
 
         for attachment in attachments:
@@ -1596,10 +2128,6 @@ def stream():
             except Exception as e:
                 print(f"Error processing attachment {attachment.get('name', 'N/A')}: {e}")
                 traceback.print_exc()
-
-
-
-
     messages = fetch_messages_for_conversation(conversation_id)
     if len(messages) == 0 and npc_object is not None:
         messages = [{'role': 'system', 
@@ -1629,8 +2157,7 @@ def stream():
     
     
     exe_mode = data.get('executionMode','chat')
-    print(exe_mode)
-    print(data)
+    
     if exe_mode == 'chat':
         stream_response = get_llm_response(
             commandstr, 
@@ -1639,6 +2166,7 @@ def stream():
             model=model,
             provider=provider, 
             npc=npc_object, 
+            api_url = npc_object.api_url if npc_object.api_url else None,
             team=team_object,
             stream=True, 
             attachments=attachment_paths_for_llm,
@@ -1646,25 +2174,7 @@ def stream():
             **tool_args
         )
         messages = stream_response.get('messages', messages)
-        user_message_filled = ''
-        if isinstance(messages[-1].get('content'), list):
-            for cont in messages[-1].get('content'):
-                txt = cont.get('text')
-                if txt is not None:
-                    user_message_filled +=txt       
-        save_conversation_message(
-            command_history, 
-            conversation_id, 
-            "user", 
-            user_message_filled if len(user_message_filled)>0 else commandstr, 
-            wd=current_path, 
-            model=model, 
-            provider=provider, 
-            npc=npc_name,
-            team=team, 
-            attachments=attachments_for_db, 
-            message_id=message_id,
-        )
+
     elif exe_mode == 'npcsh':
         from npcsh._state import execute_command, initial_state
         from npcsh.routes import router
@@ -1673,38 +2183,161 @@ def stream():
         initial_state.npc = npc_object
         initial_state.team = team_object
         initial_state.messages = messages
-        #attachments=attachment_paths_for_llm,
-        #images=images, 
+        initial_state.command_history = command_history
+        
         state, stream_response = execute_command(
             commandstr, 
             initial_state, router=router)
-        #messages = stream_response.get('messages', messages)
-        
-        # user_message_filled = ''
-        #if isinstance(messages[-1].get('content'), list):
-        #    for cont in messages[-1].get('content'):
-        #        txt = cont.get('text')
-        #        if txt is not None:
-        #            user_message_filled +=txt       
-        #save_conversation_message(
-        #    command_history, 
-        #    conversation_id, 
-        #    "user", 
-        #    user_message_filled if len(user_message_filled)>0 else commandstr, 
-        ##    wd=current_path, 
-        #    model=model, 
-        #    provider=provider, 
-        #    npc=npc_name,
-        #    team=team, 
-        #    attachments=attachments_for_db, 
-        #    message_id=message_id,
+        messages = state.messages        
+        
     elif exe_mode == 'guac':
-        print('not enabled yet')
+        from npcsh.guac import execute_guac_command
+        from npcsh.routes import router
+        from npcsh._state import initial_state
+        from pathlib import Path
+        import pandas as pd, numpy as np, matplotlib.pyplot as plt
+
+        if not hasattr(app, 'guac_locals'):
+            app.guac_locals = {}
+
+        if conversation_id not in app.guac_locals:
+            app.guac_locals[conversation_id] = {
+                'pd': pd, 
+                'np': np, 
+                'plt': plt, 
+                'datetime': datetime,
+                'Path': Path, 
+                'os': os, 
+                'sys': sys, 
+                'json': json
+            }
+
+        initial_state.model = model
+        initial_state.provider = provider  
+        initial_state.npc = npc_object
+        initial_state.team = team_object
+        initial_state.messages = messages
+        initial_state.command_history = command_history
+        
+        state, stream_response = execute_guac_command(
+            commandstr,
+            initial_state, 
+            app.guac_locals[conversation_id],
+            "guac",
+            Path.cwd() / "npc_team", 
+            router
+        )
+        messages = state.messages
         
     elif exe_mode == 'corca':
-        print('not enabled yet')
-    
-    message_id = command_history.generate_message_id()
+        
+        try:
+            from npcsh.corca import execute_command_corca, create_corca_state_and_mcp_client, MCPClientNPC
+            from npcsh._state import initial_state as state
+        except ImportError:
+            
+            print("ERROR: npcsh.corca or MCPClientNPC not found. Corca mode is disabled.", file=sys.stderr)
+            state = None 
+            stream_response = {"output": "Corca mode is not available due to missing dependencies.", "messages": messages}
+            
+        
+        if state is not None: 
+            
+            mcp_server_path_from_request = data.get("mcpServerPath")
+            selected_mcp_tools_from_request = data.get("selectedMcpTools", [])
+            
+            
+            effective_mcp_server_path = mcp_server_path_from_request
+            if not effective_mcp_server_path and team_object and hasattr(team_object, 'team_ctx') and team_object.team_ctx:
+                mcp_servers_list = team_object.team_ctx.get('mcp_servers', [])
+                if mcp_servers_list and isinstance(mcp_servers_list, list):
+                    first_server_obj = next((s for s in mcp_servers_list if isinstance(s, dict) and 'value' in s), None)
+                    if first_server_obj:
+                        effective_mcp_server_path = first_server_obj['value']
+                elif isinstance(team_object.team_ctx.get('mcp_server'), str): 
+                    effective_mcp_server_path = team_object.team_ctx.get('mcp_server')
+
+            
+            if not hasattr(app, 'corca_states'):
+                app.corca_states = {}
+            
+            state_key = f"{conversation_id}_{npc_name or 'default'}"
+            
+            corca_state = None
+            if state_key not in app.corca_states:
+                
+                corca_state = create_corca_state_and_mcp_client(
+                    conversation_id=conversation_id,
+                    command_history=command_history,
+                    npc=npc_object,
+                    team=team_object,
+                    current_path=current_path,
+                    mcp_server_path=effective_mcp_server_path
+                )
+                app.corca_states[state_key] = corca_state
+            else:
+                corca_state = app.corca_states[state_key]
+                corca_state.npc = npc_object
+                corca_state.team = team_object
+                corca_state.current_path = current_path
+                corca_state.messages = messages
+                corca_state.command_history = command_history
+
+                
+                current_mcp_client_path = getattr(corca_state.mcp_client, 'server_script_path', None)
+
+                if effective_mcp_server_path != current_mcp_client_path:
+                    print(f"MCP server path changed/updated for {state_key}. Disconnecting old client (if any) and reconnecting to {effective_mcp_server_path or 'None'}.")
+                    if corca_state.mcp_client and corca_state.mcp_client.session:
+                        corca_state.mcp_client.disconnect_sync()
+                        corca_state.mcp_client = None 
+
+                    if effective_mcp_server_path:
+                        new_mcp_client = MCPClientNPC()
+                        if new_mcp_client.connect_sync(effective_mcp_server_path):
+                            corca_state.mcp_client = new_mcp_client
+                            print(f"Successfully reconnected MCP client for {state_key} to {effective_mcp_server_path}.")
+                        else:
+                            print(f"Failed to reconnect MCP client for {state_key} to {effective_mcp_server_path}. Corca will have no tools.")
+                            corca_state.mcp_client = None
+                    
+                
+            
+            state, stream_response = execute_command_corca(
+                commandstr,
+                corca_state,
+                command_history,
+                selected_mcp_tools_names=selected_mcp_tools_from_request 
+            )
+            
+            
+            app.corca_states[state_key] = state
+            messages = state.messages 
+
+
+    user_message_filled = ''
+
+    if isinstance(messages[-1].get('content'), list):
+        for cont in messages[-1].get('content'):
+            txt = cont.get('text')
+            if txt is not None:
+                user_message_filled +=txt       
+    save_conversation_message(
+        command_history, 
+        conversation_id, 
+        "user", 
+        user_message_filled if len(user_message_filled)>0 else commandstr, 
+        wd=current_path, 
+        model=model, 
+        provider=provider, 
+        npc=npc_name,
+        team=team, 
+        attachments=attachments_for_db, 
+        message_id=message_id,
+    )
+
+
+    message_id = generate_message_id()
 
     def event_stream(current_stream_id):
         complete_response = []
@@ -1713,7 +2346,8 @@ def stream():
         tool_call_data = {"id": None, "function_name": None, "arguments": ""}
 
         try:
-            if isinstance(stream_response, str) or isinstance(stream_response.get('output'), str):
+            if isinstance(stream_response, str) :
+                print('stream a str and not a gen')
                 chunk_data = {
                         "id": None, 
                         "object": None, 
@@ -1724,7 +2358,28 @@ def stream():
                                 "index": 0, 
                                 "delta": 
                                     {
-                                        "content": stream_response.get('output') or stream_response,
+                                        "content": stream_response,
+                                        "role": "assistant"
+                                  }, 
+                                "finish_reason": 'done'
+                            }
+                        ]
+                    }
+                yield f"data: {json.dumps(chunk_data)}"
+                return
+            elif isinstance(stream_response, dict) and 'output' in stream_response and isinstance(stream_response.get('output'), str):
+                print('stream a str and not a gen')                
+                chunk_data = {
+                        "id": None, 
+                        "object": None, 
+                        "created": datetime.datetime.now().strftime('YYYY-DD-MM-HHMMSS'), 
+                        "model": model,
+                        "choices": [
+                            {
+                                "index": 0, 
+                                "delta": 
+                                    {
+                                        "content": stream_response.get('output') ,
                                         "role": "assistant"
                                   }, 
                                 "finish_reason": 'done'
@@ -1742,7 +2397,7 @@ def stream():
 
                 print('.', end="", flush=True)
                 dot_count += 1
-                if "hf.co" in model or provider == 'ollama':
+                if "hf.co" in model or provider == 'ollama' and 'gpt-oss' not in model:
                     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"]:
@@ -1759,7 +2414,9 @@ def stream():
                     if chunk_content:
                         complete_response.append(chunk_content)
                     chunk_data = {
-                        "id": None, "object": None, "created": response_chunk["created_at"], "model": response_chunk["model"],
+                        "id": None, "object": None, 
+                        "created": response_chunk["created_at"] or datetime.datetime.now(), 
+                        "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"
@@ -1823,6 +2480,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():
@@ -1834,12 +2513,12 @@ def execute():
         import uuid
         stream_id = str(uuid.uuid4())
 
-    # --- NEW: Set the initial cancellation state for this new stream ---
+    
     with cancellation_lock:
         cancellation_flags[stream_id] = False
     print(f"Starting execute stream with ID: {stream_id}")
 
-    # Your original code...
+    
     commandstr = data.get("commandstr")
     conversation_id = data.get("conversationId")
     model = data.get("model", 'llama3.2')
@@ -1860,7 +2539,7 @@ def execute():
     npc_object = None
     team_object = None
     
-    # Handle team execution
+    
     if team:
         print(team)
         if hasattr(app, 'registered_teams') and team in app.registered_teams:
@@ -1869,13 +2548,13 @@ def execute():
         else:
             print(f"Warning: Team {team} not found in registered teams")
     
-    # Handle individual NPC execution
+    
     if npc_name:
-        # First check if there's a registered team and the NPC exists within that team
+        
         if team and hasattr(app, 'registered_teams') and team in app.registered_teams:
             team_object = app.registered_teams[team]
             print('team', team_object)
-            # Check if NPC exists in team's npcs (could be dict or list)
+            
             if hasattr(team_object, 'npcs'):
                 team_npcs = team_object.npcs
                 if isinstance(team_npcs, dict):
@@ -1888,18 +2567,18 @@ def execute():
                             npc_object = npc
                             print(f"Found NPC {npc_name} in registered team {team}")
                             break
-            # Also check the forenpc
+            
             if not npc_object and hasattr(team_object, 'forenpc') and hasattr(team_object.forenpc, 'name'):
                 if team_object.forenpc.name == npc_name:
                     npc_object = team_object.forenpc
                     print(f"Found NPC {npc_name} as forenpc in team {team}")
         
-        # If not found in team, check registered NPCs directly
+        
         if not npc_object and hasattr(app, 'registered_npcs') and npc_name in app.registered_npcs:
             npc_object = app.registered_npcs[npc_name]
             print(f"Found NPC {npc_name} in registered NPCs")
         
-        # Finally fall back to loading from files
+        
         if not npc_object:
             db_conn = get_db_connection()
             npc_object = load_npc_by_name_and_source(npc_name, npc_source, db_conn, current_path)
@@ -1947,7 +2626,7 @@ def execute():
     if npc_object is not None and messages and messages[0]['role'] == 'system':
         messages[0]['content'] = npc_object.get_system_prompt()
 
-    message_id = command_history.generate_message_id()
+    message_id = generate_message_id()
     save_conversation_message(
         command_history, conversation_id, "user", commandstr,
         wd=current_path, model=model, provider=provider, npc=npc_name,
@@ -1958,18 +2637,18 @@ def execute():
         provider=provider, npc=npc_object, team=team_object, stream=True
     )
     print(response_gen)
-    #print(npc_object, provider, model)
-    message_id = command_history.generate_message_id()
+    
+    message_id = generate_message_id()
 
     def event_stream(current_stream_id):
         complete_response = []
         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']:
-                # --- Check the cancellation flag on every iteration ---
+            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.")
@@ -1979,28 +2658,7 @@ def execute():
                 print('.', end="", flush=True)
                 dot_count += 1
                 
-                chunk_content = ""
-                if isinstance(response_chunk, dict) and response_chunk.get("role") == "decision":
-                    # Stream decision immediately in standard format
-                    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"]:
@@ -2010,46 +2668,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: # its a string so assemble it
-                        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}")
@@ -2061,13 +2714,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:
@@ -2076,6 +2790,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"])
@@ -2116,7 +2831,7 @@ def get_conversations():
                 ORDER BY MAX(timestamp) DESC
                 """)
 
-                # Check both with and without trailing slash
+                
                 path_without_slash = path.rstrip('/')
                 path_with_slash = path_without_slash + '/'
                 
@@ -2130,11 +2845,11 @@ def get_conversations():
                     {
                         "conversations": [
                             {
-                                "id": conv[0],  # conversation_id
-                                "timestamp": conv[1],  # start_time
-                                "last_message_timestamp": conv[2],  # last_message_timestamp
+                                "id": conv[0],  
+                                "timestamp": conv[1],  
+                                "last_message_timestamp": conv[2],  
                                 "preview": (
-                                    conv[3][:100] + "..."  # preview (now index 3)
+                                    conv[3][:100] + "..."  
                                     if conv[3] and len(conv[3]) > 100
                                     else conv[3]
                                 ),
@@ -2158,7 +2873,7 @@ def get_conversation_messages(conversation_id):
     try:
         engine = get_db_connection()
         with engine.connect() as conn:
-            # Modified query to ensure proper ordering and deduplication
+            
             query = text("""
                 WITH ranked_messages AS (
                     SELECT
@@ -2187,7 +2902,7 @@ def get_conversation_messages(conversation_id):
                 {
                     "messages": [
                         {
-                            "message_id": msg[1] if len(msg) > 1 else None,  # Adjust indices based on your schema
+                            "message_id": msg[1] if len(msg) > 1 else None,  
                             "role": msg[3] if len(msg) > 3 else None,
                             "content": msg[4] if len(msg) > 4 else None,
                             "timestamp": msg[5] if len(msg) > 5 else None,
@@ -2196,7 +2911,7 @@ def get_conversation_messages(conversation_id):
                             "npc": msg[8] if len(msg) > 8 else None,
                             "attachments": (
                                 get_message_attachments(msg[1])
-                                if len(msg) > 1 and msg[-1]  # attachment_ids
+                                if len(msg) > 1 and msg[-1]  
                                 else []
                             ),
                         }
@@ -2224,12 +2939,12 @@ def after_request(response):
 @app.route('/api/ollama/status', methods=['GET'])
 def ollama_status():
     try:
-        # The library's list function is a reliable way to check for a connection.
-        # It will raise an exception if it can't connect.
+        
+        
         ollama.list()
         return jsonify({"status": "running"})
     except ollama.RequestError as e:
-        # This catches connection errors, indicating Ollama is not running
+        
         print(f"Ollama status check failed: {e}")
         return jsonify({"status": "not_found"})
     except Exception as e:
@@ -2242,7 +2957,7 @@ def get_ollama_models():
     response = ollama.list()
     models_list = []
     
-    # The response is a list of Model objects. Access attributes with dot notation.
+    
     for model_obj in response['models']:
         models_list.append({
             "name": model_obj.model,
@@ -2264,7 +2979,7 @@ def delete_ollama_model():
         ollama.delete(model_name)
         return jsonify({"success": True, "message": f"Model {model_name} deleted."})
     except ollama.ResponseError as e:
-        # This will catch errors from Ollama, like "model not found"
+        
         return jsonify({"error": e.error}), e.status_code
     except Exception as e:
         return jsonify({"error": str(e)}), 500
@@ -2281,8 +2996,8 @@ def pull_ollama_model():
         try:
             stream = ollama.pull(model_name, stream=True)
             for progress_obj in stream:
-                # The stream yields ProgressResponse objects.
-                # Access their attributes and convert to a dictionary for JSON.
+                
+                
                 yield json.dumps({
                     'status': getattr(progress_obj, 'status', None),
                     'digest': getattr(progress_obj, 'digest', None),
@@ -2356,7 +3071,7 @@ def start_flask_server(
     user_npc_directory = None
 ):
     try:
-        # Register teams and NPCs with the app
+        
         if teams:
             app.registered_teams = teams
             print(f"Registered {len(teams)} teams: {list(teams.keys())}")
@@ -2368,14 +3083,14 @@ def start_flask_server(
             print(f"Registered {len(npcs)} NPCs: {list(npcs.keys())}")
         else:
             app.registered_npcs = {}
-        # Ensure the database tables exist
+        
         app.config['DB_PATH'] = db_path
         app.config['user_npc_directory'] = user_npc_directory
 
         command_history = CommandHistory(db_path)
         app.command_history = command_history
 
-        # Only apply CORS if origins are specified
+        
         if cors_origins:
 
             CORS(
@@ -2387,7 +3102,7 @@ def start_flask_server(
                 
             )
 
-        # Run the Flask app on all interfaces
+        
         print(f"Starting Flask server on http://0.0.0.0:{port}")
         app.run(host="0.0.0.0", port=port, debug=debug,  threaded=True)
     except Exception as e:
@@ -2398,8 +3113,8 @@ if __name__ == "__main__":
 
     SETTINGS_FILE = Path(os.path.expanduser("~/.npcshrc"))
 
-    # Configuration
+    
     db_path = os.path.expanduser("~/npcsh_history.db")
     user_npc_directory = os.path.expanduser("~/.npcsh/npc_team")
-    # Make project_npc_directory a function that updates based on current path
+    
     start_flask_server(db_path=db_path, user_npc_directory=user_npc_directory)