Phase G: snake_case fix-up on public dataclass fields

Mirrors PR #1357 phase B + api_review_python.md item B.9 (TypeScript SDK
API review). Public Python dataclasses no longer expose camelCase
attribute names; the wire JSON keys are unchanged.

Renames (Python attribute → wire JSON key):

* `PingResponse.protocolVersion` → `protocol_version` (wire: `protocolVersion`)
* `SessionContext.gitRoot` → `git_root` (wire: `gitRoot`)
* `SessionListFilter.gitRoot` → `git_root` (wire: `gitRoot`)
* `SessionMetadata.sessionId` → `session_id` (wire: `sessionId`)
* `SessionMetadata.startTime` → `start_time` (wire: `startTime`)
* `SessionMetadata.modifiedTime` → `modified_time` (wire: `modifiedTime`)
* `SessionMetadata.isRemote` → `is_remote` (wire: `isRemote`)
* `SessionLifecycleEventMetadata.startTime` → `start_time`
* `SessionLifecycleEventMetadata.modifiedTime` → `modified_time`
* `SessionLifecycleEventBase.sessionId` → `session_id`

Hook input TypedDicts (`PreToolUseHookInput`, `PreMcpToolCallHookInput`,
etc.) intentionally keep camelCase keys — those are wire-format dicts
delivered straight to handlers, not Python attributes.

Tests + docs updated.

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

Author: SteveSandersonMS

python/README.md

@@ -199,12 +199,12 @@ await client.set_foreground_session_id("session-123")
 
 # Subscribe to all lifecycle events
 def on_lifecycle(event):
-    print(f"{event.type}: {event.sessionId}")
+    print(f"{event.type}: {event.session_id}")
 
 unsubscribe = client.on_lifecycle(on_lifecycle)
 
 # Subscribe to specific event type
-unsubscribe = client.on_lifecycle("session.foreground", lambda e: print(f"Foreground: {e.sessionId}"))
+unsubscribe = client.on_lifecycle("session.foreground", lambda e: print(f"Foreground: {e.session_id}"))
 
 # Later, to stop receiving events:
 unsubscribe()

python/copilot/client.py

@@ -351,32 +351,32 @@ class PingResponse:
     """Response from ping"""
 
     message: str  # Echo message with "pong: " prefix
-    timestamp: datetime  # ISO 8601 timestamp when the ping was processed
-    protocolVersion: int  # Protocol version for SDK compatibility
+    timestamp: datetime  # Timestamp when the ping was processed
+    protocol_version: int  # Protocol version for SDK compatibility
 
     @staticmethod
     def from_dict(obj: Any) -> PingResponse:
         assert isinstance(obj, dict)
         message = obj.get("message")
         timestamp = obj.get("timestamp")
-        protocolVersion = obj.get("protocolVersion")
-        if message is None or timestamp is None or protocolVersion is None:
+        protocol_version = obj.get("protocolVersion")
+        if message is None or timestamp is None or protocol_version is None:
             raise ValueError(
                 f"Missing required fields in PingResponse: message={message}, "
-                f"timestamp={timestamp}, protocolVersion={protocolVersion}"
+                f"timestamp={timestamp}, protocolVersion={protocol_version}"
             )
         timestamp_value = (
             datetime.fromtimestamp(timestamp / 1000, tz=UTC)
             if isinstance(timestamp, (int, float))
             else from_datetime(timestamp)
         )
-        return PingResponse(str(message), timestamp_value, int(protocolVersion))
+        return PingResponse(str(message), timestamp_value, int(protocol_version))
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["message"] = self.message
         result["timestamp"] = self.timestamp.isoformat()
-        result["protocolVersion"] = self.protocolVersion
+        result["protocolVersion"] = self.protocol_version
         return result
 
 
@@ -757,7 +757,7 @@ class SessionContext:
     """Working directory context for a session"""
 
     working_directory: str  # Working directory where the session was created
-    gitRoot: str | None = None  # Git repository root (if in a git repo)
+    git_root: str | None = None  # Git repository root (if in a git repo)
     repository: str | None = None  # GitHub repository in "owner/repo" format
     branch: str | None = None  # Current git branch
 
@@ -769,15 +769,15 @@ def from_dict(obj: Any) -> SessionContext:
             raise ValueError("Missing required field 'cwd' in SessionContext")
         return SessionContext(
             working_directory=str(cwd),
-            gitRoot=obj.get("gitRoot"),
+            git_root=obj.get("gitRoot"),
             repository=obj.get("repository"),
             branch=obj.get("branch"),
         )
 
     def to_dict(self) -> dict:
         result: dict = {"cwd": self.working_directory}
-        if self.gitRoot is not None:
-            result["gitRoot"] = self.gitRoot
+        if self.git_root is not None:
+            result["gitRoot"] = self.git_root
         if self.repository is not None:
             result["repository"] = self.repository
         if self.branch is not None:
@@ -790,16 +790,16 @@ class SessionListFilter:
     """Filter options for listing sessions"""
 
     working_directory: str | None = None  # Filter by exact working directory match
