npcpy 1.2.33__py3-none-any.whl → 1.2.35__py3-none-any.whl

npcpy/serve.py

@@ -7,8 +7,10 @@ import uuid
 import sys 
 import traceback
 import glob
+import re
+import time
 
-
+import io
 from flask_cors import CORS
 import os
 import sqlite3
@@ -29,12 +31,27 @@ try:
     import ollama 
 except:
     pass
+from jinja2 import Environment, FileSystemLoader, Template, Undefined, DictLoader
+class SilentUndefined(Undefined):
+    def _fail_with_undefined_error(self, *args, **kwargs):
+        return ""
+
+# Import ShellState and helper functions from npcsh
+from npcsh._state import ShellState
+
+
+from npcpy.memory.knowledge_graph import load_kg_from_db
+from npcpy.memory.search import execute_rag_command, execute_brainblast_command
+from npcpy.data.load import load_file_contents
+from npcpy.data.web import search_web
+
+from npcsh._state import get_relevant_memories, search_kg_facts
 
 import base64
 import shutil
 import uuid
 
-from npcpy.llm_funcs import gen_image                                                                                                                                                                      
+from npcpy.llm_funcs import gen_image, breathe                                                                                                                                                                
 
 from sqlalchemy import create_engine, text
 from sqlalchemy.orm import sessionmaker
@@ -69,6 +86,82 @@ cancellation_flags = {}
 cancellation_lock = threading.Lock()
 
 
+class MCPServerManager:
+    """
+    Simple in-process tracker for launching/stopping MCP servers.
+    Currently uses subprocess.Popen to start a Python stdio MCP server script.
+    """
+
+    def __init__(self):
+        self._procs = {}
+        self._lock = threading.Lock()
+
+    def start(self, server_path: str):
+        server_path = os.path.expanduser(server_path)
+        abs_path = os.path.abspath(server_path)
+        if not os.path.exists(abs_path):
+            raise FileNotFoundError(f"MCP server script not found at {abs_path}")
+
+        with self._lock:
+            existing = self._procs.get(abs_path)
+            if existing and existing.poll() is None:
+                return {"status": "running", "pid": existing.pid, "serverPath": abs_path}
+
+            cmd = [sys.executable, abs_path]
+            proc = subprocess.Popen(
+                cmd,
+                cwd=os.path.dirname(abs_path) or ".",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            self._procs[abs_path] = proc
+            return {"status": "started", "pid": proc.pid, "serverPath": abs_path}
+
+    def stop(self, server_path: str):
+        server_path = os.path.expanduser(server_path)
+        abs_path = os.path.abspath(server_path)
+        with self._lock:
+            proc = self._procs.get(abs_path)
+            if not proc:
+                return {"status": "not_found", "serverPath": abs_path}
+            if proc.poll() is None:
+                proc.terminate()
+                try:
+                    proc.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    proc.kill()
+            del self._procs[abs_path]
+            return {"status": "stopped", "serverPath": abs_path}
+
+    def status(self, server_path: str):
+        server_path = os.path.expanduser(server_path)
+        abs_path = os.path.abspath(server_path)
+        with self._lock:
+            proc = self._procs.get(abs_path)
+            if not proc:
+                return {"status": "not_started", "serverPath": abs_path}
+            running = proc.poll() is None
+            return {
+                "status": "running" if running else "exited",
+                "serverPath": abs_path,
+                "pid": proc.pid,
+                "returncode": None if running else proc.returncode,
+            }
+
+    def running(self):
+        with self._lock:
+            return {
+                path: {
+                    "pid": proc.pid,
+                    "status": "running" if proc.poll() is None else "exited",
+                    "returncode": None if proc.poll() is None else proc.returncode,
+                }
+                for path, proc in self._procs.items()
+            }
+
+
+mcp_server_manager = MCPServerManager()
+
 def get_project_npc_directory(current_path=None):
     """
     Get the project NPC directory based on the current path
@@ -171,6 +264,34 @@ def get_db_session():
     Session = sessionmaker(bind=engine)
     return Session()
 
+
+def resolve_mcp_server_path(current_path=None, explicit_path=None, force_global=False):
+    """
+    Resolve an MCP server path using npcsh.corca's helper when available.
+    Falls back to ~/.npcsh/npc_team/mcp_server.py.
+    """
+    if explicit_path:
+        abs_path = os.path.abspath(os.path.expanduser(explicit_path))
+        if os.path.exists(abs_path):
+            return abs_path
+    try:
+        from npcsh.corca import _resolve_and_copy_mcp_server_path
+        resolved = _resolve_and_copy_mcp_server_path(
+            explicit_path=explicit_path,
+            current_path=current_path,
+            team_ctx_mcp_servers=None,
+            interactive=False,
+            auto_copy_bypass=True,
+            force_global=force_global,
+        )
+        if resolved:
+            return os.path.abspath(resolved)
+    except Exception as e:
+        print(f"resolve_mcp_server_path: fallback path due to error: {e}")
+    
+    fallback = os.path.expanduser("~/.npcsh/npc_team/mcp_server.py")
+    return fallback
+
 extension_map = {
     "PNG": "images",
     "JPG": "images",
@@ -426,8 +547,6 @@ def capture():
         return None
 
     return jsonify({"screenshot": screenshot})
-
-
 @app.route("/api/settings/global", methods=["GET", "OPTIONS"])
 def get_global_settings():
     if request.method == "OPTIONS":
@@ -436,22 +555,22 @@ def get_global_settings():
     try:
         npcshrc_path = os.path.expanduser("~/.npcshrc")
 
-        
         global_settings = {
             "model": "llama3.2",
             "provider": "ollama",
             "embedding_model": "nomic-embed-text",
             "embedding_provider": "ollama",
             "search_provider": "perplexity",
-            "NPC_STUDIO_LICENSE_KEY": "",
             "default_folder": os.path.expanduser("~/.npcsh/"),
+            "is_predictive_text_enabled": False, # Default value for the new setting
+            "predictive_text_model": "llama3.2", # Default predictive text model
+            "predictive_text_provider": "ollama", # Default predictive text provider
         }
         global_vars = {}
 
         if os.path.exists(npcshrc_path):
             with open(npcshrc_path, "r") as f:
                 for line in f:
-                    
                     line = line.split("#")[0].strip()
                     if not line:
                         continue
@@ -459,33 +578,35 @@ def get_global_settings():
                     if "=" not in line:
                         continue
 
-                    
                     key, value = line.split("=", 1)
                     key = key.strip()
                     if key.startswith("export "):
                         key = key[7:]
 
-                    
                     value = value.strip()
                     if value.startswith('"') and value.endswith('"'):
                         value = value[1:-1]
                     elif value.startswith("'") and value.endswith("'"):
                         value = value[1:-1]
 
-                    
                     key_mapping = {
                         "NPCSH_MODEL": "model",
                         "NPCSH_PROVIDER": "provider",
                         "NPCSH_EMBEDDING_MODEL": "embedding_model",
                         "NPCSH_EMBEDDING_PROVIDER": "embedding_provider",
                         "NPCSH_SEARCH_PROVIDER": "search_provider",
-                        "NPC_STUDIO_LICENSE_KEY": "NPC_STUDIO_LICENSE_KEY",
                         "NPCSH_STREAM_OUTPUT": "NPCSH_STREAM_OUTPUT",
                         "NPC_STUDIO_DEFAULT_FOLDER": "default_folder",
+                        "NPC_STUDIO_PREDICTIVE_TEXT_ENABLED": "is_predictive_text_enabled", # New mapping
+                        "NPC_STUDIO_PREDICTIVE_TEXT_MODEL": "predictive_text_model",         # New mapping
+                        "NPC_STUDIO_PREDICTIVE_TEXT_PROVIDER": "predictive_text_provider",   # New mapping
                     }
 
                     if key in key_mapping:
-                        global_settings[key_mapping[key]] = value
+                        if key == "NPC_STUDIO_PREDICTIVE_TEXT_ENABLED":
+                            global_settings[key_mapping[key]] = value.lower() == 'true'
+                        else:
+                            global_settings[key_mapping[key]] = value
                     else:
                         global_vars[key] = value
 
@@ -502,6 +623,7 @@ 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 = []
@@ -535,46 +657,12 @@ def get_available_jinxs():
         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.
+    Returns the output as a JSON response.
     """
     data = request.json
     
@@ -585,19 +673,18 @@ def execute_jinx():
     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)}")
+    print(f"--- Jinx Execution Request for streamId: {stream_id} ---", file=sys.stderr)
+    print(f"Request Data: {json.dumps(data, indent=2)}", file=sys.stderr)
 
     jinx_name = data.get("jinxName")
     jinx_args = data.get("jinxArgs", [])
-    print(f"Jinx Name: {jinx_name}, Jinx Args: {jinx_args}")
+    print(f"Jinx Name: {jinx_name}, Jinx Args: {jinx_args}", file=sys.stderr)
     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")
+        print("ERROR: conversationId is required for Jinx execution with persistent variables", file=sys.stderr)
         return jsonify({"error": "conversationId is required for Jinx execution with persistent variables"}), 400
 
     npc_name = data.get("npc")
@@ -605,223 +692,193 @@ def execute_jinx():
     current_path = data.get("currentPath")
     
     if not jinx_name:
-        print("ERROR: jinxName is required")
+        print("ERROR: jinxName is required", file=sys.stderr)
         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
+    jinx = 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)
+    else:
+        npc_object = None
     
-    # 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]
+        print(f"Found jinx in NPC's jinxs_dict", file=sys.stderr)
     
-    # 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
+        project_jinxs_base = os.path.join(current_path, 'npc_team', 'jinxs')
+        if os.path.exists(project_jinxs_base):
+            for root, dirs, files in os.walk(project_jinxs_base):
+                if f'{jinx_name}.jinx' in files:
+                    project_jinx_path = os.path.join(root, f'{jinx_name}.jinx')
+                    jinx = Jinx(jinx_path=project_jinx_path)
+                    print(f"Found jinx at: {project_jinx_path}", file=sys.stderr)
+                    break
+        
     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)
