clawd-code-sdk 1.0.1__tar.gz → 1.0.3__tar.gz

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/PKG-INFO

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

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

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/__init__.py

@@ -37,6 +37,8 @@ from .models import (
     CommandHookHandler,
     OnUserQuestion,
     ContentBlock,
+    ImageBlock,
+    ImageSource,
     HookCallback,
     HookContext,
     HookHandler,
@@ -60,6 +62,7 @@ from .models import (
     PermissionResultAllow,
     PermissionResultDeny,
     PermissionUpdate,
+    PostCompactHookInput,
     PostToolUseFailureHookInput,
     PostToolUseFailureHookSpecificOutput,
     PostToolUseHookInput,
@@ -168,7 +171,9 @@ __all__ = [
     "HookMatcher",
     "HookMatcherConfig",
     "Hooks",
+    "ImageBlock",
     "ImageMediaType",
+    "ImageSource",
     "InitSystemMessage",
     "InvalidRequestError",
     "ListSessionsOptions",
@@ -192,6 +197,7 @@ __all__ = [
     "PermissionUpdate",
     "Permissions",
     "PlainTextMediaType",
+    "PostCompactHookInput",
     "PostToolUseFailureHookInput",
     "PostToolUseFailureHookSpecificOutput",
     "PostToolUseHookInput",

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/_internal/message_parser.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import logging
+import os
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from pydantic import ValidationError
@@ -16,6 +18,9 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+_RECORD_PATH = os.environ.get("CLAWD_RECORD_MESSAGES")
+_record_file = Path(_RECORD_PATH).open("a") if _RECORD_PATH else None  # noqa: SIM115
+
 
 def parse_message(data: dict[str, Any]) -> Message:
     """Parse message from CLI output into typed Message objects.
@@ -29,6 +34,11 @@ def parse_message(data: dict[str, Any]) -> Message:
     Raises:
         MessageParseError: If parsing fails or message type is unrecognized
     """
+    if _record_file is not None:
+        import json
+
+        _record_file.write(json.dumps(data) + "\n")
+        _record_file.flush()
     try:
         return message_adapter.validate_python(data)
     except ValidationError as e:

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/_internal/query.py

@@ -508,6 +508,12 @@ class Query:
         """Change the AI model."""
         return await self._send_control_request({"subtype": "set_model", "model": model})
 
+    async def cancel_async_message(self, message_uuid: str) -> dict[str, Any]:
+        """Drop a pending async user message from the command queue by uuid."""
+        return await self._send_control_request(
+            {"subtype": "cancel_async_message", "message_uuid": message_uuid}
+        )
+
     async def stop_task(self, task_id: str) -> dict[str, Any]:
         """Stop a running task."""
         return await self._send_control_request({"subtype": "stop_task", "task_id": task_id})

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/_internal/transport/subprocess_cli.py

@@ -515,8 +515,10 @@ def to_cli_args(options: ClaudeAgentOptions) -> list[str]:
 
     match options.mcp_servers:
         case dict() as servers if servers:
+            import dataclasses
+
             servers_for_cli = {
-                name: {k: v for k, v in cfg.items() if k != "instance"}
+                name: {k: v for k, v in dataclasses.asdict(cfg).items() if k != "instance"}
                 for name, cfg in servers.items()
             }
             dct = anyenv.dump_json({"mcpServers": servers_for_cli})

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/client.py

@@ -14,6 +14,7 @@ from clawd_code_sdk.models import (
     AssistantMessage,
     ClaudeAgentOptions,
     ClaudeCodeAgentInfo,  # noqa: TC001
+    McpSdkServerConfigWithInstance,
     McpSetServersResult,
     McpStatusResponse,
     ResultErrorMessage,
@@ -107,8 +108,8 @@ class ClaudeSDKClient:
         sdk_mcp_servers = {}
         if isinstance(self.options.mcp_servers, dict):
             for name, config in self.options.mcp_servers.items():
-                if config.get("type") == "sdk":
-                    sdk_mcp_servers[name] = config["instance"]  # type: ignore[typeddict-item]
+                if isinstance(config, McpSdkServerConfigWithInstance):
+                    sdk_mcp_servers[name] = config.instance
 
         # Calculate initialize timeout from CLAUDE_CODE_STREAM_CLOSE_TIMEOUT env var if set
         # CLAUDE_CODE_STREAM_CLOSE_TIMEOUT is in milliseconds, convert to seconds
@@ -236,6 +237,11 @@ class ClaudeSDKClient:
         query = self._ensure_connected()
         await query.set_model(model)
 
+    async def cancel_async_message(self, message_uuid: str) -> None:
+        """Drop a pending async user message from the command queue by uuid."""
+        query = self._ensure_connected()
+        await query.cancel_async_message(message_uuid)
+
     async def stop_task(self, task_id: str) -> None:
         """Stop a running task."""
         query = self._ensure_connected()
@@ -304,9 +310,11 @@ class ClaudeSDKClient:
             - 'errors': Dict mapping server names to error messages (if any)
         """
         query = self._ensure_connected()
+        import dataclasses
+
         wire_servers: dict[str, dict[str, Any]] = {}
         for name, config in servers.items():
-            server_dict = dict(config)
+            server_dict = dataclasses.asdict(config)
             server_dict["name"] = name
             wire_servers[name] = server_dict
         result = await query.set_mcp_servers(wire_servers)

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/models/__init__.py

@@ -26,6 +26,7 @@ from .control import (
     ControlErrorResponse,
     ControlRequestUnion,
     ControlResponse,
+    SDKControlCancelAsyncMessageRequest,
     SDKControlElicitationRequest,
     SDKControlEndSessionRequest,
     SDKControlInitializeRequest,
@@ -71,6 +72,7 @@ from .hooks import (
     SessionStartHookInput,
     SetupHookInput,
     PermissionRequestHookSpecificOutput,
+    PostCompactHookInput,
     PostToolUseFailureHookInput,
     PostToolUseFailureHookSpecificOutput,
     PostToolUseHookInput,
@@ -206,6 +208,8 @@ from .output_types import (
 )
 from .content_blocks import (
     ContentBlock,
+    ImageBlock,
+    ImageSource,
     TextBlock,
     ThinkingBlock,
     ToolResultBlock,
@@ -440,7 +444,9 @@ __all__ = [
     "HookSpecificOutput",
     "HookStartedSystemMessage",
     "Hooks",
+    "ImageBlock",
     "ImageMediaType",
+    "ImageSource",
     "InitSystemMessage",
     "InstructionsLoadedHookInput",
     "JSONRPCError",
@@ -497,6 +503,7 @@ __all__ = [
     "PermissionUpdateDestination",
     "Permissions",
     "PlainTextMediaType",
+    "PostCompactHookInput",
     "PostToolUseFailureHookInput",
     "PostToolUseFailureHookSpecificOutput",
     "PostToolUseHookInput",
@@ -532,6 +539,7 @@ __all__ = [
     "ResultMessage",
     "ResultSuccessMessage",
     "ResumeSession",
+    "SDKControlCancelAsyncMessageRequest",
     "SDKControlElicitationRequest",
     "SDKControlEndSessionRequest",
     "SDKControlGetSettingsRequest",

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/models/base.py

@@ -79,4 +79,5 @@ class ClaudeCodeBaseModel(BaseModel):
         populate_by_name=True,
         alias_generator=to_camel,
         extra="forbid" if IS_DEV else "ignore",
+        defer_build=True,
     )

clawd_code_sdk-1.0.3/src/clawd_code_sdk/models/content_blocks.py

@@ -0,0 +1,147 @@
+"""Content block types shared by both wire-format messages and JSONL storage.
+
+Claude Code uses the same content block schema on the wire (SDK ↔ CLI JSON
+messages) and in persisted JSONL session transcripts.  A single set of models
+therefore serves both purposes, avoiding a redundant conversion layer.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Annotated, Any, Literal
+
+from anthropic.types.beta.beta_tool_use_block import Caller
+from pydantic import BaseModel, ConfigDict, Discriminator, TypeAdapter
+
+from clawd_code_sdk.models import ToolInput
+from clawd_code_sdk.models.base import ClaudeCodeBaseModel, StopReason, ToolName
+
+
+if TYPE_CHECKING:
+    from clawd_code_sdk.anthropic_types import ToolResultContentBlock
+
+
+# =============================================================================
+# Content block types
+# =============================================================================
+
+
+class BaseContentBlock(BaseModel):
+    """Shared base for all content block types."""
+
+    # extra="allow": storage JSONL includes all union fields on every block
+    # with null for fields belonging to other block types.
+    model_config = ConfigDict(extra="allow", defer_build=True)
+
+
+class TextBlock(BaseContentBlock):
+    """Text content block."""
+
+    type: Literal["text"] = "text"
+    text: str
+
+
+class ThinkingBlock(BaseContentBlock):
+    """Thinking/reasoning content block."""
+
+    type: Literal["thinking"] = "thinking"
+    thinking: str
+    signature: str = ""
+
+
+class ToolUseBlock(BaseContentBlock):
+    """Tool use content block."""
+
+    type: Literal["tool_use"] = "tool_use"
+    id: str = ""
+    name: ToolName | str = ""
+    input: ToolInput | dict[str, Any] = {}
+    caller: Caller | None = None
+
+
+class ToolResultBlock(BaseContentBlock):
+    """Tool result content block."""
+
+    type: Literal["tool_result"] = "tool_result"
+    tool_use_id: str = ""
+    content: str | list[dict[str, Any]] | None = None  # BetaContentBlock
+    is_error: bool | None = None
+
+    def get_parsed_content(self) -> list[ToolResultContentBlock] | str | None:
+        from clawd_code_sdk.anthropic_types import validate_tool_result_content
+
+        if self.content is None or isinstance(self.content, str):
+            return self.content
+        # Validate list content against Anthropic SDK types
+        return validate_tool_result_content(self.content)
+
+    def extract_text(self) -> str:
+        """Extract text content from this tool result."""
+        if self.content is None:
+            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"
+        ]
+        return "\n".join(text_parts)
+
+
+class ImageSource(BaseContentBlock):
+    """Base64-encoded image source data."""
+
+    type: Literal["base64"]
+    media_type: str
+    data: str
+
+
+class ImageBlock(BaseContentBlock):
+    """Image content block (storage-only, not emitted on the wire)."""
+
+    type: Literal["image"] = "image"
+    source: ImageSource
+
+
+# =============================================================================
+# Unions and adapters
+# =============================================================================
+
+ContentBlock = Annotated[
+    TextBlock | ThinkingBlock | ToolUseBlock | ToolResultBlock | ImageBlock,
+    Discriminator("type"),
+]
+
+content_block_adapter = TypeAdapter[ContentBlock](ContentBlock)
+
+
+# =============================================================================
+# Message-level models
+# =============================================================================
+
+
+class MessageParam(ClaudeCodeBaseModel):
+    """Replacement for Anthropic MessageParam which serializes to our own content blocks."""
+
+    content: Sequence[ContentBlock] | str
+    role: Literal["user", "assistant"]
+    model_config = ConfigDict(extra="allow")
+
+
+class AssistantMessageContent(ClaudeCodeBaseModel):
+    """Assistant message payload mirroring ``anthropic.types.beta.BetaMessage``.
+
+    Uses our own ``ContentBlock`` types instead of the Anthropic SDK's
+    ``BetaContentBlock`` variants. Extra fields from the wire format
+    (e.g. ``container``, ``context_management``) are preserved via ``extra="allow"``.
+    """
+
+    id: str
+    type: Literal["message"] = "message"
+    role: Literal["assistant"] = "assistant"
+    content: Sequence[ContentBlock]
+    model: str
+    stop_reason: StopReason | None = None
+    stop_sequence: str | None = None
+    model_config = ConfigDict(extra="allow")

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/models/control.py

@@ -87,6 +87,14 @@ class SDKControlRewindFilesRequest:
     dry_run: bool | None = None
 
 
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SDKControlCancelAsyncMessageRequest:
+    """Drops a pending async user message from the command queue by uuid."""
+
+    subtype: Literal["cancel_async_message"] = "cancel_async_message"
+    message_uuid: str
+
+
 @dataclass(frozen=True, slots=True, kw_only=True)
 class SDKControlStopTaskRequest:
     """SDK control stop task request."""
@@ -239,6 +247,7 @@ ControlRequestUnion = Annotated[
     | SDKHookCallbackRequest
     | SDKControlMcpMessageRequest
     | SDKControlRewindFilesRequest
+    | SDKControlCancelAsyncMessageRequest
     | SDKControlMcpSetServersRequest
     | SDKControlMcpReconnectRequest
     | SDKControlMcpToggleRequest

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/models/hooks.py

@@ -25,6 +25,7 @@ HookEvent = Literal[
     "Stop",
     "SubagentStop",
     "PreCompact",
+    "PostCompact",
     "Notification",
     "SubagentStart",
     "PermissionRequest",
@@ -205,6 +206,14 @@ class PreCompactHookInput(BaseHookInput):
     custom_instructions: str | None
 
 
+class PostCompactHookInput(BaseHookInput):
+    """Input data for PostCompact hook events."""
+
+    hook_event_name: Literal["PostCompact"]
+    trigger: CompactionTrigger
+    compact_summary: str
+
+
 class NotificationHookInput(BaseHookInput):
     """Input data for Notification hook events."""
 
@@ -343,6 +352,7 @@ HookInput = (
     | StopHookInput
     | SubagentStopHookInput
     | PreCompactHookInput
+    | PostCompactHookInput
     | NotificationHookInput
     | SubagentStartHookInput
     | PermissionRequestHookInput

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/models/mcp.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Literal, NotRequired, TypedDict
 
 from pydantic import Field
@@ -68,42 +69,49 @@ JSONRPCMessage = JSONRPCRequest | JSONRPCNotification | JSONRPCResponse
 
 
 # MCP Server config
-class McpStdioServerConfig(TypedDict):
+
+
+@dataclass(kw_only=True)
+class McpStdioServerConfig:
     """MCP stdio server configuration."""
 
-    type: NotRequired[Literal["stdio"]]  # Optional for backwards compatibility
+    type: Literal["stdio"] = "stdio"
     command: str
-    args: NotRequired[list[str]]
-    env: NotRequired[dict[str, str]]
+    args: list[str] = field(default_factory=list)
+    env: dict[str, str] = field(default_factory=dict)
 
 
-class McpSSEServerConfig(TypedDict):
+@dataclass(kw_only=True)
+class McpSSEServerConfig:
     """MCP SSE server configuration."""
 
-    type: Literal["sse"]
+    type: Literal["sse"] = "sse"
     url: str
-    headers: NotRequired[dict[str, str]]
+    headers: dict[str, str] = field(default_factory=dict)
 
 
-class McpHttpServerConfig(TypedDict):
+@dataclass(kw_only=True)
+class McpHttpServerConfig:
     """MCP HTTP server configuration."""
 
-    type: Literal["http"]
+    type: Literal["http"] = "http"
     url: str
-    headers: NotRequired[dict[str, str]]
+    headers: dict[str, str] = field(default_factory=dict)
 
 
-class McpSdkServerConfig(TypedDict):
+@dataclass(kw_only=True)
+class McpSdkServerConfig:
     """SDK MCP server configuration (serializable, no instance)."""
 
-    type: Literal["sdk"]
+    type: Literal["sdk"] = "sdk"
     name: str
 
 
+@dataclass(kw_only=True)
 class McpSdkServerConfigWithInstance(McpSdkServerConfig):
     """SDK MCP server config with a live McpServer instance. Not serializable."""
 
-    instance: McpServer
+    instance: McpServer = field(repr=False)
 
 
 ExternalMcpServerConfig = McpStdioServerConfig | McpSSEServerConfig | McpHttpServerConfig
@@ -113,10 +121,11 @@ McpServerConfig = (
 )
 
 
-class McpClaudeAIProxyServerConfig(TypedDict):
+@dataclass(kw_only=True)
+class McpClaudeAIProxyServerConfig:
     """MCP Claude AI proxy server configuration."""
 
-    type: Literal["claudeai-proxy"]
+    type: Literal["claudeai-proxy"] = "claudeai-proxy"
     url: str
     id: str
 

{clawd_code_sdk-1.0.1 → clawd_code_sdk-1.0.3}/src/clawd_code_sdk/models/messages.py

@@ -6,8 +6,22 @@ from collections.abc import Sequence
 import re
 from typing import TYPE_CHECKING, Any, Literal, NotRequired, TypedDict
 
-from anthropic.types import RawMessageStreamEvent
-from pydantic import BaseModel, ConfigDict
+from anthropic.types.beta import (
+    BetaInputJSONDelta,
+    BetaMessageDeltaUsage,
+    BetaRawContentBlockDeltaEvent,
+    BetaRawContentBlockStartEvent,
+    BetaRawMessageDeltaEvent,
+    BetaRawMessageStreamEvent,
+    BetaStopReason,  # noqa: TC002
+    BetaTextBlock as ATextBlock,
+    BetaTextDelta,
+    BetaThinkingBlock as AThinkingBlock,
+    BetaThinkingDelta,
+    BetaToolUseBlock as AToolUseBlock,
+)
+from anthropic.types.beta.beta_raw_message_delta_event import Delta as BetaRawMessageDelta
+from pydantic import BaseModel, ConfigDict, Field
 
 from clawd_code_sdk._errors import (
     APIError,
@@ -28,9 +42,7 @@ from clawd_code_sdk.models.output_types import ToolUseResult
 
 
 if TYPE_CHECKING:
-    from clawd_code_sdk.models.content_blocks import (
-        ContentBlock,
-    )
+    from clawd_code_sdk.models.content_blocks import ContentBlock
 
 
 # Message types
@@ -179,7 +191,7 @@ class Usage(BaseModel):
 class BaseMessage(BaseModel):
     """Base class for messages."""
 
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, populate_by_name=True)
 
     uuid: str
     session_id: str
@@ -193,8 +205,8 @@ class UserMessage(BaseMessage):
     tool_use_result: (
         Sequence[ToolUseResult | dict[str, Any]] | ToolUseResult | dict[str, Any] | str | None
     ) = None
-    isReplay: bool | None = None  # noqa: N815
-    isSynthetic: bool | None = None  # noqa: N815
+    is_replay: bool | None = Field(default=None, validation_alias="isReplay")
+    is_synthetic: bool | None = Field(default=None, validation_alias="isSynthetic")
     priority: Literal["now", "next", "later"] | None = None
     message: MessageParam
 
@@ -283,7 +295,7 @@ class BaseResultMessage(BaseMessage):
     usage: Usage
     """Token usage from the last API call only (per-turn)."""
     stop_reason: StopReason | None
-    modelUsage: dict[str, ModelUsage] = {}  # noqa: N815
+    model_usage: dict[str, ModelUsage] = Field(default_factory=dict, validation_alias="modelUsage")
     """Cumulative token usage per model across the entire session."""
     permission_denials: list[SDKPermissionDenial] = []
     """Permission denials from the last API call only (per-turn)."""
@@ -313,25 +325,112 @@ class StreamEvent(BaseMessage):
     """Stream event for partial message updates during streaming."""
 
     type: Literal["stream_event"] = "stream_event"
-    event: RawMessageStreamEvent
+    event: BetaRawMessageStreamEvent
     parent_tool_use_id: str | None = None
 
     @classmethod
     def block_stop(cls, *, index: int, session_id: str, uuid: str) -> StreamEvent:
         """Create a synthetic content_block_stop StreamEvent."""
-        from anthropic.types import RawContentBlockStopEvent
+        from anthropic.types.beta import BetaRawContentBlockStopEvent
 
-        stop_event = RawContentBlockStopEvent(type="content_block_stop", index=index)
+        stop_event = BetaRawContentBlockStopEvent(type="content_block_stop", index=index)
         return StreamEvent(event=stop_event, session_id=session_id, uuid=uuid)
 
     @classmethod
     def message_stop(cls, *, session_id: str, uuid: str) -> StreamEvent:
         """Create a synthetic message_stop StreamEvent."""
-        from anthropic.types import RawMessageStopEvent
+        from anthropic.types.beta import BetaRawMessageStopEvent
 
-        stop_event = RawMessageStopEvent(type="message_stop")
+        stop_event = BetaRawMessageStopEvent(type="message_stop")
         return StreamEvent(event=stop_event, session_id=session_id, uuid=uuid)
 
+    @classmethod
+    def block_start_text(cls, *, index: int, session_id: str, uuid: str) -> StreamEvent:
+        """Create a synthetic content_block_start StreamEvent for a text block."""
+        content_block = ATextBlock(type="text", text="")
+        start_event = BetaRawContentBlockStartEvent(
+            type="content_block_start", index=index, content_block=content_block
+        )
+        return StreamEvent(event=start_event, session_id=session_id, uuid=uuid)
+
+    @classmethod
+    def block_start_thinking(cls, *, index: int, session_id: str, uuid: str) -> StreamEvent:
+        """Create a synthetic content_block_start StreamEvent for a thinking block."""
+        content_block = AThinkingBlock(type="thinking", thinking="", signature="")
+        start_event = BetaRawContentBlockStartEvent(
+            type="content_block_start", index=index, content_block=content_block
+        )
+        return StreamEvent(event=start_event, session_id=session_id, uuid=uuid)
+
+    @classmethod
+    def block_start_tool_use(
+        cls, *, tool_use_id: str, name: str, index: int, session_id: str, uuid: str
+    ) -> StreamEvent:
+        """Create a synthetic content_block_start StreamEvent for a tool_use block."""
+        content_block = AToolUseBlock(type="tool_use", id=tool_use_id, name=name, input={})
+        start_event = BetaRawContentBlockStartEvent(
+            type="content_block_start", index=index, content_block=content_block
+        )
+        return StreamEvent(event=start_event, session_id=session_id, uuid=uuid)
+
+    @classmethod
+    def block_text_delta(cls, *, text: str, index: int, session_id: str, uuid: str) -> StreamEvent:
+        """Create a synthetic content_block_delta StreamEvent with full block content."""
+        delta_event = BetaRawContentBlockDeltaEvent(
+            type="content_block_delta",
+            index=index,
+            delta=BetaTextDelta(type="text_delta", text=text),
+        )
+        return StreamEvent(event=delta_event, session_id=session_id, uuid=uuid)
+
+    @classmethod
+    def block_thinking_delta(
+        cls,
+        *,
+        thinking: str,
+        index: int,
+        session_id: str,
+        uuid: str,
+    ) -> StreamEvent:
+        """Create a synthetic content_block_delta StreamEvent with full block content."""
+        delta_event = BetaRawContentBlockDeltaEvent(
+            type="content_block_delta",
+            index=index,
+            delta=BetaThinkingDelta(type="thinking_delta", thinking=thinking),
+        )
+        return StreamEvent(event=delta_event, session_id=session_id, uuid=uuid)
+
+    @classmethod
+    def block_tool_json_delta(
+        cls,
+        *,
+        partial_json: str,
+        index: int,
+        session_id: str,
+        uuid: str,
+    ) -> StreamEvent:
+        """Create a synthetic content_block_delta StreamEvent with full block content."""
+        delta_event = BetaRawContentBlockDeltaEvent(
+            type="content_block_delta",
+            index=index,
+            delta=BetaInputJSONDelta(type="input_json_delta", partial_json=partial_json),
+        )
+        return StreamEvent(event=delta_event, session_id=session_id, uuid=uuid)
+
+    @classmethod
+    def message_delta(
+        cls,
+        *,
+        stop_reason: BetaStopReason | None,
+        session_id: str,
+        uuid: str,
+    ) -> StreamEvent:
+        """Create a synthetic message_delta StreamEvent."""
+        usage = BetaMessageDeltaUsage(output_tokens=0)
+        delta = BetaRawMessageDelta(stop_reason=stop_reason)
+        delta_event = BetaRawMessageDeltaEvent(type="message_delta", delta=delta, usage=usage)
+        return StreamEvent(event=delta_event, session_id=session_id, uuid=uuid)
+
 
 class ToolProgressMessage(BaseMessage):
     """Progress update for a running tool."""