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

npcpy/npc_sysenv.py

@@ -4,16 +4,18 @@ import logging
 import re
 import os
 import socket
-import concurrent.futures # For managing timeouts on blocking calls
+import concurrent.futures 
 import platform
 import sqlite3
 import sys
 from typing import Dict, List
 import textwrap
 import json
+
+
+import requests
 ON_WINDOWS = platform.system() == "Windows"
 
-# Try/except for termios, tty, pty, select, signal
 try:
     if not ON_WINDOWS:
         import termios
@@ -28,14 +30,14 @@ except ImportError:
     select = None
     signal = None
 
-# Try/except for readline
+
 try:
     import readline
 except ImportError:
     readline = None
     logging.warning('no readline support, some features may not work as desired.')
 
-# Try/except for rich imports
+
 try:
     from rich.console import Console
     from rich.markdown import Markdown
@@ -48,7 +50,7 @@ except ImportError:
 import warnings
 import time
 
-# Global variables
+
 running = True
 is_recording = False
 recording_data = []
@@ -61,7 +63,7 @@ warnings.filterwarnings("ignore", module="torch.serialization")
 os.environ["PYTHONWARNINGS"] = "ignore"
 os.environ["SDL_AUDIODRIVER"] = "dummy"
 
-def check_internet_connection(timeout=0.5):
+def check_internet_connection(timeout=5):
     """
     Checks for internet connectivity by trying to connect to a well-known host.
     """
@@ -85,38 +87,143 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                         key, value = line.split("=", 1)
                         env_vars[key.strip()] = value.strip().strip("\"'")
 
-    # --- Internet check here ---
     internet_available = check_internet_connection()
     if not internet_available:
-        logging.info("No internet connection detected. External API calls will be skipped (effective airplane_mode).")
-        # If no internet, force airplane_mode to True, regardless of its initial value.
+        logging.info(
+            "No internet connection detected. "
+            "External API calls will be skipped."
+        )
         airplane_mode = True
     else:
-        logging.info("Internet connection detected. Proceeding based on 'airplane_mode' parameter.")
-    # --- End internet check ---
-
+        logging.info(
+            "Internet connection detected. "
+            "Proceeding based on 'airplane_mode' parameter."
+        )
+    
+    custom_providers = load_custom_providers()
+    
+    for provider_name, config in custom_providers.items():
+        api_key_var = config.get('api_key_var')
+        if not api_key_var:
+            api_key_var = f"{provider_name.upper()}_API_KEY"
+        
+        if api_key_var in env_vars or os.environ.get(api_key_var):
+            try:
+                import requests
+                
+                def fetch_custom_models():
+                    base_url = config.get('base_url', '')
+                    headers = config.get('headers', {})
+                    
+                    api_key = env_vars.get(api_key_var) or \
+                              os.environ.get(api_key_var)
+                    if api_key:
+                        headers['Authorization'] = f'Bearer {api_key}'
+                    
+                    models_endpoint = f"{base_url.rstrip('/')}/models"
+                    response = requests.get(
+                        models_endpoint, 
+                        headers=headers,
+                        timeout=3.5
+                    )
+                    
+                    if response.status_code == 200:
+                        data = response.json()
+                        
+                        if isinstance(data, dict) and 'data' in data:
+                            return [
+                                m['id'] for m in data['data'] 
+                                if 'id' in m
+                            ]
+                        elif isinstance(data, list):
+                            return [
+                                m['id'] for m in data 
+                                if isinstance(m, dict) and 'id' in m
+                            ]
+                    return []
+                
+                models = fetch_custom_models()
+                for model in models:
+                    available_models[model] = 'openai-like'
+                    
+                logging.info(
+                    f"Loaded {len(models)} models "
+                    f"from custom provider '{provider_name}'"
+                )
+                
+            except Exception as e:
+                logging.warning(
+                    f"Failed to load models from "
+                    f"custom provider '{provider_name}': {e}"
+                )
+    
+    
+    airplane_mode = False
     if not airplane_mode:
         timeout_seconds = 3.5
-        # Use a single ThreadPoolExecutor for all network-dependent API calls
+        
+
         with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+          