+        global_jinxs_base = os.path.expanduser('~/.npcsh/npc_team/jinxs')
+        if os.path.exists(global_jinxs_base):
+            for root, dirs, files in os.walk(global_jinxs_base):
+                if f'{jinx_name}.jinx' in files:
+                    global_jinx_path = os.path.join(root, f'{jinx_name}.jinx')
+                    jinx = Jinx(jinx_path=global_jinx_path)
+                    print(f"Found jinx at: {global_jinx_path}", file=sys.stderr)
+                    
+                    # Initialize jinx steps by calling render_first_pass
+                    from jinja2 import Environment
+                    temp_env = Environment()
+                    jinx.render_first_pass(temp_env, {})
+                    
+                    break
     
     if not jinx:
-        print(f"ERROR: Jinx '{jinx_name}' not found")
+        print(f"ERROR: Jinx '{jinx_name}' not found", file=sys.stderr)
+        searched_paths = []
+        if npc_object:
+            searched_paths.append(f"NPC {npc_name} jinxs_dict")
+        if current_path:
+            searched_paths.append(f"Project jinxs at {os.path.join(current_path, 'npc_team', 'jinxs')}")
+        searched_paths.append(f"Global jinxs at {os.path.expanduser('~/.npcsh/npc_team/jinxs')}")
+        print(f"Searched in: {', '.join(searched_paths)}", file=sys.stderr)
         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]
+    
+    # Filter out None values from jinx_args before processing
+    cleaned_jinx_args = [arg for arg in jinx_args if arg is not None]
+
+    while i < len(cleaned_jinx_args):
+        arg = cleaned_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])
+            while i < len(cleaned_jinx_args) and not cleaned_jinx_args[i].startswith('-'):
+                value_parts.append(cleaned_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
+    print(f'Executing jinx with input_values: {input_values}', file=sys.stderr)
+    
     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}")
+    print(f"--- CONTEXT STATE (conversationId: {conversation_id}) ---", file=sys.stderr)
+    print(f"jinx_local_context BEFORE Jinx execution: {jinx_local_context}", file=sys.stderr)
 
-    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)
+    
+    # Create state object
+    state = ShellState(
+        npc=npc_object,
+        team=None,
+        conversation_id=conversation_id,
+        chat_model=model or os.getenv('NPCSH_CHAT_MODEL', 'gemma3:4b'),
+        chat_provider=provider or os.getenv('NPCSH_CHAT_PROVIDER', 'ollama'),
+        current_path=current_path or os.getcwd(),
+        search_provider=os.getenv('NPCSH_SEARCH_PROVIDER', 'duckduckgo'),
+        embedding_model=os.getenv('NPCSH_EMBEDDING_MODEL', 'nomic-embed-text'),
+        embedding_provider=os.getenv('NPCSH_EMBEDDING_PROVIDER', 'ollama'),
+    )
+    
+    # Build extra_globals with state and all necessary functions
+    extra_globals_for_jinx = {
+        **jinx_local_context,
+        'state': state,
+        'CommandHistory': CommandHistory,
+        'load_kg_from_db': load_kg_from_db,
+        'execute_rag_command': execute_rag_command,
+        'execute_brainblast_command': execute_brainblast_command,
+        'load_file_contents': load_file_contents,
+        'search_web': search_web,
+        'get_relevant_memories': get_relevant_memories,
+        'search_kg_facts': search_kg_facts,
+    }
 
-            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} ---")
+    jinx_execution_result = jinx.execute(
+        input_values=input_values,
+        jinja_env=npc_object.jinja_env if npc_object else None,
+        npc=npc_object,
+        messages=messages,
+        extra_globals=extra_globals_for_jinx
+    )
+
+    output_from_jinx_result = jinx_execution_result.get('output')
     
-    return Response(event_stream(stream_id), mimetype="text/event-stream")
+    final_output_string = str(output_from_jinx_result) if output_from_jinx_result is not None else ""
+
+    if isinstance(jinx_execution_result, dict):
+        for key, value in jinx_execution_result.items():
+            jinx_local_context[key] = value
+
+    print(f"jinx_local_context AFTER Jinx execution (final state): {jinx_local_context}", file=sys.stderr)
+    print(f"Jinx execution result output: {output_from_jinx_result}", file=sys.stderr)
+
+    user_message_id = generate_message_id()
+    
+    # Use cleaned_jinx_args for logging the user message
+    user_command_log = f"/{jinx_name} {' '.join(cleaned_jinx_args)}"
+    save_conversation_message(
+        command_history,
+        conversation_id,
+        "user",
+        user_command_log,
+        wd=current_path,
+        model=model,
+        provider=provider,
+        npc=npc_name,
+        message_id=user_message_id
+    )
+    
+    assistant_message_id = generate_message_id()
+    save_conversation_message(
+        command_history,
+        conversation_id,
+        "assistant",
+        final_output_string,
+        wd=current_path,
+        model=model,
+        provider=provider,
+        npc=npc_name,
+        message_id=assistant_message_id
+    )
 
+    # Determine mimetype based on content
+    is_html = bool(re.search(r'<[a-z][\s\S]*>', final_output_string, re.IGNORECASE))
+    
+    if is_html:
+        return Response(final_output_string, mimetype="text/html")
+    else:
+        return Response(final_output_string, mimetype="text/plain")
 @app.route("/api/settings/global", methods=["POST", "OPTIONS"])
 def save_global_settings():
     if request.method == "OPTIONS":
@@ -837,35 +894,41 @@ def save_global_settings():
             "embedding_model": "NPCSH_EMBEDDING_MODEL",
             "embedding_provider": "NPCSH_EMBEDDING_PROVIDER",
             "search_provider": "NPCSH_SEARCH_PROVIDER",
-            "NPC_STUDIO_LICENSE_KEY": "NPC_STUDIO_LICENSE_KEY",
             "NPCSH_STREAM_OUTPUT": "NPCSH_STREAM_OUTPUT",
             "default_folder": "NPC_STUDIO_DEFAULT_FOLDER",
+            "is_predictive_text_enabled": "NPC_STUDIO_PREDICTIVE_TEXT_ENABLED", # New mapping
+            "predictive_text_model": "NPC_STUDIO_PREDICTIVE_TEXT_MODEL",         # New mapping
+            "predictive_text_provider": "NPC_STUDIO_PREDICTIVE_TEXT_PROVIDER",   # New mapping
         }
 
         os.makedirs(os.path.dirname(npcshrc_path), exist_ok=True)
         print(data)
         with open(npcshrc_path, "w") as f:
-            
+
             for key, value in data.get("global_settings", {}).items():
-                if key in key_mapping and value:
-                    
-                    if " " in str(value):
-                        value = f'"{value}"'
-                    f.write(f"export {key_mapping[key]}={value}\n")
+                if key in key_mapping and value is not None: # Check for None explicitly
+                    # Handle boolean conversion for saving
+                    if key == "is_predictive_text_enabled":
+                        value_to_write = str(value).upper()
+                    elif " " in str(value):
+                        value_to_write = f'"{value}"'
+                    else:
+                        value_to_write = str(value)
+                    f.write(f"export {key_mapping[key]}={value_to_write}\n")
 
-            
             for key, value in data.get("global_vars", {}).items():
-                if key and value:
+                if key and value is not None: # Check for None explicitly
                     if " " in str(value):
-                        value = f'"{value}"'
-                    f.write(f"export {key}={value}\n")
+                        value_to_write = f'"{value}"'
+                    else:
+                        value_to_write = str(value)
+                    f.write(f"export {key}={value_to_write}\n")
 
         return jsonify({"message": "Global settings saved successfully", "error": None})
 
     except Exception as e:
         print(f"Error in save_global_settings: {str(e)}")
         return jsonify({"error": str(e)}), 500
-
 @app.route("/api/settings/project", methods=["GET", "OPTIONS"])  
 def get_project_settings():
     if request.method == "OPTIONS":
@@ -1009,52 +1072,6 @@ def api_command(command):
         return jsonify(result)
     except Exception as e:
         return jsonify({"error": str(e)})
-@app.route("/api/npc_team_global")
-def get_npc_team_global():
-    try:
-        db_conn = get_db_connection()
-        global_npc_directory = os.path.expanduser("~/.npcsh/npc_team")
-
-        npc_data = []
-
-        
-        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)
-
-                
-                serialized_npc = {
-                    "name": npc.name,
-                    "primary_directive": npc.primary_directive,
-                    "model": npc.model,
-                    "provider": npc.provider,
-                    "api_url": npc.api_url,
-                    "use_global_jinxs": npc.use_global_jinxs,
-                    "jinxs": [
-                        {
-                            "jinx_name": jinx.jinx_name,
-                            "inputs": jinx.inputs,
-                            "steps": [
-                                {
-                                    "name": step.get("name", f"step_{i}"),
-                                    "engine": step.get("engine", "natural"),
-                                    "code": step.get("code", "")
-                                }
-                                for i, step in enumerate(jinx.steps)
-                            ]
-                        }
-                        for jinx in npc.jinxs
-                    ],
-                }
-                npc_data.append(serialized_npc)
-
-        return jsonify({"npcs": npc_data, "error": None})
-
-    except Exception as e:
-        print(f"Error loading global NPCs: {str(e)}")
-        return jsonify({"npcs": [], "error": str(e)})
-
 
 @app.route("/api/jinxs/save", methods=["POST"])
 def save_jinx():
@@ -1093,101 +1110,727 @@ def save_jinx():
         return jsonify({"status": "success"})
     except Exception as e:
         return jsonify({"error": str(e)}), 500
-
-
-@app.route("/api/save_npc", methods=["POST"])
-def save_npc():
-    try:
-        data = request.json
-        npc_data = data.get("npc")
-        is_global = data.get("isGlobal")
-        current_path = data.get("currentPath")
-
-        if not npc_data or "name" not in npc_data:
-            return jsonify({"error": "Invalid NPC data"}), 400
-
-        
-        if is_global:
-            npc_directory = os.path.expanduser("~/.npcsh/npc_team")
+def serialize_jinx_inputs(inputs):
+    result = []
+    for inp in inputs:
+        if isinstance(inp, str):
+            result.append(inp)
+        elif isinstance(inp, dict):
+            key = list(inp.keys())[0]
+            result.append(key)
         else:
