claude-agent-sdk 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d17d03fa867e2779de155d6fba8a86fbc9edbc5662157ca3e21606016c81fb17
-  data.tar.gz: 949787994cd58eb5be72b8834a519a704697c61ecbfff9ca1d6f4e1fe921b18f
+  metadata.gz: 2c723c3e660d135ab87311e27be6a80b8d13127f9e42789a66b1d30ec0395278
+  data.tar.gz: 0652f808dd792a6bef8db32afc567567fe9f016abdf095f1d13ae0ac07af0d03
 SHA512:
-  metadata.gz: a99fdb7b2dcab7e0286763abfb1f6d0277423a7ef2198a040ef8c76a8959907009ebc21f6523c35ecff1409a66fd8c636648d1f594aaa481119ed3598eb1b06e
-  data.tar.gz: 8e3e7e26487dcfe993534d3d1b7f695ba5009ad18e9d173c9e1e0f1353ec54565905f3e74e81a39eb5789aa2df008536a2a5a191095e7d8604f36abd27bb6583
+  metadata.gz: 399925ff55a9a23ab54cbe97adb18fea804be6c92cf21aa3ca3fdcd4cbe54693dfc8b77b85f15ed2eaf1517acaecd09935701d0248fb99a23be6325d151c99aa
+  data.tar.gz: dd14802c444f4d6609cbb8215e79c3f5d8c4d9453e20d0d3af40cd853d653625c93e117082118beee2c5fb0ad29447a170687a44d56f88be6785affb8d118060

data/CHANGELOG.md

@@ -5,6 +5,46 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.0] - 2026-03-05
+
+Port of Python SDK v0.1.46 features.
+
+### Added
+
+#### Task Message Types
+- `TaskStartedMessage`, `TaskProgressMessage`, `TaskNotificationMessage` — typed `SystemMessage` subclasses for background task lifecycle events
+- `TASK_NOTIFICATION_STATUSES` constant (`completed`, `failed`, `stopped`)
+- `MessageParser` dispatches on `subtype` within `system` messages, falling back to generic `SystemMessage` for unknown subtypes
+
+#### MCP Server Control
+- `reconnect_mcp_server(server_name)` on `Query` and `Client` — retry failed MCP server connections
+- `toggle_mcp_server(server_name, enabled)` on `Query` and `Client` — enable/disable MCP servers live
+- `stop_task(task_id)` on `Query` and `Client` — stop a running background task
+
+#### Subagent Context on Hook Inputs
+- `agent_id` and `agent_type` attributes on `PreToolUseHookInput`, `PostToolUseHookInput`, `PostToolUseFailureHookInput`, `PermissionRequestHookInput`
+- Populated when hooks fire inside subagents, allowing attribution of tool calls to specific agents
+
+#### Result Message
+- `stop_reason` attribute on `ResultMessage` (e.g., `'end_turn'`, `'max_tokens'`, `'stop_sequence'`)
+
+#### Typed MCP Status Response
+- `McpServerInfo`, `McpToolAnnotations`, `McpToolInfo`, `McpServerStatus`, `McpStatusResponse` types
+- `.parse` class methods for hydrating from raw CLI response hashes
+- `MCP_SERVER_CONNECTION_STATUSES` constant (`connected`, `failed`, `needs-auth`, `pending`, `disabled`)
+
+#### Session Browsing
+- `ClaudeAgentSDK.list_sessions(directory:, limit:, include_worktrees:)` — list sessions from `~/.claude/projects/` JSONL files
+- `ClaudeAgentSDK.get_session_messages(session_id:, directory:, limit:, offset:)` — reconstruct conversation chain from session transcript
+- `SDKSessionInfo` type with `session_id`, `summary`, `last_modified`, `file_size`, `custom_title`, `first_prompt`, `git_branch`, `cwd`
+- `SessionMessage` type with `type`, `uuid`, `session_id`, `message`
+- Pure filesystem operations — no CLI subprocess required
+- Git worktree-aware session scanning
+- `parentUuid` chain walking with cycle detection for robust conversation reconstruction
+
+### Fixed
+- **`McpToolAnnotations.parse` losing `false` values:** `readOnly: false` was evaluated as `false || nil → nil` due to `||` short-circuiting. Now uses `.key?` to check presence before falling back to snake_case keys.
+
 ## [0.7.3] - 2026-02-26
 
 ### Fixed

data/README.md

@@ -6,6 +6,119 @@
 
 [![Gem Version](https://badge.fury.io/rb/claude-agent-sdk.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/claude-agent-sdk)
 
+### Feature Parity with Python SDK (v0.1.46)
+
+| Feature | Python | Ruby |
+|---------|:------:|:----:|
+| One-shot `query()` | `query()` | `query()` |
+| Bidirectional `Client` | `ClaudeSDKClient` | `Client` |
+| Streaming input | `AsyncIterable` | `Enumerator` |
+| Custom tools (SDK MCP servers) | `@tool` decorator | `create_tool` block |
+| MCP resources & prompts | ✅ | ✅ |
+| Hooks (all 10 events) | ✅ | ✅ |
+| Permission callbacks (`can_use_tool`) | ✅ | ✅ |
+| Structured output | ✅ | ✅ |
+| Thinking config (adaptive/enabled/disabled) | ✅ | ✅ |
+| Effort levels | ✅ | ✅ |
+| Programmatic subagents | ✅ | ✅ |
+| Sandbox settings | ✅ | ✅ |
+| Beta features (1M context) | ✅ | ✅ |
+| File checkpointing & rewind | ✅ | ✅ |
+| Session browsing (`list_sessions`, `get_session_messages`) | ✅ | ✅ |
+| Task message types (started/progress/notification) | ✅ | ✅ |
+| MCP server control (reconnect/toggle/stop) | ✅ | ✅ |
+| Subagent context on hook inputs | ✅ | ✅ |
+| Typed MCP status response | ✅ | ✅ |
+| `stop_reason` on `ResultMessage` | ✅ | ✅ |
+| Fallback model | ✅ | ✅ |
+| Plugin support | ✅ | ✅ |
+| Rails integration (configure block, ActionCable) | — | ✅ |
+| Bundled CLI binary | ✅ | — |
+
+<details>
+<summary><strong>Usage & Implementation Differences</strong></summary>
+
+#### Async model
+
+Python uses `async`/`await` with `anyio` (works with both asyncio and Trio). Ruby uses the [`async`](https://github.com/socketry/async) gem with fibers — no `await` keyword needed, blocking calls yield automatically.
+
+```python
+# Python
+async with ClaudeSDKClient(options) as client:
+    await client.query("Hello")
+    async for msg in client.receive_messages():
+        print(msg)
+```
+
+```ruby
+# Ruby
+Async do
+  client = ClaudeAgentSDK::Client.new(options: options)
+  client.connect
+  client.query("Hello")
+  client.receive_messages { |msg| puts msg }
+  client.disconnect
+end.wait
+```
+
+#### Custom tools
+
+Python uses a `@tool` decorator. Ruby uses `create_tool` with a block.
+
+```python
+# Python
+@tool(name="add", description="Add numbers", input_schema={...})
+def add(a: int, b: int) -> str:
+    return str(a + b)
+```
+
+```ruby
+# Ruby
+add = ClaudeAgentSDK.create_tool("add", "Add numbers", { a: :number, b: :number }) do |args|
+  { content: [{ type: "text", text: (args[:a] + args[:b]).to_s }] }
+end
+```
+
+#### Streaming input
+
+Python uses `AsyncIterable`. Ruby uses `Enumerator` or any `#each`-able.
+
+```python
+# Python
+async def messages():
+    yield {"type": "user", "message": {"role": "user", "content": "Hello"}}
+
+async for msg in query(prompt=messages(), options=options):
+    print(msg)
+```
+
+```ruby
+# Ruby
+messages = ClaudeAgentSDK::Streaming.from_array(["Hello", "Follow up"])
+ClaudeAgentSDK.query(prompt: messages) { |msg| puts msg }
+```
+
+#### Types
+
+Python uses `dataclass` with type annotations and `TypedDict`. Ruby uses plain classes with `attr_accessor` and keyword args — no runtime type checking, but the same structure.
+
+#### Configuration defaults
+
+Python passes options directly. Ruby adds `ClaudeAgentSDK.configure` for global defaults that merge with per-call options — handy for Rails initializers.
+
+```ruby
+# Ruby-only: global defaults
+ClaudeAgentSDK.configure do |config|
+  config.default_options = { model: "sonnet", permission_mode: "bypassPermissions" }
+end
+```
+
+#### Subprocess transport
+
+Both SDKs spawn `claude` CLI as a subprocess with stream-JSON over stdin/stdout. Python uses `anyio.open_process`; Ruby uses `Open3.popen3` with a background `Thread` for stderr. The wire protocol is identical.
+
+</details>
+
 ## Table of Contents
 
 - [Installation](#installation)
@@ -23,6 +136,7 @@
 - [Tools Configuration](#tools-configuration)
 - [Sandbox Settings](#sandbox-settings)
 - [File Checkpointing & Rewind](#file-checkpointing--rewind)
+- [Session Browsing](#session-browsing)
 - [Rails Integration](#rails-integration)
 - [Types](#types)
 - [Error Handling](#error-handling)
@@ -39,7 +153,7 @@ Add this line to your application's Gemfile:
 gem 'claude-agent-sdk', github: 'ya-luotao/claude-agent-sdk-ruby'
 
 # Or use a stable version from RubyGems
-gem 'claude-agent-sdk', '~> 0.7.3'
+gem 'claude-agent-sdk', '~> 0.8.0'
 ```
 
 And then execute:
@@ -225,13 +339,18 @@ Async do
   puts "MCP status: #{status}"
 
   # Get server initialization info
-  info = client.server_info
-  puts "Available commands: #{info}"
-
-  # (Parity alias) Get server initialization info
   info = client.get_server_info
   puts "Available commands: #{info}"
 
+  # Reconnect a failed MCP server
+  client.reconnect_mcp_server('my-server')
+
+  # Enable or disable an MCP server
+  client.toggle_mcp_server('my-server', false)
+
+  # Stop a running background task
+  client.stop_task('task_abc123')
+
   client.disconnect
 end.wait
 ```
@@ -774,6 +893,47 @@ end.wait
 
 > **Note:** The `uuid` field on `UserMessage` is populated by the CLI and represents checkpoint identifiers. Rewinding to a UUID restores file state to what it was at that point in the conversation.
 
+## Session Browsing
+
+Browse and inspect previous Claude Code sessions directly from Ruby — no CLI subprocess required.
+
+### Listing Sessions
+
+```ruby
+# List all sessions (sorted by most recent first)
+sessions = ClaudeAgentSDK.list_sessions
+sessions.each do |session|
+  puts "#{session.session_id}: #{session.summary} (#{session.git_branch})"
+end
+
+# List sessions for a specific directory
+sessions = ClaudeAgentSDK.list_sessions(directory: '/path/to/project', limit: 10)
+
+# Include git worktree sessions
+sessions = ClaudeAgentSDK.list_sessions(directory: '.', include_worktrees: true)
+```
+
+Each `SDKSessionInfo` includes:
+- `session_id`, `summary`, `last_modified`, `file_size`
+- `custom_title`, `first_prompt`, `git_branch`, `cwd`
+
+### Reading Session Messages
+
+```ruby
+# Get the full conversation from a session
+messages = ClaudeAgentSDK.get_session_messages(session_id: 'abc-123-...')
+messages.each do |msg|
+  puts "[#{msg.type}] #{msg.message}"
+end
+
+# Paginate through messages
+page = ClaudeAgentSDK.get_session_messages(session_id: 'abc-123-...', offset: 10, limit: 20)
+```
+
+Each `SessionMessage` includes `type` (`"user"` or `"assistant"`), `uuid`, `session_id`, and `message` (raw API dict).
+
+> **Note:** Session browsing reads `~/.claude/projects/` JSONL files directly. It respects the `CLAUDE_CONFIG_DIR` environment variable and automatically detects git worktrees.
+
 ## Rails Integration
 
 The SDK integrates well with Rails applications. Here are common patterns:
@@ -966,13 +1126,26 @@ end
 
 #### SystemMessage
 
-System message with metadata.
+System message with metadata. Task lifecycle events are typed subclasses.
 
 ```ruby
 class SystemMessage
-  attr_accessor :subtype,  # String ('init', etc.)
+  attr_accessor :subtype,  # String ('init', 'task_started', 'task_progress', 'task_notification', etc.)
                 :data      # Hash
 end
+
+# Typed subclasses (all inherit from SystemMessage, so is_a?(SystemMessage) still works)
+class TaskStartedMessage < SystemMessage
+  attr_accessor :task_id, :description, :uuid, :session_id, :tool_use_id, :task_type
+end
+
+class TaskProgressMessage < SystemMessage
+  attr_accessor :task_id, :description, :usage, :uuid, :session_id, :tool_use_id, :last_tool_name
+end
+
+class TaskNotificationMessage < SystemMessage
+  attr_accessor :task_id, :status, :output_file, :summary, :uuid, :session_id, :tool_use_id, :usage
+end
 ```
 
 #### ResultMessage
@@ -987,6 +1160,7 @@ class ResultMessage
                 :is_error,          # Boolean
                 :num_turns,         # Integer
                 :session_id,        # String
+                :stop_reason,       # String | nil ('end_turn', 'max_tokens', 'stop_sequence')
                 :total_cost_usd,    # Float | nil
                 :usage,             # Hash | nil
                 :result,            # String | nil (final text result)
@@ -1111,6 +1285,13 @@ end
 | `McpSSEServerConfig` | MCP server config for SSE transport |
 | `McpHttpServerConfig` | MCP server config for HTTP transport |
 | `SdkPluginConfig` | SDK plugin configuration |
+| `McpServerStatus` | Status of a single MCP server connection (with `.parse`) |
+| `McpStatusResponse` | Response from `get_mcp_status` containing all server statuses (with `.parse`) |
+| `McpServerInfo` | MCP server name and version |
+| `McpToolInfo` | MCP tool name, description, and annotations |
+| `McpToolAnnotations` | MCP tool annotation hints (`read_only`, `destructive`, `open_world`) |
+| `SDKSessionInfo` | Session metadata from `list_sessions` |
+| `SessionMessage` | Single message from `get_session_messages` |
 | `SandboxSettings` | Sandbox settings for isolated command execution |
 | `SandboxNetworkConfig` | Network configuration for sandbox |
 | `SandboxIgnoreViolations` | Configure which sandbox violations to ignore |
@@ -1126,6 +1307,8 @@ end
 | `SETTING_SOURCES` | Available setting sources |
 | `HOOK_EVENTS` | Available hook events |
 | `ASSISTANT_MESSAGE_ERRORS` | Possible error types in AssistantMessage |
+| `TASK_NOTIFICATION_STATUSES` | Task lifecycle notification statuses (`completed`, `failed`, `stopped`) |
+| `MCP_SERVER_CONNECTION_STATUSES` | MCP server connection states (`connected`, `failed`, `needs-auth`, `pending`, `disabled`) |
 
 ## Error Handling
 

data/lib/claude_agent_sdk/message_parser.rb

@@ -66,10 +66,32 @@ module ClaudeAgentSDK
     end
 
     def self.parse_system_message(data)
-      SystemMessage.new(
-        subtype: data[:subtype],
-        data: data
-      )
+      case data[:subtype]
+      when 'task_started'
+        TaskStartedMessage.new(
+          subtype: data[:subtype], data: data,
+          task_id: data[:task_id], description: data[:description],
+          uuid: data[:uuid], session_id: data[:session_id],
+          tool_use_id: data[:tool_use_id], task_type: data[:task_type]
+        )
+      when 'task_progress'
+        TaskProgressMessage.new(
+          subtype: data[: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[:tool_use_id], last_tool_name: data[:last_tool_name]
+        )
+      when 'task_notification'
+        TaskNotificationMessage.new(
+          subtype: data[: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[:tool_use_id], usage: data[:usage]
+        )
+      else
+        SystemMessage.new(subtype: data[:subtype], data: data)
+      end
     end
 
     def self.parse_result_message(data)
@@ -80,10 +102,11 @@ module ClaudeAgentSDK
         is_error: data[:is_error],
         num_turns: data[:num_turns],
         session_id: data[:session_id],
+        stop_reason: data[:stop_reason],
         total_cost_usd: data[:total_cost_usd],
         usage: data[:usage],
         result: data[:result],
-        structured_output: data[:structured_output] # Structured output when output_format is specified
+        structured_output: data[:structured_output]
       )
     end
 

data/lib/claude_agent_sdk/query.rb

@@ -316,13 +316,19 @@ module ClaudeAgentSDK
         permission_mode: fetch.call(:permission_mode)
       }
 
+      # Subagent context fields shared by tool-lifecycle hooks
+      subagent_args = {
+        agent_id: fetch.call(:agent_id),
+        agent_type: fetch.call(:agent_type)
+      }
+
       case event_name
       when 'PreToolUse'
         PreToolUseHookInput.new(
           tool_name: fetch.call(:tool_name),
           tool_input: fetch.call(:tool_input),
           tool_use_id: fetch.call(:tool_use_id),
-          **base_args
+          **subagent_args, **base_args
         )
       when 'PostToolUse'
         PostToolUseHookInput.new(
@@ -330,7 +336,7 @@ module ClaudeAgentSDK
           tool_input: fetch.call(:tool_input),
           tool_response: fetch.call(:tool_response),
           tool_use_id: fetch.call(:tool_use_id),
-          **base_args
+          **subagent_args, **base_args
         )
       when 'PostToolUseFailure'
         PostToolUseFailureHookInput.new(
@@ -339,7 +345,7 @@ module ClaudeAgentSDK
           tool_use_id: fetch.call(:tool_use_id),
           error: fetch.call(:error),
           is_interrupt: fetch.call(:is_interrupt),
-          **base_args
+          **subagent_args, **base_args
         )
       when 'UserPromptSubmit'
         UserPromptSubmitHookInput.new(
@@ -377,7 +383,7 @@ module ClaudeAgentSDK
           tool_name: fetch.call(:tool_name),
           tool_input: fetch.call(:tool_input),
           permission_suggestions: fetch.call(:permission_suggestions),
-          **base_args
+          **subagent_args, **base_args
         )
       when 'PreCompact'
         PreCompactHookInput.new(
@@ -662,6 +668,35 @@ module ClaudeAgentSDK
                            })
     end
 
+    # Reconnect a failed MCP server
+    # @param server_name [String] Name of the MCP server to reconnect
+    def reconnect_mcp_server(server_name)
+      send_control_request({
+                             subtype: 'mcp_reconnect',
+                             serverName: server_name
+                           })
+    end
+
+    # Enable or disable an MCP server
+    # @param server_name [String] Name of the MCP server
+    # @param enabled [Boolean] Whether to enable or disable
+    def toggle_mcp_server(server_name, enabled)
+      send_control_request({
+                             subtype: 'mcp_toggle',
+                             serverName: server_name,
+                             enabled: enabled
+                           })
+    end
+
+    # Stop a running background task
+    # @param task_id [String] The ID of the task to stop
+    def stop_task(task_id)
+      send_control_request({
+                             subtype: 'stop_task',
+                             task_id: task_id
+                           })
+    end
+
     # Rewind files to a previous checkpoint (v0.1.15+)
     # Restores file state to what it was at the given user message
     # Requires enable_file_checkpointing to be true in options

data/lib/claude_agent_sdk/sessions.rb

@@ -0,0 +1,499 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'json'
+require 'pathname'
+require 'shellwords'
+
+module ClaudeAgentSDK
+  # Session info returned by list_sessions
+  class SDKSessionInfo
+    attr_accessor :session_id, :summary, :last_modified, :file_size,
+                  :custom_title, :first_prompt, :git_branch, :cwd
+
+    def initialize(session_id:, summary:, last_modified:, file_size:,
+                   custom_title: nil, first_prompt: nil, git_branch: nil, cwd: nil)
+      @session_id = session_id
+      @summary = summary
+      @last_modified = last_modified
+      @file_size = file_size
+      @custom_title = custom_title
+      @first_prompt = first_prompt
+      @git_branch = git_branch
+      @cwd = cwd
+    end
+  end
+
+  # A single message from a session transcript
+  class SessionMessage
+    attr_accessor :type, :uuid, :session_id, :message, :parent_tool_use_id
+
+    def initialize(type:, uuid:, session_id:, message:, parent_tool_use_id: nil)
+      @type = type
+      @uuid = uuid
+      @session_id = session_id
+      @message = message
+      @parent_tool_use_id = parent_tool_use_id
+    end
+  end
+
+  # Session browsing functions
+  module Sessions # rubocop:disable Metrics/ModuleLength
+    LITE_READ_BUF_SIZE = 65_536
+    MAX_SANITIZED_LENGTH = 200
+
+    UUID_RE = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+    SKIP_FIRST_PROMPT_PATTERN = %r{\A(?:<local-command-stdout>|<session-start-hook>|<tick>|<goal>|
+      \[Request\ interrupted\ by\ user[^\]]*\]|
+      \s*<ide_opened_file>[\s\S]*</ide_opened_file>\s*\z|
+      \s*<ide_selection>[\s\S]*</ide_selection>\s*\z)}x
+
+    COMMAND_NAME_RE = %r{<command-name>(.*?)</command-name>}
+
+    SANITIZE_RE = /[^a-zA-Z0-9]/
+
+    module_function
+
+    # Match TypeScript's simpleHash: signed 32-bit integer, base-36 output
+    def simple_hash(str)
+      h = 0
+      str.each_char do |ch|
+        char_code = ch.ord
+        h = ((h << 5) - h + char_code) & 0xFFFFFFFF
+        h -= 0x100000000 if h >= 0x80000000
+      end
+      h = h.abs
+
+      return '0' if h.zero?
+
+      digits = '0123456789abcdefghijklmnopqrstuvwxyz'
+      out = []
+      n = h
+      while n.positive?
+        out.unshift(digits[n % 36])
+        n /= 36
+      end
+      out.join
+    end
+
+    # Sanitize a filesystem path to a project directory name
+    def sanitize_path(name)
+      sanitized = name.gsub(SANITIZE_RE, '-')
+      return sanitized if sanitized.length <= MAX_SANITIZED_LENGTH
+
+      "#{sanitized[0, MAX_SANITIZED_LENGTH]}-#{simple_hash(name)}"
+    end
+
+    # Get the Claude config directory
+    def config_dir
+      ENV.fetch('CLAUDE_CONFIG_DIR', File.expand_path('~/.claude'))
+    end
+
+    # Find the project directory for a given path
+    def find_project_dir(path)
+      projects_dir = File.join(config_dir, 'projects')
+      return nil unless File.directory?(projects_dir)
+
+      sanitized = sanitize_path(path)
+      exact_path = File.join(projects_dir, sanitized)
+      return exact_path if File.directory?(exact_path)
+
+      # For long paths, scan for prefix match
+      if sanitized.length > MAX_SANITIZED_LENGTH
+        prefix = sanitized[0, MAX_SANITIZED_LENGTH + 1] # includes the trailing '-'
+        Dir.children(projects_dir).each do |child|
+          candidate = File.join(projects_dir, child)
+          return candidate if File.directory?(candidate) && child.start_with?(prefix)
+        end
+      end
+
+      nil
+    end
+
+    # Extract a JSON string field value from raw text without full JSON parse
+    def extract_json_string_field(text, key, last: false)
+      search_patterns = ["\"#{key}\":\"", "\"#{key}\": \""]
+      result = nil
+
+      search_patterns.each do |pattern|
+        pos = 0
+        loop do
+          idx = text.index(pattern, pos)
+          break unless idx
+
+          value_start = idx + pattern.length
+          value = extract_json_string_value(text, value_start)
+          if value
+            result = unescape_json_string(value)
+            return result unless last
+          end
+          pos = value_start
+        end
+      end
+
+      result
+    end
+
+    # Extract string value starting at pos (handles escapes)
+    def extract_json_string_value(text, start)
+      pos = start
+      while pos < text.length
+        ch = text[pos]
+        if ch == '\\'
+          pos += 2
+        elsif ch == '"'
+          return text[start...pos]
+        else
+          pos += 1
+        end
+      end
+      nil
+    end
+
+    # Unescape a JSON string value
+    def unescape_json_string(str)
+      JSON.parse("\"#{str}\"")
+    rescue JSON::ParserError
+      str
+    end
+
+    # Extract the first meaningful user prompt from the head of a JSONL file
+    def extract_first_prompt_from_head(head)
+      command_fallback = nil
+
+      head.each_line do |line|
+        next unless line.include?('"type":"user"') || line.include?('"type": "user"')
+        next if line.include?('"tool_result"')
+        next if line.include?('"isMeta":true') || line.include?('"isMeta": true')
+        next if line.include?('"isCompactSummary":true') || line.include?('"isCompactSummary": true')
+
+        entry = JSON.parse(line, symbolize_names: false)
+        content = entry.dig('message', 'content')
+        next unless content
+
+        texts = if content.is_a?(String)
+                  [content]
+                elsif content.is_a?(Array)
+                  content.filter_map { |block| block['text'] if block.is_a?(Hash) && block['type'] == 'text' }
+                else
+                  next
+                end
+
+        texts.each do |text|
+          text = text.gsub(/\n+/, ' ').strip
+          next if text.empty?
+
+          if (m = text.match(COMMAND_NAME_RE))
+            command_fallback ||= m[1]
+            next
+          end
+
+          next if text.match?(SKIP_FIRST_PROMPT_PATTERN)
+
+          return text.length > 200 ? "#{text[0, 200]}…" : text
+        end
+      rescue JSON::ParserError
+        next
+      end
+
+      command_fallback || ''
+    end
+
+    # Read a single session file with lite (head/tail) strategy
+    def read_session_lite(file_path, project_path)
+      stat = File.stat(file_path)
+      return nil if stat.size.zero? # rubocop:disable Style/ZeroLengthPredicate
+
+      head, tail = read_head_tail(file_path, stat.size)
+
+      # Check first line for sidechain
+      first_line = head.lines.first || ''
+      return nil if first_line.include?('"isSidechain":true') || first_line.include?('"isSidechain": true')
+
+      build_session_info(file_path, head, tail, stat, project_path)
+    rescue StandardError
+      nil
+    end
+
+    def read_head_tail(file_path, size)
+      head = tail = nil
+      File.open(file_path, 'rb') do |f|
+        head = (f.read(LITE_READ_BUF_SIZE) || '').force_encoding('UTF-8')
+        tail = if size > LITE_READ_BUF_SIZE
+                 f.seek([0, size - LITE_READ_BUF_SIZE].max)
+                 (f.read(LITE_READ_BUF_SIZE) || '').force_encoding('UTF-8')
+               else
+                 head
+               end
+      end
+      [head, tail]
+    end
+
+    def build_session_info(file_path, head, tail, stat, project_path)
+      custom_title = extract_json_string_field(tail, 'customTitle', last: true)
+      first_prompt = extract_first_prompt_from_head(head)
+      summary = custom_title || extract_json_string_field(tail, 'summary', last: true) || first_prompt
+      return nil if summary.nil? || summary.strip.empty?
+
+      SDKSessionInfo.new(
+        session_id: File.basename(file_path, '.jsonl'),
+        summary: summary,
+        last_modified: (stat.mtime.to_f * 1000).to_i,
+        file_size: stat.size,
+        custom_title: custom_title,
+        first_prompt: first_prompt,
+        git_branch: extract_json_string_field(tail, 'gitBranch', last: true) ||
+                    extract_json_string_field(head, 'gitBranch', last: false),
+        cwd: extract_json_string_field(head, 'cwd', last: false) || project_path
+      )
+    end
+
+    # Read all sessions from a project directory
+    def read_sessions_from_dir(project_dir, project_path = nil)
+      return [] unless File.directory?(project_dir)
+
+      sessions = []
+      Dir.glob(File.join(project_dir, '*.jsonl')).each do |file_path|
+        stem = File.basename(file_path, '.jsonl')
+        next unless stem.match?(UUID_RE)
+
+        session = read_session_lite(file_path, project_path)
+        sessions << session if session
+      end
+      sessions
+    end
+
+    # List sessions for a directory (or all sessions)
+    # @param directory [String, nil] Working directory to list sessions for
+    # @param limit [Integer, nil] Maximum number of sessions to return
+    # @param include_worktrees [Boolean] Whether to include git worktree sessions
+    # @return [Array<SDKSessionInfo>] Sessions sorted by last_modified descending
+    def list_sessions(directory: nil, limit: nil, include_worktrees: true)
+      sessions = if directory
+                   list_sessions_for_directory(directory, include_worktrees)
+                 else
+                   list_all_sessions
+                 end
+
+      # Sort by last_modified descending
+      sessions.sort_by! { |s| -s.last_modified }
+      sessions = sessions.first(limit) if limit
+      sessions
+    end
+
+    # Get messages from a session transcript
+    # @param session_id [String] The session UUID
+    # @param directory [String, nil] Working directory to search in
+    # @param limit [Integer, nil] Maximum number of messages
+    # @param offset [Integer] Number of messages to skip
+    # @return [Array<SessionMessage>] Ordered messages from the session
+    def get_session_messages(session_id:, directory: nil, limit: nil, offset: 0)
+      return [] unless session_id.match?(UUID_RE)
+
+      file_path = find_session_file(session_id, directory)
+      return [] unless file_path && File.exist?(file_path)
+
+      entries = parse_jsonl_entries(file_path)
+      chain = build_conversation_chain(entries)
+      messages = filter_visible_messages(chain)
+
+      # Apply offset and limit
+      messages = messages[offset..] || []
+      messages = messages.first(limit) if limit
+      messages
+    end
+
+    # -- Private helpers --
+
+    def list_sessions_for_directory(directory, include_worktrees)
+      path = File.realpath(directory).unicode_normalize(:nfc)
+
+      worktree_paths = []
+      worktree_paths = detect_worktrees(path) if include_worktrees
+
+      if worktree_paths.length <= 1
+        project_dir = find_project_dir(path)
+        return project_dir ? read_sessions_from_dir(project_dir, path) : []
+      end
+
+      # Multiple worktrees: scan all project dirs for matches
+      all_sessions = []
+      worktree_paths.each do |wt_path|
+        project_dir = find_project_dir(wt_path)
+        next unless project_dir
+
+        all_sessions.concat(read_sessions_from_dir(project_dir, wt_path))
+      end
+
+      deduplicate_sessions(all_sessions)
+    end
+
+    def list_all_sessions
+      projects_dir = File.join(config_dir, 'projects')
+      return [] unless File.directory?(projects_dir)
+
+      all_sessions = []
+      Dir.children(projects_dir).each do |child|
+        dir = File.join(projects_dir, child)
+        next unless File.directory?(dir)
+
+        all_sessions.concat(read_sessions_from_dir(dir))
+      end
+
+      deduplicate_sessions(all_sessions)
+    end
+
+    def deduplicate_sessions(sessions)
+      by_id = {}
+      sessions.each do |s|
+        existing = by_id[s.session_id]
+        by_id[s.session_id] = s if existing.nil? || s.last_modified > existing.last_modified
+      end
+      by_id.values
+    end
+
+    def detect_worktrees(path)
+      output = `git -C #{Shellwords.escape(path)} worktree list --porcelain 2>/dev/null`
+      return [path] unless $CHILD_STATUS.success?
+
+      paths = output.lines.filter_map do |line|
+        line.strip.delete_prefix('worktree ') if line.start_with?('worktree ')
+      end
+      paths.empty? ? [path] : paths
+    rescue StandardError
+      [path]
+    end
+
+    def find_session_file(session_id, directory)
+      projects_dir = File.join(config_dir, 'projects')
+      return nil unless File.directory?(projects_dir)
+
+      if directory
+        path = File.realpath(directory).unicode_normalize(:nfc)
+        project_dir = find_project_dir(path)
+        if project_dir
+          candidate = File.join(project_dir, "#{session_id}.jsonl")
+          return candidate if File.exist?(candidate)
+        end
+
+        # Try worktrees
+        detect_worktrees(path).each do |wt_path|
+          pd = find_project_dir(wt_path)
+          next unless pd
+
+          candidate = File.join(pd, "#{session_id}.jsonl")
+          return candidate if File.exist?(candidate)
+        end
+      end
+
+      # Scan all project dirs
+      Dir.children(projects_dir).each do |child|
+        dir = File.join(projects_dir, child)
+        next unless File.directory?(dir)
+
+        candidate = File.join(dir, "#{session_id}.jsonl")
+        return candidate if File.exist?(candidate)
+      end
+
+      nil
+    end
+
+    def parse_jsonl_entries(file_path)
+      entries = []
+      valid_types = %w[user assistant progress system attachment].freeze
+
+      File.foreach(file_path) do |line|
+        entry = JSON.parse(line.strip, symbolize_names: false)
+        next unless entry.is_a?(Hash)
+        next unless valid_types.include?(entry['type'])
+        next unless entry['uuid'].is_a?(String)
+
+        entries << entry
+      rescue JSON::ParserError
+        next
+      end
+      entries
+    end
+
+    def build_conversation_chain(entries)
+      return [] if entries.empty?
+
+      by_uuid = {}
+      by_position = {}
+      parent_uuids = Set.new
+
+      entries.each_with_index do |entry, idx|
+        by_uuid[entry['uuid']] = entry
+        by_position[entry['uuid']] = idx
+        parent_uuids << entry['parentUuid'] if entry['parentUuid']
+      end
+
+      # Terminals: entries whose uuid is not any other entry's parentUuid
+      terminals = Set.new(by_uuid.keys) - parent_uuids
+
+      # Walk back from each terminal to find the nearest user/assistant leaf
+      leaf_candidates = terminals.filter_map do |uuid|
+        walk_to_leaf(by_uuid, uuid)
+      end
+
+      # Keep only main-chain candidates (not sidechain, team, or meta)
+      main_leaves = leaf_candidates.reject do |e|
+        e['isSidechain'] || e['teamName'] || e['isMeta']
+      end
+      return [] if main_leaves.empty?
+
+      # Pick the leaf with highest file position, walk to root
+      best_leaf = main_leaves.max_by { |e| by_position[e['uuid']] || 0 }
+      walk_to_root(by_uuid, best_leaf)
+    end
+
+    def walk_to_leaf(by_uuid, uuid)
+      visited = Set.new
+      current = by_uuid[uuid]
+      while current
+        return current if %w[user assistant].include?(current['type'])
+        return nil unless visited.add?(current['uuid'])
+
+        parent = current['parentUuid']
+        current = parent ? by_uuid[parent] : nil
+      end
+    end
+
+    def walk_to_root(by_uuid, leaf)
+      chain = []
+      visited = Set.new
+      current = leaf
+      while current
+        break unless visited.add?(current['uuid'])
+
+        chain << current
+        parent = current['parentUuid']
+        current = parent ? by_uuid[parent] : nil
+      end
+      chain.reverse
+    end
+
+    def filter_visible_messages(chain)
+      chain.filter_map do |entry|
+        next unless %w[user assistant].include?(entry['type'])
+        next if entry['isMeta']
+        next if entry['isSidechain']
+        next if entry['teamName']
+
+        SessionMessage.new(
+          type: entry['type'],
+          uuid: entry['uuid'],
+          session_id: entry['sessionId'] || entry['session_id'] || '',
+          message: entry['message']
+        )
+      end
+    end
+
+    private_class_method :list_sessions_for_directory, :list_all_sessions,
+                         :deduplicate_sessions, :detect_worktrees,
+                         :find_session_file, :parse_jsonl_entries,
+                         :build_conversation_chain, :walk_to_leaf, :walk_to_root,
+                         :filter_visible_messages, :read_head_tail, :build_session_info
+  end
+end

data/lib/claude_agent_sdk/types.rb

@@ -124,23 +124,79 @@ module ClaudeAgentSDK
     end
   end
 
+  # Task lifecycle notification statuses
+  TASK_NOTIFICATION_STATUSES = %w[completed failed stopped].freeze
+
+  # Task started system message (subagent/background task started)
+  class TaskStartedMessage < SystemMessage
+    attr_accessor :task_id, :description, :uuid, :session_id, :tool_use_id, :task_type
+
+    def initialize(subtype:, data:, task_id:, description:, uuid:, session_id:,
+                   tool_use_id: nil, task_type: nil)
+      super(subtype: subtype, data: data)
+      @task_id = task_id
+      @description = description
+      @uuid = uuid
+      @session_id = session_id
+      @tool_use_id = tool_use_id
+      @task_type = task_type
+    end
+  end
+
+  # Task progress system message (periodic update from a running task)
+  class TaskProgressMessage < SystemMessage
+    attr_accessor :task_id, :description, :usage, :uuid, :session_id, :tool_use_id, :last_tool_name
+
+    def initialize(subtype:, data:, task_id:, description:, usage:, uuid:, session_id:,
+                   tool_use_id: nil, last_tool_name: nil)
+      super(subtype: subtype, data: data)
+      @task_id = task_id
+      @description = description
+      @usage = usage
+      @uuid = uuid
+      @session_id = session_id
+      @tool_use_id = tool_use_id
+      @last_tool_name = last_tool_name
+    end
+  end
+
+  # Task notification system message (task completed/failed/stopped)
+  class TaskNotificationMessage < SystemMessage
+    attr_accessor :task_id, :status, :output_file, :summary, :uuid, :session_id, :tool_use_id, :usage
+
+    def initialize(subtype:, data:, task_id:, status:, output_file:, summary:, uuid:, session_id:,
+                   tool_use_id: nil, usage: nil)
+      super(subtype: subtype, data: data)
+      @task_id = task_id
+      @status = status
+      @output_file = output_file
+      @summary = summary
+      @uuid = uuid
+      @session_id = session_id
+      @tool_use_id = tool_use_id
+      @usage = usage
+    end
+  end
+
   # Result message with cost and usage information
   class ResultMessage
     attr_accessor :subtype, :duration_ms, :duration_api_ms, :is_error,
-                  :num_turns, :session_id, :total_cost_usd, :usage, :result, :structured_output
+                  :num_turns, :session_id, :stop_reason, :total_cost_usd, :usage, :result, :structured_output
 
     def initialize(subtype:, duration_ms:, duration_api_ms:, is_error:,
-                   num_turns:, session_id:, total_cost_usd: nil, usage: nil, result: nil, structured_output: nil)
+                   num_turns:, session_id:, stop_reason: nil, total_cost_usd: nil,
+                   usage: nil, result: nil, structured_output: nil)
       @subtype = subtype
       @duration_ms = duration_ms
       @duration_api_ms = duration_api_ms
       @is_error = is_error
       @num_turns = num_turns
       @session_id = session_id
+      @stop_reason = stop_reason
       @total_cost_usd = total_cost_usd
       @usage = usage
       @result = result
-      @structured_output = structured_output # Structured output when output_format is specified
+      @structured_output = structured_output
     end
   end
 
@@ -320,29 +376,34 @@ module ClaudeAgentSDK
 
   # PreToolUse hook input
   class PreToolUseHookInput < BaseHookInput
-    attr_accessor :hook_event_name, :tool_name, :tool_input, :tool_use_id
+    attr_accessor :hook_event_name, :tool_name, :tool_input, :tool_use_id, :agent_id, :agent_type
 
-    def initialize(hook_event_name: 'PreToolUse', tool_name: nil, tool_input: nil, tool_use_id: nil, **base_args)
+    def initialize(hook_event_name: 'PreToolUse', tool_name: nil, tool_input: nil, tool_use_id: nil,
+                   agent_id: nil, agent_type: nil, **base_args)
       super(**base_args)
       @hook_event_name = hook_event_name
       @tool_name = tool_name
       @tool_input = tool_input
       @tool_use_id = tool_use_id
+      @agent_id = agent_id
+      @agent_type = agent_type
     end
   end
 
   # PostToolUse hook input
   class PostToolUseHookInput < BaseHookInput
-    attr_accessor :hook_event_name, :tool_name, :tool_input, :tool_response, :tool_use_id
+    attr_accessor :hook_event_name, :tool_name, :tool_input, :tool_response, :tool_use_id, :agent_id, :agent_type
 
     def initialize(hook_event_name: 'PostToolUse', tool_name: nil, tool_input: nil, tool_response: nil,
-                   tool_use_id: nil, **base_args)
+                   tool_use_id: nil, agent_id: nil, agent_type: nil, **base_args)
       super(**base_args)
       @hook_event_name = hook_event_name
       @tool_name = tool_name
       @tool_input = tool_input
       @tool_response = tool_response
       @tool_use_id = tool_use_id
+      @agent_id = agent_id
+      @agent_type = agent_type
     end
   end
 
@@ -385,10 +446,11 @@ module ClaudeAgentSDK
 
   # PostToolUseFailure hook input
   class PostToolUseFailureHookInput < BaseHookInput
-    attr_accessor :hook_event_name, :tool_name, :tool_input, :tool_use_id, :error, :is_interrupt
+    attr_accessor :hook_event_name, :tool_name, :tool_input, :tool_use_id, :error, :is_interrupt,
+                  :agent_id, :agent_type
 
     def initialize(hook_event_name: 'PostToolUseFailure', tool_name: nil, tool_input: nil, tool_use_id: nil,
-                   error: nil, is_interrupt: nil, **base_args)
+                   error: nil, is_interrupt: nil, agent_id: nil, agent_type: nil, **base_args)
       super(**base_args)
       @hook_event_name = hook_event_name
       @tool_name = tool_name
@@ -396,6 +458,8 @@ module ClaudeAgentSDK
       @tool_use_id = tool_use_id
       @error = error
       @is_interrupt = is_interrupt
+      @agent_id = agent_id
+      @agent_type = agent_type
     end
   end
 
@@ -426,15 +490,17 @@ module ClaudeAgentSDK
 
   # PermissionRequest hook input
   class PermissionRequestHookInput < BaseHookInput
-    attr_accessor :hook_event_name, :tool_name, :tool_input, :permission_suggestions
+    attr_accessor :hook_event_name, :tool_name, :tool_input, :permission_suggestions, :agent_id, :agent_type
 
     def initialize(hook_event_name: 'PermissionRequest', tool_name: nil, tool_input: nil, permission_suggestions: nil,
-                   **base_args)
+                   agent_id: nil, agent_type: nil, **base_args)
       super(**base_args)
       @hook_event_name = hook_event_name
       @tool_name = tool_name
       @tool_input = tool_input
       @permission_suggestions = permission_suggestions
+      @agent_id = agent_id
+      @agent_type = agent_type
     end
   end
 
@@ -632,6 +698,105 @@ module ClaudeAgentSDK
     end
   end
 
+  # MCP status response types
+
+  # MCP server connection status values
+  MCP_SERVER_CONNECTION_STATUSES = %w[connected failed needs-auth pending disabled].freeze
+
+  # MCP server info (name and version)
+  class McpServerInfo
+    attr_accessor :name, :version
+
+    def initialize(name:, version: nil)
+      @name = name
+      @version = version
+    end
+  end
+
+  # MCP tool annotation hints
+  class McpToolAnnotations
+    attr_accessor :read_only, :destructive, :open_world
+
+    def initialize(read_only: nil, destructive: nil, open_world: nil)
+      @read_only = read_only
+      @destructive = destructive
+      @open_world = open_world
+    end
+
+    def self.parse(data)
+      return nil unless data
+
+      new(
+        read_only: data.key?(:readOnly) ? data[:readOnly] : data[:read_only],
+        destructive: data[:destructive],
+        open_world: data.key?(:openWorld) ? data[:openWorld] : data[:open_world]
+      )
+    end
+  end
+
+  # MCP tool info (name, description, annotations)
+  class McpToolInfo
+    attr_accessor :name, :description, :annotations
+
+    def initialize(name:, description: nil, annotations: nil)
+      @name = name
+      @description = description
+      @annotations = annotations
+    end
+
+    def self.parse(data)
+      new(
+        name: data[:name],
+        description: data[:description],
+        annotations: McpToolAnnotations.parse(data[:annotations])
+      )
+    end
+  end
+
+  # Status of a single MCP server connection
+  class McpServerStatus
+    attr_accessor :name, :status, :server_info, :error, :config, :scope, :tools
+
+    def initialize(name:, status:, server_info: nil, error: nil, config: nil, scope: nil, tools: nil)
+      @name = name
+      @status = status
+      @server_info = server_info
+      @error = error
+      @config = config
+      @scope = scope
+      @tools = tools
+    end
+
+    def self.parse(data)
+      server_info = (McpServerInfo.new(name: data[:serverInfo][:name], version: data[:serverInfo][:version]) if data[:serverInfo])
+      tools = data[:tools]&.map { |t| McpToolInfo.parse(t) }
+
+      new(
+        name: data[:name],
+        status: data[:status],
+        server_info: server_info,
+        error: data[:error],
+        config: data[:config],
+        scope: data[:scope],
+        tools: tools
+      )
+    end
+  end
+
+  # Response from get_mcp_status containing all server statuses
+  class McpStatusResponse
+    attr_accessor :mcp_servers
+
+    def initialize(mcp_servers:)
+      @mcp_servers = mcp_servers
+    end
+
+    def self.parse(data)
+      servers = (data[:mcpServers] || []).map { |s| McpServerStatus.parse(s) }
+      new(mcp_servers: servers)
+    end
+  end
+
   # MCP Server configurations
   class McpStdioServerConfig
     attr_accessor :type, :command, :args, :env

data/lib/claude_agent_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeAgentSDK
-  VERSION = '0.7.3'
+  VERSION = '0.8.0'
 end

data/lib/claude_agent_sdk.rb

@@ -10,6 +10,7 @@ require_relative 'claude_agent_sdk/message_parser'
 require_relative 'claude_agent_sdk/query'
 require_relative 'claude_agent_sdk/sdk_mcp_server'
 require_relative 'claude_agent_sdk/streaming'
+require_relative 'claude_agent_sdk/sessions'
 require 'async'
 require 'securerandom'
 
@@ -58,6 +59,25 @@ module ClaudeAgentSDK
   #   ClaudeAgentSDK.query(prompt: messages) do |message|
   #     puts message
   #   end
+  # List sessions for a directory (or all sessions)
+  # @param directory [String, nil] Working directory to list sessions for
+  # @param limit [Integer, nil] Maximum number of sessions to return
+  # @param include_worktrees [Boolean] Whether to include git worktree sessions
+  # @return [Array<SDKSessionInfo>] Sessions sorted by last_modified descending
+  def self.list_sessions(directory: nil, limit: nil, include_worktrees: true)
+    Sessions.list_sessions(directory: directory, limit: limit, include_worktrees: include_worktrees)
+  end
+
+  # Get messages from a session transcript
+  # @param session_id [String] The session UUID
+  # @param directory [String, nil] Working directory to search in
+  # @param limit [Integer, nil] Maximum number of messages
+  # @param offset [Integer] Number of messages to skip
+  # @return [Array<SessionMessage>] Ordered messages from the session
+  def self.get_session_messages(session_id:, directory: nil, limit: nil, offset: 0)
+    Sessions.get_session_messages(session_id: session_id, directory: directory, limit: limit, offset: offset)
+  end
+
   def self.query(prompt:, options: nil, &block)
     return enum_for(:query, prompt: prompt, options: options) unless block
 
@@ -310,6 +330,28 @@ module ClaudeAgentSDK
       @query_handler.set_model(model)
     end
 
+    # Reconnect a failed MCP server
+    # @param server_name [String] Name of the MCP server to reconnect
+    def reconnect_mcp_server(server_name)
+      raise CLIConnectionError, 'Not connected. Call connect() first' unless @connected
+      @query_handler.reconnect_mcp_server(server_name)
+    end
+
+    # Enable or disable an MCP server
+    # @param server_name [String] Name of the MCP server
+    # @param enabled [Boolean] Whether to enable or disable
+    def toggle_mcp_server(server_name, enabled)
+      raise CLIConnectionError, 'Not connected. Call connect() first' unless @connected
+      @query_handler.toggle_mcp_server(server_name, enabled)
+    end
+
+    # Stop a running background task
+    # @param task_id [String] The ID of the task to stop
+    def stop_task(task_id)
+      raise CLIConnectionError, 'Not connected. Call connect() first' unless @connected
+      @query_handler.stop_task(task_id)
+    end
+
     # Rewind files to a previous checkpoint (v0.1.15+)
     # Restores file state to what it was at the given user message
     # Requires enable_file_checkpointing to be true in options

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: claude-agent-sdk
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
 platform: ruby
 authors:
 - Community Contributors
 bindir: bin
 cert_chain: []
-date: 2026-02-25 00:00:00.000000000 Z
+date: 2026-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -109,6 +109,7 @@ files:
 - lib/claude_agent_sdk/message_parser.rb
 - lib/claude_agent_sdk/query.rb
 - lib/claude_agent_sdk/sdk_mcp_server.rb
+- lib/claude_agent_sdk/sessions.rb
 - lib/claude_agent_sdk/streaming.rb
 - lib/claude_agent_sdk/subprocess_cli_transport.rb
 - lib/claude_agent_sdk/transport.rb