exaonruby 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2da95920bde51eb7724ef7c1cfa01d25906d4cb04cde2d2dc9d1055ec1267f9e
-  data.tar.gz: 190c39f5437c045f60067856033ad54330ce05425dd0edea79cb0fa74fed989f
+  metadata.gz: 120800cd9da222f8a7cd47f1e608d4208a71e4a5b4d0a035b8ebfd5ffd17c115
+  data.tar.gz: 559bae5acadd43bc85854c2e62fde0852a40d683b2328fd0eea27f99aeef9470
 SHA512:
-  metadata.gz: dea6072b3c1b149c869a4d76854cd36a3aa1a18241cbdea6a105f1331e2fb297723def00c59a30e13c4c044d93095b03b1bd7594f9dc9815e8c20b3bc59c3546
-  data.tar.gz: 12db1ecb3e8b3528bcaf74c03ea9a259136d794a9c68125562d69fe1d031808582f140cb2e50eb06b2faf3b9ec476c2eefc56809fe013ad3439d63fba35a7776
+  metadata.gz: 788f13f5bc62a00227dd41b3803bb9d2bb88e5dc5f160ac6d684b6b3df487ebd66d050dc9f2da56355b7f4752ba10d1551ace7c8d49a1c1be6863b333c10b070
+  data.tar.gz: 90cdc099f08b5815329ed77551d40004ace0e869138888679a268c73c92dedb96539864f1f5b8480d67fe6b26a9baf489c47e212d60cfc09d9b5939d221023fd

data/CHANGELOG.md

@@ -0,0 +1,94 @@
+# Changelog
+
+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).
+
+## [1.1.0] - 2025-12-18
+
+### Added
+
+- **SSE Streaming** - Real-time streaming for Answer and Research APIs
+  - `Exa::Utils::SSEClient.stream_answer` - Stream answer tokens as they're generated
+  - `Exa::Utils::SSEClient.stream_research` - Stream research progress and output
+  - Automatic reconnection and error handling
+  - Ping/heartbeat support
+
+- **Sorbet Type Definitions** - Optional static type checking
+  - `Exa::Types` module with T::Struct definitions for all API types
+  - Optional dependency on `sorbet-runtime`
+  - Full type coverage for Search, Answer, Research, Websets, Monitors, Imports, Webhooks, Events
+
+## [1.0.0] - 2025-12-18
+
+### Added
+
+- **Search API**
+  - Neural, auto, fast, and deep search types
+  - Content extraction with text, highlights, and summaries
+  - Domain and date filtering
+  - Category filtering (company, person, research paper, etc.)
+
+- **Contents API**
+  - Fetch full page contents from URLs
+  - Livecrawl support (never, fallback, preferred, always)
+  - Subpage extraction
+
+- **Find Similar API**
+  - Discover semantically similar pages
+  - Exclude source URL options
+
+- **Answer API**
+  - LLM-powered question answering
+  - Citations with source URLs
+  - Search options integration
+
+- **Research API**
+  - Async research task creation
+  - Multiple models (exa-research-fast, exa-research, exa-research-pro)
+  - Structured output schema support
+  - Task polling and cancellation
+
+- **Websets API**
+  - Full CRUD operations for Websets
+  - Item management (list, get, delete)
+  - Search operations (create, get, cancel)
+  - Enrichment operations (create, list, get, delete)
+
+- **Monitors API**
+  - Create automated search/refresh schedules
+  - Cron expression support
+  - Monitor run tracking
+
+- **Imports API**
+  - CSV upload with presigned URLs
+  - Entity type configuration
+  - Import status tracking
+
+- **Webhooks API**
+  - Create webhook subscriptions
+  - Event type filtering
+  - Webhook attempt tracking
+
+- **Events API**
+  - List and filter events
+  - Event type helpers
+
+- **CLI**
+  - Beautiful colorful command-line interface
+  - Search, answer, similar, research commands
+  - Websets management subcommands
+  - JSON output option
+
+- **n8n/Zapier Integration**
+  - Webhook signature verification
+  - HMAC-SHA256 with timing attack prevention
+  - Timestamp validation for replay attack prevention
+  - Framework-agnostic header parsing
+
+- **Core Features**
+  - Automatic retry with exponential backoff
+  - Comprehensive error hierarchy
+  - Rate limit handling with retry_after
+  - YARD documentation on all public methods

data/README.md

