clawd-code-sdk 0.1.76__tar.gz → 0.1.78__tar.gz

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawd-code-sdk
-Version: 0.1.76
+Version: 0.1.78
 Summary: Python SDK for Claude Code
 Project-URL: Documentation, https://github.com/phil65/claude-agent-sdk-python
 Project-URL: Homepage, https://github.com/phil65/claude-agent-sdk-python

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "clawd-code-sdk"
-version = "0.1.76"
+version = "0.1.78"
 description = "Python SDK for Claude Code"
 readme = "README.md"
 requires-python = ">=3.13"

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/_errors.py

@@ -142,3 +142,36 @@ class ServerError(APIError):
 
     def __init__(self, message: str, model: str | None = None):
         super().__init__(message, "server_error", model)
+
+
+class ControlRequestError(ClaudeSDKError):
+    """Raised when a control protocol request fails."""
+
+    def __init__(self, message: str, subtype: str | None = None):
+        self.subtype = subtype
+        super().__init__(message)
+
+
+class ControlRequestTimeoutError(ControlRequestError):
+    """Raised when a control protocol request times out."""
+
+
+class McpError(ControlRequestError):
+    """Raised when an MCP-related control request fails.
+
+    Attributes:
+        error_code: The JSON-RPC error code from the MCP server.
+        server_name: The name of the MCP server, if known.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        error_code: int | None = None,
+        server_name: str | None = None,
+        subtype: str | None = None,
+    ):
+        self.error_code = error_code
+        self.server_name = server_name
+        super().__init__(message, subtype=subtype)

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/_internal/message_parser.py

@@ -92,8 +92,6 @@ def parse_message(data: dict[str, Any]) -> Message:
             return ToolUseSummaryMessage(**summary_data)
         case {"type": "auth_status", **auth_data}:
             # Convert camelCase isAuthenticating to snake_case
-            if "isAuthenticating" in auth_data:
-                auth_data["is_authenticating"] = auth_data.pop("isAuthenticating")
             return AuthStatusMessage(**auth_data)
         case {"type": unknown_type}:
             raise MessageParseError(f"Unknown message type: {unknown_type}", data)

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/_internal/query.py

@@ -12,6 +12,7 @@ import anyenv
 import anyio
 from pydantic import BaseModel
 
+from clawd_code_sdk._errors import ControlRequestError, ControlRequestTimeoutError
 from clawd_code_sdk.models import (
     ControlResponse,
     PermissionResultAllow,
@@ -27,6 +28,7 @@ from clawd_code_sdk.models import (
     ToolPermissionContext,
     parse_control_request,
 )
+from clawd_code_sdk.models.control import ControlErrorResponse
 from clawd_code_sdk.models.mcp import JSONRPCError, JSONRPCErrorResponse, JSONRPCResultResponse
 from clawd_code_sdk.models.server_info import ClaudeCodeServerInfo
 
@@ -98,6 +100,7 @@ class Query:
         system_prompt: str | None = None,
         append_system_prompt: str | None = None,
         json_schema: dict[str, Any] | None = None,
+        prompt_suggestions: bool | None = None,
     ):
         """Initialize Query with transport and callbacks.
 
@@ -111,6 +114,7 @@ class Query:
             system_prompt: Optional system prompt to send via initialize
             append_system_prompt: Optional text to append to preset system prompt
             json_schema: Optional JSON schema for structured output
