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

npcsh/npc_team/jinxs/modes/yap.jinx

@@ -0,0 +1,25 @@
+jinx_name: "yap"
+description: "Enter voice chat (yap) mode"
+inputs: [] # Yap mode takes its parameters directly from the environment/kwargs
+steps:
+  - name: "enter_yap"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.yap import enter_yap_mode
+      
+      output_messages = context.get('messages', [])
+
+      try:
+          result = enter_yap_mode(**context) # Pass all context as kwargs
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Exited Yap 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 yap mode: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/breathe.jinx

@@ -0,0 +1,20 @@
+jinx_name: "breathe"
+description: "Condense context on a regular cadence"
+inputs: [] # The breathe command takes all relevant context from the NPC's environment
+steps:
+  - name: "condense_context"
+    engine: "python"
+    code: |
+      from npcpy.llm_funcs import breathe
+      
+      output_messages = context.get('messages', [])
+
+      # Pass all current context as kwargs to breathe
+      result = breathe(**context) 
+      
+      if isinstance(result, dict):
+          context['output'] = result.get('output', 'Context condensed.')
+          context['messages'] = result.get('messages', output_messages)
+      else:
+          context['output'] = "Context condensation process initiated."
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/core/build.jinx

@@ -0,0 +1,65 @@
+jinx_name: "build"
+description: "Build deployment artifacts for NPC team"
+inputs:
+  - target: "flask" # The type of deployment target (e.g., flask, docker, cli, static).
+  - output: "./build" # The output directory for built artifacts.
+  - team: "./npc_team" # The path to the NPC team directory.
+  - port: 5337 # The port for flask server builds.
+  - cors: "" # Comma-separated CORS origins for flask server builds.
+steps:
+  - name: "execute_build"
+    engine: "python"
+    code: |
+      import os
+      
+      # Assume these build functions are available in the execution environment
+      # from a larger project context, e.g., from npcpy.build_funcs
+      try:
+          from npcpy.build_funcs import (
+              build_flask_server,
+              build_docker_compose,
+              build_cli_executable,
+              build_static_site,
+          )
+      except ImportError:
+          # Provide mock functions for demonstration or error handling
+          def build_flask_server(config, **kwargs): return {"output": f"Mock build flask: {config}", "messages": []}
+          def build_docker_compose(config, **kwargs): return {"output": f"Mock build docker: {config}", "messages": []}
+          def build_cli_executable(config, **kwargs): return {"output": f"Mock build cli: {config}", "messages": []}
+          def build_static_site(config, **kwargs): return {"output": f"Mock build static: {config}", "messages": []}
+
+      target = context.get('target')
+      output_dir = context.get('output')
+      team_path = context.get('team')
+      port = context.get('port')
+      cors_origins_str = context.get('cors')
+      
+      cors_origins = [origin.strip() for origin in cors_origins_str.split(',')] if cors_origins_str.strip() else None
+
+      build_config = {
+          'team_path': os.path.abspath(os.path.expanduser(team_path)),
+          'output_dir': os.path.abspath(os.path.expanduser(output_dir)),
+          'target': target,
+          'port': port,
+          'cors_origins': cors_origins,
+      }
+      
+      builders = {
+          'flask': build_flask_server,
+          'docker': build_docker_compose,
+          'cli': build_cli_executable,
+          'static': build_static_site,
+      }
+      
+      output_messages = context.get('messages', [])
+      output_result = ""
+
+      if target not in builders:
+          output_result = f"Unknown target: {target}. Available: {list(builders.keys())}"
+      else:
+          result = builders[target](build_config, messages=output_messages)
+          output_result = result.get('output', 'Build command executed.')
+          output_messages = result.get('messages', output_messages) # Update messages from builder call
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/core/compile.jinx

