npcsh 1.1.21__py3-none-any.whl → 1.1.22__py3-none-any.whl

npcsh/_state.py

@@ -2537,19 +2537,16 @@ def collect_llm_tools(state: ShellState) -> Tuple[List[Dict[str, Any]], Dict[str
     elif npc_obj and getattr(npc_obj, "tool_map", None):
         tool_map.update(npc_obj.tool_map)
 
-    # Jinx tools from NPC and Team
+    # Jinx tools from NPC only (NPC.jinxs_dict is already filtered by jinxs_spec
+    # during initialize_jinxs - don't add the full team catalog which overwhelms small models)
     aggregated_jinxs: Dict[str, Any] = {}
     if npc_obj and getattr(npc_obj, "jinxs_dict", None):
         aggregated_jinxs.update(npc_obj.jinxs_dict)
-    if state.team and isinstance(state.team, Team) and getattr(state.team, "jinxs_dict", None):
-        aggregated_jinxs.update({k: v for k, v in state.team.jinxs_dict.items() if k not in aggregated_jinxs})
 
     if aggregated_jinxs:
         jinx_catalog: Dict[str, Dict[str, Any]] = {}
         if npc_obj and getattr(npc_obj, "jinx_tool_catalog", None):
             jinx_catalog.update(npc_obj.jinx_tool_catalog or {})
-        if state.team and isinstance(state.team, Team) and getattr(state.team, "jinx_tool_catalog", None):
-            jinx_catalog.update(state.team.jinx_tool_catalog or {})
         if not jinx_catalog:
             jinx_catalog = build_jinx_tool_catalog(aggregated_jinxs)
 
@@ -2898,6 +2895,14 @@ def process_pipeline_command(
             tools_for_llm, tool_exec_map = collect_llm_tools(state)
             if not tools_for_llm:
                 tool_capable = False
+            else:
+                # Add tool guidance so model knows to use function calls
+                tool_names = [t['function']['name'] for t in tools_for_llm if 'function' in t]
+                info += (
+                    f"\nYou have access to these tools: {', '.join(tool_names)}. "
+                    f"You MUST use the function calling interface to invoke them. "
+                    f"Do NOT write tool names as text - call them as functions."
+                )
 
         npc_name = (
             state.npc.name 

npcsh/benchmark/npcsh_agent.py

@@ -53,11 +53,11 @@ class NpcshAgent(BaseInstalledAgent):
         Returns:
             List of ExecInput commands to execute
         """
-        # Wrap the instruction with explicit jinx usage directions and retry logic
-        tool_instruction = f"""You have access to jinxs including edit_file (for writing/creating files), sh (for running shell commands), and python (for running Python code).
+        # Wrap the instruction with tool usage directions and retry logic
+        tool_instruction = f"""You have access to tools: edit_file (for writing/creating files), sh (for running shell commands), and python (for running Python code).
 
 IMPORTANT RULES:
-1. You MUST use these jinxs to complete the task. Do NOT just output code as text - use the edit_file jinx to actually write files to disk.
+1. You MUST call these tools using the function calling interface to complete the task. Do NOT write tool names as text - invoke them as function calls.
 2. After implementing a solution, you MUST verify it works by running any provided test scripts.
 3. If a test fails or produces an error, you MUST try a DIFFERENT approach. Do not give up.
 4. Keep trying different approaches until you succeed or have tried at least 10 different solutions.
@@ -66,13 +66,11 @@ IMPORTANT RULES:
 Task: {instruction}
 
 WORKFLOW:
-1. Implement your solution using edit_file and sh
+1. Call edit_file to write code files. Call sh to run commands.
 2. Run any test scripts mentioned in the task
 3. Check the output carefully - look for "PASS", "SUCCESS", "OK" or similar
 4. If the test failed, analyze why and try a completely different approach
-5. Repeat until the test passes
-
-Remember: Use edit_file to write code files. Use sh to run commands. VERIFY your solution works before concluding."""
+5. Repeat until the test passes"""
 
         escaped_instruction = shlex.quote(tool_instruction)
         model_name = self.model_name
@@ -146,8 +144,14 @@ Remember: Use edit_file to write code files. Use sh to run commands. VERIFY your
         # Using corca NPC which has edit_file tool for writing files
         # Using the npc CLI which supports single-command execution
         # NPCSH_DEFAULT_MODE=agent enables automatic tool execution
+        ollama_env = ""
+        if npcsh_provider == "ollama":
+            ollama_host = os.environ.get("OLLAMA_HOST", "http://host.docker.internal:11434")
+            ollama_env = f'OLLAMA_HOST="{ollama_host}" '
+
         npcsh_cmd = (
             f'{env_prefix}'
+            f'{ollama_env}'
             f'NPCSH_CHAT_MODEL="{model}" '
             f'NPCSH_CHAT_PROVIDER="{npcsh_provider}" '
             f'NPCSH_STREAM_OUTPUT=0 '
@@ -234,11 +238,11 @@ class NpcshAgentWithNpc(NpcshAgent):
 
     def create_run_agent_commands(self, instruction: str) -> list:
         """Create commands using a specific NPC."""
-        # Wrap the instruction with explicit jinx usage directions and retry logic
-        tool_instruction = f"""You have access to jinxs including edit_file (for writing/creating files), sh (for running shell commands), and python (for running Python code).
+        # Wrap the instruction with tool usage directions and retry logic
+        tool_instruction = f"""You have access to tools: edit_file (for writing/creating files), sh (for running shell commands), and python (for running Python code).
 
 IMPORTANT RULES:
-1. You MUST use these jinxs to complete the task. Do NOT just output code as text - use the edit_file jinx to actually write files to disk.
+1. You MUST call these tools using the function calling interface to complete the task. Do NOT write tool names as text - invoke them as function calls.
 2. After implementing a solution, you MUST verify it works by running any provided test scripts.
 3. If a test fails or produces an error, you MUST try a DIFFERENT approach. Do not give up.
 4. Keep trying different approaches until you succeed or have tried at least 10 different solutions.
@@ -247,13 +251,11 @@ IMPORTANT RULES:
 Task: {instruction}
 
 WORKFLOW:
-1. Implement your solution using edit_file and sh
+1. Call edit_file to write code files. Call sh to run commands.
 2. Run any test scripts mentioned in the task
 3. Check the output carefully - look for "PASS", "SUCCESS", "OK" or similar
 4. If the test failed, analyze why and try a completely different approach
-5. Repeat until the test passes
-
-Remember: Use edit_file to write code files. Use sh to run commands. VERIFY your solution works before concluding."""
+5. Repeat until the test passes"""
 
         escaped_instruction = shlex.quote(tool_instruction)
         model_name = self.model_name
@@ -309,8 +311,14 @@ Remember: Use edit_file to write code files. Use sh to run commands. VERIFY your
 
         # Use specific NPC with --npc flag
         # NPCSH_DEFAULT_MODE=agent enables automatic tool execution
+        ollama_env = ""
+        if npcsh_provider == "ollama":
+            ollama_host = os.environ.get("OLLAMA_HOST", "http://host.docker.internal:11434")
+            ollama_env = f'OLLAMA_HOST="{ollama_host}" '
+
         npcsh_cmd = (
             f'{env_prefix}'
+            f'{ollama_env}'
             f'NPCSH_CHAT_MODEL="{model}" '
             f'NPCSH_CHAT_PROVIDER="{npcsh_provider}" '
             f'NPCSH_STREAM_OUTPUT=0 '

npcsh/benchmark/templates/install-npcsh.sh.j2

@@ -14,8 +14,8 @@ fi
 
 # Install npcsh with lite dependencies (API providers only, no local models)
 # Use --break-system-packages for PEP 668 compliance (Ubuntu 24.04+)
-echo "Installing npcsh[lite]..."
-pip install --quiet --break-system-packages npcsh[lite] || pip install --quiet npcsh[lite]
+echo "Installing npcsh[lite] + ollama..."
+pip install --quiet --break-system-packages npcsh[lite] ollama || pip install --quiet npcsh[lite] ollama
 
 # Verify installation
 echo "Verifying npcsh installation..."

npcsh/mcp_server.py

@@ -1,9 +1,17 @@
 
 """
-Enhanced MCP server that incorporates functionality from npcpy.routes, 
+Enhanced MCP server that incorporates functionality from npcpy.routes,
 npcpy.llm_funcs, and npcpy.npc_compiler as tools.
 """
 
+# When run as a subprocess, Python adds the script directory to sys.path[0].
+# Since this file lives inside the npcsh package, that shadows the package
+# (npcsh.py is found instead of the npcsh/ package). Remove it.
+import sys as _sys, os as _os
+_script_dir = _os.path.dirname(_os.path.abspath(__file__))
+if _script_dir in _sys.path:
+    _sys.path.remove(_script_dir)
+
 import os
 import subprocess
 import json

npcsh/npc_team/alicanto.npc

@@ -11,13 +11,19 @@ colors:
   top: "255,215,0"
   bottom: "218,165,32"
 primary_directive: |
-  You are alicanto, the research and exploration specialist of the NPC team.
-  Like the mythical bird, you lead users to discover valuable information.
-  Your role is web research, searching, and helping users explore topics.
-  Use search tools to find information and present findings clearly.
+  You are alicanto, a research agent. You investigate hypotheses through experimentation and evidence gathering.
+  Search academic papers to ground your work in existing literature.
+  Search the web for data, documentation, and recent findings.
+  Write and execute Python code to analyze data, compute statistics, and generate results.
+  Use shell commands for data processing and system tasks.
+  Create files to record your findings, analyses, and evidence.
+  When exploring a hypothesis, gather evidence from multiple sources, analyze it quantitatively where possible, and document what you find.
+  Say RESEARCH_COMPLETE when you have sufficient evidence to evaluate your hypothesis.
 jinxs:
-  - lib/core/search
+  - lib/core/search/web_search
+  - lib/core/search/file_search
+  - lib/core/search/db_search
   - lib/core/sh
   - lib/core/python
   - lib/core/load_file
-  - lib/research/*
+  - lib/core/edit_file

npcsh/npc_team/corca.npc

@@ -27,5 +27,4 @@ jinxs:
   - lib/core/python
   - lib/core/edit_file
   - lib/core/load_file
-  - lib/core/search
     

npcsh/npc_team/frederic.npc

@@ -22,6 +22,5 @@ jinxs:
   - lib/core/sql
   - lib/core/sh
   - lib/core/load_file
-  - lib/core/search
-  - lib/gen/*
-  - bin/wander
+  - lib/core/search/web_search
+  - lib/core/edit_file

npcsh/npc_team/jinxs/lib/core/edit_file.jinx

@@ -1,6 +1,6 @@
 jinx_name: edit_file
-description: Examines a file, determines what changes are needed, and applies those
-  changes.
+description: Creates or edits a file. If the file does not exist, creates it with
+  the specified content. If the file exists, examines it and applies changes.
 inputs:
 - file_path
 - edit_instructions
@@ -17,19 +17,42 @@ steps:
       edit_instructions = {{ edit_instructions | string | tojson }}
       backup_str = {{ backup | default("true") | string | tojson }}
       create_backup = backup_str.lower() not in ('false', 'no', '0', '')
-      
-    
-      with open(file_path, 'r') as f:
-          original_content = f.read()
-      
-    
-      if create_backup:
-          backup_path = file_path + ".bak"
-          with open(backup_path, 'w') as f:
-              f.write(original_content)
-      
-    
-      prompt = """You are a code editing assistant. Analyze this file and make the requested changes.
+
+      # Ensure parent directory exists
+      os.makedirs(os.path.dirname(file_path) or '.', exist_ok=True)
+
+      # If file doesn't exist, create it
+      if not os.path.exists(file_path):
+          prompt = """You are a code writing assistant. Create the content for a new file based on these instructions.
+
+        Instructions: """ + edit_instructions + """
+
+        Return a JSON object with:
+        1. "content": The full content to write to the file
+        2. "explanation": Brief explanation of what was created
+
+        Example response:
+        {"content": "print('hello world')", "explanation": "Created a Python hello world script"}
+        """
+          response = get_llm_response(prompt, model=npc.model, provider=npc.provider, npc=npc, format="json")
+          result = response.get("response", {})
+          content = result.get("content", edit_instructions)
+          explanation = result.get("explanation", "Created new file")
+
+          with open(file_path, 'w') as f:
+              f.write(content)
+
+          output = "Created " + file_path + "\n\n" + explanation
+      else:
+          with open(file_path, 'r') as f:
+              original_content = f.read()
+
+          if create_backup:
+              backup_path = file_path + ".bak"
+              with open(backup_path, 'w') as f:
+                  f.write(original_content)
+
+          prompt = """You are a code editing assistant. Analyze this file and make the requested changes.
 
         File content:
         """ + original_content + """
@@ -49,49 +72,48 @@ steps:
         Example response:
         {"modifications": [{"type": "replace", "original": "old code", "replacement": "new code"}], "explanation": "Updated the code"}
         """
-    
-      response = get_llm_response(prompt, model=npc.model, provider=npc.provider, npc=npc, format="json")
-      
-      result = response.get("response", {})
-      modifications = result.get("modifications", [])
-      explanation = result.get("explanation", "No explanation provided")
-      
-    
-      updated_content = original_content
-      changes_applied = 0
-      
-      for mod in modifications:
-          print(mod)
-          mod_type = mod.get("type")
-          
-          if mod_type == "replace":
-              original = mod.get("original")
-              replacement = mod.get("replacement")
-              if original in updated_content:
-                  updated_content = updated_content.replace(original, replacement)
-                  changes_applied += 1
-          
-          elif mod_type == "insert_after":
-              target = mod.get("target")
-              insertion = mod.get("insertion")
-              if target in updated_content:
-                  updated_content = updated_content.replace(target, target + insertion)
-                  changes_applied += 1
-          
-          elif mod_type == "insert_before":
-              target = mod.get("target")
-              insertion = mod.get("insertion")
-              if target in updated_content:
-                  updated_content = updated_content.replace(target, insertion + target)
-                  changes_applied += 1
-          
-          elif mod_type == "delete":
-              target = mod.get("target")
-              if target in updated_content:
-                  updated_content = updated_content.replace(target, "")
-                  changes_applied += 1
-      
-      with open(file_path, 'w') as f:
-          f.write(updated_content)
-      
-      output = "Applied " + str(changes_applied) + " changes to " + file_path + "\n\n" + explanation
+
+          response = get_llm_response(prompt, model=npc.model, provider=npc.provider, npc=npc, format="json")
+
+          result = response.get("response", {})
+          modifications = result.get("modifications", [])
+          explanation = result.get("explanation", "No explanation provided")
+
+          updated_content = original_content
+          changes_applied = 0
+
+          for mod in modifications:
+              print(mod)
+              mod_type = mod.get("type")
+
+              if mod_type == "replace":
+                  original = mod.get("original")
+                  replacement = mod.get("replacement")
+                  if original in updated_content:
+                      updated_content = updated_content.replace(original, replacement)
+                      changes_applied += 1
+
+              elif mod_type == "insert_after":
+                  target = mod.get("target")
+                  insertion = mod.get("insertion")
+                  if target in updated_content:
+                      updated_content = updated_content.replace(target, target + insertion)
+                      changes_applied += 1
+
+              elif mod_type == "insert_before":
+                  target = mod.get("target")
+                  insertion = mod.get("insertion")
+                  if target in updated_content:
+                      updated_content = updated_content.replace(target, insertion + target)
+                      changes_applied += 1
+
+              elif mod_type == "delete":
+                  target = mod.get("target")
+                  if target in updated_content:
+                      updated_content = updated_content.replace(target, "")
+                      changes_applied += 1
+
+          with open(file_path, 'w') as f:
+              f.write(updated_content)
+
+          output = "Applied " + str(changes_applied) + " changes to " + file_path + "\n\n" + explanation

npcsh/npc_team/jinxs/modes/alicanto.jinx

@@ -33,6 +33,8 @@ steps:
       from typing import List, Dict, Any, Tuple
       from pathlib import Path
 
+      import requests as _requests
+
       from npcpy.llm_funcs import get_llm_response
       from npcpy.npc_compiler import NPC
 
@@ -65,6 +67,7 @@ steps:
 
       model = context.get('model') or (npc.model if npc and hasattr(npc, 'model') else None)
       provider = context.get('provider') or (npc.provider if npc and hasattr(npc, 'provider') else None)
+      _alicanto_directive = (npc.primary_directive if npc and hasattr(npc, 'primary_directive') else "") or ""
 
       # ========== Utility ==========
       def get_size():
@@ -164,8 +167,26 @@ steps:
           except:
               return "Error listing directory."
 
-      def execute_shell_command(command: str) -> str:
-          """Execute a shell command and return stdout/stderr."""
+      def run_python(code: str) -> str:
+          """Execute Python code and return the output. This is your PRIMARY tool for data analysis, file processing, API calls, computations, and any programmatic work. Use this for: downloading data, parsing files, running analyses, making HTTP requests, processing CSVs/FITS/JSON, plotting, statistics, etc. The code runs in a fresh namespace with access to standard library and installed packages (numpy, pandas, astropy, requests, matplotlib, scipy, etc.)."""
+          import io as _io
+          _old_stdout = sys.stdout
+          _old_stderr = sys.stderr
+          _capture = _io.StringIO()
+          sys.stdout = _capture
+          sys.stderr = _capture
+          _ns = {'__builtins__': __builtins__}
+          try:
+              exec(code, _ns)
+          except Exception as _e:
+              print(f"Error: {type(_e).__name__}: {_e}")
+          finally:
+              sys.stdout = _old_stdout
+              sys.stderr = _old_stderr
+          return _capture.getvalue()[:5000] if _capture.getvalue().strip() else "(no output)"
+
+      def shell_command(command: str) -> str:
+          """Execute a shell command. ONLY use this for simple system tasks like installing packages (pip install), checking disk space, or listing system info. For ALL data work, analysis, file processing, HTTP requests, and computation, use run_python instead."""
           try:
               result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=60)
               out = ""
@@ -179,12 +200,14 @@ steps:
           except Exception as e:
               return f"Error: {e}"
 
+      _search_provider = os.environ.get('NPCSH_SEARCH_PROVIDER', 'perplexity')
+
       def _web_search_tool(query: str) -> str:
           """Search the web for information."""
           if not WEB_AVAILABLE:
               return "Web search not available."
           try:
-              results = search_web(query, num_results=5)
+              results = search_web(query, num_results=5, provider=_search_provider)
               if not results:
                   return "No results found."
               if isinstance(results, list):
@@ -199,6 +222,61 @@ steps:
           except Exception as e:
               return f"Search error: {e}"
 
+      _s2_api_key = os.environ.get('S2_API_KEY', '')
+
+      def search_papers(query: str, limit: int = 10) -> str:
+          """Search Semantic Scholar for academic papers. Returns titles, authors, year, citation count, abstracts, and URLs."""
+          s2_url = "https://api.semanticscholar.org/graph/v1/paper/search"
+          params = {
+              "query": query,
+              "limit": min(limit, 20),
+              "fields": "title,abstract,authors,year,citationCount,url,tldr,venue"
+          }
+          try:
+              # Try with API key first if available
+              if _s2_api_key:
+                  resp = _requests.get(s2_url, headers={"x-api-key": _s2_api_key}, params=params, timeout=30)
+                  if resp.status_code == 403:
+                      # Key expired/revoked, fall back to unauthenticated
+                      resp = _requests.get(s2_url, params=params, timeout=30)
+              else:
+                  resp = _requests.get(s2_url, params=params, timeout=30)
+              if resp.status_code == 429:
+                  # Rate limited, wait and retry once
+                  time.sleep(1.5)
+                  resp = _requests.get(s2_url, params=params, timeout=30)
+              resp.raise_for_status()
+              papers = resp.json().get('data', [])
+              if not papers:
+                  return f"No papers found for: {query}"
+              out = []
+              for i, p in enumerate(papers, 1):
+                  title = p.get('title', 'No title')
+                  year = p.get('year', '?')
+                  cites = p.get('citationCount', 0)
+                  authors = ', '.join([a.get('name', '') for a in p.get('authors', [])[:3]])
+                  if len(p.get('authors', [])) > 3:
+                      authors += ' et al.'
+                  tldr = p.get('tldr', {}).get('text', '') if p.get('tldr') else ''
+                  abstract = (p.get('abstract') or '')[:200]
+                  paper_url = p.get('url', '')
+                  venue = p.get('venue', '')
+                  entry = f"{i}. {title} ({year}) [{cites} citations]"
+                  entry += f"\n   Authors: {authors}"
+                  if venue:
+                      entry += f"\n   Venue: {venue}"
+                  if tldr:
+                      entry += f"\n   TL;DR: {tldr}"
+                  elif abstract:
+                      entry += f"\n   Abstract: {abstract}..."
+                  entry += f"\n   URL: {paper_url}"
+                  out.append(entry)
+              return "\n\n".join(out)
+          except _requests.exceptions.RequestException as e:
+              return f"Semantic Scholar API error: {e}"
+          except Exception as e:
+              return f"Paper search error: {e}"
+
       # ========== File Provenance (matching original) ==========
       @dataclass
       class FileProvenance:
@@ -362,14 +440,14 @@ steps:
               except Exception as e:
                   return f"Wander failed: {e}"
 
-          tools = [create_file, append_to_file, replace_in_file, read_file,
-                   list_files, execute_shell_command, _web_search_tool, wander_wrapper]
+          tools = [run_python, create_file, append_to_file, replace_in_file, read_file,
+                   list_files, _web_search_tool, search_papers, shell_command, wander_wrapper]
 
           agent = NPC(
               name=agent_name.replace(' ', '_').lower(),
               model=_model,
               provider=_provider,
-              primary_directive=agent_persona,
+              primary_directive=_alicanto_directive + "\n\n" + agent_persona,
               tools=tools
           )
 
@@ -379,6 +457,7 @@ steps:
           created_files = set()
           summary = {}
           major_step = 0
+          stall_count = 0  # consecutive steps with no filesystem change
 
           while major_step < _max_steps:
               # Check for skip/quit
@@ -401,37 +480,11 @@ steps:
               history_str = "\n".join(summarized_history)
               next_step_text = f"This is the next step suggested by your advisor. : BEGIN NEXT_STEP: {summary.get('next_step')} END NEXT STEP" if summary else ""
 
-              search_provider = os.environ.get('NPCSH_SEARCH_PROVIDER', 'duckduckgo')
-              initial_prompt = f"""Test the following hypothesis: '{hypothesis}' as related to the user query: '{user_query}'.
-      Only focus on your specific hypothesis, other agents are being tasked with other aspects of the problem.
-
-      Use bash commands to carry out research through the execute_shell_command.
-      Adjust files with `replace_in_file` and use `read_file` and `list_files` to verify file states and file creation.
-      Create files with create_file()
-
-      Test with execute_shell_command when needed
-      Get unstuck with wander_wrapper
-
-      When you have a definitive result, say RESEARCH_COMPLETE.
-
-      FILE PROVENANCE HISTORY:
-      {chr(10).join(provenance_summary)}
-
-      CURRENT FILES: {list(fs_before.keys())}
-
-      COMPLETE ACTION HISTORY:
-      BEGIN HISTORY
+              initial_prompt = f"""Hypothesis: '{hypothesis}'
+      Query: '{user_query}'
+      Files: {list(fs_before.keys())}
       {history_str}
-      END HISTORY
-
-      What specific action will you take next to test your hypothesis?
-      AVAILABLE TOOLS: create_file, append_to_file, replace_in_file, read_file, list_files, execute_shell_command, wander_wrapper, _web_search_tool.
-
-      Do not repeat actions. Use `_web_search_tool` with provider of {search_provider} to look up items if you are struggling.
-
-      {next_step_text}
-
-      Your goal is to research. To set up experiments, create figures, and produce data outputs in csvs for verification and reproducibility."""
+      {next_step_text}"""
 
               ui_state['log'].append(f"\033[90m  Major step {major_step + 1}\033[0m")
 
@@ -495,8 +548,16 @@ steps:
 
               fs_after = get_filesystem_state()
               new_files = set(fs_after.keys()) - set(fs_before.keys())
+              changed_files = {f for f in fs_after if fs_before.get(f) != fs_after.get(f)}
               if new_files:
                   ui_state['log'].append(f"  \033[32mNew files: {list(new_files)}\033[0m")
+                  stall_count = 0
+              elif changed_files:
+                  stall_count = 0
+              else:
+                  stall_count += 1
+                  if stall_count >= 3:
+                      ui_state['log'].append(f"  \033[33mStalled for {stall_count} steps, forcing wrap-up\033[0m")
 
               combined_thought = " ".join(all_thoughts)
               combined_action = " | ".join(filter(None, all_actions))
@@ -619,7 +680,7 @@ steps:
 
       Focus ONLY on the {next_section} section. Write 2-4 paragraphs of substantial academic content.
 
-      Available tools: replace_in_file, read_file, _web_search_tool"""
+      Available tools: replace_in_file, read_file, _web_search_tool, search_papers"""
 
               for micro in range(5):
                   if micro == 0:
@@ -743,7 +804,7 @@ steps:
       Use replace_in_file to make targeted improvements to paper.tex.
       Use read_file to check current state.
 
-      Available tools: replace_in_file, read_file, append_to_file, _web_search_tool"""
+      Available tools: replace_in_file, read_file, append_to_file, _web_search_tool, search_papers"""
 
           coord_messages = []
           for micro in range(8):
@@ -965,13 +1026,13 @@ steps:
               except Exception as e:
                   return f"Wander failed: {e}"
 
-          coord_tools = [create_file, append_to_file, replace_in_file, read_file,
-                         list_files, execute_shell_command, _web_search_tool, wander_wrapper_coord]
+          coord_tools = [run_python, create_file, append_to_file, replace_in_file, read_file,
+                         list_files, _web_search_tool, search_papers, shell_command, wander_wrapper_coord]
 
           coordinator = NPC(
               name="Alicanto",
               model=model, provider=provider,
-              primary_directive="You are Alicanto the mythical bird. You research topics iteratively by writing to LaTeX files and searching for more information.",
+              primary_directive=_alicanto_directive,
               tools=coord_tools
           )