-            npc_directory = os.path.join(current_path, "npc_team")
+            result.append(str(inp))
+    return result
 
-        
-        os.makedirs(npc_directory, exist_ok=True)
+@app.route("/api/jinx/test", methods=["POST"])
+def test_jinx():
+    data = request.json
+    jinx_data = data.get("jinx")
+    test_inputs = data.get("inputs", {})
+    current_path = data.get("currentPath")
+    
+    if current_path:
+        load_project_env(current_path)
+    
+    jinx = Jinx(jinx_data=jinx_data)
+    
+    from jinja2 import Environment
+    temp_env = Environment()
+    jinx.render_first_pass(temp_env, {})
+    
+    conversation_id = f"jinx_test_{uuid.uuid4().hex[:8]}"
+    command_history = CommandHistory(app.config.get('DB_PATH'))
+    
+    # 1. Save user's test command to conversation_history to get a message_id
+    user_test_command = f"Testing jinx /{jinx.jinx_name} with inputs: {test_inputs}"
+    user_message_id = generate_message_id()
+    save_conversation_message(
+        command_history,
+        conversation_id,
+        "user",
+        user_test_command,
+        wd=current_path,
+        model=None, # Or appropriate model/provider for the test context
+        provider=None,
+        npc=None,
+        message_id=user_message_id
+    )
 
-        
-        yaml_content = f"""name: {npc_data['name']}
-primary_directive: "{npc_data['primary_directive']}"
-model: {npc_data['model']}
-provider: {npc_data['provider']}
-api_url: {npc_data.get('api_url', '')}
-use_global_jinxs: {str(npc_data.get('use_global_jinxs', True)).lower()}
-"""
+    # Jinx execution status and output are now part of the assistant's response
+    jinx_execution_status = "success"
+    jinx_error_message = None
+    output = "Jinx execution did not complete." # Default output
 
-        
-        file_path = os.path.join(npc_directory, f"{npc_data['name']}.npc")
-        with open(file_path, "w") as f:
-            f.write(yaml_content)
+    try:
+        result = jinx.execute(
+            input_values=test_inputs,
+            npc=None,
+            messages=[],
+            extra_globals={},
+            jinja_env=temp_env
+        )
+        output = result.get('output', str(result))
+        if result.get('error'): # Assuming jinx.execute might return an 'error' key
+            jinx_execution_status = "failed"
+            jinx_error_message = str(result.get('error'))
+    except Exception as e:
+        jinx_execution_status = "failed"
+        jinx_error_message = str(e)
+        output = f"Jinx execution failed: {e}"
 
-        return jsonify({"message": "NPC saved successfully", "error": None})
+    # The jinx_executions table is populated by a trigger from conversation_history.
+    # The details of the execution (inputs, output, status) are now expected to be
+    # derived by analyzing the user's command and the subsequent assistant's response.
+    # No explicit update to jinx_executions is needed here.
 
-    except Exception as e:
-        print(f"Error saving NPC: {str(e)}")
-        return jsonify({"error": str(e)}), 500
+    # 2. Save assistant's response to conversation_history
+    assistant_response_message_id = generate_message_id() # ID for the assistant's response
+    save_conversation_message(
+        command_history,
+        conversation_id,
+        "assistant",
+        output, # The jinx output is the assistant's response for the test
+        wd=current_path,
+        model=None,
+        provider=None,
+        npc=None,
+        message_id=assistant_response_message_id
+    )
 
+    return jsonify({
+        "output": output,
+        "conversation_id": conversation_id,
+        "execution_id": user_message_id, # Return the user's message_id as the execution_id
+        "error": jinx_error_message
+    })
+from npcpy.ft.diff import train_diffusion, DiffusionConfig
+import threading
 
-@app.route("/api/npc_team_project", methods=["GET"])
-def get_npc_team_project():
-    try:
-        db_conn = get_db_connection()
+from npcpy.memory.knowledge_graph import (
+    load_kg_from_db,
+    save_kg_to_db # ADD THIS LINE to import the correct function
+)
 
-        project_npc_directory = request.args.get("currentPath")
-        if not project_npc_directory.endswith("npc_team"):
-            project_npc_directory = os.path.join(project_npc_directory, "npc_team")
+from collections import defaultdict # ADD THIS LINE for collecting links if not already present
 
-        npc_data = []
+finetune_jobs = {}
 
-        for file in os.listdir(project_npc_directory):
-            print(file)
-            if file.endswith(".npc"):
-                npc_path = os.path.join(project_npc_directory, file)
-                npc = NPC(file=npc_path, db_conn=db_conn)
+def extract_and_store_memories(
+    conversation_text,
+    conversation_id,
+    command_history,
+    npc_name,
+    team_name,
+    current_path,
+    model,
+    provider,
+    npc_object=None
+):
+    from npcpy.llm_funcs import get_facts
+    from npcpy.memory.command_history import format_memory_context
+    # Your CommandHistory.get_memory_examples_for_context returns a dict with 'approved' and 'rejected'
+    memory_examples_dict = command_history.get_memory_examples_for_context(
+        npc=npc_name,
+        team=team_name,
+        directory_path=current_path
+    )
+    
+    memory_context = format_memory_context(memory_examples_dict)
+    
+    facts = get_facts(
+        conversation_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
+    )
+    
+    memories_for_approval = []
+    
+    # Initialize structures to collect KG data for a single save_kg_to_db call
+    kg_facts_to_save = []
+    kg_concepts_to_save = []
+    fact_to_concept_links_temp = defaultdict(list)
+    
+    
+    if facts:
+        for i, fact in enumerate(facts):
+            # Store memory in memory_lifecycle table
+            memory_id = command_history.add_memory_to_database(
+                message_id=f"{conversation_id}_{datetime.datetime.now().strftime('%H%M%S')}_{i}",
+                conversation_id=conversation_id,
+                npc=npc_name or "default",
+                team=team_name or "default",
+                directory_path=current_path or "/",
+                initial_memory=fact.get('statement', str(fact)),
+                status="pending_approval",
+                model=npc_object.model if npc_object else model,
+                provider=npc_object.provider if npc_object else provider,
+                final_memory=None # Explicitly None for pending memories
+            )
+            
+            memories_for_approval.append({
+                "memory_id": memory_id,
+                "content": fact.get('statement', str(fact)),
+                "type": fact.get('type', 'unknown'),
+                "context": fact.get('source_text', ''),
+                "npc": npc_name or "default"
+            })
+            
+            # Collect facts and concepts for the Knowledge Graph
+            #if fact.get('type') == 'concept':
+            #    kg_concepts_to_save.append({
+            #        "name": fact.get('statement'),
+            #        "generation": current_kg_generation,
+            #        "origin": "organic" # Assuming 'organic' for extracted facts
+            #    })
+            #else: # It's a fact (or unknown type, treat as fact for KG)
+            #    kg_facts_to_save.append({
+            #        "statement": fact.get('statement'),
+            #        "source_text": fact.get('source_text', conversation_text), # Use source_text if available, else conversation_text
+            #        "type": fact.get('type', 'fact'), # Default to 'fact' if type is unknown
+            #        "generation": current_kg_generation,
+            #        "origin": "organic"
+            #    })
+            #    if fact.get('concepts'): # If this fact has related concepts
+            #        for concept_name in fact.get('concepts'):
+            #            fact_to_concept_links_temp[fact.get('statement')].append(concept_name)
+    
+    # After processing all facts, save them to the KG database in one go
+    if kg_facts_to_save or kg_concepts_to_save:
+        temp_kg_data = {
+            "facts": kg_facts_to_save,
+            "concepts": kg_concepts_to_save,
+            "generation": current_kg_generation,
+            "fact_to_concept_links": fact_to_concept_links_temp,
+            "concept_links": [], # Assuming no concept-to-concept links from direct extraction
+            "fact_to_fact_links": [] # Assuming no fact-to-fact links from direct extraction
+        }
+        
+        # Get the SQLAlchemy engine using your existing helper function
+        db_engine = get_db_connection(app.config.get('DB_PATH'))
+        
+        # Call the existing save_kg_to_db function
+        save_kg_to_db(
+            engine=db_engine,
+            kg_data=temp_kg_data,
+            team_name=team_name or "default",
+            npc_name=npc_name or "default",
+            directory_path=current_path or "/"
+        )
+    
+    return memories_for_approval
+@app.route('/api/finetuned_models', methods=['GET'])
+def get_finetuned_models():
+    current_path = request.args.get("currentPath")
+    
+    # Define a list of potential root directories where fine-tuned models might be saved.
+    # We'll be very generous here, including both 'models' and 'images' directories
+    # at both global and project levels, as the user's logs indicate saving to 'images'.
+    potential_root_paths = [
+        os.path.expanduser('~/.npcsh/models'),  # Standard global models directory
+        os.path.expanduser('~/.npcsh/images'),  # Global images directory (where user's model was saved)
+    ]
+    if current_path:
+        # Add project-specific model directories if a current_path is provided
+        project_models_path = os.path.join(current_path, 'models')
+        project_images_path = os.path.join(current_path, 'images') # Also check project images directory
+        potential_root_paths.extend([project_models_path, project_images_path])
+            
+    finetuned_models = []
+    
+    print(f"🌋 Searching for fine-tuned models in potential root paths: {set(potential_root_paths)}") # Use set for unique paths
 
