Powershell Invoke-command works but returning an exception

A normal job wouldn't solve your problem, there is no way you could pass-in those objects to a new process created by the job and still use them.

The solution would be to either use a ThreadJob, for this approach you would require the module if you're using Windows PowerShell 5.1 otherwise it's built-in in PowerShell 7.

To install it:

Instal-Module ThreadJob -Scope CurrentUser

To pass-in the objects $session and $sessionOptions you can use the $using: scope modifier.

The code using ThreadJob would be:

$job = Start-ThreadJob { ($using:Session).Open($using:SessionOptions) }
if ($job | Wait-Job -Timeout 5) {
    # here the job completed successfully
    $job | Receive-Job -AutoRemoveJob -Wait
}
else {
    # here the job didn't complete or failed
    Write-Error "Task didn't complete in time. Stopping."
    $job | Stop-Job -PassThru | Remove-Job
}

The other approach that doesn't require anything but it's a lot more code is to invoke your code in a new runspace using a PowerShell instance:

try {
    $ps = [powershell]::Create().AddScript({
        param($session, $options)

        $session.Open($options)
    }).AddArgument($Session).AddArgument($SessionOptions)

    $startTime = [datetime]::Now
    $iasync = $ps.BeginInvoke()
    while (-not $iasync.AsyncWaitHandle.WaitOne(200)) {
        if ([datetime]::Now - $startTime -gt '00:00:05') {
            # here the task didn't complete in time, stop it
            Write-Error "Task didn't complete in time. Stopping."
            # do your best to stop
            $null = $ps.BeginStop($null, $null)
            # and break the loop
            break
        }
    }

    # here the task completed successfully
    if ($ps.InvocationStateInfo.State -eq 'Completed') {
        # get the output if any
        $ps.EndInvoke($iasync)
    }
}
finally {
    $ps.Dispose()
}

Ok, thanks to @Santiago Squarzon I discovered the benefits of a runspace.

If anyone is interested, you can improve a bit and add an object of type System.Management.Automation.PSDataCollection[psobject] to inspect whatever is in the pipeline of the runspace, while iasync is still running. Like so:

$Inspector= new-object 'System.Management.Automation.PSDataCollection[psobject]' 
$iasync = $ps.BeginInvoke($Inspector,$Inspector)

More details here:

https://learn-powershell.net/2016/02/14/another-way-to-get-output-from-a-powershell-runspace/

And when typing $Inspector you get the results, but bare in mind that by doing so, you're trapped in this runspace until it ends (in my case it is never).

In my case, involving $ps.BeginStop($null, $null) didn't stop the iasync object from running

The only way to stop it cleanly was to use $Session.Abort() (This is a WinSCP session).

Every .Dispose() I tried to execute, like $PS.Dispose(), $RunSpace.Dispose(), while $iasync was running, resulted in a script-hang.

I wonder what other actions are able to force-complete iasync (or AsyncObject in my case) and terminate the WinSCP session.

Assigning $null to $PS, $RunSpace, $iasync didn't stop the WinSCP session. Let's say, .Abort() wasn't available, is $Session=$null a smart move??

Here's my final code:

$ParameterList=@{
    Session= $Session
    SessionOptions=$SessionOptions
  }             
  $RunSpace= [runspacefactory]::CreateRunspace()             
  $PS= [powershell]::Create()             
  $PS.RunSpace= $RunSpace             
  $RunSpace.Open()             
  $null= $PS.AddScript({
     Param($Session,$SessionOptions)
     $Session.Open($SessionOptions)
       
  }).AddParameters($ParameterList)
  
  # Using the optional inspector object
  $Inspector= new-object 'System.Management.Automation.PSDataCollection[psobject]'
  $AsyncObject= $PS.BeginInvoke($Inspector,$Inspector)
  #$AsyncObject= $PS.BeginInvoke()
  $StartTime= Get-Date
  Do{
   # Timer for 10 seconds
  }While ((([DateTime]::Now)-$StartTime).Seconds -lt 10)
  
  If ($AsyncObject.IsCompleted -ne "True"){
    write-host "$($Session.Output)"
    write-host "`n`nAborting"
    $Session.Abort()
    $Session.Dispose()
    $Inspector.Dispose()           
    $PS.Dispose()   
  }