npcpy 1.2.27__tar.gz → 1.2.29__tar.gz

{npcpy-1.2.27/npcpy.egg-info → npcpy-1.2.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.27
+Version: 1.2.29
 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
@@ -330,7 +330,7 @@ Users are not required to pass agents to get_llm_response, so you can work with
 ```python
 from npcpy.npc_sysenv import print_and_process_stream
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("When did the united states government begin sending advisors to vietnam?", model='qwen2.5:14b', provider='ollama', stream = True)
+response = get_llm_response("When did the united states government begin sending advisors to vietnam?", model='qwen3:latest', provider='ollama', stream = True)
 
 full_response = print_and_process_stream(response['response'], 'llama3.2', 'ollama')
 ```
@@ -338,7 +338,7 @@ Return structured outputs by specifying `format='json'` or passing a Pydantic sc
 
 ```python
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("What is the sentiment of the american people towards the repeal of Roe v Wade? Return a json object with `sentiment` as the key and a float value from -1 to 1 as the value", model='deepseek-coder', provider='deepseek', format='json')
+response = get_llm_response("What is the sentiment of the american people towards the repeal of Roe v Wade? Return a json object with `sentiment` as the key and a float value from -1 to 1 as the value", model='claude-4-5-haiku-latest', provider='deepseek', format='json')
 
 print(response['response'])
 ```

{npcpy-1.2.27 → npcpy-1.2.29}/README.md

@@ -234,7 +234,7 @@ Users are not required to pass agents to get_llm_response, so you can work with
 ```python
 from npcpy.npc_sysenv import print_and_process_stream
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("When did the united states government begin sending advisors to vietnam?", model='qwen2.5:14b', provider='ollama', stream = True)
+response = get_llm_response("When did the united states government begin sending advisors to vietnam?", model='qwen3:latest', provider='ollama', stream = True)
 
 full_response = print_and_process_stream(response['response'], 'llama3.2', 'ollama')
 ```
@@ -242,7 +242,7 @@ Return structured outputs by specifying `format='json'` or passing a Pydantic sc
 
 ```python
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("What is the sentiment of the american people towards the repeal of Roe v Wade? Return a json object with `sentiment` as the key and a float value from -1 to 1 as the value", model='deepseek-coder', provider='deepseek', format='json')
+response = get_llm_response("What is the sentiment of the american people towards the repeal of Roe v Wade? Return a json object with `sentiment` as the key and a float value from -1 to 1 as the value", model='claude-4-5-haiku-latest', provider='deepseek', format='json')
 
 print(response['response'])
 ```

{npcpy-1.2.27 → npcpy-1.2.29}/npcpy/ft/sft.py

@@ -154,13 +154,17 @@ def run_sft(
         save_steps=config.save_steps,
         weight_decay=config.weight_decay,
     )
-    
+            
+    def formatting_func(example):
+        return example["text"]
+
     trainer = SFTTrainer(
         model=model,
         train_dataset=dataset,
         peft_config=peft_config,
         args=training_args,
-        max_seq_length=config.max_length
+        processing_class=tokenizer,
+        formatting_func=formatting_func
     )
     
     print(f"Training on {len(dataset)} examples")
@@ -190,8 +194,6 @@ def load_sft_model(model_path: str):
         tokenizer.pad_token = tokenizer.eos_token
     
     return model, tokenizer
-
-
 def predict_sft(
     model,
     tokenizer,
@@ -202,8 +204,13 @@ def predict_sft(
 
     device = next(model.parameters()).device
     
+    formatted_prompt = (
+        f"<start_of_turn>user\n{prompt}<end_of_turn>\n"
+        f"<start_of_turn>model\n"
+    )
+    
     inputs = tokenizer(
-        prompt,
+        formatted_prompt,
         return_tensors="pt",
         truncation=True,
         max_length=512
@@ -222,9 +229,20 @@ def predict_sft(
             pad_token_id=tokenizer.eos_token_id
         )
     
-    response = tokenizer.decode(
+    full_response = tokenizer.decode(
         outputs[0],
-        skip_special_tokens=True
+        skip_special_tokens=False
     )
     
+    if "<start_of_turn>model\n" in full_response:
+        response = full_response.split(
+            "<start_of_turn>model\n"
+        )[-1]
+        response = response.split("<end_of_turn>")[0].strip()
+    else:
+        response = tokenizer.decode(
+            outputs[0][len(input_ids[0]):],
+            skip_special_tokens=True
+        )
+    
     return response

{npcpy-1.2.27 → npcpy-1.2.29}/npcpy/gen/image_gen.py

@@ -86,6 +86,16 @@ def generate_image_diffusers(
         else:
             raise e
 
+import os
+import base64
+import io
+from typing import Union, List, Optional
+
+import PIL
+from PIL import Image
+
+import requests
+from urllib.request import urlopen
 
 def openai_image_gen(
     prompt: str,
@@ -97,36 +107,47 @@ def openai_image_gen(
 ):
     """Generate or edit an image using the OpenAI API."""
     from openai import OpenAI
-    
+
     client = OpenAI()
-    
+
     if height is None:
         height = 1024
     if width is None:
-        width = 1024  
-    
-    size_str = f"{width}x{height}" 
+        width = 1024
+
+    size_str = f"{width}x{height}"
 
     if attachments is not None:
         processed_images = []
+        files_to_close = []
         for attachment in attachments:
             if isinstance(attachment, str):
-                processed_images.append(open(attachment, "rb"))
+                file_handle = open(attachment, "rb")
+                processed_images.append(file_handle)
+                files_to_close.append(file_handle)
             elif isinstance(attachment, bytes):
-                processed_images.append(io.BytesIO(attachment))
+                img_byte_arr = io.BytesIO(attachment)
+                img_byte_arr.name = 'image.png'  # FIX: Add filename hint
+                processed_images.append(img_byte_arr)
             elif isinstance(attachment, Image.Image):
                 img_byte_arr = io.BytesIO()
                 attachment.save(img_byte_arr, format='PNG')
                 img_byte_arr.seek(0)
+                img_byte_arr.name = 'image.png'  # FIX: Add filename hint
                 processed_images.append(img_byte_arr)
         
-        result = client.images.edit(
-            model=model,
-            image=processed_images[0],
-            prompt=prompt,
-            n=n_images,
-            size=size_str,
-        )
+        try:
+            result = client.images.edit(
+                model=model,
+                image=processed_images[0],
+                prompt=prompt,
+                n=n_images,
+                size=size_str,
+            )
+        finally:
+            # This ensures any files we opened are properly closed
+            for f in files_to_close:
+                f.close()
     else:
         result = client.images.generate(
             model=model,
@@ -134,7 +155,7 @@ def openai_image_gen(
             n=n_images,
             size=size_str,
         )
-    
+
     collected_images = []
     for item_data in result.data:
         if model == 'gpt-image-1':
@@ -153,6 +174,7 @@ def openai_image_gen(
     return collected_images
 
 
+
 def gemini_image_gen(
     prompt: str,
     model: str = "gemini-2.5-flash",

{npcpy-1.2.27 → npcpy-1.2.29}/npcpy/npc_compiler.py

@@ -264,7 +264,6 @@ class Jinx:
         self.inputs = jinx_data.get("inputs", [])
         self.description = jinx_data.get("description", "")
         self.steps = self._parse_steps(jinx_data.get("steps", []))
-            
     def _parse_steps(self, steps):
         """Parse steps from jinx definition"""
         parsed_steps = []
@@ -275,11 +274,12 @@ class Jinx:
                     "engine": step.get("engine", "natural"),
                     "code": step.get("code", "")
                 }
+                if "mode" in step:
+                    parsed_step["mode"] = step["mode"]
                 parsed_steps.append(parsed_step)
             else:
                 raise ValueError(f"Invalid step format: {step}")
         return parsed_steps
-        
     def execute(self,
                 input_values, 
                 jinxs_dict, 
@@ -317,24 +317,19 @@ class Jinx:
             )            
 
         return context
-            
     def _execute_step(self,
-                      step, 
-                      context, 
-                      jinja_env,
-                      npc=None,
-                      messages=None, 
-):
-        """Execute a single step of the jinx"""
+                  step, 
+                  context, 
+                  jinja_env,
+                  npc=None,
+                  messages=None, 
+    ):
         engine = step.get("engine", "natural")
         code = step.get("code", "")
         step_name = step.get("name", "unnamed_step")
-
-        
-        
+        mode = step.get("mode", "chat")
 
         try:
-            
             template = jinja_env.from_string(code)
             rendered_code = template.render(**context)
             
@@ -346,16 +341,23 @@ class Jinx:
             rendered_code = code
             rendered_engine = engine
                 
-        
         if rendered_engine == "natural":
             if rendered_code.strip():
-                
-                response = npc.get_llm_response(
-                    rendered_code,
-                    context=context,
-                    messages=messages,
-                )
-               
+                if mode == "agent":
+                    response = npc.get_llm_response(
+                        rendered_code,
+                        context=context,
+                        messages=messages,
+                        auto_process_tool_calls=True,
+                        use_core_tools=True
+                    )
+                else:
+                    response = npc.get_llm_response(
+                        rendered_code,
+                        context=context,
+                        messages=messages,
+                    )
+            
                 response_text = response.get("response", "")
                 context['output'] = response_text
                 context["llm_response"] = response_text
@@ -363,7 +365,6 @@ class Jinx:
                 context[step_name] = response_text
                 context['messages'] = response.get('messages')
         elif rendered_engine == "python":
-            
             exec_globals = {
                 "__builtins__": __builtins__,
                 "npc": npc,
@@ -379,48 +380,44 @@ class Jinx:
                 "pathlib": pathlib,
                 "subprocess": subprocess,
                 "get_llm_response": npy.llm_funcs.get_llm_response, 
-                
                 }
             
-            
-            
             exec_locals = {}
             exec(rendered_code, exec_globals, exec_locals)
             
-            
             context.update(exec_locals)
             
-            
             if "output" in exec_locals:
                 outp = exec_locals["output"]
                 context["output"] = outp
                 context[step_name] = outp
                 messages.append({'role':'assistant', 
-                                 'content': f'Jinx executed with following output: {outp}'})
+                                'content': f'Jinx executed with following output: {outp}'})
                 context['messages'] = messages
                 
         else:
-            
             context[step_name] = {"error": f"Unsupported engine: {rendered_engine}"}
             
         return context
-        
     def to_dict(self):
         """Convert to dictionary representation"""
+        steps_list = []
+        for i, step in enumerate(self.steps):
+            step_dict = {
+                "name": step.get("name", f"step_{i}"),
+                "engine": step.get("engine"),
+                "code": step.get("code")
+            }
+            if "mode" in step:
+                step_dict["mode"] = step["mode"]
+            steps_list.append(step_dict)
+        
         return {
             "jinx_name": self.jinx_name,
             "description": self.description,
             "inputs": self.inputs,
-            "steps": [
-                {
-                    "name": step.get("name", f"step_{i}"),
-                    "engine": step.get("engine"),
-                    "code": step.get("code")
-                }
-                for i, step in enumerate(self.steps)
-            ]
+            "steps": steps_list
         }
-        
     def save(self, directory):
         """Save jinx to file"""
         jinx_path = os.path.join(directory, f"{self.jinx_name}.jinx")
@@ -477,23 +474,23 @@ output = {mcp_tool.__module__}.{name}(
         except: 
             pass    
 
-
 def load_jinxs_from_directory(directory):
-    """Load all jinxs from a directory"""
+    """Load all jinxs from a directory recursively"""
     jinxs = []
     directory = os.path.expanduser(directory)
     
     if not os.path.exists(directory):
         return jinxs
-        
-    for filename in os.listdir(directory):
-        if filename.endswith(".jinx"):
-            try:
-                jinx_path = os.path.join(directory, filename)
-                jinx = Jinx(jinx_path=jinx_path)
-                jinxs.append(jinx)
-            except Exception as e:
-                print(f"Error loading jinx {filename}: {e}")
+    
+    for root, dirs, files in os.walk(directory):
+        for filename in files:
+            if filename.endswith(".jinx"):
+                try:
+                    jinx_path = os.path.join(root, filename)
+                    jinx = Jinx(jinx_path=jinx_path)
+                    jinxs.append(jinx)
+                except Exception as e:
+                    print(f"Error loading jinx {filename}: {e}")
                 
     return jinxs
 
@@ -693,7 +690,8 @@ class NPC:
                 self.jinxs_directory = os.path.expanduser('~/.npcsh/npc_team/jinxs/')
             else: 
                 self.jinxs_directory = None
-            self.npc_directory = None 
+            self.npc_directory = None
+
         self.team = team
         if tools is not None:
             tools_schema, tool_map = auto_tools(tools)
@@ -1057,18 +1055,16 @@ class NPC:
         """Load and process NPC-specific jinxs"""
         npc_jinxs = []
         
-        if self.jinxs_directory is None:
-            self.jinxs_dict = {}
-            return None
-        
         if jinxs == "*":
-            npc_jinxs.extend(load_jinxs_from_directory(self.jinxs_directory))
-            
-            if os.path.exists(self.jinxs_directory):
-                npc_jinxs.extend(load_jinxs_from_directory(self.jinxs_directory))                
+            if self.team and hasattr(self.team, 'jinxs_dict'):
+                for jinx in self.team.jinxs_dict.values():
+                    npc_jinxs.append(jinx)
+            elif self.use_global_jinxs or (hasattr(self, 'jinxs_directory') and self.jinxs_directory):
+                jinxs_dir = self.jinxs_directory or os.path.expanduser('~/.npcsh/npc_team/jinxs/')
+                if os.path.exists(jinxs_dir):
+                    npc_jinxs.extend(load_jinxs_from_directory(jinxs_dir))
             
             self.jinxs_dict = {jinx.jinx_name: jinx for jinx in npc_jinxs}
-            
             return npc_jinxs
 
         for jinx in jinxs:
@@ -1076,13 +1072,13 @@ class NPC:
                 npc_jinxs.append(jinx)
             elif isinstance(jinx, dict):
                 npc_jinxs.append(Jinx(jinx_data=jinx))
-            
+            elif isinstance(jinx, str):
                 jinx_path = None
                 jinx_name = jinx
                 if not jinx_name.endswith(".jinx"):
                     jinx_name += ".jinx"
                 
-                if hasattr(self, 'jinxs_directory') and os.path.exists(self.jinxs_directory):
+                if hasattr(self, 'jinxs_directory') and self.jinxs_directory and os.path.exists(self.jinxs_directory):
                     candidate_path = os.path.join(self.jinxs_directory, jinx_name)
                     if os.path.exists(candidate_path):
                         jinx_path = candidate_path
@@ -1092,8 +1088,8 @@ class NPC:
                     npc_jinxs.append(jinx_obj)
         
         self.jinxs_dict = {jinx.jinx_name: jinx for jinx in npc_jinxs}
+        print(npc_jinxs)
         return npc_jinxs
-            
     def get_llm_response(self, 
                         request,
                         jinxs=None,

{npcpy-1.2.27 → npcpy-1.2.29}/npcpy/serve.py

@@ -502,56 +502,73 @@ def get_global_settings():
     except Exception as e:
         print(f"Error in get_global_settings: {str(e)}")
         return jsonify({"error": str(e)}), 500
-
+def _get_jinx_files_recursively(directory):
+    """Helper to recursively find all .jinx file paths."""
+    jinx_paths = []
+    if os.path.exists(directory):
+        for root, _, files in os.walk(directory):
+            for filename in files:
+                if filename.endswith(".jinx"):
+                    jinx_paths.append(os.path.join(root, filename))
+    return jinx_paths
 
 @app.route("/api/jinxs/available", methods=["GET"])
 def get_available_jinxs():
-    """
-    Get all available jinxs for a given NPC and/or team.
-    Returns a list of jinx names that can be executed.
-    """
     try:
         current_path = request.args.get('currentPath')
-        npc_name = request.args.get('npc')
-        
-        jinx_names = set()  # Use set to avoid duplicates
-        
-        # Get team jinxs from project directory
+        jinx_names = set()
+
         if current_path:
             team_jinxs_dir = os.path.join(current_path, 'npc_team', 'jinxs')
-            if os.path.exists(team_jinxs_dir):
-                for file in os.listdir(team_jinxs_dir):
-                    if file.endswith('.jinx'):
-                        jinx_names.add(file[:-5])  # Remove .jinx extension
-        
-        # Get global jinxs
+            jinx_paths = _get_jinx_files_recursively(team_jinxs_dir)
+            for path in jinx_paths:
+                jinx_names.add(os.path.basename(path)[:-5])
+
         global_jinxs_dir = os.path.expanduser('~/.npcsh/npc_team/jinxs')
-        if os.path.exists(global_jinxs_dir):
-            for file in os.listdir(global_jinxs_dir):
-                if file.endswith('.jinx'):
-                    jinx_names.add(file[:-5])
-        
-        # Get NPC-specific jinxs if NPC is specified
-        if npc_name:
-            # Try to load the NPC and get its jinxs
-            db_conn = get_db_connection()
-            npc_object = load_npc_by_name_and_source(npc_name, 'project', db_conn, current_path)
-            if not npc_object:
-                npc_object = load_npc_by_name_and_source(npc_name, 'global', db_conn)
-            
-            if npc_object and hasattr(npc_object, 'jinxs_dict') and npc_object.jinxs_dict:
-                jinx_names.update(npc_object.jinxs_dict.keys())
-        
-        return jsonify({
-            'jinxs': sorted(list(jinx_names)),
-            'error': None
-        })
-        
+        jinx_paths = _get_jinx_files_recursively(global_jinxs_dir)
+        for path in jinx_paths:
+            jinx_names.add(os.path.basename(path)[:-5])
+
+        return jsonify({'jinxs': sorted(list(jinx_names)), 'error': None})
     except Exception as e:
         print(f"Error getting available jinxs: {str(e)}")
         traceback.print_exc()
         return jsonify({'jinxs': [], 'error': str(e)}), 500
 
+@app.route("/api/jinxs/global", methods=["GET"])
+def get_global_jinxs():
+    jinxs_dir = os.path.join(os.path.expanduser("~"), ".npcsh", "npc_team", "jinxs")
+    jinx_paths = _get_jinx_files_recursively(jinxs_dir)
+    jinxs = []
+    for path in jinx_paths:
+        try:
+            with open(path, "r") as f:
+                jinx_data = yaml.safe_load(f)
+                jinxs.append(jinx_data)
+        except Exception as e:
+            print(f"Error loading global jinx {path}: {e}")
+    return jsonify({"jinxs": jinxs})
+
+@app.route("/api/jinxs/project", methods=["GET"])
+def get_project_jinxs():
+    current_path = request.args.get("currentPath")
+    if not current_path:
+        return jsonify({"jinxs": []})
+
+    if not current_path.endswith("npc_team"):
+        current_path = os.path.join(current_path, "npc_team")
+
+    jinxs_dir = os.path.join(current_path, "jinxs")
+    jinx_paths = _get_jinx_files_recursively(jinxs_dir)
+    jinxs = []
+    for path in jinx_paths:
+        try:
+            with open(path, "r") as f:
+                jinx_data = yaml.safe_load(f)
+                jinxs.append(jinx_data)
+        except Exception as e:
+            print(f"Error loading project jinx {path}: {e}")
+    return jsonify({"jinxs": jinxs})
 
 @app.route("/api/jinx/execute", methods=["POST"])
 def execute_jinx():
@@ -568,8 +585,11 @@ def execute_jinx():
     with cancellation_lock:
         cancellation_flags[stream_id] = False
     
+    print(data)
+
     jinx_name = data.get("jinxName")
     jinx_args = data.get("jinxArgs", [])
+    print(jinx_args)
     conversation_id = data.get("conversationId")
     model = data.get("model")
     provider = data.get("provider")
@@ -616,8 +636,45 @@ def execute_jinx():
     
     # Extract inputs from args
     from npcpy.npc_compiler import extract_jinx_inputs
-    input_values = extract_jinx_inputs(jinx_args, jinx)
-    
+
+    # --- Start of Fix ---
+    # Re-assemble arguments that were incorrectly split by spaces.
+    fixed_args = []
+    i = 0
+    while i < len(jinx_args):
+        arg = jinx_args[i]
+        if arg.startswith('-'):
+            fixed_args.append(arg)
+            value_parts = []
+            i += 1
+            # Collect all subsequent parts until the next flag or the end of the list.
+            while i < len(jinx_args) and not jinx_args[i].startswith('-'):
+                value_parts.append(jinx_args[i])
+                i += 1
+            
+            if value_parts:
+                # Join the parts back into a single string.
+                full_value = " ".join(value_parts)
+                # Clean up the extraneous quotes that the initial bad split left behind.
+                if full_value.startswith("'") and full_value.endswith("'"):
+                    full_value = full_value[1:-1]
+                elif full_value.startswith('"') and full_value.endswith('"'):
+                    full_value = full_value[1:-1]
+                fixed_args.append(full_value)
+            # The 'i' counter is already advanced, so the loop continues from the next flag.
+        else:
+            # This handles positional arguments, just in case.
+            fixed_args.append(arg)
+            i += 1
+    # --- End of Fix ---
+
+    # Now, use the corrected arguments to extract inputs.
+    input_values = extract_jinx_inputs(fixed_args, jinx)
+
+
+
+
+    print('executing jinx with input_values ,', input_values)
     # Get conversation history
     command_history = CommandHistory(app.config.get('DB_PATH'))
     messages = fetch_messages_for_conversation(conversation_id)
@@ -966,49 +1023,6 @@ def get_npc_team_global():
         return jsonify({"npcs": [], "error": str(e)})
 
 
-@app.route("/api/jinxs/global", methods=["GET"])
-def get_global_jinxs():
-    
-    user_home = os.path.expanduser("~")
-    jinxs_dir = os.path.join(user_home, ".npcsh", "npc_team", "jinxs")
-    jinxs = []
-    if os.path.exists(jinxs_dir):
-        for file in os.listdir(jinxs_dir):
-            if file.endswith(".jinx"):
-                with open(os.path.join(jinxs_dir, file), "r") as f:
-                    jinx_data = yaml.safe_load(f)
-                    jinxs.append(jinx_data)
-            print("file", file)
-
-    return jsonify({"jinxs": jinxs})
-
-
-
-
-
-
-@app.route("/api/jinxs/project", methods=["GET"])
-def get_project_jinxs():
-    current_path = request.args.get(
-        "currentPath"
-    )  
-    if not current_path:
-        return jsonify({"jinxs": []})
-
-    if not current_path.endswith("npc_team"):
-        current_path = os.path.join(current_path, "npc_team")
-
-    jinxs_dir = os.path.join(current_path, "jinxs")
-    jinxs = []
-    if os.path.exists(jinxs_dir):
-        for file in os.listdir(jinxs_dir):
-            if file.endswith(".jinx"):
-                with open(os.path.join(jinxs_dir, file), "r") as f:
-                    jinx_data = yaml.safe_load(f)
-                    jinxs.append(jinx_data)
-    return jsonify({"jinxs": jinxs})
-
-
 @app.route("/api/jinxs/save", methods=["POST"])
 def save_jinx():
     try:

{npcpy-1.2.27 → npcpy-1.2.29/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.27
+Version: 1.2.29
 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
@@ -330,7 +330,7 @@ Users are not required to pass agents to get_llm_response, so you can work with
 ```python
 from npcpy.npc_sysenv import print_and_process_stream
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("When did the united states government begin sending advisors to vietnam?", model='qwen2.5:14b', provider='ollama', stream = True)
+response = get_llm_response("When did the united states government begin sending advisors to vietnam?", model='qwen3:latest', provider='ollama', stream = True)
 
 full_response = print_and_process_stream(response['response'], 'llama3.2', 'ollama')
 ```
@@ -338,7 +338,7 @@ Return structured outputs by specifying `format='json'` or passing a Pydantic sc
 
 ```python
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("What is the sentiment of the american people towards the repeal of Roe v Wade? Return a json object with `sentiment` as the key and a float value from -1 to 1 as the value", model='deepseek-coder', provider='deepseek', format='json')
+response = get_llm_response("What is the sentiment of the american people towards the repeal of Roe v Wade? Return a json object with `sentiment` as the key and a float value from -1 to 1 as the value", model='claude-4-5-haiku-latest', provider='deepseek', format='json')
 
 print(response['response'])
 ```

{npcpy-1.2.27 → npcpy-1.2.29}/setup.py

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