-                
-                serialized_npc = {
-                    "name": npc.name,
-                    "primary_directive": npc.primary_directive,
-                    "model": npc.model,
-                    "provider": npc.provider,
-                    "api_url": npc.api_url,
-                    "use_global_jinxs": npc.use_global_jinxs,
-                    "jinxs": [
-                        {
-                            "jinx_name": jinx.jinx_name,
-                            "inputs": jinx.inputs,
-                            "steps": [
-                                {
-                                    "name": step.get("name", f"step_{i}"),
-                                    "engine": step.get("engine", "natural"),
-                                    "code": step.get("code", "")
-                                }
-                                for i, step in enumerate(jinx.steps)
-                            ]
-                        }
-                        for jinx in npc.jinxs
-                    ],
-                }
-                npc_data.append(serialized_npc)
+    for root_path in set(potential_root_paths): # Iterate through unique potential root paths
+        if not os.path.exists(root_path) or not os.path.isdir(root_path):
+            print(f"🌋 Skipping non-existent or non-directory root path: {root_path}")
+            continue
 
-        print(npc_data)
-        return jsonify({"npcs": npc_data, "error": None})
+        print(f"🌋 Scanning root path: {root_path}")
+        for model_dir_name in os.listdir(root_path):
+            full_model_path = os.path.join(root_path, model_dir_name)
+            
+            if not os.path.isdir(full_model_path):
+                print(f"🌋 Skipping {full_model_path}: Not a directory.")
+                continue
+
+            # NEW STRATEGY: Check for user's specific output files
+            # Look for 'model_final.pt' or the 'checkpoints' directory
+            has_model_final_pt = os.path.exists(os.path.join(full_model_path, 'model_final.pt'))
+            has_checkpoints_dir = os.path.isdir(os.path.join(full_model_path, 'checkpoints'))
+
+            if has_model_final_pt or has_checkpoints_dir:
+                print(f"🌋 Identified fine-tuned model: {model_dir_name} at {full_model_path} (found model_final.pt or checkpoints dir)")
+                finetuned_models.append({
+                    "value": full_model_path, # This is the path to the directory containing the .pt files
+                    "provider": "diffusers",   # Provider is still "diffusers"
+                    "display_name": f"{model_dir_name} | Fine-tuned Diffuser"
+                })
+                continue # Move to the next model_dir_name found in this root_path
 
