claude-agent-sdk 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5f1881eb9fa20f805736f864736977c80f839d88042b3ba6e36ac23f7550548
-  data.tar.gz: 2ccee5ba2a1d59d312737eac4a36464cd15a160c3989b4a5d663ef49c7962b9e
+  metadata.gz: 4d8b669f4c3f02dea0763113551838bb0a3a5ec514125876f28dbc5d23ee44aa
+  data.tar.gz: 6ce126558a2d99e3b6aba03527d5b4ce8954ff3a99a13ee25f54dd6fa0141980
 SHA512:
-  metadata.gz: 23cb7eff0c9f6a48ba1599c793cdabef7f8f98524c0a6eaf07abbb62407e4363a6e0d63f5764b1383ae8297b389a7db042ed9670a5e43c6d5e263321a42f9361
-  data.tar.gz: fa7e760167ff757870f54c6f0175f25bb3d9480843053ae82d9a95c82c6dd29ad478f3901496c72a2bc74cdca1d596db25ddaef09a724df3743005fec907ca94
+  metadata.gz: 54e48e83a98845d56d6dc4c1843ebf8728fd74ffd3e7670e826c0fdbf3ef297359c18f5b27c2fac0757da0fab5e28d6c19ab084ac1842c5615d06cf52a0a94f8
+  data.tar.gz: 224aca0535d196fa3b348da69af9e4cbcc46276af8d36b7b58f6e35811704f93506ff31df7449e9aae9ebd252c8b5c035fa581dc4d500a5bade82d0d15f37ddc

data/CHANGELOG.md

@@ -5,6 +5,14 @@ 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.1.3] - 2025-10-15
+
+### Added
+- **MCP resource support:** Full support for MCP resources (list, read, subscribe operations)
+- **MCP prompt support:** Support for MCP prompts (list, get operations)
+- **Streaming input support:** Added streaming capabilities for input handling
+- Feature complete MCP implementation matching Python SDK functionality
+
 ## [0.1.2] - 2025-10-14
 
 ### Fixed

data/README.md

@@ -1,11 +1,13 @@
 # Claude Agent SDK for Ruby
 