-    gitRoot: str | None = None  # Filter by git root
+    git_root: str | None = None  # Filter by git root
     repository: str | None = None  # Filter by repository (owner/repo format)
     branch: str | None = None  # Filter by branch
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.working_directory is not None:
             result["cwd"] = self.working_directory
-        if self.gitRoot is not None:
-            result["gitRoot"] = self.gitRoot
+        if self.git_root is not None:
+            result["gitRoot"] = self.git_root
         if self.repository is not None:
             result["repository"] = self.repository
         if self.branch is not None:
@@ -811,43 +811,43 @@ def to_dict(self) -> dict:
 class SessionMetadata:
     """Metadata about a session"""
 
-    sessionId: str  # Session identifier
-    startTime: datetime  # Timestamp when session was created
-    modifiedTime: datetime  # Timestamp when session was last modified
-    isRemote: bool  # Whether the session is remote
+    session_id: str  # Session identifier
+    start_time: datetime  # Timestamp when session was created
+    modified_time: datetime  # Timestamp when session was last modified
+    is_remote: bool  # Whether the session is remote
     summary: str | None = None  # Optional summary of the session
     context: SessionContext | None = None  # Working directory context
 
     @staticmethod
     def from_dict(obj: Any) -> SessionMetadata:
         assert isinstance(obj, dict)
-        sessionId = obj.get("sessionId")
-        startTime = obj.get("startTime")
-        modifiedTime = obj.get("modifiedTime")
-        isRemote = obj.get("isRemote")
-        if sessionId is None or startTime is None or modifiedTime is None or isRemote is None:
+        session_id = obj.get("sessionId")
+        start_time = obj.get("startTime")
+        modified_time = obj.get("modifiedTime")
+        is_remote = obj.get("isRemote")
+        if session_id is None or start_time is None or modified_time is None or is_remote is None:
             raise ValueError(
-                f"Missing required fields in SessionMetadata: sessionId={sessionId}, "
-                f"startTime={startTime}, modifiedTime={modifiedTime}, isRemote={isRemote}"
+                f"Missing required fields in SessionMetadata: sessionId={session_id}, "
+                f"startTime={start_time}, modifiedTime={modified_time}, isRemote={is_remote}"
             )
         summary = obj.get("summary")
         context_dict = obj.get("context")
         context = SessionContext.from_dict(context_dict) if context_dict else None
         return SessionMetadata(
-            sessionId=str(sessionId),
-            startTime=_parse_session_timestamp(startTime),
-            modifiedTime=_parse_session_timestamp(modifiedTime),
-            isRemote=bool(isRemote),
+            session_id=str(session_id),
+            start_time=_parse_session_timestamp(start_time),
+            modified_time=_parse_session_timestamp(modified_time),
+            is_remote=bool(is_remote),
             summary=summary,
             context=context,
         )
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["sessionId"] = self.sessionId
-        result["startTime"] = self.startTime.isoformat()
-        result["modifiedTime"] = self.modifiedTime.isoformat()
-        result["isRemote"] = self.isRemote
+        result["sessionId"] = self.session_id
+        result["startTime"] = self.start_time.isoformat()
+        result["modifiedTime"] = self.modified_time.isoformat()
+        result["isRemote"] = self.is_remote
         if self.summary is not None:
             result["summary"] = self.summary
         if self.context is not None:
@@ -884,15 +884,15 @@ def _parse_session_timestamp(value: Any) -> datetime:
 class SessionLifecycleEventMetadata:
     """Metadata for session lifecycle events."""
 
-    startTime: datetime
-    modifiedTime: datetime
+    start_time: datetime
+    modified_time: datetime
     summary: str | None = None
 
     @staticmethod
     def from_dict(data: dict) -> SessionLifecycleEventMetadata:
         return SessionLifecycleEventMetadata(
-            startTime=_parse_session_timestamp(data.get("startTime", "")),
-            modifiedTime=_parse_session_timestamp(data.get("modifiedTime", "")),
+            start_time=_parse_session_timestamp(data.get("startTime", "")),
+            modified_time=_parse_session_timestamp(data.get("modifiedTime", "")),
             summary=data.get("summary"),
         )
 
