npcpy 1.2.28__tar.gz → 1.2.30__tar.gz

{npcpy-1.2.28/npcpy.egg-info → npcpy-1.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.28
+Version: 1.2.30
 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.2.28 → npcpy-1.2.30}/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.28 → npcpy-1.2.30}/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.28 → npcpy-1.2.30}/npcpy/llm_funcs.py

@@ -378,7 +378,6 @@ def execute_llm_command(
         "messages": messages,
         "output": "Max attempts reached. Unable to execute the command successfully.",
     }
-
 def handle_jinx_call(
     command: str,
     jinx_name: str,
@@ -391,6 +390,7 @@ def handle_jinx_call(
     n_attempts=3,
     attempt=0,
     context=None,
+    extra_globals=None,  # ADD THIS
     **kwargs
 ) -> Union[str, Dict[str, Any]]:
     """This function handles a jinx call.
@@ -568,6 +568,8 @@ def handle_jinx_call(
                 jinja_env,
                 npc=npc,
                 messages=messages,
+                extra_globals=extra_globals  # ADD THIS
+                
             )
         except Exception as e:
             print(f"An error occurred while executing the jinx: {e}")
@@ -664,10 +666,10 @@ def jinx_handler(command, extracted_data, **kwargs):
         api_key=kwargs.get('api_key'),
         messages=kwargs.get('messages'),
         npc=kwargs.get('npc'),
-        team = kwargs.get('team'),
+        team=kwargs.get('team'),
         stream=kwargs.get('stream'),
-
-        context=kwargs.get('context')
+        context=kwargs.get('context'),
+        extra_globals=kwargs.get('extra_globals')  # ADD THIS
     )
 
 def answer_handler(command, extracted_data, **kwargs):
@@ -714,6 +716,7 @@ def check_llm_command(
     stream=False,
     context=None,
     actions: Dict[str, Dict] = None,
+    extra_globals=None,
 ):
     """This function checks an LLM command and returns sequences of steps with parallel actions."""
     if messages is None:
@@ -734,6 +737,7 @@ def check_llm_command(
         stream=stream,
         context=context,
         actions=actions,
+        extra_globals=extra_globals,
 
     )
     return exec
@@ -873,6 +877,7 @@ def plan_multi_step_actions(
    api_key: str = None,
    context: str = None,
    messages: List[Dict[str, str]] = None,
+   
 
 ):
     """
@@ -992,6 +997,7 @@ def execute_multi_step_plan(
         messages=messages,
         team=team, 
         
+        
     )
     
     if not planned_actions:
@@ -1007,7 +1013,8 @@ def execute_multi_step_plan(
                                 stream=stream,
                                 team = team, 
                                 images=images, 
-                                context=context)
+                                context=context
+                                )
         return {"messages": result.get('messages',
                                        messages), 
                 "output": result.get('response')}
@@ -1037,7 +1044,7 @@ def execute_multi_step_plan(
             render_markdown(
                 f"- Executing Action: {action_name} \n- Explanation: {action_data.get('explanation')}\n "
             )
-                
+                            
             result = handler(
                 command=command, 
                 extracted_data=action_data,
@@ -1049,10 +1056,10 @@ def execute_multi_step_plan(
                 npc=npc,
                 team=team,
                 stream=stream, 
-
                 context=context+step_context, 
-                images=images
-                )
+                images=images,
+                extra_globals=kwargs.get('extra_globals')  # ADD THIS
+            )
         except KeyError as e:
           
             return execute_multi_step_plan(
@@ -1068,6 +1075,7 @@ def execute_multi_step_plan(
                                             stream=stream,
                                             context=context,
                                             actions=actions,
+                                            
                                             **kwargs, 
             )
 

{npcpy-1.2.28 → npcpy-1.2.30}/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,66 +274,71 @@ 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, 
-                jinja_env = None,
-                npc = None,
-                messages=None):
-        """Execute the jinx with given inputs"""
+                input_values: Dict[str, Any],
+                jinxs_dict: Dict[str, 'Jinx'],
+                jinja_env: Optional[Environment] = None,
+                npc: Optional[Any] = None,
+                messages: Optional[List[Dict[str, str]]] = None,
+                **kwargs: Any):
+        """
+        Execute the jinx with given inputs.
+        **kwargs can be used to pass 'extra_globals' for the python engine.
+        """
         if jinja_env is None:
