npcpy 1.2.29__tar.gz → 1.2.30__tar.gz

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

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

@@ -280,50 +280,59 @@ class Jinx:
             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, 
-    ):
+                  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")
@@ -364,7 +373,9 @@ class Jinx:
                 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,
@@ -379,21 +390,33 @@ 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
+            }
             
-            exec_locals = {}
-            exec(rendered_code, exec_globals, exec_locals)
+            # 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 = {}
+            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}"}
@@ -561,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 = {}
@@ -585,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
@@ -603,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):
@@ -629,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.29 → 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.29 → npcpy-1.2.30/npcpy.egg-info}/PKG-INFO

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

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