claude-agent-sdk 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ce875efdba662100db9de2523598a28193fda59c45f5e720ab5c69724e5e83e
-  data.tar.gz: 1cd9a2342b14ba9ec4c8775bc8fa4b47fa519112f5a43fdcb87e832c9c8f2f43
+  metadata.gz: d1b1a2ec74f15062544d42a0df92058e256bab2ed29754e19133bfc1340cddcf
+  data.tar.gz: f01aea04b3f32e51b5d98e6994d52c8e2864259fa86d1c5bdc64104486b63687
 SHA512:
-  metadata.gz: 3142185738aa66feb78e7770d91b67a1c81303db80a8b8730e9c9388e8c754588a3dc3737a2eedff1bac36f025a664cd6b02f16adbd2436324644f6015fb188c
-  data.tar.gz: f13e3d95e5f47c0da0a0a48f8b9fc969996f6f6d17f51ff418dbeebda8adb72acb22281e895ab4b5b3f4f2e26952285a17d7f51fd55d0ac953a4e80fb5660d10
+  metadata.gz: ef15b15c77ceb22fc0b40884ecc1e79a884b9b7d043b21420ef0faa34d638206eec6284ab6afeb015097d721c75c0e00ce0f3db4c63e7f8e90305bda2e468b16
+  data.tar.gz: 74ee1d9b848c2e84336fb3a12e8147b35243f64ad6c1d352fe451a39c16a92cdaa92303acb20cf053495c580171bfe36d60f5a53bee98d2781da0b1b261870d3

data/CHANGELOG.md

@@ -5,6 +5,22 @@ 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
+- **Critical:** Replaced `Async::Process` with Ruby's built-in `Open3` for subprocess management
+- Fixed "uninitialized constant Async::Process" error that prevented the gem from working
+- Process management now uses standard Ruby threads instead of async tasks
+- All 86 tests passing
+
 ## [0.1.1] - 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,6 +94,41 @@ 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).
@@ -193,6 +230,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
@@ -415,7 +504,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 +514,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/subprocess_cli_transport.rb

@@ -162,23 +162,14 @@ module ClaudeAgentSDK
       should_pipe_stderr = @options.stderr || @options.extra_args.key?('debug-to-stderr')
 
       begin
-        # Start process
-        @process = Async::Process::Child.new(
-          *cmd,
-          stdin: :pipe,
-          stdout: :pipe,
-          stderr: should_pipe_stderr ? :pipe : nil,
-          chdir: @cwd&.to_s,
-          env: process_env
-        )
+        # Start process using Open3
+        opts = { chdir: @cwd&.to_s }.compact
 
-        @stdout = @process.stdout
-        @stdin = @process.stdin if @is_streaming
+        @stdin, @stdout, @stderr, @process = Open3.popen3(process_env, *cmd, opts)
 
         # Handle stderr if piped
-        if should_pipe_stderr && @process.stderr
-          @stderr = @process.stderr
-          @stderr_task = Async do
+        if should_pipe_stderr && @stderr
+          @stderr_task = Thread.new do
             handle_stderr
           rescue StandardError
             # Ignore errors during stderr reading
@@ -186,7 +177,8 @@ module ClaudeAgentSDK
         end
 
         # Close stdin for non-streaming mode
-        @process.stdin.close unless @is_streaming
+        @stdin.close unless @is_streaming
+        @stdin = nil unless @is_streaming
 
         @ready = true
       rescue Errno::ENOENT => e
@@ -223,8 +215,11 @@ module ClaudeAgentSDK
       @ready = false
       return unless @process
 
-      # Cancel stderr task
-      @stderr_task&.stop
+      # Kill stderr thread
+      if @stderr_task&.alive?
+        @stderr_task.kill
+        @stderr_task.join(1) rescue nil
+      end
 
       # Close streams
       begin
@@ -232,6 +227,11 @@ module ClaudeAgentSDK
       rescue StandardError
         # Ignore
       end
+      begin
+        @stdout&.close
+      rescue StandardError
+        # Ignore
+      end
       begin
         @stderr&.close
       rescue StandardError
@@ -240,8 +240,8 @@ module ClaudeAgentSDK
 
       # Terminate process
       begin
-        @process.terminate
-        @process.wait
+        Process.kill('TERM', @process.pid) if @process.alive?
+        @process.value
       rescue StandardError
         # Ignore
       end
@@ -250,12 +250,13 @@ module ClaudeAgentSDK
       @stdout = nil
       @stdin = nil
       @stderr = nil
+      @stderr_task = nil
       @exit_error = nil
     end
 
     def write(data)
       raise CLIConnectionError, 'ProcessTransport is not ready for writing' unless @ready && @stdin
-      raise CLIConnectionError, "Cannot write to terminated process" if @process && @process.status
+      raise CLIConnectionError, "Cannot write to terminated process" if @process && !@process.alive?
 
       raise CLIConnectionError, "Cannot write to process that exited with error: #{@exit_error}" if @exit_error
 
@@ -326,7 +327,7 @@ module ClaudeAgentSDK
       end
 
       # Check process completion
-      status = @process.wait
+      status = @process.value
       returncode = status.exitstatus
 
       if returncode && returncode != 0

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.1'
+  VERSION = '0.1.3'
 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)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: claude-agent-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Community Contributors
 bindir: bin
 cert_chain: []
-date: 2025-10-14 00:00:00.000000000 Z
+date: 2025-10-15 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