-            
-            
             from jinja2 import DictLoader
             jinja_env = Environment(
-                loader=DictLoader({}),  
+                loader=DictLoader({}),
                 undefined=SilentUndefined,
             )
         
-        context = (npc.shared_context.copy() if npc else {})
+        context = (npc.shared_context.copy() if npc and hasattr(npc, 'shared_context') else {})
         context.update(input_values)
         context.update({
             "jinxs": jinxs_dict,
             "llm_response": None,
-            "output": None, 
+            "output": None,
             "messages": messages,
         })
         
-        
+        # This is the key change: Extract 'extra_globals' from kwargs
+        extra_globals = kwargs.get('extra_globals')
+
         for i, step in enumerate(self.steps):
             context = self._execute_step(
-                step, 
+                step,
                 context,
-                jinja_env, 
-                npc=npc, 
-                messages=messages, 
-
-            )            
+                jinja_env,
+                npc=npc,
+                messages=messages,
+                extra_globals=extra_globals # Pass it down to the step executor
+            )
 
         return context
-            
+
     def _execute_step(self,
-                      step, 
-                      context, 
-                      jinja_env,
-                      npc=None,
-                      messages=None, 
-):
-        """Execute a single step of the jinx"""
+                  step: Dict[str, Any],
+                  context: Dict[str, Any],
+                  jinja_env: Environment,
+                  npc: Optional[Any] = None,
+                  messages: Optional[List[Dict[str, str]]] = None,
+                  extra_globals: Optional[Dict[str, Any]] = None):
+        """
+        Execute a single step of the jinx.
+        """
         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,24 +350,32 @@ 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
                 context["results"] = response_text
                 context[step_name] = response_text
                 context['messages'] = response.get('messages')
+        
         elif rendered_engine == "python":
-            
+            # Base globals available to all python jinxes, defined within the library (npcpy)
             exec_globals = {
                 "__builtins__": __builtins__,
                 "npc": npc,
@@ -378,49 +390,57 @@ class Jinx:
                 "fnmatch": fnmatch,
                 "pathlib": pathlib,
                 "subprocess": subprocess,
-                "get_llm_response": npy.llm_funcs.get_llm_response, 
-                
-                }
-            
+                "get_llm_response": npy.llm_funcs.get_llm_response,
+                "CommandHistory": CommandHistory, # This is fine, it's part of npcpy
+            }
             
+            # This is the fix: Update the globals with the dictionary passed in from the application (npcsh)
+            if extra_globals:
+                exec_globals.update(extra_globals)
             
             exec_locals = {}
-            exec(rendered_code, exec_globals, exec_locals)
-            
-            
+            try:
+                exec(rendered_code, exec_globals, exec_locals)
+            except Exception as e:
+                # Provide a clear error message in the output if execution fails
+                error_msg = f"Error executing jinx python code: {type(e).__name__}: {e}"
+                context['output'] = error_msg
+                return context
+
             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}'})
