clawd-code-sdk 1.0.4__tar.gz → 1.0.6__tar.gz

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawd-code-sdk
-Version: 1.0.4
+Version: 1.0.6
 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-1.0.4 → clawd_code_sdk-1.0.6}/pyproject.toml

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

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/src/clawd_code_sdk/_internal/transport/subprocess_cli.py

@@ -469,8 +469,8 @@ def to_cli_args(options: ClaudeAgentOptions) -> list[str]:
     if options.context_1m:
         cmd.extend(["--betas", "context-1m-2025-08-07"])
 
-    if options.permission_prompt_tool_name:
-        cmd.extend(["--permission-prompt-tool", options.permission_prompt_tool_name])
+    if isinstance(options.on_permission, str):
+        cmd.extend(["--permission-prompt-tool", options.on_permission])
 
     if options.permission_mode:
         cmd.extend(["--permission-mode", options.permission_mode])

clawd_code_sdk-1.0.6/src/clawd_code_sdk/anthropic_types.py

@@ -0,0 +1,116 @@
+"""Anthropic SDK types for tool result content blocks.
+
+This module defines a discriminated union of all possible content types
+that can appear in tool results from the Anthropic SDK. These types are
+used to provide proper typing for ToolResultBlock.content.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from anthropic.types.beta import (
+    BetaBashCodeExecutionResultBlock,
+    BetaBashCodeExecutionToolResultError,
+    BetaCodeExecutionResultBlock,
+    BetaCodeExecutionToolResultError,
+    BetaImageBlockParam,
+    BetaTextBlock,
+    BetaTextEditorCodeExecutionCreateResultBlock,
+    BetaTextEditorCodeExecutionStrReplaceResultBlock,
+    BetaTextEditorCodeExecutionToolResultError,
+    BetaTextEditorCodeExecutionViewResultBlock,
+    BetaToolReferenceBlock,
+    BetaToolSearchToolResultError,
+    BetaToolSearchToolSearchResultBlock,
+    BetaWebFetchBlock,
+    BetaWebFetchToolResultErrorBlock,
+    BetaWebSearchResultBlock,
+    BetaWebSearchToolResultError,
+)
+from pydantic import BaseModel, Field, TypeAdapter
+
+
+# Union of all possible content types that can appear in tool results.
+# These are the inner content blocks, not the outer tool result wrapper.
+# Discriminated by the "type" field.
+#
+# Type discriminator values:
+# - "text" -> TextBlock
+# - "image" -> BetaImageBlockParam (TypedDict, no Pydantic model exists)
+# - "tool_reference" -> BetaToolReferenceBlock
+# - "tool_search_tool_search_result" -> BetaToolSearchToolSearchResultBlock
+# - "tool_search_tool_result_error" -> BetaToolSearchToolResultError
+# - "web_search_result" -> WebSearchResultBlock
+# - "web_search_tool_result_error" -> WebSearchToolResultError
+# - "web_fetch_result" -> BetaWebFetchBlock
+# - "web_fetch_tool_result_error" -> BetaWebFetchToolResultErrorBlock
+# - "code_execution_result" -> BetaCodeExecutionResultBlock
+# - "code_execution_tool_result_error" -> BetaCodeExecutionToolResultError
+# - "bash_code_execution_result" -> BetaBashCodeExecutionResultBlock
+# - "bash_code_execution_tool_result_error" -> BetaBashCodeExecutionToolResultError
+# - "text_editor_code_execution_view_result" -> BetaTextEditorCodeExecutionViewResultBlock
+# - "text_editor_code_execution_create_result" -> BetaTextEditorCodeExecutionCreateResultBlock
+# - "text_editor_code_execution_str_replace_result" -> BetaTextEditorCodeExecutionStrReplaceResultBlock  # noqa: E501
+# - "text_editor_code_execution_tool_result_error" -> BetaTextEditorCodeExecutionToolResultError
+ToolResultContentBlock = Annotated[
+    BetaTextBlock
+    | BetaImageBlockParam
+    | BetaToolReferenceBlock
+    | BetaToolSearchToolSearchResultBlock
+    | BetaToolSearchToolResultError
+    | BetaWebSearchResultBlock
+    | BetaWebSearchToolResultError
+    | BetaWebFetchBlock
+    | BetaWebFetchToolResultErrorBlock
+    | BetaCodeExecutionResultBlock
+    | BetaCodeExecutionToolResultError
+    | BetaBashCodeExecutionResultBlock
+    | BetaBashCodeExecutionToolResultError
+    | BetaTextEditorCodeExecutionViewResultBlock
+    | BetaTextEditorCodeExecutionCreateResultBlock
+    | BetaTextEditorCodeExecutionStrReplaceResultBlock
+    | BetaTextEditorCodeExecutionToolResultError,
+    Field(discriminator="type"),
+]
+_tool_result_content_adapter: TypeAdapter[list[ToolResultContentBlock]] | None = None
+
+
+def _get_adapter() -> TypeAdapter[list[ToolResultContentBlock]]:
+    global _tool_result_content_adapter  # noqa: PLW0603
+    if _tool_result_content_adapter is None:
+        # Force schema build for Anthropic models (deferred by default)
+        for model in [
+            BetaTextBlock,
+            BetaWebSearchResultBlock,
+            BetaWebSearchToolResultError,
+            BetaBashCodeExecutionResultBlock,
+            BetaBashCodeExecutionToolResultError,
+            BetaCodeExecutionResultBlock,
+            BetaCodeExecutionToolResultError,
+            BetaTextEditorCodeExecutionCreateResultBlock,
+            BetaTextEditorCodeExecutionStrReplaceResultBlock,
+            BetaTextEditorCodeExecutionToolResultError,
+            BetaTextEditorCodeExecutionViewResultBlock,
+            BetaToolReferenceBlock,
+            BetaToolSearchToolResultError,
+            BetaToolSearchToolSearchResultBlock,
+            BetaWebFetchBlock,
+            BetaWebFetchToolResultErrorBlock,
+        ]:
+            if isinstance(model, type) and issubclass(model, BaseModel):
+                model.model_rebuild()
+        _tool_result_content_adapter = TypeAdapter(list[ToolResultContentBlock])
+    return _tool_result_content_adapter
+
+
+def validate_tool_result_content(content: list[dict[str, object]]) -> list[ToolResultContentBlock]:
+    """Validate and parse raw tool result content into typed blocks.
+
+    Args:
+        content: Raw list of content block dictionaries from CLI output
+
+    Returns:
+        List of validated and typed content blocks
+    """
+    return _get_adapter().validate_python(content)

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/src/clawd_code_sdk/client.py

@@ -94,10 +94,13 @@ class ClaudeSDKClient:
         # Validate and configure permission settings (matching TypeScript SDK logic)
         self.options.validate()
 
-        if self.options.can_use_tool:
-            # Automatically set permission_prompt_tool_name to "stdio" for control protocol
-            options = replace(self.options, permission_prompt_tool_name="stdio")
+        # If on_permission is a callback, extract it for Query and replace with
+        # "stdio" so the CLI routes permission requests through the control protocol.
+        if callable(self.options.on_permission):
+            can_use_tool = self.options.on_permission
+            options = replace(self.options, on_permission="stdio")
         else:
+            can_use_tool = None
             options = self.options
 
         # Use provided custom transport or create subprocess transport
@@ -140,7 +143,7 @@ class ClaudeSDKClient:
         # Create Query to handle control protocol
         self._query = Query(
             transport=self._transport,
-            can_use_tool=self.options.can_use_tool,
+            can_use_tool=can_use_tool,
             on_user_question=self.options.on_user_question,
             on_elicitation=self.options.on_elicitation,
             hooks=self.options.hooks,

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/src/clawd_code_sdk/mcp_utils.py

@@ -247,8 +247,52 @@ def create_sdk_mcp_server(
     return McpSdkServerConfigWithInstance(type="sdk", name=name, instance=server)
 
 
+def _detect_capabilities(server: McpServer) -> dict[str, Any]:
+    """Detect which MCP capabilities a server supports based on registered handlers."""
+    from mcp.types import (
+        CallToolRequest,
+        GetPromptRequest,
+        ListPromptsRequest,
+        ListResourcesRequest,
+        ListResourceTemplatesRequest,
+        ListToolsRequest,
+        ReadResourceRequest,
+    )
+
+    capabilities: dict[str, Any] = {}
+    handlers = server.request_handlers
+    if handlers.get(ListToolsRequest) or handlers.get(CallToolRequest):
+        capabilities["tools"] = {}
+    if (
+        handlers.get(ListResourcesRequest)
+        or handlers.get(ReadResourceRequest)
+        or handlers.get(ListResourceTemplatesRequest)
+    ):
+        capabilities["resources"] = {}
+    if handlers.get(ListPromptsRequest) or handlers.get(GetPromptRequest):
+        capabilities["prompts"] = {}
+    return capabilities
+
+
 async def process_mcp_request(message: JSONRPCMessage, server: McpServer) -> JSONRPCResponse:
-    from mcp.types import CallToolRequest, CallToolRequestParams, CallToolResult, ListToolsRequest
+    from mcp.types import (
+        CallToolRequest,
+        CallToolRequestParams,
+        CallToolResult,
+        GetPromptRequest,
+        GetPromptRequestParams,
+        GetPromptResult,
+        ListPromptsRequest,
+        ListPromptsResult,
+        ListResourcesRequest,
+        ListResourcesResult,
+        ListResourceTemplatesRequest,
+        ListResourceTemplatesResult,
+        ListToolsRequest,
+        ReadResourceRequest,
+        ReadResourceRequestParams,
+        ReadResourceResult,
+    )
 
     raw_id = message.get("id")
     msg_id = raw_id if isinstance(raw_id, str | int) else 0
@@ -264,7 +308,7 @@ async def process_mcp_request(message: JSONRPCMessage, server: McpServer) -> JSO
                 # Handle MCP initialization - hardcoded for tools only, no listChanged
                 init_result = {
                     "protocolVersion": "2024-11-05",
-                    "capabilities": {"tools": {}},  # Tools capability without listChanged
+                    "capabilities": _detect_capabilities(server),
                     "serverInfo": {"name": server.name, "version": server.version or "1.0.0"},
                 }
                 return JSONRPCResultResponse(jsonrpc="2.0", id=msg_id, result=init_result)
@@ -291,11 +335,70 @@ async def process_mcp_request(message: JSONRPCMessage, server: McpServer) -> JSO
                 if result.root.isError:
                     response_data["is_error"] = True
                 return JSONRPCResultResponse(jsonrpc="2.0", id=msg_id, result=response_data)
+            case {"method": "resources/list"} if handler := server.request_handlers.get(
+                ListResourcesRequest
+            ):
+                list_resources_request = ListResourcesRequest()
+                result = await handler(list_resources_request)
+                assert isinstance(result.root, ListResourcesResult)
+                data = [
+                    r.model_dump(exclude_none=True, by_alias=True) for r in result.root.resources
+                ]
+                return JSONRPCResultResponse(jsonrpc="2.0", id=msg_id, result={"resources": data})
+
+            case {"method": "resources/read", "params": dict() as params} if (
+                handler := server.request_handlers.get(ReadResourceRequest)
+            ):
+                read_params = ReadResourceRequestParams(**params)
+                read_resource_request = ReadResourceRequest(params=read_params)
+                result = await handler(read_resource_request)
+                assert isinstance(result.root, ReadResourceResult)
+                contents = [
+                    c.model_dump(exclude_none=True, by_alias=True) for c in result.root.contents
+                ]
+                return JSONRPCResultResponse(
+                    jsonrpc="2.0", id=msg_id, result={"contents": contents}
+                )
+
+            case {"method": "resources/templates/list"} if handler := server.request_handlers.get(
+                ListResourceTemplatesRequest
+            ):
+                list_templates_request = ListResourceTemplatesRequest()
+                result = await handler(list_templates_request)
+                assert isinstance(result.root, ListResourceTemplatesResult)
+                data = [
+                    t.model_dump(exclude_none=True, by_alias=True)
+                    for t in result.root.resourceTemplates
+                ]
+                return JSONRPCResultResponse(
+                    jsonrpc="2.0", id=msg_id, result={"resourceTemplates": data}
+                )
+
+            case {"method": "prompts/list"} if handler := server.request_handlers.get(
+                ListPromptsRequest
+            ):
+                list_prompts_request = ListPromptsRequest()
+                result = await handler(list_prompts_request)
+                assert isinstance(result.root, ListPromptsResult)
+                data = [p.model_dump(exclude_none=True, by_alias=True) for p in result.root.prompts]
+                return JSONRPCResultResponse(jsonrpc="2.0", id=msg_id, result={"prompts": data})
+
+            case {"method": "prompts/get", "params": dict() as params} if (
+                handler := server.request_handlers.get(GetPromptRequest)
+            ):
+                get_params = GetPromptRequestParams(**params)
+                get_prompt_request = GetPromptRequest(params=get_params)
+                result = await handler(get_prompt_request)
+                assert isinstance(result.root, GetPromptResult)
+                return JSONRPCResultResponse(
+                    jsonrpc="2.0",
+                    id=msg_id,
+                    result=result.root.model_dump(exclude_none=True, by_alias=True),
+                )
+
             case {"method": "notifications/initialized"}:
                 # Handle initialized notification - just acknowledge it
                 return JSONRPCResultResponse(jsonrpc="2.0", id=msg_id, result={})
-            # Add more methods here as MCP SDK adds them (resources, prompts, etc.)
-            # This is the limitation Ashwin pointed out - we have to manually update
             case {"method": method}:
                 error = JSONRPCError(code=-32601, message=f"Method '{method}' not found")
                 return JSONRPCErrorResponse(jsonrpc="2.0", id=msg_id, error=error)

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/src/clawd_code_sdk/models/content_blocks.py

@@ -82,11 +82,7 @@ class ToolResultBlock(BaseContentBlock):
             return ""
         if isinstance(self.content, str):
             return self.content
-        text_parts = [
-            tc.get("text", "")
-            for tc in self.content
-            if isinstance(tc, dict) and tc.get("type") == "text"
-        ]
+        text_parts = [tc.get("text", "") for tc in self.content if tc.get("type") == "text"]
         return "\n".join(text_parts)
 
 

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/src/clawd_code_sdk/models/options.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass, field
 import json
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, TypedDict, assert_never
+from typing import TYPE_CHECKING, Any, Literal, assert_never
 
 
 if TYPE_CHECKING:
@@ -101,25 +101,6 @@ Can also be specified as a plain ``str``, which is a shortcut for
 """
 
 
