[11.x] Fix: Custom Exceptions with Multiple Arguments does not properly rein…

src/Illuminate/Concurrency/Console/InvokeSerializedClosureCommand.php

@@ -3,6 +3,7 @@
 namespace Illuminate\Concurrency\Console;
 
 use Illuminate\Console\Command;
+use ReflectionClass;
 use Symfony\Component\Console\Attribute\AsCommand;
 use Throwable;
 
@@ -51,12 +52,30 @@ public function handle()
         } catch (Throwable $e) {
             report($e);
 
+            $reflection = new ReflectionClass($e);
+            $constructor = $reflection->getConstructor();
+            $params = [];
+
+            if ($constructor) {
+                $declaringClass = $constructor->getDeclaringClass()->getName();
+
+                // Ensure we're only getting parameters from the current class, not inherited ones
+                if ($declaringClass === $reflection->getName()) {
+                    $args = $constructor->getParameters();
+                    foreach ($args as $param) {
+                        $property = $param->name;
+                        $params[$property] = $e->{$property} ?? null;
+                    }
+                }
+            }
+
             $this->output->write(json_encode([
                 'successful' => false,
                 'exception' => get_class($e),
                 'message' => $e->getMessage(),
                 'file' => $e->getFile(),
                 'line' => $e->getLine(),
+                'params' => $params,
             ]));
         }
     }

src/Illuminate/Concurrency/ProcessDriver.php

@@ -11,6 +11,7 @@
 use Illuminate\Support\Arr;
 use Illuminate\Support\Defer\DeferredCallback;
 use Laravel\SerializableClosure\SerializableClosure;
+use ReflectionClass;
 
 use function Illuminate\Support\defer;
 
@@ -47,9 +48,31 @@ public function run(Closure|array $tasks): array
             $result = json_decode($result->output(), true);
 
             if (! $result['successful']) {
-                throw new $result['exception'](
-                    $result['message']
-                );
+                $exceptionClass = $result['exception'];
+                $reflection = new ReflectionClass($exceptionClass);
+
+                $args = $result['params'] ?? [];
+
+                if (empty($args)) {
+                    throw new $result['exception'](
+                        $result['message']
+                    );
+                }
+
+                $constructor = $reflection->getConstructor();
+                if ($constructor) {
+                    $constructorParams = $constructor->getParameters();
+                    $finalArgs = [];
+
+                    foreach ($constructorParams as $param) {
+                        $paramName = $param->getName();
+                        $finalArgs[] = $args[$paramName] ?? ($param->isOptional() ? $param->getDefaultValue() : null);
+                    }
+                } else {
+                    $finalArgs = [];
+                }
+
+                throw $reflection->newInstanceArgs($finalArgs);
             }
 
             return unserialize($result['result']);

tests/Integration/Concurrency/ConcurrencyTest.php

@@ -2,9 +2,11 @@
 
 namespace Illuminate\Tests\Integration\Concurrency;
 
+use Exception;
 use Illuminate\Concurrency\ProcessDriver;
 use Illuminate\Foundation\Application;
 use Illuminate\Process\Factory as ProcessFactory;
+use Illuminate\Support\Facades\Concurrency;
 use Orchestra\Testbench\TestCase;
 use PHPUnit\Framework\Attributes\RequiresOperatingSystem;
 
@@ -49,4 +51,43 @@ public function testRunHandlerProcessErrorCode()
             fn () => exit(1),
         ]);
     }
+
+    public function testRunHandlerProcessErrorWithCustomExceptionWithoutParam()
+    {
+        $this->expectException(ExceptionWithoutParam::class);
+        $this->expectExceptionMessage('Test');
+        Concurrency::run([
+            fn () => throw new ExceptionWithoutParam('Test'),
+        ]);
+    }
+
+    public function testRunHandlerProcessErrorWithCustomExceptionWithParam()
+    {
+        $this->expectException(ExceptionWithParam::class);
+        $this->expectExceptionMessage('API request to https://api.example.com failed with status 400 Bad Request');
+        Concurrency::run([
+            fn () => throw new ExceptionWithParam(
+                'https://api.example.com',
+                400,
+                'Bad Request',
+                'Invalid payload'
+            ),
+        ]);
+    }
+}
+
+class ExceptionWithoutParam extends Exception
+{
+}
+
+class ExceptionWithParam extends Exception
+{
+    public function __construct(
+        public string $uri,
+        public int $statusCode,
+        public string $reason,
+        public string|array $responseBody = '',
+    ) {
+        parent::__construct("API request to {$uri} failed with status $statusCode $reason");
+    }
 }