+            prompt_suggestions: Optional flag to enable prompt suggestions
         """
         self._initialize_timeout = initialize_timeout
         self.transport = transport
@@ -121,6 +125,7 @@ class Query:
         self._system_prompt = system_prompt
         self._append_system_prompt = append_system_prompt
         self._json_schema = json_schema
+        self._prompt_suggestions = prompt_suggestions
         # Control protocol state
         self.pending_control_responses: dict[str, anyio.Event] = {}
         self.pending_control_results: dict[str, dict[str, Any] | Exception] = {}
@@ -184,6 +189,8 @@ class Query:
             request["appendSystemPrompt"] = self._append_system_prompt
         if self._json_schema is not None:
             request["jsonSchema"] = self._json_schema
+        if self._prompt_suggestions is not None:
+            request["promptSuggestions"] = self._prompt_suggestions
 
         # Use longer timeout for initialize since MCP servers may take time to start
         response = await self._send_control_request(request, timeout=self._initialize_timeout)
@@ -234,7 +241,9 @@ class Query:
                             event = self.pending_control_responses[request_id]
                             if response.get("subtype") == "error":
                                 msg = response.get("error", "Unknown error")
-                                self.pending_control_results[request_id] = Exception(msg)
+                                self.pending_control_results[request_id] = ControlRequestError(
+                                    msg, subtype=response.get("subtype")
+                                )
                             else:
                                 self.pending_control_results[request_id] = response
                             event.set()
@@ -304,10 +313,8 @@ class Query:
             await self.transport.write(anyenv.dump_json(success_response) + "\n")
 
         except Exception as e:
-            error_response = SDKControlResponse(
-                type="control_response",
-                response={"subtype": "error", "request_id": request_id, "error": str(e)},
-            )
+            response = ControlErrorResponse(subtype="error", request_id=request_id, error=str(e))
+            error_response = SDKControlResponse(type="control_response", response=response)
             await self.transport.write(anyenv.dump_json(error_response) + "\n")
 
     async def _handle_permission_request(
@@ -315,8 +322,7 @@ class Query:
     ) -> PermissionResult:
         """Handle a tool permission request."""
         if not self.can_use_tool:
-            msg = "canUseTool callback is not provided"
-            raise RuntimeError(msg)
+            raise RuntimeError("canUseTool callback is not provided")
 
         context = ToolPermissionContext(
             tool_use_id=req.tool_use_id,
@@ -332,10 +338,8 @@ class Query:
 
     async def _handle_hook_callback(self, req: SDKHookCallbackRequest) -> dict[str, Any]:
         """Handle a hook callback request."""
-        callback = self.hook_callbacks.get(req.callback_id)
-        if not callback:
-            msg = f"No hook callback found for ID: {req.callback_id}"
-            raise RuntimeError(msg)
+        if not (callback := self.hook_callbacks.get(req.callback_id)):
+            raise RuntimeError(f"No hook callback found for ID: {req.callback_id}")
 
         hook_output = await callback(req.input, req.tool_use_id, {"signal": None})
         # Strip trailing underscores from Python-safe names (async_, continue_) for CLI
@@ -375,7 +379,10 @@ class Query:
         except TimeoutError as e:
             self.pending_control_responses.pop(request_id, None)
             self.pending_control_results.pop(request_id, None)
-            raise Exception(f"Control request timeout: {request.get('subtype')}") from e
+            subtype = request.get("subtype")
+            raise ControlRequestTimeoutError(
+                f"Control request timeout: {subtype}", subtype=subtype
+            ) from e
 
     async def _handle_sdk_mcp_request(
         self, server_name: str, message: JSONRPCMessage
@@ -418,12 +425,7 @@ class Query:
         await self._send_control_request({"subtype": "mcp_reconnect", "serverName": server_name})
 
     async def mcp_toggle(self, server_name: str, *, enabled: bool) -> None:
-        """Enable or disable an MCP server.
-
-        Args:
-            server_name: Name of the MCP server to toggle
-            enabled: Whether the server should be enabled
-        """
+        """Enable or disable an MCP server."""
         await self._send_control_request(
             {"subtype": "mcp_toggle", "serverName": server_name, "enabled": enabled}
         )
@@ -605,12 +607,12 @@ async def process_mcp_request(message: JSONRPCMessage, server: McpServer) -> JSO
         match method:
             case "initialize":
                 # Handle MCP initialization - hardcoded for tools only, no listChanged
-                result = {
+                init_result = {
                     "protocolVersion": "2024-11-05",
                     "capabilities": {"tools": {}},  # Tools capability without listChanged
                     "serverInfo": {"name": server.name, "version": server.version or "1.0.0"},
                 }
-                return JSONRPCResultResponse(jsonrpc="2.0", id=msg_id, result=result)
+                return JSONRPCResultResponse(jsonrpc="2.0", id=msg_id, result=init_result)
 
             case "tools/list" if handler := server.request_handlers.get(ListToolsRequest):
                 request = ListToolsRequest()

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/_internal/transport/subprocess_cli.py

@@ -161,15 +161,18 @@ class SubprocessCLITransport(Transport):
         if self._options.resume_session_at:
             cmd.extend(["--resume-session-at", self._options.resume_session_at])
 
-        if self._options.debug or self._options.debug_file:
-            cmd.append("--debug")
-
         if self._options.debug_file:
             cmd.extend(["--debug-file", self._options.debug_file])
 
         if self._options.strict_mcp_config:
             cmd.append("--strict-mcp-config")
 
+        match self._options.worktree:
+            case True:
+                cmd.append("--worktree")
+            case str():
+                cmd.extend(["--worktree", self._options.worktree])
+
         sources_value = ",".join(self._options.setting_sources or [])
         cmd.extend(["--setting-sources", sources_value])
 
@@ -286,7 +289,6 @@ class SubprocessCLITransport(Transport):
 
                 # Always collect stderr lines for error reporting
                 self._stderr_lines.append(line_str)
-
                 # Call the stderr callback if provided
                 if self._options.stderr:
                     self._options.stderr(line_str)
@@ -401,13 +403,11 @@ class SubprocessCLITransport(Transport):
                         json_buffer = ""
                         raise SDKJSONDecodeError(
                             f"JSON message exceeded maximum buffer size of {self._max_buffer_size} bytes",
-                            ValueError(
-                                f"Buffer size {buffer_length} exceeds limit {self._max_buffer_size}"
-                            ),
+                            ValueError(f"{buffer_length=} exceeds {self._max_buffer_size=}"),
                         )
 
                     try:
-                        data = anyenv.load_json(json_buffer)
+                        data = anyenv.load_json(json_buffer, return_type=dict)
                         json_buffer = ""
                         yield data
                     except anyenv.JsonLoadError:
@@ -439,11 +439,8 @@ class SubprocessCLITransport(Transport):
         # Use exit code for error detection
         if returncode is not None and returncode != 0:
             stderr_output = "\n".join(self._stderr_lines) if self._stderr_lines else None
-            self._exit_error = ProcessError(
-                f"Command failed with exit code {returncode}",
-                exit_code=returncode,
-                stderr=stderr_output,
-            )
+            msg = f"Command failed with exit code {returncode}"
+            self._exit_error = ProcessError(msg, exit_code=returncode, stderr=stderr_output)
             raise self._exit_error
 
 

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/client.py

@@ -10,7 +10,13 @@ from typing import TYPE_CHECKING, Any
 import anyenv
 
 from clawd_code_sdk._errors import CLIConnectionError
-from clawd_code_sdk.models import ClaudeAgentOptions, ResultMessage, UserPromptMessage
+from clawd_code_sdk.models import (
+    ClaudeAgentOptions,
+    McpStdioServerConfig,
+    ResultMessage,
+    UserPromptMessage,
+)
+from clawd_code_sdk.models.mcp import McpStatusResponse
 from clawd_code_sdk.models.messages import AssistantMessage
 
 
@@ -136,6 +142,7 @@ class ClaudeSDKClient:
             system_prompt=system_prompt,
             append_system_prompt=append_system_prompt,
             json_schema=json_schema,
+            prompt_suggestions=self.options.prompt_suggestions,
         )
         # Start reading messages and initialize
         await self._query.start()
@@ -246,19 +253,16 @@ class ClaudeSDKClient:
         query = self._ensure_connected()
         await query.rewind_files(user_message_id)
 
-    async def get_mcp_status(self) -> dict[str, Any]:
+    async def get_mcp_status(self) -> McpStatusResponse:
         """Get current MCP server connection status.
 
         Returns:
