npcsh 0.3.30__py3-none-any.whl → 0.3.32__py3-none-any.whl

npcsh/shell.py

@@ -30,7 +30,7 @@ except:
     print("Could not load the sentence-transformers package.")
 # Local imports
 
-from .npc_sysenv import (
+from npcsh.npc_sysenv import (
     get_system_message,
     lookup_provider,
     NPCSH_STREAM_OUTPUT,
@@ -39,13 +39,13 @@ from .npc_sysenv import (
     NPCSH_API_URL,
 )
 
-from .command_history import (
+from npcsh.command_history import (
     CommandHistory,
     start_new_conversation,
     save_conversation_message,
     save_attachment_to_message,
 )
-from .llm_funcs import (
+from npcsh.llm_funcs import (
     execute_llm_command,
     execute_llm_question,
     generate_image,
@@ -53,14 +53,14 @@ from .llm_funcs import (
     get_conversation,
     get_system_message,
 )
-from .search import rag_search, search_web
-from .helpers import (
+from npcsh.search import rag_search, search_web
+from npcsh.helpers import (
     load_all_files,
     setup_npcsh_config,
     is_npcsh_initialized,
     initialize_base_npcs_if_needed,
 )
-from .shell_helpers import (
+from npcsh.shell_helpers import (
     complete,  # For command completion
     readline_safe_prompt,
     get_multiline_input,
@@ -70,7 +70,7 @@ from .shell_helpers import (
     render_code_block,
     orange,  # For colored prompt
 )
-from .npc_compiler import (
+from npcsh.npc_compiler import (
     NPCCompiler,
     load_tools_from_directory,
     NPC,
@@ -78,7 +78,7 @@ from .npc_compiler import (
 )
 
 import argparse
-from .serve import (
+from npcsh.serve import (
     start_flask_server,
 )
 import importlib.metadata  # Python 3.8+
@@ -407,88 +407,86 @@ def main() -> None:
             )
 
             str_output = ""
-            if NPCSH_STREAM_OUTPUT and hasattr(output, "__iter__"):
+            try:
+                if NPCSH_STREAM_OUTPUT and hasattr(output, "__iter__"):
 
-                buffer = ""
-                in_code = False
-                code_buffer = ""
+                    buffer = ""
+                    in_code = False
+                    code_buffer = ""
 
-                for chunk in output:
+                    for chunk in output:
 
-                    if provider == "anthropic":
-                        chunk_content = (
-                            chunk.delta.text
-                            if chunk.type == "content_block_delta"
-                            else None
-                        )
-                    elif provider in ["openai", "deepseek", "openai-like"]:
                         chunk_content = "".join(
                             c.delta.content for c in chunk.choices if c.delta.content
                         )
-                    elif provider == "ollama":
-                        chunk_content = chunk["message"]["content"]
-                    else:
-                        continue
+                        if not chunk_content:
+                            continue
+
+                        str_output += chunk_content
+                        # print(str_output, "str_output")
+                        # Process the content character by character
+                        for char in chunk_content:
+                            buffer += char
+
+                            # Check for triple backticks
+                            if buffer.endswith("```"):
+                                if not in_code:
+                                    # Start of code block
+                                    in_code = True
+                                    # Print everything before the backticks
+                                    print(buffer[:-3], end="")
+                                    buffer = ""
+                                    code_buffer = ""
+                                else:
+                                    # End of code block
+                                    in_code = False
+                                    # Remove the backticks from the end of the buffer
+                                    buffer = buffer[:-3]
+                                    # Add buffer to code content and render
+                                    code_buffer += buffer
+
+                                    # Check for and strip language tag
+                                    if (
+                                        "\n" in code_buffer
+                                        and code_buffer.index("\n") < 15
+                                    ):
+                                        first_line, rest = code_buffer.split("\n", 1)
+                                        if (
+                                            first_line.strip()
+                                            and not "```" in first_line
+                                        ):
+                                            code_buffer = rest
 
-                    if not chunk_content:
-                        continue
+                                    # Render the code block
+                                    render_code_block(code_buffer)
 
-                    str_output += chunk_content
-                    # print(str_output, "str_output")
-                    # Process the content character by character
-                    for char in chunk_content:
-                        buffer += char
-
-                        # Check for triple backticks
-                        if buffer.endswith("```"):
-                            if not in_code:
-                                # Start of code block
-                                in_code = True
-                                # Print everything before the backticks
-                                print(buffer[:-3], end="")
-                                buffer = ""
-                                code_buffer = ""
+                                    # Reset buffers
+                                    buffer = ""
+                                    code_buffer = ""
+                            elif in_code:
+                                # Just add to code buffer
+                                code_buffer += char
+                                if len(buffer) >= 3:  # Keep buffer small while in code
+                                    buffer = buffer[-3:]
                             else:
-                                # End of code block
-                                in_code = False
-                                # Remove the backticks from the end of the buffer
-                                buffer = buffer[:-3]
-                                # Add buffer to code content and render
-                                code_buffer += buffer
-
-                                # Check for and strip language tag
-                                if "\n" in code_buffer and code_buffer.index("\n") < 15:
-                                    first_line, rest = code_buffer.split("\n", 1)
-                                    if first_line.strip() and not "```" in first_line:
-                                        code_buffer = rest
-
-                                # Render the code block
-                                render_code_block(code_buffer)
-
-                                # Reset buffers
-                                buffer = ""
-                                code_buffer = ""
-                        elif in_code:
-                            # Just add to code buffer
-                            code_buffer += char
-                            if len(buffer) >= 3:  # Keep buffer small while in code
-                                buffer = buffer[-3:]
-                        else:
-                            # Regular text - print if buffer gets too large
-                            if len(buffer) > 100:
-                                print(buffer[:-3], end="")
-                                buffer = buffer[
-                                    -3:
-                                ]  # Keep last 3 chars to check for backticks
-
-                # Handle any remaining content
-                if in_code:
-                    render_code_block(code_buffer)
-                else:
-                    print(buffer, end="")
+                                # Regular text - print if buffer gets too large
+                                if len(buffer) > 100:
+                                    print(buffer[:-3], end="")
+                                    buffer = buffer[
+                                        -3:
+                                    ]  # Keep last 3 chars to check for backticks
+
+                    # Handle any remaining content
+                    if in_code:
+                        render_code_block(code_buffer)
+                    else:
+                        print(buffer, end="")
+
+                    if str_output:
+                        output = str_output
+            except:
+                output = None
 
-                if str_output:
-                    output = str_output
             print("\n")
 
             if isinstance(output, str):