fix: prevent sleep on final retry attempt in api call

- refactor exception handling to separate typesense client errors from network errors
- fix sleep logic to only execute between retry attempts, not after final attempt
- add test to verify no sleep occurs on final retry attempt with timing validation

Author: tharropoulos

src/ApiCall.php

@@ -268,27 +268,38 @@ private function makeRequest(string $method, string $endPoint, bool $asJson, arr
             } catch (HttpException $exception) {
                 $statusCode = $exception->getResponse()->getStatusCode();
 
+                // Skip 408 timeouts and continue to next iteration
                 if ($statusCode === 408) {
                     continue;
                 }
 
+                // For 4xx errors, don't retry - throw immediately
                 if (400 <= $statusCode && $statusCode < 500) {
                     $this->setNodeHealthCheck($node, false);
                     throw $this->getException($statusCode)
                         ->setMessage($exception->getMessage());
                 }
 
+                // For 5xx errors, set exception and continue to retry logic
                 $this->setNodeHealthCheck($node, false);
                 $lastException = $this->getException($statusCode)
                     ->setMessage($exception->getMessage());
-            } catch (TypesenseClientError | HttpClientException $exception) {
+            } catch (HttpClientException $exception) {
+                // For network errors, set exception and continue to retry logic
                 $this->setNodeHealthCheck($node, false);
                 $lastException = $exception;
             } catch (Exception $exception) {
+                if ($exception instanceof TypesenseClientError) {
+                    throw $exception;
+                }
+                
                 $this->setNodeHealthCheck($node, false);
                 $lastException = $exception;
-                sleep($this->config->getRetryIntervalSeconds());
             }
+            
+            if ($numRetries < $this->config->getNumRetries() + 1) {
+                usleep((int) ($this->config->getRetryIntervalSeconds() * 10**6));
+            } 
         }
 
         if ($lastException) {

tests/Feature/ApiCallRetryTest.php

@@ -406,4 +406,60 @@ public function test408ErrorsAreSkippedAndRetryingContinues(): void
         $this->assertEquals(['success' => true], $result);
         $this->assertEquals(2, $callCount);
     }
+
+    public function testDoesNotSleepOnFinalRetryAttempt(): void
+    {
+        $callCount = 0;
+        $retryIntervalSeconds = 0.1; 
+        
+        $httpClient = $this->createMock(ClientInterface::class);
+        $httpClient->method('sendRequest')
+            ->willReturnCallback(function() use (&$callCount) {
+                $callCount++;
+                
+                $response = $this->createMock(ResponseInterface::class);
+                $response->method('getStatusCode')->willReturn(500);
+                throw new HttpException('Server error', $this->createMock(RequestInterface::class), $response);
+            });
+
+        $config = new Configuration([
+            'api_key' => 'test-key',
+            'nodes' => [
+                ['host' => 'node1', 'port' => 8108, 'protocol' => 'http']
+            ],
+            'num_retries' => 2, 
+            'retry_interval_seconds' => $retryIntervalSeconds,
+            'client' => $httpClient
+        ]);
+
+        $apiCall = new ApiCall($config);
+        
+        $startTime = microtime(true);
+        
+        try {
+            $apiCall->get('/test', []);
+        } catch (ServerError $e) {
+        }
+        
+        $endTime = microtime(true);
+        $actualDuration = $endTime - $startTime;
+        
+        //  2 sleep intervals (between 1st->2nd and 2nd->3rd attempts)
+        //  no sleep after the final (3rd) attempt
+        $expectedDuration = $retryIntervalSeconds * 2; 
+        
+        $tolerance = 0.05;
+        
+        $this->assertEquals(3, $callCount, 'Should make exactly 3 attempts');
+        $this->assertLessThan(
+            $expectedDuration + $tolerance, 
+            $actualDuration,
+            "Execution took too long ({$actualDuration}s), suggesting sleep was called on final attempt"
+        );
+        $this->assertGreaterThan(
+            $expectedDuration - $tolerance, 
+            $actualDuration,
+            "Execution was too fast ({$actualDuration}s), suggesting sleep intervals were skipped"
+        );
+    }
 }