npcpy 1.2.32__tar.gz → 1.2.34__tar.gz

{npcpy-1.2.32/npcpy.egg-info → npcpy-1.2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.32
+Version: 1.2.34
 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
@@ -185,62 +185,117 @@ for tool_call in response['tool_results']:
 Here is an example for setting up an agent team to use Jinja Execution (Jinxs) templates that are processed entirely with prompts, allowing you to use them with models that do or do not possess tool calling support.
 
 ```python
+
 from npcpy.npc_compiler import NPC, Team, Jinx
 from npcpy.tools import auto_tools
 import os
+from jinja2 import Environment, Undefined, DictLoader # Import necessary Jinja2 components for Jinx code
 
-
-
+# --- REVISED file_reader_jinx ---
 file_reader_jinx = Jinx(jinx_data={
     "jinx_name": "file_reader",
-    "description": "Read a file and summarize its contents",
+    "description": "Read a file and optionally summarize its contents using an LLM.",
     "inputs": ["filename"],
     "steps": [
         {
-            "name": "read_file",
+            "name": "read_file_content",
             "engine": "python",
-            "code": """
+            "code": '''
 import os
-with open(os.path.abspath('{{ filename }}'), 'r') as f:
-    content = f.read()
-output= content
-            """
+from jinja2 import Environment, Undefined, DictLoader # Local import for Jinx step
+
+# The 'filename' input to the file_reader jinx might be a Jinja template string like "{{ source_filename }}"
+# or a direct filename. We need to render it using the current execution context.
+
+# Get the Jinja environment from the NPC if available, otherwise create a default one.
+# The 'npc' variable is available in the Jinx execution context.
+# We need to ensure 'npc' exists before trying to access its 'jinja_env'.
+execution_jinja_env = npc.jinja_env if npc else Environment(loader=DictLoader({}), undefined=Undefined)
+
+# Render the filename. The current 'context' should contain the variables needed for rendering.
+# For declarative calls, the parent Jinx's inputs (like 'source_filename') will be in this context.
+# We also need to ensure the value from context['filename'] is treated as a template string.
+filename_template = execution_jinja_env.from_string(context['filename'])
+rendered_filename = filename_template.render(**context)
+
+file_path_abs = os.path.abspath(rendered_filename)
+try:
+    with open(file_path_abs, 'r') as f:
+        content = f.read()
+    context['file_raw_content'] = content # Store raw content in context for later use
+    output = content # Output of this step is the raw content
+except FileNotFoundError:
+    output = f"Error: File not found at {file_path_abs}"
+    context['file_raw_content'] = output # Store error message for consistency
+except Exception as e:
+    output = f"Error reading file {file_path_abs}: {e}"
+    context['file_raw_content'] = output # Store error message for consistency
+            '''
         },
         {
-            "name": "summarize_content",
-            "engine": "natural",
-            "code": """
-                Summarize the content of the file: {{ read_file }}.
-            """
+            "name": "summarize_file_content",
+            "engine": "python",
+            "code": '''
+# Check if the previous step encountered an error
+if "Error" not in context['file_raw_content']:
+    prompt = f"Summarize the following content concisely, highlighting key themes and points: {context['file_raw_content']}"
+    llm_result = npc.get_llm_response(prompt, tool_choice=False) # FIX: Passed prompt positionally
+    output = llm_result.get('response', 'Failed to generate summary due to LLM error.')
+else:
+    output = "Skipping summary due to previous file reading error."
+            '''
         }
     ]
 })
 
-
-# Define a jinx for literary research
+# --- REVISED literary_research_jinx ---
 literary_research_jinx = Jinx(jinx_data={
     "jinx_name": "literary_research",
-    "description": "Research a literary topic, analyze files, and summarize findings",
-    "inputs": ["topic"],
+    "description": "Research a literary topic, read a specific file, analyze, and synthesize findings.",
+    "inputs": ["topic", "source_filename"],
     "steps": [
         {
-            "name": "gather_info",
-            "engine": "natural",
-            "code": """
-                Research the topic: {{ topic }}.
-                Summarize the main themes and historical context.
-            """
+            "name": "initial_llm_research",
+            "engine": "python",
+            "code": '''
+prompt = f"Research the topic: {context['topic']}. Summarize the main themes, key authors, and historical context. Be thorough."
+llm_result = npc.get_llm_response(prompt, tool_choice=False) # FIX: Passed prompt positionally
+context['research_summary'] = llm_result.get('response', 'No initial LLM research found.')
+output = context['research_summary']
+            '''
+        },
+        {
+            "name": "read_and_process_source_file",
+            "engine": "file_reader",
+            "filename": "{{ source_filename }}" # This is passed as a string template to file_reader
         },
         {
-            "name": "final_summary",
-            "engine": "natural",
-            "code": """
-                Based on the research in. {{gather_info}}, write a concise, creative summary.
-            """
+            "name": "final_synthesis_and_creative_writing",
+            "engine": "python",
+            "code": '''
+# Access outputs from previous steps.
+research_summary = context['initial_llm_research']
+# The output of a declarative jinx call (like 'file_reader') is stored under its step name.
+# The actual content we want is the 'output' of the *last step* within that sub-jinx.
+file_summary = context['read_and_process_source_file'].get('output', 'No file summary available.')
+
+prompt = f"""Based on the following information:
+1. Comprehensive Research Summary:
+{research_summary}
+
+2. Key Insights from Source File:
+{file_summary}
+
+Integrate these findings and write a concise, creative, and poetically styled summary of the literary topic '{context['topic']}'. Emphasize unique perspectives or connections between the research and the file content, as if written by a master of magical realism.
+"""
+llm_result = npc.get_llm_response(prompt, tool_choice=False) # FIX: Passed prompt positionally
+output = llm_result.get('response', 'Failed to generate final creative summary.')
+            '''
         }
     ]
 })
 
+# --- NPC Definitions (unchanged) ---
 ggm = NPC(
     name='Gabriel Garcia Marquez',
     primary_directive='You are Gabriel Garcia Marquez, master of magical realism. Research, analyze, and write with poetic flair.',
@@ -263,16 +318,24 @@ borges = NPC(
     provider='ollama',
 )
 
-# Set up a team with a forenpc that orchestrates the other npcs
-lit_team = Team(npcs=[ggm, isabel], forenpc=borges, jinxs={'literary_research': literary_research_jinx, 'file_reader': file_reader_jinx},
+# --- Team Setup ---
+lit_team = Team(
+    npcs=[ggm, isabel], 
+    forenpc=borges, 
+    jinxs=[literary_research_jinx, file_reader_jinx],
 )
 
-# Example: Orchestrate a jinx workflow
+# --- Orchestration Example ---
 result = lit_team.orchestrate(
-    "Research the topic of magical realism, read ./test_data/magical_realism.txt and summarize the findings"
+    "Research the topic of magical realism, using the file './test_data/magical_realism.txt' as a primary source, and provide a comprehensive, creative summary."
 )
+
+print("\n--- Orchestration Result Summary ---")
 print(result['debrief']['summary'])
 
+print("\n--- Full Orchestration Output ---")
+print(result['output'])
+
 ```
 ```
  • Action chosen: pass_to_npc                                                                                                                                          

{npcpy-1.2.32 → npcpy-1.2.34}/README.md

@@ -89,62 +89,117 @@ for tool_call in response['tool_results']:
 Here is an example for setting up an agent team to use Jinja Execution (Jinxs) templates that are processed entirely with prompts, allowing you to use them with models that do or do not possess tool calling support.
 
 ```python
+
 from npcpy.npc_compiler import NPC, Team, Jinx
 from npcpy.tools import auto_tools
 import os
+from jinja2 import Environment, Undefined, DictLoader # Import necessary Jinja2 components for Jinx code
 
-
-
+# --- REVISED file_reader_jinx ---
 file_reader_jinx = Jinx(jinx_data={
     "jinx_name": "file_reader",
-    "description": "Read a file and summarize its contents",
+    "description": "Read a file and optionally summarize its contents using an LLM.",
     "inputs": ["filename"],
     "steps": [
         {
-            "name": "read_file",
+            "name": "read_file_content",
             "engine": "python",
-            "code": """
+            "code": '''
 import os
-with open(os.path.abspath('{{ filename }}'), 'r') as f:
-    content = f.read()
-output= content
-            """
+from jinja2 import Environment, Undefined, DictLoader # Local import for Jinx step
+
+# The 'filename' input to the file_reader jinx might be a Jinja template string like "{{ source_filename }}"
+# or a direct filename. We need to render it using the current execution context.
+
+# Get the Jinja environment from the NPC if available, otherwise create a default one.
+# The 'npc' variable is available in the Jinx execution context.
+# We need to ensure 'npc' exists before trying to access its 'jinja_env'.
+execution_jinja_env = npc.jinja_env if npc else Environment(loader=DictLoader({}), undefined=Undefined)
+
+# Render the filename. The current 'context' should contain the variables needed for rendering.
+# For declarative calls, the parent Jinx's inputs (like 'source_filename') will be in this context.
+# We also need to ensure the value from context['filename'] is treated as a template string.
+filename_template = execution_jinja_env.from_string(context['filename'])
+rendered_filename = filename_template.render(**context)
+
+file_path_abs = os.path.abspath(rendered_filename)
+try:
+    with open(file_path_abs, 'r') as f:
+        content = f.read()
+    context['file_raw_content'] = content # Store raw content in context for later use
+    output = content # Output of this step is the raw content
+except FileNotFoundError:
+    output = f"Error: File not found at {file_path_abs}"
+    context['file_raw_content'] = output # Store error message for consistency
+except Exception as e:
+    output = f"Error reading file {file_path_abs}: {e}"
+    context['file_raw_content'] = output # Store error message for consistency
+            '''
         },
         {
-            "name": "summarize_content",
-            "engine": "natural",
-            "code": """
-                Summarize the content of the file: {{ read_file }}.
-            """
+            "name": "summarize_file_content",
+            "engine": "python",
+            "code": '''
+# Check if the previous step encountered an error
+if "Error" not in context['file_raw_content']:
+    prompt = f"Summarize the following content concisely, highlighting key themes and points: {context['file_raw_content']}"
+    llm_result = npc.get_llm_response(prompt, tool_choice=False) # FIX: Passed prompt positionally
+    output = llm_result.get('response', 'Failed to generate summary due to LLM error.')
+else:
+    output = "Skipping summary due to previous file reading error."
+            '''
         }
     ]
 })
 
-
-# Define a jinx for literary research
+# --- REVISED literary_research_jinx ---
 literary_research_jinx = Jinx(jinx_data={
     "jinx_name": "literary_research",
-    "description": "Research a literary topic, analyze files, and summarize findings",
-    "inputs": ["topic"],
+    "description": "Research a literary topic, read a specific file, analyze, and synthesize findings.",
+    "inputs": ["topic", "source_filename"],
     "steps": [
         {
-            "name": "gather_info",
-            "engine": "natural",
-            "code": """
-                Research the topic: {{ topic }}.
-                Summarize the main themes and historical context.
-            """
+            "name": "initial_llm_research",
+            "engine": "python",
+            "code": '''
+prompt = f"Research the topic: {context['topic']}. Summarize the main themes, key authors, and historical context. Be thorough."
+llm_result = npc.get_llm_response(prompt, tool_choice=False) # FIX: Passed prompt positionally
+context['research_summary'] = llm_result.get('response', 'No initial LLM research found.')
+output = context['research_summary']
+            '''
+        },
+        {
+            "name": "read_and_process_source_file",
+            "engine": "file_reader",
+            "filename": "{{ source_filename }}" # This is passed as a string template to file_reader
         },
         {
-            "name": "final_summary",
-            "engine": "natural",
-            "code": """
-                Based on the research in. {{gather_info}}, write a concise, creative summary.
-            """
+            "name": "final_synthesis_and_creative_writing",
+            "engine": "python",
+            "code": '''
+# Access outputs from previous steps.
+research_summary = context['initial_llm_research']
+# The output of a declarative jinx call (like 'file_reader') is stored under its step name.
+# The actual content we want is the 'output' of the *last step* within that sub-jinx.
+file_summary = context['read_and_process_source_file'].get('output', 'No file summary available.')
+
+prompt = f"""Based on the following information:
+1. Comprehensive Research Summary:
+{research_summary}
+
+2. Key Insights from Source File:
+{file_summary}
+
+Integrate these findings and write a concise, creative, and poetically styled summary of the literary topic '{context['topic']}'. Emphasize unique perspectives or connections between the research and the file content, as if written by a master of magical realism.
+"""
+llm_result = npc.get_llm_response(prompt, tool_choice=False) # FIX: Passed prompt positionally
+output = llm_result.get('response', 'Failed to generate final creative summary.')
+            '''
         }
     ]
 })
 
+# --- NPC Definitions (unchanged) ---
 ggm = NPC(
     name='Gabriel Garcia Marquez',
     primary_directive='You are Gabriel Garcia Marquez, master of magical realism. Research, analyze, and write with poetic flair.',
@@ -167,16 +222,24 @@ borges = NPC(
     provider='ollama',
 )
 
-# Set up a team with a forenpc that orchestrates the other npcs
-lit_team = Team(npcs=[ggm, isabel], forenpc=borges, jinxs={'literary_research': literary_research_jinx, 'file_reader': file_reader_jinx},
+# --- Team Setup ---
+lit_team = Team(
+    npcs=[ggm, isabel], 
+    forenpc=borges, 
+    jinxs=[literary_research_jinx, file_reader_jinx],
 )
 
-# Example: Orchestrate a jinx workflow
+# --- Orchestration Example ---
 result = lit_team.orchestrate(
-    "Research the topic of magical realism, read ./test_data/magical_realism.txt and summarize the findings"
+    "Research the topic of magical realism, using the file './test_data/magical_realism.txt' as a primary source, and provide a comprehensive, creative summary."
 )
+
+print("\n--- Orchestration Result Summary ---")
 print(result['debrief']['summary'])
 
+print("\n--- Full Orchestration Output ---")
+print(result['output'])
+
 ```
 ```
  • Action chosen: pass_to_npc                                                                                                                                          

{npcpy-1.2.32 → npcpy-1.2.34}/npcpy/llm_funcs.py

@@ -379,6 +379,8 @@ def execute_llm_command(
         "messages": messages,
         "output": "Max attempts reached. Unable to execute the command successfully.",
     }
+
+# --- START OF CORRECTED handle_jinx_call ---
 def handle_jinx_call(
     command: str,
     jinx_name: str,
@@ -391,7 +393,7 @@ def handle_jinx_call(
     n_attempts=3,
     attempt=0,
     context=None,
-    extra_globals=None,  # ADD THIS
+    extra_globals=None,
     **kwargs
 ) -> Union[str, Dict[str, Any]]:
     """This function handles a jinx call.
@@ -411,10 +413,13 @@ def handle_jinx_call(
     if npc is None and team is None:
         return f"No jinxs are available. "
     else:
+        jinx = None
+        if npc and hasattr(npc, 'jinxs_dict') and jinx_name in npc.jinxs_dict:
+            jinx = npc.jinxs_dict[jinx_name]
+        elif team and hasattr(team, 'jinxs_dict') and jinx_name in team.jinxs_dict:
+            jinx = team.jinxs_dict[jinx_name]
 
-       
-       
-        if jinx_name not in npc.jinxs_dict and jinx_name not in team.jinxs_dict:
+        if not jinx:
             print(f"Jinx {jinx_name} not available")
             if attempt < n_attempts:
                 print(f"attempt {attempt+1} to generate jinx name failed, trying again")                
@@ -442,16 +447,11 @@ def handle_jinx_call(
                 "messages": messages,
             }
 
-
-
-
-        elif jinx_name in npc.jinxs_dict:
-            jinx = npc.jinxs_dict[jinx_name]
-        elif jinx_name in team.jinxs_dict:
-            jinx = team.jinxs_dict[jinx_name]
-
         render_markdown(f"jinx found: {jinx.jinx_name}")
-        jinja_env = Environment(loader=FileSystemLoader("."), undefined=Undefined)
+        
+        # This jinja_env is for parsing the Jinx's *inputs* from the LLM response, not for Jinx.execute's second pass.
+        local_jinja_env_for_input_parsing = Environment(loader=FileSystemLoader("."), undefined=Undefined)
+        
         example_format = {}
         for inp in jinx.inputs:
             if isinstance(inp, str):
@@ -563,20 +563,32 @@ def handle_jinx_call(
         
         render_markdown( "\n".join(['\n - ' + str(key) + ': ' +str(val) for key, val in input_values.items()]))
 
+        # Initialize jinx_output before the try block to prevent UnboundLocalError
+        jinx_output = {"output": "Jinx execution did not complete."} 
+        
         try:
+            # --- CRITICAL FIX HERE ---
+            # Pass arguments as keyword arguments to avoid positional confusion
+            # Use npc.jinja_env for the second-pass rendering
             jinx_output = jinx.execute(
-                input_values,
-                jinja_env,
-                npc=npc,
+                input_values=input_values,
+                npc=npc, # This is the orchestrating NPC
                 messages=messages,
-                extra_globals=extra_globals  # ADD THIS
-                
+                extra_globals=extra_globals,
+                jinja_env=npc.jinja_env if npc else (team.forenpc.jinja_env if team and team.forenpc else None) # Use NPC's or Team's forenpc's jinja_env
             )
+            # Ensure jinx_output is a dict with an 'output' key
+            if jinx_output is None:
+                jinx_output = {"output": "Jinx executed, but returned no explicit output."}
+            elif not isinstance(jinx_output, dict):
+                jinx_output = {"output": str(jinx_output)}
+
         except Exception as e:
             print(f"An error occurred while executing the jinx: {e}")
             print(f"trying again, attempt {attempt+1}")
             print('command', command)
             if attempt < n_attempts:
+                # Recursively call handle_jinx_call for retry
                 jinx_output = handle_jinx_call(
                     command,
                     jinx_name,
@@ -589,9 +601,15 @@ def handle_jinx_call(
                     attempt=attempt + 1,
                     n_attempts=n_attempts,
                     context=f""" \n \n \n "jinx failed: {e}  \n \n \n here was the previous attempt: {input_values}""",
+                    extra_globals=extra_globals
                 )
+            else:
+                # If max attempts reached, set a clear error output
+                jinx_output = {"output": f"Jinx '{jinx_name}' failed after {n_attempts} attempts: {e}", "error": True}
+
+
         if not stream and len(messages) > 0 :            
-            render_markdown(f""" ## jinx OUTPUT FROM CALLING {jinx_name} \n \n output:{jinx_output['output']}""" )            
+            render_markdown(f""" ## jinx OUTPUT FROM CALLING {jinx_name} \n \n output:{jinx_output.get('output', 'No output.')}""" )            
             response = get_llm_response(f"""
                 The user had the following request: {command}. 
                 Here were the jinx outputs from calling {jinx_name}: {jinx_output.get('output', '')}
@@ -610,7 +628,9 @@ def handle_jinx_call(
             response = response.get("response", {})
             return {'messages':messages, 'output':response}
         
-        return {'messages': messages, 'output': jinx_output['output']}
+        return {'messages': messages, 'output': jinx_output.get('output', 'No output.')} # Ensure 'output' key exists
+
+# --- END OF CORRECTED handle_jinx_call ---
 
 
 def handle_request_input(
@@ -670,7 +690,7 @@ def jinx_handler(command, extracted_data, **kwargs):
         team=kwargs.get('team'),
         stream=kwargs.get('stream'),
         context=kwargs.get('context'),
-        extra_globals=kwargs.get('extra_globals')  # ADD THIS
+        extra_globals=kwargs.get('extra_globals')
     )
 
 def answer_handler(command, extracted_data, **kwargs):
@@ -976,8 +996,8 @@ def execute_multi_step_plan(
    images: list = None,
    stream=False,
    context=None,
-
    actions: Dict[str, Dict] = None,
+   extra_globals=None,
    **kwargs, 
 ):
     """
@@ -1045,7 +1065,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,
@@ -1059,7 +1079,7 @@ def execute_multi_step_plan(
                 stream=stream, 
                 context=context+step_context, 
                 images=images,
-                extra_globals=kwargs.get('extra_globals')  # ADD THIS
+                extra_globals=extra_globals
             )
         except KeyError as e:
           
@@ -1862,7 +1882,7 @@ def zoom_in(facts,
                        npc=npc,
                        context=context,
                        attempt_number=attempt_number+1,
-                       n_tries=n_tries,
+                       n_tries=n_attempts, # Corrected from n_tries to n_attempts
                        **kwargs)
     return facts
 def generate_groups(facts, 
@@ -1945,7 +1965,6 @@ def remove_redundant_groups(groups,
     response = get_llm_response(prompt, 
                                 model=model, 
                                 provider=provider, 
-                                format="json", 
                                 npc=npc,
                                 context=context,
                                 **kwargs)
@@ -2056,17 +2075,18 @@ def get_related_facts_llm(new_fact_statement,
                                 npc=npc,
                                 context=context,
                                 **kwargs)   
-    if attempt_number > n_attempts:
-        print(f"  Attempt {attempt_number} to find related facts yielded no results. Giving up.")
-        return get_related_facts_llm(new_fact_statement, 
-                                       existing_fact_statements, 
-                                       model=model, 
-                                       provider=provider, 
-                                       npc=npc,
-                                       attempt_number=attempt_number+1,
-                                       n_attempts=n_attempts,
-                                       context=context,
-                                       **kwargs)    
+    if attempt_number <= n_attempts: # Corrected logic: retry if attempt_number is within limits
+        if not response["response"].get("related_facts", []): # Only retry if no related facts found
+            print(f"  Attempt {attempt_number} to find related facts yielded no results. Retrying...")
+            return get_related_facts_llm(new_fact_statement, 
+                                           existing_fact_statements, 
+                                           model=model, 
+                                           provider=provider, 
+                                           npc=npc,
+                                           attempt_number=attempt_number+1,
+                                           n_attempts=n_attempts,
+                                           context=context,
+                                           **kwargs)    
 
     return response["response"].get("related_facts", [])
 

{npcpy-1.2.32 → npcpy-1.2.34}/npcpy/memory/command_history.py

@@ -825,6 +825,31 @@ class CommandHistory:
             FROM message_attachments WHERE message_id = :message_id
         """
         return self._fetch_all(stmt, {"message_id": message_id})
+    def delete_message(self, conversation_id, message_id):
+        """Delete a specific message from a conversation"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        try:
+            # Delete from the messages table
+            cursor.execute("""
+                DELETE FROM messages 
+                WHERE conversation_id = ? AND message_id = ?
+            """, (conversation_id, message_id))
+            
+            rows_affected = cursor.rowcount
+            conn.commit()
+            
+            print(f"[DB] Deleted message {message_id} from conversation {conversation_id}. Rows affected: {rows_affected}")
+            
+            return rows_affected
+            
+        except Exception as e:
+            print(f"[DB] Error deleting message: {e}")
+            conn.rollback()
+            raise
+        finally:
+            conn.close()
 
     def get_attachment_data(self, attachment_id) -> Optional[Tuple[bytes, str, str]]:
         stmt = "SELECT attachment_data, attachment_name, attachment_type FROM message_attachments WHERE id = :attachment_id"
@@ -1172,4 +1197,4 @@ def get_available_tables(db_path_or_engine: Union[str, Engine]) -> List[Tuple[st
             return [row[0] for row in result]
     except Exception as e:
         print(f"Error getting available tables: {e}")
-        return []
+        return []