@@ -0,0 +1,50 @@
+jinx_name: "compile"
+description: "Compile NPC profiles"
+inputs:
+  - npc_file_path: "" # Optional path to a specific NPC file to compile.
+  - npc_team_dir: "./npc_team" # Directory containing NPC profiles to compile, if no specific file is given.
+steps:
+  - name: "compile_npcs"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.npc_compiler import NPC, Team # Assuming Team might be needed for full directory compilation
+      
+      npc_file_path_arg = context.get('npc_file_path')
+      npc_team_dir = context.get('npc_team_dir')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      compiled_npc_object = None
+      
+      try:
+          if npc_file_path_arg and npc_file_path_arg.strip():
+              npc_full_path = os.path.abspath(os.path.expanduser(npc_file_path_arg))
+              if os.path.exists(npc_full_path):
+                  # Assuming NPC() constructor "compiles" it by loading its definition
+                  compiled_npc_object = NPC(file=npc_full_path, db_conn=context.get('db_conn'))
+                  output_result = f"Compiled NPC: {npc_full_path}"
+              else:
+                  output_result = f"Error: NPC file not found: {npc_full_path}"
+          else:
+              # Compile all NPCs in the directory. This would typically involve iterating and loading.
+              # For simplicity in this Jinx, we just acknowledge the directory.
+              # A more robust implementation would loop through .npc files and compile them.
+              abs_npc_team_dir = os.path.abspath(os.path.expanduser(npc_team_dir))
+              if os.path.exists(abs_npc_team_dir):
+                  output_result = f"Acknowledged compilation for all NPCs in directory: {abs_npc_team_dir}"
+                  # Example of loading a Team and setting the compiled_npc_object to its forenpc if available
+                  # team = Team(team_path=abs_npc_team_dir, db_conn=context.get('db_conn'))
+                  # if team.forenpc:
+                  #    compiled_npc_object = team.forenpc 
+              else:
+                  output_result = f"Error: NPC team directory not found: {npc_team_dir}"
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error compiling: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages
+      if compiled_npc_object:
+          context['compiled_npc_object'] = compiled_npc_object # Store the compiled NPC object if any

npcsh/npc_team/jinxs/utils/core/help.jinx

@@ -0,0 +1,52 @@
+jinx_name: help
+description: Show help for commands, NPCs, or Jinxs
+inputs:
+  - topic: null
+steps:
+  - name: show_help
+    engine: python
+    code: |
+      import json
+      from npcsh._state import CANONICAL_ARGS, get_argument_help
+      
+      topic = context.get('topic')
+      
+      if not topic:
+          output_lines = ["# Available Commands\n\n"]
+          
+          all_jinxs = {}
+          if hasattr(npc, 'team') and npc.team and hasattr(npc.team, 'jinxs_dict'):
+              all_jinxs.update(npc.team.jinxs_dict)
+          if hasattr(npc, 'jinxs_dict') and npc.jinxs_dict:
+              all_jinxs.update(npc.jinxs_dict)
+          
+          for cmd in sorted(all_jinxs.keys()):
+              jinx_obj = all_jinxs[cmd]
+              desc = getattr(jinx_obj, 'description', 'No description')
+              output_lines.append(f"/{cmd} - {desc}\n\n")
+          
+          arg_help_map = get_argument_help()
+          if arg_help_map:
+              output_lines.append("## Common Command-Line Flags\n\n")
+              output_lines.append("The shortest unambiguous prefix works.\n")
+              
+              for arg in sorted(CANONICAL_ARGS):
+                  aliases = arg_help_map.get(arg, [])
+                  alias_str = f"(-{min(aliases, key=len)})" if aliases else ""
+                  output_lines.append(f"--{arg:<20} {alias_str}\n")
+          
+          output = "".join(output_lines)
+      else:
+          jinx_obj = None
+          if hasattr(npc, 'team') and npc.team and hasattr(npc.team, 'jinxs_dict'):
+              jinx_obj = npc.team.jinxs_dict.get(topic)
+          if not jinx_obj and hasattr(npc, 'jinxs_dict'):
+              jinx_obj = npc.jinxs_dict.get(topic)
+          
+          if jinx_obj:
+              output = f"## Help for Jinx: `/{topic}`\n\n"
+              output += f"- **Description**: {jinx_obj.description}\n"
+              if hasattr(jinx_obj, 'inputs') and jinx_obj.inputs:
+                  output += f"- **Inputs**: {json.dumps(jinx_obj.inputs, indent=2)}\n"
+          else:
+              output = f"No help topic found for `{topic}`."

