fix: Convert camelCase to snake_case for Python naming conventions (#146)

ashwin-ant · claude · web-flow · commit 681f46c873f5 · 2025-09-04T19:26:00.000-07:00
- Renamed PermissionRuleValue fields: toolName → tool_name, ruleContent → rule_content - Renamed PermissionResultAllow fields: updatedInput → updated_input, updatedPermissions → updated_permissions - Removed unused PermissionResult import from query.py - Fixed trailing whitespace issues in types.py - Updated all usages in examples and tests to use snake_case These changes ensure compliance with Python's PEP 8 naming conventions and fix linting errors. 🤖 Generated with [Claude Code](https://claude.ai/code) --------- Co-authored-by: Claude <noreply@anthropic.com>
diff --git a/examples/tool_permission_callback.py b/examples/tool_permission_callback.py
@@ -61,7 +61,7 @@ async def my_permission_callback(
             modified_input = input_data.copy()
             modified_input["file_path"] = safe_path
             return PermissionResultAllow(
-                updatedInput=modified_input
+                updated_input=modified_input
             )
 
     # Check dangerous bash commands
diff --git a/src/claude_code_sdk/__init__.py b/src/claude_code_sdk/__init__.py
@@ -57,7 +57,7 @@ class SdkMcpTool(Generic[T]):
 
 def tool(
     name: str, description: str, input_schema: type | dict[str, Any]
-) -> Callable[[Callable[[Any], Awaitable[dict[str, Any]]]], SdkMcpTool]:
+) -> Callable[[Callable[[Any], Awaitable[dict[str, Any]]]], SdkMcpTool[Any]]:
     """Decorator for defining MCP tools with type safety.
 
     Creates a tool that can be used with SDK MCP servers. The tool runs
@@ -105,7 +105,9 @@ def tool(
         - Errors can be indicated by including "is_error": True in the response
     """
 
-    def decorator(handler: Callable[[Any], Awaitable[dict[str, Any]]]) -> SdkMcpTool:
+    def decorator(
+        handler: Callable[[Any], Awaitable[dict[str, Any]]],
+    ) -> SdkMcpTool[Any]:
         return SdkMcpTool(
             name=name,
             description=description,
@@ -117,7 +119,7 @@ def decorator(handler: Callable[[Any], Awaitable[dict[str, Any]]]) -> SdkMcpTool
 
 
 def create_sdk_mcp_server(
-    name: str, version: str = "1.0.0", tools: list[SdkMcpTool] | None = None
+    name: str, version: str = "1.0.0", tools: list[SdkMcpTool[Any]] | None = None
 ) -> McpSdkServerConfig:
     """Create an in-process MCP server that runs within your Python application.
 
@@ -200,7 +202,7 @@ def create_sdk_mcp_server(
         tool_map = {tool_def.name: tool_def for tool_def in tools}
 
         # Register list_tools handler to expose available tools
-        @server.list_tools()
+        @server.list_tools()  # type: ignore[no-untyped-call,misc]
         async def list_tools() -> list[Tool]:
             """Return the list of available tools."""
             tool_list = []
@@ -246,8 +248,8 @@ async def list_tools() -> list[Tool]:
             return tool_list
 
         # Register call_tool handler to execute tools
-        @server.call_tool()
-        async def call_tool(name: str, arguments: dict) -> Any:
+        @server.call_tool()  # type: ignore[misc]
+        async def call_tool(name: str, arguments: dict[str, Any]) -> Any:
             """Execute a tool by name with given arguments."""
             if name not in tool_map:
                 raise ValueError(f"Tool '{name}' not found")
diff --git a/src/claude_code_sdk/_internal/client.py b/src/claude_code_sdk/_internal/client.py
@@ -20,17 +20,17 @@ def __init__(self) -> None:
         """Initialize the internal client."""
 
     def _convert_hooks_to_internal_format(
-        self, hooks: dict[str, list]
+        self, hooks: dict[str, list[Any]]
     ) -> dict[str, list[dict[str, Any]]]:
         """Convert HookMatcher format to internal Query format."""
-        internal_hooks = {}
+        internal_hooks: dict[str, list[dict[str, Any]]] = {}
         for event, matchers in hooks.items():
             internal_hooks[event] = []
             for matcher in matchers:
                 # Convert HookMatcher to internal dict format
                 internal_matcher = {
-                    "matcher": matcher.matcher if hasattr(matcher, 'matcher') else None,
-                    "hooks": matcher.hooks if hasattr(matcher, 'hooks') else []
+                    "matcher": matcher.matcher if hasattr(matcher, "matcher") else None,
+                    "hooks": matcher.hooks if hasattr(matcher, "hooks") else [],
                 }
                 internal_hooks[event].append(internal_matcher)
         return internal_hooks
@@ -57,15 +57,17 @@ async def process_query(
         if options.mcp_servers and isinstance(options.mcp_servers, dict):
             for name, config in options.mcp_servers.items():
                 if isinstance(config, dict) and config.get("type") == "sdk":
-                    sdk_mcp_servers[name] = config["instance"]
+                    sdk_mcp_servers[name] = config["instance"]  # type: ignore[typeddict-item]
 
         # Create Query to handle control protocol
         is_streaming = not isinstance(prompt, str)
         query = Query(
             transport=chosen_transport,
             is_streaming_mode=is_streaming,
             can_use_tool=options.can_use_tool,
-            hooks=self._convert_hooks_to_internal_format(options.hooks) if options.hooks else None,
+            hooks=self._convert_hooks_to_internal_format(options.hooks)
+            if options.hooks
+            else None,
             sdk_mcp_servers=sdk_mcp_servers,
         )
 
diff --git a/src/claude_code_sdk/_internal/query.py b/src/claude_code_sdk/_internal/query.py
@@ -15,7 +15,6 @@
 )
 
 from ..types import (
-    PermissionResult,
     PermissionResultAllow,
     PermissionResultDeny,
     SDKControlPermissionRequest,
@@ -48,7 +47,8 @@ def __init__(
         transport: Transport,
         is_streaming_mode: bool,
         can_use_tool: Callable[
-            [str, dict[str, Any], dict[str, Any]], Awaitable[dict[str, Any]]
+            [str, dict[str, Any], ToolPermissionContext],
+            Awaitable[PermissionResultAllow | PermissionResultDeny],
         ]
         | None = None,
         hooks: dict[str, list[dict[str, Any]]] | None = None,
@@ -191,7 +191,7 @@ async def _handle_control_request(self, request: SDKControlRequest) -> None:
         subtype = request_data["subtype"]
 
         try:
-            response_data = {}
+            response_data: dict[str, Any] = {}
 
             if subtype == "can_use_tool":
                 permission_request: SDKControlPermissionRequest = request_data  # type: ignore[assignment]
@@ -202,30 +202,28 @@ async def _handle_control_request(self, request: SDKControlRequest) -> None:
                 context = ToolPermissionContext(
                     signal=None,  # TODO: Add abort signal support
                     suggestions=permission_request.get("permission_suggestions", [])
+                    or [],
                 )
 
                 response = await self.can_use_tool(
                     permission_request["tool_name"],
                     permission_request["input"],
-                    context
+                    context,
                 )
 
                 # Convert PermissionResult to expected dict format
                 if isinstance(response, PermissionResultAllow):
-                    response_data = {
-                        "allow": True
-                    }
-                    if response.updatedInput is not None:
-                        response_data["input"] = response.updatedInput
+                    response_data = {"allow": True}
+                    if response.updated_input is not None:
+                        response_data["input"] = response.updated_input
                     # TODO: Handle updatedPermissions when control protocol supports it
                 elif isinstance(response, PermissionResultDeny):
-                    response_data = {
-                        "allow": False,
-                        "reason": response.message
-                    }
+                    response_data = {"allow": False, "reason": response.message}
                     # TODO: Handle interrupt flag when control protocol supports it
                 else:
-                    raise TypeError(f"Tool permission callback must return PermissionResult (PermissionResultAllow or PermissionResultDeny), got {type(response)}")
+                    raise TypeError(
+                        f"Tool permission callback must return PermissionResult (PermissionResultAllow or PermissionResultDeny), got {type(response)}"
+                    )
 
             elif subtype == "hook_callback":
                 hook_callback_request: SDKHookCallbackRequest = request_data  # type: ignore[assignment]
@@ -241,15 +239,20 @@ async def _handle_control_request(self, request: SDKControlRequest) -> None:
                     {"signal": None},  # TODO: Add abort signal support
                 )
 
-            elif subtype == "mcp_request":
+            elif subtype == "mcp_message":
                 # Handle SDK MCP request
                 server_name = request_data.get("server_name")
                 mcp_message = request_data.get("message")
 
                 if not server_name or not mcp_message:
                     raise Exception("Missing server_name or message for MCP request")
 
-                response_data = await self._handle_sdk_mcp_request(server_name, mcp_message)
+                # Type narrowing - we've verified these are not None above
+                assert isinstance(server_name, str)
+                assert isinstance(mcp_message, dict)
+                response_data = await self._handle_sdk_mcp_request(
+                    server_name, mcp_message
+                )
 
             else:
                 raise Exception(f"Unsupported control request subtype: {subtype}")
@@ -317,7 +320,9 @@ async def _send_control_request(self, request: dict[str, Any]) -> dict[str, Any]
             self.pending_control_results.pop(request_id, None)
             raise Exception(f"Control request timeout: {request.get('subtype')}") from e
 
-    async def _handle_sdk_mcp_request(self, server_name: str, message: dict) -> dict:
+    async def _handle_sdk_mcp_request(
+        self, server_name: str, message: dict[str, Any]
+    ) -> dict[str, Any]:
         """Handle an MCP request for an SDK server.
 
         This acts as a bridge between JSONRPC messages from the CLI
@@ -362,43 +367,50 @@ async def _handle_sdk_mcp_request(self, server_name: str, message: dict) -> dict
                         {
                             "name": tool.name,
                             "description": tool.description,
-                            "inputSchema": tool.inputSchema.model_dump() if tool.inputSchema else {}
+                            "inputSchema": tool.inputSchema.model_dump()  # type: ignore[union-attr]
+                            if tool.inputSchema
+                            else {},
                         }
-                        for tool in result.root.tools
+                        for tool in result.root.tools  # type: ignore[union-attr]
                     ]
                     return {
                         "jsonrpc": "2.0",
                         "id": message.get("id"),
-                        "result": {"tools": tools_data}
+                        "result": {"tools": tools_data},
                     }
 
             elif method == "tools/call":
-                request = CallToolRequest(
+                call_request = CallToolRequest(
                     method=method,
                     params=CallToolRequestParams(
-                        name=params.get("name"),
-                        arguments=params.get("arguments", {})
-                    )
+                        name=params.get("name"), arguments=params.get("arguments", {})
+                    ),
                 )
                 handler = server.request_handlers.get(CallToolRequest)
                 if handler:
-                    result = await handler(request)
+                    result = await handler(call_request)
                     # Convert MCP result to JSONRPC response
                     content = []
-                    for item in result.root.content:
-                        if hasattr(item, 'text'):
+                    for item in result.root.content:  # type: ignore[union-attr]
+                        if hasattr(item, "text"):
                             content.append({"type": "text", "text": item.text})
-                        elif hasattr(item, 'data') and hasattr(item, 'mimeType'):
-                            content.append({"type": "image", "data": item.data, "mimeType": item.mimeType})
+                        elif hasattr(item, "data") and hasattr(item, "mimeType"):
+                            content.append(
+                                {
+                                    "type": "image",
+                                    "data": item.data,
+                                    "mimeType": item.mimeType,
+                                }
+                            )
 
                     response_data = {"content": content}
-                    if hasattr(result.root, 'is_error') and result.root.is_error:
-                        response_data["is_error"] = True
+                    if hasattr(result.root, "is_error") and result.root.is_error:
+                        response_data["is_error"] = True  # type: ignore[assignment]
 
                     return {
                         "jsonrpc": "2.0",
                         "id": message.get("id"),
-                        "result": response_data
+                        "result": response_data,
                     }
 
             # Add more methods here as MCP SDK adds them (resources, prompts, etc.)
diff --git a/src/claude_code_sdk/client.py b/src/claude_code_sdk/client.py
@@ -101,17 +101,17 @@ def __init__(self, options: ClaudeCodeOptions | None = None):
         os.environ["CLAUDE_CODE_ENTRYPOINT"] = "sdk-py-client"
 
     def _convert_hooks_to_internal_format(
-        self, hooks: dict[str, list]
+        self, hooks: dict[str, list[Any]]
     ) -> dict[str, list[dict[str, Any]]]:
         """Convert HookMatcher format to internal Query format."""
-        internal_hooks = {}
+        internal_hooks: dict[str, list[dict[str, Any]]] = {}
         for event, matchers in hooks.items():
             internal_hooks[event] = []
             for matcher in matchers:
                 # Convert HookMatcher to internal dict format
                 internal_matcher = {
-                    "matcher": matcher.matcher if hasattr(matcher, 'matcher') else None,
-                    "hooks": matcher.hooks if hasattr(matcher, 'hooks') else []
+                    "matcher": matcher.matcher if hasattr(matcher, "matcher") else None,
+                    "hooks": matcher.hooks if hasattr(matcher, "hooks") else [],
                 }
                 internal_hooks[event].append(internal_matcher)
         return internal_hooks
@@ -145,14 +145,16 @@ async def _empty_stream() -> AsyncIterator[dict[str, Any]]:
         if self.options.mcp_servers and isinstance(self.options.mcp_servers, dict):
             for name, config in self.options.mcp_servers.items():
                 if isinstance(config, dict) and config.get("type") == "sdk":
-                    sdk_mcp_servers[name] = config["instance"]
+                    sdk_mcp_servers[name] = config["instance"]  # type: ignore[typeddict-item]
 
         # Create Query to handle control protocol
         self._query = Query(
             transport=self._transport,
             is_streaming_mode=True,  # ClaudeSDKClient always uses streaming mode
             can_use_tool=self.options.can_use_tool,
-            hooks=self._convert_hooks_to_internal_format(self.options.hooks) if self.options.hooks else None,
+            hooks=self._convert_hooks_to_internal_format(self.options.hooks)
+            if self.options.hooks
+            else None,
             sdk_mcp_servers=sdk_mcp_servers,
         )
 
diff --git a/src/claude_code_sdk/types.py b/src/claude_code_sdk/types.py
diff --git a/tests/test_tool_callbacks.py b/tests/test_tool_callbacks.py

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ async def my_permission_callback(`
`61`	`61`	`modified_input = input_data.copy()`
`62`	`62`	`modified_input["file_path"] = safe_path`
`63`	`63`	`return PermissionResultAllow(`
`64`		`- updatedInput=modified_input`
	`64`	`+ updated_input=modified_input`
`65`	`65`	`)`
`66`	`66`
`67`	`67`	`# Check dangerous bash commands`