-> **⚠️ DISCLAIMER**: This is an **unofficial, community-maintained** Ruby SDK for Claude Agent. It is not officially supported or maintained by Anthropic. For official SDK support, please refer to the [Python SDK](https://github.com/anthropics/claude-code/tree/main/agent-sdk/python).
+> **⚠️ DISCLAIMER**: This is an **unofficial, community-maintained** Ruby SDK for Claude Agent. It is not officially supported or maintained by Anthropic. For official SDK support, please refer to the [Python SDK](https://docs.claude.com/en/api/agent-sdk/python).
 >
 > This implementation is based on the official Python SDK and aims to provide feature parity for Ruby developers. Use at your own risk.
 
 Ruby SDK for Claude Agent. See the [Claude Agent SDK documentation](https://docs.anthropic.com/en/docs/claude-code/sdk) for more information.
 
+[![Gem Version](https://badge.fury.io/rb/claude-agent-sdk.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/claude-agent-sdk)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -92,9 +94,48 @@ options = ClaudeAgentSDK::ClaudeAgentOptions.new(
 )
 ```
 
+### Streaming Input
+
+The `query()` function supports streaming input, allowing you to send multiple messages dynamically instead of a single prompt string.
+
+```ruby
+require 'claude_agent_sdk'
+
+# Create a stream of messages
+messages = ['Hello!', 'What is 2+2?', 'Thanks!']
+stream = ClaudeAgentSDK::Streaming.from_array(messages)
+
+# Query with streaming input
+ClaudeAgentSDK.query(prompt: stream) do |message|
+  puts message if message.is_a?(ClaudeAgentSDK::AssistantMessage)
+end
+```
+
+You can also create custom streaming enumerators:
+
+```ruby
+# Dynamic message generation
+stream = Enumerator.new do |yielder|
+  yielder << ClaudeAgentSDK::Streaming.user_message("First message")
+  # Do some processing...
+  yielder << ClaudeAgentSDK::Streaming.user_message("Second message")
+  yielder << ClaudeAgentSDK::Streaming.user_message("Third message")
+end
+
+ClaudeAgentSDK.query(prompt: stream) do |message|
+  # Process responses
+end
+```
+
+For a complete example, see [examples/streaming_input_example.rb](examples/streaming_input_example.rb).
+
 ## Client
 
-`ClaudeAgentSDK::Client` supports bidirectional, interactive conversations with Claude Code. Unlike `query()`, `Client` enables **custom tools**, **hooks**, and **permission callbacks**, all of which can be defined as Ruby procs/lambdas. See [lib/claude_agent_sdk.rb](lib/claude_agent_sdk.rb).
+`ClaudeAgentSDK::Client` supports bidirectional, interactive conversations with Claude Code. Unlike `query()`, `Client` enables **custom tools**, **hooks**, and **permission callbacks**, all of which can be defined as Ruby procs/lambdas.
+
+**The Client class automatically uses streaming mode** for bidirectional communication, allowing you to send multiple queries dynamically during a single session without closing the connection. This matches the Python SDK's `ClaudeSDKClient` behavior.
+
+See [lib/claude_agent_sdk.rb](lib/claude_agent_sdk.rb) for implementation details.
 
 ### Custom Tools (SDK MCP Servers)
 
@@ -193,6 +234,58 @@ options = ClaudeAgentSDK::ClaudeAgentOptions.new(
 )
 ```
 
+#### MCP Resources and Prompts
+
+SDK MCP servers can also expose **resources** (data sources) and **prompts** (reusable templates):
+
+```ruby
+# Create a resource (data source Claude can read)
+config_resource = ClaudeAgentSDK.create_resource(
+  uri: 'config://app/settings',
+  name: 'Application Settings',
+  description: 'Current app configuration',
+  mime_type: 'application/json'
+) do
+  config_data = { app_name: 'MyApp', version: '1.0.0' }
+  {
+    contents: [{
+      uri: 'config://app/settings',
+      mimeType: 'application/json',
+      text: JSON.pretty_generate(config_data)
+    }]
+  }
+end
+
+# Create a prompt template
+review_prompt = ClaudeAgentSDK.create_prompt(
+  name: 'code_review',
+  description: 'Review code for best practices',
+  arguments: [
+    { name: 'code', description: 'Code to review', required: true }
+  ]
+) do |args|
+  {
+    messages: [{
+      role: 'user',
+      content: {
+        type: 'text',
+        text: "Review this code: #{args[:code]}"
+      }
+    }]
+  }
+end
+
+# Create server with tools, resources, and prompts
+server = ClaudeAgentSDK.create_sdk_mcp_server(
+  name: 'dev-tools',
+  tools: [my_tool],
+  resources: [config_resource],
+  prompts: [review_prompt]
+)
+```
+
+For complete examples, see [examples/mcp_resources_prompts_example.rb](examples/mcp_resources_prompts_example.rb).
+
 ### Basic Client Usage
 
 ```ruby
@@ -203,6 +296,7 @@ Async do
   client = ClaudeAgentSDK::Client.new
 
   begin
+    # Connect automatically uses streaming mode for bidirectional communication
     client.connect
 
     # Send a query
@@ -415,7 +509,9 @@ See the following examples for complete working code:
 
 - [examples/quick_start.rb](examples/quick_start.rb) - Basic `query()` usage with options
 - [examples/client_example.rb](examples/client_example.rb) - Interactive Client usage
+- [examples/streaming_input_example.rb](examples/streaming_input_example.rb) - Streaming input for multi-turn conversations
 - [examples/mcp_calculator.rb](examples/mcp_calculator.rb) - Custom tools with SDK MCP servers
+- [examples/mcp_resources_prompts_example.rb](examples/mcp_resources_prompts_example.rb) - MCP resources and prompts
 - [examples/hooks_example.rb](examples/hooks_example.rb) - Using hooks to control tool execution
 - [examples/permission_callback_example.rb](examples/permission_callback_example.rb) - Dynamic tool permission control
 
@@ -423,10 +519,6 @@ See the following examples for complete working code:
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rspec` to run the tests.
 
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/anthropics/claude-agent-sdk-ruby.
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/claude_agent_sdk/query.rb

@@ -314,6 +314,14 @@ module ClaudeAgentSDK
         handle_mcp_tools_list(server, message)
       when 'tools/call'
         handle_mcp_tools_call(server, message, params)
+      when 'resources/list'
+        handle_mcp_resources_list(server, message)
+      when 'resources/read'
+        handle_mcp_resources_read(server, message, params)
+      when 'prompts/list'
+        handle_mcp_prompts_list(server, message)
+      when 'prompts/get'
+        handle_mcp_prompts_get(server, message, params)
       when 'notifications/initialized'
         { jsonrpc: '2.0', result: {} }
       else
@@ -332,12 +340,17 @@ module ClaudeAgentSDK
     end
 
     def handle_mcp_initialize(server, message)
+      capabilities = {}
+      capabilities[:tools] = {} if server.tools && !server.tools.empty?
+      capabilities[:resources] = {} if server.resources && !server.resources.empty?
+      capabilities[:prompts] = {} if server.prompts && !server.prompts.empty?
+
       {
         jsonrpc: '2.0',
         id: message[:id],
         result: {
           protocolVersion: '2024-11-05',
-          capabilities: { tools: {} },
+          capabilities: capabilities,
           serverInfo: {
             name: server.name,
             version: server.version || '1.0.0'
@@ -384,6 +397,58 @@ module ClaudeAgentSDK
       }
     end
 
+    def handle_mcp_resources_list(server, message)
+      # List resources from the SDK MCP server
+      resources_data = server.list_resources
+      {
+        jsonrpc: '2.0',
+        id: message[:id],
+        result: { resources: resources_data }
+      }
+    end
+
+    def handle_mcp_resources_read(server, message, params)
+      # Read a resource from the SDK MCP server
+      uri = params[:uri]
+      raise 'Missing uri parameter for resources/read' unless uri
+
+      # Read the resource
+      result = server.read_resource(uri)
+
+      {
+        jsonrpc: '2.0',
+        id: message[:id],
+        result: result
+      }
+    end
+
+    def handle_mcp_prompts_list(server, message)
+      # List prompts from the SDK MCP server
+      prompts_data = server.list_prompts
+      {
+        jsonrpc: '2.0',
+        id: message[:id],
+        result: { prompts: prompts_data }
+      }
+    end
+
+    def handle_mcp_prompts_get(server, message, params)
+      # Get a prompt from the SDK MCP server
+      name = params[:name]
+      raise 'Missing name parameter for prompts/get' unless name
+
+      arguments = params[:arguments] || {}
+
+      # Get the prompt
+      result = server.get_prompt(name, arguments)
+
+      {
+        jsonrpc: '2.0',
+        id: message[:id],
+        result: result
+      }
+    end
+
     public
 
     # Send interrupt control request

data/lib/claude_agent_sdk/sdk_mcp_server.rb

@@ -6,14 +6,23 @@ module ClaudeAgentSDK
   # Unlike external MCP servers that run as separate processes, SDK MCP servers
   # run directly in your application's process, providing better performance
   # and simpler deployment.
+  #
+  # Supports:
+  # - Tools: Executable functions that Claude can call
+  # - Resources: Data sources that can be read (files, databases, APIs, etc.)
+  # - Prompts: Reusable prompt templates with arguments
   class SdkMcpServer
-    attr_reader :name, :version, :tools
+    attr_reader :name, :version, :tools, :resources, :prompts
 
-    def initialize(name:, version: '1.0.0', tools: [])
+    def initialize(name:, version: '1.0.0', tools: [], resources: [], prompts: [])
       @name = name
       @version = version
       @tools = tools
+      @resources = resources
+      @prompts = prompts
       @tool_map = tools.each_with_object({}) { |tool, hash| hash[tool.name] = tool }
+      @resource_map = resources.each_with_object({}) { |res, hash| hash[res.uri] = res }
+      @prompt_map = prompts.each_with_object({}) { |prompt, hash| hash[prompt.name] = prompt }
     end
 
     # List all available tools
@@ -47,6 +56,68 @@ module ClaudeAgentSDK
       result
     end
 
+    # List all available resources
+    # @return [Array<Hash>] Array of resource definitions
+    def list_resources
+      @resources.map do |resource|
+        {
+          uri: resource.uri,
+          name: resource.name,
+          description: resource.description,
+          mimeType: resource.mime_type
+        }.compact
+      end
+    end
+
+    # Read a resource by URI
+    # @param uri [String] Resource URI
+    # @return [Hash] Resource content
+    def read_resource(uri)
+      resource = @resource_map[uri]
+      raise "Resource '#{uri}' not found" unless resource
+
+      # Call the resource's reader
+      content = resource.reader.call
+
+      # Ensure content has the expected format
+      unless content.is_a?(Hash) && content[:contents]
+        raise "Resource '#{uri}' must return a hash with :contents key"
+      end
+
+      content
+    end
+
+    # List all available prompts
+    # @return [Array<Hash>] Array of prompt definitions
+    def list_prompts
+      @prompts.map do |prompt|
+        {
+          name: prompt.name,
+          description: prompt.description,
+          arguments: prompt.arguments
+        }.compact
+      end
+    end
+
+    # Get a prompt by name
+    # @param name [String] Prompt name
+    # @param arguments [Hash] Arguments to fill in the prompt template
+    # @return [Hash] Prompt with filled-in arguments
+    def get_prompt(name, arguments = {})
+      prompt = @prompt_map[name]
+      raise "Prompt '#{name}' not found" unless prompt
+
+      # Call the prompt's generator
+      result = prompt.generator.call(arguments)
+
+      # Ensure result has the expected format
+      unless result.is_a?(Hash) && result[:messages]
+        raise "Prompt '#{name}' must return a hash with :messages key"
+      end
+
+      result
+    end
+
     private
 
     def convert_input_schema(schema)
@@ -130,11 +201,123 @@ module ClaudeAgentSDK
     )
   end
 
+  # Helper function to create a resource definition
+  #
+  # @param uri [String] Unique identifier for the resource (e.g., "file:///path/to/file")
+  # @param name [String] Human-readable name
+  # @param description [String, nil] Optional description
+  # @param mime_type [String, nil] Optional MIME type (e.g., "text/plain", "application/json")
+  # @param reader [Proc] Block that returns the resource content
+  # @return [SdkMcpResource] Resource definition
+  #
+  # @example File resource
+  #   resource = create_resource(
+  #     uri: 'file:///config/settings.json',
+  #     name: 'Application Settings',
+  #     description: 'Current application configuration',
+  #     mime_type: 'application/json'
+  #   ) do
+  #     content = File.read('/path/to/settings.json')
+  #     {
+  #       contents: [{
+  #         uri: 'file:///config/settings.json',
+  #         mimeType: 'application/json',
+  #         text: content
+  #       }]
+  #     }
+  #   end
+  #
+  # @example Database resource
+  #   resource = create_resource(
+  #     uri: 'db://users/count',
+  #     name: 'User Count',
+  #     description: 'Total number of registered users'
+  #   ) do
+  #     count = User.count
+  #     {
+  #       contents: [{
+  #         uri: 'db://users/count',
+  #         mimeType: 'text/plain',
+  #         text: count.to_s
+  #       }]
+  #     }
+  #   end
+  def self.create_resource(uri:, name:, description: nil, mime_type: nil, &reader)
+    raise ArgumentError, 'Block required for resource reader' unless reader
+
+    SdkMcpResource.new(
+      uri: uri,
+      name: name,
+      description: description,
+      mime_type: mime_type,
+      reader: reader
+    )
+  end
+
+  # Helper function to create a prompt definition
+  #
+  # @param name [String] Unique identifier for the prompt
+  # @param description [String, nil] Optional description
+  # @param arguments [Array<Hash>, nil] Optional argument definitions
+  # @param generator [Proc] Block that generates prompt messages
+  # @return [SdkMcpPrompt] Prompt definition
+  #
+  # @example Simple prompt
+  #   prompt = create_prompt(
+  #     name: 'code_review',
+  #     description: 'Review code for best practices'
+  #   ) do |args|
+  #     {
+  #       messages: [
+  #         {
+  #           role: 'user',
+  #           content: {
+  #             type: 'text',
+  #             text: 'Please review this code for best practices and suggest improvements.'
+  #           }
+  #         }
+  #       ]
+  #     }
+  #   end
+  #
+  # @example Prompt with arguments
+  #   prompt = create_prompt(
+  #     name: 'git_commit',
+  #     description: 'Generate a git commit message',
+  #     arguments: [
+  #       { name: 'changes', description: 'Description of changes', required: true }
+  #     ]
+  #   ) do |args|
+  #     {
+  #       messages: [
+  #         {
+  #           role: 'user',
+  #           content: {
+  #             type: 'text',
+  #             text: "Generate a concise git commit message for: #{args[:changes]}"
+  #           }
+  #         }
+  #       ]
+  #     }
+  #   end
+  def self.create_prompt(name:, description: nil, arguments: nil, &generator)
+    raise ArgumentError, 'Block required for prompt generator' unless generator
+
+    SdkMcpPrompt.new(
+      name: name,
+      description: description,
+      arguments: arguments,
+      generator: generator
+    )
+  end
+
   # Create an SDK MCP server
   #
   # @param name [String] Unique identifier for the server
   # @param version [String] Server version (default: '1.0.0')
   # @param tools [Array<SdkMcpTool>] List of tool definitions
+  # @param resources [Array<SdkMcpResource>] List of resource definitions
+  # @param prompts [Array<SdkMcpPrompt>] List of prompt definitions
   # @return [Hash] MCP server configuration for ClaudeAgentOptions
   #
   # @example Simple calculator server
@@ -152,8 +335,31 @@ module ClaudeAgentSDK
   #     mcp_servers: { calc: calculator },
   #     allowed_tools: ['mcp__calc__add']
   #   )
-  def self.create_sdk_mcp_server(name:, version: '1.0.0', tools: [])
-    server = SdkMcpServer.new(name: name, version: version, tools: tools)
+  #
+  # @example Server with resources and prompts
+  #   config_resource = ClaudeAgentSDK.create_resource(
+  #     uri: 'config://app',
+  #     name: 'App Config'
+  #   ) { { contents: [{ uri: 'config://app', text: 'config data' }] } }
+  #
+  #   review_prompt = ClaudeAgentSDK.create_prompt(
+  #     name: 'review',
+  #     description: 'Code review'
+  #   ) { { messages: [{ role: 'user', content: { type: 'text', text: 'Review this' } }] } }
+  #
+  #   server = ClaudeAgentSDK.create_sdk_mcp_server(
+  #     name: 'dev-tools',
+  #     resources: [config_resource],
+  #     prompts: [review_prompt]
+  #   )
+  def self.create_sdk_mcp_server(name:, version: '1.0.0', tools: [], resources: [], prompts: [])
+    server = SdkMcpServer.new(
+      name: name,
+      version: version,
+      tools: tools,
+      resources: resources,
+      prompts: prompts
+    )
 
     # Return configuration for ClaudeAgentOptions
     {

data/lib/claude_agent_sdk/streaming.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ClaudeAgentSDK
+  # Streaming input helpers for Claude Agent SDK
+  module Streaming
+    # Create a user message for streaming input
+    #
+    # @param content [String] The message content
+    # @param session_id [String] Session identifier
+    # @param parent_tool_use_id [String, nil] Parent tool use ID if responding to a tool
+    # @return [String] JSON-encoded message
+    def self.user_message(content, session_id: 'default', parent_tool_use_id: nil)
+      message = {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: content
+        },
+        parent_tool_use_id: parent_tool_use_id,
+        session_id: session_id
+      }
+      JSON.generate(message) + "\n"
+    end
+
+    # Create an Enumerator from an array of messages
+    #
+    # @param messages [Array<String>] Array of message strings
+    # @param session_id [String] Session identifier
+    # @return [Enumerator] Enumerator yielding JSON-encoded messages
+    #
+    # @example
+    #   messages = ['Hello', 'What is 2+2?', 'Thanks!']
+    #   stream = ClaudeAgentSDK::Streaming.from_array(messages)
+    def self.from_array(messages, session_id: 'default')
+      Enumerator.new do |yielder|
+        messages.each do |content|
+          yielder << user_message(content, session_id: session_id)
+        end
+      end
+    end
+
+    # Create an Enumerator from a block
+    #
+    # @yield Block that yields message strings
+    # @param session_id [String] Session identifier
+    # @return [Enumerator] Enumerator yielding JSON-encoded messages
+    #
+    # @example
+    #   stream = ClaudeAgentSDK::Streaming.from_block do |yielder|
+    #     yielder.yield('First message')
+    #     sleep 1
+    #     yielder.yield('Second message')
+    #   end
+    def self.from_block(session_id: 'default', &block)
+      Enumerator.new do |yielder|
+        collector = Object.new
+        def collector.yield(content)
+          @content = content
+        end
+        def collector.content
+          @content
+        end
+
+        inner_enum = Enumerator.new(&block)
+        inner_enum.each do |content|
+          yielder << user_message(content, session_id: session_id)
+        end
+      end
+    end
+  end
+end

data/lib/claude_agent_sdk/types.rb

@@ -355,4 +355,29 @@ module ClaudeAgentSDK
       @handler = handler
     end
   end
+
+  # SDK MCP Resource definition
+  class SdkMcpResource
+    attr_accessor :uri, :name, :description, :mime_type, :reader
+
+    def initialize(uri:, name:, description: nil, mime_type: nil, reader:)
+      @uri = uri
+      @name = name
+      @description = description
+      @mime_type = mime_type
+      @reader = reader
+    end
+  end
+
+  # SDK MCP Prompt definition
+  class SdkMcpPrompt
+    attr_accessor :name, :description, :arguments, :generator
+
+    def initialize(name:, description: nil, arguments: nil, generator:)
+      @name = name
+      @description = description
+      @arguments = arguments
+      @generator = generator
+    end
+  end
 end

data/lib/claude_agent_sdk/version.rb

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

data/lib/claude_agent_sdk.rb

@@ -8,6 +8,7 @@ require_relative 'claude_agent_sdk/subprocess_cli_transport'
 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 'async'
 require 'securerandom'
 
@@ -18,7 +19,7 @@ module ClaudeAgentSDK
   # This function is ideal for simple, stateless queries where you don't need
   # bidirectional communication or conversation management.
   #
-  # @param prompt [String] The prompt to send to Claude
+  # @param prompt [String, Enumerator] The prompt to send to Claude, or an Enumerator for streaming input
   # @param options [ClaudeAgentOptions] Optional configuration
   # @yield [Message] Each message from the conversation
   # @return [Enumerator] if no block given
@@ -40,6 +41,12 @@ module ClaudeAgentSDK
   #       end
   #     end
   #   end
+  #
+  # @example Streaming input
+  #   messages = Streaming.from_array(['Hello', 'What is 2+2?', 'Thanks!'])
+  #   ClaudeAgentSDK.query(prompt: messages) do |message|
+  #     puts message
+  #   end
   def self.query(prompt:, options: nil, &block)
     return enum_for(:query, prompt: prompt, options: options) unless block
 
@@ -50,6 +57,21 @@ module ClaudeAgentSDK
       transport = SubprocessCLITransport.new(prompt, options)
       begin
         transport.connect
+
+        # If prompt is an Enumerator, write each message to stdin
+        if prompt.is_a?(Enumerator) || prompt.respond_to?(:each)
+          Async do
+            begin
+              prompt.each do |message_json|
+                transport.write(message_json)
+              end
+            ensure
+              transport.end_input
+            end
+          end
+        end
+
+        # Read and yield messages
         transport.read_messages do |data|
           message = MessageParser.parse(data)
           block.call(message)
@@ -64,11 +86,12 @@ module ClaudeAgentSDK
   #
   # This client provides full control over the conversation flow with support
   # for streaming, hooks, permission callbacks, and dynamic message sending.
+  # The Client class always uses streaming mode for bidirectional communication.
   #
   # @example Basic usage
   #   Async do
   #     client = ClaudeAgentSDK::Client.new
-  #     client.connect
+  #     client.connect  # No arguments needed - automatically uses streaming mode
   #
   #     client.query("What is the capital of France?")
   #     client.receive_response do |msg|
@@ -128,8 +151,10 @@ module ClaudeAgentSDK
         configured_options = @options.dup_with(permission_prompt_tool_name: 'stdio')
       end
 
-      # Create transport
-      actual_prompt = prompt || ''
+      # Auto-connect with empty enumerator if no prompt is provided
+      # This matches the Python SDK pattern where ClaudeSDKClient always uses streaming mode
+      # An empty enumerator keeps stdin open for bidirectional communication
+      actual_prompt = prompt || [].to_enum
       @transport = SubprocessCLITransport.new(actual_prompt, configured_options)
       @transport.connect
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: claude-agent-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Community Contributors
 bindir: bin
 cert_chain: []
-date: 2025-10-14 00:00:00.000000000 Z
+date: 2025-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -94,6 +94,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/streaming.rb
 - lib/claude_agent_sdk/subprocess_cli_transport.rb
 - lib/claude_agent_sdk/transport.rb
 - lib/claude_agent_sdk/types.rb