+            if 'NPCSH_API_URL' in env_vars or os.environ.get('NPCSH_API_URL'):
+              try:
+                  import requests
+                  
+                  def fetch_custom_models():
+                      base_url = env_vars.get('NPCSH_API_URL') or os.environ.get('NPCSH_API_URL')                      
+                      models_endpoint = f"{base_url.rstrip('/')}/models"
+                      response = requests.get(
+                          models_endpoint, 
+
+                          timeout=3.5
+                      )
+                      
+                      if response.status_code == 200:
+                          data = response.json()
+                          
+                          if isinstance(data, dict) and 'data' in data:
+                              return [
+                                  m['id'] for m in data['data'] 
+                                  if 'id' in m
+                              ]
+                          elif isinstance(data, list):
+                              return [
+                                  m['id'] for m in data 
+                                  if isinstance(m, dict) and 'id' in m
+                              ]
+                      return []
+                  
+                  models = fetch_custom_models()
+                  for model in models:
+                      available_models[model] = 'openai-like'
+                      
 
+                
+                  
+              except Exception as e:
+                  logging.warning(
+                      f"Failed to load models from "
+                      f"custom provider 'openai-like': {e}"
+                  )
+  
+            
             if "ANTHROPIC_API_KEY" in env_vars or os.environ.get("ANTHROPIC_API_KEY"):
                 try:
                     import anthropic
                     
                     def fetch_anthropic_models():
                         client = anthropic.Anthropic(api_key=env_vars.get("ANTHROPIC_API_KEY") or os.environ.get("ANTHROPIC_API_KEY"))
-                        # Modern Anthropic client can also take a timeout in constructor:
-                        # client = anthropic.Anthropic(api_key=..., timeout=timeout_seconds)
+                        
+                        
                         return client.models.list()
 
                     future = executor.submit(fetch_anthropic_models)
-                    models = future.result(timeout=timeout_seconds) # Apply timeout
+                    models = future.result(timeout=timeout_seconds) 
 
                     for model in models.data:
                         available_models[model.id] = 'anthropic'
                             
-                except (ImportError, anthropic.APIError, concurrent.futures.TimeoutError, Exception) as e:
+                except (ImportError, concurrent.futures.TimeoutError, Exception) as e:
                     logging.info(f"Anthropic models not indexed or timed out: {e}")
 
             if "OPENAI_API_KEY" in env_vars or os.environ.get("OPENAI_API_KEY"):
@@ -128,7 +235,7 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                         return openai.models.list()
 
                     future = executor.submit(fetch_openai_models)
