claude-agent-sdk 0.1.0__tar.gz → 0.1.2__tar.gz

{claude_agent_sdk-0.1.0 → claude_agent_sdk-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-agent-sdk
-Version: 0.1.0
+Version: 0.1.2
 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.1.0 → claude_agent_sdk-0.1.2}/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.1.0 → claude_agent_sdk-0.1.2}/pyproject.toml

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

{claude_agent_sdk-0.1.0 → claude_agent_sdk-0.1.2}/src/claude_agent_sdk/__init__.py

@@ -23,6 +23,7 @@ from .types import (
     ContentBlock,
     HookCallback,
     HookContext,
+    HookJSONOutput,
     HookMatcher,
     McpSdkServerConfig,
     McpServerConfig,
@@ -308,6 +309,7 @@ __all__ = [
     "PermissionUpdate",
     "HookCallback",
     "HookContext",
+    "HookJSONOutput",
     "HookMatcher",
     # Agent support
     "AgentDefinition",

{claude_agent_sdk-0.1.0 → claude_agent_sdk-0.1.2}/src/claude_agent_sdk/_internal/query.py

@@ -195,6 +195,7 @@ class Query:
 
             if subtype == "can_use_tool":
                 permission_request: SDKControlPermissionRequest = request_data  # type: ignore[assignment]
+                original_input = permission_request["input"]
                 # Handle tool permission request
                 if not self.can_use_tool:
                     raise Exception("canUseTool callback is not provided")
@@ -213,13 +214,23 @@ class Query:
 
                 # Convert PermissionResult to expected dict format
                 if isinstance(response, PermissionResultAllow):
-                    response_data = {"allow": True}
-                    if response.updated_input is not None:
-                        response_data["input"] = response.updated_input
-                    # TODO: Handle updatedPermissions when control protocol supports it
+                    response_data = {
+                        "behavior": "allow",
+                        "updatedInput": (
+                            response.updated_input
+                            if response.updated_input is not None
+                            else original_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.1.0 → claude_agent_sdk-0.1.2}/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
@@ -25,6 +27,7 @@ from . import Transport
 logger = logging.getLogger(__name__)
 
 _DEFAULT_MAX_BUFFER_SIZE = 1024 * 1024  # 1MB buffer limit
+MINIMUM_CLAUDE_CODE_VERSION = "2.0.0"
 
 
 class SubprocessCLITransport(Transport):
@@ -202,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
@@ -448,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.1.0 → claude_agent_sdk-0.1.2}/src/claude_agent_sdk/_version.py

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

{claude_agent_sdk-0.1.0 → claude_agent_sdk-0.1.2}/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.1.0 → claude_agent_sdk-0.1.2}/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
@@ -121,18 +157,74 @@ HookEvent = (
 )
 
 
+# Hook-specific output types
+class PreToolUseHookSpecificOutput(TypedDict):
+    """Hook-specific output for PreToolUse events."""
+
+    hookEventName: Literal["PreToolUse"]
+    permissionDecision: NotRequired[Literal["allow", "deny", "ask"]]
+    permissionDecisionReason: NotRequired[str]
+    updatedInput: NotRequired[dict[str, Any]]
+
+
+class PostToolUseHookSpecificOutput(TypedDict):
+    """Hook-specific output for PostToolUse events."""
+
+    hookEventName: Literal["PostToolUse"]
+    additionalContext: NotRequired[str]
+
+
+class UserPromptSubmitHookSpecificOutput(TypedDict):
+    """Hook-specific output for UserPromptSubmit events."""
+
+    hookEventName: Literal["UserPromptSubmit"]
+    additionalContext: NotRequired[str]
+
+
+class SessionStartHookSpecificOutput(TypedDict):
+    """Hook-specific output for SessionStart events."""
+
+    hookEventName: Literal["SessionStart"]
+    additionalContext: NotRequired[str]
+
+
+HookSpecificOutput = (
+    PreToolUseHookSpecificOutput
+    | PostToolUseHookSpecificOutput
+    | UserPromptSubmitHookSpecificOutput
+    | SessionStartHookSpecificOutput
+)
+
+
 # See https://docs.anthropic.com/en/docs/claude-code/hooks#advanced%3A-json-output
-# for documentation of the output types. Currently, "continue", "stopReason",
-# and "suppressOutput" are not supported in the Python SDK.
-class HookJSONOutput(TypedDict):
-    # Whether to block the action related to the hook.
+# for documentation of the output types.
+class AsyncHookJSONOutput(TypedDict):
+    """Async hook output that defers hook execution."""
+
+    async_: Literal[True]  # Using async_ to avoid Python keyword
+    asyncTimeout: NotRequired[int]
+
+
+class SyncHookJSONOutput(TypedDict):
+    """Synchronous hook output with control and decision fields."""
+
+    # Common control fields
+    continue_: NotRequired[bool]  # Using continue_ to avoid Python keyword
+    suppressOutput: NotRequired[bool]
+    stopReason: NotRequired[str]
+
+    # Decision fields
+    # Note: "approve" is deprecated for PreToolUse (use permissionDecision instead)
+    # For other hooks, only "block" is meaningful
     decision: NotRequired[Literal["block"]]
-    # Optionally add a system message that is not visible to Claude but saved in
-    # the chat transcript.
     systemMessage: NotRequired[str]
-    # See each hook's individual "Decision Control" section in the documentation
-    # for guidance.
-    hookSpecificOutput: NotRequired[Any]
+    reason: NotRequired[str]
+
+    # Hook-specific outputs
+    hookSpecificOutput: NotRequired[HookSpecificOutput]
+
+
+HookJSONOutput = AsyncHookJSONOutput | SyncHookJSONOutput
 
 
 @dataclass

{claude_agent_sdk-0.1.0 → claude_agent_sdk-0.1.2}/tests/test_streaming_client.py

@@ -633,21 +633,28 @@ assert '"Second"' in stdin_messages[1]
 print('{"type": "result", "subtype": "success", "duration_ms": 100, "duration_api_ms": 50, "is_error": false, "num_turns": 1, "session_id": "test", "total_cost_usd": 0.001}')
 """)
 
-            Path(test_script).chmod(0o755)
+            # Make script executable (Unix-style systems)
+            if sys.platform != "win32":
+                Path(test_script).chmod(0o755)
 
             try:
-                # Mock _find_cli to return python executing our test script
+                # Mock _find_cli to return the test script path directly
                 with patch.object(
-                    SubprocessCLITransport, "_find_cli", return_value=sys.executable
+                    SubprocessCLITransport, "_find_cli", return_value=test_script
                 ):
-                    # Mock _build_command to add our test script as first argument
+                    # Mock _build_command to properly execute Python script
                     original_build_command = SubprocessCLITransport._build_command
 
                     def mock_build_command(self):
                         # Get original command
                         cmd = original_build_command(self)
-                        # Replace the CLI path with python + script
-                        cmd[0] = test_script
+                        # On Windows, we need to use python interpreter to run the script
+                        if sys.platform == "win32":
+                            # Replace first element with python interpreter and script
+                            cmd[0:1] = [sys.executable, test_script]
+                        else:
+                            # On Unix, just use the script directly
+                            cmd[0] = test_script
                         return cmd
 
                     with patch.object(

{claude_agent_sdk-0.1.0 → claude_agent_sdk-0.1.2}/tests/test_tool_callbacks.py

@@ -1,10 +1,13 @@
 """Tests for tool permission callbacks and hook callbacks."""
 
+import json
+
 import pytest
 
 from claude_agent_sdk import (
     ClaudeAgentOptions,
     HookContext,
+    HookJSONOutput,
     HookMatcher,
     PermissionResultAllow,
     PermissionResultDeny,
@@ -90,7 +93,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 +128,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 +167,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
@@ -257,6 +260,136 @@ class TestHookCallbacks:
         last_response = transport.written_messages[-1]
         assert '"processed": true' in last_response
 
+    @pytest.mark.asyncio
+    async def test_hook_output_fields(self):
+        """Test that all SyncHookJSONOutput fields are properly handled."""
+
+        # Test all SyncHookJSONOutput fields together
+        async def comprehensive_hook(
+            input_data: dict, tool_use_id: str | None, context: HookContext
+        ) -> HookJSONOutput:
+            return {
+                # Control fields
+                "continue_": True,
+                "suppressOutput": False,
+                "stopReason": "Test stop reason",
+                # Decision fields
+                "decision": "block",
+                "systemMessage": "Test system message",
+                "reason": "Test reason for blocking",
+                # Hook-specific output with all PreToolUse fields
+                "hookSpecificOutput": {
+                    "hookEventName": "PreToolUse",
+                    "permissionDecision": "deny",
+                    "permissionDecisionReason": "Security policy violation",
+                    "updatedInput": {"modified": "input"},
+                },
+            }
+
+        transport = MockTransport()
+        hooks = {
+            "PreToolUse": [
+                {"matcher": {"tool": "TestTool"}, "hooks": [comprehensive_hook]}
+            ]
+        }
+
+        query = Query(
+            transport=transport, is_streaming_mode=True, can_use_tool=None, hooks=hooks
+        )
+
+        callback_id = "test_comprehensive_hook"
+        query.hook_callbacks[callback_id] = comprehensive_hook
+
+        request = {
+            "type": "control_request",
+            "request_id": "test-comprehensive",
+            "request": {
+                "subtype": "hook_callback",
+                "callback_id": callback_id,
+                "input": {"test": "data"},
+                "tool_use_id": "tool-456",
+            },
+        }
+
+        await query._handle_control_request(request)
+
+        # Check response contains all the fields
+        assert len(transport.written_messages) > 0
+        last_response = transport.written_messages[-1]
+
+        # Parse the JSON response
+        response_data = json.loads(last_response)
+        # The hook result is nested at response.response
+        result = response_data["response"]["response"]
+
+        # Verify control fields are present
+        assert result.get("continue_") is True or result.get("continue") is True
+        assert result.get("suppressOutput") is False
+        assert result.get("stopReason") == "Test stop reason"
+
+        # Verify decision fields are present
+        assert result.get("decision") == "block"
+        assert result.get("reason") == "Test reason for blocking"
+        assert result.get("systemMessage") == "Test system message"
+
+        # Verify hook-specific output is present
+        hook_output = result.get("hookSpecificOutput", {})
+        assert hook_output.get("hookEventName") == "PreToolUse"
+        assert hook_output.get("permissionDecision") == "deny"
+        assert (
+            hook_output.get("permissionDecisionReason") == "Security policy violation"
+        )
+        assert "updatedInput" in hook_output
+
+    @pytest.mark.asyncio
+    async def test_async_hook_output(self):
+        """Test AsyncHookJSONOutput type with proper async fields."""
+
+        async def async_hook(
+            input_data: dict, tool_use_id: str | None, context: HookContext
+        ) -> HookJSONOutput:
+            # Test that async hooks properly use async_ and asyncTimeout fields
+            return {
+                "async_": True,
+                "asyncTimeout": 5000,
+            }
+
+        transport = MockTransport()
+        hooks = {"PreToolUse": [{"matcher": None, "hooks": [async_hook]}]}
+
+        query = Query(
+            transport=transport, is_streaming_mode=True, can_use_tool=None, hooks=hooks
+        )
+
+        callback_id = "test_async_hook"
+        query.hook_callbacks[callback_id] = async_hook
+
+        request = {
+            "type": "control_request",
+            "request_id": "test-async",
+            "request": {
+                "subtype": "hook_callback",
+                "callback_id": callback_id,
+                "input": {"test": "async_data"},
+                "tool_use_id": None,
+            },
+        }
+
+        await query._handle_control_request(request)
+
+        # Check response contains async fields
+        assert len(transport.written_messages) > 0
+        last_response = transport.written_messages[-1]
+
+        # Parse the JSON response
+        response_data = json.loads(last_response)
+        # The hook result is nested at response.response
+        result = response_data["response"]["response"]
+
+        # The SDK should preserve the async_ field (or convert to "async")
+        assert result.get("async_") is True or result.get("async") is True
+        assert result.get("asyncTimeout") == 5000
+
 
 class TestClaudeAgentOptionsIntegration:
     """Test that callbacks work through ClaudeAgentOptions."""

{claude_agent_sdk-0.1.0 → claude_agent_sdk-0.1.2}/tests/test_transport.py

@@ -44,13 +44,15 @@ class TestSubprocessCLITransport:
         """Test that cli_path accepts pathlib.Path objects."""
         from pathlib import Path
 
+        path = Path("/usr/bin/claude")
         transport = SubprocessCLITransport(
             prompt="Hello",
             options=ClaudeAgentOptions(),
-            cli_path=Path("/usr/bin/claude"),
+            cli_path=path,
         )
 
-        assert transport._cli_path == "/usr/bin/claude"
+        # Path object is converted to string, compare with str(path)
+        assert transport._cli_path == str(path)
 
     def test_build_command_with_system_prompt_string(self):
         """Test building CLI command with system prompt as string."""
@@ -106,7 +108,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 +121,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
@@ -129,19 +131,25 @@ class TestSubprocessCLITransport:
         """Test building CLI command with add_dirs option."""
         from pathlib import Path
 
+        dir1 = "/path/to/dir1"
+        dir2 = Path("/path/to/dir2")
         transport = SubprocessCLITransport(
             prompt="test",
-            options=ClaudeAgentOptions(
-                add_dirs=["/path/to/dir1", Path("/path/to/dir2")]
-            ),
+            options=ClaudeAgentOptions(add_dirs=[dir1, dir2]),
             cli_path="/usr/bin/claude",
         )
 
         cmd = transport._build_command()
-        cmd_str = " ".join(cmd)
 
-        # Check that the command string contains the expected --add-dir flags
-        assert "--add-dir /path/to/dir1 --add-dir /path/to/dir2" in cmd_str
+        # Check that both directories are in the command
+        assert "--add-dir" in cmd
+        add_dir_indices = [i for i, x in enumerate(cmd) if x == "--add-dir"]
+        assert len(add_dir_indices) == 2
+
+        # The directories should appear after --add-dir flags
+        dirs_in_cmd = [cmd[i + 1] for i in add_dir_indices]
+        assert dir1 in dirs_in_cmd
+        assert str(dir2) in dirs_in_cmd
 
     def test_session_continuation(self):
         """Test session continuation options."""
@@ -163,6 +171,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 +193,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",
@@ -311,28 +330,31 @@ class TestSubprocessCLITransport:
         from pathlib import Path
 
         # Test with string path
+        string_path = "/path/to/mcp-config.json"
         transport = SubprocessCLITransport(
             prompt="test",
-            options=ClaudeAgentOptions(mcp_servers="/path/to/mcp-config.json"),
+            options=ClaudeAgentOptions(mcp_servers=string_path),
             cli_path="/usr/bin/claude",
         )
 
         cmd = transport._build_command()
         assert "--mcp-config" in cmd
         mcp_idx = cmd.index("--mcp-config")
-        assert cmd[mcp_idx + 1] == "/path/to/mcp-config.json"
+        assert cmd[mcp_idx + 1] == string_path
 
         # Test with Path object
+        path_obj = Path("/path/to/mcp-config.json")
         transport = SubprocessCLITransport(
             prompt="test",
-            options=ClaudeAgentOptions(mcp_servers=Path("/path/to/mcp-config.json")),
+            options=ClaudeAgentOptions(mcp_servers=path_obj),
             cli_path="/usr/bin/claude",
         )
 
         cmd = transport._build_command()
         assert "--mcp-config" in cmd
         mcp_idx = cmd.index("--mcp-config")
-        assert cmd[mcp_idx + 1] == "/path/to/mcp-config.json"
+        # Path object gets converted to string, compare with str(path_obj)
+        assert cmd[mcp_idx + 1] == str(path_obj)
 
     def test_build_command_with_mcp_servers_as_json_string(self):
         """Test building CLI command with mcp_servers as JSON string."""
@@ -363,13 +385,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 +413,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 +446,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 +474,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.1.0 → claude_agent_sdk-0.1.2}/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"