npcsh 1.1.10__py3-none-any.whl → 1.1.12__py3-none-any.whl

npcsh/_state.py

@@ -26,7 +26,7 @@ import sqlite3
 import subprocess
 import sys
 import time
-from typing import Dict, List,  Any, Tuple, Union, Optional
+from typing import Dict, List,  Any, Tuple, Union, Optional, Callable
 import logging
 import textwrap
 from termcolor import colored
@@ -80,14 +80,15 @@ from npcpy.memory.command_history import (
     load_kg_from_db, 
     save_kg_to_db, 
 )
-from npcpy.npc_compiler import NPC, Team, load_jinxs_from_directory
+from npcpy.npc_compiler import NPC, Team, load_jinxs_from_directory, build_jinx_tool_catalog
 from npcpy.llm_funcs import (
     check_llm_command,
     get_llm_response,
     execute_llm_command,
     breathe, 
-    
+
 )
+from npcpy.tools import auto_tools
 
 from npcpy.memory.knowledge_graph import (
     kg_evolve_incremental, 
@@ -544,59 +545,7 @@ def get_relevant_memories(
     return all_memories[-max_memories:]
 
 
-def search_kg_facts(
-    self,
-    npc: str,
-    team: str,
-    directory_path: str,
-    query: str
-) -> List[Dict]:
-    
-    kg = load_kg_from_db(
-        self.engine, 
-        team, 
-        npc, 
-        directory_path
-    )
-    
-    if not kg or 'facts' not in kg:
-        return []
-    
-    query_lower = query.lower()
-    matching_facts = []
-    
-    for fact in kg['facts']:
-        statement = fact.get('statement', '').lower()
-        if query_lower in statement:
-            matching_facts.append(fact)
-    
-    return matching_facts
 
-def format_memory_context(memory_examples):
-    if not memory_examples:
-        return ""
-    
-    context_parts = []
-    
-    approved_examples = memory_examples.get("approved", [])
-    rejected_examples = memory_examples.get("rejected", [])
-    
-    if approved_examples:
-        context_parts.append("EXAMPLES OF GOOD MEMORIES:")
-        for ex in approved_examples[:5]:
-            final = ex.get("final_memory") or ex.get("initial_memory")
-            context_parts.append(f"- {final}")
-    
-    if rejected_examples:
-        context_parts.append("\nEXAMPLES OF POOR MEMORIES TO AVOID:")
-        for ex in rejected_examples[:3]:
-            context_parts.append(f"- {ex.get('initial_memory')}")
-    
-    if context_parts:
-        context_parts.append("\nLearn from these examples to generate similar high-quality memories.")
-        return "\n".join(context_parts)
-    
-    return ""
 def add_npcshrc_to_shell_config() -> None:
     """
     Function Description:
@@ -989,6 +938,7 @@ def validate_bash_command(command_parts: list) -> bool:
     """
     Function Description:
         Validate if the command sequence is a valid bash command with proper arguments/flags.
+        Simplified to be less strict and allow bash to handle argument specifics for common commands.
     Args:
         command_parts : list : Command parts
     Keyword Args:
@@ -999,216 +949,20 @@ def validate_bash_command(command_parts: list) -> bool:
     if not command_parts:
         return False
 
-    COMMAND_PATTERNS = {
-        "cat": {
-            "flags": ["-n", "-b", "-E", "-T", "-s", "--number", "-A", "--show-all"],
-            "requires_arg": True,
-        },
-        "find": {
-            "flags": [
-                "-name",
-                "-type",
-                "-size",
-                "-mtime",
-                "-exec",
-                "-print",
-                "-delete",
-                "-maxdepth",
-                "-mindepth",
-                "-perm",
-                "-user",
-                "-group",
-            ],
-            "requires_arg": True,
-        },
-        "who": {
-            "flags": [
-                "-a",
-                "-b",
-                "-d",
-                "-H",
-                "-l",
-                "-p",
-                "-q",
-                "-r",
-                "-s",
-                "-t",
-                "-u",
-                "--all",
-                "--count",
-                "--heading",
-            ],
-            "requires_arg": False,
-        },
-        "open": {
-            "flags": ["-a", "-e", "-t", "-f", "-F", "-W", "-n", "-g", "-h"],
-            "requires_arg": True,
-        },
-        "ls": {
-            "flags": [
-                "-a",
-                "-l",
-                "-h",
-                "-R",
-                "-t",
-                "-S",
-                "-r",
-                "-d",
-                "-F",
-                "-i",
-                "--color",
-            ],
-            "requires_arg": False,
-        },
-        "cp": {
-            "flags": [
-                "-r",
-                "-f",
-                "-i",
-                "-u",
-                "-v",
-                "--preserve",
-                "--no-preserve=mode,ownership,timestamps",
-            ],
-            "requires_arg": True,
-        },
-        "mv": {
-            "flags": ["-f", "-i", "-u", "-v", "--backup", "--no-clobber"],
-            "requires_arg": True,
-        },
-        "rm": {
-            "flags": ["-f", "-i", "-r", "-v", "--preserve-root", "--no-preserve-root"],
-            "requires_arg": True,
-        },
-        "mkdir": {
-            "flags": ["-p", "-v", "-m", "--mode", "--parents"],
-            "requires_arg": True,
-        },
-        "rmdir": {
-            "flags": ["-p", "-v", "--ignore-fail-on-non-empty"],
-            "requires_arg": True,
-        },
-        "touch": {
-            "flags": ["-a", "-c", "-m", "-r", "-d", "--date"],
-            "requires_arg": True,
-        },
-        "grep": {
-            "flags": [
-                "-i",
-                "-v",
-                "-r",
-                "-l",
-                "-n",
-                "-c",
-                "-w",
-                "-x",
-                "--color",
-                "--exclude",
-                "--include",
-            ],
-            "requires_arg": True,
-        },
-        "sed": {
-            "flags": [
-                "-e",
-                "-f",
-                "-i",
-                "-n",
-                "--expression",
-                "--file",
-                "--in-place",
-                "--quiet",
-                "--silent",
-            ],
-            "requires_arg": True,
-        },
-        "awk": {
-            "flags": [
-                "-f",
-                "-v",
-                "--file",
-                "--source",
-                "--assign",
-                "--posix",
-                "--traditional",
-            ],
-            "requires_arg": True,
-        },
-        "sort": {
-            "flags": [
-                "-b",
-                "-d",
-                "-f",
-                "-g",
-                "-i",
-                "-n",
-                "-r",
-                "-u",
-                "--check",
-                "--ignore-case",
-                "--numeric-sort",
-            ],
-            "requires_arg": False,
-        },
-        "uniq": {
-            "flags": ["-c", "-d", "-u", "-i", "--check-chars", "--skip-chars"],
-            "requires_arg": False,
-        },
-        "wc": {
-            "flags": ["-c", "-l", "-w", "-m", "-L", "--bytes", "--lines", "--words"],
-            "requires_arg": False,
-        },
-        "pwd": {
-            "flags": ["-L", "-P"],
-            "requires_arg": False,
-        },
-        "chmod": {
-            "flags": ["-R", "-v", "-c", "--reference"],
-            "requires_arg": True,
-        },
-
-    }
-
     base_command = command_parts[0]
 
-    if base_command == 'which':
-        return False 
-
+    # Commands that are always considered valid for direct execution
+    ALWAYS_VALID_COMMANDS = BASH_COMMANDS + list(interactive_commands.keys()) + TERMINAL_EDITORS
 
-  
-    INTERACTIVE_COMMANDS = ["ipython", "python", "sqlite3", "r"]
-    TERMINAL_EDITORS = ["vim", "nano", "emacs"]
-    if base_command in TERMINAL_EDITORS or base_command in INTERACTIVE_COMMANDS:
+    if base_command in ALWAYS_VALID_COMMANDS:
         return True
+    
+    # Specific checks for commands that might be misinterpreted or need special handling
+    if base_command == 'which':
+        return True # 'which' is a valid bash command
 
-    if base_command not in COMMAND_PATTERNS and base_command not in BASH_COMMANDS:
-        return False 
-
-    pattern = COMMAND_PATTERNS.get(base_command)
-    if not pattern:
-        return True
-
-    args = []
-    flags = []
-
-    for i in range(1, len(command_parts)):
-        part = command_parts[i]
-        if part.startswith("-"):
-            flags.append(part)
-            if part not in pattern["flags"]:
-                return False
-        else:
-            args.append(part)
-
-  
-    if base_command == "who" and args:
-        return False
-  
-    if pattern.get("requires_arg", False) and not args:
-        return False
-
-    return True
-
+    # If it's not in our explicit list, it's not a bash command we want to validate strictly
+    return False # If it reaches here, it's not a recognized bash command for strict validation.
 
 def is_npcsh_initialized() -> bool:
     """
@@ -1506,8 +1260,9 @@ if not completion_logger.handlers:
     formatter = logging.Formatter('[%(name)s] %(message)s')
     handler.setFormatter(formatter)
     completion_logger.addHandler(handler)
-
 def make_completer(shell_state: ShellState, router: Any):
+    slash_hint_cache = {"last_key": None}
+
     def complete(text: str, state_index: int) -> Optional[str]:
         """Main completion function"""
         try:
@@ -1515,56 +1270,72 @@ def make_completer(shell_state: ShellState, router: Any):
             begidx = readline.get_begidx()
             endidx = readline.get_endidx()
             
-            completion_logger.debug(f"text='{text}', buffer='{buffer}', begidx={begidx}, endidx={endidx}, state_index={state_index}")
-            
+            # The word currently being completed (e.g., "lor" in "ls lor")
+            word_under_cursor = buffer[begidx:endidx] 
+
+            # The very first word/token in the entire buffer (e.g., "ls" in "ls lor")
+            first_token_of_buffer = ""
+            if buffer.strip():
+                match = re.match(r'^(\S+)', buffer.strip())
+                if match:
+                    first_token_of_buffer = match.group(1)
+
             matches = []
-            
-          
-            if begidx > 0 and buffer[begidx-1] == '/':
-                completion_logger.debug(f"Slash command completion - text='{text}'")
+
+            # Determine if we are in a "slash command context"
+            # This is true if the *entire buffer starts with a slash* AND
+            # the current completion is for that initial slash command (begidx == 0).
+
+            is_slash_command_context = (begidx <=1 and first_token_of_buffer.startswith('/'))
+
+            if is_slash_command_context:
                 slash_commands = get_slash_commands(shell_state, router)
-                completion_logger.debug(f"Available slash commands: {slash_commands}")
                 
-                if text == '':
+                if first_token_of_buffer == '/': # If just '/' is typed
                     matches = [cmd[1:] for cmd in slash_commands]
-                else:
-                    full_text = '/' + text
-                    matching_commands = [cmd for cmd in slash_commands if cmd.startswith(full_text)]
+                else: # If '/ag' is typed
+                    matching_commands = [cmd for cmd in slash_commands if cmd.startswith(first_token_of_buffer)]
                     matches = [cmd[1:] for cmd in matching_commands]
                 
-                completion_logger.debug(f"Slash command matches: {matches}")
-                
-            elif is_command_position(buffer, begidx):
-                completion_logger.debug("Command position detected")
-                bash_matches = [cmd for cmd in BASH_COMMANDS if cmd.startswith(text)]
+                # Only print hints if this is the first completion attempt (state_index == 0)
+                # and the hints haven't been printed for this specific input yet.
+                if matches and state_index == 0:
+                    key = (buffer, first_token_of_buffer) # Use full buffer for cache key
+                    if slash_hint_cache["last_key"] != key:
+                        print("\nAvailable slash commands: " + ", ".join(slash_commands))
+                        try:
+                            readline.redisplay()
+                        except Exception:
+                            pass
+                        slash_hint_cache["last_key"] = key
+            
+            # If not a slash command context, then it's either a regular command or an argument.
+            elif begidx == 0: # Completing a regular command (e.g., "ls", "pyt")
+                bash_matches = [cmd for cmd in BASH_COMMANDS if cmd.startswith(word_under_cursor)]
                 matches.extend(bash_matches)
                 
-                interactive_matches = [cmd for cmd in interactive_commands.keys() if cmd.startswith(text)]
+                interactive_matches = [cmd for cmd in interactive_commands.keys() if cmd.startswith(word_under_cursor)]
                 matches.extend(interactive_matches)
                 
-                if len(text) >= 1:
+                if len(word_under_cursor) >= 1:
                     path_executables = get_path_executables()
-                    exec_matches = [cmd for cmd in path_executables if cmd.startswith(text)]
+                    exec_matches = [cmd for cmd in path_executables if cmd.startswith(word_under_cursor)]
                     matches.extend(exec_matches[:20])
-            else:
-                completion_logger.debug("File completion")
-                matches = get_file_completions(text)
+            
+            else: # Completing a file or directory path (e.g., "ls doc/my_f")
+                matches = get_file_completions(word_under_cursor)
             
             matches = sorted(list(set(matches)))
-            completion_logger.debug(f"Final matches: {matches}")
             
             if state_index < len(matches):
-                result = matches[state_index]
-                completion_logger.debug(f"Returning: '{result}'")
-                return result
+                return matches[state_index]
             else:
-                completion_logger.debug(f"No match for state_index {state_index}")
+                return None # readline expects None when no more completions
             
         except Exception as e:
-            completion_logger.error(f"Exception in completion: {e}")
-            completion_logger.debug("Exception details:", exc_info=True)
-        
-        return None
+            # Using completion_logger for internal debugging, not printing to stdout for user.
+            # completion_logger.error(f"Exception in completion: {e}", exc_info=True) 
+            return None
     
     return complete
 
@@ -1598,39 +1369,71 @@ def get_slash_commands(state: ShellState, router: Any) -> List[str]:
     completion_logger.debug(f"Final slash commands: {result}")
     return result
 def get_file_completions(text: str) -> List[str]:
-    """Get file/directory completions"""
+    """Get file/directory completions, including for subfolders."""
     try:
-        if text.startswith('/'):
-            basedir = os.path.dirname(text) or '/'
-            prefix = os.path.basename(text)
-        elif text.startswith('./') or text.startswith('../'):
-            basedir = os.path.dirname(text) or '.'
+        # Determine the base directory and the prefix to match
+        if '/' in text:
+            basedir = os.path.dirname(text)
             prefix = os.path.basename(text)
         else:
             basedir = '.'
             prefix = text
         
-        if not os.path.exists(basedir):
-            return []
-        
+        # If basedir is empty (e.g., text is "folder/"), it should be current dir
+        if not basedir:
+            basedir = '.'
+
+        # Handle absolute paths
+        if text.startswith('/'):
+            # Ensure absolute path starts with / and handle cases like "/something"
+            if basedir.startswith('/'):
+                pass # already absolute
+            else:
+                basedir = '/' + basedir.lstrip('/') 
+            if basedir == '/': # If text was just "/something", basedir is "/"
+                prefix = os.path.basename(text)
+
+        # Resolve the actual path to list
+        if basedir == '.':
+            current_path_to_list = os.getcwd()
+        else:
+            # If basedir is relative, join it with current working directory
+            if not os.path.isabs(basedir):
+                current_path_to_list = os.path.join(os.getcwd(), basedir)
+            else:
+                current_path_to_list = basedir
+
+            if not os.path.isdir(current_path_to_list): # If the base path doesn't exist yet, no completions
+                return []
+
         matches = []
         try:
-            for item in os.listdir(basedir):
+            for item in os.listdir(current_path_to_list):
                 if item.startswith(prefix):
-                    full_path = os.path.join(basedir, item)
+                    full_item_path = os.path.join(current_path_to_list, item)
+                    
+                    # Construct the completion string relative to the input 'text'
+                    # This ensures that if the input was 'folder/s', the completion is 'folder/subfolder/'
                     if basedir == '.':
                         completion = item
                     else:
-                        completion = os.path.join(basedir, item)
-                    
-                  
-                    matches.append(completion)
+                        # Reconstruct the path fragment before the prefix
+                        path_fragment_before_prefix = text[:len(text) - len(prefix)]
+                        completion = os.path.join(path_fragment_before_prefix, item)
+
+                    if os.path.isdir(full_item_path):
+                        matches.append(completion + '/')
+                    else:
+                        matches.append(completion)
         except (PermissionError, OSError):
             pass
         
         return sorted(matches)
-    except Exception:
+    except Exception as e:
+        completion_logger.error(f"Error in get_file_completions for text '{text}': {e}", exc_info=True)
         return []
+
+
 def is_command_position(buffer: str, begidx: int) -> bool:
     """Determine if cursor is at a command position"""
   
@@ -1996,6 +1799,181 @@ def parse_generic_command_flags(parts: List[str]) -> Tuple[Dict[str, Any], List[
         
     return parsed_kwargs, positional_args
 
+def _ollama_supports_tools(model: str) -> Optional[bool]:
+    """
+    Best-effort check for tool-call support on an Ollama model by inspecting its template/metadata.
+    Mirrors the lightweight check used in the Flask serve path.
+    """
+    try:
+        import ollama  # Local import to avoid hard dependency when Ollama isn't installed
+    except Exception:
+        return None
+
+    try:
+        details = ollama.show(model)
+        template = details.get("template") or ""
+        metadata = details.get("metadata") or {}
+        if any(token in template for token in ["{{- if .Tools", "{{- range .Tools", "{{- if .ToolCalls"]):
+            return True
+        if metadata.get("tools") or metadata.get("tool_calls"):
+            return True
+        return False
+    except Exception:
+        return None
+
+
+def model_supports_tool_calls(model: Optional[str], provider: Optional[str]) -> bool:
+    """
+    Decide whether to attempt tool-calling for the given model/provider.
+    Uses Ollama template inspection when possible and falls back to name heuristics.
+    """
+    if not model:
+        return False
+
+    provider = (provider or "").lower()
+    model_lower = model.lower()
+
+    if provider == "ollama":
+        ollama_support = _ollama_supports_tools(model)
+        if ollama_support is not None:
+            return ollama_support
+
+    toolish_markers = [
+        "gpt",
+        "claude",
+        "qwen",
+        "mistral",
+        "llama-3.1",
+        "llama3.1",
+        "llama-3.2",
+        "llama3.2",
+        "tool",
+    ]
+    return any(marker in model_lower for marker in toolish_markers)
+
+
+def collect_llm_tools(state: ShellState) -> Tuple[List[Dict[str, Any]], Dict[str, Callable]]:
+    """
+    Assemble tool definitions + executable map from NPC tools, Jinxs, and MCP servers.
+    This mirrors the auto-translation used in the Flask server path.
+    """
+    tools: List[Dict[str, Any]] = []
+    tool_map: Dict[str, Callable] = {}
+
+    # NPC-defined Python tools
+    npc_obj = state.npc if isinstance(state.npc, NPC) else None
+    if npc_obj and getattr(npc_obj, "tools", None):
+        if isinstance(npc_obj.tools, list) and npc_obj.tools and callable(npc_obj.tools[0]):
+            tools_schema, auto_map = auto_tools(npc_obj.tools)
+            tools.extend(tools_schema or [])
+            tool_map.update(auto_map or {})
+        else:
+            tools.extend(npc_obj.tools or [])
+            if getattr(npc_obj, "tool_map", None):
+                tool_map.update(npc_obj.tool_map)
+    elif npc_obj and getattr(npc_obj, "tool_map", None):
+        tool_map.update(npc_obj.tool_map)
+
+    # Jinx tools from NPC and Team
+    aggregated_jinxs: Dict[str, Any] = {}
+    if npc_obj and getattr(npc_obj, "jinxs_dict", None):
+        aggregated_jinxs.update(npc_obj.jinxs_dict)
+    if state.team and isinstance(state.team, Team) and getattr(state.team, "jinxs_dict", None):
+        aggregated_jinxs.update({k: v for k, v in state.team.jinxs_dict.items() if k not in aggregated_jinxs})
+
+    if aggregated_jinxs:
+        jinx_catalog: Dict[str, Dict[str, Any]] = {}
+        if npc_obj and getattr(npc_obj, "jinx_tool_catalog", None):
+            jinx_catalog.update(npc_obj.jinx_tool_catalog or {})
+        if state.team and isinstance(state.team, Team) and getattr(state.team, "jinx_tool_catalog", None):
+            jinx_catalog.update(state.team.jinx_tool_catalog or {})
+        if not jinx_catalog:
+            jinx_catalog = build_jinx_tool_catalog(aggregated_jinxs)
+
+        tools.extend(list(jinx_catalog.values()))
+
+        jinja_env_for_jinx = getattr(npc_obj, "jinja_env", None)
+        if not jinja_env_for_jinx and state.team and isinstance(state.team, Team):
+            jinja_env_for_jinx = getattr(state.team, "jinja_env", None)
+
+        for name, jinx_obj in aggregated_jinxs.items():
+            def _make_runner(jinx=jinx_obj, jinja_env=jinja_env_for_jinx, tool_name=name):
+                def runner(**kwargs):
+                    input_values = kwargs if isinstance(kwargs, dict) else {}
+                    try:
+                        ctx = jinx.execute(
+                            input_values=input_values,
+                            npc=npc_obj,
+                            messages=state.messages,
+                            extra_globals={"state": state},
+                            jinja_env=jinja_env
+                        )
+                        return ctx.get("output", ctx)
+                    except Exception as exc:
+                        return f"Jinx '{tool_name}' failed: {exc}"
+                return runner
+            tool_map[name] = _make_runner()
+
+    # MCP tools via npcsh.corca client
+    try:
+        from npcsh.corca import MCPClientNPC, _resolve_and_copy_mcp_server_path  # type: ignore
+
+        team_ctx_mcp_servers = None
+        if state.team and isinstance(state.team, Team) and hasattr(state.team, "team_ctx"):
+            team_ctx_mcp_servers = state.team.team_ctx.get("mcp_servers", [])
+
+        mcp_server_path = _resolve_and_copy_mcp_server_path(
+            explicit_path=None,
+            current_path=state.current_path,
+            team_ctx_mcp_servers=team_ctx_mcp_servers,
+            interactive=False,
+            auto_copy_bypass=True
+        )
+
+        if mcp_server_path:
+            reuse_client = (
+                state.mcp_client
+                if state.mcp_client and getattr(state.mcp_client, "server_script_path", None) == mcp_server_path
+                else None
+            )
+            mcp_client = reuse_client or MCPClientNPC()
+            if reuse_client is None:
+                try:
+                    connected = mcp_client.connect_sync(mcp_server_path)
+                except Exception:
+                    connected = False
+                if connected:
+                    state.mcp_client = mcp_client
+            if mcp_client and getattr(mcp_client, "available_tools_llm", None):
+                for tool_def in mcp_client.available_tools_llm:
+                    name = tool_def.get("function", {}).get("name")
+                    if name and name not in tool_map:
+                        tools.append(tool_def)
+                tool_map.update(getattr(mcp_client, "tool_map", {}) or {})
+    except Exception:
+        pass  # MCP is optional; ignore failures
+
+    # Deduplicate tools by name to avoid confusing the LLM
+    deduped = {}
+    for tool_def in tools:
+        name = tool_def.get("function", {}).get("name")
+        if name:
+            deduped[name] = tool_def
+    return list(deduped.values()), tool_map
+
+
+def normalize_llm_result(llm_result: Any, fallback_messages: List[Dict[str, Any]]) -> Tuple[Any, List[Dict[str, Any]]]:
+    """
+    Normalize varying LLM return shapes into (output, messages).
+    """
+    if isinstance(llm_result, dict):
+        messages = llm_result.get("messages", fallback_messages)
+        output = llm_result.get("output")
+        if output is None:
+            output = llm_result.get("response")
+        return output, messages
+    return llm_result, fallback_messages
+
 
 def should_skip_kg_processing(user_input: str, assistant_output: str) -> bool:
     """Determine if this interaction is too trivial for KG processing"""
@@ -2166,12 +2144,16 @@ def process_pipeline_command(
 
     if validate_bash_command(cmd_parts):
         with SpinnerContext(f"Executing {command_name}", style="line"):
-            success, result = handle_bash_command(
-                cmd_parts, 
-                cmd_to_process, 
-                stdin_input, 
-                state
-            )
+            try: # Added try-except for KeyboardInterrupt here
+                success, result = handle_bash_command(
+                    cmd_parts, 
+                    cmd_to_process, 
+                    stdin_input, 
+                    state
+                )
+            except KeyboardInterrupt:
+                print(colored("\nBash command interrupted by user.", "yellow"))
+                return state, colored("Command interrupted.", "red")
         
         if success:
             return state, result
@@ -2192,14 +2174,18 @@ def process_pipeline_command(
                 f"{exec_model} analyzing error", 
                 style="brain"
             ):
-                response = execute_llm_command(
-                    fixer_prompt, 
-                    model=exec_model,
-                    provider=exec_provider,
-                    npc=state.npc, 
-                    stream=stream_final, 
-                    messages=state.messages
-                )
+                try: # Added try-except for KeyboardInterrupt here
+                    response = execute_llm_command(
+                        fixer_prompt, 
+                        model=exec_model,
+                        provider=exec_provider,
+                        npc=state.npc, 
+                        stream=stream_final, 
+                        messages=state.messages
+                    )
+                except KeyboardInterrupt:
+                    print(colored("\nLLM analysis interrupted by user.", "yellow"))
+                    return state, colored("LLM analysis interrupted.", "red")
             
             state.messages = response['messages']     
             return state, response['response']
@@ -2225,7 +2211,15 @@ def process_pipeline_command(
         )
         info = path_cmd + '\n' + ls_files + '\n' + platform_info + '\n' 
         state.messages.append({'role':'user', 'content':full_llm_cmd})
-        
+
+        tools_for_llm: List[Dict[str, Any]] = []
+        tool_exec_map: Dict[str, Callable] = {}
+        tool_capable = model_supports_tool_calls(exec_model, exec_provider)
+        if tool_capable:
+            tools_for_llm, tool_exec_map = collect_llm_tools(state)
+            if not tools_for_llm:
+                tool_capable = False
+
         npc_name = (
             state.npc.name 
             if isinstance(state.npc, NPC) 
@@ -2245,27 +2239,54 @@ def process_pipeline_command(
                 "load_file_contents": load_file_contents, 
                 "search_web": search_web,
                 "get_relevant_memories": get_relevant_memories,
-                "search_kg_facts": search_kg_facts,
+
                 'state': state
             }
             current_module = sys.modules[__name__]
             for name, func in inspect.getmembers(current_module, inspect.isfunction):
                 application_globals_for_jinx[name] = func
 
-            llm_result = check_llm_command(
-                full_llm_cmd,
-                model=exec_model,      
-                provider=exec_provider, 
-                api_url=state.api_url,
-                api_key=state.api_key,
-                npc=state.npc,
-                team=state.team,
-                messages=state.messages,
-                images=state.attachments,
-                stream=stream_final,
-                context=info,
-                extra_globals=application_globals_for_jinx  
-            )
+            try: # Added try-except for KeyboardInterrupt here
+                if tool_capable:
+                    llm_result = get_llm_response(
+                        full_llm_cmd,
+                        model=exec_model,
+                        provider=exec_provider,
+                        npc=state.npc,
+                        team=state.team,
+                        messages=state.messages,
+                        stream=stream_final,
+                        attachments=state.attachments,
+                        context=info,
+                        auto_process_tool_calls=True,
+                        tools=tools_for_llm,
+                        tool_map=tool_exec_map,
+                        tool_choice={"type": "auto"},
+                    )
+                else:
+                    llm_result = check_llm_command(
+                        full_llm_cmd,
+                        model=exec_model,      
+                        provider=exec_provider, 
+                        api_url=state.api_url,
+                        api_key=state.api_key,
+                        npc=state.npc,
+                        team=state.team,
+                        messages=state.messages,
+                        images=state.attachments,
+                        stream=stream_final,
+                        context=info,
+                        extra_globals=application_globals_for_jinx  
+                    )
+            except KeyboardInterrupt:
+                print(colored("\nLLM processing interrupted by user.", "yellow"))
+                return state, colored("LLM processing interrupted.", "red")
+
+        if tool_capable:
+            output, updated_messages = normalize_llm_result(llm_result, state.messages)
+            state.messages = updated_messages
+            return state, output
+
         if not review:
             if isinstance(llm_result, dict):
                 state.messages = llm_result.get("messages", state.messages)
@@ -2475,7 +2496,9 @@ def execute_command(
                     review=review,
                     router=router
                 )
-                
+                if isinstance(output, dict) and 'output' in output:
+                    output = output['output']
+
                 if is_last_command:
                     print(colored("✅ Pipeline complete", "green"))
                     return current_state, output
@@ -2514,6 +2537,9 @@ def execute_command(
                     f"  → Passing to stage {stage_num + 1}", 
                     "blue"
                 ))
+            except KeyboardInterrupt:
+                print(colored("\nOperation interrupted by user.", "yellow"))
+                return current_state, colored("Command interrupted.", "red")
             except RateLimitError:
                 print(colored('Rate Limit Exceeded'))
                 # wait 30 seconds then truncate messages/condense context with breathing mechanism
@@ -2590,14 +2616,18 @@ def execute_command(
             f"Chatting with {active_model}", 
             style="brain"
         ):
-            response = get_llm_response(
-                command, 
-                model=active_model,          
-                provider=active_provider,    
-                npc=state.npc,
-                stream=state.stream_output,
-                messages=state.messages
-            )
+            try: # Added try-except for KeyboardInterrupt here
+                response = get_llm_response(
+                    command, 
+                    model=active_model,          
+                    provider=active_provider,    
+                    npc=state.npc,
+                    stream=state.stream_output,
+                    messages=state.messages
+                )
+            except KeyboardInterrupt:
+                print(colored("\nChat interrupted by user.", "yellow"))
+                return state, colored("Chat interrupted.", "red")
         
         state.messages = response['messages']
         return state, response['response']
@@ -2607,18 +2637,23 @@ def execute_command(
             f"Executing with {active_model}", 
             style="dots_pulse"
         ):
-            response = execute_llm_command(
-                command, 
-                model=active_model,          
-                provider=active_provider,  
-                npc=state.npc, 
-                stream=state.stream_output, 
-                messages=state.messages
-            ) 
+            try: # Added try-except for KeyboardInterrupt here
+                response = execute_llm_command(
+                    command, 
+                    model=active_model,          
+                    provider=active_provider,  
+                    npc=state.npc, 
+                    stream=state.stream_output, 
+                    messages=state.messages
+                ) 
+            except KeyboardInterrupt:
+                print(colored("\nCommand execution interrupted by user.", "yellow"))
+                return state, colored("Command interrupted.", "red")
         
         state.messages = response['messages']     
         return state, response['response']
 
+
 def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     setup_npcsh_config()
 
@@ -2821,7 +2856,6 @@ def process_memory_approvals(command_history, memory_queue):
                 approval['decision'], 
                 approval.get('final_memory')
             )
-
 def process_result(
     user_input: str,
     result_state: ShellState,
@@ -2854,10 +2888,17 @@ def process_result(
 
     final_output_str = None
     
+    # FIX: Handle dict output properly
     if isinstance(output, dict):
         output_content = output.get('output')
         model_for_stream = output.get('model', active_npc.model)
         provider_for_stream = output.get('provider', active_npc.provider)
+        
+        # If output_content is still a dict or None, convert to string
+        if isinstance(output_content, dict):
+            output_content = str(output_content)
+        elif output_content is None:
+            output_content = "Command completed with no output"
     else:
         output_content = output
         model_for_stream = active_npc.model
@@ -2870,15 +2911,21 @@ def process_result(
         else:
             render_markdown(str(output_content))
     elif result_state.stream_output:
-        final_output_str = print_and_process_stream_with_markdown(
-            output_content, 
-            model_for_stream, 
-            provider_for_stream, 
-            show=True
-        )
+        # FIX: Only stream if output_content is a generator, not a string
+        if isinstance(output_content, str):
+            final_output_str = output_content
+            render_markdown(final_output_str)
+        else:
+            final_output_str = print_and_process_stream_with_markdown(
+                output_content, 
+                model_for_stream, 
+                provider_for_stream, 
+                show=True
+            )
     elif output_content is not None:
         final_output_str = str(output_content)
         render_markdown(final_output_str)
+        
 
     if final_output_str:
         if result_state.messages: