fix: address batchCheck review feedback

- clientBatchCheck: use handle instead of handleAsync so the trivial response construction runs inline, avoiding thread-per-task churn on <=2 vCPU hosts where the common pool falls back to per-task threads and reintroduces the churn this change removes

- batchCheck: route response-processing errors through the failure reference so a malformed 200 (e.g. null result) no longer aborts the remaining batches in a lane; all batches are attempted, then the returned future fails, matching the request-failure path

- tests: add regression coverage that response-processing failures fail the returned future and do not skip remaining batches

Author: SoulPancake

src/main/java/dev/openfga/sdk/api/client/OpenFgaClient.java

@@ -940,7 +940,7 @@ public CompletableFuture<List<ClientBatchCheckClientResponse>> clientBatchCheck(
 
         Function<ClientCheckRequest, CompletableFuture<Void>> singleClientCheckRequest =
                 request -> call(() -> this.check(request, clientCheckOptions))
-                        .handleAsync(ClientBatchCheckClientResponse.asyncHandler(request))
+                        .handle(ClientBatchCheckClientResponse.asyncHandler(request))
                         .thenAccept(responses::add);
 
         return executeInLanes(requests, singleClientCheckRequest, maxParallelRequests)
@@ -1068,6 +1068,10 @@ public CompletableFuture<ClientBatchCheckResponse> batchCheck(
                     });
                     responses.addAll(batchResults);
                     return null;
+                })
+                .exceptionally(processingFailure -> {
+                    failure.compareAndSet(null, processingFailure);
+                    return null;
                 });
 
         return executeInLanes(batchedChecks, singleBatchCheckRequest, maxParallelRequests)

src/test/java/dev/openfga/sdk/api/client/OpenFgaClientTest.java

@@ -2095,6 +2095,59 @@ public void batchCheckMethodsRejectNonPositiveMaxParallelRequests() {
         }
     }
 
+    @Test
+    public void batchCheckFailsWhenResponseProcessingFails() throws Exception {
+        // Given: a successful HTTP response whose body is missing the result payload
+        String batchCheckUrl = String.format("%s/stores/%s/batch-check", FgaConstants.TEST_API_URL, DEFAULT_STORE_ID);
+        mockHttpClient.onPost(batchCheckUrl).doReturn(200, "{\"result\": null}");
+
+        ClientBatchCheckItem batchItem = new ClientBatchCheckItem()
+                ._object(DEFAULT_OBJECT)
+                .relation(DEFAULT_RELATION)
+                .user(DEFAULT_USER)
+                .correlationId("cor-1");
+
+        // When
+        var future = fga.batchCheck(new ClientBatchCheckRequest().checks(List.of(batchItem)));
+
+        // Then: a response-processing error must fail the returned future rather than be silently dropped
+        var exception = assertThrows(ExecutionException.class, () -> future.get(5, TimeUnit.SECONDS));
+        assertNotNull(exception.getCause());
+    }
+
+    @Test
+    public void batchCheckAttemptsRemainingBatchesWhenResponseProcessingFails() throws Exception {
+        // Given: 60 checks form two sub-batches with the default maxBatchSize of 50, sent one lane at a time
+        var pending = new CopyOnWriteArrayList<CompletableFuture<HttpResponse<String>>>();
+        var fga = clientBackedByPendingResponses(pending);
+        List<ClientBatchCheckItem> checks = IntStream.range(0, 60)
+                .mapToObj(i -> new ClientBatchCheckItem()
+                        ._object(DEFAULT_OBJECT)
+                        .relation(DEFAULT_RELATION)
+                        .user(DEFAULT_USER)
+                        .correlationId("cor-" + i))
+                .collect(Collectors.toList());
+        var options = new ClientBatchCheckOptions().maxParallelRequests(1);
+
+        var future = assertTimeoutPreemptively(
+                Duration.ofSeconds(5), () -> fga.batchCheck(new ClientBatchCheckRequest().checks(checks), options));
+
+        assertFalse(future.isDone());
+        Thread.sleep(200);
+        assertEquals(1, pending.size());
+
+        // The first sub-batch returns a malformed 200 (null result) that fails during response processing
+        pending.get(0).complete(fakeResponse("{\"result\": null}"));
+
+        // The lane must still send the remaining sub-batch instead of aborting early
+        awaitSize(pending, 2);
+        pending.get(1).complete(fakeResponse("{\"result\": {}}"));
+
+        // Then: every batch was attempted, and the returned future fails with the captured processing error
+        var exception = assertThrows(ExecutionException.class, () -> future.get(5, TimeUnit.SECONDS));
+        assertNotNull(exception.getCause());
+    }
+
     private OpenFgaClient clientBackedByPendingResponses(List<CompletableFuture<HttpResponse<String>>> pending)
             throws Exception {
         HttpClient pendingClient = mock(HttpClient.class);