agentex-sdk 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

agentex/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "agentex"
-__version__ = "0.2.6"  # x-release-please-version
+__version__ = "0.2.8"  # x-release-please-version

agentex/lib/adk/utils/_modules/client.py

@@ -8,17 +8,18 @@ logger = make_logger(__name__)
 
 
 class EnvAuth(httpx.Auth):
-    def __init__(self, header_name="x-agent-identity"):
+    def __init__(self, header_name="x-agent-api-key"):
         self.header_name = header_name
 
     def auth_flow(self, request):
         # This gets called for every request
         env_vars = EnvironmentVariables.refresh()
         if env_vars:
-            agent_id = env_vars.AGENT_ID
-            if agent_id:
-                request.headers[self.header_name] = agent_id
-                logger.info(f"Adding header {self.header_name}:{agent_id}")
+            agent_api_key = env_vars.AGENT_API_KEY  
+            if agent_api_key:
+                request.headers[self.header_name] = agent_api_key
+                masked_key = agent_api_key[-4:] if agent_api_key and len(agent_api_key) > 4 else "****"
+                logger.info(f"Adding header {self.header_name}:{masked_key}")
         yield request
 
 

agentex/lib/cli/commands/agents.py

@@ -11,6 +11,7 @@ from agentex.lib.cli.handlers.agent_handlers import (
     build_agent,
     run_agent,
 )
+from agentex.lib.cli.debug import DebugConfig, DebugMode
 from agentex.lib.cli.handlers.cleanup_handlers import cleanup_agent_workflows
 from agentex.lib.cli.handlers.deploy_handlers import (
     DeploymentError,
@@ -171,7 +172,13 @@ def run(
         False, 
         help="Clean up existing workflows for this agent before starting"
     ),
-):
+    # Debug options
+    debug: bool = typer.Option(False, help="Enable debug mode for both worker and ACP (disables auto-reload)"),
+    debug_worker: bool = typer.Option(False, help="Enable debug mode for temporal worker only"),
+    debug_acp: bool = typer.Option(False, help="Enable debug mode for ACP server only"),
+    debug_port: int = typer.Option(5678, help="Port for remote debugging (worker uses this, ACP uses port+1)"),
+    wait_for_debugger: bool = typer.Option(False, help="Wait for debugger to attach before starting"),
+) -> None:
     """
     Run an agent locally from the given manifest.
     """
