Improve Go SDK error propagation and enhance CLI error tests

Go SDK:
- Change processDone from buffered error channel to closed signal channel
- Store processError separately and use mutex for thread-safe access
- Check for process exit before sending requests (fail fast)
- Subsequent requests after process exit now get the same stderr error

All SDKs:
- Enhanced CLI error tests to verify subsequent calls also fail properly
- Tests now call createSession/send instead of just ping

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

Author: SteveSandersonMS

dotnet/test/ClientTests.cs

@@ -244,6 +244,19 @@ public async Task Should_Report_Error_With_Stderr_When_CLI_Fails_To_Start()
         Assert.Contains("stderr", errorMessage, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("nonexistent", errorMessage, StringComparison.OrdinalIgnoreCase);
 
+        // Verify subsequent calls also fail with the same error (containing stderr info)
+        var ex2 = await Assert.ThrowsAnyAsync<Exception>(async () =>
+        {
+            var session = await client.CreateSessionAsync();
+            await session.SendAsync(new MessageOptions { Prompt = "test" });
+        });
+        var errorMessage2 = ex2.Message;
+        Assert.True(
+            errorMessage2.Contains("stderr", StringComparison.OrdinalIgnoreCase) ||
+            errorMessage2.Contains("nonexistent", StringComparison.OrdinalIgnoreCase) ||
+            errorMessage2.Contains("not connected", StringComparison.OrdinalIgnoreCase),
+            $"Expected subsequent error to reference CLI failure, got: {errorMessage2}");
+
         // Cleanup - ForceStop should handle the disconnected state gracefully
         try { await client.ForceStopAsync(); } catch { /* Expected */ }
     }

go/client.go

@@ -88,7 +88,8 @@ type Client struct {
 	typedLifecycleHandlers map[SessionLifecycleEventType][]SessionLifecycleHandler
 	lifecycleHandlersMux   sync.Mutex
 	stderrBuf              bytes.Buffer // captures CLI stderr for error messages
-	processDone            chan error   // signals when CLI process exits
+	processDone            chan struct{} // closed when CLI process exits
+	processError           error        // set before processDone is closed
 
 	// RPC provides typed server-scoped RPC methods.
 	// This field is nil until the client is connected via Start().
@@ -1107,22 +1108,23 @@ func (c *Client) startCLIServer(ctx context.Context) error {
 		}
 
 		// Monitor process exit to signal pending requests
-		c.processDone = make(chan error, 1)
+		c.processDone = make(chan struct{})
 		go func() {
 			err := c.process.Wait()
 			stderrOutput := strings.TrimSpace(c.stderrBuf.String())
 			if stderrOutput != "" {
-				c.processDone <- fmt.Errorf("CLI process exited: %v\nstderr: %s", err, stderrOutput)
+				c.processError = fmt.Errorf("CLI process exited: %v\nstderr: %s", err, stderrOutput)
 			} else if err != nil {
-				c.processDone <- fmt.Errorf("CLI process exited: %v", err)
+				c.processError = fmt.Errorf("CLI process exited: %v", err)
 			} else {
-				c.processDone <- fmt.Errorf("CLI process exited unexpectedly")
+				c.processError = fmt.Errorf("CLI process exited unexpectedly")
 			}
+			close(c.processDone)
 		}()
 
 		// Create JSON-RPC client immediately
 		c.client = jsonrpc2.NewClient(stdin, stdout)
-		c.client.SetProcessDone(c.processDone)
+		c.client.SetProcessDone(c.processDone, &c.processError)
 		c.RPC = rpc.NewServerRpc(c.client)
 		c.setupNotificationHandler()
 		c.client.Start()

go/internal/e2e/client_test.go

@@ -245,5 +245,18 @@ func TestClient(t *testing.T) {
 		if !strings.Contains(errStr, "stderr") || !strings.Contains(errStr, "nonexistent") {
 			t.Errorf("Expected error to contain stderr output about invalid flag, got: %v", err)
 		}
+
+		// Verify subsequent calls also fail with the same error
+		session, err := client.CreateSession(t.Context(), nil)
+		if err == nil {
+			_, err = session.Send(t.Context(), copilot.MessageOptions{Prompt: "test"})
+		}
+		if err == nil {
+			t.Fatal("Expected CreateSession/Send to fail after CLI exit")
+		}
+		errStr = err.Error()
+		if !strings.Contains(errStr, "stderr") && !strings.Contains(errStr, "nonexistent") {
+			t.Errorf("Expected subsequent error to reference CLI failure, got: %v", err)
+		}
 	})
 }