-    except Exception as e:
-        print(f"Error fetching NPC team: {str(e)}")
-        return jsonify({"npcs": [], "error": str(e)})
-def get_last_used_model_and_npc_in_directory(directory_path):
-    """
-    Fetches the model and NPC from the most recent message in any conversation
+            print(f"🌋 Skipping {full_model_path}: No model_final.pt or checkpoints directory found at root.")
+    
+    print(f"🌋 Finished scanning. Found {len(finetuned_models)} fine-tuned models.")
+    return jsonify({"models": finetuned_models, "error": None})
+
+@app.route('/api/finetune_diffusers', methods=['POST'])
+def finetune_diffusers():
+    data = request.json
+    images = data.get('images', [])
+    captions = data.get('captions', [])
+    output_name = data.get('outputName', 'my_diffusion_model')
+    num_epochs = data.get('epochs', 100)
+    batch_size = data.get('batchSize', 4)
+    learning_rate = data.get('learningRate', 1e-4)
+    output_path = data.get('outputPath', '~/.npcsh/models')
+    
+    print(f"🌋 Finetune Diffusers Request Received!")
+    print(f"  Images: {len(images)} files")
+    print(f"  Output Name: {output_name}")
+    print(f"  Epochs: {num_epochs}, Batch Size: {batch_size}, Learning Rate: {learning_rate}")
+    
+    if not images:
+        print("🌋 Error: No images provided for finetuning.")
+        return jsonify({'error': 'No images provided'}), 400
+    
+    if not captions or len(captions) != len(images):
+        print("🌋 Warning: Captions not provided or mismatching image count. Using empty captions.")
+        captions = [''] * len(images)
+    
+    expanded_images = [os.path.expanduser(p) for p in images]
+    output_dir = os.path.expanduser(
+        os.path.join(output_path, output_name)
+    )
+    
+    job_id = f"ft_{int(time.time())}"
+    finetune_jobs[job_id] = {
+        'status': 'running',
+        'output_dir': output_dir,
+        'epochs': num_epochs,
+        'current_epoch': 0,
+        'start_time': datetime.datetime.now().isoformat()
+    }
+    print(f"🌋 Finetuning job {job_id} initialized. Output directory: {output_dir}")
+    
+    def run_training_async():
+        print(f"🌋 Finetuning job {job_id}: Starting asynchronous training thread...")
+        try:
+            config = DiffusionConfig(
+                num_epochs=num_epochs,
+                batch_size=batch_size,
+                learning_rate=learning_rate,
+                output_model_path=output_dir
+            )
+            
+            print(f"🌋 Finetuning job {job_id}: Calling train_diffusion with config: {config}")
+            # Assuming train_diffusion might print its own progress or allow callbacks
+            # For more granular logging, you'd need to modify train_diffusion itself
+            model_path = train_diffusion(
+                expanded_images,
+                captions,
+                config=config
+            )
+            
+            finetune_jobs[job_id]['status'] = 'complete'
+            finetune_jobs[job_id]['model_path'] = model_path
+            finetune_jobs[job_id]['end_time'] = datetime.datetime.now().isoformat()
+            print(f"🌋 Finetuning job {job_id}: Training complete! Model saved to: {model_path}")
+        except Exception as e:
+            finetune_jobs[job_id]['status'] = 'error'
+            finetune_jobs[job_id]['error_msg'] = str(e)
+            finetune_jobs[job_id]['end_time'] = datetime.datetime.now().isoformat()
+            print(f"🌋 Finetuning job {job_id}: ERROR during training: {e}")
+            traceback.print_exc()
+        print(f"🌋 Finetuning job {job_id}: Asynchronous training thread finished.")
+
+    # Start the training in a separate thread
+    thread = threading.Thread(target=run_training_async)
+    thread.daemon = True # Allow the main program to exit even if this thread is still running
+    thread.start()
+    
+    print(f"🌋 Finetuning job {job_id} successfully launched in background. Returning initial status.")
+    return jsonify({
+        'status': 'started',
+        'jobId': job_id,
+        'message': f"Finetuning job '{job_id}' started. Check /api/finetune_status/{job_id} for updates."
+    })
+
+
+@app.route('/api/finetune_status/<job_id>', methods=['GET'])
+def finetune_status(job_id):
+    if job_id not in finetune_jobs:
+        return jsonify({'error': 'Job not found'}), 404
+    
+    job = finetune_jobs[job_id]
+    
+    if job['status'] == 'complete':
+        return jsonify({
+            'complete': True,
+            'outputPath': job.get('model_path', job['output_dir'])
+        })
+    elif job['status'] == 'error':
+        return jsonify({'error': job.get('error_msg', 'Unknown error')})
+    
+    return jsonify({
+        'step': job.get('current_epoch', 0),
+        'total': job['epochs'],
+        'status': 'running'
+    })
+
+@app.route("/api/ml/train", methods=["POST"])
+def train_ml_model():
+    import pickle
+    import numpy as np
+    from sklearn.linear_model import LinearRegression, LogisticRegression
+    from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
+    from sklearn.tree import DecisionTreeRegressor
+    from sklearn.cluster import KMeans
+    from sklearn.model_selection import train_test_split
+    from sklearn.metrics import mean_squared_error, r2_score, accuracy_score
+    
+    data = request.json
+    model_name = data.get("name")
+    model_type = data.get("type")
+    target = data.get("target")
+    features = data.get("features")
+    training_data = data.get("data")
+    hyperparams = data.get("hyperparameters", {})
+    
+    df = pd.DataFrame(training_data)
+    X = df[features].values
+    
+    metrics = {}
+    model = None
+    
+    if model_type == "linear_regression":
+        y = df[target].values
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
+        model = LinearRegression()
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        metrics = {
+            "r2_score": r2_score(y_test, y_pred),
+            "rmse": np.sqrt(mean_squared_error(y_test, y_pred))
+        }
+    
+    elif model_type == "logistic_regression":
+        y = df[target].values
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
+        model = LogisticRegression(max_iter=1000)
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        metrics = {"accuracy": accuracy_score(y_test, y_pred)}
+    
+    elif model_type == "random_forest":
+        y = df[target].values
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
+        model = RandomForestRegressor(n_estimators=100)
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        metrics = {
+            "r2_score": r2_score(y_test, y_pred),
+            "rmse": np.sqrt(mean_squared_error(y_test, y_pred))
+        }
+    
+    elif model_type == "clustering":
+        n_clusters = hyperparams.get("n_clusters", 3)
+        model = KMeans(n_clusters=n_clusters)
+        labels = model.fit_predict(X)
+        metrics = {"inertia": model.inertia_, "n_clusters": n_clusters}
+    
+    elif model_type == "gradient_boost":
+        y = df[target].values
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
+        model = GradientBoostingRegressor()
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        metrics = {
+            "r2_score": r2_score(y_test, y_pred),
+            "rmse": np.sqrt(mean_squared_error(y_test, y_pred))
+        }
+    
+    model_id = f"{model_name}_{int(time.time())}"
+    model_path = os.path.expanduser(f"~/.npcsh/models/{model_id}.pkl")
+    os.makedirs(os.path.dirname(model_path), exist_ok=True)
+    
+    with open(model_path, 'wb') as f:
+        pickle.dump({
+            "model": model,
+            "features": features,
+            "target": target,
+            "type": model_type
+        }, f)
+    
+    return jsonify({
+        "model_id": model_id,
+        "metrics": metrics,
+        "error": None
+    })
+
+
+@app.route("/api/ml/predict", methods=["POST"])
+def ml_predict():
+    import pickle
+    
+    data = request.json
+    model_name = data.get("model_name")
+    input_data = data.get("input_data")
+    
+    model_dir = os.path.expanduser("~/.npcsh/models/")
+    model_files = [f for f in os.listdir(model_dir) if f.startswith(model_name)]
+    
+    if not model_files:
+        return jsonify({"error": f"Model {model_name} not found"})
+    
+    model_path = os.path.join(model_dir, model_files[0])
+    
+    with open(model_path, 'rb') as f:
+        model_data = pickle.load(f)
+    
+    model = model_data["model"]
+    prediction = model.predict([input_data])
+    
+    return jsonify({
+        "prediction": prediction.tolist(),
+        "error": None
+    })
+@app.route("/api/jinx/executions/label", methods=["POST"])
+def label_jinx_execution():
+    data = request.json
+    execution_id = data.get("executionId")
+    label = data.get("label")
+    
+    command_history = CommandHistory(app.config.get('DB_PATH'))
+    command_history.label_jinx_execution(execution_id, label)
+    
+    return jsonify({"success": True, "error": None})
+
+
+@app.route("/api/npc/executions", methods=["GET"])
+def get_npc_executions():
+    npc_name = request.args.get("npcName")
+
+    
+    command_history = CommandHistory(app.config.get('DB_PATH'))
+    executions = command_history.get_npc_executions(npc_name)
+    
+    return jsonify({"executions": executions, "error": None})
+
+
+@app.route("/api/npc/executions/label", methods=["POST"])
+def label_npc_execution():
+    data = request.json
+    execution_id = data.get("executionId")
+    label = data.get("label")
+    
+    command_history = CommandHistory(app.config.get('DB_PATH'))
+    command_history.label_npc_execution(execution_id, label)
+    
+    return jsonify({"success": True, "error": None})
+
+
+@app.route("/api/training/dataset", methods=["POST"])
+def build_training_dataset():
+    data = request.json
+    filters = data.get("filters", {})
+    
+    command_history = CommandHistory(app.config.get('DB_PATH'))
+    dataset = command_history.get_training_dataset(
+        include_jinxs=filters.get("jinxs", True),
+        include_npcs=filters.get("npcs", True),
+        npc_names=filters.get("npc_names")
+    )
+    
+    return jsonify({
+        "dataset": dataset,
+        "count": len(dataset),
+        "error": None
+    })
+@app.route("/api/save_npc", methods=["POST"])
+def save_npc():
+    try:
+        data = request.json
+        npc_data = data.get("npc")
+        is_global = data.get("isGlobal")
+        current_path = data.get("currentPath")
+
+        if not npc_data or "name" not in npc_data:
+            return jsonify({"error": "Invalid NPC data"}), 400
+
+        
+        if is_global:
+            npc_directory = os.path.expanduser("~/.npcsh/npc_team")
+        else:
+            npc_directory = os.path.join(current_path, "npc_team")
+
+        
+        os.makedirs(npc_directory, exist_ok=True)
+
+        
+        yaml_content = f"""name: {npc_data['name']}
+primary_directive: "{npc_data['primary_directive']}"
+model: {npc_data['model']}
+provider: {npc_data['provider']}
+api_url: {npc_data.get('api_url', '')}
+use_global_jinxs: {str(npc_data.get('use_global_jinxs', True)).lower()}
+"""
+
+        
+        file_path = os.path.join(npc_directory, f"{npc_data['name']}.npc")
+        with open(file_path, "w") as f:
+            f.write(yaml_content)
+
+        return jsonify({"message": "NPC saved successfully", "error": None})
+
+    except Exception as e:
+        print(f"Error saving NPC: {str(e)}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/api/jinxs/global")
+def get_jinxs_global():
+    global_jinx_directory = os.path.expanduser("~/.npcsh/npc_team/jinxs")
+    jinx_data = []
+
+    if not os.path.exists(global_jinx_directory):
+        return jsonify({"jinxs": [], "error": None})
+
+    for root, dirs, files in os.walk(global_jinx_directory):
+        for file in files:
+            if file.endswith(".jinx"):
+                jinx_path = os.path.join(root, file)
+                with open(jinx_path, 'r') as f:
+                    raw_data = yaml.safe_load(f)
+                
+                inputs = []
+                for inp in raw_data.get("inputs", []):
+                    if isinstance(inp, str):
+                        inputs.append(inp)
+                    elif isinstance(inp, dict):
+                        inputs.append(list(inp.keys())[0])
+                    else:
+                        inputs.append(str(inp))
+                
+                rel_path = os.path.relpath(jinx_path, global_jinx_directory)
+                path_without_ext = rel_path[:-5]
+                
+                jinx_data.append({
+                    "jinx_name": raw_data.get("jinx_name", file[:-5]),
+                    "path": path_without_ext,
+                    "description": raw_data.get("description", ""),
+                    "inputs": inputs,
+                    "steps": raw_data.get("steps", [])
+                })
+
+    return jsonify({"jinxs": jinx_data, "error": None})
+
+@app.route("/api/jinxs/project", methods=["GET"])
+def get_jinxs_project():
+    project_dir = request.args.get("currentPath")
+    if not project_dir:
+        return jsonify({"jinxs": [], "error": "currentPath required"}), 400
+
+    if not project_dir.endswith("jinxs"):
+        project_dir = os.path.join(project_dir, "jinxs")
+
+    jinx_data = []
+    if not os.path.exists(project_dir):
+        return jsonify({"jinxs": [], "error": None})
+
+    for root, dirs, files in os.walk(project_dir):
+        for file in files:
+            if file.endswith(".jinx"):
+                jinx_path = os.path.join(root, file)
+                with open(jinx_path, 'r') as f:
+                    raw_data = yaml.safe_load(f)
+                
+                inputs = []
+                for inp in raw_data.get("inputs", []):
+                    if isinstance(inp, str):
+                        inputs.append(inp)
+                    elif isinstance(inp, dict):
+                        inputs.append(list(inp.keys())[0])
+                    else:
+                        inputs.append(str(inp))
+                
+                rel_path = os.path.relpath(jinx_path, project_dir)
+                path_without_ext = rel_path[:-5]
+                
+                jinx_data.append({
+                    "jinx_name": raw_data.get("jinx_name", file[:-5]),
+                    "path": path_without_ext,
+                    "description": raw_data.get("description", ""),
+                    "inputs": inputs,
+                    "steps": raw_data.get("steps", [])
+                })
+    print(jinx_data)
+    return jsonify({"jinxs": jinx_data, "error": None})
+
+@app.route("/api/npc_team_global")
+def get_npc_team_global():
+    global_npc_directory = os.path.expanduser("~/.npcsh/npc_team")
+    npc_data = []
+
+    if not os.path.exists(global_npc_directory):
+        return jsonify({"npcs": [], "error": None})
+
+    for file in os.listdir(global_npc_directory):
+        if file.endswith(".npc"):
+            npc_path = os.path.join(global_npc_directory, file)
+            with open(npc_path, 'r') as f:
+                raw_data = yaml.safe_load(f)
+            
+            npc_data.append({
+                "name": raw_data.get("name", file[:-4]),
+                "primary_directive": raw_data.get("primary_directive", ""),
+                "model": raw_data.get("model", ""),
+                "provider": raw_data.get("provider", ""),
+                "api_url": raw_data.get("api_url", ""),
+                "use_global_jinxs": raw_data.get("use_global_jinxs", True),
+                "jinxs": raw_data.get("jinxs", "*"),
+            })
+
+    return jsonify({"npcs": npc_data, "error": None})
+
+
+@app.route("/api/npc_team_project", methods=["GET"])
+def get_npc_team_project():
+    project_npc_directory = request.args.get("currentPath")
+    if not project_npc_directory:
+        return jsonify({"npcs": [], "error": "currentPath required"}), 400
+
+    if not project_npc_directory.endswith("npc_team"):
+        project_npc_directory = os.path.join(
+            project_npc_directory, 
+            "npc_team"
+        )
+
+    npc_data = []
+
+    if not os.path.exists(project_npc_directory):
+        return jsonify({"npcs": [], "error": None})
+
+    for file in os.listdir(project_npc_directory):
+        if file.endswith(".npc"):
+            npc_path = os.path.join(project_npc_directory, file)
+            with open(npc_path, 'r') as f:
+                raw_npc_data = yaml.safe_load(f)
+            
+            serialized_npc = {
+                "name": raw_npc_data.get("name", file[:-4]),
+                "primary_directive": raw_npc_data.get("primary_directive", ""),
+                "model": raw_npc_data.get("model", ""),
+                "provider": raw_npc_data.get("provider", ""),
+                "api_url": raw_npc_data.get("api_url", ""),
+                "use_global_jinxs": raw_npc_data.get("use_global_jinxs", True),
+                "jinxs": raw_npc_data.get("jinxs", "*"),
+            }
+            npc_data.append(serialized_npc)
+
+    return jsonify({"npcs": npc_data, "error": None})
+        
+def get_last_used_model_and_npc_in_directory(directory_path):
+    """
+    Fetches the model and NPC from the most recent message in any conversation
     within the given directory.
     """
     engine = get_db_connection()
@@ -1503,11 +2146,62 @@ IMAGE_MODELS = {
         {"value": "runwayml/stable-diffusion-v1-5", "display_name": "Stable Diffusion v1.5"},
     ],
 }
+# In npcpy/serve.py, find the @app.route('/api/finetuned_models', methods=['GET'])
+# and replace the entire function with this:
+
+# This is now an internal helper function, not a Flask route.
+def _get_finetuned_models_internal(current_path=None): # Renamed to indicate internal use
+    
+    # Define a list of potential root directories where fine-tuned models might be saved.
+    potential_root_paths = [
+        os.path.expanduser('~/.npcsh/models'),  # Standard global models directory
+        os.path.expanduser('~/.npcsh/images'),  # Global images directory (where user's model was saved)
+    ]
+    if current_path:
+        # Add project-specific model directories if a current_path is provided
+        project_models_path = os.path.join(current_path, 'models')
+        project_images_path = os.path.join(current_path, 'images') # Also check project images directory
+        potential_root_paths.extend([project_models_path, project_images_path])
+            
+    finetuned_models = []
+    
+    print(f"🌋 (Internal) Searching for fine-tuned models in potential root paths: {set(potential_root_paths)}")
+
+    for root_path in set(potential_root_paths):
+        if not os.path.exists(root_path) or not os.path.isdir(root_path):
+            print(f"🌋 (Internal) Skipping non-existent or non-directory root path: {root_path}")
+            continue
+
+        print(f"🌋 (Internal) Scanning root path: {root_path}")
+        for model_dir_name in os.listdir(root_path):
+            full_model_path = os.path.join(root_path, model_dir_name)
+            
+            if not os.path.isdir(full_model_path):
+                print(f"🌋 (Internal) Skipping {full_model_path}: Not a directory.")
+                continue
+
+            # Check for 'model_final.pt' or the 'checkpoints' directory
+            has_model_final_pt = os.path.exists(os.path.join(full_model_path, 'model_final.pt'))
+            has_checkpoints_dir = os.path.isdir(os.path.join(full_model_path, 'checkpoints'))
+
+            if has_model_final_pt or has_checkpoints_dir:
+                print(f"🌋 (Internal) Identified fine-tuned model: {model_dir_name} at {full_model_path} (found model_final.pt or checkpoints dir)")
+                finetuned_models.append({
+                    "value": full_model_path, # This is the path to the directory containing the .pt files
+                    "provider": "diffusers",   # Provider is still "diffusers"
+                    "display_name": f"{model_dir_name} | Fine-tuned Diffuser"
+                })
+                continue
 
+            print(f"🌋 (Internal) Skipping {full_model_path}: No model_final.pt or checkpoints directory found at root.")
+    
+    print(f"🌋 (Internal) Finished scanning. Found {len(finetuned_models)} fine-tuned models.")
+    # <--- CRITICAL FIX: Directly return the list of models, not a Flask Response
+    return {"models": finetuned_models, "error": None} # Return a dict for consistency
 def get_available_image_models(current_path=None):
     """
     Retrieves available image generation models based on environment variables
