deeprails 0.1.0

data/rbi/deeprails/models/monitor_retrieve_response.rbi

@@ -0,0 +1,336 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class MonitorRetrieveResponse < Deeprails::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::Models::MonitorRetrieveResponse,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      # Represents whether the request was completed successfully.
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      # Detailed response payload for retrieving a monitor and its evaluations.
+      sig do
+        returns(T.nilable(Deeprails::Models::MonitorRetrieveResponse::Data))
+      end
+      attr_reader :data
+
+      sig do
+        params(
+          data: Deeprails::Models::MonitorRetrieveResponse::Data::OrHash
+        ).void
+      end
+      attr_writer :data
+
+      # The accompanying message for the request. Includes error details when
+      # applicable.
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # Response wrapper for operations returning a MonitorDetailResponse.
+      sig do
+        params(
+          success: T::Boolean,
+          data: Deeprails::Models::MonitorRetrieveResponse::Data::OrHash,
+          message: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Represents whether the request was completed successfully.
+        success:,
+        # Detailed response payload for retrieving a monitor and its evaluations.
+        data: nil,
+        # The accompanying message for the request. Includes error details when
+        # applicable.
+        message: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            success: T::Boolean,
+            data: Deeprails::Models::MonitorRetrieveResponse::Data,
+            message: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Deeprails::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Deeprails::Models::MonitorRetrieveResponse::Data,
+              Deeprails::Internal::AnyHash
+            )
+          end
+
+        # A unique monitor ID.
+        sig { returns(String) }
+        attr_accessor :monitor_id
+
+        # Status of the monitor. Can be `active` or `inactive`. Inactive monitors no
+        # longer record and evaluate events.
+        sig do
+          returns(
+            Deeprails::Models::MonitorRetrieveResponse::Data::MonitorStatus::TaggedSymbol
+          )
+        end
+        attr_accessor :monitor_status
+
+        # Name of this monitor.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The time the monitor was created in UTC.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :created_at
+
+        sig { params(created_at: Time).void }
+        attr_writer :created_at
+
+        # Description of this monitor.
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        # An array of all evaluations performed by this monitor. Each one corresponds to a
+        # separate monitor event.
+        sig { returns(T.nilable(T::Array[Deeprails::Evaluation])) }
+        attr_reader :evaluations
+
+        sig do
+          params(evaluations: T::Array[Deeprails::Evaluation::OrHash]).void
+        end
+        attr_writer :evaluations
+
+        # Contains five fields used for stats of this monitor: total evaluations,
+        # completed evaluations, failed evaluations, queued evaluations, and in progress
+        # evaluations.
+        sig do
+          returns(
+            T.nilable(Deeprails::Models::MonitorRetrieveResponse::Data::Stats)
+          )
+        end
+        attr_reader :stats
+
+        sig do
+          params(
+            stats:
+              Deeprails::Models::MonitorRetrieveResponse::Data::Stats::OrHash
+          ).void
+        end
+        attr_writer :stats
+
+        # The most recent time the monitor was modified in UTC.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :updated_at
+
+        sig { params(updated_at: Time).void }
+        attr_writer :updated_at
+
+        # User ID of the user who created the monitor.
+        sig { returns(T.nilable(String)) }
+        attr_reader :user_id
+
+        sig { params(user_id: String).void }
+        attr_writer :user_id
+
+        # Detailed response payload for retrieving a monitor and its evaluations.
+        sig do
+          params(
+            monitor_id: String,
+            monitor_status:
+              Deeprails::Models::MonitorRetrieveResponse::Data::MonitorStatus::OrSymbol,
+            name: String,
+            created_at: Time,
+            description: String,
+            evaluations: T::Array[Deeprails::Evaluation::OrHash],
+            stats:
+              Deeprails::Models::MonitorRetrieveResponse::Data::Stats::OrHash,
+            updated_at: Time,
+            user_id: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A unique monitor ID.
+          monitor_id:,
+          # Status of the monitor. Can be `active` or `inactive`. Inactive monitors no
+          # longer record and evaluate events.
+          monitor_status:,
+          # Name of this monitor.
+          name:,
+          # The time the monitor was created in UTC.
+          created_at: nil,
+          # Description of this monitor.
+          description: nil,
+          # An array of all evaluations performed by this monitor. Each one corresponds to a
+          # separate monitor event.
+          evaluations: nil,
+          # Contains five fields used for stats of this monitor: total evaluations,
+          # completed evaluations, failed evaluations, queued evaluations, and in progress
+          # evaluations.
+          stats: nil,
+          # The most recent time the monitor was modified in UTC.
+          updated_at: nil,
+          # User ID of the user who created the monitor.
+          user_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              monitor_id: String,
+              monitor_status:
+                Deeprails::Models::MonitorRetrieveResponse::Data::MonitorStatus::TaggedSymbol,
+              name: String,
+              created_at: Time,
+              description: String,
+              evaluations: T::Array[Deeprails::Evaluation],
+              stats: Deeprails::Models::MonitorRetrieveResponse::Data::Stats,
+              updated_at: Time,
+              user_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Status of the monitor. Can be `active` or `inactive`. Inactive monitors no
+        # longer record and evaluate events.
+        module MonitorStatus
+          extend Deeprails::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Deeprails::Models::MonitorRetrieveResponse::Data::MonitorStatus
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACTIVE =
+            T.let(
+              :active,
+              Deeprails::Models::MonitorRetrieveResponse::Data::MonitorStatus::TaggedSymbol
+            )
+          INACTIVE =
+            T.let(
+              :inactive,
+              Deeprails::Models::MonitorRetrieveResponse::Data::MonitorStatus::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Deeprails::Models::MonitorRetrieveResponse::Data::MonitorStatus::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        class Stats < Deeprails::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Deeprails::Models::MonitorRetrieveResponse::Data::Stats,
+                Deeprails::Internal::AnyHash
+              )
+            end
+
+          # Number of evaluations that completed successfully.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :completed_evaluations
+
+          sig { params(completed_evaluations: Integer).void }
+          attr_writer :completed_evaluations
+
+          # Number of evaluations that failed.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :failed_evaluations
+
+          sig { params(failed_evaluations: Integer).void }
+          attr_writer :failed_evaluations
+
+          # Number of evaluations currently in progress.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :in_progress_evaluations
+
+          sig { params(in_progress_evaluations: Integer).void }
+          attr_writer :in_progress_evaluations
+
+          # Number of evaluations currently queued.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :queued_evaluations
+
+          sig { params(queued_evaluations: Integer).void }
+          attr_writer :queued_evaluations
+
+          # Total number of evaluations performed by this monitor.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :total_evaluations
+
+          sig { params(total_evaluations: Integer).void }
+          attr_writer :total_evaluations
+
+          # Contains five fields used for stats of this monitor: total evaluations,
+          # completed evaluations, failed evaluations, queued evaluations, and in progress
+          # evaluations.
+          sig do
+            params(
+              completed_evaluations: Integer,
+              failed_evaluations: Integer,
+              in_progress_evaluations: Integer,
+              queued_evaluations: Integer,
+              total_evaluations: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Number of evaluations that completed successfully.
+            completed_evaluations: nil,
+            # Number of evaluations that failed.
+            failed_evaluations: nil,
+            # Number of evaluations currently in progress.
+            in_progress_evaluations: nil,
+            # Number of evaluations currently queued.
+            queued_evaluations: nil,
+            # Total number of evaluations performed by this monitor.
+            total_evaluations: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                completed_evaluations: Integer,
+                failed_evaluations: Integer,
+                in_progress_evaluations: Integer,
+                queued_evaluations: Integer,
+                total_evaluations: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/deeprails/models/monitor_submit_event_params.rbi

@@ -0,0 +1,264 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class MonitorSubmitEventParams < Deeprails::Internal::Type::BaseModel
+      extend Deeprails::Internal::Type::RequestParameters::Converter
+      include Deeprails::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::MonitorSubmitEventParams,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      # An array of guardrail metrics that the model input and output pair will be
+      # evaluated on. For non-enterprise users, these will be limited to `correctness`,
+      # `completeness`, `instruction_adherence`, `context_adherence`,
+      # `ground_truth_adherence`, and/or `comprehensive_safety`.
+      sig do
+        returns(
+          T::Array[
+            Deeprails::MonitorSubmitEventParams::GuardrailMetric::OrSymbol
+          ]
+        )
+      end
+      attr_accessor :guardrail_metrics
+
+      # A dictionary of inputs sent to the LLM to generate output. This must contain a
+      # `user_prompt` field and an optional `context` field. Additional properties are
+      # allowed.
+      sig { returns(Deeprails::MonitorSubmitEventParams::ModelInput) }
+      attr_reader :model_input
+
+      sig do
+        params(
+          model_input: Deeprails::MonitorSubmitEventParams::ModelInput::OrHash
+        ).void
+      end
+      attr_writer :model_input
+
+      # Output generated by the LLM to be evaluated.
+      sig { returns(String) }
+      attr_accessor :model_output
+
+      # Model ID used to generate the output, like `gpt-4o` or `o3`.
+      sig { returns(T.nilable(String)) }
+      attr_reader :model_used
+
+      sig { params(model_used: String).void }
+      attr_writer :model_used
+
+      # An optional, user-defined tag for the event.
+      sig { returns(T.nilable(String)) }
+      attr_reader :nametag
+
+      sig { params(nametag: String).void }
+      attr_writer :nametag
+
+      # Run mode for the monitor event. The run mode allows the user to optimize for
+      # speed, accuracy, and cost by determining which models are used to evaluate the
+      # event. Available run modes include `precision_plus`, `precision`, `smart`, and
+      # `economy`. Defaults to `smart`.
+      sig do
+        returns(
+          T.nilable(Deeprails::MonitorSubmitEventParams::RunMode::OrSymbol)
+        )
+      end
+      attr_reader :run_mode
+
+      sig do
+        params(
+          run_mode: Deeprails::MonitorSubmitEventParams::RunMode::OrSymbol
+        ).void
+      end
+      attr_writer :run_mode
+
+      sig do
+        params(
+          guardrail_metrics:
+            T::Array[
+              Deeprails::MonitorSubmitEventParams::GuardrailMetric::OrSymbol
+            ],
+          model_input: Deeprails::MonitorSubmitEventParams::ModelInput::OrHash,
+          model_output: String,
+          model_used: String,
+          nametag: String,
+          run_mode: Deeprails::MonitorSubmitEventParams::RunMode::OrSymbol,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # An array of guardrail metrics that the model input and output pair will be
+        # evaluated on. For non-enterprise users, these will be limited to `correctness`,
+        # `completeness`, `instruction_adherence`, `context_adherence`,
+        # `ground_truth_adherence`, and/or `comprehensive_safety`.
+        guardrail_metrics:,
+        # A dictionary of inputs sent to the LLM to generate output. This must contain a
+        # `user_prompt` field and an optional `context` field. Additional properties are
+        # allowed.
+        model_input:,
+        # Output generated by the LLM to be evaluated.
+        model_output:,
+        # Model ID used to generate the output, like `gpt-4o` or `o3`.
+        model_used: nil,
+        # An optional, user-defined tag for the event.
+        nametag: nil,
+        # Run mode for the monitor event. The run mode allows the user to optimize for
+        # speed, accuracy, and cost by determining which models are used to evaluate the
+        # event. Available run modes include `precision_plus`, `precision`, `smart`, and
+        # `economy`. Defaults to `smart`.
+        run_mode: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            guardrail_metrics:
+              T::Array[
+                Deeprails::MonitorSubmitEventParams::GuardrailMetric::OrSymbol
+              ],
+            model_input: Deeprails::MonitorSubmitEventParams::ModelInput,
+            model_output: String,
+            model_used: String,
+            nametag: String,
+            run_mode: Deeprails::MonitorSubmitEventParams::RunMode::OrSymbol,
+            request_options: Deeprails::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module GuardrailMetric
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::MonitorSubmitEventParams::GuardrailMetric)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CORRECTNESS =
+          T.let(
+            :correctness,
+            Deeprails::MonitorSubmitEventParams::GuardrailMetric::TaggedSymbol
+          )
+        COMPLETENESS =
+          T.let(
+            :completeness,
+            Deeprails::MonitorSubmitEventParams::GuardrailMetric::TaggedSymbol
+          )
+        INSTRUCTION_ADHERENCE =
+          T.let(
+            :instruction_adherence,
+            Deeprails::MonitorSubmitEventParams::GuardrailMetric::TaggedSymbol
+          )
+        CONTEXT_ADHERENCE =
+          T.let(
+            :context_adherence,
+            Deeprails::MonitorSubmitEventParams::GuardrailMetric::TaggedSymbol
+          )
+        GROUND_TRUTH_ADHERENCE =
+          T.let(
+            :ground_truth_adherence,
+            Deeprails::MonitorSubmitEventParams::GuardrailMetric::TaggedSymbol
+          )
+        COMPREHENSIVE_SAFETY =
+          T.let(
+            :comprehensive_safety,
+            Deeprails::MonitorSubmitEventParams::GuardrailMetric::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Deeprails::MonitorSubmitEventParams::GuardrailMetric::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class ModelInput < Deeprails::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Deeprails::MonitorSubmitEventParams::ModelInput,
+              Deeprails::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :user_prompt
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :context
+
+        sig { params(context: String).void }
+        attr_writer :context
+
+        # A dictionary of inputs sent to the LLM to generate output. This must contain a
+        # `user_prompt` field and an optional `context` field. Additional properties are
+        # allowed.
+        sig do
+          params(user_prompt: String, context: String).returns(T.attached_class)
+        end
+        def self.new(user_prompt:, context: nil)
+        end
+
+        sig { override.returns({ user_prompt: String, context: String }) }
+        def to_hash
+        end
+      end
+
+      # Run mode for the monitor event. The run mode allows the user to optimize for
+      # speed, accuracy, and cost by determining which models are used to evaluate the
+      # event. Available run modes include `precision_plus`, `precision`, `smart`, and
+      # `economy`. Defaults to `smart`.
+      module RunMode
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::MonitorSubmitEventParams::RunMode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PRECISION_PLUS =
+          T.let(
+            :precision_plus,
+            Deeprails::MonitorSubmitEventParams::RunMode::TaggedSymbol
+          )
+        PRECISION =
+          T.let(
+            :precision,
+            Deeprails::MonitorSubmitEventParams::RunMode::TaggedSymbol
+          )
+        SMART =
+          T.let(
+            :smart,
+            Deeprails::MonitorSubmitEventParams::RunMode::TaggedSymbol
+          )
+        ECONOMY =
+          T.let(
+            :economy,
+            Deeprails::MonitorSubmitEventParams::RunMode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Deeprails::MonitorSubmitEventParams::RunMode::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end