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

npcsh-1.1.5.data/data/npcsh/npc_team/ots.jinx

@@ -0,0 +1,92 @@
+jinx_name: "ots"
+description: "Take screenshot and analyze with vision model"
+inputs:
+  - image_paths_args: "" # Optional comma-separated paths to image files for analysis.
+  - prompt: "" # The prompt for the LLM about the image(s).
+  - 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.
+  - stream: False # Whether to stream the output from the LLM.
+  - api_url: "" # API URL for the LLM.
+  - api_key: "" # API key for the LLM.
+steps:
+  - name: "analyze_screenshot_or_image"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.data.image import capture_screenshot
+      # Assuming NPCSH_VISION_MODEL and NPCSH_VISION_PROVIDER are accessible through _state or defaults
+      # For simplicity in Jinx, we'll use fallbacks or assume context will provide
+      
+      image_paths_args_str = context.get('image_paths_args')
+      user_prompt = context.get('prompt')
+      vision_model = context.get('vmodel')
+      vision_provider = context.get('vprovider')
+      stream_output = context.get('stream')
+      api_url = context.get('api_url')
+      api_key = context.get('api_key')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      image_paths = []
+      if image_paths_args_str and image_paths_args_str.strip():
+          for img_path_arg in image_paths_args_str.split(','):
+              full_path = os.path.abspath(os.path.expanduser(img_path_arg.strip()))
+              if os.path.exists(full_path):
+                  image_paths.append(full_path)
+              else:
+                  context['output'] = f"Error: Image file not found at {full_path}"
+                  context['messages'] = output_messages
+                  exit()
+      
+      if not image_paths:
+          screenshot_info = capture_screenshot(full=False)
+          if screenshot_info and "file_path" in screenshot_info:
+              image_paths.append(screenshot_info["file_path"])
+              print(f"Screenshot captured: {screenshot_info.get('filename', os.path.basename(screenshot_info['file_path']))}")
+          else:
+               context['output'] = "Error: Failed to capture screenshot."
+               context['messages'] = output_messages
+               exit()
+
+      if not image_paths:
+          context['output'] = "No valid images found or captured."
+          context['messages'] = output_messages
+          exit()
+
+      if not user_prompt or not user_prompt.strip():
+          # In a non-interactive Jinx, a default prompt is better than waiting for input
+          user_prompt = "Describe the image(s)."
+
+      # 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:
+          response_data = get_llm_response(
+              prompt=user_prompt,
+              model=vision_model,
+              provider=vision_provider,
+              messages=output_messages, # Pass current messages to LLM
+              images=image_paths,
+              stream=stream_output,
+              npc=current_npc,
+              api_url=api_url,
+              api_key=api_key
+          )
+          context['output'] = response_data.get('response')
+          context['messages'] = response_data.get('messages', output_messages)
+          context['model'] = vision_model
+          context['provider'] = vision_provider
+
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error during /ots command: {e}"
+          context['messages'] = output_messages

npcsh-1.1.5.data/data/npcsh/npc_team/plan.jinx

@@ -0,0 +1,33 @@
+jinx_name: "plan"
+description: "Execute a plan command"
+inputs:
+  - plan_description: "" # Description of the plan to execute.
+steps:
+  - name: "execute_plan"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.work.plan import execute_plan_command
+      
+      plan_description = context.get('plan_description')
+      output_messages = context.get('messages', [])
+      
+      if not plan_description or not plan_description.strip():
+          context['output'] = "Usage: /plan <description_of_plan>"
+          context['messages'] = output_messages
+          exit()
+      
+      try:
+          # Pass all current context as kwargs to execute_plan_command
+          result = execute_plan_command(command=plan_description, **context)
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Plan executed.')
+              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 executing plan: {e}"
+          context['messages'] = output_messages

npcsh-1.1.5.data/data/npcsh/npc_team/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-1.1.5.data/data/npcsh/npc_team/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-1.1.3.data/data/npcsh/npc_team/python_executor.jinx → npcsh-1.1.5.data/data/npcsh/npc_team/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-1.1.5.data/data/npcsh/npc_team/rag.jinx