npcsh/npc_team/jinxs/utils/core/init.jinx

@@ -0,0 +1,41 @@
+jinx_name: "init"
+description: "Initialize NPC project"
+inputs:
+  - directory: "." # The directory where the NPC project should be initialized.
+  - templates: "" # Optional templates to use for initialization.
+  - context: "" # Optional context for project initialization.
+  - model: "" # Optional LLM model to set as default for the project.
+  - provider: "" # Optional LLM provider to set as default for the project.
+steps:
+  - name: "initialize_project"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.npc_compiler import initialize_npc_project
+      
+      directory = context.get('directory')
+      templates = context.get('templates')
+      context_param = context.get('context') # Renamed to avoid conflict with Jinx context
+      model = context.get('model')
+      provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      try:
+          initialize_npc_project(
+              directory=directory,
+              templates=templates,
+              context=context_param, # Use the renamed context parameter
+              model=model,
+              provider=provider
+          )
+          output_result = f"NPC project initialized in {os.path.abspath(directory)}."
+      except NameError:
+          output_result = "Init function (initialize_npc_project) not available."
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error initializing project: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/core/jinxs.jinx

@@ -0,0 +1,32 @@
+jinx_name: jinxs
+description: Show available jinxs for the current NPC/Team
+inputs: []
+steps:
+  - name: list_jinxs
+    engine: python
+    code: |
+      output_lines = ["Available Jinxs:\n"]
+      jinxs_listed = set()
+      
+      if hasattr(npc, 'team') and npc.team:
+          team = npc.team
+          
+          if hasattr(team, 'jinxs_dict') and team.jinxs_dict:
+              output_lines.append(f"\n--- Team Jinxs ---\n")
+              for name, jinx_obj in sorted(team.jinxs_dict.items()):
+                  desc = getattr(jinx_obj, 'description', 'No description available.')
+                  output_lines.append(f"- /{name}: {desc}\n")
+                  jinxs_listed.add(name)
+      
+      if hasattr(npc, 'jinxs_dict') and npc.jinxs_dict:
+          output_lines.append(f"\n--- NPC Jinxs for {npc.name} ---\n")
+          for name, jinx_obj in sorted(npc.jinxs_dict.items()):
+              if name not in jinxs_listed:
+                  desc = getattr(jinx_obj, 'description', 'No description available.')
+                  output_lines.append(f"- /{name}: {desc}\n")
+                  jinxs_listed.add(name)
+      
+      if not jinxs_listed:
+          output = "No jinxs available for the current context."
+      else:
+          output = "".join(output_lines)

npcsh/npc_team/jinxs/utils/core/set.jinx

