npcsh 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

npcsh/_state.py

@@ -1875,17 +1875,15 @@ def execute_slash_command(command: str,
     all_command_parts = shlex.split(command)
     command_name = all_command_parts[0].lstrip('/')
     
-  
     if command_name in ['n', 'npc']:
         npc_to_switch_to = all_command_parts[1] if len(all_command_parts) > 1 else None
         if npc_to_switch_to and state.team and npc_to_switch_to in state.team.npcs:
             state.npc = state.team.npcs[npc_to_switch_to]
-            return state, f"Switched to NPC: {npc_to_switch_to}"
+            return state, {"output": f"Switched to NPC: {npc_to_switch_to}", "messages": state.messages}
         else:
             available_npcs = list(state.team.npcs.keys()) if state.team else []
-            return state, colored(f"NPC '{npc_to_switch_to}' not found. Available NPCs: {', '.join(available_npcs)}", "red")
+            return state, {"output": colored(f"NPC '{npc_to_switch_to}' not found. Available NPCs: {', '.join(available_npcs)}", "red"), "messages": state.messages}
     
-  
     handler = router.get_route(command_name)
     if handler:
         parsed_flags, positional_args = parse_generic_command_flags(all_command_parts[1:])
@@ -1901,12 +1899,10 @@ def execute_slash_command(command: str,
             'positional_args': positional_args,
             'plonk_context': state.team.shared_context.get('PLONK_CONTEXT') if state.team and hasattr(state.team, 'shared_context') else None,
             
-          
             'model': state.npc.model if isinstance(state.npc, NPC) and state.npc.model else state.chat_model,
             'provider': state.npc.provider if isinstance(state.npc, NPC) and state.npc.provider else state.chat_provider,
             'npc': state.npc,
             
-          
             'sprovider': state.search_provider,
             'emodel': state.embedding_model,
             'eprovider': state.embedding_provider,
@@ -1927,7 +1923,6 @@ def execute_slash_command(command: str,
 
         render_markdown(f'- Calling {command_name} handler {kwarg_part} ')
         
-      
         if 'model' in normalized_flags and 'provider' not in normalized_flags:
             inferred_provider = lookup_provider(normalized_flags['model'])
             if inferred_provider:
@@ -1943,20 +1938,22 @@ def execute_slash_command(command: str,
         handler_kwargs.update(normalized_flags)
         
         try:
-            result_dict = handler(command=command, 
-                                  **handler_kwargs)
-            if isinstance(result_dict, dict):
-                state.messages = result_dict.get("messages", state.messages)
-                return state, result_dict
+            result = handler(command=command, **handler_kwargs)
+            
+            if isinstance(result, dict):
+                state.messages = result.get("messages", state.messages)
+                return state, result
+            elif isinstance(result, str):
+                return state, {"output": result, "messages": state.messages}
             else:
-                return state, result_dict
+                return state, {"output": str(result), "messages": state.messages}
+                
         except Exception as e:
             import traceback
             print(f"Error executing slash command '{command_name}':", file=sys.stderr)
             traceback.print_exc()
-            return state, colored(f"Error executing slash command '{command_name}': {e}", "red")
+            return state, {"output": colored(f"Error executing slash command '{command_name}': {e}", "red"), "messages": state.messages}
 
-  
     active_npc = state.npc if isinstance(state.npc, NPC) else None
     jinx_to_execute = None
     executor = None
@@ -1970,14 +1967,12 @@ def execute_slash_command(command: str,
     if jinx_to_execute:
         args = all_command_parts[1:]
         try:
-          
             input_values = {}
             if hasattr(jinx_to_execute, 'inputs') and jinx_to_execute.inputs:
                 for i, input_name in enumerate(jinx_to_execute.inputs):
                     if i < len(args):
                         input_values[input_name] = args[i]
             
-          
             if isinstance(executor, NPC):
                 jinx_output = jinx_to_execute.execute(
                     input_values=input_values,
@@ -1994,25 +1989,24 @@ def execute_slash_command(command: str,
                 )
             if isinstance(jinx_output, dict) and 'messages' in jinx_output:
                 state.messages = jinx_output['messages']
-                return state, str(jinx_output.get('output', jinx_output))
+                return state, jinx_output
             elif isinstance(jinx_output, dict):
-                return state, str(jinx_output.get('output', jinx_output))
-            else:
                 return state, jinx_output
+            else:
+                return state, {"output": str(jinx_output), "messages": state.messages}
             
         except Exception as e:
             import traceback
             print(f"Error executing jinx '{command_name}':", file=sys.stderr)
             traceback.print_exc()
-            return state, colored(f"Error executing jinx '{command_name}': {e}", "red")
+            return state, {"output": colored(f"Error executing jinx '{command_name}': {e}", "red"), "messages": state.messages}
+    
     if state.team and command_name in state.team.npcs:
         new_npc = state.team.npcs[command_name]
         state.npc = new_npc
-        return state, f"Switched to NPC: {new_npc.name}"
-
-    return state, colored(f"Unknown slash command, jinx, or NPC: {command_name}", "red")
-
+        return state, {"output": f"Switched to NPC: {new_npc.name}", "messages": state.messages}
 
+    return state, {"output": colored(f"Unknown slash command, jinx, or NPC: {command_name}", "red"), "messages": state.messages}
 
 
 def process_pipeline_command(
@@ -2190,7 +2184,7 @@ def check_mode_switch(command:str , state: ShellState):
 def execute_command(
     command: str,
     state: ShellState,
-    review = True, 
+    review = False, 
     router = None,
     command_history = None,
     ) -> Tuple[ShellState, Any]:
@@ -2319,7 +2313,6 @@ def execute_command(
         return state, response['response']
 
 def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
-
     setup_npcsh_config()
 
     db_path = os.getenv("NPCSH_DB_PATH", HISTORY_DB_DEFAULT_PATH)
@@ -2327,14 +2320,11 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     os.makedirs(os.path.dirname(db_path), exist_ok=True)
     command_history = CommandHistory(db_path)
 
-
     if not is_npcsh_initialized():
         print("Initializing NPCSH...")
         initialize_base_npcs_if_needed(db_path)
         print("NPCSH initialization complete. Restart or source ~/.npcshrc.")
 
-
-
     try:
         history_file = setup_readline()
         atexit.register(save_readline_history)
@@ -2397,7 +2387,6 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
             team_dir = global_team_path
             default_forenpc_name = "sibiji"            
         
-
     team_ctx = {}
     team_ctx_path = get_team_ctx_path(team_dir)
     if team_ctx_path:
@@ -2410,34 +2399,12 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
   
     print('forenpc_name:', forenpc_name)
 
-    if team_ctx.get("use_global_jinxs", False):
-        jinxs_dir = os.path.expanduser("~/.npcsh/npc_team/jinxs")
-    else:
-        jinxs_dir = os.path.join(team_dir, "jinxs")
-        
-    jinxs_list = load_jinxs_from_directory(jinxs_dir)
-    jinxs_dict = {jinx.jinx_name: jinx for jinx in jinxs_list}
-
-    forenpc_obj = None
     forenpc_path = os.path.join(team_dir, f"{forenpc_name}.npc")
-
     print('forenpc_path:', forenpc_path)
 
-    if os.path.exists(forenpc_path):
-        forenpc_obj = NPC(file = forenpc_path, 
-                          jinxs=jinxs_list, 
-                          db_conn=command_history.engine)
-        if forenpc_obj.model is None:
-            forenpc_obj.model= team_ctx.get("model", initial_state.chat_model)
-        if forenpc_obj.provider is None:
-            forenpc_obj.provider=team_ctx.get('provider', initial_state.chat_provider)
-            
-    else:
-        print(f"Warning: Forenpc file '{forenpc_name}.npc' not found in {team_dir}.")
-
-    team = Team(team_path=team_dir, 
-                forenpc=forenpc_obj, 
-                jinxs=jinxs_dict)
+    team = Team(team_path=team_dir, db_conn=command_history.engine)
+    
+    forenpc_obj = team.forenpc if hasattr(team, 'forenpc') and team.forenpc else None
 
     for npc_name, npc_obj in team.npcs.items():
         if not npc_obj.model:
@@ -2445,12 +2412,12 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
         if not npc_obj.provider:
             npc_obj.provider = initial_state.chat_provider
 
-  
     if team.forenpc and isinstance(team.forenpc, NPC):
         if not team.forenpc.model:
             team.forenpc.model = initial_state.chat_model
         if not team.forenpc.provider:
             team.forenpc.provider = initial_state.chat_provider
+    
     team_name_from_ctx = team_ctx.get("name")
     if team_name_from_ctx:
         team.name = team_name_from_ctx
@@ -2464,11 +2431,19 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     else:
         team.name = "npcsh"
 
-
     return command_history, team, forenpc_obj
 
-
-
+def initialize_router_with_jinxs(team, router):
+    """Load global and team Jinxs into router"""
+    global_jinxs_dir = os.path.expanduser("~/.npcsh/npc_team/jinxs")
+    router.load_jinx_routes(global_jinxs_dir)
+    
+    if team and team.team_path:
+        team_jinxs_dir = os.path.join(team.team_path, "jinxs")
+        if os.path.exists(team_jinxs_dir):
+            router.load_jinx_routes(team_jinxs_dir)
+    
+    return router
                 
 from npcpy.memory.memory_processor import  memory_approval_ui
 from npcpy.ft.memory_trainer import MemoryTrainer
@@ -2688,13 +2663,22 @@ def process_result(
     result_state.attachments = None
 
     final_output_str = None
-    output_content = output.get('output') if isinstance(output, dict) else output
-    model_for_stream = output.get('model', active_npc.model) if isinstance(output, dict) else active_npc.model
-    provider_for_stream = output.get('provider', active_npc.provider) if isinstance(output, dict) else active_npc.provider
+    
+    if isinstance(output, dict):
+        output_content = output.get('output')
+        model_for_stream = output.get('model', active_npc.model)
+        provider_for_stream = output.get('provider', active_npc.provider)
+    else:
+        output_content = output
+        model_for_stream = active_npc.model
+        provider_for_stream = active_npc.provider
 
     print('\n')
     if user_input == '/help':
-        render_markdown(output.get('output'))
+        if isinstance(output_content, str):
+            render_markdown(output_content)
+        else:
+            render_markdown(str(output_content))
     elif result_state.stream_output:
         final_output_str = print_and_process_stream_with_markdown(
             output_content, 

npcsh/npc_team/jinxs/{python_executor.jinx → code/python.jinx}

@@ -1,4 +1,4 @@
-jinx_name: python_executor
+jinx_name: python
 description: Execute scripts with python. You must set the ultimate result as the "output"
   variable. It MUST be a string. 
   Do not add unnecessary print statements. 

npcsh/npc_team/jinxs/{bash_executer.jinx → code/sh.jinx}

@@ -1,4 +1,4 @@
-jinx_name: bash_executor
+jinx_name: sh
 description: Execute bash queries. Should be used to grep for file contents, list directories, explore information to answer user questions more practically.
 inputs:
 - bash_command

npcsh/npc_team/jinxs/code/sql.jinx

@@ -0,0 +1,18 @@
+jinx_name: sql_executor
+description: Execute queries on the ~/npcsh_history.db to pull data. The database
+  contains only information about conversations and other user-provided data. It does
+  not store any information about individual files. Avoid using percent signs unless absolutely necessary. Returns a LLM summary so no post-summary is required
+inputs:
+- sql_query
+- user_query
+- interpret: true
+steps:
+  - engine: python
+    code: |
+      import pandas as pd
+      query = "{{ sql_query }}"
+      try:
+        df = pd.read_sql_query(query, npc.db_conn)
+      except Exception as e:
+        df = pd.DataFrame({'Error': [str(e)]})
+      output = df.to_string()

npcsh/npc_team/jinxs/modes/alicanto.jinx

@@ -0,0 +1,88 @@
+jinx_name: "alicanto"
+description: "Conduct deep research with multiple perspectives, identifying gold insights and cliff warnings"
+inputs:
+  - query: "" # Required research query.
+  - num_npcs: 5 # Number of NPCs to involve in research.
+  - depth: 3 # Depth of research.
+  - model: "" # LLM model to use. Defaults to NPCSH_CHAT_MODEL or NPC's model.
+  - provider: "" # LLM provider to use. Defaults to NPCSH_CHAT_PROVIDER or NPC's provider.
+  - max_steps: 20 # Maximum number of steps in Alicanto research.
+  - skip_research: True # Whether to skip the research phase.
+  - exploration: "" # Exploration factor (float).
+  - creativity: "" # Creativity factor (float).
+  - format: "" # Output format (report, summary, full).
+steps:
+  - name: "conduct_alicanto_research"
+    engine: "python"
+    code: |
+      import traceback
+      import logging
+      from npcsh.alicanto import alicanto
+      # Assuming NPCSH_CHAT_MODEL and NPCSH_CHAT_PROVIDER are accessible
+
+      query = context.get('query')
+      num_npcs = int(context.get('num_npcs', 5)) # Ensure int type
+      depth = int(context.get('depth', 3)) # Ensure int type
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      max_steps = int(context.get('max_steps', 20)) # Ensure int type
+      skip_research = context.get('skip_research', True)
+      exploration_factor = context.get('exploration')
+      creativity_factor = context.get('creativity')
+      output_format = context.get('format')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      
+      if not query or not query.strip():
+          context['output'] = "Usage: /alicanto <research query> [--num-npcs N] [--depth N] [--exploration 0.3] [--creativity 0.5] [--format report|summary|full]"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not llm_model and current_npc and current_npc.model:
+          llm_model = current_npc.model
+      if not llm_provider and current_npc and current_npc.provider:
+          llm_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      # Assuming NPCSH_CHAT_MODEL and NPCSH_CHAT_PROVIDER exist and are imported implicitly or set by environment
+      # Hardcoding defaults for demonstration if not available through NPC or _state
+      if not llm_model: llm_model = "gemini-1.5-pro" 
+      if not llm_provider: llm_provider = "gemini" 
+
+      try:
+          logging.info(f"Starting Alicanto research on: {query}")
+
+          alicanto_kwargs = {
+              'query': query,
+              'num_npcs': num_npcs,
+              'depth': depth,
+              'model': llm_model,
+              'provider': llm_provider, 
+              'max_steps': max_steps,
+              'skip_research': skip_research,
+          }
+
+          if exploration_factor: alicanto_kwargs['exploration_factor'] = float(exploration_factor)
+          if creativity_factor: alicanto_kwargs['creativity_factor'] = float(creativity_factor)
+          if output_format: alicanto_kwargs['output_format'] = output_format
+
+          result = alicanto(**alicanto_kwargs)
+          
+          output_result = ""
+          if isinstance(result, dict):
+              if "integration" in result:
+                  output_result = result["integration"]
+              else:
+                  output_result = "Alicanto research completed. Full results available in returned data."
+          else:
+              output_result = str(result)
+              
+          context['output'] = output_result
+          context['messages'] = output_messages
+          context['alicanto_result'] = result # Store full result in context
+      except Exception as e:
+          traceback.print_exc()
+          logging.error(f"Error during Alicanto research: {e}")
+          context['output'] = f"Error during Alicanto research: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/corca.jinx

@@ -0,0 +1,28 @@
+jinx_name: "corca"
+description: "Enter the Corca MCP-powered agentic shell. Usage: /corca [--mcp-server-path path]"
+inputs:
+  - command: "/corca" # The full command string, e.g., "/corca --mcp-server-path /tmp/mcp"
+steps:
+  - name: "enter_corca"
+    engine: "python"
+    code: |
+      # Assume npcsh._state and enter_corca_mode are accessible in the environment
+
+      from npcsh._state import initial_state, setup_shell 
+      from npcsh.corca import enter_corca_mode
+
+
+      full_command_str = context.get('command')
+      output_messages = context.get('messages', [])
+      
+      command_history, team, default_npc = setup_shell()
+      
+      result = enter_corca_mode(
+          command=full_command_str, 
+          command_history=command_history, 
+          shell_state=initial_state,
+          **context # Pass all context as kwargs to enter_corca_mode as it expects
+      )
+      
+      context['output'] = result.get('output', 'Entered Corca mode.')
+      context['messages'] = result.get('messages', output_messages)

npcsh/npc_team/jinxs/modes/guac.jinx

@@ -0,0 +1,46 @@
+jinx_name: "guac"
+description: "Enter guac mode for plotting and data visualization."
+inputs:
+  - config_dir: "" # Optional configuration directory.
+  - plots_dir: "" # Optional directory for plots.
+  - refresh_period: 100 # Refresh period for guac mode.
+  - lang: "" # Language setting for guac mode.
+steps:
+  - name: "enter_guac"
+    engine: "python"
+    code: |
+      import os
+      from sqlalchemy import create_engine
+      from npcpy.npc_compiler import NPC, Team
+      from npcsh.guac import enter_guac_mode
+      
+      config_dir = context.get('config_dir')
+      plots_dir = context.get('plots_dir')
+      refresh_period = context.get('refresh_period')
+      lang = context.get('lang')
+      output_messages = context.get('messages', [])
+      
+      db_path = os.path.expanduser('~/npcsh_history.db')
+      db_conn = create_engine(f'sqlite:///{db_path}')
+      
+      npc_file = os.path.expanduser('~/.npcsh/guac/npc_team/guac.npc')
+      npc_team_dir = os.path.expanduser('~/.npcsh/guac/npc_team/')
+      
+      # Ensure directories exist for guac NPC/Team
+      os.makedirs(os.path.dirname(npc_file), exist_ok=True)
+      
+      guac_npc = NPC(file=npc_file, db_conn=db_conn)
+      guac_team = Team(npc_team_dir, db_conn=db_conn)
+      
+      enter_guac_mode(
+          npc=guac_npc, 
+          team=guac_team, 
+          config_dir=config_dir, 
+          plots_dir=plots_dir,
+          npc_team_dir=npc_team_dir,
+          refresh_period=int(refresh_period), # Ensure int type
+          lang=lang
+      )
+      
+      context['output'] = 'Exiting Guac Mode'
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/plonk.jinx

@@ -0,0 +1,57 @@
+jinx_name: "plonk"
+description: "Use vision model to interact with GUI. Usage: /plonk <task description>"
+inputs:
+  - task_description: "" # Required task description for GUI interaction.
+  - vmodel: "" # Vision model to use. Defaults to NPCSH_VISION_MODEL or NPC's model.
+  - vprovider: "" # Vision model provider. Defaults to NPCSH_VISION_PROVIDER or NPC's provider.
+steps:
+  - name: "execute_plonk"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.plonk import execute_plonk_command, format_plonk_summary
+      # Assuming NPCSH_VISION_MODEL and NPCSH_VISION_PROVIDER are accessible
+      
+      task_description = context.get('task_description')
+      vision_model = context.get('vmodel')
+      vision_provider = context.get('vprovider')
+      plonk_context = context.get('plonk_context') # Passed from original context
+      current_npc = context.get('npc')
+      output_messages = context.get('messages', [])
+      
+      if not task_description or not task_description.strip():
+          context['output'] = "Usage: /plonk <task_description> [--vmodel model_name] [--vprovider provider_name]"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not vision_model and current_npc and current_npc.model:
+          vision_model = current_npc.model
+      if not vision_provider and current_npc and current_npc.provider:
+          vision_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not vision_model: vision_model = "gemini-1.5-pro-vision" # Example default
+      if not vision_provider: vision_provider = "gemini" # Example default
+
+      try:
+          summary_data = execute_plonk_command(
+              request=task_description,
+              model=vision_model,
+              provider=vision_provider,
+              npc=current_npc,
+              plonk_context=plonk_context,
+              debug=True # Assuming debug is often desired for plonk
+          )        
+          
+          if summary_data and isinstance(summary_data, list):
+              output_report = format_plonk_summary(summary_data)
+              context['output'] = output_report
+          else:
+              context['output'] = "Plonk command did not complete within the maximum number of iterations."
+
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error executing plonk command: {e}"
+      
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/pti.jinx

@@ -0,0 +1,28 @@
+jinx_name: "pti"
+description: "Enter Pardon-The-Interruption mode for human-in-the-loop reasoning."
+inputs:
+  - command_args: "" # The full command string or specific arguments for PTI mode.
+steps:
+  - name: "enter_pti"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.pti import enter_pti_mode
+      
+      command_args = context.get('command_args', '') # The full command string from router
+      output_messages = context.get('messages', [])
+      
+      try:
+          # enter_pti_mode likely expects the full command string for its own parsing
+          result = enter_pti_mode(command=command_args, **context)
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Entered PTI mode.')
+              context['messages'] = result.get('messages', output_messages)
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error entering pti mode: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/spool.jinx

@@ -0,0 +1,40 @@
+jinx_name: "spool"
+description: "Enter interactive chat (spool) mode"
+inputs: [] # Spool mode typically takes its parameters directly from the environment/kwargs
+steps:
+  - name: "enter_spool"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.npc_compiler import NPC, Team
+      from npcsh.spool import enter_spool_mode
+      
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      current_team = context.get('team')
+
+      try:
+          # Handle potential string NPC name if passed from CLI
+          if isinstance(current_npc, str) and current_team:
+              npc_name = current_npc
+              if npc_name in current_team.npcs:
+                  current_npc = current_team.npcs[npc_name]
+              else:
+                  context['output'] = f"Error: NPC '{npc_name}' not found in team. Available NPCs: {', '.join(current_team.npcs.keys())}"
+                  context['messages'] = output_messages
+                  exit()
+          context['npc'] = current_npc # Ensure the NPC object is updated in context
+          
+          result = enter_spool_mode(**context) # Pass all context as kwargs
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Exited Spool Mode.')
+              context['messages'] = result.get('messages', output_messages)
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error entering spool mode: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/wander.jinx

@@ -0,0 +1,81 @@
+jinx_name: "wander"
+description: "Enter wander mode (experimental)"
+inputs:
+  - problem: "" # The problem to wander about.
+  - environment: "" # Optional environment for wander mode.
+  - low_temp: 0.5 # Low temperature setting for LLM.
+  - high_temp: 1.9 # High temperature setting for LLM.
+  - interruption_likelihood: 1.0 # Likelihood of interruption.
+  - sample_rate: 0.4 # Sample rate.
+  - n_high_temp_streams: 5 # Number of high temperature streams.
+  - include_events: False # Whether to include events.
+  - num_events: 3 # Number of events to include.
+steps:
+  - name: "enter_wander"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.wander import enter_wander_mode
+      
+      problem = context.get('problem')
+      environment = context.get('environment')
+      low_temp = float(context.get('low_temp', 0.5)) # Ensure float type
+      high_temp = float(context.get('high_temp', 1.9)) # Ensure float type
+      interruption_likelihood = float(context.get('interruption_likelihood', 1.0)) # Ensure float type
+      sample_rate = float(context.get('sample_rate', 0.4)) # Ensure float type
+      n_high_temp_streams = int(context.get('n_high_temp_streams', 5)) # Ensure int type
+      include_events = context.get('include_events', False) # Boolean type
+      num_events = int(context.get('num_events', 3)) # Ensure int type
+      
+      current_npc = context.get('npc')
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      output_messages = context.get('messages', [])
+
+      if not problem or not problem.strip():
+          context['output'] = "Usage: /wander <problem> [key=value...]"
+          context['messages'] = output_messages
+          exit()
+      
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not llm_model and current_npc and current_npc.model:
+          llm_model = current_npc.model
+      if not llm_provider and current_npc and current_npc.provider:
+          llm_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not llm_model: llm_model = "gemini-1.5-pro" # Example default
+      if not llm_provider: llm_provider = "gemini" # Example default
+
+      try:
+          mode_args = {
+              'problem': problem,
+              'npc': current_npc,
+              'model': llm_model,
+              'provider': llm_provider,
+              'environment': environment,
+              'low_temp': low_temp,
+              'high_temp': high_temp,
+              'interruption_likelihood': interruption_likelihood,
+              'sample_rate': sample_rate,
+              'n_high_temp_streams': n_high_temp_streams,
+              'include_events': include_events,
+              'num_events': num_events
+          }
+          
+          result = enter_wander_mode(**mode_args)
+          
+          output_result = ""
+          if isinstance(result, list) and result:
+              output_result = result[-1].get("insight", "Wander mode session complete.")
+          else:
+              output_result = str(result) if result else "Wander mode session complete."
+              
+          output_messages.append({"role": "assistant", "content": output_result})
+          context['output'] = output_result
+          context['messages'] = output_messages
+          
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error during wander mode: {e}"
+          context['messages'] = output_messages