-    and predefined configurations.
+    and predefined configurations, including locally fine-tuned Diffusers models.
     """
     
     if current_path:
@@ -1515,7 +2209,7 @@ def get_available_image_models(current_path=None):
     
     all_image_models = []
 
-    
+    # Add models configured via environment variables
     env_image_model = os.getenv("NPCSH_IMAGE_MODEL")
     env_image_provider = os.getenv("NPCSH_IMAGE_PROVIDER")
 
@@ -1526,9 +2220,8 @@ def get_available_image_models(current_path=None):
             "display_name": f"{env_image_model} | {env_image_provider} (Configured)"
         })
 
-    
+    # Add predefined models (OpenAI, Gemini, and standard Diffusers)
     for provider_key, models_list in IMAGE_MODELS.items():
-        
         if provider_key == "openai":
             if os.environ.get("OPENAI_API_KEY"):
                 all_image_models.extend([
@@ -1541,16 +2234,25 @@ def get_available_image_models(current_path=None):
                     {**model, "provider": provider_key, "display_name": f"{model['display_name']} | {provider_key}"}
                     for model in models_list
                 ])
-        elif provider_key == "diffusers":
-            
-            
+        elif provider_key == "diffusers": # This entry in IMAGE_MODELS is for standard diffusers
             all_image_models.extend([
                 {**model, "provider": provider_key, "display_name": f"{model['display_name']} | {provider_key}"}
                 for model in models_list
             ])
         
+    # <--- CRITICAL FIX: Directly call the internal helper function for fine-tuned models
+    try:
+        finetuned_data_result = _get_finetuned_models_internal(current_path)
+        if finetuned_data_result and finetuned_data_result.get("models"):
+            all_image_models.extend(finetuned_data_result["models"])
+        else:
+            print(f"No fine-tuned models returned by internal helper or an error occurred internally.")
+            if finetuned_data_result.get("error"):
+                print(f"Internal error in _get_finetuned_models_internal: {finetuned_data_result['error']}")
+    except Exception as e:
+        print(f"Error calling _get_finetuned_models_internal: {e}")
 
-    
+    # Deduplicate models
     seen_models = set()
     unique_models = []
     for model_entry in all_image_models:
@@ -1559,6 +2261,7 @@ def get_available_image_models(current_path=None):
             seen_models.add(key)
             unique_models.append(model_entry)
 
+    # Return the combined, deduplicated list of models as a dictionary with a 'models' key
     return unique_models
 
 @app.route('/api/generative_fill', methods=['POST'])
@@ -1893,14 +2596,24 @@ def get_mcp_tools():
     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")
+    raw_server_path = request.args.get("mcpServerPath")
+    current_path_arg = request.args.get("currentPath")
     conversation_id = request.args.get("conversationId")
     npc_name = request.args.get("npc")
+    selected_filter = request.args.get("selected", "")
+    selected_names = [s.strip() for s in selected_filter.split(",") if s.strip()]
     
-    if not server_path:
+    if not raw_server_path:
         return jsonify({"error": "mcpServerPath parameter is required."}), 400
 
-    
+    # Normalize/expand the provided path so cwd/tilde don't break imports
+    resolved_path = resolve_mcp_server_path(
+        current_path=current_path_arg,
+        explicit_path=raw_server_path,
+        force_global=False
+    )
+    server_path = os.path.abspath(os.path.expanduser(resolved_path))
+
     try:
         from npcsh.corca import MCPClientNPC
     except ImportError:
@@ -1917,13 +2630,19 @@ def get_mcp_tools():
                    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})
+                    tools = temp_mcp_client.available_tools_llm
+                    if selected_names:
+                        tools = [t for t in tools if t.get("function", {}).get("name") in selected_names]
+                    return jsonify({"tools": tools, "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})
+            tools = temp_mcp_client.available_tools_llm
+            if selected_names:
+                tools = [t for t in tools if t.get("function", {}).get("name") in selected_names]
+            return jsonify({"tools": tools, "error": None})
         else:
             return jsonify({"error": f"Failed to connect to MCP server at {server_path}."}), 500
     except FileNotFoundError as e:
@@ -1942,6 +2661,64 @@ def get_mcp_tools():
             temp_mcp_client.disconnect_sync()
 
 
+@app.route("/api/mcp/server/resolve", methods=["GET"])
+def api_mcp_resolve():
+    current_path = request.args.get("currentPath")
+    explicit = request.args.get("serverPath")
+    try:
+        resolved = resolve_mcp_server_path(current_path=current_path, explicit_path=explicit)
+        return jsonify({"serverPath": resolved, "error": None})
+    except Exception as e:
+        return jsonify({"serverPath": None, "error": str(e)}), 500
+
+
+@app.route("/api/mcp/server/start", methods=["POST"])
+def api_mcp_start():
+    data = request.get_json() or {}
+    current_path = data.get("currentPath")
+    explicit = data.get("serverPath")
+    try:
+        server_path = resolve_mcp_server_path(current_path=current_path, explicit_path=explicit)
+        result = mcp_server_manager.start(server_path)
+        return jsonify({**result, "error": None})
+    except Exception as e:
+        print(f"Error starting MCP server: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/mcp/server/stop", methods=["POST"])
+def api_mcp_stop():
+    data = request.get_json() or {}
+    explicit = data.get("serverPath")
+    if not explicit:
+        return jsonify({"error": "serverPath is required to stop a server."}), 400
+    try:
+        result = mcp_server_manager.stop(explicit)
+        return jsonify({**result, "error": None})
+    except Exception as e:
+        print(f"Error stopping MCP server: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/mcp/server/status", methods=["GET"])
+def api_mcp_status():
+    explicit = request.args.get("serverPath")
+    current_path = request.args.get("currentPath")
+    try:
+        if explicit:
+            result = mcp_server_manager.status(explicit)
+        else:
+            resolved = resolve_mcp_server_path(current_path=current_path, explicit_path=explicit)
+            result = mcp_server_manager.status(resolved)
+        return jsonify({**result, "running": result.get("status") == "running", "all": mcp_server_manager.running(), "error": None})
+    except Exception as e:
+        print(f"Error checking MCP server status: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
 @app.route("/api/image_models", methods=["GET"]) 
 def get_image_models_api():
     """
@@ -1950,6 +2727,7 @@ def get_image_models_api():
     current_path = request.args.get("currentPath")
     try:
         image_models = get_available_image_models(current_path)
+        print('image models', image_models)
         return jsonify({"models": image_models, "error": None})
     except Exception as e:
         print(f"Error getting available image models: {str(e)}")
@@ -1961,34 +2739,224 @@ def get_image_models_api():
 
 
 
+def _run_stream_post_processing(
+    conversation_turn_text,
+    conversation_id,
+    command_history,
+    npc_name,
+    team_name,
+    current_path,
+    model,
+    provider,
+    npc_object,
+    messages # For context compression
+):
+    """
+    Runs memory extraction and context compression in a background thread.
+    These operations will not block the main stream.
+    """
+    print(f"🌋 Background task started for conversation {conversation_id}!")
 
-@app.route("/api/stream", methods=["POST"])
-def stream():
+    # Memory extraction and KG fact insertion
+    try:
+        if len(conversation_turn_text) > 50: # Only extract memories if the turn is substantial
+            memories_for_approval = extract_and_store_memories(
+                conversation_turn_text,
+                conversation_id,
+                command_history,
+                npc_name,
+                team_name,
+                current_path,
+                model,
+                provider,
+                npc_object
+            )
+            if memories_for_approval:
+                print(f"🔥 Background: Extracted {len(memories_for_approval)} memories for approval for conversation {conversation_id}. Stored as pending in the database (table: memory_lifecycle).")
+        else:
+            print(f"Background: Conversation turn too short ({len(conversation_turn_text)} chars) for memory extraction. Skipping.")
+    except Exception as e:
+        print(f"🌋 Background: Error during memory extraction and KG insertion for conversation {conversation_id}: {e}")
+        traceback.print_exc()
+
+    # Context compression using breathe from llm_funcs
+    try:
+        if len(messages) > 30: # Use the threshold specified in your request
+            # Directly call breathe for summarization
+            breathe_result = breathe(
+                messages=messages,
+                model=model,
+                provider=provider,
+                npc=npc_object # Pass npc for context if available
+            )
+            compressed_output = breathe_result.get('output', '')
+            
+            if compressed_output:
+                # Save the compressed context as a new system message in conversation_history
+                compressed_message_id = generate_message_id()
+                save_conversation_message(
+                    command_history,
+                    conversation_id,
+                    "system", # Role for compressed context
+                    f"[AUTOMATIC CONTEXT COMPRESSION]: {compressed_output}",
+                    wd=current_path,
+                    model=model, # Use the same model/provider that generated the summary
+                    provider=provider,
+                    npc=npc_name, # Associate with the NPC
+                    team=team_name, # Associate with the team
+                    message_id=compressed_message_id
+                )
+                print(f"💨 Background: Compressed context for conversation {conversation_id} saved as new system message: {compressed_output[:100]}...")
+            else:
+                print(f"Background: Context compression returned no output for conversation {conversation_id}. Skipping saving.")
+        else:
+            print(f"Background: Conversation messages count ({len(messages)}) below threshold for context compression. Skipping.")
+    except Exception as e:
+        print(f"🌋 Background: Error during context compression with breathe for conversation {conversation_id}: {e}")
+        traceback.print_exc()
+
+    print(f"🌋 Background task finished for conversation {conversation_id}!")
+
+
+
+
+@app.route("/api/text_predict", methods=["POST"])
+def text_predict():
     data = request.json