-class ListSessionsOptions(TypedDict, total=False):
-    """Options for listing sessions.
-
-    When ``dir`` is provided, returns sessions for that project directory
-    and its git worktrees. When omitted, returns sessions across all projects.
-    """
-
-    dir: str
-    """Directory to list sessions for.
-
-    When provided, returns sessions for this project directory
-    (and its git worktrees). When omitted, returns sessions
-    across all projects.
-    """
-
-    limit: int
-    """Maximum number of sessions to return."""
-
-
 @dataclass
 class ClaudeAgentOptions:
     """Query options for Claude SDK."""
@@ -131,6 +112,27 @@ class ClaudeAgentOptions:
     """Tools which execute without prompting for permission."""
     disallowed_tools: list[str] | None = None
     """Tools that are removed from agent context and cant be used."""
+    enable_agent_teams: bool = False
+    """Enable the experimental agent teams feature."""
+    disable_parallel_tool_use: bool = False
+    """Disable parallel too use (only one tool_use block per response)."""
+    tool_config: ToolConfig | None = None
+    """Per-tool configuration for built-in tools."""
+    enable_tool_search: bool | int | Literal["auto"] | None = None
+    """Enable or disable MCP tool search.
+
+    When many MCP tools are configured, tool definitions can consume a
+    significant portion of the context window. Tool search dynamically
+    loads tools on-demand instead of preloading all of them.
+
+    - ``True``: Always enabled.
+    - ``False``: Always disabled, all MCP tools loaded upfront.
+    - ``"auto"``: Activates when MCP tools exceed 10% of context (default behavior).
+    - ``int``: Auto-activates at this percentage threshold (e.g. ``5`` for 5%).
+    - ``None`` (default): Uses Claude Code's default (auto at 10%).
+
+    Requires models that support ``tool_reference`` blocks (Sonnet 4+, Opus 4+).
+    """
     # MCP
     mcp_servers: dict[str, McpServerConfig] | str | Path = field(default_factory=dict)
     """MCP servers for the agent."""
