Update e2e tests for unwrapped session mode get/set

Author: SteveSandersonMS

dotnet/test/RpcTests.cs

@@ -88,19 +88,19 @@ public async Task Should_Get_And_Set_Session_Mode()
 
         // Get initial mode (default should be interactive)
         var initial = await session.Rpc.Mode.GetAsync();
-        Assert.Equal(SessionMode.Interactive, initial.Mode);
+        Assert.Equal(SessionMode.Interactive, initial);
 
         // Switch to plan mode
         var planResult = await session.Rpc.Mode.SetAsync(SessionMode.Plan);
-        Assert.Equal(SessionMode.Plan, planResult.Mode);
+        Assert.Equal(SessionMode.Plan, planResult);
 
         // Verify mode persisted
         var afterPlan = await session.Rpc.Mode.GetAsync();
-        Assert.Equal(SessionMode.Plan, afterPlan.Mode);
+        Assert.Equal(SessionMode.Plan, afterPlan);
 
         // Switch back to interactive
         var interactiveResult = await session.Rpc.Mode.SetAsync(SessionMode.Interactive);
-        Assert.Equal(SessionMode.Interactive, interactiveResult.Mode);
+        Assert.Equal(SessionMode.Interactive, interactiveResult);
     }
 
     [Fact]

go/internal/e2e/rpc_test.go

@@ -218,35 +218,35 @@ func TestSessionRpc(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Failed to get mode: %v", err)
 		}
-		if initial.Mode != rpc.SessionModeInteractive {
-			t.Errorf("Expected initial mode 'interactive', got %q", initial.Mode)
+		if *initial != rpc.SessionModeInteractive {
+			t.Errorf("Expected initial mode 'interactive', got %q", *initial)
 		}
 
 		// Switch to plan mode
 		planResult, err := session.RPC.Mode.Set(t.Context(), &rpc.ModeSetRequest{Mode: rpc.SessionModePlan})
 		if err != nil {
 			t.Fatalf("Failed to set mode to plan: %v", err)
 		}
-		if planResult.Mode != rpc.SessionModePlan {
-			t.Errorf("Expected mode 'plan', got %q", planResult.Mode)
+		if *planResult != rpc.SessionModePlan {
+			t.Errorf("Expected mode 'plan', got %q", *planResult)
 		}
 
 		// Verify mode persisted
 		afterPlan, err := session.RPC.Mode.Get(t.Context())
 		if err != nil {
 			t.Fatalf("Failed to get mode after plan: %v", err)
 		}
-		if afterPlan.Mode != rpc.SessionModePlan {
-			t.Errorf("Expected mode 'plan' after set, got %q", afterPlan.Mode)
+		if *afterPlan != rpc.SessionModePlan {
+			t.Errorf("Expected mode 'plan' after set, got %q", *afterPlan)
 		}
 
 		// Switch back to interactive
 		interactiveResult, err := session.RPC.Mode.Set(t.Context(), &rpc.ModeSetRequest{Mode: rpc.SessionModeInteractive})
 		if err != nil {
 			t.Fatalf("Failed to set mode to interactive: %v", err)
 		}
-		if interactiveResult.Mode != rpc.SessionModeInteractive {
-			t.Errorf("Expected mode 'interactive', got %q", interactiveResult.Mode)
+		if *interactiveResult != rpc.SessionModeInteractive {
+			t.Errorf("Expected mode 'interactive', got %q", *interactiveResult)
 		}
 	})
 

go/session.go

@@ -777,7 +777,7 @@ func (ui *SessionUI) Input(ctx context.Context, message string, opts *InputOptio
 			prop.MaxLength = &f
 		}
 		if opts.Format != "" {
-			format := rpc.UIElicitationSchemaPropertyStringFormatDetails(opts.Format)
+			format := rpc.UIElicitationSchemaPropertyStringFormat(opts.Format)
 			prop.Format = &format
 		}
 		if opts.Default != "" {

nodejs/test/e2e/rpc.test.ts

@@ -109,19 +109,19 @@ describe("Session RPC", async () => {
 
         // Get initial mode (default should be interactive)
         const initial = await session.rpc.mode.get();
-        expect(initial.mode).toBe("interactive");
+        expect(initial).toBe("interactive");
 
         // Switch to plan mode
         const planResult = await session.rpc.mode.set({ mode: "plan" });
-        expect(planResult.mode).toBe("plan");
+        expect(planResult).toBe("plan");
 
         // Verify mode persisted
         const afterPlan = await session.rpc.mode.get();
-        expect(afterPlan.mode).toBe("plan");
+        expect(afterPlan).toBe("plan");
 
         // Switch back to interactive
         const interactiveResult = await session.rpc.mode.set({ mode: "interactive" });
-        expect(interactiveResult.mode).toBe("interactive");
+        expect(interactiveResult).toBe("interactive");
     });
 
     it("should read, update, and delete plan", async () => {

python/e2e/test_rpc.py

@@ -126,21 +126,21 @@ async def test_get_and_set_session_mode(self):
 
             # Get initial mode (default should be interactive)
             initial = await session.rpc.mode.get()
-            assert initial.mode == SessionMode.INTERACTIVE
+            assert initial == SessionMode.INTERACTIVE
 
             # Switch to plan mode
             plan_result = await session.rpc.mode.set(ModeSetRequest(mode=SessionMode.PLAN))
-            assert plan_result.mode == SessionMode.PLAN
+            assert plan_result == SessionMode.PLAN
 
             # Verify mode persisted
             after_plan = await session.rpc.mode.get()
-            assert after_plan.mode == SessionMode.PLAN
+            assert after_plan == SessionMode.PLAN
 
             # Switch back to interactive
             interactive_result = await session.rpc.mode.set(
                 ModeSetRequest(mode=SessionMode.INTERACTIVE)
             )
-            assert interactive_result.mode == SessionMode.INTERACTIVE
+            assert interactive_result == SessionMode.INTERACTIVE
 
             await session.disconnect()
             await client.stop()