-            Dictionary with MCP server status information. Contains a
-            'mcpServers' key with a list of server status objects, each having:
-            - 'name': Server name (str)
-            - 'status': Connection status ('connected', 'pending', 'failed',
-              'needs-auth', 'disabled')
+            Validated MCP status response containing server statuses,
+            configurations, tools, and connection information.
         """
         query = self._ensure_connected()
         result = await query.get_mcp_status()
-        return result
+        return McpStatusResponse.model_validate(result)
 
     async def set_mcp_servers(self, servers: dict[str, McpServerConfig]) -> dict[str, Any]:
         """Add, replace, or remove MCP servers dynamically mid-session.

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/models/__init__.py

@@ -112,11 +112,16 @@ from .mcp import (
     JSONRPCRequest,
     JSONRPCResponse,
     JSONRPCResultResponse,
+    McpConnectionStatus,
     McpHttpServerConfig,
     McpSdkServerConfig,
     McpServerConfig,
+    McpServerStatusEntry,
+    McpServerVersionInfo,
     McpSSEServerConfig,
+    McpStatusResponse,
     McpStdioServerConfig,
+    McpToolStatus,
     RequestId,
     SdkPluginConfig,
 )
@@ -289,11 +294,16 @@ __all__ = [
     "JSONRPCRequest",
     "JSONRPCResponse",
     "JSONRPCResultResponse",
+    "McpConnectionStatus",
     "McpHttpServerConfig",
     "McpSdkServerConfig",
     "McpServerConfig",
+    "McpServerStatusEntry",
+    "McpServerVersionInfo",
     "McpSSEServerConfig",
+    "McpStatusResponse",
     "McpStdioServerConfig",
+    "McpToolStatus",
     "RequestId",
     "SdkPluginConfig",
     # sandbox

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/models/base.py

@@ -4,6 +4,15 @@ from __future__ import annotations
 
 from typing import Literal, TypedDict
 
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class ClaudeCodeBaseModel(BaseModel):
+    """Base model for all Claude Code Pydantic models."""
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel, extra="forbid")
+
 
 # Permission modes
 # - 'default': Standard behavior, prompts for dangerous operations

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/models/hooks.py

