npcpy 1.3.6__tar.gz → 1.3.7__tar.gz

{npcpy-1.3.6/npcpy.egg-info → npcpy-1.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.6
+Version: 1.3.7
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.3.6 → npcpy-1.3.7}/npcpy/gen/response.py

@@ -570,6 +570,106 @@ def get_ollama_response(
 import time
 
 
+def get_llamacpp_response(
+    prompt: str = None,
+    model: str = None,
+    images: List[str] = None,
+    tools: list = None,
+    tool_choice: Dict = None,
+    tool_map: Dict = None,
+    think=None,
+    format: Union[str, BaseModel] = None,
+    messages: List[Dict[str, str]] = None,
+    stream: bool = False,
+    attachments: List[str] = None,
+    auto_process_tool_calls: bool = False,
+    **kwargs,
+) -> Dict[str, Any]:
+    """
+    Generate response using llama-cpp-python for local GGUF/GGML files.
+    """
+    try:
+        from llama_cpp import Llama
+    except ImportError:
+        return {
+            "response": "",
+            "messages": messages or [],
+            "error": "llama-cpp-python not installed. Install with: pip install llama-cpp-python"
+        }
+
+    result = {
+        "response": None,
+        "messages": messages.copy() if messages else [],
+        "raw_response": None,
+        "tool_calls": [],
+        "tool_results": []
+    }
+
+    if prompt:
+        if messages and messages[-1]["role"] == "user":
+            messages[-1]["content"] = prompt
+        else:
+            if not messages:
+                messages = []
+            messages.append({"role": "user", "content": prompt})
+
+    try:
+        # Load model
+        n_ctx = kwargs.get("n_ctx", 4096)
+        n_gpu_layers = kwargs.get("n_gpu_layers", -1)  # -1 = all layers on GPU if available
+
+        llm = Llama(
+            model_path=model,
+            n_ctx=n_ctx,
+            n_gpu_layers=n_gpu_layers,
+            verbose=False
+        )
+
+        # Build params
+        params = {
+            "messages": messages,
+            "stream": stream,
+        }
+        if kwargs.get("temperature"):
+            params["temperature"] = kwargs["temperature"]
+        if kwargs.get("max_tokens"):
+            params["max_tokens"] = kwargs["max_tokens"]
+        if kwargs.get("top_p"):
+            params["top_p"] = kwargs["top_p"]
+        if kwargs.get("stop"):
+            params["stop"] = kwargs["stop"]
+
+        if stream:
+            response = llm.create_chat_completion(**params)
+
+            def generate():
+                for chunk in response:
+                    # Yield the full chunk dict for proper streaming handling
+                    yield chunk
+
+            result["response"] = generate()
+        else:
+            response = llm.create_chat_completion(**params)
+            result["raw_response"] = response
+
+            if response.get("choices"):
+                content = response["choices"][0].get("message", {}).get("content", "")
+                result["response"] = content
+                result["messages"].append({"role": "assistant", "content": content})
+
+            if response.get("usage"):
+                result["usage"] = {
+                    "input_tokens": response["usage"].get("prompt_tokens", 0),
+                    "output_tokens": response["usage"].get("completion_tokens", 0),
+                }
+
+    except Exception as e:
+        result["error"] = f"llama.cpp error: {str(e)}"
+        result["response"] = ""
+
+    return result
+
+
 def get_litellm_response(
     prompt: str = None,
     model: str = None,
@@ -614,22 +714,37 @@ def get_litellm_response(
         )
     elif provider=='transformers':
         return get_transformers_response(
-            prompt, 
-            model, 
-            images=images, 
-            tools=tools, 
-            tool_choice=tool_choice, 
+            prompt,
+            model,
+            images=images,
+            tools=tools,
+            tool_choice=tool_choice,
             tool_map=tool_map,
             think=think,
-            format=format, 
-            messages=messages, 
-            stream=stream, 
-            attachments=attachments, 
-            auto_process_tool_calls=auto_process_tool_calls, 
+            format=format,
+            messages=messages,
+            stream=stream,
+            attachments=attachments,
+            auto_process_tool_calls=auto_process_tool_calls,
             **kwargs
 
         )
-    
+    elif provider == 'llamacpp':
+        return get_llamacpp_response(
+            prompt,
+            model,
+            images=images,
+            tools=tools,
+            tool_choice=tool_choice,
+            tool_map=tool_map,
+            think=think,
+            format=format,
+            messages=messages,
+            stream=stream,
+            attachments=attachments,
+            auto_process_tool_calls=auto_process_tool_calls,
+            **kwargs
+        )
 
     if attachments:
         for attachment in attachments:

{npcpy-1.3.6 → npcpy-1.3.7}/npcpy/llm_funcs.py

@@ -775,18 +775,19 @@ Instructions:
                 required_inputs = []
 
             if required_inputs:
-                # Get parameter names, distinguishing required (string) from optional with defaults (dict)
-                required_names = []  # Params without defaults - truly required
-                optional_names = []  # Params with defaults - not required
+                # Get just the parameter names (handle both string and dict formats)
+                # String inputs are required, dict inputs have defaults and are optional
+                required_names = []
+                optional_names = []
                 for inp in required_inputs:
                     if isinstance(inp, str):
                         # String inputs have no default, so they're required
                         required_names.append(inp)
                     elif isinstance(inp, dict):
-                        # Dict inputs have defaults (e.g., "backup: true"), so they're optional
+                        # Dict inputs have default values, so they're optional
                         optional_names.extend(inp.keys())
 
-                # Only check truly required params (those without defaults)
+                # Check which required params are missing (only string inputs, not dict inputs with defaults)
                 missing = [p for p in required_names if p not in inputs or not inputs.get(p)]
                 provided = list(inputs.keys())
                 if missing:

{npcpy-1.3.6 → npcpy-1.3.7}/npcpy/memory/command_history.py

@@ -30,7 +30,22 @@ except NameError as e:
     chromadb = None
 
 
-import logging 
+import logging
+
+
+def normalize_path_for_db(path_str):
+    """
+    Normalize a path for consistent database storage.
+    Converts backslashes to forward slashes for cross-platform compatibility.
+    """
+    if not path_str:
+        return path_str
+    # Convert backslashes to forward slashes
+    normalized = path_str.replace('\\', '/')
+    # Remove trailing slashes for consistency
+    normalized = normalized.rstrip('/')
+    return normalized
+
 
 def flush_messages(n: int, messages: list) -> dict:
     if n <= 0:
@@ -852,6 +867,9 @@ class CommandHistory:
         if tool_results is not None and not isinstance(tool_results, str):
             tool_results = json.dumps(tool_results, cls=CustomJSONEncoder)
 
+        # Normalize directory path for cross-platform compatibility
+        normalized_directory_path = normalize_path_for_db(directory_path)
+
         stmt = """
             INSERT INTO conversation_history
             (message_id, timestamp, role, content, conversation_id, directory_path, model, provider, npc, team, reasoning_content, tool_calls, tool_results)
@@ -859,7 +877,7 @@ class CommandHistory:
         """
         params = {
             "message_id": message_id, "timestamp": timestamp, "role": role, "content": content,
-            "conversation_id": conversation_id, "directory_path": directory_path, "model": model,
+            "conversation_id": conversation_id, "directory_path": normalized_directory_path, "model": model,
             "provider": provider, "npc": npc, "team": team, "reasoning_content": reasoning_content,
             "tool_calls": tool_calls, "tool_results": tool_results
         }
@@ -879,28 +897,31 @@ class CommandHistory:
 
         return message_id
 
-    def add_memory_to_database(self, message_id: str, conversation_id: str, npc: str, team: str, 
-                            directory_path: str, initial_memory: str, status: str, 
+    def add_memory_to_database(self, message_id: str, conversation_id: str, npc: str, team: str,
+                            directory_path: str, initial_memory: str, status: str,
                             model: str = None, provider: str = None, final_memory: str = None):
         """Store a memory entry in the database"""
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
+
+        # Normalize directory path for cross-platform compatibility
+        normalized_directory_path = normalize_path_for_db(directory_path)
+
         stmt = """
-            INSERT INTO memory_lifecycle 
-            (message_id, conversation_id, npc, team, directory_path, timestamp, 
+            INSERT INTO memory_lifecycle
+            (message_id, conversation_id, npc, team, directory_path, timestamp,
             initial_memory, final_memory, status, model, provider)
-            VALUES (:message_id, :conversation_id, :npc, :team, :directory_path, 
+            VALUES (:message_id, :conversation_id, :npc, :team, :directory_path,
                     :timestamp, :initial_memory, :final_memory, :status, :model, :provider)
         """
-        
+
         params = {
             "message_id": message_id, "conversation_id": conversation_id,
-            "npc": npc, "team": team, "directory_path": directory_path,
+            "npc": npc, "team": team, "directory_path": normalized_directory_path,
             "timestamp": timestamp, "initial_memory": initial_memory,
             "final_memory": final_memory, "status": status,
             "model": model, "provider": provider
         }
-        
+
         return self._execute_returning_id(stmt, params)
     def get_memories_for_scope(
         self,

{npcpy-1.3.6 → npcpy-1.3.7}/npcpy/memory/knowledge_graph.py

@@ -594,7 +594,7 @@ def kg_dream_process(existing_kg,
         return existing_kg, {}
     print(f"  - Generated Dream: '{dream_text[:150]}...'")
     
-    dream_kg, _ = kg_evolve_incremental(existing_kg, dream_text, model, provider, npc,  context)
+    dream_kg, _ = kg_evolve_incremental(existing_kg, new_content_text=dream_text, model=model, provider=provider, npc=npc, context=context)
     
     original_fact_stmts = {f['statement'] for f in existing_kg['facts']}
     for fact in dream_kg['facts']:

{npcpy-1.3.6 → npcpy-1.3.7}/npcpy/npc_sysenv.py

@@ -305,7 +305,33 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                 available_models[mod] = "ollama"
     except (ImportError, concurrent.futures.TimeoutError, Exception) as e:
         logging.info(f"Error loading Ollama models or timed out: {e}")
-        
+
+    # Scan for local GGUF/GGML models
+    gguf_dirs = [
+        os.path.expanduser('~/.npcsh/models/gguf'),
+        os.path.expanduser('~/.npcsh/models'),
+        os.path.expanduser('~/models'),
+        os.path.expanduser('~/.cache/huggingface/hub'),
+    ]
+    env_gguf_dir = os.environ.get('NPCSH_GGUF_DIR')
+    if env_gguf_dir:
+        gguf_dirs.insert(0, os.path.expanduser(env_gguf_dir))
+
+    seen_paths = set()
+    for scan_dir in gguf_dirs:
+        if not os.path.isdir(scan_dir):
+            continue
+        try:
+            for root, dirs, files in os.walk(scan_dir):
+                for f in files:
+                    if f.endswith(('.gguf', '.ggml')) and not f.startswith('.'):
+                        full_path = os.path.join(root, f)
+                        if full_path not in seen_paths:
+                            seen_paths.add(full_path)
+                            available_models[full_path] = "llamacpp"
+        except Exception as e:
+            logging.info(f"Error scanning GGUF directory {scan_dir}: {e}")
+
     return available_models
 
 

{npcpy-1.3.6 → npcpy-1.3.7}/npcpy/serve.py

@@ -88,6 +88,21 @@ cancellation_flags = {}
 cancellation_lock = threading.Lock()
 
 
+def normalize_path_for_db(path_str):
+    """
+    Normalize a path for consistent database storage/querying.
+    Converts backslashes to forward slashes for cross-platform compatibility.
+    This ensures Windows paths match Unix paths in the database.
+    """
+    if not path_str:
+        return path_str
+    # Convert backslashes to forward slashes
+    normalized = path_str.replace('\\', '/')
+    # Remove trailing slashes for consistency
+    normalized = normalized.rstrip('/')
+    return normalized
+
+
 # Minimal MCP client (inlined from npcsh corca to avoid corca import)
 class MCPClientNPC:
     def __init__(self, debug: bool = True):
@@ -1172,14 +1187,9 @@ def get_models():
             )
             
             display_model = m
-            if "claude-3-5-haiku-latest" in m:
-                display_model = "claude-3.5-haiku"
-            elif "claude-3-5-sonnet-latest" in m:
-                display_model = "claude-3.5-sonnet"
-            elif "gemini-1.5-flash" in m:
-                display_model = "gemini-1.5-flash"  
-            elif "gemini-2.0-flash-lite-preview-02-05" in m:
-                display_model = "gemini-2.0-flash-lite-preview"
+            if m.endswith(('.gguf', '.ggml')):
+                # For local GGUF/GGML files, show just the filename
+                display_model = os.path.basename(m)
 
             display_name = f"{display_model} | {p} {text_only}".strip()
 
@@ -2120,16 +2130,18 @@ def get_last_used_model_and_npc_in_directory(directory_path):
     engine = get_db_connection()
     try:
         with engine.connect() as conn:
+            # Normalize path for cross-platform compatibility
             query = text("""
                 SELECT model, npc
                 FROM conversation_history
-                WHERE directory_path = :directory_path 
-                AND model IS NOT NULL AND npc IS NOT NULL 
+                WHERE REPLACE(RTRIM(directory_path, '/\\'), '\\', '/') = :normalized_path
+                AND model IS NOT NULL AND npc IS NOT NULL
                 AND model != '' AND npc != ''
                 ORDER BY timestamp DESC, id DESC
                 LIMIT 1
             """)
-            result = conn.execute(query, {"directory_path": directory_path}).fetchone()
+            normalized_path = normalize_path_for_db(directory_path)
+            result = conn.execute(query, {"normalized_path": normalized_path}).fetchone()
             return {"model": result[0], "npc": result[1]} if result else {"model": None, "npc": None}
     except Exception as e:
         print(f"Error getting last used model/NPC for directory {directory_path}: {e}")
@@ -3359,7 +3371,7 @@ def stream():
     provider = data.get("provider", None)
     if provider is None:
         provider = available_models.get(model)
-        
+
     npc_name = data.get("npc", None)
     npc_source = data.get("npcSource", "global")
     current_path = data.get("currentPath")
@@ -3986,7 +3998,27 @@ def stream():
 
                     print('.', end="", flush=True)
                     dot_count += 1
-                    if "hf.co" in model or provider == 'ollama' and 'gpt-oss' not in model:
+                    if provider == 'llamacpp':
+                        # llama-cpp-python returns OpenAI-format dicts
+                        chunk_content = ""
+                        reasoning_content = None
+                        if isinstance(response_chunk, dict) and response_chunk.get("choices"):
+                            delta = response_chunk["choices"][0].get("delta", {})
+                            chunk_content = delta.get("content", "") or ""
+                            reasoning_content = delta.get("reasoning_content")
+                        if chunk_content:
+                            complete_response.append(chunk_content)
+                        if reasoning_content:
+                            complete_reasoning.append(reasoning_content)
+                        chunk_data = {
+                            "id": response_chunk.get("id"),
+                            "object": response_chunk.get("object"),
+                            "created": response_chunk.get("created"),
+                            "model": response_chunk.get("model", model),
+                            "choices": [{"index": 0, "delta": {"content": chunk_content, "role": "assistant", "reasoning_content": reasoning_content}, "finish_reason": response_chunk.get("choices", [{}])[0].get("finish_reason")}]
+                        }
+                        yield f"data: {json.dumps(chunk_data)}\n\n"
+                    elif "hf.co" in model or provider == 'ollama' and 'gpt-oss' not in model:
                         # Ollama returns ChatResponse objects - support both attribute and dict access
                         msg = getattr(response_chunk, "message", None) or response_chunk.get("message", {}) if hasattr(response_chunk, "get") else {}
                         chunk_content = getattr(msg, "content", None) or (msg.get("content") if hasattr(msg, "get") else "") or ""
@@ -4235,24 +4267,24 @@ def get_conversations():
         engine = get_db_connection()
         try:
             with engine.connect() as conn:
+                # Use REPLACE to normalize paths in the query for cross-platform compatibility
+                # This handles both forward slashes and backslashes stored in the database
                 query = text("""
                 SELECT DISTINCT conversation_id,
                        MIN(timestamp) as start_time,
                        MAX(timestamp) as last_message_timestamp,
                        GROUP_CONCAT(content) as preview
                 FROM conversation_history
-                WHERE directory_path = :path_without_slash OR directory_path = :path_with_slash
+                WHERE REPLACE(RTRIM(directory_path, '/\\'), '\\', '/') = :normalized_path
                 GROUP BY conversation_id
                 ORDER BY MAX(timestamp) DESC
                 """)
 
-                
-                path_without_slash = path.rstrip('/')
-                path_with_slash = path_without_slash + '/'
-                
+                # Normalize the input path (convert backslashes to forward slashes, strip trailing slashes)
+                normalized_path = normalize_path_for_db(path)
+
                 result = conn.execute(query, {
-                    "path_without_slash": path_without_slash,
-                    "path_with_slash": path_with_slash
+                    "normalized_path": normalized_path
                 })
                 conversations = result.fetchall()
 
@@ -4746,6 +4778,181 @@ def openai_list_models():
     })
 
 
+# ============== GGUF/GGML Model Scanning ==============
+@app.route('/api/models/gguf/scan', methods=['GET'])
+def scan_gguf_models():
+    """Scan for GGUF/GGML model files in specified or default directories."""
+    directory = request.args.get('directory')
+
+    # Default directories to scan
+    default_dirs = [
+        os.path.expanduser('~/.npcsh/models/gguf'),
+        os.path.expanduser('~/.npcsh/models'),
+        os.path.expanduser('~/models'),
+        os.path.expanduser('~/.cache/huggingface/hub'),
+    ]
+
+    # Add env var directory if set
+    env_dir = os.environ.get('NPCSH_GGUF_DIR')
+    if env_dir:
+        default_dirs.insert(0, os.path.expanduser(env_dir))
+
+    dirs_to_scan = [os.path.expanduser(directory)] if directory else default_dirs
+
+    models = []
+    seen_paths = set()
+
+    for scan_dir in dirs_to_scan:
+        if not os.path.isdir(scan_dir):
+            continue
+
+        for root, dirs, files in os.walk(scan_dir):
+            for f in files:
+                if f.endswith(('.gguf', '.ggml', '.bin')) and not f.startswith('.'):
+                    full_path = os.path.join(root, f)
+                    if full_path not in seen_paths:
+                        seen_paths.add(full_path)
+                        try:
+                            size = os.path.getsize(full_path)
+                            models.append({
+                                'name': f,
+                                'path': full_path,
+                                'size': size,
+                                'size_gb': round(size / (1024**3), 2)
+                            })
+                        except OSError:
+                            pass
+
+    return jsonify({'models': models, 'error': None})
+
+
+@app.route('/api/models/hf/download', methods=['POST'])
+def download_hf_model():
+    """Download a GGUF model from HuggingFace."""
+    data = request.json
+    url = data.get('url', '')
+    target_dir = data.get('target_dir', '~/.npcsh/models/gguf')
+
+    target_dir = os.path.expanduser(target_dir)
+    os.makedirs(target_dir, exist_ok=True)
+
+    try:
+        # Parse HuggingFace URL or model ID
+        # Formats:
+        # - TheBloke/Llama-2-7B-GGUF
+        # - https://huggingface.co/TheBloke/Llama-2-7B-GGUF/resolve/main/llama-2-7b.Q4_K_M.gguf
+
+        if url.startswith('http'):
+            # Direct URL - download the file
+            import requests
+            filename = url.split('/')[-1].split('?')[0]
+            target_path = os.path.join(target_dir, filename)
+
+            print(f"Downloading {url} to {target_path}")
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
+
+            with open(target_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+
+            return jsonify({'path': target_path, 'error': None})
+        else:
+            # Model ID - use huggingface_hub to download
+            try:
+                from huggingface_hub import hf_hub_download, list_repo_files
+
+                # List files in repo to find GGUF files
+                files = list_repo_files(url)
+                gguf_files = [f for f in files if f.endswith('.gguf')]
+
+                if not gguf_files:
+                    return jsonify({'error': 'No GGUF files found in repository'}), 400
+
+                # Download the first/smallest Q4 quantized version or first available
+                q4_files = [f for f in gguf_files if 'Q4' in f or 'q4' in f]
+                file_to_download = q4_files[0] if q4_files else gguf_files[0]
+
+                print(f"Downloading {file_to_download} from {url}")
+                path = hf_hub_download(
+                    repo_id=url,
+                    filename=file_to_download,
+                    local_dir=target_dir,
+                    local_dir_use_symlinks=False
+                )
+
+                return jsonify({'path': path, 'error': None})
+            except ImportError:
+                return jsonify({'error': 'huggingface_hub not installed. Run: pip install huggingface_hub'}), 500
+
+    except Exception as e:
+        print(f"Error downloading HF model: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
+# ============== Local Model Provider Status ==============
+@app.route('/api/models/local/scan', methods=['GET'])
+def scan_local_models():
+    """Scan for models from local providers (LM Studio, llama.cpp)."""
+    provider = request.args.get('provider', '')
+
+    if provider == 'lmstudio':
+        # LM Studio typically runs on port 1234
+        try:
+            import requests
+            response = requests.get('http://127.0.0.1:1234/v1/models', timeout=2)
+            if response.ok:
+                data = response.json()
+                models = [{'name': m.get('id', m.get('name', 'unknown'))} for m in data.get('data', [])]
+                return jsonify({'models': models, 'error': None})
+        except:
+            pass
+        return jsonify({'models': [], 'error': 'LM Studio not running or not accessible'})
+
+    elif provider == 'llamacpp':
+        # llama.cpp server typically runs on port 8080
+        try:
+            import requests
+            response = requests.get('http://127.0.0.1:8080/v1/models', timeout=2)
+            if response.ok:
+                data = response.json()
+                models = [{'name': m.get('id', m.get('name', 'unknown'))} for m in data.get('data', [])]
+                return jsonify({'models': models, 'error': None})
+        except:
+            pass
+        return jsonify({'models': [], 'error': 'llama.cpp server not running or not accessible'})
+
+    return jsonify({'models': [], 'error': f'Unknown provider: {provider}'})
+
+
+@app.route('/api/models/local/status', methods=['GET'])
+def get_local_model_status():
+    """Check if a local model provider is running."""
+    provider = request.args.get('provider', '')
+
+    if provider == 'lmstudio':
+        try:
+            import requests
+            response = requests.get('http://127.0.0.1:1234/v1/models', timeout=2)
+            if response.ok:
+                return jsonify({'status': 'running'})
+        except:
+            pass
+        return jsonify({'status': 'not_running'})
+
+    elif provider == 'llamacpp':
+        try:
+            import requests
+            response = requests.get('http://127.0.0.1:8080/v1/models', timeout=2)
+            if response.ok:
+                return jsonify({'status': 'running'})
+        except:
+            pass
+        return jsonify({'status': 'not_running'})
+
+    return jsonify({'status': 'unknown', 'error': f'Unknown provider: {provider}'})
+
+
 def start_flask_server(
     port=5337,
     cors_origins=None,

{npcpy-1.3.6 → npcpy-1.3.7/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.6
+Version: 1.3.7
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.3.6 → npcpy-1.3.7}/setup.py

@@ -83,7 +83,7 @@ extra_files = package_files("npcpy/npc_team/")
 
 setup(
     name="npcpy",
-    version="1.3.6",
+    version="1.3.7",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  
     extras_require={