exa-ai-ruby 1.0.0

data/lib/exa/resources/websets.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Exa
+  module Resources
+    class Websets < Base
+      require_relative "websets/monitors"
+      require_relative "websets/items"
+      require_relative "websets/enrichments"
+
+      attr_reader :monitors, :items, :enrichments
+
+      def initialize(client:)
+        super
+        @monitors = Exa::Resources::Websets::Monitors.new(client: client)
+        @items = Exa::Resources::Websets::Items.new(client: client)
+        @enrichments = Exa::Resources::Websets::Enrichments.new(client: client)
+      end
+
+      def create(params)
+        client.request(
+          method: :post,
+          path: websets_path,
+          body: params,
+          response_model: Exa::Responses::Webset
+        )
+      end
+
+      def list(params = nil)
+        client.request(
+          method: :get,
+          path: websets_path,
+          query: params,
+          response_model: Exa::Responses::WebsetListResponse
+        )
+      end
+
+      def retrieve(webset_id)
+        client.request(
+          method: :get,
+          path: websets_path(webset_id),
+          response_model: Exa::Responses::Webset
+        )
+      end
+
+      def update(webset_id, params)
+        client.request(
+          method: :patch,
+          path: websets_path(webset_id),
+          body: params,
+          response_model: Exa::Responses::Webset
+        )
+      end
+
+      def delete(webset_id)
+        client.request(
+          method: :delete,
+          path: websets_path(webset_id),
+          response_model: Exa::Responses::Webset
+        )
+      end
+
+      private
+
+      def websets_path(*parts)
+        ["v0", "websets", *parts]
+      end
+    end
+  end
+end

data/lib/exa/resources.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "resources/base"
+require_relative "resources/search"
+require_relative "resources/research"
+require_relative "resources/websets"
+require_relative "resources/events"
+require_relative "resources/webhooks"
+require_relative "resources/imports"

data/lib/exa/responses/contents_response.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    class ContentStatus < T::Struct
+      const :id, String
+      const :status, String
+      const :error, T.nilable(T::Hash[Symbol, T.untyped])
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(id: sym[:id], status: sym[:status], error: sym[:error])
+      end
+    end
+
+    class ContentsResponse < T::Struct
+      const :request_id, T.nilable(String)
+      const :results, T::Array[ResultWithContent]
+      const :context, T.nilable(String)
+      const :statuses, T.nilable(T::Array[ContentStatus])
+      const :cost_dollars, T.nilable(Float)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          request_id: sym[:requestId],
+          results: Array(sym[:results]).map { ResultWithContent.from_hash(_1) },
+          context: sym[:context],
+          statuses: sym[:statuses]&.map { ContentStatus.from_hash(_1) },
+          cost_dollars: sym[:costDollars]&.to_f
+        )
+      end
+    end
+  end
+end

data/lib/exa/responses/event_response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    class Event < T::Struct
+      const :id, String
+      const :object, T.nilable(String)
+      const :type, String
+      const :data, T.nilable(T.untyped)
+      const :created_at, T.nilable(String)
+      const :raw, T::Hash[Symbol, T.untyped]
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        data = sym[:data]
+        normalized_data = data.is_a?(Hash) ? Helpers.symbolize_keys(data) : data
+        new(
+          id: sym[:id],
+          object: sym[:object],
+          type: sym[:type],
+          data: normalized_data,
+          created_at: sym[:createdAt],
+          raw: sym
+        )
+      end
+    end
+
+    class EventListResponse < T::Struct
+      const :data, T::Array[Event]
+      const :has_more, T.nilable(T::Boolean)
+      const :next_cursor, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          data: Array(sym[:data]).map { Event.from_hash(_1) },
+          has_more: sym[:hasMore],
+          next_cursor: sym[:nextCursor]
+        )
+      end
+    end
+  end
+end

data/lib/exa/responses/helpers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    module Helpers
+      module_function
+
+      def symbolize_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(k, v), acc|
+            acc[k.to_sym] = symbolize_keys(v)
+          end
+        when Array
+          value.map { symbolize_keys(_1) }
+        else
+          value
+        end
+      end
+
+      def stringify_string_hash(hash)
+        return nil if hash.nil?
+        hash.each_with_object({}) do |(k, v), acc|
+          acc[k.to_s] = v
+        end
+      end
+    end
+  end
+end

