Python SDK: refactor types to idiomatic snake_case dataclasses

- ToolResult, ToolInvocation, ToolBinaryResult: TypedDict(camelCase) -> dataclass(snake_case)
- PermissionRequest: remove handwritten TypedDict, re-export codegen'd dataclass
- PermissionRequestResult: TypedDict -> dataclass with snake_case fields
- Update all tests to use attribute access instead of dict access
- Remove stale TestHandleToolCallRequest (tested removed v2 RPC method)

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

Author: SteveSandersonMS

python/copilot/session.py

@@ -317,47 +317,34 @@ async def _execute_tool_and_respond(
     ) -> None:
         """Execute a tool handler and send the result back via HandlePendingToolCall RPC."""
         try:
-            invocation: ToolInvocation = {
-                "session_id": self.session_id,
-                "tool_call_id": tool_call_id,
-                "tool_name": tool_name,
-                "arguments": arguments,
-            }
+            invocation = ToolInvocation(
+                session_id=self.session_id,
+                tool_call_id=tool_call_id,
+                tool_name=tool_name,
+                arguments=arguments,
+            )
 
             result = handler(invocation)
             if inspect.isawaitable(result):
                 result = await result
 
             if result is None:
                 result = ToolResult(
-                    textResultForLlm="Tool returned no result.",
-                    resultType="failure",
+                    text_result_for_llm="Tool returned no result.",
+                    result_type="failure",
                     error="tool returned no result",
-                    toolTelemetry={},
+                    tool_telemetry={},
                 )
 
-            # Build a structured ResultResult from the ToolResult
-            text_result = ""
-            error_str = None
-            result_type = None
-            tool_telemetry = None
-
-            if isinstance(result, dict):
-                text_result = result.get("textResultForLlm", str(result))
-                error_str = result.get("error")
-                result_type = result.get("resultType")
-                tool_telemetry = result.get("toolTelemetry")
-            else:
-                text_result = str(result)
 
             await self.rpc.tools.handle_pending_tool_call(
                 SessionToolsHandlePendingToolCallParams(
                     request_id=request_id,
                     result=ResultResult(
-                        text_result_for_llm=text_result,
-                        error=error_str,
-                        result_type=result_type,
-                        tool_telemetry=tool_telemetry,
+                        text_result_for_llm=result.text_result_for_llm,
+                        error=result.error,
+                        result_type=result.result_type,
+                        tool_telemetry=result.tool_telemetry,
                     ),
                 )
             )
@@ -380,36 +367,18 @@ async def _execute_permission_and_respond(
     ) -> None:
         """Execute a permission handler and respond via RPC."""
         try:
-            # Convert from generated PermissionRequest to dict for the handler
-            if hasattr(permission_request, "to_dict"):
-                perm_dict = permission_request.to_dict()
-            elif isinstance(permission_request, dict):
-                perm_dict = permission_request
-            else:
-                perm_dict = permission_request
-
-            result = handler(perm_dict, {"session_id": self.session_id})
+            result = handler(permission_request, {"session_id": self.session_id})
             if inspect.isawaitable(result):
                 result = await result
 
             result = cast(PermissionRequestResult, result)