@@ -143,25 +145,27 @@ class ClaudeAgentOptions:
     """Permission mode."""
     allow_dangerously_skip_permissions: bool = False
     """Must be True when using permission_mode='bypassPermissions'."""
-    permission_prompt_tool_name: str | None = None
-    """MCP tool to handle permission prompts."""
-    can_use_tool: CanUseTool | None = None
-    """Tool permission callback.
+    on_permission: CanUseTool | str | None = None
+    """Permission handler for tool execution.
 
-    When set, the SDK automatically adds ``--permission-prompt-tool stdio`` to
-    the CLI, which tells the CLI to route permission requests through the
-    control protocol to this callback.
+    Accepts either:
+    - A callback function (``CanUseTool``): The SDK routes permission requests
+      through the control protocol to this callback. Automatically adds
+      ``--permission-prompt-tool stdio`` to the CLI.
+    - A string: Name of an MCP tool to handle permission prompts
+      (passed as ``--permission-prompt-tool <name>`` to the CLI).
+    - ``None``: Default behavior.
 
     Interaction with ``permission_mode``:
 
-    - ``"default"``: All tool calls are routed to this callback.
-    - ``"acceptEdits"``: All tool calls are routed to this callback.
-      The callback is responsible for implementing the auto-approve-edits policy.
+    - ``"default"``: All tool calls are routed to this handler.
+    - ``"acceptEdits"``: All tool calls are routed to this handler.
+      The handler is responsible for implementing the auto-approve-edits policy.
     - ``"plan"``: Only the synthetic ``ExitPlanMode`` tool is routed here.
