npcpy 1.3.16__tar.gz → 1.3.18__tar.gz

{npcpy-1.3.16/npcpy.egg-info → npcpy-1.3.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.16
+Version: 1.3.18
 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.16 → npcpy-1.3.18}/npcpy/data/web.py

@@ -66,7 +66,6 @@ def search_perplexity(
         "top_p": top_p,
         "return_images": False,
         "return_related_questions": False,
-        "search_recency_filter": "month",
         "top_k": 0,
         "stream": False,
         "presence_penalty": 0,

{npcpy-1.3.16 → npcpy-1.3.18}/npcpy/gen/response.py

@@ -588,6 +588,148 @@ def get_ollama_response(
 import time
 
 
+def get_lora_response(
+    prompt: str = None,
+    model: str = None,
+    tools: list = None,
+    tool_map: Dict = None,
+    format: str = None,
+    messages: List[Dict[str, str]] = None,
+    stream: bool = False,
+    auto_process_tool_calls: bool = False,
+    **kwargs,
+) -> Dict[str, Any]:
+    """
+    Generate response using a LoRA adapter on top of a base model.
+    The adapter path should contain adapter_config.json with base_model_name_or_path.
+    """
+    print(f"🎯 get_lora_response called with model={model}, prompt={prompt[:50] if prompt else 'None'}...")
+
+    result = {
+        "response": None,
+        "messages": messages.copy() if messages else [],
+        "raw_response": None,
+        "tool_calls": [],
+        "tool_results": []
+    }
+
+    try:
+        import torch
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        from peft import PeftModel
+        print("🎯 Successfully imported torch, transformers, peft")
+    except ImportError as e:
+        print(f"🎯 Import error: {e}")
+        return {
+            "response": "",
+            "messages": messages or [],
+            "error": f"Missing dependencies for LoRA. Install with: pip install transformers peft torch. Error: {e}"
+        }
+
+    adapter_path = os.path.expanduser(model)
+    adapter_config_path = os.path.join(adapter_path, 'adapter_config.json')
+
+    if not os.path.exists(adapter_config_path):
+        return {
+            "response": "",
+            "messages": messages or [],
+            "error": f"No adapter_config.json found at {adapter_path}"
+        }
+
+    # Read base model from adapter config
+    try:
+        with open(adapter_config_path, 'r') as f:
+            adapter_config = json.load(f)
+        base_model_id = adapter_config.get('base_model_name_or_path')
+        if not base_model_id:
+            return {
+                "response": "",
+                "messages": messages or [],
+                "error": "adapter_config.json missing base_model_name_or_path"
+            }
+    except Exception as e:
+        return {
+            "response": "",
+            "messages": messages or [],
+            "error": f"Failed to read adapter config: {e}"
+        }
+
+    if prompt:
+        if result['messages'] and result['messages'][-1]["role"] == "user":
+            result['messages'][-1]["content"] = prompt
+        else:
+            result['messages'].append({"role": "user", "content": prompt})
+
+    if format == "json":
+        json_instruction = """If you are returning a json object, begin directly with the opening {.
+Do not include any additional markdown formatting or leading ```json tags in your response."""
+        if result["messages"] and result["messages"][-1]["role"] == "user":
+            result["messages"][-1]["content"] += "\n" + json_instruction
+
+    try:
+        logger.info(f"Loading base model: {base_model_id}")
+        tokenizer = AutoTokenizer.from_pretrained(base_model_id, trust_remote_code=True)
+        base_model = AutoModelForCausalLM.from_pretrained(
+            base_model_id,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto" if torch.cuda.is_available() else None,
+            trust_remote_code=True
+        )
+
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        logger.info(f"Loading LoRA adapter: {adapter_path}")
+        model_with_adapter = PeftModel.from_pretrained(base_model, adapter_path)
+
+        # Apply chat template
+        chat_text = tokenizer.apply_chat_template(
+            result["messages"],
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        device = next(model_with_adapter.parameters()).device
+        inputs = tokenizer(chat_text, return_tensors="pt", padding=True, truncation=True)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+
+        max_new_tokens = kwargs.get("max_tokens", 512)
+        temperature = kwargs.get("temperature", 0.7)
+
+        with torch.no_grad():
+            outputs = model_with_adapter.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens,
+                temperature=temperature,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+            )
+
+        response_content = tokenizer.decode(
+            outputs[0][inputs['input_ids'].shape[1]:],
+            skip_special_tokens=True
+        ).strip()
+
+        result["response"] = response_content
+        result["raw_response"] = response_content
+        result["messages"].append({"role": "assistant", "content": response_content})
+
+        if format == "json":
+            try:
+                if response_content.startswith("```json"):
+                    response_content = response_content.replace("```json", "").replace("```", "").strip()
+                parsed_response = json.loads(response_content)
+                result["response"] = parsed_response
+            except json.JSONDecodeError:
+                result["error"] = f"Invalid JSON response: {response_content}"
+
+    except Exception as e:
+        logger.error(f"LoRA inference error: {e}")
+        result["error"] = f"LoRA inference error: {str(e)}"
+        result["response"] = ""
+
+    return result
+
+
 def get_llamacpp_response(
     prompt: str = None,
     model: str = None,
@@ -730,7 +872,7 @@ def get_litellm_response(
             auto_process_tool_calls=auto_process_tool_calls, 
             **kwargs
         )
-    elif provider=='transformers':
+    elif provider == 'transformers':
         return get_transformers_response(
             prompt,
             model,
@@ -745,8 +887,24 @@ def get_litellm_response(
             attachments=attachments,
             auto_process_tool_calls=auto_process_tool_calls,
             **kwargs
-
         )
+    elif provider == 'lora':
+        print(f"🔧 LoRA provider detected, calling get_lora_response with model: {model}")
+        result = get_lora_response(
+            prompt=prompt,
+            model=model,
+            tools=tools,
+            tool_map=tool_map,
+            format=format,
+            messages=messages,
+            stream=stream,
+            auto_process_tool_calls=auto_process_tool_calls,
+            **kwargs
+        )
+        print(f"🔧 LoRA response: {result.get('response', 'NO RESPONSE')[:200] if result.get('response') else 'EMPTY'}")
+        if result.get('error'):
+            print(f"🔧 LoRA error: {result.get('error')}")
+        return result
     elif provider == 'llamacpp':
         return get_llamacpp_response(
             prompt,

{npcpy-1.3.16 → npcpy-1.3.18}/npcpy/memory/command_history.py

@@ -611,7 +611,9 @@ class CommandHistory:
             Column('reasoning_content', Text),  # For thinking tokens / chain of thought
             Column('tool_calls', Text),  # JSON array of tool calls made by assistant
             Column('tool_results', Text),  # JSON array of tool call results
-            Column('parent_message_id', String(50))  # Links assistant response to parent user message for broadcast grouping
+            Column('parent_message_id', String(50)),  # Links assistant response to parent user message for broadcast grouping
+            Column('device_id', String(255)),  # UUID of the device that created this message
+            Column('device_name', String(255))  # Human-readable device name
         )
         
         Table('message_attachments', metadata,
@@ -867,6 +869,8 @@ class CommandHistory:
         tool_calls=None,
         tool_results=None,
         parent_message_id=None,
+        device_id=None,
+        device_name=None,
     ):
         if isinstance(content, (dict, list)):
             content = json.dumps(content, cls=CustomJSONEncoder)
@@ -882,14 +886,15 @@ class CommandHistory:
 
         stmt = """
             INSERT INTO conversation_history
-            (message_id, timestamp, role, content, conversation_id, directory_path, model, provider, npc, team, reasoning_content, tool_calls, tool_results, parent_message_id)
-            VALUES (:message_id, :timestamp, :role, :content, :conversation_id, :directory_path, :model, :provider, :npc, :team, :reasoning_content, :tool_calls, :tool_results, :parent_message_id)
+            (message_id, timestamp, role, content, conversation_id, directory_path, model, provider, npc, team, reasoning_content, tool_calls, tool_results, parent_message_id, device_id, device_name)
+            VALUES (:message_id, :timestamp, :role, :content, :conversation_id, :directory_path, :model, :provider, :npc, :team, :reasoning_content, :tool_calls, :tool_results, :parent_message_id, :device_id, :device_name)
         """
         params = {
             "message_id": message_id, "timestamp": timestamp, "role": role, "content": content,
             "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, "parent_message_id": parent_message_id
+            "tool_calls": tool_calls, "tool_results": tool_results, "parent_message_id": parent_message_id,
+            "device_id": device_id, "device_name": device_name
         }
         with self.engine.begin() as conn:
             conn.execute(text(stmt), params)
@@ -1461,6 +1466,8 @@ def save_conversation_message(
     tool_results: List[Dict] = None,
     parent_message_id: str = None,
     skip_if_exists: bool = True,
+    device_id: str = None,
+    device_name: str = None,
     ):
     """
     Saves a conversation message linked to a conversation ID with optional attachments.
@@ -1495,7 +1502,9 @@ def save_conversation_message(
         reasoning_content=reasoning_content,
         tool_calls=tool_calls,
         tool_results=tool_results,
-        parent_message_id=parent_message_id)
+        parent_message_id=parent_message_id,
+        device_id=device_id,
+        device_name=device_name)
 def retrieve_last_conversation(
     command_history: CommandHistory, conversation_id: str
     ) -> str:

{npcpy-1.3.16 → npcpy-1.3.18}/npcpy/ml_funcs.py

@@ -16,7 +16,6 @@ Same interface pattern as llm_funcs:
 from __future__ import annotations
 import copy
 import itertools
-import pickle
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
@@ -708,21 +707,67 @@ def cross_validate(
 
 # ==================== Utility Functions ====================
 
-def serialize_model(model: Any, path: str = None) -> bytes:
-    """Serialize model to bytes or file"""
-    data = pickle.dumps(model)
-    if path:
-        with open(path, 'wb') as f:
-            f.write(data)
-    return data
-
-
-def deserialize_model(data: Union[bytes, str]) -> Any:
-    """Deserialize model from bytes or file path"""
-    if isinstance(data, str):
-        with open(data, 'rb') as f:
-            data = f.read()
-    return pickle.loads(data)
+def serialize_model(model: Any, path: str, format: str = "joblib") -> None:
+    """
+    Serialize model to file using safe formats (no pickle).
+
+    Args:
+        model: The model to serialize
+        path: File path to write to (required)
+        format: Serialization format - "joblib" (default) or "safetensors"
+
+    Raises:
+        ImportError: If required library is not installed
+        ValueError: If format is not supported for the model type
+    """
+    if format == "safetensors":
+        from safetensors.torch import save_file
+        if hasattr(model, 'state_dict'):
+            save_file(model.state_dict(), path)
+        else:
+            raise ValueError("safetensors format requires model with state_dict (PyTorch)")
+    elif format == "joblib":
+        import joblib
+        joblib.dump(model, path)
+    else:
+        raise ValueError(f"Unsupported format: {format}. Use 'joblib' or 'safetensors'.")
+
+
+def deserialize_model(path: str, format: str = "auto") -> Any:
+    """
+    Deserialize model from file using safe formats (no pickle).
+
+    Args:
+        path: File path to load from
+        format: "auto" (detect from extension), "joblib", or "safetensors"
+
+    Returns:
+        The deserialized model
+
+    Raises:
+        ImportError: If required library is not installed
+        ValueError: If format cannot be determined
+    """
+    # Auto-detect format from extension
+    if format == "auto":
+        if path.endswith('.safetensors'):
+            format = "safetensors"
+        elif path.endswith('.joblib'):
+            format = "joblib"
+        else:
+            raise ValueError(
+                f"Cannot auto-detect format for {path}. "
+                "Use .joblib or .safetensors extension, or specify format explicitly."
+            )
+
+    if format == "safetensors":
+        from safetensors.torch import load_file
+        return load_file(path)
+    elif format == "joblib":
+        import joblib
+        return joblib.load(path)
+    else:
+        raise ValueError(f"Unsupported format: {format}. Use 'joblib' or 'safetensors'.")
 
 
 def get_model_params(model: Any) -> Dict[str, Any]:

{npcpy-1.3.16 → npcpy-1.3.18}/npcpy/npc_array.py

@@ -20,7 +20,6 @@ Example:
 from __future__ import annotations
 import copy
 import itertools
-import pickle
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
 from typing import (
@@ -47,6 +46,7 @@ class OpType(Enum):
     REDUCE = "reduce"
     CHAIN = "chain"
     EVOLVE = "evolve"
+    JINX = "jinx"  # Execute a Jinx workflow across models
 
 
 @dataclass
@@ -328,6 +328,61 @@ class NPCArray:
 
         return cls(specs)
 
+    @classmethod
+    def from_matrix(
+        cls,
+        matrix: List[Dict[str, Any]]
+    ) -> 'NPCArray':
+        """
+        Create NPCArray from a matrix of model configurations.
+
+        This is particularly useful for defining model arrays in Jinx templates
+        where you want explicit control over each model configuration.
+
+        Args:
+            matrix: List of model configuration dicts. Each dict should have:
+                - 'model': model name/reference (required)
+                - 'provider': provider name (optional)
+                - 'type': model type - 'llm', 'npc', 'sklearn', 'torch' (default: 'llm')
+                - Any additional config parameters
+
+        Example:
+            >>> # In a Jinx template, define a matrix of models:
+            >>> matrix = [
+            ...     {'model': 'gpt-4', 'provider': 'openai', 'temperature': 0.7},
+            ...     {'model': 'claude-3-opus', 'provider': 'anthropic', 'temperature': 0.5},
+            ...     {'model': 'llama3.2', 'provider': 'ollama', 'temperature': 0.8},
+            ... ]
+            >>> arr = NPCArray.from_matrix(matrix)
+
+            >>> # Mixed model types:
+            >>> matrix = [
+            ...     {'model': 'gpt-4', 'type': 'llm', 'provider': 'openai'},
+            ...     {'model': my_npc, 'type': 'npc'},
+            ...     {'model': sklearn_model, 'type': 'sklearn'},
+            ... ]
+        """
+        specs = []
+        for config in matrix:
+            model_type = config.get('type', 'llm')
+            model_ref = config.get('model')
+            provider = config.get('provider')
+
+            # Extract config params (everything except type, model, provider)
+            extra_config = {
+                k: v for k, v in config.items()
+                if k not in ('type', 'model', 'provider')
+            }
+
+            specs.append(ModelSpec(
+                model_type=model_type,
+                model_ref=model_ref,
+                provider=provider,
+                config=extra_config
+            ))
+
+        return cls(specs)
+
     # ==================== Properties ====================
 
     @property
@@ -490,6 +545,43 @@ class NPCArray:
 
         return NPCArray(self._specs, new_node)
 
+    def jinx(
+        self,
+        jinx_name: str,
+        inputs: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> 'LazyResult':
+        """
+        Execute a Jinx workflow across all models in the array.
+
+        Each model in the array will be used as the 'npc' context for the jinx,
+        allowing you to run the same workflow template with different models.
+
+        Args:
+            jinx_name: Name of the jinx workflow to execute (e.g., 'analyze', 'summarize')
+            inputs: Input values for the jinx template variables
+            **kwargs: Additional execution parameters
+
+        Returns:
+            LazyResult with workflow outputs from each model
+
+        Example:
+            >>> models = NPCArray.from_llms(['gpt-4', 'claude-3'])
+            >>> results = models.jinx('analyze', inputs={'topic': 'AI safety'}).collect()
+        """
+        new_node = GraphNode(
+            op_type=OpType.JINX,
+            params={
+                "jinx_name": jinx_name,
+                "inputs": inputs or {},
+                **kwargs
+            },
+            parents=[self._graph],
+            shape=(len(self._specs),)
+        )
+
+        return LazyResult(self._specs, new_node)
+
 
 class LazyResult:
     """
@@ -792,6 +884,7 @@ class GraphExecutor:
             OpType.REDUCE: self._exec_reduce,
             OpType.CHAIN: self._exec_chain,
             OpType.EVOLVE: self._exec_evolve,
+            OpType.JINX: self._exec_jinx,
         }
 
         handler = handlers.get(node.op_type)
@@ -1136,6 +1229,61 @@ class GraphExecutor:
             metadata={"operation": "evolve", "generation": 1}
         )
 
+    def _exec_jinx(self, node, specs, prompts, parents) -> ResponseTensor:
+        """Execute a Jinx workflow across models"""
+        from npcpy.npc_compiler import NPC, Jinx
+
+        jinx_name = node.params.get("jinx_name")
+        inputs = node.params.get("inputs", {})
+        extra_kwargs = {k: v for k, v in node.params.items()
+                       if k not in ("jinx_name", "inputs")}
+
+        results = []
+
+        def run_jinx_single(spec: ModelSpec) -> str:
+            """Run jinx for a single model spec"""
+            try:
+                if spec.model_type == "npc":
+                    # Use the NPC directly
+                    npc = spec.model_ref
+                else:
+                    # Create a temporary NPC with the model
+                    npc = NPC(
+                        name=f"array_npc_{spec.model_ref}",
+                        model=spec.model_ref,
+                        provider=spec.provider
+                    )
+
+                # Execute the jinx
+                result = npc.execute_jinx(
+                    jinx_name=jinx_name,
+                    input_values=inputs,
+                    **extra_kwargs
+                )
+                return result.get("output", str(result))
+            except Exception as e:
+                return f"Error: {e}"
+
+        if self.parallel and len(specs) > 1:
+            with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+                futures = {executor.submit(run_jinx_single, spec): i
+                          for i, spec in enumerate(specs)}
+                results = [None] * len(specs)
+                for future in as_completed(futures):
+                    idx = futures[future]
+                    try:
+                        results[idx] = future.result()
+                    except Exception as e:
+                        results[idx] = f"Error: {e}"
+        else:
+            results = [run_jinx_single(spec) for spec in specs]
+
+        return ResponseTensor(
+            data=np.array(results, dtype=object),
+            model_specs=specs,
+            metadata={"operation": "jinx", "jinx_name": jinx_name, **inputs}
+        )
+
 
 def _compute_response_variance(responses: List[str]) -> float:
     """Compute semantic variance across responses"""

{npcpy-1.3.16 → npcpy-1.3.18}/npcpy/npc_compiler.py

@@ -52,6 +52,7 @@ import fnmatch
 import subprocess
 from typing import Any, Dict, List, Optional, Union, Callable, Tuple
 from jinja2 import Environment, FileSystemLoader, Template, Undefined, DictLoader
+from jinja2.sandbox import SandboxedEnvironment
 from sqlalchemy import create_engine, text
 import npcpy as npy 
 from npcpy.tools import auto_tools
@@ -231,7 +232,8 @@ def load_yaml_file(file_path):
 
         # First pass: render Jinja2 templates to produce valid YAML
         # This allows {% if %} and other control structures to work
-        jinja_env = Environment(undefined=SilentUndefined)
+        # Use SandboxedEnvironment to prevent template injection attacks
+        jinja_env = SandboxedEnvironment(undefined=SilentUndefined)
         # Configure tojson filter to handle SilentUndefined
         jinja_env.policies['json.dumps_function'] = _json_dumps_with_undefined
         template = jinja_env.from_string(content)
@@ -694,7 +696,8 @@ class Jinx:
                 jinja_env: Optional[Environment] = None):
         
         if jinja_env is None:
-            jinja_env = Environment(
+            # Use SandboxedEnvironment to prevent template injection attacks
+            jinja_env = SandboxedEnvironment(
                 loader=DictLoader({}),
                 undefined=SilentUndefined,
             )
@@ -771,21 +774,24 @@ class Jinx:
         
         self._log_debug(f"DEBUG: Executing step '{step_name}' with rendered code: {rendered_code}")
 
+        # Import NPCArray for array operations in jinx
+        from npcpy.npc_array import NPCArray, infer_matrix, ensemble_vote
+
         exec_globals = {
             "__builtins__": __builtins__,
             "npc": active_npc,
             "context": context, # Pass context by reference
-            "math": math, 
-            "random": random, 
+            "math": math,
+            "random": random,
             "datetime": datetime,
             "Image": Image,
             "pd": pd,
             "plt": plt,
-            "sys": sys, 
+            "sys": sys,
             "subprocess": subprocess,
             "np": np,
             "os": os,
-            're': re, 
+            're': re,
             "json": json,
             "Path": pathlib.Path,
             "fnmatch": fnmatch,
@@ -793,6 +799,10 @@ class Jinx:
             "subprocess": subprocess,
             "get_llm_response": npy.llm_funcs.get_llm_response,
             "CommandHistory": CommandHistory,
+            # NPCArray support for compute graph operations in jinx
+            "NPCArray": NPCArray,
+            "infer_matrix": infer_matrix,
+            "ensemble_vote": ensemble_vote,
         }
         
         if extra_globals:
@@ -1261,7 +1271,8 @@ class NPC:
             dirs.append(self.jinxs_directory)
             
         # This jinja_env is for the *second pass* (runtime variable resolution in Jinx.execute)
-        self.jinja_env = Environment(
+        # Use SandboxedEnvironment to prevent template injection attacks
+        self.jinja_env = SandboxedEnvironment(
             loader=FileSystemLoader([
                 os.path.expanduser(d) for d in dirs
             ]),
@@ -1389,13 +1400,13 @@ class NPC:
 
             combined_raw_jinxs_dict = {j.jinx_name: j for j in all_available_raw_jinxs}
 
-            npc_first_pass_jinja_env = Environment(undefined=SilentUndefined)
-            
+            npc_first_pass_jinja_env = SandboxedEnvironment(undefined=SilentUndefined)
+
             jinx_macro_globals = {}
             for raw_jinx in combined_raw_jinxs_dict.values():
                 def create_jinx_callable(jinx_obj_in_closure):
                     def callable_jinx(**kwargs):
-                        temp_jinja_env = Environment(undefined=SilentUndefined)
+                        temp_jinja_env = SandboxedEnvironment(undefined=SilentUndefined)
                         rendered_target_steps = []
                         for target_step in jinx_obj_in_closure._raw_steps:
                             temp_rendered_step = {}
@@ -2506,7 +2517,7 @@ class Team:
         self._raw_jinxs_list: List['Jinx'] = [] # Temporary storage for raw Team-level Jinx objects
         self.jinx_tool_catalog: Dict[str, Dict[str, Any]] = {}  # Jinx-derived tool defs ready for MCP/LLM
         
-        self.jinja_env_for_first_pass = Environment(undefined=SilentUndefined) # Env for macro expansion
+        self.jinja_env_for_first_pass = SandboxedEnvironment(undefined=SilentUndefined) # Env for macro expansion
 
         self.db_conn = db_conn
         self.team_path = os.path.expanduser(team_path) if team_path else None
@@ -2700,7 +2711,7 @@ class Team:
                 def callable_jinx(**kwargs):
                     # This callable will be invoked by the Jinja renderer during the first pass.
                     # It needs to render the target Jinx's *raw* steps with the provided kwargs.
-                    temp_jinja_env = Environment(undefined=SilentUndefined)
+                    temp_jinja_env = SandboxedEnvironment(undefined=SilentUndefined)
                     
                     rendered_target_steps = []
                     for target_step in jinx_obj_in_closure._raw_steps: