clawd-code-sdk 1.0.0__tar.gz → 1.0.2__tar.gz

{clawd_code_sdk-1.0.0 → clawd_code_sdk-1.0.2}/PKG-INFO

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

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

{clawd_code_sdk-1.0.0 → clawd_code_sdk-1.0.2}/src/clawd_code_sdk/__init__.py

@@ -37,6 +37,8 @@ from .models import (
     CommandHookHandler,
     OnUserQuestion,
     ContentBlock,
+    ImageBlock,
+    ImageSource,
     HookCallback,
     HookContext,
     HookHandler,
@@ -168,7 +170,9 @@ __all__ = [
     "HookMatcher",
     "HookMatcherConfig",
     "Hooks",
+    "ImageBlock",
     "ImageMediaType",
+    "ImageSource",
     "InitSystemMessage",
     "InvalidRequestError",
     "ListSessionsOptions",

{clawd_code_sdk-1.0.0 → clawd_code_sdk-1.0.2}/src/clawd_code_sdk/models/__init__.py

@@ -206,6 +206,8 @@ from .output_types import (
 )
 from .content_blocks import (
     ContentBlock,
+    ImageBlock,
+    ImageSource,
     TextBlock,
     ThinkingBlock,
     ToolResultBlock,
@@ -318,6 +320,19 @@ def _message_discriminator(data: Any) -> str:
     return str(type(data).__name__)
 
 
+MessageUnion = (
+    UserMessage
+    | AssistantMessage
+    | ResultMessage
+    | StreamEvent
+    | RateLimitMessage
+    | ToolProgressMessage
+    | ToolUseSummaryMessage
+    | AuthStatusMessage
+    | PromptSuggestionMessage
+    | SystemMessageUnion
+)
+
 Message = Annotated[
     Annotated[UserMessage, Tag("user")]
     | Annotated[AssistantMessage, Tag("assistant")]
@@ -427,7 +442,9 @@ __all__ = [
     "HookSpecificOutput",
     "HookStartedSystemMessage",
     "Hooks",
+    "ImageBlock",
     "ImageMediaType",
+    "ImageSource",
     "InitSystemMessage",
     "InstructionsLoadedHookInput",
     "JSONRPCError",

{clawd_code_sdk-1.0.0 → clawd_code_sdk-1.0.2}/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.2/src/clawd_code_sdk/models/content_blocks.py

@@ -0,0 +1,146 @@
+"""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 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 _ContentBlockBase(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(_ContentBlockBase):
+    """Text content block."""
+
+    type: Literal["text"] = "text"
+    text: str
+
+
+class ThinkingBlock(_ContentBlockBase):
+    """Thinking/reasoning content block."""
+
+    type: Literal["thinking"] = "thinking"
+    thinking: str
+    signature: str = ""
+
+
+class ToolUseBlock(_ContentBlockBase):
+    """Tool use content block."""
+
+    type: Literal["tool_use"] = "tool_use"
+    id: str = ""
+    name: ToolName | str = ""
+    input: ToolInput | dict[str, Any] = {}
+    caller: dict[str, str] | None = None
+
+
+class ToolResultBlock(_ContentBlockBase):
+    """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(_ContentBlockBase):
+    """Base64-encoded image source data."""
+
+    type: Literal["base64"]
+    media_type: str
+    data: str
+
+
+class ImageBlock(_ContentBlockBase):
+    """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.0 → clawd_code_sdk-1.0.2}/src/clawd_code_sdk/models/messages.py

@@ -4,9 +4,22 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 import re
-from typing import TYPE_CHECKING, Any, Literal, NotRequired, TypedDict
-
-from anthropic.types import RawMessageStreamEvent
+from typing import TYPE_CHECKING, Any, Literal, NotRequired, TypedDict, get_args
+
+from anthropic.types.beta import (
+    BetaInputJSONDelta,
+    BetaMessageDeltaUsage,
+    BetaRawContentBlockDeltaEvent,
+    BetaRawContentBlockStartEvent,
+    BetaRawMessageDeltaEvent,
+    BetaRawMessageStreamEvent,
+    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
 
 from clawd_code_sdk._errors import (
@@ -28,9 +41,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
@@ -66,6 +77,16 @@ OverAgeDisabledReason = Literal[
     "no_limits_configured",
     "unknown",
 ]
+_AnthropicStopReason = Literal[
+    "end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn", "refusal"
+]
+
+
+def _coerce_stop_reason(value: str | None) -> _AnthropicStopReason | None:
+    """Coerce a stored stop_reason string to the Anthropic SDK literal type."""
+    if value is not None and value in get_args(_AnthropicStopReason):
+        return value  # type: ignore[return-value]
+    return None
 
 
 class SDKSessionInfo(BaseModel):
@@ -313,25 +334,114 @@ 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: str | None,
+        session_id: str,
+        uuid: str,
+    ) -> StreamEvent:
+        """Create a synthetic message_delta StreamEvent."""
+        usage = BetaMessageDeltaUsage(output_tokens=0)
+        delta = BetaRawMessageDelta(
+            stop_reason=_coerce_stop_reason(stop_reason), stop_sequence=None
+        )
+        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."""

{clawd_code_sdk-1.0.0 → clawd_code_sdk-1.0.2}/src/clawd_code_sdk/storage/helpers.py

@@ -284,42 +284,3 @@ def extract_title(session_path: Path, max_chars: int = 60) -> str | None:
 #         walk(root)
 
 #     return result
-
-
-if __name__ == "__main__":
-    import sys
-
-    projects_dir = get_claude_projects_dir()
-    if not projects_dir.exists():
-        print(f"No projects directory found at {projects_dir}")
-        sys.exit(1)
-
-    total_entries = 0
-    total_sessions = 0
-    errors = 0
-
-    for project_dir in sorted(projects_dir.iterdir()):
-        if not project_dir.is_dir():
-            continue
-        session_files = sorted(
-            project_dir.glob("*.jsonl"), key=lambda p: p.stat().st_mtime, reverse=True
-        )
-        if not session_files:
-            continue
-        project_path = decode_project_path(project_dir.name)
-        print(f"\nProject: {project_path} ({len(session_files)} sessions)")
-        for session_file in session_files:
-            total_sessions += 1
-            try:
-                entries = read_session(session_file)
-                total_entries += len(entries)
-                title = extract_title(session_file) or "(no title)"
-                print(f"  {session_file.stem}: {len(entries)} entries - {title}")
-            except Exception as e:
-                errors += 1
-                print(f"  {session_file.stem}: ERROR - {e}")
-
-    print("\n--- Summary ---")
-    print(f"Sessions: {total_sessions}")
-    print(f"Total entries: {total_entries}")
-    print(f"Errors: {errors}")

{clawd_code_sdk-1.0.0 → clawd_code_sdk-1.0.2}/src/clawd_code_sdk/storage/models.py

@@ -16,12 +16,24 @@ See ARCHITECTURE.md for detailed documentation of the storage format.
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import Annotated, Any, Literal, assert_never
+from typing import TYPE_CHECKING, Annotated, Any, Literal
 
 from pydantic import BaseModel, Discriminator, Field, Tag
 
 from clawd_code_sdk.models import ToolUseResult
 from clawd_code_sdk.models.base import ClaudeCodeBaseModel, StopReason
+from clawd_code_sdk.models.content_blocks import (
+    ContentBlock,
+    ImageBlock,
+    ImageSource,
+    TextBlock,
+    ToolResultBlock,
+)
+from clawd_code_sdk.models.messages import Usage
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 
 # See https://github.com/daaain/claude-code-log/blob/main/claude_code_log/models.py
@@ -30,97 +42,33 @@ UserType = Literal["external", "internal"]
 MCPToolCallStatus = Literal["started", "completed", "failed"]
 
 
-class ClaudeTextBlock(BaseModel):
-    """Text content block."""
-
-    type: Literal["text"]
-    text: str
-
-
-class ClaudeToolUseBlock(BaseModel):
-    """Tool use content block."""
-
-    type: Literal["tool_use"]
-    id: str
-    name: str
-    input: dict[str, Any]
-
-
-class ClaudeToolResultBlock(BaseModel):
-    """Tool result content block."""
-
-    type: Literal["tool_result"]
-    tool_use_id: str
-    content: list[dict[str, Any]] | str | None = None
-    is_error: bool | None = None
-
-    def extract_text(self) -> str:
-        """Extract text content from this tool result."""
-        match self.content:
-            case None:
-                return ""
-            case str():
-                return self.content
-            case list():
-                text_parts = [
-                    tc.get("text", "")
-                    for tc in self.content
-                    if isinstance(tc, dict) and tc.get("type") == "text"
-                ]
-                return "\n".join(text_parts)
-            case _ as unreachable:
-                assert_never(unreachable)
-
-
-class ClaudeThinkingBlock(BaseModel):
-    """Thinking/reasoning content block."""
-
-    type: Literal["thinking"]
-    thinking: str
-    signature: str | None = None
+class ClaudeUsage(Usage):
+    """Token usage from Claude API response, with additional storage fields."""
 
-
-class ClaudeImageSource(BaseModel):
-    """Base64-encoded image source data."""
-
-    type: Literal["base64"]
-    media_type: str
-    data: str
-
-
-class ClaudeImageBlock(BaseModel):
-    """Image content block."""
-
-    type: Literal["image"]
-    source: ClaudeImageSource
-
-
-ClaudeContentBlock = Annotated[
-    ClaudeTextBlock
-    | ClaudeToolUseBlock
-    | ClaudeToolResultBlock
-    | ClaudeThinkingBlock
-    | ClaudeImageBlock,
-    Field(discriminator="type"),
-]
-"""Discriminated union of all content block types in message content arrays."""
-
-
-class ClaudeUsage(BaseModel):
-    """Token usage from Claude API response."""
-
-    input_tokens: int = 0
-    output_tokens: int = 0
-    cache_creation_input_tokens: int = 0
-    cache_read_input_tokens: int = 0
     service_tier: str | None = None
     server_tool_use: dict[str, Any] | None = None
 
-    def add(self, other: ClaudeUsage) -> None:
-        self.input_tokens += other.input_tokens
-        self.output_tokens += other.output_tokens
-        self.cache_creation_input_tokens += other.cache_creation_input_tokens
-        self.cache_read_input_tokens += other.cache_read_input_tokens
+    @classmethod
+    def from_entries(cls, entries: Iterable[ClaudeJSONLEntry]) -> ClaudeUsage:
+        """Extract deduplicated aggregate token usage from stored entries.
+
+        Storage duplicates usage data across all content-block entries that
+        share the same API ``message.id``. This deduplicates by ``message.id``
+        and sums across all unique API calls.
+        """
+        seen_ids: set[str] = set()
+        total = cls()
+        for entry in entries:
+            if not isinstance(entry, ClaudeAssistantEntry):
+                continue
+            msg = entry.message
+            if not isinstance(msg, ClaudeApiMessage):
+                continue
+            if msg.id in seen_ids:
+                continue
+            seen_ids.add(msg.id)
+            total.accumulate(msg.usage)
+        return total
 
 
 # =============================================================================
@@ -135,7 +83,7 @@ class ClaudeApiMessage(BaseModel):
     id: str
     type: Literal["message"] = "message"
     role: Literal["assistant"]
-    content: str | Sequence[ClaudeContentBlock]
+    content: str | Sequence[ContentBlock]
     stop_reason: StopReason | None = None
     stop_sequence: str | None = None
     usage: ClaudeUsage = Field(default_factory=ClaudeUsage)
@@ -145,7 +93,7 @@ class ClaudeUserMessage(BaseModel):
     """User message content."""
 
     role: Literal["user"]
-    content: str | Sequence[ClaudeContentBlock]
+    content: str | Sequence[ContentBlock]
     usage: ClaudeUsage | None = None
     """Usage info (for type compatibility with ClaudeApiMessage)."""
 
@@ -197,6 +145,13 @@ class ClaudeUserEntry(ClaudeMessageEntryBase):
         list[ToolUseResult | dict[str, Any]] | ToolUseResult | dict[str, Any] | str | None
     ) = None
 
+    @property
+    def is_tool_result(self) -> bool:
+        """Whether this is a synthetic tool_result entry (vs. an actual user prompt)."""
+        if isinstance(self.message.content, str):
+            return False
+        return all(b.type == "tool_result" for b in self.message.content)
+
 
 class ClaudeAssistantEntry(ClaudeMessageEntryBase):
     """Assistant message entry."""
@@ -217,12 +172,10 @@ class ClaudeDocumentContent(ClaudeCodeBaseModel):
     """Document content block."""
 
     type: Literal["document"]
-    source: ClaudeImageSource
+    source: ImageSource
 
 
-ClaudeQueueContent = (
-    str | ClaudeTextBlock | ClaudeImageBlock | ClaudeDocumentContent | ClaudeToolResultBlock
-)
+type ClaudeQueueContent = str | TextBlock | ImageBlock | ClaudeDocumentContent | ToolResultBlock
 
 
 class ClaudeEnqueueOperation(ClaudeCodeBaseModel):