npcsh 1.1.14__py3-none-any.whl → 1.1.15__py3-none-any.whl

npcsh/_state.py

@@ -21,20 +21,19 @@ import textwrap
 from typing import Dict, List, Any, Tuple, Union, Optional, Callable
 import yaml
 
-# Setup debug logging if NPCSH_DEBUG is set
-def _setup_debug_logging():
-    if os.environ.get("NPCSH_DEBUG", "0") == "1":
-        logging.basicConfig(
-            level=logging.DEBUG,
-            format='%(asctime)s [%(name)s] %(levelname)s: %(message)s',
-            datefmt='%H:%M:%S'
-        )
-        # Set specific loggers to DEBUG
-        logging.getLogger("npcsh.state").setLevel(logging.DEBUG)
-        logging.getLogger("npcpy.llm_funcs").setLevel(logging.DEBUG)
-        logging.getLogger("npcsh.state").debug("Debug logging enabled via NPCSH_DEBUG=1")
+# Setup logging - INFO by default, DEBUG if NPCSH_DEBUG=1
+def _setup_logging():
+    level = logging.DEBUG if os.environ.get("NPCSH_DEBUG", "0") == "1" else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format='%(message)s',  # Simple format - just the message
+        datefmt='%H:%M:%S'
+    )
+    # Always show tool calls from llm_funcs at INFO level
+    logging.getLogger("npcpy.llm_funcs").setLevel(level)
+    logging.getLogger("npcsh.state").setLevel(level)
 
-_setup_debug_logging()
+_setup_logging()
 
 # Platform-specific imports
 try:
@@ -167,6 +166,10 @@ class ShellState:
     session_input_tokens: int = 0
     session_output_tokens: int = 0
     session_cost_usd: float = 0.0
+    # Session timing
+    session_start_time: float = field(default_factory=lambda: __import__('time').time())
+    # Logging level: "silent", "normal", "verbose"
+    log_level: str = "normal"
 
     def get_model_for_command(self, model_type: str = "chat"):
         if model_type == "chat":
@@ -182,7 +185,34 @@ class ShellState:
         elif model_type == "video_gen":
             return self.video_gen_model, self.video_gen_provider
         else:
