fix(serverless): use executionTimeoutMs as runsync client timeout

src/runpod_flash/core/resources/serverless.py

@@ -37,6 +37,9 @@
 # Prefix applied to endpoint names during live provisioning
 LIVE_PREFIX = "live-"
 
+# Default client-side HTTP timeout for runsync calls (seconds)
+DEFAULT_RUNSYNC_TIMEOUT_S = 60
+
 
 log = logging.getLogger(__name__)
 
@@ -1201,10 +1204,16 @@ async def runsync(self, payload: Dict[str, Any]) -> "JobOutput":
         if not self.id:
             raise ValueError("Serverless is not deployed")
 
+        timeout_s: float = (
+            self.executionTimeoutMs / 1000
+            if self.executionTimeoutMs is not None and self.executionTimeoutMs > 0
+            else DEFAULT_RUNSYNC_TIMEOUT_S
+        )
+
         def _fetch_job():
             log.info(f"{self} | API /runsync")
             return self.endpoint.rp_client.post(
-                f"{self.id}/runsync", payload, timeout=60
+                f"{self.id}/runsync", payload, timeout=timeout_s
             )
 
         try:

tests/unit/resources/test_serverless.py

@@ -1272,6 +1272,8 @@ def test_serverless_endpoint_with_existing_template(self):
 
     def test_serverless_endpoint_template_env_override(self):
         """Test ServerlessEndpoint overrides template env vars."""
+        from runpod_flash.core.resources.template import PodTemplate, KeyValuePair
+
         template = PodTemplate(
             name="existing-template",
             imageName="test/image:v1",
@@ -2567,3 +2569,116 @@ async def test_update_echoes_empty_env_for_default_template_env(self):
         template_payload = mock_client.update_template.call_args.args[0]
         env_entries = template_payload.get("env", [])
         assert env_entries == []
+
+
+class TestServerlessRunsyncTimeout:
+    """Test that runsync uses executionTimeoutMs as client timeout."""
+
+    @pytest.fixture
+    def resource_with_timeout(self):
+        """ServerlessResource with executionTimeoutMs set to 300s."""
+        resource = ServerlessResource(
+            name="test-gpu-worker",
+            executionTimeoutMs=300_000,
+        )
+        resource.id = "ep-abc123"
+        return resource
+
+    @pytest.fixture
+    def resource_default_timeout(self):
+        """ServerlessResource with default executionTimeoutMs (0)."""
+        resource = ServerlessResource(
+            name="test-default",
+            executionTimeoutMs=0,
+        )
+        resource.id = "ep-default"
+        return resource
+
+    @pytest.mark.asyncio
+    async def test_runsync_uses_execution_timeout(self, resource_with_timeout):
+        """runsync should use executionTimeoutMs/1000 as client timeout."""
+        mock_rp_client = MagicMock()
+        mock_rp_client.post.return_value = {
+            "id": "job-1",
+            "workerId": "w-1",
+            "status": "COMPLETED",
+            "delayTime": 100,
+            "executionTime": 5000,
+            "output": {"result": "ok"},
+        }
+
+        mock_endpoint = MagicMock()
+        mock_endpoint.rp_client = mock_rp_client
+
+        with patch.object(
+            ServerlessResource,
+            "endpoint",
+            new_callable=lambda: property(lambda self: mock_endpoint),
+        ):
+            result = await resource_with_timeout.runsync({"input": "data"})
+
+        # The client timeout should be executionTimeoutMs / 1000 = 300s, not 60s
+        mock_rp_client.post.assert_called_once_with(
+            "ep-abc123/runsync", {"input": "data"}, timeout=300
+        )
+        assert result.status == "COMPLETED"
+
+    @pytest.mark.asyncio
+    async def test_runsync_default_timeout_when_zero(self, resource_default_timeout):
+        """runsync should fall back to 60s when executionTimeoutMs is 0."""
+        mock_rp_client = MagicMock()
+        mock_rp_client.post.return_value = {
+            "id": "job-2",
+            "workerId": "w-2",
+            "status": "COMPLETED",
+            "delayTime": 50,
+            "executionTime": 2000,
+            "output": None,
+        }
+
+        mock_endpoint = MagicMock()
+        mock_endpoint.rp_client = mock_rp_client
+
+        with patch.object(
+            ServerlessResource,
+            "endpoint",
+            new_callable=lambda: property(lambda self: mock_endpoint),
+        ):
+            await resource_default_timeout.runsync({"input": "data"})
+
+        mock_rp_client.post.assert_called_once_with(
+            "ep-default/runsync", {"input": "data"}, timeout=60
+        )
+
+    @pytest.mark.asyncio
+    async def test_runsync_default_timeout_when_none(self):
+        """runsync should fall back to 60s when executionTimeoutMs is None."""
+        resource = ServerlessResource(
+            name="test-none",
+            executionTimeoutMs=None,
+        )
+        resource.id = "ep-none"
+
+        mock_rp_client = MagicMock()
+        mock_rp_client.post.return_value = {
+            "id": "job-3",
+            "workerId": "w-3",
+            "status": "COMPLETED",
+            "delayTime": 10,
+            "executionTime": 1000,
+            "output": None,
+        }
+
+        mock_endpoint = MagicMock()
+        mock_endpoint.rp_client = mock_rp_client
+
+        with patch.object(
+            ServerlessResource,
+            "endpoint",
+            new_callable=lambda: property(lambda self: mock_endpoint),
+        ):
+            await resource.runsync({"input": "data"})
+
+        mock_rp_client.post.assert_called_once_with(
+            "ep-none/runsync", {"input": "data"}, timeout=60
+        )