Honor documented contract: timeoutMs <= 0 means no timeout in sendAndWait

src/main/java/com/github/copilot/sdk/CopilotSession.java

  Skip scheduling the timeout task when timeoutMs <= 0, matching the
  Javadoc contract that 0 or negative means "no timeout". Previously,
  timeoutMs=0 would schedule an immediate timeout, contradicting the
  docs. The timeout cancel in the whenComplete cleanup is now guarded
  for the null case.

src/test/java/com/github/copilot/sdk/ZeroTimeoutContractTest.java (new)

  TDD test that asserts the documented contract: calling sendAndWait
  with timeoutMs=0 should not cause the future to complete with a
  TimeoutException. Uses Mockito to stub JsonRpcClient.invoke().

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: edburns

src/main/java/com/github/copilot/sdk/CopilotSession.java

@@ -421,33 +421,39 @@ public CompletableFuture<AssistantMessageEvent> sendAndWait(MessageOptions optio
 
         var result = new CompletableFuture<AssistantMessageEvent>();
 
-        // Schedule timeout on the shared session-level scheduler
-        ScheduledFuture<?> timeoutTask;
-        try {
-            timeoutTask = timeoutScheduler.schedule(() -> {
-                if (!future.isDone()) {
-                    future.completeExceptionally(
-                            new TimeoutException("sendAndWait timed out after " + timeoutMs + "ms"));
-                }
-            }, timeoutMs, TimeUnit.MILLISECONDS);
-        } catch (RejectedExecutionException e) {
+        // Schedule timeout on the shared session-level scheduler.
+        // Per Javadoc, timeoutMs <= 0 means "no timeout".
+        ScheduledFuture<?> timeoutTask = null;
+        if (timeoutMs > 0) {
             try {
-                subscription.close();
-            } catch (IOException closeEx) {
-                e.addSuppressed(closeEx);
+                timeoutTask = timeoutScheduler.schedule(() -> {
+                    if (!future.isDone()) {
+                        future.completeExceptionally(
+                                new TimeoutException("sendAndWait timed out after " + timeoutMs + "ms"));
+                    }
+                }, timeoutMs, TimeUnit.MILLISECONDS);
+            } catch (RejectedExecutionException e) {
+                try {
+                    subscription.close();
+                } catch (IOException closeEx) {
+                    e.addSuppressed(closeEx);
+                }
+                result.completeExceptionally(e);
+                return result;
             }
-            result.completeExceptionally(e);
-            return result;
         }
 
         // When inner future completes, run cleanup and propagate to result
+        final ScheduledFuture<?> taskToCancel = timeoutTask;
         future.whenComplete((r, ex) -> {
             try {
                 subscription.close();
             } catch (IOException e) {
                 LOG.log(Level.SEVERE, "Error closing subscription", e);
             }
-            timeoutTask.cancel(false);
+            if (taskToCancel != null) {
+                taskToCancel.cancel(false);
+            }
             if (!result.isDone()) {
                 if (ex != null) {
                     result.completeExceptionally(ex);

src/test/java/com/github/copilot/sdk/ZeroTimeoutContractTest.java

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+package com.github.copilot.sdk;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.junit.jupiter.api.Test;
+
+import com.github.copilot.sdk.events.AssistantMessageEvent;
+import com.github.copilot.sdk.events.SessionIdleEvent;
+import com.github.copilot.sdk.json.MessageOptions;
+
+/**
+ * Verifies the documented contract that {@code timeoutMs <= 0} means "no
+ * timeout" in {@link CopilotSession#sendAndWait(MessageOptions, long)}.
+ */
+public class ZeroTimeoutContractTest {
+
+    @SuppressWarnings("unchecked")
+    @Test
+    void sendAndWaitWithZeroTimeoutShouldNotTimeOut() throws Exception {
+        // Build a session via reflection (package-private constructor)
+        var ctor = CopilotSession.class.getDeclaredConstructor(
+                String.class, JsonRpcClient.class, String.class);
+        ctor.setAccessible(true);
+
+        var mockRpc = mock(JsonRpcClient.class);
+        when(mockRpc.invoke(any(), any(), any()))
+                .thenReturn(new CompletableFuture<>());
+
+        var session = ctor.newInstance("zero-timeout-test", mockRpc, null);
+
+        // Per the Javadoc: timeoutMs of 0 means "no timeout".
+        // The future should NOT complete with TimeoutException.
+        CompletableFuture<AssistantMessageEvent> result =
+                session.sendAndWait(new MessageOptions().setPrompt("test"), 0);
+
+        // Give the scheduler a chance to fire if it was (incorrectly) scheduled
+        Thread.sleep(200);
+
+        // The future should still be pending — not timed out
+        assertFalse(result.isDone(),
+                "Future should not be done; timeoutMs=0 means no timeout per Javadoc");
+    }
+}