deeprails 0.10.0 → 0.12.0

data/rbi/deeprails/models/monitor_event_detail_response.rbi

@@ -0,0 +1,383 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class MonitorEventDetailResponse < Deeprails::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::MonitorEventDetailResponse,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      # The capabilities associated with the monitor event.
+      sig do
+        returns(
+          T.nilable(T::Array[Deeprails::MonitorEventDetailResponse::Capability])
+        )
+      end
+      attr_reader :capabilities
+
+      sig do
+        params(
+          capabilities:
+            T::Array[Deeprails::MonitorEventDetailResponse::Capability::OrHash]
+        ).void
+      end
+      attr_writer :capabilities
+
+      # The time spent on the evaluation in seconds.
+      sig { returns(T.nilable(String)) }
+      attr_reader :eval_time
+
+      sig { params(eval_time: String).void }
+      attr_writer :eval_time
+
+      # The result of the evaluation of the monitor event.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :evaluation_result
+
+      sig { params(evaluation_result: T::Hash[Symbol, T.anything]).void }
+      attr_writer :evaluation_result
+
+      # A unique monitor event ID.
+      sig { returns(T.nilable(String)) }
+      attr_reader :event_id
+
+      sig { params(event_id: String).void }
+      attr_writer :event_id
+
+      # The files associated with the monitor event.
+      sig do
+        returns(
+          T.nilable(T::Array[Deeprails::MonitorEventDetailResponse::File])
+        )
+      end
+      attr_reader :files
+
+      sig do
+        params(
+          files: T::Array[Deeprails::MonitorEventDetailResponse::File::OrHash]
+        ).void
+      end
+      attr_writer :files
+
+      # The guardrail metrics evaluated by the monitor event.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :guardrail_metrics
+
+      sig { params(guardrail_metrics: T::Array[String]).void }
+      attr_writer :guardrail_metrics
+
+      # The model input used to create the monitor event.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :model_input
+
+      sig { params(model_input: T::Hash[Symbol, T.anything]).void }
+      attr_writer :model_input
+
+      # The output evaluated by the monitor event.
+      sig { returns(T.nilable(String)) }
+      attr_reader :model_output
+
+      sig { params(model_output: String).void }
+      attr_writer :model_output
+
+      # Monitor ID associated with this event.
+      sig { returns(T.nilable(String)) }
+      attr_reader :monitor_id
+
+      sig { params(monitor_id: String).void }
+      attr_writer :monitor_id
+
+      # A human-readable tag for the monitor event.
+      sig { returns(T.nilable(String)) }
+      attr_reader :nametag
+
+      sig { params(nametag: String).void }
+      attr_writer :nametag
+
+      # The run mode used to evaluate the monitor event.
+      sig do
+        returns(
+          T.nilable(Deeprails::MonitorEventDetailResponse::RunMode::OrSymbol)
+        )
+      end
+      attr_reader :run_mode
+
+      sig do
+        params(
+          run_mode: Deeprails::MonitorEventDetailResponse::RunMode::OrSymbol
+        ).void
+      end
+      attr_writer :run_mode
+
+      # Status of the monitor event's evaluation.
+      sig do
+        returns(
+          T.nilable(Deeprails::MonitorEventDetailResponse::Status::OrSymbol)
+        )
+      end
+      attr_reader :status
+
+      sig do
+        params(
+          status: Deeprails::MonitorEventDetailResponse::Status::OrSymbol
+        ).void
+      end
+      attr_writer :status
+
+      # The time the monitor event was created in UTC.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :timestamp
+
+      sig { params(timestamp: Time).void }
+      attr_writer :timestamp
+
+      sig do
+        params(
+          capabilities:
+            T::Array[Deeprails::MonitorEventDetailResponse::Capability::OrHash],
+          eval_time: String,
+          evaluation_result: T::Hash[Symbol, T.anything],
+          event_id: String,
+          files: T::Array[Deeprails::MonitorEventDetailResponse::File::OrHash],
+          guardrail_metrics: T::Array[String],
+          model_input: T::Hash[Symbol, T.anything],
+          model_output: String,
+          monitor_id: String,
+          nametag: String,
+          run_mode: Deeprails::MonitorEventDetailResponse::RunMode::OrSymbol,
+          status: Deeprails::MonitorEventDetailResponse::Status::OrSymbol,
+          timestamp: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The capabilities associated with the monitor event.
+        capabilities: nil,
+        # The time spent on the evaluation in seconds.
+        eval_time: nil,
+        # The result of the evaluation of the monitor event.
+        evaluation_result: nil,
+        # A unique monitor event ID.
+        event_id: nil,
+        # The files associated with the monitor event.
+        files: nil,
+        # The guardrail metrics evaluated by the monitor event.
+        guardrail_metrics: nil,
+        # The model input used to create the monitor event.
+        model_input: nil,
+        # The output evaluated by the monitor event.
+        model_output: nil,
+        # Monitor ID associated with this event.
+        monitor_id: nil,
+        # A human-readable tag for the monitor event.
+        nametag: nil,
+        # The run mode used to evaluate the monitor event.
+        run_mode: nil,
+        # Status of the monitor event's evaluation.
+        status: nil,
+        # The time the monitor event was created in UTC.
+        timestamp: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            capabilities:
+              T::Array[Deeprails::MonitorEventDetailResponse::Capability],
+            eval_time: String,
+            evaluation_result: T::Hash[Symbol, T.anything],
+            event_id: String,
+            files: T::Array[Deeprails::MonitorEventDetailResponse::File],
+            guardrail_metrics: T::Array[String],
+            model_input: T::Hash[Symbol, T.anything],
+            model_output: String,
+            monitor_id: String,
+            nametag: String,
+            run_mode: Deeprails::MonitorEventDetailResponse::RunMode::OrSymbol,
+            status: Deeprails::MonitorEventDetailResponse::Status::OrSymbol,
+            timestamp: Time
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Capability < Deeprails::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Deeprails::MonitorEventDetailResponse::Capability,
+              Deeprails::Internal::AnyHash
+            )
+          end
+
+        # The type of capability.
+        sig { returns(T.nilable(String)) }
+        attr_reader :capability
+
+        sig { params(capability: String).void }
+        attr_writer :capability
+
+        sig { params(capability: String).returns(T.attached_class) }
+        def self.new(
+          # The type of capability.
+          capability: nil
+        )
+        end
+
+        sig { override.returns({ capability: String }) }
+        def to_hash
+        end
+      end
+
+      class File < Deeprails::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Deeprails::MonitorEventDetailResponse::File,
+              Deeprails::Internal::AnyHash
+            )
+          end
+
+        # The ID of the file.
+        sig { returns(T.nilable(String)) }
+        attr_reader :file_id
+
+        sig { params(file_id: String).void }
+        attr_writer :file_id
+
+        # The name of the file.
+        sig { returns(T.nilable(String)) }
+        attr_reader :file_name
+
+        sig { params(file_name: String).void }
+        attr_writer :file_name
+
+        # The size of the file in bytes.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :file_size
+
+        sig { params(file_size: Integer).void }
+        attr_writer :file_size
+
+        sig do
+          params(
+            file_id: String,
+            file_name: String,
+            file_size: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The ID of the file.
+          file_id: nil,
+          # The name of the file.
+          file_name: nil,
+          # The size of the file in bytes.
+          file_size: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { file_id: String, file_name: String, file_size: Integer }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      # The run mode used to evaluate the monitor event.
+      module RunMode
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::MonitorEventDetailResponse::RunMode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PRECISION_PLUS =
+          T.let(
+            :precision_plus,
+            Deeprails::MonitorEventDetailResponse::RunMode::TaggedSymbol
+          )
+        PRECISION =
+          T.let(
+            :precision,
+            Deeprails::MonitorEventDetailResponse::RunMode::TaggedSymbol
+          )
+        SMART =
+          T.let(
+            :smart,
+            Deeprails::MonitorEventDetailResponse::RunMode::TaggedSymbol
+          )
+        ECONOMY =
+          T.let(
+            :economy,
+            Deeprails::MonitorEventDetailResponse::RunMode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Deeprails::MonitorEventDetailResponse::RunMode::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Status of the monitor event's evaluation.
+      module Status
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::MonitorEventDetailResponse::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        IN_PROGRESS =
+          T.let(
+            :in_progress,
+            Deeprails::MonitorEventDetailResponse::Status::TaggedSymbol
+          )
+        COMPLETED =
+          T.let(
+            :completed,
+            Deeprails::MonitorEventDetailResponse::Status::TaggedSymbol
+          )
+        CANCELED =
+          T.let(
+            :canceled,
+            Deeprails::MonitorEventDetailResponse::Status::TaggedSymbol
+          )
+        QUEUED =
+          T.let(
+            :queued,
+            Deeprails::MonitorEventDetailResponse::Status::TaggedSymbol
+          )
+        FAILED =
+          T.let(
+            :failed,
+            Deeprails::MonitorEventDetailResponse::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Deeprails::MonitorEventDetailResponse::Status::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/deeprails/models/monitor_event_response.rbi

@@ -8,10 +8,6 @@ module Deeprails
           T.any(Deeprails::MonitorEventResponse, Deeprails::Internal::AnyHash)
         end
 
-      # A unique evaluation ID associated with this event.
-      sig { returns(String) }
-      attr_accessor :evaluation_id
-
       # A unique monitor event ID.
       sig { returns(String) }
       attr_accessor :event_id
@@ -28,16 +24,11 @@ module Deeprails
       attr_writer :created_at
 
       sig do
-        params(
-          evaluation_id: String,
-          event_id: String,
-          monitor_id: String,
-          created_at: Time
-        ).returns(T.attached_class)
+        params(event_id: String, monitor_id: String, created_at: Time).returns(
+          T.attached_class
+        )
       end
       def self.new(
-        # A unique evaluation ID associated with this event.
-        evaluation_id:,
         # A unique monitor event ID.
         event_id:,
         # Monitor ID associated with this event.
@@ -49,12 +40,7 @@ module Deeprails
 
       sig do
         override.returns(
-          {
-            evaluation_id: String,
-            event_id: String,
-            monitor_id: String,
-            created_at: Time
-          }
+          { event_id: String, monitor_id: String, created_at: Time }
         )
       end
       def to_hash

data/rbi/deeprails/models/monitor_retrieve_params.rbi

@@ -11,7 +11,8 @@ module Deeprails
           T.any(Deeprails::MonitorRetrieveParams, Deeprails::Internal::AnyHash)
         end
 
-      # Limit the returned events associated with this monitor. Defaults to 10.
+      # Limit the number of returned evaluations associated with this monitor. Defaults
+      # to 10.
       sig { returns(T.nilable(Integer)) }
       attr_reader :limit
 
@@ -25,7 +26,8 @@ module Deeprails
         ).returns(T.attached_class)
       end
       def self.new(
-        # Limit the returned events associated with this monitor. Defaults to 10.
+        # Limit the number of returned evaluations associated with this monitor. Defaults
+        # to 10.
         limit: nil,
         request_options: {}
       )

data/rbi/deeprails/models/monitor_submit_event_params.rbi

@@ -14,19 +14,6 @@ module Deeprails
           )
         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. The dictionary must
       # contain at least a `user_prompt` field or a `system_prompt` field. For
       # ground_truth_adherence guardrail metric, `ground_truth` should be provided.
@@ -44,13 +31,6 @@ module Deeprails
       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
@@ -78,32 +58,20 @@ module Deeprails
 
       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. The dictionary must
         # contain at least a `user_prompt` field or a `system_prompt` field. For
         # ground_truth_adherence guardrail metric, `ground_truth` should be provided.
         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
@@ -118,13 +86,8 @@ module Deeprails
       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
@@ -134,57 +97,6 @@ module Deeprails
       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

data/rbi/deeprails/models/monitor_update_params.rbi

@@ -18,47 +18,41 @@ module Deeprails
       sig { params(description: String).void }
       attr_writer :description
 
+      # Name of the monitor.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
       # Status of the monitor. Can be `active` or `inactive`. Inactive monitors no
       # longer record and evaluate events.
       sig do
-        returns(
-          T.nilable(Deeprails::MonitorUpdateParams::MonitorStatus::OrSymbol)
-        )
+        returns(T.nilable(Deeprails::MonitorUpdateParams::Status::OrSymbol))
       end
-      attr_reader :monitor_status
+      attr_reader :status
 
       sig do
-        params(
-          monitor_status:
-            Deeprails::MonitorUpdateParams::MonitorStatus::OrSymbol
-        ).void
+        params(status: Deeprails::MonitorUpdateParams::Status::OrSymbol).void
       end
-      attr_writer :monitor_status
-
-      # Name of the monitor.
-      sig { returns(T.nilable(String)) }
-      attr_reader :name
-
-      sig { params(name: String).void }
-      attr_writer :name
+      attr_writer :status
 
       sig do
         params(
           description: String,
-          monitor_status:
-            Deeprails::MonitorUpdateParams::MonitorStatus::OrSymbol,
           name: String,
+          status: Deeprails::MonitorUpdateParams::Status::OrSymbol,
           request_options: Deeprails::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
         # Description of the monitor.
         description: nil,
-        # Status of the monitor. Can be `active` or `inactive`. Inactive monitors no
-        # longer record and evaluate events.
-        monitor_status: nil,
         # Name of the monitor.
         name: nil,
+        # Status of the monitor. Can be `active` or `inactive`. Inactive monitors no
+        # longer record and evaluate events.
+        status: nil,
         request_options: {}
       )
       end
@@ -67,9 +61,8 @@ module Deeprails
         override.returns(
           {
             description: String,
-            monitor_status:
-              Deeprails::MonitorUpdateParams::MonitorStatus::OrSymbol,
             name: String,
+            status: Deeprails::MonitorUpdateParams::Status::OrSymbol,
             request_options: Deeprails::RequestOptions
           }
         )
@@ -79,31 +72,21 @@ module Deeprails
 
       # Status of the monitor. Can be `active` or `inactive`. Inactive monitors no
       # longer record and evaluate events.
-      module MonitorStatus
+      module Status
         extend Deeprails::Internal::Type::Enum
 
         TaggedSymbol =
-          T.type_alias do
-            T.all(Symbol, Deeprails::MonitorUpdateParams::MonitorStatus)
-          end
+          T.type_alias { T.all(Symbol, Deeprails::MonitorUpdateParams::Status) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         ACTIVE =
-          T.let(
-            :active,
-            Deeprails::MonitorUpdateParams::MonitorStatus::TaggedSymbol
-          )
+          T.let(:active, Deeprails::MonitorUpdateParams::Status::TaggedSymbol)
         INACTIVE =
-          T.let(
-            :inactive,
-            Deeprails::MonitorUpdateParams::MonitorStatus::TaggedSymbol
-          )
+          T.let(:inactive, Deeprails::MonitorUpdateParams::Status::TaggedSymbol)
 
         sig do
           override.returns(
-            T::Array[
-              Deeprails::MonitorUpdateParams::MonitorStatus::TaggedSymbol
-            ]
+            T::Array[Deeprails::MonitorUpdateParams::Status::TaggedSymbol]
           )
         end
         def self.values