apologist 1.0.2

data/lib/Apologist/chat/client.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    class Client
+      # @param client [Apologist::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Returns a paginated list of chat completions (prompts) for the agent, with applied tags expanded as { id, name }
+      # and share metadata.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [Integer, nil] :page
+      # @option params [Integer, nil] :per_page
+      # @option params [String, nil] :agent_id
+      # @option params [String, nil] :channel_id
+      # @option params [String, nil] :bible_id
+      # @option params [String, nil] :cached
+      # @option params [String, nil] :client
+      # @option params [String, nil] :config_id
+      # @option params [String, nil] :conversation_id
+      # @option params [String, nil] :device_id
+      # @option params [String, nil] :flagged
+      # @option params [String, nil] :favorited
+      # @option params [String, nil] :language
+      # @option params [String, nil] :liked
+      # @option params [String, nil] :session_id
+      # @option params [String, nil] :user_id
+      # @option params [String, nil] :min_timestamp
+      # @option params [String, nil] :max_timestamp
+      #
+      # @example
+      #   client.chat.list_chat_completions
+      #
+      # @return [Apologist::Chat::Types::ListChatCompletionsResponse]
+      def list_chat_completions(request_options: {}, **params)
+        params = Apologist::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["page"] = params[:page] if params.key?(:page)
+        query_params["per_page"] = params[:per_page] if params.key?(:per_page)
+        query_params["agent_id"] = params[:agent_id] if params.key?(:agent_id)
+        query_params["channel_id"] = params[:channel_id] if params.key?(:channel_id)
+        query_params["bible_id"] = params[:bible_id] if params.key?(:bible_id)
+        query_params["cached"] = params[:cached] if params.key?(:cached)
+        query_params["client"] = params[:client] if params.key?(:client)
+        query_params["config_id"] = params[:config_id] if params.key?(:config_id)
+        query_params["conversation_id"] = params[:conversation_id] if params.key?(:conversation_id)
+        query_params["device_id"] = params[:device_id] if params.key?(:device_id)
+        query_params["flagged"] = params[:flagged] if params.key?(:flagged)
+        query_params["favorited"] = params[:favorited] if params.key?(:favorited)
+        query_params["language"] = params[:language] if params.key?(:language)
+        query_params["liked"] = params[:liked] if params.key?(:liked)
+        query_params["session_id"] = params[:session_id] if params.key?(:session_id)
+        query_params["user_id"] = params[:user_id] if params.key?(:user_id)
+        query_params["min_timestamp"] = params[:min_timestamp] if params.key?(:min_timestamp)
+        query_params["max_timestamp"] = params[:max_timestamp] if params.key?(:max_timestamp)
+
+        request = Apologist::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "chat/completions",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Apologist::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Apologist::Chat::Types::ListChatCompletionsResponse.load(response.body)
+        else
+          error_class = Apologist::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Creates a chat completion using the agent's configured model. Supports both streaming and non-streaming
+      # responses.
+      #
+      # @param request_options [Hash]
+      # @param params [Apologist::Types::ChatCompletionRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.chat.create_chat_completion(request: {
+      #     key: "value"
+      #   })
+      #
+      # @return [Apologist::Types::ChatCompletionResponse]
+      def create_chat_completion(request_options: {}, **params)
+        params = Apologist::Internal::Types::Utils.normalize_keys(params)
+        request = Apologist::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "chat/completions",
+          body: Apologist::Types::ChatCompletionRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Apologist::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Apologist::Types::ChatCompletionResponse.load(response.body)
+        else
+          error_class = Apologist::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Updates the like status of a specific chat completion
+      #
+      # @param request_options [Hash]
+      # @param params [Apologist::Chat::Types::LikeRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.chat.like_completion(
+      #     id: "id",
+      #     liked: true
+      #   )
+      #
+      # @return [Apologist::Types::SuccessResponse]
+      def like_completion(request_options: {}, **params)
+        params = Apologist::Internal::Types::Utils.normalize_keys(params)
+        request_data = Apologist::Chat::Types::LikeRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Apologist::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "chat/completions/#{URI.encode_uri_component(params[:id].to_s)}/like",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Apologist::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Apologist::Types::SuccessResponse.load(response.body)
+        else
+          error_class = Apologist::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Updates the flagged status of a specific chat completion
+      #
+      # @param request_options [Hash]
+      # @param params [Apologist::Chat::Types::FlagRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.chat.flag_completion(
+      #     id: "id",
+      #     flagged: true
+      #   )
+      #
+      # @return [Apologist::Types::SuccessResponse]
+      def flag_completion(request_options: {}, **params)
+        params = Apologist::Internal::Types::Utils.normalize_keys(params)
+        request_data = Apologist::Chat::Types::FlagRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Apologist::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "chat/completions/#{URI.encode_uri_component(params[:id].to_s)}/flag",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Apologist::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Apologist::Types::SuccessResponse.load(response.body)
+        else
+          error_class = Apologist::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Adds user feedback to a specific chat completion
+      #
+      # @param request_options [Hash]
+      # @param params [Apologist::Chat::Types::FeedbackRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.chat.feedback_completion(
+      #     id: "id",
+      #     feedback: "feedback"
+      #   )
+      #
+      # @return [Apologist::Types::SuccessResponse]
+      def feedback_completion(request_options: {}, **params)
+        params = Apologist::Internal::Types::Utils.normalize_keys(params)
+        request_data = Apologist::Chat::Types::FeedbackRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Apologist::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "chat/completions/#{URI.encode_uri_component(params[:id].to_s)}/feedback",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Apologist::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Apologist::Types::SuccessResponse.load(response.body)
+        else
+          error_class = Apologist::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Creates a share record for a specific chat completion
+      #
+      # @param request_options [Hash]
+      # @param params [Apologist::Chat::Types::ShareRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.chat.share_completion(id: "id")
+      #
+      # @return [Apologist::Types::SuccessResponse]
+      def share_completion(request_options: {}, **params)
+        params = Apologist::Internal::Types::Utils.normalize_keys(params)
+        request_data = Apologist::Chat::Types::ShareRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Apologist::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "chat/completions/#{URI.encode_uri_component(params[:id].to_s)}/share",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Apologist::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Apologist::Types::SuccessResponse.load(response.body)
+        else
+          error_class = Apologist::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Returns a single chat completion (prompt) by numeric id or UUID, including applied tags, guardrail/cta metadata,
+      # share metadata, and automation results.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.chat.get_chat_completion(id: "id")
+      #
+      # @return [Apologist::Chat::Types::GetChatCompletionResponse]
+      def get_chat_completion(request_options: {}, **params)
+        params = Apologist::Internal::Types::Utils.normalize_keys(params)
+        request = Apologist::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "chat/completions/#{URI.encode_uri_component(params[:id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Apologist::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Apologist::Chat::Types::GetChatCompletionResponse.load(response.body)
+        else
+          error_class = Apologist::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/Apologist/chat/types/feedback_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    module Types
+      class FeedbackRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :feedback, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Apologist/chat/types/flag_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    module Types
+      class FlagRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :flagged, -> { Internal::Types::Boolean }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Apologist/chat/types/get_chat_completion_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    module Types
+      class GetChatCompletionRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Apologist/chat/types/get_chat_completion_response.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    module Types
+      class GetChatCompletionResponse < Internal::Types::Model
+        field :data, -> { Internal::Types::Hash[String, Object] }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/Apologist/chat/types/like_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    module Types
+      class LikeRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :liked, -> { Internal::Types::Boolean }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Apologist/chat/types/list_chat_completions_request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    module Types
+      class ListChatCompletionsRequest < Internal::Types::Model
+        field :page, -> { Integer }, optional: true, nullable: false
+
+        field :per_page, -> { Integer }, optional: true, nullable: false
+
+        field :agent_id, -> { String }, optional: true, nullable: false
+
+        field :channel_id, -> { String }, optional: true, nullable: false
+
+        field :bible_id, -> { String }, optional: true, nullable: false
+
+        field :cached, -> { String }, optional: true, nullable: false
+
+        field :client, -> { String }, optional: true, nullable: false
+
+        field :config_id, -> { String }, optional: true, nullable: false
+
+        field :conversation_id, -> { String }, optional: true, nullable: false
+
+        field :device_id, -> { String }, optional: true, nullable: false
+
+        field :flagged, -> { String }, optional: true, nullable: false
+
+        field :favorited, -> { String }, optional: true, nullable: false
+
+        field :language, -> { String }, optional: true, nullable: false
+
+        field :liked, -> { String }, optional: true, nullable: false
+
+        field :session_id, -> { String }, optional: true, nullable: false
+
+        field :user_id, -> { String }, optional: true, nullable: false
+
+        field :min_timestamp, -> { String }, optional: true, nullable: false
+
+        field :max_timestamp, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/Apologist/chat/types/list_chat_completions_response.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    module Types
+      class ListChatCompletionsResponse < Internal::Types::Model
+        field :data, -> { Internal::Types::Array[Internal::Types::Hash[String, Object]] }, optional: true, nullable: false
+
+        field :total, -> { Integer }, optional: true, nullable: false
+
+        field :page, -> { Integer }, optional: true, nullable: false
+
+        field :per_page, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/Apologist/chat/types/share_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Apologist
+  module Chat
+    module Types
+      class ShareRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :conversation_id, -> { String }, optional: true, nullable: false
+
+        field :session_id, -> { String }, optional: true, nullable: false
+
+        field :user_id, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/Apologist/client.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Apologist
+  class AgentClient
+    # @param api_key [String]
+    # @param base_url [String, nil]
+    # @param domain [String, nil]
+    # @param max_retries [Integer]
+    #
+    # @return [void]
+    def initialize(api_key:, base_url: nil, domain: nil, max_retries: 2)
+      unless domain.nil?
+        domain_value = domain.nil? ? "your-agent-domain.com" : domain
+        environment_url_templates = {
+          Apologist::Environment::DEFAULT => "https://#{domain_value}/api/v1"
+        }
+        base_url = base_url.nil? ? "https://#{domain_value}/api/v1" : environment_url_templates.fetch(base_url, base_url)
+      end
+
+      @raw_client = Apologist::Internal::Http::RawClient.new(
+        base_url: base_url || Apologist::Environment::DEFAULT,
+        headers: {
+          "User-Agent" => "apologist/0.0.5",
+          "X-Fern-Language" => "Ruby",
+          "x-api-key" => api_key.to_s
+        },
+        max_retries: max_retries
+      )
+    end
+
+    # @return [Apologist::Chat::Client]
+    def chat
+      @chat ||= Apologist::Chat::Client.new(client: @raw_client)
+    end
+
+    # @return [Apologist::Corpus::Client]
+    def corpus
+      @corpus ||= Apologist::Corpus::Client.new(client: @raw_client)
+    end
+
+    # @return [Apologist::Evaluators::Client]
+    def evaluators
+      @evaluators ||= Apologist::Evaluators::Client.new(client: @raw_client)
+    end
+
+    # @return [Apologist::CtAs::Client]
+    def ct_as
+      @ct_as ||= Apologist::CtAs::Client.new(client: @raw_client)
+    end
+
+    # @return [Apologist::Users::Client]
+    def users
+      @users ||= Apologist::Users::Client.new(client: @raw_client)
+    end
+
+    # @return [Apologist::Benchmarks::Client]
+    def benchmarks
+      @benchmarks ||= Apologist::Benchmarks::Client.new(client: @raw_client)
+    end
+
+    # @return [Apologist::Channels::Client]
+    def channels
+      @channels ||= Apologist::Channels::Client.new(client: @raw_client)
+    end
+
+    # @return [Apologist::Shares::Client]
+    def shares
+      @shares ||= Apologist::Shares::Client.new(client: @raw_client)
+    end
+  end
+end