test: add clientName forwarding tests across all SDKs

Add tests verifying clientName is included in session.create and
session.resume RPC payloads when set:

- Node.js: spy on connection.sendRequest to verify payload
- Python: mock _client.request to capture and assert payload
- Go: JSON serialization tests for internal request structs
- .NET: clone test for ClientName on SessionConfig

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

Author: devm33

dotnet/test/CloneTests.cs

@@ -78,6 +78,7 @@ public void SessionConfig_Clone_CopiesAllProperties()
         var original = new SessionConfig
         {
             SessionId = "test-session",
+            ClientName = "my-app",
             Model = "gpt-4",
             ReasoningEffort = "high",
             ConfigDir = "/config",
@@ -94,6 +95,7 @@ public void SessionConfig_Clone_CopiesAllProperties()
         var clone = original.Clone();
 
         Assert.Equal(original.SessionId, clone.SessionId);
+        Assert.Equal(original.ClientName, clone.ClientName);
         Assert.Equal(original.Model, clone.Model);
         Assert.Equal(original.ReasoningEffort, clone.ReasoningEffort);
         Assert.Equal(original.ConfigDir, clone.ConfigDir);

go/client_test.go

@@ -1,6 +1,7 @@
 package copilot
 
 import (
+	"encoding/json"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -389,3 +390,57 @@ func fileExistsForTest(path string) bool {
 	_, err := os.Stat(path)
 	return err == nil
 }
+
+func TestCreateSessionRequest_ClientName(t *testing.T) {
+	t.Run("includes clientName in JSON when set", func(t *testing.T) {
+		req := createSessionRequest{ClientName: "my-app"}
+		data, err := json.Marshal(req)
+		if err != nil {
+			t.Fatalf("Failed to marshal: %v", err)
+		}
+		var m map[string]any
+		if err := json.Unmarshal(data, &m); err != nil {
+			t.Fatalf("Failed to unmarshal: %v", err)
+		}
+		if m["clientName"] != "my-app" {
+			t.Errorf("Expected clientName to be 'my-app', got %v", m["clientName"])
+		}
+	})
+
+	t.Run("omits clientName from JSON when empty", func(t *testing.T) {
+		req := createSessionRequest{}
+		data, _ := json.Marshal(req)
+		var m map[string]any
+		json.Unmarshal(data, &m)
+		if _, ok := m["clientName"]; ok {
+			t.Error("Expected clientName to be omitted when empty")
+		}
+	})
+}
+
+func TestResumeSessionRequest_ClientName(t *testing.T) {
+	t.Run("includes clientName in JSON when set", func(t *testing.T) {
+		req := resumeSessionRequest{SessionID: "s1", ClientName: "my-app"}
+		data, err := json.Marshal(req)
+		if err != nil {
+			t.Fatalf("Failed to marshal: %v", err)
+		}
+		var m map[string]any
+		if err := json.Unmarshal(data, &m); err != nil {
+			t.Fatalf("Failed to unmarshal: %v", err)
+		}
+		if m["clientName"] != "my-app" {
+			t.Errorf("Expected clientName to be 'my-app', got %v", m["clientName"])
+		}
+	})
+
+	t.Run("omits clientName from JSON when empty", func(t *testing.T) {
+		req := resumeSessionRequest{SessionID: "s1"}
+		data, _ := json.Marshal(req)
+		var m map[string]any
+		json.Unmarshal(data, &m)
+		if _, ok := m["clientName"]; ok {
+			t.Error("Expected clientName to be omitted when empty")
+		}
+	})
+}

nodejs/test/client.test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, expect, it, onTestFinished } from "vitest";
+import { describe, expect, it, onTestFinished, vi } from "vitest";
 import { CopilotClient } from "../src/index.js";
 
 // This file is for unit tests. Where relevant, prefer to add e2e tests in e2e/*.test.ts instead
@@ -27,6 +27,35 @@ describe("CopilotClient", () => {
         });
     });
 
+    it("forwards clientName in session.create request", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const spy = vi.spyOn((client as any).connection!, "sendRequest");
+        await client.createSession({ clientName: "my-app" });
+
+        expect(spy).toHaveBeenCalledWith(
+            "session.create",
+            expect.objectContaining({ clientName: "my-app" })
+        );
+    });
+
+    it("forwards clientName in session.resume request", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const session = await client.createSession();
+        const spy = vi.spyOn((client as any).connection!, "sendRequest");
+        await client.resumeSession(session.sessionId, { clientName: "my-app" });
+
+        expect(spy).toHaveBeenCalledWith(
+            "session.resume",
+            expect.objectContaining({ clientName: "my-app", sessionId: session.sessionId })
+        );
+    });
+
     describe("URL parsing", () => {
         it("should parse port-only URL format", () => {
             const client = new CopilotClient({

python/test_client.py

@@ -147,3 +147,45 @@ def test_use_logged_in_user_with_cli_url_raises(self):
             CopilotClient(
                 {"cli_url": "localhost:8080", "use_logged_in_user": False, "log_level": "error"}
             )
+
+
+class TestSessionConfigForwarding:
+    @pytest.mark.asyncio
+    async def test_create_session_forwards_client_name(self):
+        client = CopilotClient({"cli_path": CLI_PATH})
+        await client.start()
+
+        try:
+            captured = {}
+            original_request = client._client.request
+
+            async def mock_request(method, params):
+                captured[method] = params
+                return await original_request(method, params)
+
+            client._client.request = mock_request
+            await client.create_session({"client_name": "my-app"})
+            assert captured["session.create"]["clientName"] == "my-app"
+        finally:
+            await client.force_stop()
+
+    @pytest.mark.asyncio
+    async def test_resume_session_forwards_client_name(self):
+        client = CopilotClient({"cli_path": CLI_PATH})
+        await client.start()
+
+        try:
+            session = await client.create_session()
+
+            captured = {}
+            original_request = client._client.request
+
+            async def mock_request(method, params):
+                captured[method] = params
+                return await original_request(method, params)
+
+            client._client.request = mock_request
+            await client.resume_session(session.session_id, {"client_name": "my-app"})
+            assert captured["session.resume"]["clientName"] == "my-app"
+        finally:
+            await client.force_stop()