@@ -27,6 +27,7 @@ HookEvent = Literal[
     "Setup",
     "TeammateIdle",
     "TaskCompleted",
+    "ConfigChange",
 ]
 
 
@@ -170,6 +171,16 @@ class TaskCompletedHookInput(BaseHookInput):
     team_name: NotRequired[str]
 
 
+class ConfigChangeHookInput(BaseHookInput):
+    """Input data for ConfigChange hook events."""
+
+    hook_event_name: Literal["ConfigChange"]
+    source: Literal[
+        "user_settings", "project_settings", "local_settings", "policy_settings", "skills"
+    ]
+    file_path: NotRequired[str]
+
+
 # Union type for all hook inputs
 HookInput = (
     PreToolUseHookInput
@@ -187,6 +198,7 @@ HookInput = (
     | SetupHookInput
     | TeammateIdleHookInput
     | TaskCompletedHookInput
+    | ConfigChangeHookInput
 )
 
 

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/models/input_types.py

@@ -9,6 +9,10 @@ from __future__ import annotations
 from typing import Literal, NotRequired, TypedDict
 
 
+ModelName = Literal["sonnet", "opus", "haiku"]
+PermissionMode = Literal["acceptEdits", "bypassPermissions", "default", "dontAsk", "plan"]
+
+
 class AgentInput(TypedDict):
     """Input for the Task tool. Launches a new agent to handle complex, multi-step tasks."""
 
@@ -18,6 +22,20 @@ class AgentInput(TypedDict):
     """The task for the agent to perform."""
     subagent_type: str
     """The type of specialized agent to use for this task."""
+    model: NotRequired[ModelName]
+    """Optional model to use for the agent."""
+    resume: NotRequired[str]
+    """Optional agent ID to resume from in order to continue from the previous execution transcript."""
+    run_in_background: NotRequired[bool]
+    """Whether to run the agent in the background."""
+    max_turns: NotRequired[int]
+    """Maximum number of agentic turns (API round-trips) before stopping. Used internally for warmup."""
+    name: NotRequired[str]
+    """Name for the spawned agent."""
+    team_name: NotRequired[str]
+    """Team name for spawning. Uses current team context if omitted."""
+    mode: NotRequired[PermissionMode]
+    """Permission mode for spawned teammate (e.g., "plan" to require plan approval)."""
 
 
 class AskUserQuestionOption(TypedDict):
@@ -96,9 +114,11 @@ class FileReadInput(TypedDict):
     file_path: str
     """The absolute path to the file to read."""
     offset: NotRequired[int]
-    """The line number to start reading from."""
+    """The line number to start reading from. Only provide if the file is too large to read at once."""
     limit: NotRequired[int]
-    """The number of lines to read."""
+    """The number of lines to read. Only provide if the file is too large to read at once"""
+    pages: NotRequired[str]
+    """Page range for PDF files (e.g., "1-5", "3", "10-20"). Only applicable to PDF files. Maximum 20 pages per request."""
 
 
 class FileWriteInput(TypedDict):

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/models/mcp.py

@@ -2,7 +2,11 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Literal, NotRequired, TypedDict
+from typing import TYPE_CHECKING, Any, Literal, NotRequired, TypedDict
+
+from pydantic import Field
+
+from clawd_code_sdk.models.base import ClaudeCodeBaseModel
 
 
 if TYPE_CHECKING:
@@ -12,6 +16,8 @@ if TYPE_CHECKING:
 RequestId = str | int
 JSONRPC_VERSION = "2.0"
 
+McpConnectionStatus = Literal["connected", "pending", "failed", "needs-auth", "disabled"]
+
 
 # JSON-RPC types (from MCP specification)
 
@@ -30,7 +36,7 @@ class JSONRPCRequest(TypedDict):
     jsonrpc: str
     id: RequestId
     method: str
-    params: NotRequired[dict[str, object]]
+    params: NotRequired[dict[str, Any]]
 
 
 class JSONRPCNotification(TypedDict):
@@ -38,7 +44,7 @@ class JSONRPCNotification(TypedDict):
 
     jsonrpc: str
     method: str
-    params: NotRequired[dict[str, object]]
+    params: NotRequired[dict[str, Any]]
 
 
 class JSONRPCResultResponse(TypedDict):
@@ -46,7 +52,7 @@ class JSONRPCResultResponse(TypedDict):
 
     jsonrpc: str
     id: RequestId
-    result: dict[str, object]
+    result: dict[str, Any]
 
 
 class JSONRPCErrorResponse(TypedDict):
@@ -111,3 +117,58 @@ class SdkPluginConfig(TypedDict):
 
     type: Literal["local"]
     path: str
+
+
+# Pydantic models for MCP status responses
+
+
+class ToolAnnotations(ClaudeCodeBaseModel):
+    """
+    Additional properties describing a Tool to clients.
+    """
+
+    title: str | None = None
+    """A human-readable title for the tool."""
+
+    read_only_hint: bool | None = None
+    """Read-only hint."""
+
+    destructive_hint: bool | None = None
+    """Destructive hint."""
+
+    idempotent_hint: bool | None = None
+    """Idempodent hint."""
+
+    open_world_hint: bool | None = None
+    """Open-world hint."""
+
+
+class McpToolStatus(ClaudeCodeBaseModel):
+    """Status information for a single MCP tool."""
+
+    name: str
+    annotations: ToolAnnotations = Field(default_factory=ToolAnnotations)
+
+
+class McpServerVersionInfo(ClaudeCodeBaseModel):
+    """Server version information returned in MCP status."""
+
+    name: str
+    version: str
+
+
+class McpServerStatusEntry(ClaudeCodeBaseModel):
+    """Status information for a single MCP server."""
+
+    name: str
+    status: McpConnectionStatus
+    server_info: McpServerVersionInfo | None = None
+    config: dict[str, Any] = Field(default_factory=dict)
+    scope: str | None = None
+    tools: list[McpToolStatus] = Field(default_factory=list)
+
+
+class McpStatusResponse(ClaudeCodeBaseModel):
+    """Response from get_mcp_status() containing all MCP server statuses."""
+
+    mcp_servers: list[McpServerStatusEntry] = Field(default_factory=list)

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/models/messages.py

@@ -91,7 +91,7 @@ class UserMessage(BaseMessage):
 
 
 @dataclass(kw_only=True)
-class AssistantMessage(BaseMessage):
+class AssistantMessage:
     """Assistant message with content blocks."""
 
     type: Literal["assistant"] = "assistant"
@@ -99,6 +99,8 @@ class AssistantMessage(BaseMessage):
     model: str
     parent_tool_use_id: str | None = None
     error: AssistantMessageError | None = None
+    session_id: str | None = None  # not sure these two are needed.
+    uuid: str | None = None
 
     def raise_if_api_error(self) -> None:
         """Raise the appropriate API exception if error is set.
@@ -391,7 +393,7 @@ class AuthStatusMessage(BaseMessage):
     """Authentication status update."""
 
     type: Literal["auth_status"] = "auth_status"
-    is_authenticating: bool = False
+    isAuthenticating: bool = False  # noqa: N815
     output: list[str] | None = None
     error: str | None = None
 

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/models/options.py

@@ -76,14 +76,14 @@ class ClaudeAgentOptions:
     allow_dangerously_skip_permissions: bool = False
     # Resume from a specific message UUID (use with `resume`).
     resume_session_at: str | None = None
-    # Enable debug mode for the Claude Code process.
-    debug: bool = False
     # Write debug logs to a specific file path. Implicitly enables debug mode.
     debug_file: str | None = None
     # Enforce strict validation of MCP server configurations.
     strict_mcp_config: bool = False
     # Enable 1M token context window (Sonnet 4/4.5 only).
     context_1m: bool = False
+    prompt_suggestions: bool | None = None
+    worktree: bool | str = False
 
     def build_settings_value(self) -> str | None:
         """Build settings value, merging sandbox settings if provided.

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/models/server_info.py

@@ -2,17 +2,17 @@
 
 from __future__ import annotations
 
-from pydantic import BaseModel, ConfigDict, Field
-from pydantic.alias_generators import to_camel
+from typing import Literal
 
+from pydantic import Field
 
-class ClaudeCodeBasemodel(BaseModel):
-    """Base model."""
+from clawd_code_sdk.models.base import ClaudeCodeBaseModel
 
-    model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)
 