@@ -0,0 +1,40 @@
+jinx_name: "set"
+description: "Set configuration values"
+inputs:
+  - key: "" # The configuration key to set.
+  - value: "" # The value to set for the configuration key.
+steps:
+  - name: "set_config_value"
+    engine: "python"
+    code: |
+      import traceback
+      # Assuming set_npcsh_config_value is accessible
+      try:
+          from npcsh._state import set_npcsh_config_value
+      except ImportError:
+          def set_npcsh_config_value(key, value):
+              print(f"Mock: Setting config '{key}' to '{value}'")
+              # In a real scenario, this might write to a config file or global state
+              pass
+
+      key = context.get('key')
+      value = context.get('value')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      if not key or not value:
+          context['output'] = "Usage: /set <key>=<value>"
+          context['messages'] = output_messages
+          exit()
+
+      try:
+          set_npcsh_config_value(key, value)
+          output_result = f"Configuration value '{key}' set."
+      except NameError:
+          output_result = "Set function (set_npcsh_config_value) not available."
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error setting configuration '{key}': {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/{edit_file.jinx → utils/edit_file.jinx}

@@ -1,4 +1,4 @@
-jinx_name: file_editor
+jinx_name: edit_file
 description: Examines a file, determines what changes are needed, and applies those
   changes.
 inputs:

npcsh/npc_team/jinxs/utils/flush.jinx

@@ -0,0 +1,39 @@
+jinx_name: "flush"
+description: "Flush the last N messages from the conversation history."
+inputs:
+  - n: 1 # The number of messages to flush (default to 1).
+steps:
+  - name: "flush_messages"
+    engine: "python"
+    code: |
+      n = int(context.get('n', 1))
+      output_messages = context.get('messages', [])
+      
+      if n <= 0:
+          context['output'] = "Error: Number of messages must be positive."
+          context['messages'] = output_messages
+          exit()
+
+      new_messages = list(output_messages)
+      original_len = len(new_messages)
+      removed_count = 0
+
+      if new_messages and new_messages[0].get("role") == "system":
+          system_message = new_messages[0]
+          working_messages = new_messages[1:]
+          num_to_remove = min(n, len(working_messages))
+          if num_to_remove > 0:
+              final_messages = [system_message] + working_messages[:-num_to_remove]
+              removed_count = num_to_remove
+          else:
+              final_messages = [system_message]
+      else:
+          num_to_remove = min(n, original_len)
+          if num_to_remove > 0:
+              final_messages = new_messages[:-num_to_remove]
+              removed_count = num_to_remove
+          else:
+              final_messages = []
+
+      context['output'] = f"Flushed {removed_count} message(s). Context is now {len(final_messages)} messages."
+      context['messages'] = final_messages

npcsh/npc_team/jinxs/utils/npc-studio.jinx

@@ -0,0 +1,82 @@
+jinx_name: "npc-studio"
+description: "Start npc studio"
+inputs:
+  - user_command: "" # Any additional arguments to pass to the npc studio launch.
+steps:
+  - name: "launch_npc_studio"
+    engine: "python"
+    code: |
+      import os
+      import subprocess
+      import sys
+      from pathlib import Path
+      import traceback
+      
+      NPC_STUDIO_DIR = Path.home() / ".npcsh" / "npc-studio"
+
+      def ensure_repo():
+          """Clone or update the npc-studio repo."""
+          if not NPC_STUDIO_DIR.exists():
+              os.makedirs(NPC_STUDIO_DIR.parent, exist_ok=True)
+              subprocess.check_call([
+                  "git", "clone",
+                  "https://github.com/npc-worldwide/npc-studio.git",
+                  str(NPC_STUDIO_DIR)
+              ])
+          else:
+              subprocess.check_call(
+                  ["git", "pull"],
+                  cwd=NPC_STUDIO_DIR
+              )
+
+      def install_dependencies():
+          """Install npm and pip dependencies."""
+          subprocess.check_call(["npm", "install"], cwd=NPC_STUDIO_DIR)
+
+          req_file = NPC_STUDIO_DIR / "requirements.txt"
+          if req_file.exists():
+              subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", str(req_file)])
+
+      def launch_npc_studio(path_to_open: str = None):
+          """
+          Launch the NPC Studio backend + frontend.
+          Returns PIDs for processes.
+          """
+          ensure_repo()
+          install_dependencies()
+
+          backend = subprocess.Popen(
+              [sys.executable, "npc_studio_serve.py"],
+              cwd=NPC_STUDIO_DIR, 
+              shell = False
+          )
+          
+          # npm run dev is typically for the frontend development server
+          dev_server = subprocess.Popen(
+              ["npm", "run", "dev"],
+              cwd=NPC_STUDIO_DIR,
+              shell=False
+          )
+          
+          # npm start is typically for electron or other packaged frontend
+          frontend = subprocess.Popen(
+              ["npm", "start"],
+              cwd=NPC_STUDIO_DIR,
+              shell=False
+          )
+
+          return backend, dev_server, frontend
+      
+      user_command = context.get('user_command')
+      output_messages = context.get('messages', [])
+      output_result = ""
+
+      try:
+          backend, electron, frontend = launch_npc_studio(user_command or None)
+          output_result = f"NPC Studio started!\nBackend PID={backend.pid}, Electron PID={electron.pid} Frontend PID={frontend.pid}"
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Failed to start NPC Studio: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/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/npc_team/jinxs/utils/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/npc_team/jinxs/utils/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