@@ -0,0 +1,70 @@
+jinx_name: "rag"
+description: "Execute a RAG command using ChromaDB embeddings with optional file input (-f/--file)"
+inputs:
+  - query: "" # Required search query for RAG.
+  - file_paths: "" # Optional comma-separated file paths to include in RAG.
+  - vector_db_path: "~/npcsh_chroma.db" # Path to the ChromaDB vector database.
+  - emodel: "" # Embedding model to use. Defaults to NPCSH_EMBEDDING_MODEL or NPC's model.
+  - eprovider: "" # Embedding provider to use. Defaults to NPCSH_EMBEDDING_PROVIDER or NPC's provider.
+steps:
+  - name: "execute_rag"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.data.load import load_file_contents
+      from npcpy.memory.search import execute_rag_command
+      # Assuming NPCSH_EMBEDDING_MODEL and NPCSH_EMBEDDING_PROVIDER are accessible
+      
+      query = context.get('query')
+      file_paths_str = context.get('file_paths')
+      vector_db_path = context.get('vector_db_path')
+      embedding_model = context.get('emodel')
+      embedding_provider = context.get('eprovider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      file_paths = []
+      if file_paths_str and file_paths_str.strip():
+          file_paths = [os.path.abspath(os.path.expanduser(p.strip())) for p in file_paths_str.split(',')]
+      
+      if not query and not file_paths:
+          context['output'] = "Usage: /rag [-f file_path] <query>"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not embedding_model and current_npc and current_npc.model:
+          embedding_model = current_npc.model
+      if not embedding_provider and current_npc and current_npc.provider:
+          embedding_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not embedding_model: embedding_model = "nomic-ai/nomic-embed-text-v1.5" # Example default
+      if not embedding_provider: embedding_provider = "ollama" # Example default
+
+      try:
+          file_contents = []
+          for file_path in file_paths:
+              try:
+                  chunks = load_file_contents(file_path)
+                  file_name = os.path.basename(file_path)
+                  file_contents.extend([f"[{file_name}] {chunk}" for chunk in chunks])
+              except Exception as file_err:
+                  file_contents.append(f"Error processing file {file_path}: {str(file_err)}")
+          
+          result = execute_rag_command(
+              command=query,
+              vector_db_path=os.path.expanduser(vector_db_path),
+              embedding_model=embedding_model,
+              embedding_provider=embedding_provider,
+              file_contents=file_contents if file_paths else None,
+              **{k:v for k,v in context.items() if k not in ['messages', 'query', 'file_paths']} # Pass other context
+          )
+          context['output'] = result.get('response')
+          context['messages'] = result.get('messages', output_messages)
+      
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error executing RAG command: {e}"
+          context['messages'] = output_messages

npcsh-1.1.5.data/data/npcsh/npc_team/roll.jinx

@@ -0,0 +1,66 @@
+jinx_name: "roll"
+description: "Generate a video from a text prompt."
+inputs:
+  - prompt: "" # Required text prompt for video generation.
+  - num_frames: 125 # Number of frames for the video.
+  - width: 256 # Width of the video.
+  - height: 256 # Height of the video.
+  - output_path: "output.mp4" # Output file path for the video.
+  - vgmodel: "" # Video generation model to use. Defaults to NPCSH_VIDEO_GEN_MODEL or NPC's model.
+  - vgprovider: "" # Video generation provider to use. Defaults to NPCSH_VIDEO_GEN_PROVIDER or NPC's provider.
+steps:
+  - name: "generate_video"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.llm_funcs import gen_video
+      # Assuming NPCSH_VIDEO_GEN_MODEL and NPCSH_VIDEO_GEN_PROVIDER are accessible
+      
+      prompt = context.get('prompt')
+      num_frames = int(context.get('num_frames', 125)) # Ensure int type
+      width = int(context.get('width', 256)) # Ensure int type
+      height = int(context.get('height', 256)) # Ensure int type
+      output_path = context.get('output_path')
+      video_gen_model = context.get('vgmodel')
+      video_gen_provider = context.get('vgprovider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      
+      if not prompt or not prompt.strip():
+          context['output'] = "Usage: /roll <your prompt>"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not video_gen_model and current_npc and current_npc.model:
+          video_gen_model = current_npc.model
+      if not video_gen_provider and current_npc and current_npc.provider:
+          video_gen_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not video_gen_model: video_gen_model = "stable-video-diffusion" # Example default
+      if not video_gen_provider: video_gen_provider = "diffusers" # Example default
+
+      try:
+          result = gen_video(
+              prompt=prompt,
+              model=video_gen_model,
+              provider=video_gen_provider,
+              npc=current_npc,
+              num_frames=num_frames,
+              width=width,
+              height=height,
+              output_path=output_path,
+              **context.get('api_kwargs', {}) # Assuming api_kwargs might be passed
+          )
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Video generated.')
+              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 generating video: {e}"
+          context['messages'] = output_messages

npcsh-1.1.5.data/data/npcsh/npc_team/sample.jinx

@@ -0,0 +1,56 @@
+jinx_name: "sample"
+description: "Send a prompt directly to the LLM."
+inputs:
+  - prompt: "" # Required text prompt to send to the LLM.
+  - model: "" # LLM model to use. Defaults to NPC's model.
+  - provider: "" # LLM provider to use. Defaults to NPC's provider.
+steps:
+  - name: "send_prompt_to_llm"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.llm_funcs import get_llm_response
+      
+      prompt = context.get('prompt')
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      if not prompt or not prompt.strip():
+          context['output'] = "Usage: /sample <your prompt> [-m --model] model  [-p --provider] provider"
+          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:
+          result = get_llm_response(
+              prompt=prompt,
+              model=llm_model,
+              provider=llm_provider,
+              npc=current_npc,
+              **{k:v for k,v in context.items() if k not in ['messages', 'prompt', 'model', 'provider']} # Pass other context
+          )
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('response')
+              context['messages'] = result.get('messages', output_messages)
+              context['model'] = llm_model
+              context['provider'] = llm_provider
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error sampling LLM: {e}"
+          context['messages'] = output_messages

npcsh-1.1.5.data/data/npcsh/npc_team/search.jinx

@@ -0,0 +1,192 @@
+jinx_name: "search"
+description: "Execute web search or memory/KG search. Usage: /search [-m/-mem | -kg] <query>"
+inputs:
+  - query: "" # Required search query.
+  - search_type: "web" # Type of search: "web", "memory", or "kg".
+  - sprovider: "" # Search provider for web search. Defaults to NPCSH_SEARCH_PROVIDER.
+  - history_db_path: "~/npcsh_history.db" # Path to the command history database for memory/KG search.
+steps:
+  - name: "execute_search"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.data.web import search_web
+      from npcpy.memory.command_history import CommandHistory, load_kg_from_db, save_kg_to_db # For KG search
+      from npcsh._state import get_relevant_memories # For memory search
+      # Assuming NPCSH_SEARCH_PROVIDER is accessible
+
+      query = context.get('query')
+      search_type = context.get('search_type')
+      search_provider = context.get('sprovider')
+      history_db_path = context.get('history_db_path')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      current_team = context.get('team')
+      
+      if not query or not query.strip():
+          context['output'] = (
+              "Usage:\n"
+              "  /search <query>              - Web search\n"
+              "  /search -m <query>           - Memory search\n"
+              "  /search -kg <query>          - Knowledge graph search"
+          )
+          context['messages'] = output_messages
+          exit()
+
+      def search_memories(query_str, current_context, output_msgs):
+          command_history = current_context.get('command_history')
+          if not command_history:
+              db_path = os.path.expanduser(current_context.get("history_db_path", "~/npcsh_history.db"))
+              try:
+                  command_history = CommandHistory(db_path)
+                  current_context['command_history'] = command_history
+              except Exception as e:
+                  return {"output": f"Error connecting to history: {e}", "messages": output_msgs}
+          
+          npc_name = current_context.get('npc_name', '__none__')
+          team_name = current_context.get('team_name', '__none__')
+          current_path = current_context.get('current_path', os.getcwd())
+          state = current_context.get('state')
+          
+          try:
+              memories = get_relevant_memories(
+                  command_history=command_history,
+                  npc_name=npc_name,
+                  team_name=team_name,
+                  path=current_path,
+                  query=query_str,
+                  max_memories=10,
+                  state=state
+              )
+              
+              if not memories:
+                  output = f"No memories found for query: '{query_str}'"
+              else:
+                  output = f"Found {len(memories)} memories:\n\n"
+                  for i, mem in enumerate(memories, 1):
+                      final_mem = (
+                          mem.get('final_memory') or 
+                          mem.get('initial_memory')
+                      )
+                      timestamp = mem.get('timestamp', 'unknown')
+                      output += f"{i}. [{timestamp}] {final_mem}\n"
+              
+              return {"output": output, "messages": output_msgs}
+              
+          except Exception as e:
+              traceback.print_exc()
+              return {"output": f"Error searching memories: {e}", "messages": output_msgs}
+
+      def search_knowledge_graph(query_str, current_context, output_msgs):
+          command_history = current_context.get('command_history')
+          if not command_history:
+              db_path = os.path.expanduser(current_context.get("history_db_path", "~/npcsh_history.db"))
+              try:
+                  command_history = CommandHistory(db_path)
+                  current_context['command_history'] = command_history
+              except Exception as e:
+                  return {"output": f"Error connecting to history: {e}", "messages": output_msgs}
+          
+          npc_name = current_context.get('npc_name', '__none__')
+          team_name = current_context.get('team_name', '__none__')
+          current_path = current_context.get('current_path', os.getcwd())
+          
+          try:
+              engine = command_history.engine
+              kg = load_kg_from_db(
+                  engine, 
+                  team_name, 
+                  npc_name, 
+                  current_path
+              )
+              
+              if not kg or not kg.get('facts'):
+                  return {
+                      "output": (
+                          f"No knowledge graph found for current scope.\n"
+                          f"Scope: Team='{team_name}', "
+                          f"NPC='{npc_name}', Path='{current_path}'"
+                      ),
+                      "messages": output_msgs
+                  }
+              
+              query_lower = query_str.lower()
+              matching_facts = []
+              matching_concepts = []
+              
+              for fact in kg.get('facts', []):
+                  statement = fact.get('statement', '').lower()
+                  if query_lower in statement:
+                      matching_facts.append(fact)
+              
+              for concept in kg.get('concepts', []):
+                  name = concept.get('name', '').lower()
+                  desc = concept.get('description', '').lower()
+                  if query_lower in name or query_lower in desc:
+                      matching_concepts.append(concept)
+              
+              output = f"Knowledge Graph Search Results for '{query_str}':\n\n"
+              
+              if matching_facts:
+                  output += f"## Facts ({len(matching_facts)}):\n"
+                  for i, fact in enumerate(matching_facts, 1):
+                      output += f"{i}. {fact.get('statement')}\n"
+                  output += "\n"
+              
+              if matching_concepts:
+                  output += f"## Concepts ({len(matching_concepts)}):\n"
+                  for i, concept in enumerate(matching_concepts, 1):
+                      name = concept.get('name')
+                      desc = concept.get('description', '')
+                      output += f"{i}. {name}: {desc}\n"
+              
+              if not matching_facts and not matching_concepts:
+                  output += "No matching facts or concepts found."
+              
+              return {"output": output, "messages": output_msgs}
+              
+          except Exception as e:
+              traceback.print_exc()
+              return {"output": f"Error searching KG: {e}", "messages": output_msgs}
+
+      def search_web_default(query_str, current_context, output_msgs):
+          # Fallback for search_provider if not explicitly set in Jinx inputs
+          current_search_provider = current_context.get('sprovider')
+          # If NPCSH_SEARCH_PROVIDER is accessible, use it. Otherwise, a default.
+          # For Jinx, let's just use a hardcoded default if not provided.
+          if not current_search_provider:
+              current_search_provider = "google" # Example default
+
+          # Assuming render_markdown is accessible
+          # render_markdown(f'- Searching {current_search_provider} for "{query_str}"') # Not directly supported in Jinx steps
+
+          try:
+              search_results = search_web(query_str, provider=current_search_provider)
+              output = (
+                  "\n".join([f"- {res}" for res in search_results]) 
+                  if search_results 
+                  else "No results found."
+              )
+          except Exception as e:
+              traceback.print_exc()
+              output = f"Error during web search: {e}"
+          
+          return {"output": output, "messages": output_msgs}
+
+
+      # Populate npc_name, team_name, current_path for search functions
+      context['npc_name'] = current_npc.name if isinstance(current_npc, type(None).__class__) else "__none__"
+      context['team_name'] = current_team.name if current_team else "__none__"
+      context['current_path'] = os.getcwd() # Or get from context if available
+
+      final_result = None
+      if search_type == 'memory':
+          final_result = search_memories(query, context, output_messages)
+      elif search_type == 'kg':
+          final_result = search_knowledge_graph(query, context, output_messages)
+      else:
+          final_result = search_web_default(query, context, output_messages)
+
+      context['output'] = final_result.get('output')
+      context['messages'] = final_result.get('messages', output_messages)

npcsh-1.1.5.data/data/npcsh/npc_team/serve.jinx

@@ -0,0 +1,29 @@
+jinx_name: "serve"
+description: "Serve an NPC Team"
+inputs:
+  - port: 5337 # The port to run the Flask server on.
+  - cors: "" # Comma-separated CORS origins.
+steps:
+  - name: "start_flask_server"
+    engine: "python"
+    code: |
+      from npcpy.serve import start_flask_server
+      
+      port = context.get('port')
+      cors_str = context.get('cors')
+      output_messages = context.get('messages', [])
+
+      cors_origins = None
+      if cors_str and cors_str.strip():
+          cors_origins = [origin.strip() for origin in cors_str.split(",")]
+
+      # start_flask_server blocks, so this will hold the Jinx until the server is stopped.
+      # In a real-world scenario, you might want to run this in a separate process
+      # or have a non-blocking server start.
+      start_flask_server(
+          port=int(port), # Ensure port is an integer
+          cors_origins=cors_origins,
+      )
+
+      context['output'] = "NPC Team server started. Execution of this jinx will pause until the server is stopped."
+      context['messages'] = output_messages