+EffortLevel = Literal["low", "medium", "high", "max"]
 
-class ClaudeCodeModelInfo(ClaudeCodeBasemodel):
+
+class ClaudeCodeModelInfo(ClaudeCodeBaseModel):
     """Information about an available AI model from Claude Code."""
 
     value: str
@@ -24,8 +24,17 @@ class ClaudeCodeModelInfo(ClaudeCodeBasemodel):
     description: str
     """Full description including capabilities and pricing."""
 
+    supports_effort: bool | None = None
+    """Whether the model supports effort setting."""
+
+    supported_effort_levels: list[EffortLevel] | None = None
+    """Supported effort levels."""
+
+    supports_adaptive_thinking: bool | None = None
+    """Whether the model supports adaptive thinking."""
 
-class ClaudeCodeCommandInfo(ClaudeCodeBasemodel):
+
+class ClaudeCodeCommandInfo(ClaudeCodeBaseModel):
     """Information about an available slash command from Claude Code."""
 
     name: str
@@ -38,7 +47,7 @@ class ClaudeCodeCommandInfo(ClaudeCodeBasemodel):
     """Usage hint for command arguments (may be empty string)."""
 
 
-class ClaudeCodeAccountInfo(ClaudeCodeBasemodel):
+class ClaudeCodeAccountInfo(ClaudeCodeBaseModel):
     """Account information from Claude Code."""
 
     email: str | None = None