-      Actual modification tools are blocked by the CLI before reaching the callback.
-    - ``"dontAsk"``: This callback is NEVER invoked. The CLI auto-denies all
+      Actual modification tools are blocked by the CLI before reaching the handler.
+    - ``"dontAsk"``: This handler is NEVER invoked. The CLI auto-denies all
       tools not pre-approved via the permissions config internally.
-    - ``"bypassPermissions"``: This callback is NEVER invoked. The CLI
+    - ``"bypassPermissions"``: This handler is NEVER invoked. The CLI
       auto-approves all tools internally.
     """
     on_user_question: OnUserQuestion | None = None
@@ -169,7 +173,7 @@ class ClaudeAgentOptions:
 
     Called when Claude asks the user a clarifying question via the
     AskUserQuestion tool. If not set, these requests fall through
-    to can_use_tool (if set) for backwards compatibility.
+    to on_permission (if it's a callback) for backwards compatibility.
     """
     on_elicitation: OnElicitation | None = None
     """Callback for handling MCP elicitation requests.
@@ -278,8 +282,6 @@ class ClaudeAgentOptions:
     When enabled, files can be rewound to their state at any user message
     using `ClaudeSDKClient.rewind_files()`.
     """
-    tool_config: ToolConfig | None = None
-    """Per-tool configuration for built-in tools."""
     agent: str | None = None
     """Agent name for the main thread. The agent must be defined in `agents` or settings."""
     context_1m: bool = False