go/internal/jsonrpc2/jsonrpc2.go

@@ -57,7 +57,9 @@ type Client struct {
 	running         bool
 	stopChan        chan struct{}
 	wg              sync.WaitGroup
-	processDone     <-chan error // signals when the underlying process exits
+	processDone     chan struct{}   // closed when the underlying process exits
+	processError    error           // set before processDone is closed
+	processErrorMu  sync.RWMutex    // protects processError
 }
 
 // NewClient creates a new JSON-RPC client
@@ -71,9 +73,26 @@ func NewClient(stdin io.WriteCloser, stdout io.ReadCloser) *Client {
 	}
 }
 
-// SetProcessDone sets a channel that signals when the underlying process exits
-func (c *Client) SetProcessDone(ch <-chan error) {
-	c.processDone = ch
+// SetProcessDone sets a channel that will be closed when the process exits,
+// and stores the error that should be returned to pending/future requests.
+func (c *Client) SetProcessDone(done chan struct{}, errPtr *error) {
+	c.processDone = done
+	// Monitor the channel and copy the error when it closes
+	go func() {
+		<-done
+		if errPtr != nil {
+			c.processErrorMu.Lock()
+			c.processError = *errPtr
+			c.processErrorMu.Unlock()
+		}
+	}()
+}
+
+// getProcessError returns the process exit error if the process has exited
+func (c *Client) getProcessError() error {
+	c.processErrorMu.RLock()
+	defer c.processErrorMu.RUnlock()
+	return c.processError
 }
 
 // Start begins listening for messages in a background goroutine
@@ -178,6 +197,19 @@ func (c *Client) Request(method string, params any) (json.RawMessage, error) {
 		c.mu.Unlock()
 	}()
 
+	// Check if process already exited before sending
+	if c.processDone != nil {
+		select {
+		case <-c.processDone:
+			if err := c.getProcessError(); err != nil {
+				return nil, err
+			}
+			return nil, fmt.Errorf("process exited unexpectedly")
+		default:
+			// Process still running, continue
+		}
+	}
+
 	paramsData, err := json.Marshal(params)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal params: %w", err)
@@ -203,8 +235,8 @@ func (c *Client) Request(method string, params any) (json.RawMessage, error) {
 				return nil, response.Error
 			}
 			return response.Result, nil
-		case err := <-c.processDone:
-			if err != nil {
+		case <-c.processDone:
+			if err := c.getProcessError(); err != nil {
 				return nil, err
 			}
 			return nil, fmt.Errorf("process exited unexpectedly")

nodejs/test/e2e/client.test.ts

@@ -140,13 +140,31 @@ describe("Client", () => {
         });
         onTestFinishedForceStop(client);
 
+        let initialError: Error | undefined;
         try {
             await client.start();
             expect.fail("Expected start() to throw an error");
+        } catch (error) {
+            initialError = error as Error;
+            expect(initialError.message).toContain("stderr");
+            expect(initialError.message).toContain("nonexistent");
+        }
+
+        // Verify subsequent calls also fail with the same error
+        try {
+            const session = await client.createSession();
+            await session.send("test");
+            expect.fail("Expected send() to throw an error after CLI exit");
         } catch (error) {
             const message = (error as Error).message;
-            expect(message).toContain("stderr");
-            expect(message).toContain("nonexistent");
+            // Accept either stderr info or a "not connected" style error
+            expect(
+                message.includes("stderr") ||
+                message.includes("nonexistent") ||
+                message.includes("not connected") ||
+                message.includes("Connection") ||
+                message.includes("closed")
+            ).toBe(true);
         }
     });
 });

python/e2e/test_client.py

@@ -201,5 +201,20 @@ async def test_should_report_error_with_stderr_when_cli_fails_to_start(self):
             assert "nonexistent" in error_message, (
                 f"Expected error to contain 'nonexistent', got: {error_message}"
             )
+
+            # Verify subsequent calls also fail with the same error
+            with pytest.raises(Exception) as exc_info2:
+                session = await client.create_session()
+                await session.send("test")
+
+            error_message2 = str(exc_info2.value)
+            # Accept either stderr info or a generic connection error
+            assert (
+                "stderr" in error_message2
+                or "nonexistent" in error_message2
+                or "Invalid argument" in error_message2
+                or "not connected" in error_message2.lower()
+                or "closed" in error_message2.lower()
+            ), f"Expected subsequent error to reference CLI failure, got: {error_message2}"
         finally:
             await client.force_stop()