@@ -906,7 +906,7 @@ class SessionLifecycleEventBase:
     branch on the event kind.
     """
 
-    sessionId: str
+    session_id: str
     metadata: SessionLifecycleEventMetadata | None = None
 
 
@@ -962,17 +962,17 @@ def _session_lifecycle_event_from_dict(data: dict) -> SessionLifecycleEvent:
     session_id = data.get("sessionId", "")
     match data.get("type"):
         case "session.created":
-            return SessionCreatedEvent(sessionId=session_id, metadata=metadata)
+            return SessionCreatedEvent(session_id=session_id, metadata=metadata)
         case "session.deleted":
-            return SessionDeletedEvent(sessionId=session_id, metadata=metadata)
+            return SessionDeletedEvent(session_id=session_id, metadata=metadata)
         case "session.foreground":
-            return SessionForegroundEvent(sessionId=session_id, metadata=metadata)
+            return SessionForegroundEvent(session_id=session_id, metadata=metadata)
         case "session.background":
-            return SessionBackgroundEvent(sessionId=session_id, metadata=metadata)
+            return SessionBackgroundEvent(session_id=session_id, metadata=metadata)
         case _:
             # Default to ``session.updated`` for unknown event types so consumers
             # keep working across server upgrades.
-            return SessionUpdatedEvent(sessionId=session_id, metadata=metadata)
+            return SessionUpdatedEvent(session_id=session_id, metadata=metadata)
 
 
 SessionLifecycleHandler = Callable[[SessionLifecycleEvent], None]
@@ -2419,7 +2419,7 @@ async def get_session_metadata(self, session_id: str) -> SessionMetadata | None:
         Example:
             >>> metadata = await client.get_session_metadata("session-123")
             >>> if metadata:
-            ...     print(f"Session started at: {metadata.startTime}")
+            ...     print(f"Session started at: {metadata.start_time}")
         """
         if not self._client:
             raise RuntimeError("Client not connected")
@@ -2573,11 +2573,11 @@ def on_lifecycle(
         Example:
             >>> # Subscribe to specific event type
             >>> unsubscribe = client.on_lifecycle(
-            ...     "session.foreground", lambda e: print(e.sessionId)
+            ...     "session.foreground", lambda e: print(e.session_id)
             ... )
             >>>
             >>> # Subscribe to all events
-            >>> unsubscribe = client.on_lifecycle(lambda e: print(f"{e.type}: {e.sessionId}"))
+            >>> unsubscribe = client.on_lifecycle(lambda e: print(f"{e.type}: {e.session_id}"))
             >>>
             >>> # Later, to stop receiving events:
             >>> unsubscribe()

python/e2e/test_client_e2e.py

@@ -105,8 +105,8 @@ async def test_should_get_status_with_version_and_protocol_info(self):
             assert hasattr(status, "version")
             assert isinstance(status.version, str)
             assert hasattr(status, "protocolVersion")
-            assert isinstance(status.protocolVersion, int)
-            assert status.protocolVersion >= 1
+            assert isinstance(status.protocol_version, int)
+            assert status.protocol_version >= 1
 
             await client.stop()
         finally:

python/e2e/test_client_lifecycle_e2e.py

@@ -118,7 +118,7 @@ def handler(event):
             try:
                 event = await asyncio.wait_for(created, 10.0)
                 assert event.type == "session.created"
-                assert event.sessionId == session.session_id
+                assert event.session_id == session.session_id
             finally:
                 await session.disconnect()
         finally:
@@ -140,7 +140,7 @@ def handler(event):
             try:
                 event = await asyncio.wait_for(created, 10.0)
                 assert event.type == "session.created"
-                assert event.sessionId == session.session_id
+                assert event.session_id == session.session_id
             finally:
                 await session.disconnect()
         finally:
@@ -170,7 +170,7 @@ def disposed_handler(_event):
             )
             try:
                 event = await asyncio.wait_for(active_event, 10.0)
-                assert event.sessionId == session.session_id
+                assert event.session_id == session.session_id
                 assert unsubscribed_count == 0, "Disposed handler should not have fired"
             finally:
                 await session.disconnect()
@@ -206,7 +206,7 @@ async def test_should_receive_session_updated_lifecycle_event_for_non_ephemeral_
         def handler(event):
             if (
                 event.type == "session.updated"
-                and event.sessionId == session.session_id
+                and event.session_id == session.session_id
                 and not updated.done()
             ):
                 updated.set_result(event)
@@ -216,7 +216,7 @@ def handler(event):
             await session.rpc.mode.set(ModeSetRequest(mode=SessionMode.PLAN))
             event = await asyncio.wait_for(updated, timeout=15.0)
             assert event.type == "session.updated"
-            assert event.sessionId == session.session_id
+            assert event.session_id == session.session_id
         finally:
             unsubscribe()
             await session.disconnect()
@@ -241,7 +241,7 @@ async def test_should_receive_session_deleted_lifecycle_event_when_deleted(
         def handler(event):
             if (
                 event.type == "session.deleted"
-                and event.sessionId == session_id
+                and event.session_id == session_id
                 and not deleted.done()
             ):
                 deleted.set_result(event)
@@ -253,6 +253,6 @@ def handler(event):
 
             event = await asyncio.wait_for(deleted, timeout=15.0)
             assert event.type == "session.deleted"
-            assert event.sessionId == session_id
+            assert event.session_id == session_id
         finally:
             unsubscribe()

python/e2e/test_client_options_e2e.py

@@ -142,7 +142,7 @@ def _get_available_port() -> int:
     return;
   }
   if (message.method === "session.create") {
-    const sessionId = message.params?.sessionId ?? "fake-session";
+    const sessionId = message.params?.session_id ?? "fake-session";
     writeResponse(message.id, { sessionId, workspacePath: null, capabilities: null });
     return;
   }