-                    models = future.result(timeout=timeout_seconds) # Apply timeout
+                    models = future.result(timeout=timeout_seconds) 
 
                     for model in models.data:
                         if (
@@ -151,7 +258,7 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                     def fetch_gemini_models():
                         client = genai.Client(api_key=env_vars.get("GEMINI_API_KEY") or os.environ.get("GEMINI_API_KEY"))
                         found_models = []
-                        # Define the model names you want to filter for
+                        
                         target_models = [
                             'gemini-2.5-pro', 
                             'gemini-2.5-flash', 
@@ -165,15 +272,15 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                             for action in m.supported_actions:
                                 if action == "generateContent":
                                     if 'models/' in m.name:
-                                        model_name_part = m.name.split('/')[1]  # Extract the part after 'models/'
-                                        # Check if any of the target models are contained within the model name
+                                        model_name_part = m.name.split('/')[1]  
+                                        
                                         if any(model in model_name_part for model in target_models):
                                             found_models.append(model_name_part)
                         return set(found_models)
                     future = executor.submit(fetch_gemini_models)
-                    models = future.result(timeout=timeout_seconds) # Apply timeout
+                    models = future.result(timeout=timeout_seconds) 
 
-                    for model in models: # 'models' is already a set of strings here
+                    for model in models: 
                         if "gemini" in model:
                             available_models[model] = "gemini"
                 except (ImportError, concurrent.futures.TimeoutError, Exception) as e:
@@ -184,13 +291,13 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                 available_models['deepseek-reasoner'] = 'deepseek'        
     try:
         import ollama
-        timeout_seconds = 0.5 # Re-using the same timeout
+        timeout_seconds = 0.5 
         with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ollama_executor:
             def fetch_ollama_models():
                 return ollama.list()
             
             future = ollama_executor.submit(fetch_ollama_models)
-            models = future.result(timeout=timeout_seconds) # Apply timeout to Ollama call
+            models = future.result(timeout=timeout_seconds) 
 
         for model in models.models:
             if "embed" not in model.model:
@@ -238,9 +345,9 @@ def preprocess_markdown(md_text):
     current_code_block = []
 
     for line in lines:
-        if line.startswith("```"):  # Toggle code block
+        if line.startswith("```"):  
             if inside_code_block:
-                # Close code block, unindent, and append
+                
                 processed_lines.append("```")
                 processed_lines.extend(
                     textwrap.dedent("\n".join(current_code_block)).split("\n")
@@ -285,7 +392,7 @@ def render_markdown(text: str) -> None:
     for line in lines:
         if line.startswith("```"):
             if inside_code_block:
-                # End of code block - render the collected code
+                
                 code = "\n".join(code_lines)
                 if code.strip():
                     syntax = Syntax(
@@ -294,13 +401,13 @@ def render_markdown(text: str) -> None:
                     console.print(syntax)
                 code_lines = []
             else:
-                # Start of code block - get language if specified
+                
                 lang = line[3:].strip() or None
             inside_code_block = not inside_code_block
         elif inside_code_block:
             code_lines.append(line)
         else:
-            # Regular markdown
+            
             console.print(Markdown(line))
 
 def get_directory_npcs(directory: str = None) -> List[str]:
@@ -371,7 +478,7 @@ def init_db_tables(db_path="~/npcsh_history.db"):
     """Initialize necessary database tables"""
     db_path = os.path.expanduser(db_path)
     with sqlite3.connect(db_path) as conn:
-        # NPC log table for storing all kinds of entries
+        
         conn.execute("""
             CREATE TABLE IF NOT EXISTS npc_log (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -383,7 +490,7 @@ def init_db_tables(db_path="~/npcsh_history.db"):
             )
         """)
         
-        # Pipeline runs table for tracking pipeline executions
+        
         conn.execute("""
             CREATE TABLE IF NOT EXISTS pipeline_runs (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -394,7 +501,7 @@ def init_db_tables(db_path="~/npcsh_history.db"):
             )
         """)
         
-        # Compiled NPCs table for storing compiled NPC content
+        
         conn.execute("""
             CREATE TABLE IF NOT EXISTS compiled_npcs (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -430,26 +537,26 @@ def get_model_and_provider(command: str, available_models: list) -> tuple:
     model_match = re.search(r"@(\S+)", command)
     if model_match:
         model_name = model_match.group(1)
-        # Autocomplete model name
+        
         matches = [m for m in available_models if m.startswith(model_name)]
         if matches:
             if len(matches) == 1:
-                model_name = matches[0]  # Complete the name if only one match
-            # Find provider for the (potentially autocompleted) model
+                model_name = matches[0]  
+            
             provider = lookup_provider(model_name)
             if provider:
-                # Remove the model tag from the command
+                
                 cleaned_command = command.replace(
                     f"@{model_match.group(1)}", ""
                 ).strip()
-                # print(cleaned_command, 'cleaned_command')
+                
                 return model_name, provider, cleaned_command
             else:
-                return None, None, command  # Provider not found
+                return None, None, command  
         else:
-            return None, None, command  # No matching model
+            return None, None, command  
     else:
-        return None, None, command  # No model specified
+        return None, None, command  
 
 def render_code_block(code: str, language: str = None) -> None:
     """Render a code block with syntax highlighting using rich, left-justified with no line numbers"""
@@ -458,7 +565,7 @@ def render_code_block(code: str, language: str = None) -> None:
 
     console = Console(highlight=True)
     code = code.strip()
-    # If code starts with a language identifier, remove it
+    
     if code.split("\n", 1)[0].lower() in ["python", "bash", "javascript"]:
         code = code.split("\n", 1)[1]
     syntax = Syntax(
@@ -479,8 +586,8 @@ def print_and_process_stream_with_markdown(response, model, provider, show=False
         print('\n') 
         return response 
     
-    # Save cursor position at the start
-    sys.stdout.write('\033[s')  # Save cursor position
+    
+    sys.stdout.write('\033[s')  
     sys.stdout.flush()
     
     try:
@@ -528,10 +635,7 @@ def print_and_process_stream_with_markdown(response, model, provider, show=False
                 for c in chunk.choices:
                     if hasattr(c.delta, "reasoning_content"):        
                         reasoning_content += c.delta.reasoning_content
-                
-                if len(reasoning_content) > 0:
-                    chunk_content = reasoning_content
-                        
+                                        
                 chunk_content += "".join(
                     c.delta.content for c in chunk.choices if c.delta.content
                 )
@@ -553,7 +657,7 @@ def print_and_process_stream_with_markdown(response, model, provider, show=False
         print('\n⚠️ Stream interrupted by user')
     
     if tool_call_data["id"] or tool_call_data["function_name"] or tool_call_data["arguments"]:
-        str_output += "\n\n### Tool Call Data\n"
+        str_output += "\n\n"
         if tool_call_data["id"]:
             str_output += f"**ID:** {tool_call_data['id']}\n\n"
         if tool_call_data["function_name"]:
@@ -568,12 +672,12 @@ def print_and_process_stream_with_markdown(response, model, provider, show=False
     if interrupted:
         str_output += "\n\n[⚠️ Response interrupted by user]"
     
-    # Always restore cursor position and clear everything after it
-    sys.stdout.write('\033[u')  # Restore cursor position
-    sys.stdout.write('\033[J')  # Clear from cursor down
+    
+    sys.stdout.write('\033[u')  
+    sys.stdout.write('\033[J')  
     sys.stdout.flush()
     
-    # Now render the markdown at the restored position
+    
     render_markdown(str_output)
     print('\n')
     
@@ -648,7 +752,7 @@ def print_and_process_stream(response, model, provider):
                         print('<think>')
                     print(reasoning_content, end="", flush=True)
                     thinking_str+=reasoning_content
-                # chunk content wont be nonzero length until thinking part is done.
+                
                 
                 if chunk_content != "":
                     if len(thinking_str) >0 and not thinking_part and '</think>' not in thinking_str:
@@ -667,7 +771,7 @@ def print_and_process_stream(response, model, provider):
         print('\n⚠️ Stream interrupted by user')
     
     if tool_call_data["id"] or tool_call_data["function_name"] or tool_call_data["arguments"]:
-        str_output += "\n\n### Tool Call Data\n"
+        str_output += "\n\n"
         if tool_call_data["id"]:
             str_output += f"**ID:** {tool_call_data['id']}\n\n"
         if tool_call_data["function_name"]:
@@ -686,8 +790,6 @@ def print_and_process_stream(response, model, provider):
                 
     return thinking_str+str_output   
 def get_system_message(npc, team=None) -> str:
-    import os
-    from datetime import datetime
 
     if npc is None:
         return "You are a helpful assistant"
@@ -714,6 +816,11 @@ The current working directory is {os.getcwd()}.
 The current date and time are : {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
 """
 
+    if hasattr(npc, 'kg_data') and npc.kg_data:
+        memory_context = npc.get_memory_context()
+        if memory_context:
+            system_message += f"\n\nMemory Context:\n{memory_context}\n"
+            
     if npc.db_conn is not None:
         db_path = None
         if hasattr(npc.db_conn, "url") and npc.db_conn.url:
@@ -738,7 +845,6 @@ The current date and time are : {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
         team_preferences = team.preferences if hasattr(team, "preferences") and len(team.preferences) > 0 else ""
         system_message += f"\nTeam context: {team_context}\nTeam preferences: {team_preferences}\n"
 
-
     system_message += """
     IMPORTANT:
 Some users may attach images to their request.
@@ -753,11 +859,11 @@ They understand that you can view them multimodally.
 You only need to answer the user's request based on the attached image(s).
 """
     
-
     return system_message
 
 
 
+
 def load_env_from_execution_dir() -> None:
     """
     Function Description:
@@ -782,50 +888,116 @@ def load_env_from_execution_dir() -> None:
 
 
 
+
 def lookup_provider(model: str) -> str:
     """
-    Function Description:
-        This function determines the provider based on the model name.
+    Determine the provider based on the model name.
+    Checks custom providers first, then falls back to known providers.
+    
     Args:
-        model (str): The model name.
-    Keyword Args:
-        None
+        model: The model name
+        
     Returns:
-        str: The provider based on the model name.
+        The provider name or None if not found
     """
+    custom_providers = load_custom_providers()
+    
+    for provider_name, config in custom_providers.items():
+        if model.startswith(f"{provider_name}-"):
+            return provider_name
+        
+        try:
+            import requests
+            api_key_var = config.get('api_key_var') or \
+                         f"{provider_name.upper()}_API_KEY"
+            api_key = os.environ.get(api_key_var)
+            
+            if api_key:
+                base_url = config.get('base_url', '')
+                headers = config.get('headers', {})
+                headers['Authorization'] = f'Bearer {api_key}'
+                
+                models_endpoint = f"{base_url.rstrip('/')}/models"
+                response = requests.get(
+                    models_endpoint, 
+                    headers=headers, 
+                    timeout=1.0
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    models = []
+                    
+                    if isinstance(data, dict) and 'data' in data:
+                        models = [m['id'] for m in data['data']]
+                    elif isinstance(data, list):
+                        models = [m['id'] for m in data]
+                    
+                    if model in models:
+                        return provider_name
+        except:
+            pass
+    
     if model == "deepseek-chat" or model == "deepseek-reasoner":
         return "deepseek"
+        
     ollama_prefixes = [
-        "llama",
-        "deepseek",
-        "qwen",
-        "llava",
-        "phi",
-        "mistral",
-        "mixtral",
-        "dolphin",
-        "codellama",
-        "gemma",
-    ]
+        "llama", "deepseek", "qwen", "llava", 
+        "phi", "mistral", "mixtral", "dolphin", 
+        "codellama", "gemma",]
     if any(model.startswith(prefix) for prefix in ollama_prefixes):
         return "ollama"
 
-    # OpenAI models
     openai_prefixes = ["gpt-", "dall-e-", "whisper-", "o1"]
     if any(model.startswith(prefix) for prefix in openai_prefixes):
         return "openai"
 
-    # Anthropic models
     if model.startswith("claude"):
         return "anthropic"
     if model.startswith("gemini"):
         return "gemini"
     if "diffusion" in model:
         return "diffusers"
+        
     return None
+
+
+def load_custom_providers():
+    """
+    Load custom provider configurations from .npcshrc
+    
+    Returns:
+        dict: Custom provider configurations keyed by provider name
+    """
+    custom_providers = {}
+    npcshrc_path = os.path.expanduser("~/.npcshrc")
+    
+    if os.path.exists(npcshrc_path):
+        with open(npcshrc_path, "r") as f:
+            for line in f:
+                line = line.split("#")[0].strip()
+                if "CUSTOM_PROVIDER_" in line and "=" in line:
+                    key, value = line.split("=", 1)
+                    key = key.strip().replace("export ", "")
+                    value = value.strip().strip("\"'")
+                    
+                    try:
+                        config = json.loads(value)
+                        provider_name = key.replace(
+                            "CUSTOM_PROVIDER_", ""
+                        ).lower()
+                        custom_providers[provider_name] = config
+                    except json.JSONDecodeError as e:
+                        logging.warning(
+                            f"Failed to parse custom provider {key}: {e}"
+                        )
+                        continue
+    
+    return custom_providers
 load_env_from_execution_dir()
 deepseek_api_key = os.getenv("DEEPSEEK_API_KEY", None)
 gemini_api_key = os.getenv("GEMINI_API_KEY", None)
 
 anthropic_api_key = os.getenv("ANTHROPIC_API_KEY", None)
 openai_api_key = os.getenv("OPENAI_API_KEY", None)
+