-    
+
     stream_id = data.get("streamId")
     if not stream_id:
-        import uuid
         stream_id = str(uuid.uuid4())
 
     with cancellation_lock:
         cancellation_flags[stream_id] = False
-    print(f"Starting stream with ID: {stream_id}")
-    
-    commandstr = data.get("commandstr")
-    conversation_id = data.get("conversationId")
-    model = data.get("model", None)
-    provider = data.get("provider", None)
-    if provider is None:
-        provider = available_models.get(model)
-        
-    npc_name = data.get("npc", None)
-    npc_source = data.get("npcSource", "global")
+
+    print(f"Starting text prediction stream with ID: {stream_id}")
+    print('data')
+
+
+    text_content = data.get("text_content", "")
+    cursor_position = data.get("cursor_position", len(text_content))
     current_path = data.get("currentPath")
-    
+    model = data.get("model")
+    provider = data.get("provider")
+    context_type = data.get("context_type", "general") # e.g., 'code', 'chat', 'general'
+    file_path = data.get("file_path") # Optional: for code context
+
     if current_path:
-        loaded_vars = load_project_env(current_path)
-        print(f"Loaded project env variables for stream request: {list(loaded_vars.keys())}")
+        load_project_env(current_path)
+
+    text_before_cursor = text_content[:cursor_position]
+
+
+    if context_type == 'code':
+        prompt_for_llm = f"You are an AI code completion assistant. Your task is to complete the provided code snippet.\nYou MUST ONLY output the code that directly completes the snippet.\nDO NOT include any explanations, comments, or additional text.\nDO NOT wrap the completion in markdown code blocks.\n\nHere is the code context where the completion should occur (file: {file_path or 'unknown'}):\n\n{text_before_cursor}\n\nPlease provide the completion starting from the end of the last line shown.\n"
+        system_prompt = "You are an AI code completion assistant. Only provide code. Do not add explanations or any other text."
+    elif context_type == 'chat':
+        prompt_for_llm = f"You are an AI chat assistant. Your task is to provide a natural and helpful completion to the user's ongoing message.\nYou MUST ONLY output the text that directly completes the message.\nDO NOT include any explanations or additional text.\n\nHere is the message context where the completion should occur:\n\n{text_before_cursor}\n\nPlease provide the completion starting from the end of the last line shown.\n"
+        system_prompt = "You are an AI chat assistant. Only provide natural language completion. Do not add explanations or any other text."
+    else: # general text prediction
+        prompt_for_llm = f"You are an AI text completion assistant. Your task is to provide a natural and helpful completion to the user's ongoing text.\nYou MUST ONLY output the text that directly completes the snippet.\nDO NOT include any explanations or additional text.\n\nHere is the text context where the completion should occur:\n\n{text_before_cursor}\n\nPlease provide the completion starting from the end of the last line shown.\n"
+        system_prompt = "You are an AI text completion assistant. Only provide natural language completion. Do not add explanations or any other text."
+
+
+    npc_object = None # For prediction, we don't necessarily use a specific NPC
+
+    messages_for_llm = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": prompt_for_llm}
+    ]
+
+    def event_stream_text_predict(current_stream_id):
+        complete_prediction = []
+        try:
+            stream_response_generator = get_llm_response(
+                prompt_for_llm,
+                messages=messages_for_llm,
+                model=model,
+                provider=provider,
+                npc=npc_object,
+                stream=True,
+            )
+
+            # get_llm_response returns a dict with 'response' as a generator when stream=True
+            if isinstance(stream_response_generator, dict) and 'response' in stream_response_generator:
+                stream_generator = stream_response_generator['response']
+            else:
+                # Fallback for non-streaming LLM responses or errors
+                output_content = ""
+                if isinstance(stream_response_generator, dict) and 'output' in stream_response_generator:
+                    output_content = stream_response_generator['output']
+                elif isinstance(stream_response_generator, str):
+                    output_content = stream_response_generator
+
+                yield f"data: {json.dumps({'choices': [{'delta': {'content': output_content}}]})}\n\n"
+                yield f"data: [DONE]\n\n"
+                return
+
+
+            for response_chunk in stream_generator:
+                with cancellation_lock:
+                    if cancellation_flags.get(current_stream_id, False):
+                        print(f"Cancellation flag triggered for {current_stream_id}. Breaking loop.")
+                        break
+
+                chunk_content = ""
+                # Handle different LLM API response formats
+                if "hf.co" in model or (provider == 'ollama' and 'gpt-oss' not in model): # Heuristic for Ollama/HF models
+                    chunk_content = response_chunk["message"]["content"] if "message" in response_chunk and "content" in response_chunk["message"] else ""
+                else: # Assume OpenAI-like streaming format
+                    chunk_content = "".join(choice.delta.content for choice in response_chunk.choices if choice.delta.content is not None)
+
+                print(chunk_content, end='')
+
+                if chunk_content:
+                    complete_prediction.append(chunk_content)
+                    yield f"data: {json.dumps({'choices': [{'delta': {'content': chunk_content}}]})}\n\n"
+
+        except Exception as e:
+            print(f"\nAn exception occurred during text prediction streaming for {current_stream_id}: {e}")
+            traceback.print_exc()
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+        finally:
+            print(f"\nText prediction stream {current_stream_id} finished.")
+            yield f"data: [DONE]\n\n" # Signal end of stream
+            with cancellation_lock:
+                if current_stream_id in cancellation_flags:
+                    del cancellation_flags[current_stream_id]
+                    print(f"Cleaned up cancellation flag for stream ID: {current_stream_id}")
+
+    return Response(event_stream_text_predict(stream_id), mimetype="text/event-stream")
+
+@app.route("/api/stream", methods=["POST"])
+def stream():
+    data = request.json
+    
+    stream_id = data.get("streamId")
+    if not stream_id:
+        import uuid
+        stream_id = str(uuid.uuid4())
+
+    with cancellation_lock:
+        cancellation_flags[stream_id] = False
+    print(f"Starting stream with ID: {stream_id}")
+    
+    commandstr = data.get("commandstr")
+    conversation_id = data.get("conversationId")
+    model = data.get("model", None)
+    provider = data.get("provider", None)
+    if provider is None:
+        provider = available_models.get(model)
+        
+    npc_name = data.get("npc", None)
+    npc_source = data.get("npcSource", "global")
+    current_path = data.get("currentPath")
+    is_resend = data.get("isResend", False)  # ADD THIS LINE
+
+    if current_path:
+        loaded_vars = load_project_env(current_path)
+        print(f"Loaded project env variables for stream request: {list(loaded_vars.keys())}")
     
     npc_object = None
     team_object = None
@@ -2155,7 +3123,9 @@ def stream():
         if 'tools' in tool_args and tool_args['tools']:
             tool_args['tool_choice'] = {"type": "auto"}
     
-    
+    # Default stream response so closures below always have a value
+    stream_response = {"output": "", "messages": messages}
+
     exe_mode = data.get('executionMode','chat')
     
     if exe_mode == 'chat':
@@ -2230,23 +3200,18 @@ def stream():
         messages = state.messages
         
     elif exe_mode == 'corca':
-        
         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 
+            state = None
             stream_response = {"output": "Corca mode is not available due to missing dependencies.", "messages": messages}
-            
-        
-        if state is not None: 
-            
+
+        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', [])
@@ -2254,18 +3219,19 @@ def stream():
                     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): 
+                elif isinstance(team_object.team_ctx.get('mcp_server'), str):
                     effective_mcp_server_path = team_object.team_ctx.get('mcp_server')
 
-            
+            if effective_mcp_server_path:
+                effective_mcp_server_path = os.path.abspath(os.path.expanduser(effective_mcp_server_path))
+
             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 = app.corca_states.get(state_key)
+
+            if corca_state is None:
                 corca_state = create_corca_state_and_mcp_client(
                     conversation_id=conversation_id,
                     command_history=command_history,
@@ -2276,21 +3242,21 @@ def stream():
                 )
                 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 current_mcp_client_path:
+                    current_mcp_client_path = os.path.abspath(os.path.expanduser(current_mcp_client_path))
 
                 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 
+                        corca_state.mcp_client = None
 
                     if effective_mcp_server_path:
                         new_mcp_client = MCPClientNPC()
@@ -2300,20 +3266,19 @@ def stream():
                         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 
+                selected_mcp_tools_names=selected_mcp_tools_from_request
             )
-            
-            
+
             app.corca_states[state_key] = state
-            messages = state.messages 
+            messages = state.messages
 
+    else:
+        stream_response = {"output": f"Unsupported execution mode: {exe_mode}", "messages": messages}
 
     user_message_filled = ''
 
@@ -2321,20 +3286,25 @@ def stream():
         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,