@@ -298,25 +300,6 @@ class ClaudeAgentOptions:
     """
     worktree: bool | str = False
     """Create a new git worktree for the session (with optional name)."""
-    enable_agent_teams: bool = False
-    """Enable the experimental agent teams feature."""
-    disable_parallel_tool_use: bool = False
-    """Disable parallel too use (only one tool_use block per response)."""
-    enable_tool_search: bool | int | Literal["auto"] | None = None
-    """Enable or disable MCP tool search.
-
-    When many MCP tools are configured, tool definitions can consume a
-    significant portion of the context window. Tool search dynamically
-    loads tools on-demand instead of preloading all of them.
-
-    - ``True``: Always enabled.
-    - ``False``: Always disabled, all MCP tools loaded upfront.
-    - ``"auto"``: Activates when MCP tools exceed 10% of context (default behavior).
-    - ``int``: Auto-activates at this percentage threshold (e.g. ``5`` for 5%).
-    - ``None`` (default): Uses Claude Code's default (auto at 10%).
-
-    Requires models that support ``tool_reference`` blocks (Sonnet 4+, Opus 4+).
-    """
 
     def build_settings_value(self) -> str | None:
         """Build the CLI ``--settings`` value, merging sandbox if provided.
@@ -328,20 +311,14 @@ class ClaudeAgentOptions:
 
         from clawd_code_sdk.models.settings import ClaudeCodeSettings as _Settings
 
-        has_settings = self.settings is not None
-        has_sandbox = self.sandbox is not None
-
-        if not has_settings and not has_sandbox:
-            return None
-
         # Resolve settings to a dict (or pass through as file path)
         match self.settings:
             case _Settings() as model:
                 settings_obj = model.model_dump(by_alias=True, exclude_none=True)
-            case str() | Path() as path if has_sandbox and Path(path).exists():
+            case str() | Path() as path if self.sandbox and Path(path).exists():
                 with Path(path).open(encoding="utf-8") as f:
                     settings_obj = json.load(f)
-            case str() | Path() as path if has_sandbox:
+            case str() | Path() as path if self.sandbox:
                 logger.warning("Settings file not found: %s", path)
                 settings_obj = {}
             case str() | Path() as path:  # No sandbox to merge, pass file path directly to CLI
@@ -352,21 +329,10 @@ class ClaudeAgentOptions:
                 assert_never(unreachable)
 
         # Merge sandbox settings
-        if has_sandbox:
-            assert self.sandbox is not None
+        if self.sandbox is not None:
             settings_obj["sandbox"] = self.sandbox.model_dump(by_alias=True, exclude_none=True)
 
-        return anyenv.dump_json(settings_obj)
+        return anyenv.dump_json(settings_obj) if settings_obj else None
 
     def validate(self) -> None:
-        """Validate option constraints.
-
-        Raises:
-            ValueError: If mutually exclusive options are set.
-        """
-        if self.can_use_tool and self.permission_prompt_tool_name:
-            msg = (
-                "can_use_tool callback cannot be used with permission_prompt_tool_name. "
-                "Please use one or the other."
-            )
-            raise ValueError(msg)
+        """Validate option constraints."""

clawd_code_sdk-1.0.6/tests/e2e/test_mcp_resources.py