@@ -54,7 +63,7 @@ class ClaudeCodeAccountInfo(ClaudeCodeBasemodel):
     """Where API key comes from (e.g., "ANTHROPIC_API_KEY")."""
 
 
-class ClaudeCodeServerInfo(ClaudeCodeBasemodel):
+class ClaudeCodeServerInfo(ClaudeCodeBaseModel):
     """Complete server initialization info from Claude Code.
 
     This is returned by the Claude Code server during initialization and contains
@@ -76,3 +85,6 @@ class ClaudeCodeServerInfo(ClaudeCodeBasemodel):
 
     account: ClaudeCodeAccountInfo | None = Field(default=None)
     """Account and authentication information."""
+
+    pid: int | None = None
+    """Process id."""

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/src/clawd_code_sdk/storage/helpers.py

@@ -6,7 +6,7 @@ See ARCHITECTURE.md for detailed documentation of the storage format.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from pathlib import Path
 
 import anyenv
 from pydantic import TypeAdapter, ValidationError
@@ -14,9 +14,6 @@ from pydantic import TypeAdapter, ValidationError
 from clawd_code_sdk.storage.models import ClaudeJSONLEntry
 
 
-if TYPE_CHECKING:
-    from pathlib import Path
-
 logger = logging.getLogger(__name__)
 
 
@@ -70,28 +67,16 @@ def read_session(session_path: Path) -> list[ClaudeJSONLEntry]:
                 entry = adapter.validate_python(data)
                 entries.append(entry)
             except anyenv.JsonLoadError as e:
-                logger.warning(
-                    "Failed to parse JSONL line (path: %s, error: %s, raw_line: %s)",
-                    str(session_path),
-                    str(e),
-                    raw_line,
-                )
+                msg = "Failed to parse JSONL line (path: %s, error: %s, raw_line: %s)"
+                logger.warning(msg, str(session_path), str(e), raw_line)
             except ValidationError as e:
-                logger.warning(
-                    "Failed to validate JSONL entry (path: %s, error: %s)",
-                    str(session_path),
-                    str(e),
-                )
+                msg = "Failed to validate JSONL entry (path: %s, error: %s)"
+                logger.warning(msg, str(session_path), str(e))
     return entries
 
 
 def get_claude_data_dir() -> Path:
-    """Get the Claude Code data directory path.
-
-    Claude Code stores data in ~/.claude rather than the XDG data directory.
-    """
-    from pathlib import Path
-
+    """Get the Claude Code data directory path (~/.claude)."""
     return Path.home() / ".claude"
 
 
@@ -115,27 +100,13 @@ def path_to_claude_dir_name(project_path: str) -> str:
 
 
 def get_latest_session(project_path: str) -> Path | None:
-    """Get the most recent session file for a project.
-
-    Args:
-        project_path: The project path
-
-    Returns:
-        Path to the latest session file, or None if no sessions exist
-    """
+    """Get the path for the most recent session file for given project if existing."""
     sessions = list_project_sessions(project_path)
     return sessions[0] if sessions else None
 
 
 def list_project_sessions(project_path: str) -> list[Path]:
-    """List all session files for a project.
-
-    Args:
-        project_path: The project path (will be converted to Claude's format)
-
-    Returns:
-        List of session file paths, sorted by modification time (newest first)
-    """
+    """List all session files for given project path, sorted by modification time (newest first)."""
     projects_dir = get_claude_projects_dir()
     project_dir_name = path_to_claude_dir_name(project_path)
     project_dir = projects_dir / project_dir_name

{clawd_code_sdk-0.1.76 → clawd_code_sdk-0.1.78}/tests/test_client.py

@@ -12,11 +12,13 @@ from clawd_code_sdk import (
     AssistantMessage,
     AuthenticationError,
     ClaudeAgentOptions,
+    ClaudeSDKClient,
     InvalidRequestError,
     RateLimitError,
     ServerError,
     query,
 )
+from clawd_code_sdk.models.mcp import McpServerStatusEntry, McpStatusResponse
 
 
 def create_mock_transport_with_messages(messages: list[dict]):
@@ -55,8 +57,11 @@ def create_mock_transport_with_messages(messages: list[dict]):
                         "response": {
                             "request_id": msg.get("request_id"),
                             "subtype": "success",
-                            "commands": [],
-                            "output_style": "default",
+                            "response": {
+                                "commands": [],
+                                "outputStyle": "default",
+                                "pid": 12345,
+                            },
                         },
                     }
                     break
@@ -365,3 +370,146 @@ class TestAPIErrorRaising:
             assert messages[0].content[0].text == "Hello!"
 
         anyio.run(_test)
+
+
+def _create_control_protocol_transport(
+    control_responses: dict[str, dict],
+) -> AsyncMock:
+    """Create a mock transport that handles initialization and responds to control requests.
+
+    Args:
+        control_responses: Mapping of control request subtype to response payload.
+            The "initialize" subtype is handled automatically.
+    """
+    mock_transport = AsyncMock()
+    mock_transport.connect = AsyncMock()
+    mock_transport.close = AsyncMock()
+    mock_transport.end_input = AsyncMock()
+
+    written_messages: list[str] = []
+
+    async def mock_write(data: str) -> None:
+        written_messages.append(data)
+
+    mock_transport.write = AsyncMock(side_effect=mock_write)
+
+    init_response = {
+        "subtype": "success",
+        "response": {
+            "commands": [],
+            "outputStyle": "default",
+            "pid": 12345,
+        },
+    }
+    all_responses = {"initialize": init_response, **control_responses}
+
+    async def mock_receive():
+        last_check = 0
+        timeout_counter = 0
+        while timeout_counter < 200:
+            await asyncio.sleep(0.01)
+            timeout_counter += 1
+
+            for msg_str in written_messages[last_check:]:
+                try:
+                    msg = json.loads(msg_str.strip())
+                    if msg.get("type") != "control_request":
+                        continue
+                    subtype = msg.get("request", {}).get("subtype")
+                    if subtype in all_responses:
+                        yield {
+                            "type": "control_response",
+                            "response": {
+                                "request_id": msg.get("request_id"),
+                                **all_responses[subtype],
+                            },
+                        }
+                except (json.JSONDecodeError, KeyError, AttributeError):
+                    pass
+            last_check = len(written_messages)
+
+    mock_transport.read_messages = mock_receive
+    return mock_transport
+
+
+class TestGetMcpStatus:
+    """Test get_mcp_status returns validated McpStatusResponse."""
+
+    def test_get_mcp_status_parses_response(self):
+        """Test that get_mcp_status returns a validated McpStatusResponse."""
+
+        async def _test():
+            mcp_status_payload = {
+                "subtype": "success",
+                "response": {
+                    "mcpServers": [
+                        {
+                            "name": "git",
+                            "status": "connected",
+                            "serverInfo": {"name": "mcp-git", "version": "1.26.0"},
+                            "config": {
+                                "type": "stdio",
+                                "command": "uvx",
+                                "args": ["mcp-server-git"],
+                            },
+                            "scope": "dynamic",
+                            "tools": [
+                                {"name": "git_status", "annotations": {}},
+                                {"name": "git_log", "annotations": {}},
+                            ],
+                        }
+                    ]
+                },
+            }
+            mock_transport = _create_control_protocol_transport({"mcp_status": mcp_status_payload})
+
+            client = ClaudeSDKClient(transport=mock_transport)
+            await client.connect()
+            try:
+                status = await client.get_mcp_status()
+
+                assert isinstance(status, McpStatusResponse)
+                assert len(status.mcp_servers) == 1
+
+                server = status.mcp_servers[0]
+                assert isinstance(server, McpServerStatusEntry)
+                assert server.name == "git"
+                assert server.status == "connected"
+                assert server.scope == "dynamic"
+                assert server.server_info is not None
+                assert server.server_info.name == "mcp-git"
+                assert server.server_info.version == "1.26.0"
+                assert server.config == {
+                    "type": "stdio",
+                    "command": "uvx",
+                    "args": ["mcp-server-git"],
+                }
+                assert len(server.tools) == 2
+                assert server.tools[0].name == "git_status"
+                assert server.tools[1].name == "git_log"
+            finally:
+                await client.disconnect()
+
+        anyio.run(_test)
+
+    def test_get_mcp_status_empty_servers(self):
+        """Test get_mcp_status with no MCP servers configured."""
+
+        async def _test():
+            mcp_status_payload = {
+                "subtype": "success",
+                "response": {"mcpServers": []},
+            }
+            mock_transport = _create_control_protocol_transport({"mcp_status": mcp_status_payload})
+
+            client = ClaudeSDKClient(transport=mock_transport)
+            await client.connect()
+            try:
+                status = await client.get_mcp_status()
+
+                assert isinstance(status, McpStatusResponse)
+                assert len(status.mcp_servers) == 0
+            finally:
+                await client.disconnect()
+
+        anyio.run(_test)