data/lib/exa/responses/import_response.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    module ImportAttributes
+      module_function
+
+      def apply(base)
+        base.const :id, String
+        base.const :object, T.nilable(String)
+        base.const :status, T.nilable(String)
+        base.const :format, T.nilable(String)
+        base.const :entity, T.nilable(T.untyped)
+        base.const :title, T.nilable(String)
+        base.const :count, T.nilable(Integer)
+        base.const :metadata, T.nilable(T::Hash[String, String])
+        base.const :failed_reason, T.nilable(String)
+        base.const :failed_at, T.nilable(String)
+        base.const :failed_message, T.nilable(String)
+        base.const :created_at, T.nilable(String)
+        base.const :updated_at, T.nilable(String)
+      end
+    end
+
+    module ImportResponseHelpers
+      module_function
+
+      def build_common(sym)
+        entity = sym[:entity]
+        entity = Helpers.symbolize_keys(entity) if entity.is_a?(Hash)
+        {
+          id: sym[:id],
+          object: sym[:object],
+          status: sym[:status],
+          format: sym[:format],
+          entity: entity,
+          title: sym[:title],
+          count: sym[:count]&.to_i,
+          metadata: Helpers.stringify_string_hash(sym[:metadata]),
+          failed_reason: sym[:failedReason],
+          failed_at: sym[:failedAt],
+          failed_message: sym[:failedMessage],
+          created_at: sym[:createdAt],
+          updated_at: sym[:updatedAt]
+        }
+      end
+    end
+
+    class Import < T::Struct
+      ImportAttributes.apply(self)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(**ImportResponseHelpers.build_common(sym))
+      end
+    end
+
+    class ImportCreationResponse < T::Struct
+      ImportAttributes.apply(self)
+      const :upload_url, T.nilable(String)
+      const :upload_valid_until, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        attrs = ImportResponseHelpers.build_common(sym).merge(
+          upload_url: sym[:uploadUrl],
+          upload_valid_until: sym[:uploadValidUntil]
+        )
+        new(**attrs)
+      end
+    end
+
+    class ImportListResponse < T::Struct
+      const :data, T::Array[Import]
+      const :has_more, T.nilable(T::Boolean)
+      const :next_cursor, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          data: Array(sym[:data]).map { Import.from_hash(_1) },
+          has_more: sym[:hasMore],
+          next_cursor: sym[:nextCursor]
+        )
+      end
+    end
+
+    ImportResponse = T.type_alias { T.any(Import, ImportCreationResponse) }
+  end
+end

data/lib/exa/responses/monitor_response.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    class Monitor < T::Struct
+      const :id, String
+      const :status, T.nilable(String)
+      const :webset_id, T.nilable(String)
+      const :cadence, T.nilable(T::Hash[Symbol, T.untyped])
+      const :behavior, T.nilable(T::Hash[Symbol, T.untyped])
+      const :search_parameters, T.nilable(T::Hash[Symbol, T.untyped])
+      const :raw, T::Hash[Symbol, T.untyped]
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          id: sym[:id],
+          status: sym[:status],
+          webset_id: sym[:websetId],
+          cadence: sym[:cadence],
+          behavior: sym[:behavior],
+          search_parameters: sym[:searchParameters],
+          raw: sym
+        )
+      end
+    end
+
+    class MonitorListResponse < T::Struct
+      const :data, T::Array[Monitor]
+      const :next_page_token, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          data: Array(sym[:data]).map { Monitor.from_hash(_1) },
+          next_page_token: sym[:nextPageToken]
+        )
+      end
+    end
+
+    class MonitorRun < T::Struct
+      const :id, String
+      const :monitor_id, T.nilable(String)
+      const :status, T.nilable(String)
+      const :run_type, T.nilable(String)
+      const :started_at, T.nilable(String)
+      const :finished_at, T.nilable(String)
+      const :raw, T::Hash[Symbol, T.untyped]
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          id: sym[:id],
+          monitor_id: sym[:monitorId],
+          status: sym[:status],
+          run_type: sym[:type] || sym[:runType],
+          started_at: sym[:startedAt],
+          finished_at: sym[:finishedAt],
+          raw: sym
+        )
+      end
+    end
+
+    class MonitorRunListResponse < T::Struct
+      const :data, T::Array[MonitorRun]
+      const :next_page_token, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          data: Array(sym[:data]).map { MonitorRun.from_hash(_1) },
+          next_page_token: sym[:nextPageToken]
+        )
+      end
+    end
+  end
+end