@@ -196,8 +203,35 @@ def run(
             console.print(f"[yellow]⚠ Pre-run cleanup failed: {str(e)}[/yellow]")
             logger.warning(f"Pre-run cleanup failed: {e}")
     
+    # Create debug configuration based on CLI flags
+    debug_config = None
+    if debug or debug_worker or debug_acp:
+        # Determine debug mode
+        if debug:
+            mode = DebugMode.BOTH
+        elif debug_worker and debug_acp:
+            mode = DebugMode.BOTH
+        elif debug_worker:
+            mode = DebugMode.WORKER
+        elif debug_acp:
+            mode = DebugMode.ACP
+        else:
+            mode = DebugMode.NONE
+        
+        debug_config = DebugConfig(
+            enabled=True,
+            mode=mode,
+            port=debug_port,
+            wait_for_attach=wait_for_debugger,
+            auto_port=False  # Use fixed port to match VS Code launch.json
+        )
+        
+        console.print(f"[blue]🐛 Debug mode enabled: {mode.value}[/blue]")
+        if wait_for_debugger:
+            console.print("[yellow]⏳ Processes will wait for debugger attachment[/yellow]")
+    
     try:
-        run_agent(manifest_path=manifest)
+        run_agent(manifest_path=manifest, debug_config=debug_config)
     except Exception as e:
         typer.echo(f"Error running agent: {str(e)}", err=True)
         logger.exception("Error running agent")

agentex/lib/cli/debug/__init__.py

@@ -0,0 +1,15 @@
+"""
+Debug functionality for AgentEx CLI
+
+Provides debug support for temporal workers and ACP servers during local development.
+"""
+
+from .debug_config import DebugConfig, DebugMode
+from .debug_handlers import start_acp_server_debug, start_temporal_worker_debug
+
+__all__ = [
+    "DebugConfig",
+    "DebugMode", 
+    "start_acp_server_debug",
+    "start_temporal_worker_debug",
+] 

agentex/lib/cli/debug/debug_config.py

@@ -0,0 +1,116 @@
+"""
+Debug configuration models for AgentEx CLI debugging.
+"""
+
+import socket
+from enum import Enum
+from typing import Optional
+
+from agentex.lib.utils.model_utils import BaseModel
+
+
+class DebugMode(str, Enum):
+    """Debug mode options"""
+    WORKER = "worker"
+    ACP = "acp"
+    BOTH = "both"
+    NONE = "none"
+
+
+class DebugConfig(BaseModel):
+    """Configuration for debug mode"""
+    
+    enabled: bool = False
+    mode: DebugMode = DebugMode.NONE
+    port: int = 5678
+    wait_for_attach: bool = False
+    auto_port: bool = True  # Automatically find available port if specified port is busy
+    
+    @classmethod
+    def create_worker_debug(
+        cls, 
+        port: int = 5678, 
+        wait_for_attach: bool = False,
+        auto_port: bool = True
+    ) -> "DebugConfig":
+        """Create debug config for worker debugging"""
+        return cls(
+            enabled=True,
+            mode=DebugMode.WORKER,
+            port=port,
+            wait_for_attach=wait_for_attach,
+            auto_port=auto_port
+        )
+    
+    @classmethod
+    def create_acp_debug(
+        cls, 
+        port: int = 5679, 
+        wait_for_attach: bool = False,
+        auto_port: bool = True
+    ) -> "DebugConfig":
+        """Create debug config for ACP debugging"""
+        return cls(
+            enabled=True,
+            mode=DebugMode.ACP,
+            port=port,
+            wait_for_attach=wait_for_attach,
+            auto_port=auto_port
+        )
+    
+    @classmethod
+    def create_both_debug(
+        cls, 
+        worker_port: int = 5678,
+        acp_port: int = 5679,
+        wait_for_attach: bool = False,
+        auto_port: bool = True
+    ) -> "DebugConfig":
+        """Create debug config for both worker and ACP debugging"""
+        return cls(
+            enabled=True,
+            mode=DebugMode.BOTH,
+            port=worker_port,  # Primary port for worker
+            wait_for_attach=wait_for_attach,
+            auto_port=auto_port
+        )
+    
+    def should_debug_worker(self) -> bool:
+        """Check if worker should be debugged"""
+        return self.enabled and self.mode in (DebugMode.WORKER, DebugMode.BOTH)
+    
+    def should_debug_acp(self) -> bool:
+        """Check if ACP should be debugged"""
+        return self.enabled and self.mode in (DebugMode.ACP, DebugMode.BOTH)
+    
+    def get_worker_port(self) -> int:
+        """Get port for worker debugging"""
+        return self.port
+    
+    def get_acp_port(self) -> int:
+        """Get port for ACP debugging"""
+        if self.mode == DebugMode.BOTH:
+            return self.port + 1  # Use port + 1 for ACP when debugging both
+        return self.port
+
+
+def find_available_port(start_port: int = 5678, max_attempts: int = 10) -> int:
+    """Find an available port starting from start_port"""
+    for port in range(start_port, start_port + max_attempts):
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(('localhost', port))
+                return port
+        except OSError:
+            continue
+    
+    # If we can't find an available port, just return the start port
+    # and let the debug server handle the error
+    return start_port
+
+
+def resolve_debug_port(config: DebugConfig, target_port: int) -> int:
+    """Resolve the actual port to use for debugging"""
+    if config.auto_port:
+        return find_available_port(target_port)
+    return target_port 

agentex/lib/cli/debug/debug_handlers.py

@@ -0,0 +1,174 @@
+"""
+Debug process handlers for AgentEx CLI.
+
+Provides debug-enabled versions of ACP server and temporal worker startup.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Dict, TYPE_CHECKING
+
+from rich.console import Console
+
+if TYPE_CHECKING:
+    import asyncio.subprocess
+
+from .debug_config import DebugConfig, resolve_debug_port
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+
+async def start_temporal_worker_debug(
+    worker_path: Path, 
+    env: Dict[str, str], 
+    debug_config: DebugConfig
+):
+    """Start temporal worker with debug support"""
+    
+    if not debug_config.should_debug_worker():
+        raise ValueError("Debug config is not configured for worker debugging")
+    
+    # Resolve the actual debug port
+    debug_port = resolve_debug_port(debug_config, debug_config.get_worker_port())
+    
+    # Add debug environment variables
+    debug_env = env.copy()
+    debug_env.update({
+        "AGENTEX_DEBUG_ENABLED": "true",
+        "AGENTEX_DEBUG_PORT": str(debug_port),
+        "AGENTEX_DEBUG_WAIT_FOR_ATTACH": str(debug_config.wait_for_attach).lower(),
+        "AGENTEX_DEBUG_TYPE": "worker"
+    })
+    
+    # Start the worker process
+    # For debugging, use absolute path to run_worker.py to run from workspace root
+    worker_script = worker_path.parent / "run_worker.py"
+    cmd = [sys.executable, str(worker_script)]
+    
+    console.print(f"[blue]🐛 Starting Temporal worker in debug mode[/blue]")
+    console.print(f"[yellow]📡 Debug server will listen on port {debug_port}[/yellow]")
+    console.print(f"[green]✓ VS Code should connect to: localhost:{debug_port}[/green]")
+    
+    if debug_config.wait_for_attach:
+        console.print(f"[yellow]⏳ Worker will wait for debugger to attach[/yellow]")
+    
+    console.print(f"[dim]💡 In your IDE: Attach to localhost:{debug_port}[/dim]")
+    console.print(f"[dim]🔧 If connection fails, check that VS Code launch.json uses port {debug_port}[/dim]")
+    
+    return await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=Path.cwd(),  # Run from current working directory (workspace root)
+        env=debug_env,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+
+
+async def start_acp_server_debug(
+    acp_path: Path, 
+    port: int, 
+    env: Dict[str, str],
+    debug_config: DebugConfig
+):
+    """Start ACP server with debug support"""
+    
+    if not debug_config.should_debug_acp():
+        raise ValueError("Debug config is not configured for ACP debugging")
+    
+    # Resolve the actual debug port
+    debug_port = resolve_debug_port(debug_config, debug_config.get_acp_port())
+    
+    # Add debug environment variables
+    debug_env = env.copy()
+    debug_env.update({
+        "AGENTEX_DEBUG_ENABLED": "true",
+        "AGENTEX_DEBUG_PORT": str(debug_port),
+        "AGENTEX_DEBUG_WAIT_FOR_ATTACH": str(debug_config.wait_for_attach).lower(),
+        "AGENTEX_DEBUG_TYPE": "acp"
+    })
+    
+    # Disable uvicorn auto-reload in debug mode to prevent conflicts
+    cmd = [
+        sys.executable,
+        "-m",
+        "uvicorn",
+        f"{acp_path.parent.name}.acp:acp",
+        "--port",
+        str(port),
+        "--host",
+        "0.0.0.0",
+        # Note: No --reload flag when debugging
+    ]
+
+    console.print(f"[blue]🐛 Starting ACP server in debug mode[/blue]")
+    console.print(f"[yellow]📡 Debug server will listen on port {debug_port}[/yellow]")
+    
+    if debug_config.wait_for_attach:
+        console.print(f"[yellow]⏳ ACP server will wait for debugger to attach[/yellow]")
+        
+    console.print(f"[dim]💡 In your IDE: Attach to localhost:{debug_port}[/dim]")
+
+    return await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=acp_path.parent.parent,
+        env=debug_env,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+
+
+def create_debug_startup_script() -> str:
+    """Create a Python script snippet for debug initialization"""
+    return '''
+import os
+import sys
+
+# Debug initialization for AgentEx
+if os.getenv("AGENTEX_DEBUG_ENABLED") == "true":
+    try:
+        import debugpy
+        debug_port = int(os.getenv("AGENTEX_DEBUG_PORT", "5678"))
+        debug_type = os.getenv("AGENTEX_DEBUG_TYPE", "unknown")
+        wait_for_attach = os.getenv("AGENTEX_DEBUG_WAIT_FOR_ATTACH", "false").lower() == "true"
+        
+        # Configure debugpy
+        debugpy.configure(subProcess=False)
+        debugpy.listen(debug_port)
+        
+        print(f"🐛 [{debug_type.upper()}] Debug server listening on port {debug_port}")
+        
+        if wait_for_attach:
+            print(f"⏳ [{debug_type.upper()}] Waiting for debugger to attach...")
+            debugpy.wait_for_client()
+            print(f"✅ [{debug_type.upper()}] Debugger attached!")
+        else:
+            print(f"📡 [{debug_type.upper()}] Ready for debugger attachment")
+            
+    except ImportError:
+        print("❌ debugpy not available. Install with: pip install debugpy")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ Debug setup failed: {e}")
+        sys.exit(1)
+'''
+
+
+def inject_debug_code_to_worker_template() -> str:
+    """Generate debug code to inject into worker template"""
+    return """
+# === DEBUG SETUP (Auto-generated by AgentEx CLI) ===
+""" + create_debug_startup_script() + """
+# === END DEBUG SETUP ===
+"""
+
+
+def inject_debug_code_to_acp_template() -> str:
+    """Generate debug code to inject into ACP template"""
+    return """
+# === DEBUG SETUP (Auto-generated by AgentEx CLI) ===
+""" + create_debug_startup_script() + """
+# === END DEBUG SETUP ===
+""" 

agentex/lib/cli/handlers/agent_handlers.py

@@ -7,6 +7,7 @@ from rich.console import Console
 
 from agentex.lib.cli.handlers.run_handlers import RunError
 from agentex.lib.cli.handlers.run_handlers import run_agent as _run_agent
+from agentex.lib.cli.debug import DebugConfig
 from agentex.lib.sdk.config.agent_manifest import AgentManifest
 from agentex.lib.utils.logging import make_logger
 
@@ -126,7 +127,7 @@ def build_agent(
     return image_name
 
 
-def run_agent(manifest_path: str):
+def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = None):
     """Run an agent locally from the given manifest"""
     import asyncio
     import signal
@@ -152,7 +153,7 @@ def run_agent(manifest_path: str):
     signal.signal(signal.SIGTERM, signal_handler)
     
     try:
-        asyncio.run(_run_agent(manifest_path))
+        asyncio.run(_run_agent(manifest_path, debug_config))
     except KeyboardInterrupt:
         print("Shutdown completed.")
         sys.exit(0)

agentex/lib/cli/handlers/deploy_handlers.py

@@ -22,7 +22,7 @@ logger = make_logger(__name__)
 console = Console()
 
 TEMPORAL_WORKER_KEY = "temporal-worker"
-AGENTEX_AGENTS_HELM_CHART_VERSION = "0.1.4-v1-beta"
+AGENTEX_AGENTS_HELM_CHART_VERSION = "0.1.6-v1-beta"
 
 
 class InputDeployOverrides(BaseModel):
@@ -133,7 +133,7 @@ def merge_deployment_configs(
         raise DeploymentError("Repository and image tag are required")
 
     # Start with global configuration
-    helm_values = {
+    helm_values: dict[str, Any] = {
         "global": {
             "image": {
                 "repository": repository,
@@ -157,55 +157,76 @@ def merge_deployment_configs(
                 "memory": manifest.deployment.global_config.resources.limits.memory,
             },
         },
+        # Enable autoscaling by default for production deployments
+        "autoscaling": {
+            "enabled": True,
+            "minReplicas": 1,
+            "maxReplicas": 10,
+            "targetCPUUtilizationPercentage": 50,
+        },
     }
 
     # Handle temporal configuration using new helper methods
     if agent_config.is_temporal_agent():
         temporal_config = agent_config.get_temporal_workflow_config()
         if temporal_config:
-            helm_values[TEMPORAL_WORKER_KEY] = {}
+            helm_values[TEMPORAL_WORKER_KEY] = {
+                "enabled": True,
+                # Enable autoscaling for temporal workers as well
+                "autoscaling": {
+                    "enabled": True,
+                    "minReplicas": 1,
+                    "maxReplicas": 10,
+                    "targetCPUUtilizationPercentage": 50,
+                },
+            }
             helm_values["global"]["workflow"] = {
                 "name": temporal_config.name,
                 "taskQueue": temporal_config.queue_name,
             }
-            helm_values[TEMPORAL_WORKER_KEY]["enabled"] = True
 
-    secret_env_vars = []
-    if agent_config.credentials:
-        for credential in agent_config.credentials:
-            secret_env_vars.append(
-                {
-                    "name": credential.env_var_name,
-                    "secretName": credential.secret_name,
-                    "secretKey": credential.secret_key,
-                }
-            )
-
-        helm_values["secretEnvVars"] = secret_env_vars
-        if TEMPORAL_WORKER_KEY in helm_values:
-            helm_values[TEMPORAL_WORKER_KEY]["secretEnvVars"] = secret_env_vars
-
-    # Set the agent_config env vars first to the helm values and so then it can be overriden by the cluster config
+    # Collect all environment variables with conflict detection
+    all_env_vars: dict[str, str] = {}
+    secret_env_vars: list[dict[str, str]] = []
+    
+    # Start with agent_config env vars
     if agent_config.env:
-        helm_values["env"] = agent_config.env
-        if TEMPORAL_WORKER_KEY in helm_values:
-            helm_values[TEMPORAL_WORKER_KEY]["env"] = agent_config.env
+        all_env_vars.update(agent_config.env)
 
     # Add auth principal env var if manifest principal is set
     encoded_principal = _encode_principal_context(manifest)
     if encoded_principal:
-        if "env" not in helm_values:
-            helm_values["env"] = {}
-        helm_values["env"][EnvVarKeys.AUTH_PRINCIPAL_B64.value] = encoded_principal
+        all_env_vars[EnvVarKeys.AUTH_PRINCIPAL_B64.value] = encoded_principal
 
-    if manifest.deployment and manifest.deployment.imagePullSecrets:
-        pull_secrets = [
-            pull_secret.to_dict()
-            for pull_secret in manifest.deployment.imagePullSecrets
-        ]
-        helm_values["global"]["imagePullSecrets"] = pull_secrets
-        # TODO: Remove this once i bump the chart version again
-        helm_values["imagePullSecrets"] = pull_secrets
+    # Handle credentials and check for conflicts
+    if agent_config.credentials:
+        for credential in agent_config.credentials:
+            # Handle both CredentialMapping objects and legacy dict format
+            if isinstance(credential, dict):
+                env_var_name = credential["env_var_name"]
+                secret_name = credential["secret_name"]
+                secret_key = credential["secret_key"]
+            else:
+                env_var_name = credential.env_var_name
+                secret_name = credential.secret_name
+                secret_key = credential.secret_key
+            
+            # Check if the environment variable name conflicts with existing env vars
+            if env_var_name in all_env_vars:
+                logger.warning(
+                    f"Environment variable '{env_var_name}' is defined in both "
+                    f"env and secretEnvVars. The secret value will take precedence."
+                )
+                # Remove from regular env vars since secret takes precedence
+                del all_env_vars[env_var_name]
+            
+            secret_env_vars.append(
+                {
+                    "name": env_var_name,
+                    "secretName": secret_name,
+                    "secretKey": secret_key,
+                }
+            )
 
     # Apply cluster-specific overrides
     if cluster_config:
@@ -236,23 +257,50 @@ def merge_deployment_configs(
                     }
                 )
 
+        # Handle cluster env vars with conflict detection
         if cluster_config.env:
-            helm_values["env"] = cluster_config.env
+            # Convert cluster env list to dict for easier conflict detection
+            cluster_env_dict = {env_var["name"]: env_var["value"] for env_var in cluster_config.env}
+            
+            # Check for conflicts with secret env vars
+            for secret_env_var in secret_env_vars:
+                if secret_env_var["name"] in cluster_env_dict:
+                    logger.warning(
+                        f"Environment variable '{secret_env_var['name']}' is defined in both "
+                        f"cluster config env and secretEnvVars. The secret value will take precedence."
+                    )
+                    del cluster_env_dict[secret_env_var["name"]]
+            
+            # Update all_env_vars with cluster overrides
+            all_env_vars.update(cluster_env_dict)
 
         # Apply additional arbitrary overrides
         if cluster_config.additional_overrides:
             _deep_merge(helm_values, cluster_config.additional_overrides)
 
-    # Convert the env vars to a list of dictionaries
-    if "env" in helm_values:
-        helm_values["env"] = convert_env_vars_dict_to_list(helm_values["env"])
-
-    # Convert the temporal worker env vars to a list of dictionaries
-    if TEMPORAL_WORKER_KEY in helm_values and "env" in helm_values[TEMPORAL_WORKER_KEY]:
-        helm_values[TEMPORAL_WORKER_KEY]["env"] = convert_env_vars_dict_to_list(
-            helm_values[TEMPORAL_WORKER_KEY]["env"]
-        )
+    # Set final environment variables
+    if all_env_vars:
+        helm_values["env"] = convert_env_vars_dict_to_list(all_env_vars)
     
+    if secret_env_vars:
+        helm_values["secretEnvVars"] = secret_env_vars
+
+    # Set environment variables for temporal worker if enabled
+    if TEMPORAL_WORKER_KEY in helm_values:
+        if all_env_vars:
+            helm_values[TEMPORAL_WORKER_KEY]["env"] = convert_env_vars_dict_to_list(all_env_vars)
+        if secret_env_vars:
+            helm_values[TEMPORAL_WORKER_KEY]["secretEnvVars"] = secret_env_vars
+
+    # Handle image pull secrets
+    if manifest.deployment and manifest.deployment.imagePullSecrets:
+        pull_secrets = [
+            pull_secret.to_dict()
+            for pull_secret in manifest.deployment.imagePullSecrets
+        ]
+        helm_values["global"]["imagePullSecrets"] = pull_secrets
+        helm_values["imagePullSecrets"] = pull_secrets
+
     # Add dynamic ACP command based on manifest configuration
     add_acp_command_to_helm_values(helm_values, manifest, manifest_path)
     

agentex/lib/cli/handlers/run_handlers.py

@@ -18,6 +18,9 @@ from agentex.lib.cli.utils.path_utils import (
 
 from agentex.lib.environment_variables import EnvVarKeys
 from agentex.lib.sdk.config.agent_manifest import AgentManifest
+
+# Import debug functionality
+from agentex.lib.cli.debug import DebugConfig, start_acp_server_debug, start_temporal_worker_debug
 from agentex.lib.utils.logging import make_logger
 
 logger = make_logger(__name__)
@@ -249,7 +252,7 @@ async def stream_process_output(process: asyncio.subprocess.Process, prefix: str
         logger.debug(f"Output streaming ended for {prefix}: {e}")
 
 
-async def run_agent(manifest_path: str):
+async def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = None):
     """Run an agent locally from the given manifest"""
 
     # Validate manifest exists
@@ -289,11 +292,16 @@ async def run_agent(manifest_path: str):
             )
         )
 
-        # Start ACP server
+        # Start ACP server (with debug support if enabled)
         manifest_dir = Path(manifest_path).parent
-        acp_process = await start_acp_server(
-            file_paths["acp"], manifest.local_development.agent.port, agent_env, manifest_dir
-        )
+        if debug_config and debug_config.should_debug_acp():
+            acp_process = await start_acp_server_debug(
+                file_paths["acp"], manifest.local_development.agent.port, agent_env, debug_config
+            )
+        else:
+            acp_process = await start_acp_server(
+                file_paths["acp"], manifest.local_development.agent.port, agent_env, manifest_dir
+            )
         process_manager.add_process(acp_process)
 
         # Start output streaming for ACP
@@ -301,9 +309,18 @@ async def run_agent(manifest_path: str):
 
         tasks = [acp_output_task]
 
-        # Start temporal worker if needed
+        # Start temporal worker if needed (with debug support if enabled)
         if is_temporal_agent(manifest) and file_paths["worker"]:
-            worker_task = await start_temporal_worker_with_reload(file_paths["worker"], agent_env, process_manager)
+            if debug_config and debug_config.should_debug_worker():
+                # In debug mode, start worker without auto-reload to prevent conflicts
+                worker_process = await start_temporal_worker_debug(
+                    file_paths["worker"], agent_env, debug_config
+                )
+                process_manager.add_process(worker_process)
+                worker_task = asyncio.create_task(stream_process_output(worker_process, "WORKER"))
+            else:
+                # Normal mode with auto-reload
+                worker_task = await start_temporal_worker_with_reload(file_paths["worker"], agent_env, process_manager)
             tasks.append(worker_task)
 
         console.print(

agentex/lib/cli/templates/default/Dockerfile.j2

@@ -15,6 +15,8 @@ RUN apt-get update && apt-get install -y \
     gcc \
     cmake \
     netcat-openbsd \
+    node \
+    npm \ 
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*