@@ -0,0 +1,72 @@
+"""E2E tests for MCP resource support.
+
+Tests whether MCP resources can be listed and read through external MCP servers.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+
+import pytest
+
+from clawd_code_sdk import (
+    AssistantMessage,
+    ClaudeAgentOptions,
+    ClaudeSDKClient,
+    ResultMessage,
+)
+from clawd_code_sdk.models.mcp import McpStdioServerConfig
+
+
+@pytest.mark.e2e
+async def test_external_mcp_resource_list_and_read():
+    """Test that resources from an external MCP server can be listed and read."""
+    mcp_server_path = str(Path(__file__).parent.parent / "mcp_server.py")
+
+    options = ClaudeAgentOptions(
+        mcp_servers={
+            "res_test": McpStdioServerConfig(
+                command=sys.executable,
+                args=[mcp_server_path],
+            ),
+        },
+        permission_mode="bypassPermissions",
+        allow_dangerously_skip_permissions=True,
+        allowed_tools=[
+            "ListMcpResources",
+            "ReadMcpResource",
+        ],
+        max_turns=5,
+        enable_tool_search=False,
+    )
+
+    async with ClaudeSDKClient(options=options) as client:
+        await client.query(
+            "First, use the ListMcpResources tool to list available MCP resources. "
+            "Then use ReadMcpResource to read the 'test://greeting' resource from "
+            "the 'res_test' server. Report what you find."
+        )
+        messages = [msg async for msg in client.receive_response()]
+
+    # Check we got a result
+    result_messages = [m for m in messages if isinstance(m, ResultMessage)]
+    assert result_messages, f"No ResultMessage. Got: {[type(m).__name__ for m in messages]}"
+    assert not result_messages[0].is_error
+
+    # Look for evidence that resources were accessed
+    all_text = []
+    for msg in messages:
+        if isinstance(msg, AssistantMessage):
+            for block in msg.content:
+                if hasattr(block, "text"):
+                    all_text.append(block.text)  # noqa: PERF401
+
+    combined = " ".join(all_text).lower()
+    assert "hello from mcp resource" in combined or "greeting" in combined, (
+        f"Expected resource content in response. Got: {combined[:500]}"
+    )
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-vv", "-m", "e2e"])

clawd_code_sdk-1.0.6/tests/e2e/test_sdk_mcp_resources.py

@@ -0,0 +1,78 @@
+"""E2E tests for SDK MCP resource support (in-process servers).
+
+Tests whether MCP resources registered on SDK servers can be listed and read.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from clawd_code_sdk import (
+    AssistantMessage,
+    ClaudeAgentOptions,
+    ClaudeSDKClient,
+    ResultMessage,
+)
+from clawd_code_sdk.models import ToolUseBlock
+
+
+@pytest.mark.e2e
+@pytest.mark.skip(
+    reason="CLI does not route ListMcpResources/ReadMcpResource to SDK servers yet. "
+    "The SDK correctly advertises resources capability and routes resources/list + "
+    "resources/read, but the CLI only sends tools/list and tools/call for SDK servers."
+)
+async def test_sdk_mcp_resource_list_and_read():
+    """Test that resources on an SDK MCP server can be listed and read."""
+    from mcp.server.fastmcp import FastMCP
+
+    from clawd_code_sdk.models import McpSdkServerConfigWithInstance
+
+    mcp = FastMCP("sdk_res_test")
+
+    @mcp.resource("test://greeting")
+    def get_greeting() -> str:
+        return "Hello from SDK MCP resource!"
+
+    @mcp.tool()
+    def ping() -> str:
+        """Simple ping tool."""
+        return "pong"
+
+    server_config = McpSdkServerConfigWithInstance(
+        type="sdk", name="sdk_res", instance=mcp._mcp_server
+    )
+
+    options = ClaudeAgentOptions(
+        mcp_servers={"sdk_res": server_config},
+        permission_mode="bypassPermissions",
+        allow_dangerously_skip_permissions=True,
+        allowed_tools=["ListMcpResources", "ReadMcpResource", "mcp__sdk_res__ping"],
+        max_turns=5,
+        enable_tool_search=False,
+    )
+
+    async with ClaudeSDKClient(options=options) as client:
+        await client.query(
+            "Use ListMcpResources to list resources, then ReadMcpResource "
+            "to read 'test://greeting' from 'sdk_res'."
+        )
+        messages = [msg async for msg in client.receive_response()]
+
+    result_messages = [m for m in messages if isinstance(m, ResultMessage)]
+    assert result_messages
+    assert not result_messages[0].is_error
+
+    tool_uses = [
+        block.name
+        for msg in messages
+        if isinstance(msg, AssistantMessage)
+        for block in msg.content
+        if isinstance(block, ToolUseBlock)
+    ]
+    resource_tools_used = [t for t in tool_uses if "Resource" in t]
+    assert resource_tools_used, f"No resource tools used. Tools: {tool_uses}"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-vv", "-m", "e2e"])

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/tests/e2e/test_tool_permissions.py