data/lib/exa/responses/raw_response.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    class RawResponse < T::Struct
+      const :raw, T::Hash[Symbol, T.untyped]
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(raw: sym)
+      end
+    end
+  end
+end

data/lib/exa/responses/research_response.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    class Research < T::Struct
+      const :id, String
+      const :model, T.nilable(String)
+      const :instructions, T.nilable(String)
+      const :status, T.nilable(String)
+      const :created_at, T.nilable(Integer)
+      const :events, T::Array[T.untyped]
+      const :operations, T::Array[T.untyped]
+      const :output, T.nilable(T::Hash[Symbol, T.untyped])
+      const :error, T.nilable(String)
+      const :raw, T::Hash[Symbol, T.untyped]
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          id: sym[:researchId],
+          model: sym[:model],
+          instructions: sym[:instructions],
+          status: sym[:status],
+          created_at: sym[:createdAt]&.to_i,
+          events: Array(sym[:events]),
+          operations: Array(sym[:operations]),
+          output: normalize_hash(sym[:output]),
+          error: sym[:error],
+          raw: sym
+        )
+      end
+
+      def self.normalize_hash(value)
+        return nil if value.nil?
+        value.each_with_object({}) do |(k, v), acc|
+          acc[k.to_sym] = v
+        end
+      end
+    end
+
+    class ResearchListResponse < T::Struct
+      const :data, T::Array[Research]
+      const :has_more, T.nilable(T::Boolean)
+      const :next_cursor, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          data: Array(sym[:data]).map { Research.from_hash(_1) },
+          has_more: sym[:hasMore],
+          next_cursor: sym[:nextCursor]
+        )
+      end
+    end
+  end
+end

data/lib/exa/responses/result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    module ResultProps
+      def self.included(base)
+        base.const :title, T.nilable(String)
+        base.const :url, T.nilable(String)
+        base.const :published_date, T.nilable(String)
+        base.const :author, T.nilable(String)
+        base.const :score, T.nilable(Float)
+        base.const :id, T.nilable(String)
+        base.const :image, T.nilable(String)
+        base.const :favicon, T.nilable(String)
+      end
+    end
+
+    class Result < T::Struct
+      include ResultProps
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          title: sym[:title],
+          url: sym[:url],
+          published_date: sym[:publishedDate],
+          author: sym[:author],
+          score: sym[:score]&.to_f,
+          id: sym[:id],
+          image: sym[:image],
+          favicon: sym[:favicon]
+        )
+      end
+    end
+
+    class ResultWithContent < T::Struct
+      include ResultProps
+      const :text, T.nilable(String)
+      const :highlights, T.nilable(T::Array[String])
+      const :highlight_scores, T.nilable(T::Array[Float])
+      const :summary, T.nilable(String)
+      const :subpages, T.nilable(T::Array[Result])
+      const :extras, T.nilable(T::Hash[String, T.untyped])
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        base = Result.from_hash(sym)
+        attrs = base.serialize.transform_keys { _1.to_sym }
+        attrs = attrs.merge(
+          text: sym[:text],
+          highlights: sym[:highlights],
+          highlight_scores: sym[:highlightScores]&.map(&:to_f),
+          summary: sym[:summary],
+          subpages: sym[:subpages]&.map { ResultWithContent.from_hash(_1) },
+          extras: sym[:extras]
+        )
+        new(**attrs)
+      end
+    end
+  end
+end