-            return self.chat_model, self.chat_provider 
+            return self.chat_model, self.chat_provider
+
+    def set_log_level(self, level: str) -> str:
+        """Set the logging level and configure npcpy loggers accordingly."""
+        level = level.lower()
+        if level not in ("silent", "normal", "verbose"):
+            return f"Invalid log level: {level}. Use 'silent', 'normal', or 'verbose'."
+
+        self.log_level = level
+
+        # Map to Python logging levels
+        level_map = {
+            "silent": logging.WARNING,
+            "normal": logging.INFO,
+            "verbose": logging.DEBUG,
+        }
+        log_level = level_map[level]
+
+        # Configure npcpy loggers
+        for logger_name in ["npcpy", "npcpy.gen", "npcpy.gen.response", "npcsh"]:
+            logger = logging.getLogger(logger_name)
+            logger.setLevel(log_level)
+
+        # Also set root logger for npcpy
+        logging.getLogger("npcpy").setLevel(log_level)
+
+        return f"Log level set to: {level}"
+
 CONFIG_KEY_MAP = {
   
     "model": "NPCSH_CHAT_MODEL",
@@ -369,31 +399,76 @@ def initialize_base_npcs_if_needed(db_path: str) -> None:
                 shutil.copy2(source_path, destination_path)
                 print(f"Copied ctx {filename} to {destination_path}")
 
-    # Copy jinxs directory RECURSIVELY
+    # Copy jinxs directory RECURSIVELY with manifest tracking
+    # This ensures we only sync package jinxs and can clean up old ones
     package_jinxs_dir = os.path.join(package_npc_team_dir, "jinxs")
+    manifest_path = os.path.join(user_jinxs_dir, ".package_manifest.json")
+
+    # Load existing manifest of package-synced jinxs
+    old_package_jinxs = set()
+    if os.path.exists(manifest_path):
+        try:
+            import json
+            with open(manifest_path, 'r') as f:
+                old_package_jinxs = set(json.load(f).get('jinxs', []))
+        except:
+            pass
+
+    # Track current package jinxs
+    current_package_jinxs = set()
+
     if os.path.exists(package_jinxs_dir):
         for root, dirs, files in os.walk(package_jinxs_dir):
             # Calculate relative path from package_jinxs_dir
             rel_path = os.path.relpath(root, package_jinxs_dir)
-            
+
             # Create corresponding directory in user jinxs
             if rel_path == '.':
                 dest_dir = user_jinxs_dir
             else:
                 dest_dir = os.path.join(user_jinxs_dir, rel_path)
             os.makedirs(dest_dir, exist_ok=True)
-            
+
             # Copy all .jinx files in this directory
             for filename in files:
                 if filename.endswith(".jinx"):
                     source_jinx_path = os.path.join(root, filename)
                     destination_jinx_path = os.path.join(dest_dir, filename)
-                    
+                    jinx_rel_path = os.path.join(rel_path, filename) if rel_path != '.' else filename
+                    current_package_jinxs.add(jinx_rel_path)
+
                     if not os.path.exists(destination_jinx_path) or file_has_changed(
                         source_jinx_path, destination_jinx_path
                     ):
                         shutil.copy2(source_jinx_path, destination_jinx_path)
-                        print(f"Copied jinx {os.path.join(rel_path, filename)} to {destination_jinx_path}")
+                        print(f"Copied jinx {jinx_rel_path} to {destination_jinx_path}")
+
+    # Clean up old package jinxs that are no longer in the package
+    # (but preserve user-created jinxs that were never in the manifest)
+    stale_jinxs = old_package_jinxs - current_package_jinxs
+    for stale_jinx in stale_jinxs:
+        stale_path = os.path.join(user_jinxs_dir, stale_jinx)
+        if os.path.exists(stale_path):
+            try:
+                os.remove(stale_path)
+                print(f"Removed stale package jinx: {stale_jinx}")
+                # Remove empty parent directories
+                parent_dir = os.path.dirname(stale_path)
+                while parent_dir != user_jinxs_dir:
+                    if os.path.isdir(parent_dir) and not os.listdir(parent_dir):
+                        os.rmdir(parent_dir)
+                        print(f"Removed empty directory: {parent_dir}")
+                    parent_dir = os.path.dirname(parent_dir)
+            except Exception as e:
+                print(f"Could not remove stale jinx {stale_jinx}: {e}")
+
+    # Save updated manifest
+    try:
+        import json
+        with open(manifest_path, 'w') as f:
+            json.dump({'jinxs': list(current_package_jinxs), 'updated': str(__import__('datetime').datetime.now())}, f, indent=2)
+    except Exception as e:
+        print(f"Could not save jinx manifest: {e}")
 
     # Copy templates directory
     templates = os.path.join(package_npc_team_dir, "templates")
@@ -1548,29 +1623,134 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
 
         sys.stdout.flush()
 
+    # Enable bracketed paste mode - terminal will wrap pastes with escape sequences
+    sys.stdout.write('\033[?2004h')
+
     # Print prompt and reserve hint line
     sys.stdout.write(prompt + '\n' + (token_hint or '') + '\033[A\r')
     if prompt_visible_len > 0:
         sys.stdout.write('\033[' + str(prompt_visible_len) + 'C')
     sys.stdout.flush()
 
+    # Store pasted content separately
+    pasted_content = None
+    in_paste = False
+    paste_buffer = ""
+
+    # Track Ctrl+C for double-press exit
+    import time
+    last_ctrl_c_time = 0
+
     try:
         tty.setcbreak(fd)
+
         while True:
             c = sys.stdin.read(1)
 
-            if c in ('\n', '\r'):
-                # Clear hint and newline
+            if not c:  # EOF/stdin closed
+                sys.stdout.write('\033[?2004l')  # Disable bracketed paste
                 sys.stdout.write('\n\033[K')
                 sys.stdout.flush()
-                if buf.strip():
-                    readline.add_history(buf)
-                return buf
+                raise EOFError
 
-            elif c == '\x1b':  # ESC - could be arrow key
+            # Check for bracketed paste start: ESC [ 2 0 0 ~
+            if c == '\x1b':
                 c2 = sys.stdin.read(1)
                 if c2 == '[':
                     c3 = sys.stdin.read(1)
+                    if c3 == '2':
+                        c4 = sys.stdin.read(1)
+                        if c4 == '0':
+                            c5 = sys.stdin.read(1)
+                            if c5 == '0':
+                                c6 = sys.stdin.read(1)
+                                if c6 == '~':
+                                    # Start of bracketed paste
+                                    in_paste = True
+                                    paste_buffer = ""
+                                    continue
+                            elif c5 == '1':
+                                c6 = sys.stdin.read(1)
+                                if c6 == '~':
+                                    # End of bracketed paste ESC [ 2 0 1 ~
+                                    in_paste = False
+                                    if paste_buffer:
+                                        # Check if this looks like binary/image data
+                                        # Image signatures: PNG (\x89PNG), JPEG (\xff\xd8\xff), GIF (GIF8), BMP (BM)
+                                        # Also check for high ratio of non-printable chars
+                                        is_binary = False
+                                        if len(paste_buffer) > 4:
+                                            # Check for common image magic bytes
+                                            if paste_buffer[:4] == '\x89PNG' or paste_buffer[:8] == '\x89PNG\r\n\x1a\n':
+                                                is_binary = True
+                                            elif paste_buffer[:2] == '\xff\xd8':  # JPEG
+                                                is_binary = True
+                                            elif paste_buffer[:4] == 'GIF8':  # GIF
+                                                is_binary = True
+                                            elif paste_buffer[:2] == 'BM':  # BMP
+                                                is_binary = True
+                                            elif paste_buffer.startswith('data:image/'):  # Base64 data URL
+                                                is_binary = True
+                                            else:
+                                                # Check for high ratio of non-printable characters
+                                                non_printable = sum(1 for c in paste_buffer[:100] if ord(c) < 32 and c not in '\n\r\t')
+                                                if non_printable > 10:  # More than 10% non-printable in first 100 chars
+                                                    is_binary = True
+
+                                        if is_binary:
+                                            # Save image data to temp file
+                                            import tempfile
+                                            import os
+                                            try:
+                                                # Determine extension from magic bytes
+                                                ext = '.bin'
+                                                if '\x89PNG' in paste_buffer[:8]:
+                                                    ext = '.png'
+                                                elif paste_buffer[:2] == '\xff\xd8':
+                                                    ext = '.jpg'
+                                                elif paste_buffer[:4] == 'GIF8':
+                                                    ext = '.gif'
+                                                elif paste_buffer.startswith('data:image/'):
+                                                    # Extract from data URL
+                                                    if 'png' in paste_buffer[:30]:
+                                                        ext = '.png'
+                                                    elif 'jpeg' in paste_buffer[:30] or 'jpg' in paste_buffer[:30]:
+                                                        ext = '.jpg'
+                                                    elif 'gif' in paste_buffer[:30]:
+                                                        ext = '.gif'
+
+                                                fd, temp_path = tempfile.mkstemp(suffix=ext, prefix='npcsh_paste_')
+                                                with os.fdopen(fd, 'wb') as f:
+                                                    if paste_buffer.startswith('data:image/'):
+                                                        # Decode base64 data URL
+                                                        import base64
+                                                        _, data = paste_buffer.split(',', 1)
+                                                        f.write(base64.b64decode(data))
+                                                    else:
+                                                        f.write(paste_buffer.encode('latin-1'))
+                                                pasted_content = temp_path  # Store path to image
+                                                placeholder = f"[pasted image: {temp_path}]"
+                                            except:
+                                                pasted_content = None
+                                                placeholder = "[pasted image: failed to save]"
+                                        else:
+                                            pasted_content = paste_buffer.rstrip('\r\n')
+                                            line_count = pasted_content.count('\n') + 1
+                                            char_count = len(pasted_content)
+                                            if line_count > 1:
+                                                placeholder = f"[pasted: {line_count} lines, {char_count} chars]"
+                                            else:
+                                                # Single line paste - just insert it directly
+                                                buf = buf[:pos] + pasted_content + buf[pos:]
+                                                pos += len(pasted_content)
+                                                pasted_content = None  # Clear so we don't replace on submit
+                                                draw()
+                                                continue
+                                        buf = buf[:pos] + placeholder + buf[pos:]
+                                        pos += len(placeholder)
+                                        draw()
+                                    continue
+                    # Handle arrow keys and other escape sequences
                     if c3 == 'A':  # Up
                         if history_idx > 0:
                             if history_idx == len(history):
@@ -1579,37 +1759,78 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
                             buf = history[history_idx] or ''
                             pos = len(buf)
                             draw()
+                        continue
                     elif c3 == 'B':  # Down
                         if history_idx < len(history):
                             history_idx += 1
                             buf = saved_line if history_idx == len(history) else (history[history_idx] or '')
                             pos = len(buf)
                             draw()
+                        continue
                     elif c3 == 'C':  # Right
                         if pos < len(buf):
                             pos += 1
                             sys.stdout.write('\033[C')
                             sys.stdout.flush()
+                        continue
                     elif c3 == 'D':  # Left
                         if pos > 0:
                             pos -= 1
                             sys.stdout.write('\033[D')
                             sys.stdout.flush()
+                        continue
                     elif c3 == '3':  # Del
                         sys.stdin.read(1)  # ~
                         if pos < len(buf):
                             buf = buf[:pos] + buf[pos+1:]
                             draw()
+                        continue
                     elif c3 == 'H':  # Home
                         pos = 0
                         draw()
+                        continue
                     elif c3 == 'F':  # End
                         pos = len(buf)
                         draw()
+                        continue
                 elif c2 == '\x1b':  # Double ESC
+                    sys.stdout.write('\033[?2004l')  # Disable bracketed paste
                     sys.stdout.write('\n\033[K')
                     sys.stdout.flush()
                     return '\x1b'
+                continue
+
+            # If we're in a paste, accumulate to paste buffer
+            if in_paste:
+                paste_buffer += c
+                continue
+
+            if c in ('\n', '\r'):
+                # Clear hint and newline
+                sys.stdout.write('\033[?2004l')  # Disable bracketed paste
+                sys.stdout.write('\n\033[K')
+                sys.stdout.flush()
+                # If we have pasted content, replace placeholder with actual content
+                if pasted_content is not None:
+                    import re
+                    # Escape pipe characters in pasted content so they aren't parsed as pipeline operators
+                    escaped_content = pasted_content.replace('|', '\\|')
+                    # If pasted content is at the start of command, escape @ and / to prevent
+                    # them being interpreted as delegation or slash commands
+                    placeholder_pattern = r'\[pasted: \d+ lines?, \d+ chars?\]'
+                    if re.match(placeholder_pattern, buf.lstrip()):
+                        if escaped_content.startswith('@'):
+                            escaped_content = '\\@' + escaped_content[1:]
+                        elif escaped_content.startswith('/'):
+                            escaped_content = '\\/' + escaped_content[1:]
+                    # Use lambda to avoid backreference issues in replacement string
+                    result = re.sub(placeholder_pattern, lambda m: escaped_content, buf)
+                    if result.strip():
+                        readline.add_history(result)
+                    return result
+                if buf.strip():
+                    readline.add_history(buf)
+                return buf
 
             elif c == '\x7f' or c == '\x08':  # Backspace
                 if pos > 0:
@@ -1618,9 +1839,27 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
                     draw()
 
             elif c == '\x03':  # Ctrl-C
-                sys.stdout.write('\n\033[K')
-                sys.stdout.flush()
-                raise KeyboardInterrupt
+                current_time = time.time()
+                if current_time - last_ctrl_c_time < 1.0:  # Double Ctrl+C within 1 second
+                    # Exit
+                    sys.stdout.write('\033[?2004l')  # Disable bracketed paste
+                    sys.stdout.write('\n\033[K')
+                    sys.stdout.flush()
+                    termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+                    raise KeyboardInterrupt
+                else:
+                    # First Ctrl+C - clear the line
+                    last_ctrl_c_time = current_time
+                    buf = ""
+                    pos = 0
+                    pasted_content = None
+                    sys.stdout.write('\r\033[K')  # Clear current line
+                    sys.stdout.write('^C\n')
+                    # Redraw prompt
+                    sys.stdout.write(prompt + '\n' + current_hint() + '\033[A\r')
+                    if prompt_visible_len > 0:
+                        sys.stdout.write('\033[' + str(prompt_visible_len) + 'C')
+                    sys.stdout.flush()
 
             elif c == '\x04':  # Ctrl-D
                 if not buf:
@@ -1692,12 +1931,14 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
                 except:
                     pass
 
-            elif ord(c) >= 32:  # Printable
+            elif c and ord(c) >= 32:  # Printable
                 buf = buf[:pos] + c + buf[pos:]
                 pos += 1
                 draw()
 
     finally:
+        sys.stdout.write('\033[?2004l')  # Disable bracketed paste mode
+        sys.stdout.flush()
         termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
 
 
@@ -2123,6 +2364,96 @@ def model_supports_tool_calls(model: Optional[str], provider: Optional[str]) ->
     return any(marker in model_lower for marker in toolish_markers)
 
 
+def wrap_tool_with_display(tool_name: str, tool_func: Callable, state: ShellState) -> Callable:
+    """Wrap a tool function to add visual feedback when it executes.
+
+    Respects state.log_level:
+    - "silent": no output
+    - "normal": show tool name and success/failure
+    - "verbose": show tool name, args, success/failure, and result preview
+    """
+    def wrapped(**kwargs):
+        log_level = getattr(state, 'log_level', 'normal')
+
+        # Display tool call (skip in silent mode)
+        if log_level != "silent":
+            try:
+                args_display = ""
+                # Always show a preview of args for key tools
+                if kwargs:
+                    # For sh/python/sql, show the code/command being run
+                    if tool_name in ('sh', 'python', 'sql', 'cmd') and 'code' in kwargs:
+                        code_preview = str(kwargs['code']).strip().split('\n')[0]  # First line
+                        if len(code_preview) > 80:
+                            code_preview = code_preview[:80] + "…"
+                        args_display = code_preview
+                    elif tool_name == 'sh' and 'bash_command' in kwargs:
+                        cmd_preview = str(kwargs['bash_command']).strip().split('\n')[0]
+                        if len(cmd_preview) > 80:
+                            cmd_preview = cmd_preview[:80] + "…"
+                        args_display = cmd_preview
+                    elif tool_name in ('sh', 'cmd') and 'command' in kwargs:
+                        cmd_preview = str(kwargs['command']).strip().split('\n')[0]
+                        if len(cmd_preview) > 80:
+                            cmd_preview = cmd_preview[:80] + "…"
+                        args_display = cmd_preview
+                    elif tool_name == 'python' and 'python_code' in kwargs:
+                        code_preview = str(kwargs['python_code']).strip().split('\n')[0]
+                        if len(code_preview) > 80:
+                            code_preview = code_preview[:80] + "…"
+                        args_display = code_preview
+                    elif tool_name == 'agent' and 'npc_name' in kwargs:
+                        args_display = f"@{kwargs['npc_name']}"
+                        if 'request' in kwargs:
+                            req = str(kwargs['request'])[:50]
+                            args_display += f": {req}…" if len(str(kwargs['request'])) > 50 else f": {req}"
+                    elif tool_name == 'agent' and 'query' in kwargs:
+                        query_preview = str(kwargs['query']).strip()[:60]
+                        args_display = query_preview + ("…" if len(str(kwargs['query'])) > 60 else "")
+                    elif log_level == "verbose":
+                        arg_parts = []
+                        for _, v in kwargs.items():
+                            v_str = str(v)
+                            if len(v_str) > 40:
+                                v_str = v_str[:40] + "…"
+                            arg_parts.append(f"{v_str}")
+                        args_display = " ".join(arg_parts)
+                        if len(args_display) > 60:
+                            args_display = args_display[:60] + "…"
+
+                if args_display:
+                    print(colored(f"  ⚡ {tool_name}", "cyan") + colored(f" {args_display}", "white", attrs=["dark"]), end="", flush=True)
+                else:
+                    print(colored(f"  ⚡ {tool_name}", "cyan"), end="", flush=True)
+            except:
+                pass
+
+        # Execute tool
+        try:
+            result = tool_func(**kwargs)
+            if log_level != "silent":
+                try:
+                    print(colored(" ✓", "green"), flush=True)
+                    # Show preview of result only in verbose mode
+                    if log_level == "verbose":
+                        result_preview = str(result)
+                        if len(result_preview) > 200:
+                            result_preview = result_preview[:200] + "..."
+                        if result_preview and result_preview not in ('None', '', '{}', '[]'):
+                            print(colored(f"    → {result_preview}", "white", attrs=["dark"]), flush=True)
+                except:
+                    pass
+            return result
+        except Exception as e:
+            if log_level != "silent":
+                try:
+                    print(colored(f" ✗ {str(e)[:100]}", "red"), flush=True)
+                except:
+                    pass
+            raise
+    return wrapped
+
+
 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.
@@ -2230,7 +2561,11 @@ def collect_llm_tools(state: ShellState) -> Tuple[List[Dict[str, Any]], Dict[str
         name = tool_def.get("function", {}).get("name")
         if name:
             deduped[name] = tool_def
-    return list(deduped.values()), tool_map
+
+    # Wrap all tools with display feedback for npcsh
+    wrapped_tool_map = {name: wrap_tool_with_display(name, func, state) for name, func in tool_map.items()}
+
+    return list(deduped.values()), wrapped_tool_map
 
 
 def should_skip_kg_processing(user_input: str, assistant_output: str) -> bool:
@@ -2454,15 +2789,19 @@ def process_pipeline_command(
             else cmd_to_process
         )
         path_cmd = 'The current working directory is: ' + state.current_path
-        ls_files = (
-            'Files in the current directory (full paths):\n' + 
-            "\n".join([
-                os.path.join(state.current_path, f) 
-                for f in os.listdir(state.current_path)
-            ]) 
-            if os.path.exists(state.current_path) 
-            else 'No files found in the current directory.'
-        )
+        if os.path.exists(state.current_path):
+            all_files = os.listdir(state.current_path)
+            # Limit to first 100 files to avoid token explosion
+            limited_files = all_files[:100]
+            file_list = "\n".join([
+                os.path.join(state.current_path, f)
+                for f in limited_files
+            ])
+            if len(all_files) > 100:
+                file_list += f"\n... and {len(all_files) - 100} more files"
+            ls_files = 'Files in the current directory (full paths):\n' + file_list
+        else:
+            ls_files = 'No files found in the current directory.'
         platform_info = (
             f"Platform: {platform.system()} {platform.release()} "
             f"({platform.machine()})"
@@ -2526,18 +2865,66 @@ def process_pipeline_command(
                                 (exec_model and "gemini" in exec_model.lower())
                     llm_kwargs["tool_choice"] = 'auto'
 
-                    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,
-                        **llm_kwargs,
-                    )
+                    # Agent loop: keep calling LLM until it stops making tool calls
+                    # The LLM decides when it's done - npcsh just facilitates
+                    iteration = 0
+                    max_iterations = 50  # Safety limit to prevent infinite loops
+                    total_usage = {"input_tokens": 0, "output_tokens": 0}
+
+                    while iteration < max_iterations:
+                        iteration += 1
+
+                        llm_result = get_llm_response(
+                            full_llm_cmd if iteration == 1 else None,  # Only pass prompt on first call
+                            model=exec_model,
+                            provider=exec_provider,
+                            npc=state.npc,
+                            team=state.team,
+                            messages=state.messages,
+                            stream=False,  # Don't stream intermediate calls
+                            attachments=state.attachments if iteration == 1 else None,
+                            context=info if iteration == 1 else None,
+                            **llm_kwargs,
+                        )
+
+                        # Accumulate usage
+                        if isinstance(llm_result, dict) and llm_result.get('usage'):
+                            total_usage["input_tokens"] += llm_result['usage'].get('input_tokens', 0)
+                            total_usage["output_tokens"] += llm_result['usage'].get('output_tokens', 0)
+
+                        # Update state messages
+                        old_msg_count = len(state.messages) if state.messages else 0
+                        if isinstance(llm_result, dict):
+                            state.messages = llm_result.get("messages", state.messages)
+
+                        # Display tool outputs from this iteration
+                        for msg in state.messages[old_msg_count:]:
+                            if msg.get("role") == "tool":
+                                tool_name = msg.get("name", "tool")
+                                tool_content = msg.get("content", "")
+                                if tool_content and tool_content.strip():
+                                    print(colored(f"\n⚡ {tool_name}:", "cyan"))
+                                    lines = tool_content.split('\n')
+                                    if len(lines) > 50:
+                                        print('\n'.join(lines[:25]))
+                                        print(colored(f"\n... ({len(lines) - 50} lines hidden) ...\n", "white", attrs=["dark"]))
+                                        print('\n'.join(lines[-25:]))
+                                    else:
+                                        print(tool_content)
+
+                        # Check if LLM made tool calls - if not, it's done
+                        tool_calls_made = isinstance(llm_result, dict) and llm_result.get("tool_calls")
+                        if not tool_calls_made:
+                            # LLM is done - no more tool calls
+                            break
+
+                        # Clear the prompt for continuation calls - context is in messages
+                        full_llm_cmd = None
+
+                    # Store accumulated usage
+                    if isinstance(llm_result, dict):
+                        llm_result['usage'] = total_usage
+
                 else:
                     llm_result = check_llm_command(
                         full_llm_cmd,
@@ -2781,6 +3168,11 @@ def execute_command(
     if not command.strip():
         return state, ""
 
+    # Unescape @ and / at start of command that were escaped to prevent misinterpretation
+    # (e.g., from pasted content that starts with @ or /)
+    if command.startswith('\\@') or command.startswith('\\/'):
+        command = command[1:]  # Remove the escape backslash
+
     # Check for mode switch commands
     mode_change, state = check_mode_switch(command, state)
     if mode_change:
@@ -2802,6 +3194,8 @@ def execute_command(
 
     original_command_for_embedding = command
     commands = split_by_pipes(command)
+    # Unescape pipe characters that were escaped to prevent splitting (e.g., from pasted content)
+    commands = [cmd.replace('\\|', '|') for cmd in commands]
 
     stdin_for_next = None
     final_output = None
@@ -2993,32 +3387,44 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
         default_forenpc_name = "forenpc"
     else:
         if not os.path.exists('.npcsh_global'):
-            resp = input(f"No npc_team found in {os.getcwd()}. Create a new team here? [Y/n]: ").strip().lower()
+            try:
+                resp = input(f"No npc_team found in {os.getcwd()}. Create a new team here? [Y/n]: ").strip().lower()
+            except (KeyboardInterrupt, EOFError):
+                print("\nAborted.")
+                sys.exit(0)
             if resp in ("", "y", "yes"):
                 team_dir = project_team_path
                 os.makedirs(team_dir, exist_ok=True)
                 default_forenpc_name = "forenpc"
-                forenpc_directive = input(
-                    f"Enter a primary directive for {default_forenpc_name} (default: 'You are the forenpc of the team...'): "
-                ).strip() or "You are the forenpc of the team, coordinating activities between NPCs on the team, verifying that results from NPCs are high quality and can help to adequately answer user requests."
-                forenpc_model = input("Enter a model for your forenpc (default: llama3.2): ").strip() or "llama3.2"
-                forenpc_provider = input("Enter a provider for your forenpc (default: ollama): ").strip() or "ollama"
-                
+                try:
+                    forenpc_directive = input(
+                        f"Enter a primary directive for {default_forenpc_name} (default: 'You are the forenpc of the team...'): "
+                    ).strip() or "You are the forenpc of the team, coordinating activities between NPCs on the team, verifying that results from NPCs are high quality and can help to adequately answer user requests."
+                    forenpc_model = input("Enter a model for your forenpc (default: llama3.2): ").strip() or "llama3.2"
+                    forenpc_provider = input("Enter a provider for your forenpc (default: ollama): ").strip() or "ollama"
+                except (KeyboardInterrupt, EOFError):
+                    print("\nAborted.")
+                    sys.exit(0)
+
                 with open(os.path.join(team_dir, f"{default_forenpc_name}.npc"), "w") as f:
                     yaml.dump({
                         "name": default_forenpc_name, "primary_directive": forenpc_directive,
                         "model": forenpc_model, "provider": forenpc_provider
                     }, f)
-                
+
                 ctx_path = os.path.join(team_dir, "team.ctx")
-                folder_context = input("Enter a short description for this project/team (optional): ").strip()
-                team_ctx_data = {
-                    "forenpc": default_forenpc_name, 
-                    "model": forenpc_model,
-                    "provider": forenpc_provider, 
-                    "context": folder_context if folder_context else None
-                }
-                use_jinxs = input("Use global jinxs folder (g) or copy to this project (c)? [g/c, default: g]: ").strip().lower()
+                try:
+                    folder_context = input("Enter a short description for this project/team (optional): ").strip()
+                    team_ctx_data = {
+                        "forenpc": default_forenpc_name,
+                        "model": forenpc_model,
+                        "provider": forenpc_provider,
+                        "context": folder_context if folder_context else None
+                    }
+                    use_jinxs = input("Use global jinxs folder (g) or copy to this project (c)? [g/c, default: g]: ").strip().lower()
+                except (KeyboardInterrupt, EOFError):
+                    print("\nAborted.")
+                    sys.exit(0)
                 if use_jinxs == "c":
                     global_jinxs_dir = os.path.expanduser("~/.npcsh/npc_team/jinxs")
                     if os.path.exists(global_jinxs_dir):
@@ -3035,7 +3441,7 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
                 with open(".npcsh_global", "w") as f:
                     pass
                 team_dir = global_team_path
-                default_forenpc_name = "sibiji"  
+                default_forenpc_name = "sibiji"
         else:
             team_dir = global_team_path
             default_forenpc_name = "sibiji"
@@ -3195,7 +3601,8 @@ def process_result(
 
     # FIX: Handle dict output properly
     if isinstance(output, dict):
-        output_content = output.get('output')
+        # Use None-safe check to not skip empty strings
+        output_content = output.get('output') if 'output' in output else output.get('response')
         model_for_stream = output.get('model', active_npc.model)
         provider_for_stream = output.get('provider', active_npc.provider)
 
@@ -3212,18 +3619,22 @@ def process_result(
                 usage.get('output_tokens', 0)
             )
 
-        # If output_content is still a dict or None, convert to string
+        # If output_content is still a dict, 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"
+        elif output_content is None or output_content == '':
+            # No output from the agent - this is fine, don't show annoying message
+            output_content = None
     else:
         output_content = output
         model_for_stream = active_npc.model
         provider_for_stream = active_npc.provider
 
     print('\n')
-    if user_input == '/help':
+    if output_content is None:
+        # No output to display - tool results already shown during execution
+        pass
+    elif user_input == '/help':
         if isinstance(output_content, str):
             render_markdown(output_content)
         else:
@@ -3235,12 +3646,12 @@ def process_result(
             render_markdown(final_output_str)
         else:
             final_output_str = print_and_process_stream_with_markdown(
-                output_content, 
-                model_for_stream, 
-                provider_for_stream, 
+                output_content,
+                model_for_stream,
+                provider_for_stream,
                 show=True
             )
-    elif output_content is not None:
+    else:
         final_output_str = str(output_content)
         render_markdown(final_output_str)