@@ -40,7 +40,7 @@ async def test_permission_callback_gets_called():
         callback_invocations.append((tool_name, input_data))
         return PermissionResultAllow()
 
-    options = ClaudeAgentOptions(can_use_tool=permission_callback)
+    options = ClaudeAgentOptions(on_permission=permission_callback)
 
     try:
         async with ClaudeSDKClient(options=options) as client:

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/tests/mcp_server.py

@@ -12,6 +12,18 @@ from fastmcp.utilities.types import Image
 mcp = FastMCP("Image Test Server")
 
 
+@mcp.resource("test://greeting")
+def get_greeting() -> str:
+    """A simple test resource that returns a greeting."""
+    return "Hello from MCP resource!"
+
+
+@mcp.resource("test://data/{item_id}")
+def get_data_item(item_id: str) -> str:
+    """A parameterized test resource."""
+    return f"Data for item: {item_id}"
+
+
 @mcp.tool
 async def get_test_image() -> Image:
     """Return a small test PNG image."""

{clawd_code_sdk-1.0.4 → clawd_code_sdk-1.0.6}/tests/test_sdk_mcp_integration.py

@@ -7,7 +7,14 @@ matching the TypeScript SDK test/sdk.test.ts pattern.
 import base64
 from typing import Any
 
-from mcp.types import CallToolRequest, CallToolRequestParams, ToolAnnotations
+from mcp.types import (
+    CallToolRequest,
+    CallToolRequestParams,
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
+    ToolAnnotations,
+)
 import pytest
 
 from clawd_code_sdk import ClaudeAgentOptions, create_sdk_mcp_server, tool
@@ -205,11 +212,11 @@ async def test_image_content_support():
     assert len(result.root.content) == 2
     # Check text content
     text_content = result.root.content[0]
-    assert text_content.type == "text"
+    assert isinstance(text_content, TextContent)
     assert text_content.text == "Generated chart: Sales Report"
     # Check image content
     image_content = result.root.content[1]
-    assert image_content.type == "image"
+    assert isinstance(image_content, ImageContent)
     assert image_content.data == png_data
     assert image_content.mimeType == "image/png"
     # Verify the tool was executed correctly
@@ -262,11 +269,11 @@ async def test_document_content_support():
     assert len(result.root.content) == 2
     # Check text content
     text_content = result.root.content[0]
-    assert text_content.type == "text"
+    assert isinstance(text_content, TextContent)
     assert text_content.text == "Document: report.pdf"
     # Check document content (stored as EmbeddedResource with BlobResourceContents)
     doc_content = result.root.content[1]
-    assert doc_content.type == "resource"
+    assert isinstance(doc_content, EmbeddedResource)
     assert hasattr(doc_content, "resource")
     assert str(doc_content.resource.uri) == "document://base64"
     assert doc_content.resource.mimeType == "application/pdf"
@@ -430,5 +437,131 @@ async def test_tool_annotations_in_jsonrpc():
     assert "annotations" not in tools_by_name["plain_tool"]
 
 