-    )
+                user_message_filled += txt
+    
+    # Only save user message if it's NOT a resend
+    if not is_resend:  # ADD THIS CONDITION
+        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()
@@ -2349,44 +3319,44 @@ def stream():
             if isinstance(stream_response, str) :
                 print('stream a str and not a gen')
                 chunk_data = {
-                        "id": None, 
-                        "object": None, 
-                        "created": datetime.datetime.now().strftime('YYYY-DD-MM-HHMMSS'), 
+                        "id": None,
+                        "object": None,
+                        "created": datetime.datetime.now().strftime('YYYY-DD-MM-HHMMSS'),
                         "model": model,
                         "choices": [
                             {
-                                "index": 0, 
-                                "delta": 
+                                "index": 0,
+                                "delta":
                                     {
                                         "content": stream_response,
                                         "role": "assistant"
-                                  }, 
+                                  },
                                 "finish_reason": 'done'
                             }
                         ]
                     }
-                yield f"data: {json.dumps(chunk_data)}"
+                yield f"data: {json.dumps(chunk_data)}\n\n"
                 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')                
+                print('stream a str and not a gen')
                 chunk_data = {
-                        "id": None, 
-                        "object": None, 
-                        "created": datetime.datetime.now().strftime('YYYY-DD-MM-HHMMSS'), 
+                        "id": None,
+                        "object": None,
+                        "created": datetime.datetime.now().strftime('YYYY-DD-MM-HHMMSS'),
                         "model": model,
                         "choices": [
                             {
-                                "index": 0, 
-                                "delta": 
+                                "index": 0,
+                                "delta":
                                     {
                                         "content": stream_response.get('output') ,
                                         "role": "assistant"
-                                  }, 
+                                  },
                                 "finish_reason": 'done'
                             }
                         ]
                     }
-                yield f"data: {json.dumps(chunk_data)}"
+                yield f"data: {json.dumps(chunk_data)}\n\n"
                 return
             for response_chunk in stream_response.get('response', stream_response.get('output')):
                 with cancellation_lock:
@@ -2414,8 +3384,8 @@ def stream():
                     if chunk_content:
                         complete_response.append(chunk_content)
                     chunk_data = {
-                        "id": None, "object": None, 
-                        "created": response_chunk["created_at"] or datetime.datetime.now(), 
+                        "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")}]
                     }
@@ -2449,36 +3419,85 @@ def stream():
             print(f"\nAn exception occurred during streaming for {current_stream_id}: {e}")
             traceback.print_exc()
             interrupted = True
-        
+
         finally:
             print(f"\nStream {current_stream_id} finished. Interrupted: {interrupted}")
             print('\r' + ' ' * dot_count*2 + '\r', end="", flush=True)
 
             final_response_text = ''.join(complete_response)
+
+            # Yield message_stop immediately so the client's stream ends quickly
             yield f"data: {json.dumps({'type': 'message_stop'})}\n\n"
-            
+
+            # Save assistant message to the database
             npc_name_to_save = npc_object.name if npc_object else ''
             save_conversation_message(
-                command_history, 
-                conversation_id, 
-                "assistant", 
+                command_history,
+                conversation_id,
+                "assistant",
                 final_response_text,
-                wd=current_path, 
-                model=model, 
+                wd=current_path,
+                model=model,
                 provider=provider,
-                npc=npc_name_to_save, 
-                team=team, 
+                npc=npc_name_to_save,
+                team=team,
                 message_id=message_id,
             )
 
+            # Start background tasks for memory extraction and context compression
+            # These will run without blocking the main response stream.
+            conversation_turn_text = f"User: {commandstr}\nAssistant: {final_response_text}"
+            background_thread = threading.Thread(
+                target=_run_stream_post_processing,
+                args=(
+                    conversation_turn_text,
+                    conversation_id,
+                    command_history,
+                    npc_name,
+                    team, # Pass the team variable from the outer scope
+                    current_path,
+                    model,
+                    provider,
+                    npc_object,
+                    messages # Pass messages for context compression
+                )
+            )
+            background_thread.daemon = True # Allow the main program to exit even if this thread is still running
+            background_thread.start()
+
             with cancellation_lock:
                 if current_stream_id in cancellation_flags:
                     del cancellation_flags[current_stream_id]
                     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/delete_message', methods=['POST'])
+def delete_message():
+    data = request.json
+    conversation_id = data.get('conversationId')
+    message_id = data.get('messageId')
+    
+    if not conversation_id or not message_id:
+        return jsonify({"error": "Missing conversationId or messageId"}), 400
+    
+    try:
+        command_history = CommandHistory(app.config.get('DB_PATH'))
+        
+        # Delete the message from the database
+        result = command_history.delete_message(conversation_id, message_id)
+        
+        print(f"[DELETE_MESSAGE] Deleted message {message_id} from conversation {conversation_id}. Rows affected: {result}")
+        
+        return jsonify({
+            "success": True,
+            "deletedMessageId": message_id,
+            "rowsAffected": result
+        }), 200
+        
+    except Exception as e:
+        print(f"[DELETE_MESSAGE] Error: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
 
 @app.route("/api/memory/approve", methods=["POST"])
 def approve_memories():
@@ -2503,295 +3522,6 @@ def approve_memories():
 
 
 
-@app.route("/api/execute", methods=["POST"])
-def execute():
-    data = request.json
-    
-
-    stream_id = data.get("streamId")
-    if not stream_id:
-        import uuid
-        stream_id = str(uuid.uuid4())
-
-    
-    with cancellation_lock:
-        cancellation_flags[stream_id] = False
-    print(f"Starting execute stream with ID: {stream_id}")
-
-    
-    commandstr = data.get("commandstr")
-    conversation_id = data.get("conversationId")
-    model = data.get("model", 'llama3.2')
-    provider = data.get("provider", 'ollama')
-    if provider is None:
-        provider = available_models.get(model)
-
-        
-    npc_name = data.get("npc", "sibiji")
-    npc_source = data.get("npcSource", "global")
-    team = data.get("team", None)
-    current_path = data.get("currentPath")
-    
-    if current_path:
-        loaded_vars = load_project_env(current_path)
-        print(f"Loaded project env variables for stream request: {list(loaded_vars.keys())}")
-    
-    npc_object = None
-    team_object = None
-    
-    
-    if team:
-        print(team)
-        if hasattr(app, 'registered_teams') and team in app.registered_teams:
-            team_object = app.registered_teams[team]
-            print(f"Using registered team: {team}")
-        else:
-            print(f"Warning: Team {team} not found in registered teams")
-    
-    
-    if npc_name:
-        
-        if team and hasattr(app, 'registered_teams') and team in app.registered_teams:
-            team_object = app.registered_teams[team]
-            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]
-                        print(f"Found NPC {npc_name} in registered team {team}")
-                elif isinstance(team_npcs, list):
-                    for npc in team_npcs:
-                        if hasattr(npc, 'name') and npc.name == npc_name:
-                            npc_object = npc
-                            print(f"Found NPC {npc_name} in registered team {team}")
-                            break
-            
-            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 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")
-        
-        
-        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)
-            
-            if not npc_object and npc_source == 'project':
-                print(f"NPC {npc_name} not found in project directory, trying global...")
-                npc_object = load_npc_by_name_and_source(npc_name, 'global', db_conn)
-                
-            if npc_object:
-                print(f"Successfully loaded NPC {npc_name} from {npc_source} directory")
-            else:
-                print(f"Warning: Could not load NPC {npc_name}")
-
-    attachments = data.get("attachments", [])
-    command_history = CommandHistory(app.config.get('DB_PATH'))
-    images = []
-    attachments_loaded = []
-    
-
-    if attachments:
-        for attachment in attachments:
-            extension = attachment["name"].split(".")[-1]
-            extension_mapped = extension_map.get(extension.upper(), "others")
-            file_path = os.path.expanduser("~/.npcsh/" + extension_mapped + "/" + attachment["name"])
-            if extension_mapped == "images":
-                ImageFile.LOAD_TRUNCATED_IMAGES = True
-                img = Image.open(attachment["path"])
-                img_byte_arr = BytesIO()
-                img.save(img_byte_arr, format="PNG")
-                img_byte_arr.seek(0)
-                img.save(file_path, optimize=True, quality=50)
-                images.append(file_path)
-                attachments_loaded.append({
-                    "name": attachment["name"], "type": extension_mapped,
-                    "data": img_byte_arr.read(), "size": os.path.getsize(file_path)
-                })
-
-    messages = fetch_messages_for_conversation(conversation_id)
-    if len(messages) == 0 and npc_object is not None:
-        messages = [{'role': 'system', 'content': npc_object.get_system_prompt()}]
-    elif len(messages)>0 and messages[0]['role'] != 'system' and npc_object is not None:
-        messages.insert(0, {'role': 'system', 'content': npc_object.get_system_prompt()})
-    elif len(messages) > 0 and npc_object is not None:
-        messages[0]['content'] = npc_object.get_system_prompt()
-    if npc_object is not None and messages and messages[0]['role'] == 'system':
-        messages[0]['content'] = npc_object.get_system_prompt()
-
-    message_id = generate_message_id()
-    save_conversation_message(
-        command_history, conversation_id, "user", commandstr,
-        wd=current_path, model=model, provider=provider, npc=npc_name,
-        team=team, attachments=attachments_loaded, message_id=message_id,
-    )
-    response_gen = check_llm_command(
-        commandstr, messages=messages, images=images, model=model,
-        provider=provider, npc=npc_object, team=team_object, stream=True
-    )
-    print(response_gen)
-    
-    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 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.")
-                        interrupted = True
-                        break
-
-                print('.', end="", flush=True)
-                dot_count += 1
-                
-                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"]:
-                            if "id" in tool_call:
-                                tool_call_data["id"] = tool_call["id"]
-                            if "function" in tool_call:
-                                if "name" in tool_call["function"]:
-                                    tool_call_data["function_name"] = tool_call["function"]["name"]
-                                if "arguments" in tool_call["function"]:
-                                    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 = ""
-                    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]
-                    }
-                    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}")
-            traceback.print_exc()
-            interrupted = True
-        
-        finally:
-            print(f"\nStream {current_stream_id} finished. Interrupted: {interrupted}")
-            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,
-            )
-
-            with cancellation_lock:
-                if current_stream_id in cancellation_flags:
-                    del cancellation_flags[current_stream_id]
-                    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"])
 def interrupt_stream():