Merge branch 'anthropics:main' into main

Author: Mng-dev-ai

CHANGELOG.md

@@ -1,5 +1,63 @@
 # Changelog
 
+## 0.1.46
+
+### New Features
+
+- **Session history functions**: Added `list_sessions()` and `get_session_messages()` top-level functions for retrieving past session data (#622)
+- **MCP control methods**: Added `add_mcp_server()`, `remove_mcp_server()`, and typed `McpServerStatus` for runtime MCP server management (#620)
+- **Typed task messages**: Added `TaskStarted`, `TaskProgress`, and `TaskNotification` message subclasses for better type safety when handling task-related events (#621)
+- **ResultMessage stop_reason**: Added `stop_reason` field to `ResultMessage` for inspecting why a conversation turn ended (#619)
+- **Hook input enhancements**: Added `agent_id` and `agent_type` fields to tool-lifecycle hook inputs (`PreToolUseHookInput`, `PostToolUseHookInput`, `PostToolUseFailureHookInput`) (#628)
+
+### Bug Fixes
+
+- **String prompt MCP initialization**: Fixed an issue where passing a string prompt would close stdin before MCP server initialization completed, causing MCP servers to fail to register (#630)
+
+### Internal/Other Changes
+
+- Updated bundled Claude CLI to version 2.1.69
+
+## 0.1.45
+
+### Internal/Other Changes
+
+- Updated bundled Claude CLI to version 2.1.63
+
+## 0.1.44
+
+### Internal/Other Changes
+
+- Updated bundled Claude CLI to version 2.1.59
+
+## 0.1.43
+
+### Internal/Other Changes
+
+- Updated bundled Claude CLI to version 2.1.56
+
+## 0.1.42
+
+### Internal/Other Changes
+
+- Updated bundled Claude CLI to version 2.1.55
+
+## 0.1.41
+
+### Internal/Other Changes
+
+- Updated bundled Claude CLI to version 2.1.52
+
+## 0.1.40
+
+### Bug Fixes
+
+- **Unknown message type handling**: Fixed an issue where unrecognized CLI message types (e.g., `rate_limit_event`) would crash the session by raising `MessageParseError`. Unknown message types are now silently skipped, making the SDK forward-compatible with future CLI message types (#598)
+
+### Internal/Other Changes
+
+- Updated bundled Claude CLI to version 2.1.51
+
 ## 0.1.39
 
 ### Internal/Other Changes

pyproject.toml

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

src/claude_agent_sdk/__init__.py

@@ -13,6 +13,7 @@
     CLINotFoundError,
     ProcessError,
 )
+from ._internal.sessions import get_session_messages, list_sessions
 from ._internal.transport import Transport
 from ._version import __version__
 from .client import ClaudeSDKClient
@@ -31,6 +32,13 @@
     HookMatcher,
     McpSdkServerConfig,
     McpServerConfig,
+    McpServerConnectionStatus,
+    McpServerInfo,
+    McpServerStatus,
+    McpServerStatusConfig,
+    McpStatusResponse,
+    McpToolAnnotations,
+    McpToolInfo,
     Message,
     NotificationHookInput,
     NotificationHookSpecificOutput,
@@ -52,12 +60,19 @@
     SandboxSettings,
     SdkBeta,
     SdkPluginConfig,
+    SDKSessionInfo,
+    SessionMessage,
     SettingSource,
     StopHookInput,
     SubagentStartHookInput,
     SubagentStartHookSpecificOutput,
     SubagentStopHookInput,
     SystemMessage,
+    TaskNotificationMessage,
+    TaskNotificationStatus,
+    TaskProgressMessage,
+    TaskStartedMessage,
+    TaskUsage,
     TextBlock,
     ThinkingBlock,
     ThinkingConfig,
@@ -330,9 +345,21 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> Any:
     "PermissionMode",
     "McpServerConfig",
     "McpSdkServerConfig",
+    "McpServerStatus",
+    "McpServerStatusConfig",
+    "McpServerConnectionStatus",
+    "McpServerInfo",
+    "McpStatusResponse",
+    "McpToolAnnotations",
+    "McpToolInfo",
     "UserMessage",
     "AssistantMessage",
     "SystemMessage",
+    "TaskStartedMessage",
+    "TaskProgressMessage",
+    "TaskNotificationMessage",
+    "TaskNotificationStatus",
+    "TaskUsage",
     "ResultMessage",
     "Message",
     "ClaudeAgentOptions",
@@ -378,6 +405,11 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> Any:
     "SettingSource",
     # Plugin support
     "SdkPluginConfig",
+    # Session listing
+    "list_sessions",
+    "get_session_messages",
+    "SDKSessionInfo",
+    "SessionMessage",
     # Beta support
     "SdkBeta",
     # Sandbox support

src/claude_agent_sdk/_cli_version.py

@@ -1,3 +1,3 @@
 """Bundled Claude Code CLI version."""
 
-__cli_version__ = "2.1.49"
+__cli_version__ = "2.1.69"

src/claude_agent_sdk/_internal/client.py

@@ -1,5 +1,6 @@
 """Internal client implementation."""
 
+import json
 from collections.abc import AsyncIterable, AsyncIterator
 from dataclasses import asdict, replace
 from typing import Any
@@ -122,16 +123,14 @@ async def process_query(
             if isinstance(prompt, str):
                 # For string prompts, write user message to stdin after initialize
                 # (matching TypeScript SDK behavior)
-                import json
-
                 user_message = {
                     "type": "user",
                     "session_id": "",
                     "message": {"role": "user", "content": prompt},
                     "parent_tool_use_id": None,
                 }
                 await chosen_transport.write(json.dumps(user_message) + "\n")
-                await chosen_transport.end_input()
+                await query.wait_for_result_and_end_input()
             elif isinstance(prompt, AsyncIterable) and query._tg:
                 # Stream input in background for async iterables
                 query._tg.start_soon(query.stream_input, prompt)

src/claude_agent_sdk/_internal/message_parser.py

@@ -11,6 +11,9 @@
     ResultMessage,
     StreamEvent,
     SystemMessage,
+    TaskNotificationMessage,
+    TaskProgressMessage,
+    TaskStartedMessage,
     TextBlock,
     ThinkingBlock,
     ToolResultBlock,
@@ -136,10 +139,49 @@ def parse_message(data: dict[str, Any]) -> Message | None:
 
         case "system":
             try:
-                return SystemMessage(
-                    subtype=data["subtype"],
-                    data=data,
-                )
+                subtype = data["subtype"]
+                match subtype:
+                    case "task_started":
+                        return TaskStartedMessage(
+                            subtype=subtype,
+                            data=data,
+                            task_id=data["task_id"],
+                            description=data["description"],
+                            uuid=data["uuid"],
+                            session_id=data["session_id"],
+                            tool_use_id=data.get("tool_use_id"),
+                            task_type=data.get("task_type"),
+                        )
+                    case "task_progress":
+                        return TaskProgressMessage(
+                            subtype=subtype,
+                            data=data,
+                            task_id=data["task_id"],
+                            description=data["description"],
+                            usage=data["usage"],
+                            uuid=data["uuid"],
+                            session_id=data["session_id"],
+                            tool_use_id=data.get("tool_use_id"),
+                            last_tool_name=data.get("last_tool_name"),
+                        )
+                    case "task_notification":
+                        return TaskNotificationMessage(
+                            subtype=subtype,
+                            data=data,
+                            task_id=data["task_id"],
+                            status=data["status"],
+                            output_file=data["output_file"],
+                            summary=data["summary"],
+                            uuid=data["uuid"],
+                            session_id=data["session_id"],
+                            tool_use_id=data.get("tool_use_id"),
+                            usage=data.get("usage"),
+                        )
+                    case _:
+                        return SystemMessage(
+                            subtype=subtype,
+                            data=data,
+                        )
             except KeyError as e:
                 raise MessageParseError(
                     f"Missing required field in system message: {e}", data
@@ -154,6 +196,7 @@ def parse_message(data: dict[str, Any]) -> Message | None:
                     is_error=data["is_error"],
                     num_turns=data["num_turns"],
                     session_id=data["session_id"],
+                    stop_reason=data.get("stop_reason"),
                     total_cost_usd=data.get("total_cost_usd"),
                     usage=data.get("usage"),
                     result=data.get("result"),

src/claude_agent_sdk/_internal/query.py

@@ -227,6 +227,9 @@ async def _read_messages(self) -> None:
             # Put error in stream so iterators can handle it
             await self._message_send.send({"type": "error", "error": str(e)})
         finally:
+            # Unblock any waiters (e.g. string-prompt path waiting for first
+            # result) so they don't stall for the full timeout on early exit.
+            self._first_result_event.set()
             # Always signal end of stream
             await self._message_send.send({"type": "end"})
 
@@ -567,6 +570,65 @@ async def rewind_files(self, user_message_id: str) -> None:
             }
         )
 
+    async def reconnect_mcp_server(self, server_name: str) -> None:
+        """Reconnect a disconnected or failed MCP server.
+
+        Args:
+            server_name: The name of the MCP server to reconnect
+        """
+        await self._send_control_request(
+            {
+                "subtype": "mcp_reconnect",
+                "serverName": server_name,
+            }
+        )
+
+    async def toggle_mcp_server(self, server_name: str, enabled: bool) -> None:
+        """Enable or disable an MCP server.
+
+        Args:
+            server_name: The name of the MCP server to toggle
+            enabled: Whether the server should be enabled
+        """
+        await self._send_control_request(
+            {
+                "subtype": "mcp_toggle",
+                "serverName": server_name,
+                "enabled": enabled,
+            }
+        )
+
+    async def stop_task(self, task_id: str) -> None:
+        """Stop a running task.
+
+        Args:
+            task_id: The task ID from task_notification events
+        """
+        await self._send_control_request(
+            {
+                "subtype": "stop_task",
+                "task_id": task_id,
+            }
+        )
+
+    async def wait_for_result_and_end_input(self) -> None:
+        """Wait for the first result (if needed) then close stdin.
+
+        If SDK MCP servers or hooks require bidirectional communication,
+        keeps stdin open until the first result arrives (or timeout).
+        Otherwise closes stdin immediately.
+        """
+        if self.sdk_mcp_servers or self.hooks:
+            logger.debug(
+                "Waiting for first result before closing stdin "
+                f"(sdk_mcp_servers={len(self.sdk_mcp_servers)}, "
+                f"has_hooks={bool(self.hooks)})"
+            )
+            with anyio.move_on_after(self._stream_close_timeout):
+                await self._first_result_event.wait()
+
+        await self.transport.end_input()
+
     async def stream_input(self, stream: AsyncIterable[dict[str, Any]]) -> None:
         """Stream input messages to transport.
 
@@ -579,25 +641,7 @@ async def stream_input(self, stream: AsyncIterable[dict[str, Any]]) -> None:
                     break
                 await self.transport.write(json.dumps(message) + "\n")
 
-            # If we have SDK MCP servers or hooks that need bidirectional communication,
-            # wait for first result before closing the channel
-            has_hooks = bool(self.hooks)
-            if self.sdk_mcp_servers or has_hooks:
-                logger.debug(
-                    f"Waiting for first result before closing stdin "
-                    f"(sdk_mcp_servers={len(self.sdk_mcp_servers)}, has_hooks={has_hooks})"
-                )
-                try:
-                    with anyio.move_on_after(self._stream_close_timeout):
-                        await self._first_result_event.wait()
-                        logger.debug("Received first result, closing input stream")
-                except Exception:
-                    logger.debug(
-                        "Timed out waiting for first result, closing input stream"
-                    )
-
-            # After all messages sent (and result received if needed), end input
-            await self.transport.end_input()
+            await self.wait_for_result_and_end_input()
         except Exception as e:
             logger.debug(f"Error streaming input: {e}")