+async def test_process_mcp_request_resources_list():
+    """Test that process_mcp_request routes resources/list correctly."""
+    from mcp.server.fastmcp import FastMCP
+
+    from clawd_code_sdk.mcp_utils import process_mcp_request
+
+    mcp = FastMCP("res_test")
+
+    @mcp.resource("test://greeting")
+    def get_greeting() -> str:
+        return "Hello from resource!"
+
+    server = mcp._mcp_server
+
+    # Test resources/list
+    msg = {"jsonrpc": "2.0", "id": 1, "method": "resources/list"}
+    resp = await process_mcp_request(msg, server)
+    assert resp.get("id") == 1
+    assert "result" in resp
+    resources = resp["result"]["resources"]
+    assert len(resources) == 1
+    assert resources[0]["name"] == "get_greeting"
+    assert str(resources[0]["uri"]) == "test://greeting"
+
+
+async def test_process_mcp_request_resources_read():
+    """Test that process_mcp_request routes resources/read correctly."""
+    from mcp.server.fastmcp import FastMCP
+
+    from clawd_code_sdk.mcp_utils import process_mcp_request
+
+    mcp = FastMCP("res_test")
+
+    @mcp.resource("test://greeting")
+    def get_greeting() -> str:
+        return "Hello from resource!"
+
+    server = mcp._mcp_server
+
+    msg = JSONRPCRequest(
+        jsonrpc="2.0",
+        id=2,
+        method="resources/read",
+        params={"uri": "test://greeting"},
+    )
+    resp = await process_mcp_request(msg, server)
+    assert resp.get("id") == 2
+    assert "result" in resp
+    contents = resp["result"]["contents"]
+    assert len(contents) == 1
+    assert contents[0]["text"] == "Hello from resource!"
+    assert contents[0]["mimeType"] == "text/plain"
+
+
+async def test_process_mcp_request_resource_templates_list():
+    """Test that process_mcp_request routes resources/templates/list correctly."""
+    from mcp.server.fastmcp import FastMCP
+
+    from clawd_code_sdk.mcp_utils import process_mcp_request
+
+    mcp = FastMCP("res_test")
+
+    @mcp.resource("test://data/{item_id}")
+    def get_data(item_id: str) -> str:
+        return f"Data for {item_id}"
+
+    server = mcp._mcp_server
+
+    msg = JSONRPCRequest(jsonrpc="2.0", id=3, method="resources/templates/list")
+    resp = await process_mcp_request(msg, server)
+    assert resp.get("id") == 3
+    assert "result" in resp
+    templates = resp["result"]["resourceTemplates"]
+    assert len(templates) == 1
+    assert "test://data/{item_id}" in templates[0]["uriTemplate"]
+
+
+async def test_detect_capabilities():
+    """Test that _detect_capabilities correctly detects server capabilities."""
+    from mcp.server import Server
+    from mcp.server.fastmcp import FastMCP
+
+    from clawd_code_sdk.mcp_utils import _detect_capabilities
+
+    # Empty server
+    empty = Server("empty")
+    caps = _detect_capabilities(empty)
+    assert caps == {}
+
+    # Server with tools + resources + prompts
+    mcp = FastMCP("full")
+
+    @mcp.resource("test://r")
+    def res() -> str:
+        return "r"
+
+    @mcp.tool()
+    def t() -> str:
+        return "t"
+
+    caps = _detect_capabilities(mcp._mcp_server)
+    assert "tools" in caps
+    assert "resources" in caps
+    assert "prompts" in caps  # FastMCP registers prompt handlers by default
+
+
+async def test_process_mcp_request_initialize_advertises_capabilities():
+    """Test that initialize response includes detected capabilities."""
+    from mcp.server.fastmcp import FastMCP
+
+    from clawd_code_sdk.mcp_utils import process_mcp_request
+
+    mcp = FastMCP("cap_test")
+
+    @mcp.resource("test://r")
+    def res() -> str:
+        return "r"
+
+    server = mcp._mcp_server
+    msg = JSONRPCRequest(jsonrpc="2.0", id=1, method="initialize", params={})
+    resp = await process_mcp_request(msg, server)
+    caps = resp["result"]["capabilities"]
+    assert "resources" in caps
+    assert "tools" in caps
+
+
 if __name__ == "__main__":
     pytest.main(["-v", __file__])

clawd_code_sdk-1.0.4/src/clawd_code_sdk/anthropic_types.py

@@ -1,39 +0,0 @@
-"""Anthropic SDK types for tool result content blocks.
-
-This module re-exports BetaContentBlock from the Anthropic SDK as the
-canonical union type for content blocks in tool results. BetaImageBlockParam
-is included because image content in MCP tool results uses the input
-(Param) type rather than an output block type.
-"""
-
-from __future__ import annotations
-
-from anthropic.types.beta import BetaContentBlock, BetaImageBlockParam
-from pydantic import TypeAdapter
-
-
-# Union of content types that can appear in tool results.
-# BetaContentBlock covers all server-side tool output blocks.
-# BetaImageBlockParam covers image content from MCP tools (TypedDict, not a model).
-ToolResultContentBlock = BetaContentBlock | BetaImageBlockParam
-
-_tool_result_content_adapter: TypeAdapter[list[ToolResultContentBlock]] | None = None
-
-
-def _get_adapter() -> TypeAdapter[list[ToolResultContentBlock]]:
-    global _tool_result_content_adapter  # noqa: PLW0603
-    if _tool_result_content_adapter is None:
-        _tool_result_content_adapter = TypeAdapter(list[ToolResultContentBlock])
-    return _tool_result_content_adapter
-
-
-def validate_tool_result_content(content: list[dict[str, object]]) -> list[ToolResultContentBlock]:
-    """Validate and parse raw tool result content into typed blocks.
-
-    Args:
-        content: Raw list of content block dictionaries from CLI output
-
-    Returns:
-        List of validated and typed content blocks
-    """
-    return _get_adapter().validate_python(content)