claude-agent-sdk 0.0.23__tar.gz → 0.1.1__tar.gz

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-agent-sdk
-Version: 0.0.23
+Version: 0.1.1
 Summary: Python SDK for Claude Code
 Project-URL: Homepage, https://github.com/anthropics/claude-agent-sdk-python
 Project-URL: Documentation, https://docs.anthropic.com/en/docs/claude-code/sdk
@@ -43,8 +43,8 @@ pip install claude-agent-sdk
 
 **Prerequisites:**
 - Python 3.10+
-- Node.js 
-- Claude Code: `npm install -g @anthropic-ai/claude-code`
+- Node.js
+- Claude Code 2.0.0+: `npm install -g @anthropic-ai/claude-code`
 
 ## Quick Start
 
@@ -92,7 +92,7 @@ options = ClaudeAgentOptions(
 )
 
 async for message in query(
-    prompt="Create a hello.py file", 
+    prompt="Create a hello.py file",
     options=options
 ):
     # Process tool use and results
@@ -304,6 +304,15 @@ See [examples/quick_start.py](examples/quick_start.py) for a complete working ex
 
 See [examples/streaming_mode.py](examples/streaming_mode.py) for comprehensive examples involving `ClaudeSDKClient`. You can even run interactive examples in IPython from [examples/streaming_mode_ipython.py](examples/streaming_mode_ipython.py).
 
+## Migrating from Claude Code SDK
+
+If you're upgrading from the Claude Code SDK (versions < 0.1.0), please see the [CHANGELOG.md](CHANGELOG.md#010) for details on breaking changes and new features, including:
+
+- `ClaudeCodeOptions` → `ClaudeAgentOptions` rename
+- Merged system prompt configuration
+- Settings isolation and explicit control
+- New programmatic subagents and session forking features
+
 ## License
 
 MIT

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/README.md

@@ -10,8 +10,8 @@ pip install claude-agent-sdk
 
 **Prerequisites:**
 - Python 3.10+
-- Node.js 
-- Claude Code: `npm install -g @anthropic-ai/claude-code`
+- Node.js
+- Claude Code 2.0.0+: `npm install -g @anthropic-ai/claude-code`
 
 ## Quick Start
 
@@ -59,7 +59,7 @@ options = ClaudeAgentOptions(
 )
 
 async for message in query(
-    prompt="Create a hello.py file", 
+    prompt="Create a hello.py file",
     options=options
 ):
     # Process tool use and results
@@ -271,6 +271,15 @@ See [examples/quick_start.py](examples/quick_start.py) for a complete working ex
 
 See [examples/streaming_mode.py](examples/streaming_mode.py) for comprehensive examples involving `ClaudeSDKClient`. You can even run interactive examples in IPython from [examples/streaming_mode_ipython.py](examples/streaming_mode_ipython.py).
 
+## Migrating from Claude Code SDK
+
+If you're upgrading from the Claude Code SDK (versions < 0.1.0), please see the [CHANGELOG.md](CHANGELOG.md#010) for details on breaking changes and new features, including:
+
+- `ClaudeCodeOptions` → `ClaudeAgentOptions` rename
+- Merged system prompt configuration
+- Settings isolation and explicit control
+- New programmatic subagents and session forking features
+
 ## License
 
 MIT

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-agent-sdk"
-version = "0.0.23"
+version = "0.1.1"
 description = "Python SDK for Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/src/claude_agent_sdk/_internal/query.py

@@ -213,13 +213,18 @@ class Query:
 
                 # Convert PermissionResult to expected dict format
                 if isinstance(response, PermissionResultAllow):
-                    response_data = {"allow": True}
+                    response_data = {"behavior": "allow"}
                     if response.updated_input is not None:
-                        response_data["input"] = response.updated_input
-                    # TODO: Handle updatedPermissions when control protocol supports it
+                        response_data["updatedInput"] = response.updated_input
+                    if response.updated_permissions is not None:
+                        response_data["updatedPermissions"] = [
+                            permission.to_dict()
+                            for permission in response.updated_permissions
+                        ]
                 elif isinstance(response, PermissionResultDeny):