data/lib/exa/responses/search_response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    class SearchResponse < T::Struct
+      const :request_id, T.nilable(String)
+      const :resolved_search_type, T.nilable(String)
+      const :search_type, T.nilable(String)
+      const :results, T::Array[ResultWithContent]
+      const :context, T.nilable(String)
+      const :cost_dollars, T.nilable(Float)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          request_id: sym[:requestId],
+          resolved_search_type: sym[:resolvedSearchType],
+          search_type: sym[:searchType],
+          results: Array(sym[:results]).map { ResultWithContent.from_hash(_1) },
+          context: sym[:context],
+          cost_dollars: sym[:costDollars]&.to_f
+        )
+      end
+    end
+
+    class FindSimilarResponse < T::Struct
+      const :request_id, T.nilable(String)
+      const :results, T::Array[ResultWithContent]
+      const :context, T.nilable(String)
+      const :cost_dollars, T.nilable(Float)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          request_id: sym[:requestId],
+          results: Array(sym[:results]).map { ResultWithContent.from_hash(_1) },
+          context: sym[:context],
+          cost_dollars: sym[:costDollars]&.to_f
+        )
+      end
+    end
+  end
+end

data/lib/exa/responses/webhook_response.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Exa
+  module Responses
+    class Webhook < T::Struct
+      const :id, String
+      const :object, T.nilable(String)
+      const :status, T.nilable(String)
+      const :events, T::Array[String]
+      const :url, T.nilable(String)
+      const :secret, T.nilable(String)
+      const :metadata, T.nilable(T::Hash[String, String])
+      const :created_at, T.nilable(String)
+      const :updated_at, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          id: sym[:id],
+          object: sym[:object],
+          status: sym[:status],
+          events: Array(sym[:events]).map(&:to_s),
+          url: sym[:url],
+          secret: sym[:secret],
+          metadata: Helpers.stringify_string_hash(sym[:metadata]),
+          created_at: sym[:createdAt],
+          updated_at: sym[:updatedAt]
+        )
+      end
+    end
+
+    class WebhookListResponse < T::Struct
+      const :data, T::Array[Webhook]
+      const :has_more, T.nilable(T::Boolean)
+      const :next_cursor, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          data: Array(sym[:data]).map { Webhook.from_hash(_1) },
+          has_more: sym[:hasMore],
+          next_cursor: sym[:nextCursor]
+        )
+      end
+    end
+
+    class WebhookAttempt < T::Struct
+      const :id, String
+      const :object, T.nilable(String)
+      const :event_id, T.nilable(String)
+      const :event_type, T.nilable(String)
+      const :webhook_id, T.nilable(String)
+      const :url, T.nilable(String)
+      const :successful, T.nilable(T::Boolean)
+      const :response_headers, T.nilable(T::Hash[String, String])
+      const :response_body, T.nilable(String)
+      const :response_status_code, T.nilable(Integer)
+      const :attempt, T.nilable(Integer)
+      const :attempted_at, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          id: sym[:id],
+          object: sym[:object],
+          event_id: sym[:eventId],
+          event_type: sym[:eventType],
+          webhook_id: sym[:webhookId],
+          url: sym[:url],
+          successful: sym[:successful],
+          response_headers: Helpers.stringify_string_hash(sym[:responseHeaders]),
+          response_body: sym[:responseBody],
+          response_status_code: sym[:responseStatusCode]&.to_i,
+          attempt: sym[:attempt]&.to_i,
+          attempted_at: sym[:attemptedAt]
+        )
+      end
+    end
+
+    class WebhookAttemptListResponse < T::Struct
+      const :data, T::Array[WebhookAttempt]
+      const :has_more, T.nilable(T::Boolean)
+      const :next_cursor, T.nilable(String)
+
+      def self.from_hash(hash)
+        sym = Helpers.symbolize_keys(hash)
+        new(
+          data: Array(sym[:data]).map { WebhookAttempt.from_hash(_1) },
+          has_more: sym[:hasMore],
+          next_cursor: sym[:nextCursor]
+        )
+      end
+    end
+  end
+end