@@ -13,6 +13,8 @@ A production-ready Ruby gem wrapper for the [Exa.ai](https://exa.ai) API, provid
 - **Monitors**: Automated scheduled searches and content refresh
 - **Imports**: Upload CSV data into Websets
 - **Webhooks & Events**: Real-time notifications for Websets activity
+- **SSE Streaming**: Real-time token streaming for Answer and Research APIs
+- **Sorbet Types**: Optional T::Struct type definitions for static type checking
 - **Beautiful CLI**: Colorful command-line interface
 - **n8n/Zapier Integration**: Webhook signature verification utilities
 - **Automatic Retries**: Built-in retry logic for transient failures
@@ -593,12 +595,82 @@ exa search "AI news" --json
 exa version
 ```
 
+## SSE Streaming
+
+Stream tokens in real-time for Answer and Research APIs:
+
+```ruby
+# Stream an answer with real-time token output
+Exa::Utils::SSEClient.stream_answer(
+  api_key: ENV["EXA_API_KEY"],
+  query: "What is quantum computing?"
+) do |event|
+  case event[:type]
+  when :token
+    print event[:data]  # Print each token as it arrives
+  when :citation
+    puts "\nSource: #{event[:data][:url]}"
+  when :done
+    puts "\n\nComplete!"
+  when :error
+    puts "Error: #{event[:data]}"
+  end
+end
+
+# Stream research progress
+Exa::Utils::SSEClient.stream_research(
+  api_key: ENV["EXA_API_KEY"],
+  instructions: "Research latest AI developments"
+) do |event|
+  case event[:type]
+  when :progress
+    puts "Progress: #{event[:data][:percent]}%"
+  when :output
+    puts event[:data]
+  end
+end
+
+# Instance-based streaming
+streamer = Exa::Utils::SSEClient.new(api_key: ENV["EXA_API_KEY"])
+streamer.answer("What is GPT-4?") { |e| print e[:data] if e[:type] == :token }
+```
+
+## Sorbet Type Definitions
+
+Optional static type checking with Sorbet:
+
+```ruby
+# Install sorbet-runtime for type definitions
+# gem install sorbet-runtime
+
+require 'exa'
+
+# Types are available when sorbet-runtime is installed
+params = Exa::Types::SearchParams.new(
+  query: "AI research",
+  type: "neural",
+  num_results: 10,
+  text: true
+)
+
+# Type definitions for all API responses
+# Exa::Types::SearchResultData
+# Exa::Types::AnswerResponseData
+# Exa::Types::ResearchTaskData
+# Exa::Types::WebsetData
+# Exa::Types::MonitorData
+# Exa::Types::ImportData
+# Exa::Types::WebhookData
+# Exa::Types::EventData
+```
+
 ## Requirements
 
 - Ruby >= 3.1
 - faraday >= 2.0
 - faraday-retry >= 2.0
 - thor >= 1.0
+- sorbet-runtime >= 0.5 (optional, for type definitions)
 
 ## Development
 

data/exaonruby.gemspec

@@ -8,10 +8,11 @@ Gem::Specification.new do |spec|
   spec.authors = ["tigel-agm"]
   spec.email = []
 
-  spec.summary = "Complete Ruby client for the Exa.ai API with beautiful CLI"
+  spec.summary = "Complete Ruby client for the Exa.ai API with CLI and SSE streaming"
   spec.description = "A production-ready Ruby gem wrapper for the Exa.ai Search and Websets APIs. " \
                      "Features neural search, LLM-powered answers, async research tasks, " \
-                     "Websets management (monitors, imports, webhooks), and a beautiful CLI. " \
+                     "Websets management (monitors, imports, webhooks), SSE streaming, " \
+                     "Sorbet type definitions, and a beautiful CLI. " \
                      "Includes n8n/Zapier webhook signature verification utilities."
   spec.homepage = "https://github.com/tigel-agm/exaonruby"
   spec.license = "MIT"
@@ -24,14 +25,18 @@ Gem::Specification.new do |spec|
   spec.metadata["rubygems_mfa_required"] = "true"
 
   # Include all lib files explicitly since we may not have git
-  spec.files = Dir.glob("{lib,exe}/**/*") + %w[LICENSE.txt README.md]
+  spec.files = Dir.glob("{lib,exe}/**/*") + %w[LICENSE.txt README.md CHANGELOG.md]
   spec.files += Dir.glob("*.gemspec")
 
   spec.bindir = "exe"
   spec.executables = ["exa"]
   spec.require_paths = ["lib"]
 
+  # Core dependencies
   spec.add_dependency "faraday", ">= 2.0", "< 3.0"
   spec.add_dependency "faraday-retry", ">= 2.0", "< 3.0"
   spec.add_dependency "thor", ">= 1.0", "< 3.0"
+
+  # Optional: Sorbet types (install sorbet-runtime for type checking)
+  # gem install sorbet-runtime
 end

data/lib/exa/types.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+require "sorbet-runtime"
+
+module Exa
+  module Types
+    extend T::Sig
+
+    # Typed request structures for Search API
+    class SearchParams < T::Struct
+      const :query, String
+      const :type, T.nilable(String)
+      const :num_results, T.nilable(Integer)
+      const :include_domains, T.nilable(T::Array[String])
+      const :exclude_domains, T.nilable(T::Array[String])
+      const :start_crawl_date, T.nilable(String)
+      const :end_crawl_date, T.nilable(String)
+      const :start_published_date, T.nilable(String)
+      const :end_published_date, T.nilable(String)
+      const :include_text, T.nilable(T::Array[String])
+      const :exclude_text, T.nilable(T::Array[String])
+      const :category, T.nilable(String)
+      const :country, T.nilable(String)
+      const :text, T.nilable(T::Boolean)
+      const :highlights, T.nilable(T::Boolean)
+      const :summary, T.nilable(T::Boolean)
+      const :livecrawl, T.nilable(String)
+    end
+
+    class ContentsParams < T::Struct
+      const :ids, T::Array[String]
+      const :text, T.nilable(T::Boolean)
+      const :highlights, T.nilable(T::Boolean)
+      const :summary, T.nilable(T::Boolean)
+      const :livecrawl, T.nilable(String)
+      const :subpages, T.nilable(Integer)
+    end
+
+    class AnswerParams < T::Struct
+      const :query, String
+      const :text, T.nilable(T::Boolean)
+      const :stream, T.nilable(T::Boolean)
+      const :num_results, T.nilable(Integer)
+    end
+
+    class ResearchParams < T::Struct
+      const :instructions, String
+      const :model, T.nilable(String)
+      const :output_schema, T.nilable(T::Hash[Symbol, T.untyped])
+    end
+
+    # Typed response structures
+    class SearchResultData < T::Struct
+      const :id, String
+      const :url, String
+      const :title, T.nilable(String)
+      const :score, T.nilable(Float)
+      const :published_date, T.nilable(String)
+      const :author, T.nilable(String)
+      const :text, T.nilable(String)
+      const :highlights, T.nilable(T::Array[String])
+      const :summary, T.nilable(String)
+      const :image, T.nilable(String)
+      const :favicon, T.nilable(String)
+    end
+
+    class CostBreakdown < T::Struct
+      const :neural_search, T.nilable(Float)
+      const :deep_search, T.nilable(Float)
+      const :content_text, T.nilable(Float)
+      const :content_highlight, T.nilable(Float)
+      const :content_summary, T.nilable(Float)
+    end
+
+    class CostData < T::Struct
+      const :total, Float
+      const :search, T.nilable(Float)
+      const :contents, T.nilable(Float)
+      const :breakdown, T.nilable(CostBreakdown)
+    end
+
+    class SearchResponseData < T::Struct
+      const :request_id, T.nilable(String)
+      const :results, T::Array[SearchResultData]
+      const :cost_dollars, T.nilable(CostData)
+    end
+
+    class AnswerResponseData < T::Struct
+      const :answer, String
+      const :citations, T::Array[SearchResultData]
+      const :cost_dollars, T.nilable(CostData)
+    end
+
+    class ResearchTaskData < T::Struct
+      const :research_id, String
+      const :model, String
+      const :instructions, String
+      const :status, String
+      const :created_at, T.nilable(Integer)
+      const :completed_at, T.nilable(Integer)
+      const :output, T.nilable(T.any(String, T::Hash[Symbol, T.untyped]))
+      const :error, T.nilable(String)
+    end
+
+    # Websets types
+    class WebsetData < T::Struct
+      const :id, String
+      const :object, String
+      const :status, String
+      const :external_id, T.nilable(String)
+      const :title, T.nilable(String)
+      const :metadata, T.nilable(T::Hash[Symbol, T.untyped])
+      const :created_at, T.nilable(String)
+      const :updated_at, T.nilable(String)
+    end
+
+    class WebsetItemData < T::Struct
+      const :id, String
+      const :object, String
+      const :webset_id, String
+      const :url, String
+      const :type, T.nilable(String)
+      const :status, T.nilable(String)
+      const :created_at, T.nilable(String)
+    end
+
+    class MonitorData < T::Struct
+      const :id, String
+      const :object, String
+      const :status, String
+      const :webset_id, String
+      const :cron, T.nilable(String)
+      const :timezone, T.nilable(String)
+      const :next_run_at, T.nilable(String)
+      const :created_at, T.nilable(String)
+    end
+
+    class ImportData < T::Struct
+      const :id, String
+      const :object, String
+      const :status, String
+      const :format, String
+      const :title, T.nilable(String)
+      const :count, T.nilable(Integer)
+      const :upload_url, T.nilable(String)
+      const :upload_valid_until, T.nilable(String)
+      const :created_at, T.nilable(String)
+    end
+
+    class WebhookData < T::Struct
+      const :id, String
+      const :object, String
+      const :status, String
+      const :url, String
+      const :events, T::Array[String]
+      const :secret, T.nilable(String)
+      const :created_at, T.nilable(String)
+    end
+
+    class EventData < T::Struct
+      const :id, String
+      const :object, String
+      const :type, String
+      const :data, T::Hash[Symbol, T.untyped]
+      const :created_at, T.nilable(String)
+    end
+
+    # Pagination types
+    class PaginatedResponseData < T::Struct
+      const :data, T::Array[T.untyped]
+      const :has_more, T.nilable(T::Boolean)
+      const :next_cursor, T.nilable(String)
+    end
+
+    # Type aliases for common patterns
+    SearchType = T.type_alias { T.any(String, Symbol) }
+    LivecrawlOption = T.type_alias { T.any(String, Symbol) }
+    DateInput = T.type_alias { T.any(String, Time, Date) }
+
+    # Valid enum values
+    SEARCH_TYPES = T.let(%w[auto neural fast deep].freeze, T::Array[String])
+    LIVECRAWL_OPTIONS = T.let(%w[never fallback preferred always].freeze, T::Array[String])
+    CATEGORIES = T.let(%w[
+      company person research_paper news pdf github tweet 
+      personal_site financial_report
+    ].freeze, T::Array[String])
+    RESEARCH_MODELS = T.let(%w[exa-research-fast exa-research exa-research-pro].freeze, T::Array[String])
+    WEBSET_STATUSES = T.let(%w[idle pending running paused].freeze, T::Array[String])
+    IMPORT_STATUSES = T.let(%w[pending processing completed failed].freeze, T::Array[String])
+    MONITOR_STATUSES = T.let(%w[enabled disabled].freeze, T::Array[String])
+
+    WEBHOOK_EVENTS = T.let(%w[
+      webset.created webset.deleted webset.paused webset.idle
+      webset.search.created webset.search.canceled webset.search.completed webset.search.updated
+      import.created import.completed
+      webset.item.created webset.item.enriched
+      monitor.created monitor.updated monitor.deleted
+      monitor.run.created monitor.run.completed
+      webset.export.created webset.export.completed
+    ].freeze, T::Array[String])
+  end
+end

data/lib/exa/utils/sse_client.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+require "json"
+require "net/http"
+require "uri"
+
+module Exa
+  module Utils
+    # Server-Sent Events (SSE) streaming client for Exa.ai API
+    #
+    # Provides real-time streaming for Answer and Research endpoints that support
+    # the stream=true parameter. Tokens are yielded as they're generated.
+    #
+    # @example Stream an answer
+    #   Exa::Utils::SSEClient.stream_answer(
+    #     api_key: ENV["EXA_API_KEY"],
+    #     query: "What is quantum computing?"
+    #   ) do |event|
+    #     case event[:type]
+    #     when :token
+    #       print event[:data]  # Print each token as it arrives
+    #     when :citation
+    #       puts "\nSource: #{event[:data][:url]}"
+    #     when :done
+    #       puts "\n\nComplete!"
+    #     when :error
+    #       puts "Error: #{event[:data]}"
+    #     end
+    #   end
+    #
+    # @example Stream research progress
+    #   Exa::Utils::SSEClient.stream_research(
+    #     api_key: ENV["EXA_API_KEY"],
+    #     instructions: "Research latest AI developments"
+    #   ) do |event|
+    #     case event[:type]
+    #     when :progress
+    #       puts "Progress: #{event[:data][:percent]}%"
+    #     when :output
+    #       puts event[:data]
+    #     end
+    #   end
+    class SSEClient
+      DEFAULT_BASE_URL = "https://api.exa.ai"
+
+      # Event types that can be yielded
+      EVENT_TYPES = %i[token citation progress output done error ping].freeze
+
+      class << self
+        # Stream an answer with real-time token output
+        #
+        # @param api_key [String] Exa API key
+        # @param query [String] Question to answer
+        # @param base_url [String] API base URL
+        # @param options [Hash] Additional options (text, num_results, etc.)
+        #
+        # @yield [Hash] Event hash with :type and :data keys
+        # @yieldparam event [Hash] Event data
+        # @yieldparam event[:type] [Symbol] One of :token, :citation, :done, :error
+        # @yieldparam event[:data] [String, Hash] Event payload
+        #
+        # @return [void]
+        def stream_answer(api_key:, query:, base_url: DEFAULT_BASE_URL, **options, &block)
+          raise ArgumentError, "Block required for streaming" unless block_given?
+          raise InvalidRequestError, "query is required" if query.nil? || query.empty?
+
+          body = { query: query, stream: true }
+          body.merge!(options)
+
+          stream_request(
+            api_key: api_key,
+            url: "#{base_url}/answer",
+            body: body,
+            &block
+          )
+        end
+
+        # Stream research task output in real-time
+        #
+        # @param api_key [String] Exa API key
+        # @param instructions [String] Research instructions
+        # @param model [String] Model to use
+        # @param base_url [String] API base URL
+        # @param options [Hash] Additional options
+        #
+        # @yield [Hash] Event hash with :type and :data keys
+        # @yieldparam event [Hash] Event data
+        #
+        # @return [void]
+        def stream_research(api_key:, instructions:, model: "exa-research", base_url: DEFAULT_BASE_URL, **options, &block)
+          raise ArgumentError, "Block required for streaming" unless block_given?
+          raise InvalidRequestError, "instructions required" if instructions.nil? || instructions.empty?
+
+          body = {
+            instructions: instructions,
+            model: model,
+            stream: true
+          }
+          body.merge!(options)
+
+          stream_request(
+            api_key: api_key,
+            url: "#{base_url}/research/v1",
+            body: body,
+            &block
+          )
+        end
+
+        private
+
+        # Perform SSE streaming request
+        #
+        # @param api_key [String] API key
+        # @param url [String] Full endpoint URL
+        # @param body [Hash] Request body
+        #
+        # @yield [Hash] Parsed SSE events
+        def stream_request(api_key:, url:, body:)
+          uri = URI.parse(url)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.read_timeout = 300  # 5 minutes for long streams
+          http.open_timeout = 30
+
+          request = Net::HTTP::Post.new(uri.request_uri)
+          request["Content-Type"] = "application/json"
+          request["Accept"] = "text/event-stream"
+          request["Cache-Control"] = "no-cache"
+          request["x-api-key"] = api_key
+          request.body = JSON.generate(body)
+
+          buffer = String.new
+
+          http.request(request) do |response|
+            unless response.is_a?(Net::HTTPSuccess)
+              yield({ type: :error, data: "HTTP #{response.code}: #{response.message}" })
+              return
+            end
+
+            response.read_body do |chunk|
+              buffer << chunk
+              events = parse_sse_buffer(buffer)
+
+              events.each do |event|
+                yield(event)
+              end
+            end
+          end
+
+          yield({ type: :done, data: nil })
+        rescue Net::OpenTimeout, Net::ReadTimeout => e
+          yield({ type: :error, data: "Timeout: #{e.message}" })
+        rescue IOError, Errno::ECONNRESET => e
+          yield({ type: :error, data: "Connection error: #{e.message}" })
+        rescue StandardError => e
+          yield({ type: :error, data: "Error: #{e.message}" })
+        end
+
+        # Parse SSE buffer and extract complete events
+        #
+        # @param buffer [String] Buffer to parse (modified in place)
+        # @return [Array<Hash>] Parsed events
+        def parse_sse_buffer(buffer)
+          events = []
+          event_data = {}
+
+          # Split on double newlines (event boundaries)
+          while (idx = buffer.index("\n\n"))
+            raw_event = buffer.slice!(0, idx + 2)
+
+            raw_event.each_line do |line|
+              line = line.strip
+              next if line.empty?
+
+              if line.start_with?("event:")
+                event_data[:event] = line[6..].strip
+              elsif line.start_with?("data:")
+                data_content = line[5..].strip
+                event_data[:data] = data_content
+              elsif line.start_with?("id:")
+                event_data[:id] = line[3..].strip
+              elsif line.start_with?("retry:")
+                event_data[:retry] = line[6..].strip.to_i
+              end
+            end
+
+            if event_data.any?
+              parsed = parse_event(event_data)
+              events << parsed if parsed
+              event_data = {}
+            end
+          end
+
+          events
+        end
+
+        # Parse a single SSE event into our format
+        #
+        # @param event_data [Hash] Raw event data
+        # @return [Hash, nil] Parsed event or nil
+        def parse_event(event_data)
+          event_type = event_data[:event]&.to_sym || :message
+          raw_data = event_data[:data]
+
+          return nil unless raw_data
+
+          # Try to parse as JSON
+          data = begin
+            JSON.parse(raw_data, symbolize_names: true)
+          rescue JSON::ParserError
+            raw_data
+          end
+
+          case event_type
+          when :message, :token, :delta
+            # Token/delta events contain partial answer text
+            if data.is_a?(Hash)
+              text = data[:delta] || data[:content] || data[:text] || data[:token]
+              { type: :token, data: text } if text
+            else
+              { type: :token, data: data }
+            end
+          when :citation, :source
+            { type: :citation, data: data }
+          when :progress
+            { type: :progress, data: data }
+          when :output, :result
+            { type: :output, data: data }
+          when :done, :complete, :end
+            { type: :done, data: data }
+          when :error
+            { type: :error, data: data }
+          when :ping, :heartbeat
+            { type: :ping, data: nil }
+          else
+            # Return raw data for unknown event types
+            { type: event_type, data: data }
+          end
+        end
+      end
+
+      # Instance-based streaming for more control
+      #
+      # @param api_key [String] Exa API key
+      # @param base_url [String] API base URL
+      def initialize(api_key:, base_url: DEFAULT_BASE_URL)
+        @api_key = api_key
+        @base_url = base_url
+      end
+
+      # Stream an answer
+      # @see SSEClient.stream_answer
+      def answer(query, **options, &block)
+        self.class.stream_answer(
+          api_key: @api_key,
+          query: query,
+          base_url: @base_url,
+          **options,
+          &block
+        )
+      end
+
+      # Stream research
+      # @see SSEClient.stream_research
+      def research(instructions, **options, &block)
+        self.class.stream_research(
+          api_key: @api_key,
+          instructions: instructions,
+          base_url: @base_url,
+          **options,
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/exa/version.rb

@@ -3,5 +3,5 @@
 # typed: strict
 
 module Exa
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/exa.rb

@@ -8,6 +8,15 @@ require_relative "exa/configuration"
 
 require_relative "exa/utils/parameter_converter"
 require_relative "exa/utils/webhook_handler"
+require_relative "exa/utils/sse_client"
+
+# Optional: Sorbet types (only loaded if sorbet-runtime is available)
+begin
+  require "sorbet-runtime"
+  require_relative "exa/types"
+rescue LoadError
+  # sorbet-runtime not installed, types module not available
+end
 
 require_relative "exa/resources/base"
 require_relative "exa/resources/search_result"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exaonruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - tigel-agm
@@ -71,14 +71,15 @@ dependencies:
         version: '3.0'
 description: A production-ready Ruby gem wrapper for the Exa.ai Search and Websets
   APIs. Features neural search, LLM-powered answers, async research tasks, Websets
-  management (monitors, imports, webhooks), and a beautiful CLI. Includes n8n/Zapier
-  webhook signature verification utilities.
+  management (monitors, imports, webhooks), SSE streaming, Sorbet type definitions,
+  and a beautiful CLI. Includes n8n/Zapier webhook signature verification utilities.
 email: []
 executables:
 - exa
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - exaonruby.gemspec
@@ -114,7 +115,9 @@ files:
 - lib/exa/resources/webhook.rb
 - lib/exa/resources/webset.rb
 - lib/exa/resources/webset_item.rb
+- lib/exa/types.rb
 - lib/exa/utils/parameter_converter.rb
+- lib/exa/utils/sse_client.rb
 - lib/exa/utils/webhook_handler.rb
 - lib/exa/version.rb
 homepage: https://github.com/tigel-agm/exaonruby
@@ -142,5 +145,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.2
 specification_version: 4
-summary: Complete Ruby client for the Exa.ai API with beautiful CLI
+summary: Complete Ruby client for the Exa.ai API with CLI and SSE streaming
 test_files: []