-                    response_data = {"allow": False, "reason": response.message}
-                    # TODO: Handle interrupt flag when control protocol supports it
+                    response_data = {"behavior": "deny", "message": response.message}
+                    if response.interrupt:
+                        response_data["interrupt"] = response.interrupt
                 else:
                     raise TypeError(
                         f"Tool permission callback must return PermissionResult (PermissionResultAllow or PermissionResultDeny), got {type(response)}"

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/src/claude_agent_sdk/_internal/transport/subprocess_cli.py

@@ -3,7 +3,9 @@
 import json
 import logging
 import os
+import re
 import shutil
+import sys
 from collections.abc import AsyncIterable, AsyncIterator
 from contextlib import suppress
 from dataclasses import asdict
@@ -24,7 +26,8 @@ from . import Transport
 
 logger = logging.getLogger(__name__)
 
-_MAX_BUFFER_SIZE = 1024 * 1024  # 1MB buffer limit
+_DEFAULT_MAX_BUFFER_SIZE = 1024 * 1024  # 1MB buffer limit
+MINIMUM_CLAUDE_CODE_VERSION = "2.0.0"
 
 
 class SubprocessCLITransport(Transport):
@@ -48,6 +51,11 @@ class SubprocessCLITransport(Transport):
         self._stderr_task_group: anyio.abc.TaskGroup | None = None
         self._ready = False
         self._exit_error: Exception | None = None  # Track process exit errors
+        self._max_buffer_size = (
+            options.max_buffer_size
+            if options.max_buffer_size is not None
+            else _DEFAULT_MAX_BUFFER_SIZE
+        )
 
     def _find_cli(self) -> str:
         """Find Claude Code CLI binary."""
@@ -66,15 +74,6 @@ class SubprocessCLITransport(Transport):
             if path.exists() and path.is_file():
                 return str(path)
 
-        node_installed = shutil.which("node") is not None
-
-        if not node_installed:
-            error_msg = "Claude Code requires Node.js, which is not installed.\n\n"
-            error_msg += "Install Node.js from: https://nodejs.org/\n"
-            error_msg += "\nAfter installing Node.js, install Claude Code:\n"
-            error_msg += "  npm install -g @anthropic-ai/claude-code"
-            raise CLINotFoundError(error_msg)
-
         raise CLINotFoundError(
             "Claude Code not found. Install with:\n"
             "  npm install -g @anthropic-ai/claude-code\n"
@@ -206,6 +205,8 @@ class SubprocessCLITransport(Transport):
         if self._process:
             return
 
+        await self._check_claude_version()
+
         cmd = self._build_command()
         try:
             # Merge environment variables: system -> user -> SDK required
@@ -411,12 +412,13 @@ class SubprocessCLITransport(Transport):
                     # Keep accumulating partial JSON until we can parse it
                     json_buffer += json_line
 
-                    if len(json_buffer) > _MAX_BUFFER_SIZE:
+                    if len(json_buffer) > self._max_buffer_size:
+                        buffer_length = len(json_buffer)
                         json_buffer = ""
                         raise SDKJSONDecodeError(
-                            f"JSON message exceeded maximum buffer size of {_MAX_BUFFER_SIZE} bytes",
+                            f"JSON message exceeded maximum buffer size of {self._max_buffer_size} bytes",
                             ValueError(
-                                f"Buffer size {len(json_buffer)} exceeds limit {_MAX_BUFFER_SIZE}"
+                                f"Buffer size {buffer_length} exceeds limit {self._max_buffer_size}"
                             ),
                         )
 
@@ -427,7 +429,7 @@ class SubprocessCLITransport(Transport):
                     except json.JSONDecodeError:
                         # We are speculatively decoding the buffer until we get
                         # a full JSON object. If there is an actual issue, we
-                        # raise an error after _MAX_BUFFER_SIZE.
+                        # raise an error after exceeding the configured limit.
                         continue
 
         except anyio.ClosedResourceError:
@@ -451,6 +453,46 @@ class SubprocessCLITransport(Transport):
             )
             raise self._exit_error
 
+    async def _check_claude_version(self) -> None:
+        """Check Claude Code version and warn if below minimum."""
+        version_process = None
+        try:
+            with anyio.fail_after(2):  # 2 second timeout
+                version_process = await anyio.open_process(
+                    [self._cli_path, "-v"],
+                    stdout=PIPE,
+                    stderr=PIPE,
+                )
+
+                if version_process.stdout:
+                    stdout_bytes = await version_process.stdout.receive()
+                    version_output = stdout_bytes.decode().strip()
+
+                    match = re.match(r"([0-9]+\.[0-9]+\.[0-9]+)", version_output)
+                    if match:
+                        version = match.group(1)
+                        version_parts = [int(x) for x in version.split(".")]
+                        min_parts = [
+                            int(x) for x in MINIMUM_CLAUDE_CODE_VERSION.split(".")
+                        ]
+
+                        if version_parts < min_parts:
+                            warning = (
+                                f"Warning: Claude Code version {version} is unsupported in the Agent SDK. "
+                                f"Minimum required version is {MINIMUM_CLAUDE_CODE_VERSION}. "
+                                "Some features may not work correctly."
+                            )
+                            logger.warning(warning)
+                            print(warning, file=sys.stderr)
+        except Exception:
+            pass
+        finally:
+            if version_process:
+                with suppress(Exception):
+                    version_process.terminate()
+                with suppress(Exception):
+                    await version_process.wait()
+
     def is_ready(self) -> bool:
         """Check if transport is ready for communication."""
         return self._ready

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/src/claude_agent_sdk/_version.py

@@ -1,3 +1,3 @@
 """Version information for claude-agent-sdk."""
 
-__version__ = "0.0.23"
+__version__ = "0.1.1"

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/src/claude_agent_sdk/client.py

@@ -6,6 +6,7 @@ from collections.abc import AsyncIterable, AsyncIterator
 from dataclasses import replace
 from typing import Any
 
+from . import Transport
 from ._errors import CLIConnectionError
 from .types import ClaudeAgentOptions, HookEvent, HookMatcher, Message, ResultMessage
 
@@ -51,12 +52,17 @@ class ClaudeSDKClient:
     exist.
     """
 
-    def __init__(self, options: ClaudeAgentOptions | None = None):
+    def __init__(
+        self,
+        options: ClaudeAgentOptions | None = None,
+        transport: Transport | None = None,
+    ):
         """Initialize Claude SDK client."""
         if options is None:
             options = ClaudeAgentOptions()
         self.options = options
-        self._transport: Any | None = None
+        self._custom_transport = transport
+        self._transport: Transport | None = None
         self._query: Any | None = None
         os.environ["CLAUDE_CODE_ENTRYPOINT"] = "sdk-py-client"
 
@@ -115,10 +121,14 @@ class ClaudeSDKClient:
         else:
             options = self.options
 
-        self._transport = SubprocessCLITransport(
-            prompt=actual_prompt,
-            options=options,
-        )
+        # Use provided custom transport or create subprocess transport
+        if self._custom_transport:
+            self._transport = self._custom_transport
+        else:
+            self._transport = SubprocessCLITransport(
+                prompt=actual_prompt,
+                options=options,
+            )
         await self._transport.connect()
 
         # Extract SDK MCP servers from options
@@ -222,7 +232,7 @@ class ClaudeSDKClient:
 
         Args:
             model: The model to use, or None to use default. Examples:
-                - 'claude-sonnet-4-20250514'
+                - 'claude-sonnet-4-5'
                 - 'claude-opus-4-1-20250805'
                 - 'claude-opus-4-20250514'
 
@@ -233,7 +243,7 @@ class ClaudeSDKClient:
                 await client.query("Help me understand this problem")
 
                 # Switch to a different model for implementation
-                await client.set_model('claude-3-5-sonnet-20241022')
+                await client.set_model('claude-sonnet-4-5')
                 await client.query("Now implement the solution")
             ```
         """

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/src/claude_agent_sdk/types.py

@@ -70,6 +70,42 @@ class PermissionUpdate:
     directories: list[str] | None = None
     destination: PermissionUpdateDestination | None = None
 
+    def to_dict(self) -> dict[str, Any]:
+        """Convert PermissionUpdate to dictionary format matching TypeScript control protocol."""
+        result: dict[str, Any] = {
+            "type": self.type,
+        }
+
+        # Add destination for all variants
+        if self.destination is not None:
+            result["destination"] = self.destination
+
+        # Handle different type variants
+        if self.type in ["addRules", "replaceRules", "removeRules"]:
+            # Rules-based variants require rules and behavior
+            if self.rules is not None:
+                result["rules"] = [
+                    {
+                        "toolName": rule.tool_name,
+                        "ruleContent": rule.rule_content,
+                    }
+                    for rule in self.rules
+                ]
+            if self.behavior is not None:
+                result["behavior"] = self.behavior
+
+        elif self.type == "setMode":
+            # Mode variant requires mode
+            if self.mode is not None:
+                result["mode"] = self.mode
+
+        elif self.type in ["addDirectories", "removeDirectories"]:
+            # Directory variants require directories
+            if self.directories is not None:
+                result["directories"] = self.directories
+
+        return result
+
 
 # Tool callback types
 @dataclass
@@ -320,6 +356,7 @@ class ClaudeAgentOptions:
     extra_args: dict[str, str | None] = field(
         default_factory=dict
     )  # Pass arbitrary CLI flags
+    max_buffer_size: int | None = None  # Max bytes when buffering CLI stdout
     debug_stderr: Any = (
         sys.stderr
     )  # Deprecated: File-like object for debug output. Use stderr callback instead.

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/tests/test_integration.py

@@ -161,7 +161,7 @@ class TestIntegration:
                 async for _ in query(prompt="test"):
                     pass
 
-            assert "Claude Code requires Node.js" in str(exc_info.value)
+            assert "Claude Code not found" in str(exc_info.value)
 
         anyio.run(_test)
 

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/tests/test_subprocess_buffering.py

@@ -10,7 +10,7 @@ import pytest
 
 from claude_agent_sdk._errors import CLIJSONDecodeError
 from claude_agent_sdk._internal.transport.subprocess_cli import (
-    _MAX_BUFFER_SIZE,
+    _DEFAULT_MAX_BUFFER_SIZE,
     SubprocessCLITransport,
 )
 from claude_agent_sdk.types import ClaudeAgentOptions
@@ -237,7 +237,7 @@ class TestSubprocessBuffering:
         """Test that exceeding buffer size raises an appropriate error."""
 
         async def _test() -> None:
-            huge_incomplete = '{"data": "' + "x" * (_MAX_BUFFER_SIZE + 1000)
+            huge_incomplete = '{"data": "' + "x" * (_DEFAULT_MAX_BUFFER_SIZE + 1000)
 
             transport = SubprocessCLITransport(
                 prompt="test", options=ClaudeAgentOptions(), cli_path="/usr/bin/claude"
@@ -260,6 +260,34 @@ class TestSubprocessBuffering:
 
         anyio.run(_test)
 
+    def test_buffer_size_option(self) -> None:
+        """Test that the configurable buffer size option is respected."""
+
+        async def _test() -> None:
+            custom_limit = 512
+            huge_incomplete = '{"data": "' + "x" * (custom_limit + 10)
+
+            transport = SubprocessCLITransport(
+                prompt="test",
+                options=ClaudeAgentOptions(max_buffer_size=custom_limit),
+                cli_path="/usr/bin/claude",
+            )
+
+            mock_process = MagicMock()
+            mock_process.returncode = None
+            mock_process.wait = AsyncMock(return_value=None)
+            transport._process = mock_process
+            transport._stdout_stream = MockTextReceiveStream([huge_incomplete])
+            transport._stderr_stream = MockTextReceiveStream([])
+
+            with pytest.raises(CLIJSONDecodeError) as exc_info:
+                async for _ in transport.read_messages():
+                    pass
+
+            assert f"maximum buffer size of {custom_limit} bytes" in str(exc_info.value)
+
+        anyio.run(_test)
+
     def test_mixed_complete_and_split_json(self) -> None:
         """Test handling a mix of complete and split JSON messages."""
 

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/tests/test_tool_callbacks.py

@@ -90,7 +90,7 @@ class TestToolPermissionCallbacks:
         # Check response was sent
         assert len(transport.written_messages) == 1
         response = transport.written_messages[0]
-        assert '"allow": true' in response
+        assert '"behavior": "allow"' in response
 
     @pytest.mark.asyncio
     async def test_permission_callback_deny(self):
@@ -125,8 +125,8 @@ class TestToolPermissionCallbacks:
         # Check response
         assert len(transport.written_messages) == 1
         response = transport.written_messages[0]
-        assert '"allow": false' in response
-        assert '"reason": "Security policy violation"' in response
+        assert '"behavior": "deny"' in response
+        assert '"message": "Security policy violation"' in response
 
     @pytest.mark.asyncio
     async def test_permission_callback_input_modification(self):
@@ -164,7 +164,7 @@ class TestToolPermissionCallbacks:
         # Check response includes modified input
         assert len(transport.written_messages) == 1
         response = transport.written_messages[0]
-        assert '"allow": true' in response
+        assert '"behavior": "allow"' in response
         assert '"safe_mode": true' in response
 
     @pytest.mark.asyncio

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/tests/test_transport.py

@@ -25,7 +25,7 @@ class TestSubprocessCLITransport:
         ):
             SubprocessCLITransport(prompt="test", options=ClaudeAgentOptions())
 
-        assert "Claude Code requires Node.js" in str(exc_info.value)
+        assert "Claude Code not found" in str(exc_info.value)
 
     def test_build_command_basic(self):
         """Test building basic CLI command."""
@@ -106,7 +106,7 @@ class TestSubprocessCLITransport:
             options=ClaudeAgentOptions(
                 allowed_tools=["Read", "Write"],
                 disallowed_tools=["Bash"],
-                model="claude-3-5-sonnet",
+                model="claude-sonnet-4-5",
                 permission_mode="acceptEdits",
                 max_turns=5,
             ),
@@ -119,7 +119,7 @@ class TestSubprocessCLITransport:
         assert "--disallowedTools" in cmd
         assert "Bash" in cmd
         assert "--model" in cmd
-        assert "claude-3-5-sonnet" in cmd
+        assert "claude-sonnet-4-5" in cmd
         assert "--permission-mode" in cmd
         assert "acceptEdits" in cmd
         assert "--max-turns" in cmd
@@ -163,6 +163,16 @@ class TestSubprocessCLITransport:
 
         async def _test():
             with patch("anyio.open_process") as mock_exec:
+                # Mock version check process
+                mock_version_process = MagicMock()
+                mock_version_process.stdout = MagicMock()
+                mock_version_process.stdout.receive = AsyncMock(
+                    return_value=b"2.0.0 (Claude Code)"
+                )
+                mock_version_process.terminate = MagicMock()
+                mock_version_process.wait = AsyncMock()
+
+                # Mock main process
                 mock_process = MagicMock()
                 mock_process.returncode = None
                 mock_process.terminate = MagicMock()
@@ -175,7 +185,8 @@ class TestSubprocessCLITransport:
                 mock_stdin.aclose = AsyncMock()
                 mock_process.stdin = mock_stdin
 
-                mock_exec.return_value = mock_process
+                # Return version process first, then main process
+                mock_exec.side_effect = [mock_version_process, mock_process]
 
                 transport = SubprocessCLITransport(
                     prompt="test",
@@ -363,13 +374,25 @@ class TestSubprocessCLITransport:
             with patch(
                 "anyio.open_process", new_callable=AsyncMock
             ) as mock_open_process:
+                # Mock version check process
+                mock_version_process = MagicMock()
+                mock_version_process.stdout = MagicMock()
+                mock_version_process.stdout.receive = AsyncMock(
+                    return_value=b"2.0.0 (Claude Code)"
+                )
+                mock_version_process.terminate = MagicMock()
+                mock_version_process.wait = AsyncMock()
+
+                # Mock main process
                 mock_process = MagicMock()
                 mock_process.stdout = MagicMock()
                 mock_stdin = MagicMock()
                 mock_stdin.aclose = AsyncMock()  # Add async aclose method
                 mock_process.stdin = mock_stdin
                 mock_process.returncode = None
-                mock_open_process.return_value = mock_process
+
+                # Return version process first, then main process
+                mock_open_process.side_effect = [mock_version_process, mock_process]
 
                 transport = SubprocessCLITransport(
                     prompt="test",
@@ -379,11 +402,13 @@ class TestSubprocessCLITransport:
 
                 await transport.connect()
 
-                # Verify open_process was called with correct env vars
-                mock_open_process.assert_called_once()
-                call_kwargs = mock_open_process.call_args.kwargs
-                assert "env" in call_kwargs
-                env_passed = call_kwargs["env"]
+                # Verify open_process was called twice (version check + main process)
+                assert mock_open_process.call_count == 2
+
+                # Check the second call (main process) for env vars
+                second_call_kwargs = mock_open_process.call_args_list[1].kwargs
+                assert "env" in second_call_kwargs
+                env_passed = second_call_kwargs["env"]
 
                 # Check that custom env var was passed
                 assert env_passed["MY_TEST_VAR"] == test_value
@@ -410,13 +435,25 @@ class TestSubprocessCLITransport:
             with patch(
                 "anyio.open_process", new_callable=AsyncMock
             ) as mock_open_process:
+                # Mock version check process
+                mock_version_process = MagicMock()
+                mock_version_process.stdout = MagicMock()
+                mock_version_process.stdout.receive = AsyncMock(
+                    return_value=b"2.0.0 (Claude Code)"
+                )
+                mock_version_process.terminate = MagicMock()
+                mock_version_process.wait = AsyncMock()
+
+                # Mock main process
                 mock_process = MagicMock()
                 mock_process.stdout = MagicMock()
                 mock_stdin = MagicMock()
                 mock_stdin.aclose = AsyncMock()  # Add async aclose method
                 mock_process.stdin = mock_stdin
                 mock_process.returncode = None
-                mock_open_process.return_value = mock_process
+
+                # Return version process first, then main process
+                mock_open_process.side_effect = [mock_version_process, mock_process]
 
                 transport = SubprocessCLITransport(
                     prompt="test",
@@ -426,11 +463,13 @@ class TestSubprocessCLITransport:
 
                 await transport.connect()
 
-                # Verify open_process was called with correct user
-                mock_open_process.assert_called_once()
-                call_kwargs = mock_open_process.call_args.kwargs
-                assert "user" in call_kwargs
-                user_passed = call_kwargs["user"]
+                # Verify open_process was called twice (version check + main process)
+                assert mock_open_process.call_count == 2
+
+                # Check the second call (main process) for user
+                second_call_kwargs = mock_open_process.call_args_list[1].kwargs
+                assert "user" in second_call_kwargs
+                user_passed = second_call_kwargs["user"]
 
                 # Check that user was passed
                 assert user_passed == "claude"

{claude_agent_sdk-0.0.23 → claude_agent_sdk-0.1.1}/tests/test_types.py

@@ -145,7 +145,7 @@ class TestOptions:
     def test_claude_code_options_with_model_specification(self):
         """Test Options with model specification."""
         options = ClaudeAgentOptions(
-            model="claude-3-5-sonnet-20241022", permission_prompt_tool_name="CustomTool"
+            model="claude-sonnet-4-5", permission_prompt_tool_name="CustomTool"
         )
-        assert options.model == "claude-3-5-sonnet-20241022"
+        assert options.model == "claude-sonnet-4-5"
         assert options.permission_prompt_tool_name == "CustomTool"

claude_agent_sdk-0.0.23/tests/mock_transport.py

@@ -1,177 +0,0 @@
-"""Mock transport implementation for testing."""
-
-import json
-from collections.abc import AsyncIterator
-from typing import Any
-
-import anyio
-
-from claude_agent_sdk._internal.transport import Transport
-
-
-class MockTransport(Transport):
-    """Mock transport for testing Query and Client behavior.
-
-    This transport allows tests to:
-    - Capture all messages written by the SDK
-    - Simulate responses from the CLI
-    - Control message flow timing
-    """
-
-    def __init__(self):
-        """Initialize mock transport."""
-        self.written_messages: list[dict[str, Any]] = []
-        self.messages_to_read: list[dict[str, Any]] = []
-        self._ready = False
-        self._read_index = 0
-        self._write_delay = 0.0  # Optional delay for write operations
-        self._read_delay = 0.0  # Optional delay between messages
-
-    async def connect(self) -> None:
-        """Mark transport as ready."""
-        self._ready = True
-
-    async def write(self, data: str) -> None:
-        """Capture written messages.
-
-        Args:
-            data: JSON string with newline
-        """
-        if self._write_delay > 0:
-            await anyio.sleep(self._write_delay)
-
-        # Parse and store the message
-        message = json.loads(data.strip())
-        self.written_messages.append(message)
-
-    async def read_messages(self) -> AsyncIterator[dict[str, Any]]:
-        """Yield messages from the configured list.
-
-        Yields:
-            Messages added via add_message_to_read()
-        """
-        # Auto-respond to initialize requests
-        responded_to_init = False
-
-        while self._ready:
-            # Check for initialize requests we need to respond to
-            if not responded_to_init:
-                for msg in self.written_messages:
-                    if (
-                        msg.get("type") == "control_request"
-                        and msg.get("request", {}).get("subtype") == "initialize"
-                    ):
-                        # Auto-send initialize response
-                        responded_to_init = True
-                        yield {
-                            "type": "control_response",
-                            "response": {
-                                "subtype": "success",
-                                "request_id": msg.get("request_id"),
-                                "response": {
-                                    "commands": [],
-                                    "output_style": "default",
-                                    "hooks": [],  # Will be populated by Query.initialize
-                                },
-                            },
-                        }
-                        break
-
-            # Yield any manually added messages
-            if self._read_index < len(self.messages_to_read):
-                if self._read_delay > 0:
-                    await anyio.sleep(self._read_delay)
-
-                message = self.messages_to_read[self._read_index]
-                self._read_index += 1
-                yield message
-            else:
-                # Small delay to avoid busy loop
-                await anyio.sleep(0.01)
-
-    async def close(self) -> None:
-        """Mark transport as not ready."""
-        self._ready = False
-
-    def is_ready(self) -> bool:
-        """Check if transport is ready.
-
-        Returns:
-            True if connect() was called and close() wasn't
-        """
-        return self._ready
-
-    async def end_input(self) -> None:
-        """No-op for mock transport."""
-        pass
-
-    # Helper methods for testing
-
-    def add_message_to_read(self, message: dict[str, Any]) -> None:
-        """Add a message that will be returned by read_messages().
-
-        Args:
-            message: Message dict to be yielded by read_messages()
-        """
-        self.messages_to_read.append(message)
-
-    def add_control_request(self, subtype: str, request_id: str, **kwargs: Any) -> None:
-        """Helper to add a control request message.
-
-        Args:
-            subtype: Control request subtype (e.g., "initialize", "hook_callback")
-            request_id: Request ID
-            **kwargs: Additional request fields
-        """
-        self.add_message_to_read(
-            {
-                "type": "control_request",
-                "request_id": request_id,
-                "request": {"subtype": subtype, **kwargs},
-            }
-        )
-
-    def get_written_messages(self, msg_type: str | None = None) -> list[dict[str, Any]]:
-        """Get written messages, optionally filtered by type.
-
-        Args:
-            msg_type: Optional message type to filter by
-
-        Returns:
-            List of written messages
-        """
-        if msg_type is None:
-            return self.written_messages
-        return [msg for msg in self.written_messages if msg.get("type") == msg_type]
-
-    def get_control_responses(self) -> list[dict[str, Any]]:
-        """Get all control response messages that were written.
-
-        Returns:
-            List of control response messages
-        """
-        return self.get_written_messages("control_response")
-
-    def get_last_response(self) -> dict[str, Any] | None:
-        """Get the last written message.
-
-        Returns:
-            Last written message or None if no messages
-        """
-        return self.written_messages[-1] if self.written_messages else None
-
-    def clear(self) -> None:
-        """Clear all messages and reset state."""
-        self.written_messages.clear()
-        self.messages_to_read.clear()
-        self._read_index = 0
-
-    def set_delays(self, write_delay: float = 0.0, read_delay: float = 0.0) -> None:
-        """Set artificial delays for testing timing issues.
-
-        Args:
-            write_delay: Delay in seconds for write operations
-            read_delay: Delay in seconds between read messages
-        """
-        self._write_delay = write_delay
-        self._read_delay = read_delay

claude_agent_sdk-0.0.23/tests/test_hooks.py

@@ -1,148 +0,0 @@
-"""Tests for the hooks decorator API."""
-
-import anyio
-
-from claude_agent_sdk.hooks import (
-    PreToolUseHookResponse,
-    clear_registry,
-    get_registry,
-    post_tool_use,
-    pre_tool_use,
-)
-from claude_agent_sdk.hooks.executor import execute_hook
-
-
-class TestHooksAPI:
-    """Test the decorator-based hooks API."""
-
-    def setup_method(self):
-        """Clear registry before each test."""
-        clear_registry()
-
-    def test_decorator_registers_and_executes(self):
-        """Test that decorators register hooks and they execute properly."""
-
-        async def _test():
-            executed = []
-
-            # Test pre_tool_use decorator
-            @pre_tool_use(matcher="Bash", timeout=5)
-            def check_dangerous_commands(tool_name, tool_input):
-                executed.append(("pre", tool_name, tool_input.to_dict()))
-                if "rm -rf /" in tool_input.get("command", ""):
-                    return PreToolUseHookResponse(
-                        permission_decision="deny",
-                        permission_decision_reason="Dangerous command blocked",
-                    )
-                return None  # Allow
-
-            # Verify registration
-            registry = get_registry()
-            hooks = registry.get_hooks("PreToolUse")
-            assert len(hooks) == 1
-            assert hooks[0].matcher == "Bash"
-            assert hooks[0].timeout == 5
-
-            # Test execution with dangerous command
-            result = await execute_hook(
-                check_dangerous_commands,
-                {"tool_name": "Bash", "tool_input": {"command": "rm -rf /"}},
-            )
-            assert isinstance(result, PreToolUseHookResponse)
-            assert result.permission_decision == "deny"
-            assert "Dangerous command blocked" in result.permission_decision_reason
-
-            # Test execution with safe command
-            result = await execute_hook(
-                check_dangerous_commands,
-                {"tool_name": "Bash", "tool_input": {"command": "ls -la"}},
-            )
-            assert result is None  # Allowed
-
-            # Verify hook was called
-            assert len(executed) == 2
-            assert executed[0][0] == "pre"
-            assert executed[0][1] == "Bash"
-
-        anyio.run(_test)
-
-    def test_registry_lifecycle(self):
-        """Test registry clear and isolation between tests."""
-
-        # Register some hooks
-        @pre_tool_use()
-        def hook1():
-            pass
-
-        @post_tool_use(matcher="Write")
-        def hook2():
-            pass
-
-        registry = get_registry()
-        assert len(registry.get_hooks("PreToolUse")) == 1
-        assert len(registry.get_hooks("PostToolUse")) == 1
-
-        # Clear registry
-        clear_registry()
-        assert len(registry.get_hooks("PreToolUse")) == 0
-        assert len(registry.get_hooks("PostToolUse")) == 0
-
-        # Register new hooks - verify no interference
-        @pre_tool_use(matcher="Read")
-        def hook3():
-            pass
-
-        assert len(registry.get_hooks("PreToolUse")) == 1
-        assert registry.get_hooks("PreToolUse")[0].matcher == "Read"
-
-    def test_parameter_introspection(self):
-        """Test that hooks only receive the parameters they request."""
-
-        async def _test():
-            received_params = {}
-
-            # Hook that only wants tool_name
-            def minimal_hook(tool_name):
-                received_params["minimal"] = {"tool_name": tool_name}
-                return None
-
-            # Hook that wants multiple params
-            def full_hook(tool_name, tool_input, tool_use_id):
-                received_params["full"] = {
-                    "tool_name": tool_name,
-                    "tool_input": tool_input.to_dict(),
-                    "tool_use_id": tool_use_id,
-                }
-                return None
-
-            # Test minimal hook - should only get tool_name
-            await execute_hook(
-                minimal_hook,
-                {
-                    "tool_name": "TestTool",
-                    "tool_input": {"data": "test"},
-                    "extra": "ignored",
-                },
-                tool_use_id="123",
-            )
-
-            assert "minimal" in received_params
-            assert received_params["minimal"] == {"tool_name": "TestTool"}
-
-            # Test full hook - should get all requested params
-            await execute_hook(
-                full_hook,
-                {
-                    "tool_name": "TestTool",
-                    "tool_input": {"data": "test"},
-                    "extra": "also_ignored",
-                },
-                tool_use_id="456",
-            )
-
-            assert "full" in received_params
-            assert received_params["full"]["tool_name"] == "TestTool"
-            assert received_params["full"]["tool_input"] == {"data": "test"}
-            assert received_params["full"]["tool_use_id"] == "456"
-
-        anyio.run(_test)