-                context['messages'] = messages
+                if messages is not None:
+                    messages.append({'role':'assistant', 
+                                     '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")
@@ -564,6 +584,9 @@ def get_npc_action_space(npc=None, team=None):
     
     return actions
 def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
+    print(f"DEBUG extract_jinx_inputs called with args: {args}")
+    print(f"DEBUG jinx.inputs: {jinx.inputs}")
+    
     inputs = {}
 
     flag_mapping = {}
@@ -588,7 +611,6 @@ def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
     else:
         used_args = set()
 
-
     for i, arg in enumerate(args):
         if i in used_args:
             continue
@@ -606,21 +628,38 @@ def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
 
     unused_args = [arg for i, arg in enumerate(args) if i not in used_args]
     
-    jinx_input_names = []
+    print(f"DEBUG unused_args: {unused_args}")
+    
+    # Find first required input (no default value)
+    first_required = None
     for input_ in jinx.inputs:
         if isinstance(input_, str):
-            jinx_input_names.append(input_)
-        elif isinstance(input_, dict):
-            jinx_input_names.append(list(input_.keys())[0])
-    if len(jinx_input_names) == 1:
-        inputs[jinx_input_names[0]] = ' '.join(unused_args).strip()
+            first_required = input_
+            break
+    
+    print(f"DEBUG first_required: {first_required}")
+    
+    # Give all unused args to first required input
+    if first_required and unused_args:
+        inputs[first_required] = ' '.join(unused_args).strip()
+        print(f"DEBUG assigned to first_required: {inputs[first_required]}")
     else:
-        for i, arg in enumerate(unused_args):
-            if i < len(jinx_input_names):
-                input_name = jinx_input_names[i]
-                if input_name not in inputs: 
-                    inputs[input_name] = arg
-
+        # Fallback to original behavior
+        jinx_input_names = []
+        for input_ in jinx.inputs:
+            if isinstance(input_, str):
+                jinx_input_names.append(input_)
+            elif isinstance(input_, dict):
+                jinx_input_names.append(list(input_.keys())[0])
+        
+        if len(jinx_input_names) == 1:
+            inputs[jinx_input_names[0]] = ' '.join(unused_args).strip()
+        else:
+            for i, arg in enumerate(unused_args):
+                if i < len(jinx_input_names):
+                    input_name = jinx_input_names[i]
+                    if input_name not in inputs: 
+                        inputs[input_name] = arg
 
     for input_ in jinx.inputs:
         if isinstance(input_, str):
@@ -632,8 +671,8 @@ def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
             if key not in inputs:
                 inputs[key] = default_value
 
+    print(f"DEBUG final inputs: {inputs}")
     return inputs
-
 from npcpy.memory.command_history import load_kg_from_db, save_kg_to_db
 from npcpy.memory.knowledge_graph import kg_initial, kg_evolve_incremental, kg_sleep_process, kg_dream_process
 from npcpy.llm_funcs import get_llm_response, breathe

{npcpy-1.2.28 → npcpy-1.2.30}/npcpy/serve.py

@@ -149,7 +149,7 @@ def load_kg_data(generation=None):
 app = Flask(__name__)
 app.config["REDIS_URL"] = "redis://localhost:6379"
 app.config['DB_PATH'] = ''
-
+app.jinx_conversation_contexts ={}
 
 redis_client = redis.Redis(host="localhost", port=6379, decode_responses=True)
 
@@ -585,19 +585,27 @@ def execute_jinx():
     with cancellation_lock:
         cancellation_flags[stream_id] = False
     
-    print(data)
+    print(f"--- Jinx Execution Request for streamId: {stream_id} ---")
+    print(f"Request Data: {json.dumps(data, indent=2)}")
 
     jinx_name = data.get("jinxName")
     jinx_args = data.get("jinxArgs", [])
-    print(jinx_args)
+    print(f"Jinx Name: {jinx_name}, Jinx Args: {jinx_args}")
     conversation_id = data.get("conversationId")
     model = data.get("model")
     provider = data.get("provider")
+
+    # --- IMPORTANT: Ensure conversation_id is present for context persistence ---
+    if not conversation_id:
+        print("ERROR: conversationId is required for Jinx execution with persistent variables")
+        return jsonify({"error": "conversationId is required for Jinx execution with persistent variables"}), 400
+
     npc_name = data.get("npc")
     npc_source = data.get("npcSource", "global")
     current_path = data.get("currentPath")
     
     if not jinx_name:
+        print("ERROR: jinxName is required")
         return jsonify({"error": "jinxName is required"}), 400
     
     # Load project environment if applicable
@@ -632,12 +640,12 @@ def execute_jinx():
             jinx = Jinx(jinx_path=global_jinx_path)
     
     if not jinx:
+        print(f"ERROR: Jinx '{jinx_name}' not found")
         return jsonify({"error": f"Jinx '{jinx_name}' not found"}), 404
     
     # Extract inputs from args
     from npcpy.npc_compiler import extract_jinx_inputs
 
-    # --- Start of Fix ---
     # Re-assemble arguments that were incorrectly split by spaces.
     fixed_args = []
     i = 0
@@ -666,15 +674,11 @@ def execute_jinx():
             # 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)
+    print(f'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)
@@ -684,20 +688,48 @@ def execute_jinx():
     if npc_object and hasattr(npc_object, 'jinxs_dict'):
         all_jinxs.update(npc_object.jinxs_dict)
     
+    # --- IMPORTANT: Retrieve or initialize the persistent Jinx context for this conversation ---
+    if conversation_id not in app.jinx_conversation_contexts:
+        app.jinx_conversation_contexts[conversation_id] = {}
+    jinx_local_context = app.jinx_conversation_contexts[conversation_id]
+
+    print(f"--- CONTEXT STATE (conversationId: {conversation_id}) ---")
+    print(f"jinx_local_context BEFORE Jinx execution: {jinx_local_context}")
+
     def event_stream(current_stream_id):
         try:
-            # Execute the jinx
+            # --- IMPORTANT: Pass the persistent context as 'extra_globals' ---
             result = jinx.execute(
                 input_values=input_values,
                 jinxs_dict=all_jinxs,
                 jinja_env=npc_object.jinja_env if npc_object else None,
                 npc=npc_object,
-                messages=messages
+                messages=messages,
+                extra_globals=jinx_local_context # <--- THIS IS WHERE THE PERSISTENT CONTEXT IS PASSED
             )
             
-            # Get output
+            # --- CRITICAL FIX: Capture and update local_vars from the Jinx's result ---
+            # The Jinx.execute method returns its internal 'context' dictionary.
+            # We need to update our persistent 'jinx_local_context' with the new variables
+            # from the Jinx's returned context.
+            if isinstance(result, dict):
+                # We need to be careful not to overwrite core Jinx/NPC context keys
+                # that are not meant for variable persistence.
+                keys_to_exclude = ['output', 'llm_response', 'messages', 'results', 'npc', 'context', 'jinxs', 'team']
+                
+                # Update jinx_local_context with all non-excluded keys from the result
+                for key, value in result.items():
+                    if key not in keys_to_exclude and not key.startswith('_'): # Exclude internal/temporary keys
+                        jinx_local_context[key] = value
+                
+                print(f"jinx_local_context UPDATED from Jinx result: {jinx_local_context}") # NEW LOG
+            
+            # Get output (this still comes from the 'output' key in the result)
             output = result.get('output', str(result))
             messages_updated = result.get('messages', messages)
+
+            print(f"jinx_local_context AFTER Jinx execution (final state): {jinx_local_context}")
+            print(f"Jinx execution result output: {output}")
             
             # Check for interruption
             with cancellation_lock:
@@ -774,7 +806,7 @@ def execute_jinx():
             )
             
         except Exception as e:
-            print(f"Error executing jinx {jinx_name}: {str(e)}")
+            print(f"ERROR: Exception during jinx execution {jinx_name}: {str(e)}")
             traceback.print_exc()
             error_data = {
                 "type": "error",
@@ -786,6 +818,7 @@ def execute_jinx():
             with cancellation_lock:
                 if current_stream_id in cancellation_flags:
                     del cancellation_flags[current_stream_id]
+            print(f"--- Jinx Execution Finished for streamId: {stream_id} ---")
     
     return Response(event_stream(stream_id), mimetype="text/event-stream")
 

{npcpy-1.2.28 → npcpy-1.2.30/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.28
+Version: 1.2.30
 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.2.28 → npcpy-1.2.30}/setup.py

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