-            default_kind = "denied-no-approval-rule-and-could-not-request-from-user"
-            if isinstance(result, dict):
-                kind_str = result.get("kind", default_kind)
-            else:
-                kind_str = getattr(result, "kind", default_kind)
-
-            def _get(key: str) -> Any:
-                if isinstance(result, dict):
-                    return result.get(key)
-                return getattr(result, key, None)
 
             perm_result = SessionPermissionsHandlePendingPermissionRequestParamsResult(
-                kind=Kind(kind_str),
-                rules=_get("rules"),
-                feedback=_get("feedback"),
-                message=_get("message"),
-                path=_get("path"),
+                kind=Kind(result.kind),
+                rules=result.rules,
+                feedback=result.feedback,
+                message=result.message,
+                path=result.path,
             )
 
             await self.rpc.permissions.handle_pending_permission_request(
@@ -509,7 +478,7 @@ async def _handle_permission_request(
 
         if not handler:
             # No handler registered, deny permission
-            return {"kind": "denied-no-approval-rule-and-could-not-request-from-user"}
+            return PermissionRequestResult()
 
         try:
             result = handler(request, {"session_id": self.session_id})
@@ -518,7 +487,7 @@ async def _handle_permission_request(
             return cast(PermissionRequestResult, result)
         except Exception:  # pylint: disable=broad-except
             # Handler failed, deny permission
-            return {"kind": "denied-no-approval-rule-and-could-not-request-from-user"}
+            return PermissionRequestResult()
 
     def _register_user_input_handler(self, handler: UserInputHandler | None) -> None:
         """

python/copilot/tools.py

@@ -122,7 +122,7 @@ async def wrapped_handler(invocation: ToolInvocation) -> ToolResult:
                 # Build args based on detected signature
                 call_args = []
                 if takes_params:
-                    args = invocation["arguments"] or {}
+                    args = invocation.arguments or {}
                     if ptype is not None and _is_pydantic_model(ptype):
                         call_args.append(ptype.model_validate(args))
                     else:
@@ -141,11 +141,11 @@ async def wrapped_handler(invocation: ToolInvocation) -> ToolResult:
                 # Don't expose detailed error information to the LLM for security reasons.
                 # The actual error is stored in the 'error' field for debugging.
                 return ToolResult(
-                    textResultForLlm="Invoking this tool produced an error. "
+                    text_result_for_llm="Invoking this tool produced an error. "
                     "Detailed information is not available.",
-                    resultType="failure",
+                    result_type="failure",
                     error=str(exc),
-                    toolTelemetry={},
+                    tool_telemetry={},
                 )
 
         return Tool(
@@ -185,19 +185,19 @@ def _normalize_result(result: Any) -> ToolResult:
     """
     if result is None:
         return ToolResult(
-            textResultForLlm="",
-            resultType="success",
+            text_result_for_llm="",
+            result_type="success",
         )
 
-    # ToolResult passes through directly
-    if isinstance(result, dict) and "resultType" in result and "textResultForLlm" in result:
+    # ToolResult dataclass passes through directly
+    if isinstance(result, ToolResult):
         return result
 
     # Strings pass through directly
     if isinstance(result, str):
         return ToolResult(
-            textResultForLlm=result,
-            resultType="success",
+            text_result_for_llm=result,
+            result_type="success",
         )
 
     # Everything else gets JSON-serialized (with Pydantic model support)
@@ -212,6 +212,6 @@ def default(obj: Any) -> Any:
         raise TypeError(f"Failed to serialize tool result: {exc}") from exc
 
     return ToolResult(
-        textResultForLlm=json_str,
-        resultType="success",
+        text_result_for_llm=json_str,
+        result_type="success",
     )

python/copilot/types.py

@@ -9,7 +9,10 @@
 from typing import Any, Literal, NotRequired, TypedDict
 
 # Import generated SessionEvent types
-from .generated.session_events import SessionEvent
+from .generated.session_events import (
+    PermissionRequest,
+    SessionEvent,
+)
 
 # SessionEvent is now imported from generated types
 # It provides proper type discrimination for all event types
@@ -100,29 +103,36 @@ class CopilotClientOptions(TypedDict, total=False):
 ToolResultType = Literal["success", "failure", "rejected", "denied"]
 
 
-class ToolBinaryResult(TypedDict, total=False):
-    data: str
-    mimeType: str
-    type: str
-    description: str
+@dataclass
+class ToolBinaryResult:
+    """Binary content returned by a tool."""
+
+    data: str = ""
+    mime_type: str = ""
+    type: str = ""
+    description: str = ""
 
 
-class ToolResult(TypedDict, total=False):
+@dataclass
+class ToolResult:
     """Result of a tool invocation."""
 
-    textResultForLlm: str
-    binaryResultsForLlm: list[ToolBinaryResult]
-    resultType: ToolResultType
-    error: str
-    sessionLog: str
-    toolTelemetry: dict[str, Any]
+    text_result_for_llm: str = ""
+    result_type: ToolResultType = "success"
+    error: str | None = None
+    binary_results_for_llm: list[ToolBinaryResult] | None = None
+    session_log: str | None = None
+    tool_telemetry: dict[str, Any] | None = None
 
 
-class ToolInvocation(TypedDict):
-    session_id: str
-    tool_call_id: str
-    tool_name: str
-    arguments: Any
+@dataclass
+class ToolInvocation:
+    """Context passed to a tool handler when invoked."""
+
+    session_id: str = ""
+    tool_call_id: str = ""
+    tool_name: str = ""
+    arguments: Any = None
 
 
 ToolHandler = Callable[[ToolInvocation], ToolResult | Awaitable[ToolResult]]
@@ -164,25 +174,26 @@ class SystemMessageReplaceConfig(TypedDict):
 SystemMessageConfig = SystemMessageAppendConfig | SystemMessageReplaceConfig
 
 
-# Permission request types
-class PermissionRequest(TypedDict, total=False):
-    """Permission request from the server"""
-
-    kind: Literal["shell", "write", "mcp", "read", "url", "custom-tool"]
-    toolCallId: str
-    # Additional fields vary by kind
+# Permission result types
 
+PermissionRequestResultKind = Literal[
+    "approved",
+    "denied-by-rules",
+    "denied-by-content-exclusion-policy",
+    "denied-no-approval-rule-and-could-not-request-from-user",
+    "denied-interactively-by-user",
+]
 
-class PermissionRequestResult(TypedDict, total=False):
-    """Result of a permission request"""
 
-    kind: Literal[
-        "approved",
-        "denied-by-rules",
-        "denied-no-approval-rule-and-could-not-request-from-user",
-        "denied-interactively-by-user",
-    ]
-    rules: list[Any]
+@dataclass
+class PermissionRequestResult:
+    """Result of a permission request."""
+
+    kind: PermissionRequestResultKind = "denied-no-approval-rule-and-could-not-request-from-user"
+    rules: list[Any] | None = None
+    feedback: str | None = None
+    message: str | None = None
+    path: str | None = None
 
 
 _PermissionHandlerFn = Callable[

python/e2e/test_multi_client.py

@@ -13,7 +13,13 @@
 import pytest_asyncio
 from pydantic import BaseModel, Field
 
-from copilot import CopilotClient, PermissionHandler, ToolInvocation, define_tool
+from copilot import (
+    CopilotClient,
+    PermissionHandler,
+    PermissionRequestResult,
+    ToolInvocation,
+    define_tool,
+)
 
 from .testharness import get_final_assistant_message
 from .testharness.proxy import CapiProxy
@@ -232,7 +238,7 @@ async def test_one_client_approves_permission(self, mctx: MultiClientContext):
         session1 = await mctx.client1.create_session(
             {
                 "on_permission_request": lambda request, invocation: (
-                    permission_requests.append(request) or {"kind": "approved"}
+                    permission_requests.append(request) or PermissionRequestResult(kind="approved")
                 ),
             }
         )
@@ -279,9 +285,9 @@ async def test_one_client_rejects_permission(self, mctx: MultiClientContext):
         # Client 1 creates a session and denies all permission requests
         session1 = await mctx.client1.create_session(
             {
-                "on_permission_request": lambda request, invocation: {
-                    "kind": "denied-interactively-by-user"
-                },
+                "on_permission_request": lambda request, invocation: (
+                    PermissionRequestResult(kind="denied-interactively-by-user")
+                ),
             }
         )