deeprails 0.18.0 → 0.23.0

data/rbi/deeprails/models/defend_response.rbi

@@ -20,8 +20,8 @@ module Deeprails
       end
       attr_accessor :automatic_hallucination_tolerance_levels
 
-      # Extended AI capabilities available to the event, if any. Can be `web_search`
-      # and/or `file_search`.
+      # Extended AI capabilities available to the event, if any. Can be `web_search`,
+      # `file_search`, and/or `context_awareness`.
       sig { returns(T::Array[Deeprails::DefendResponse::Capability]) }
       attr_accessor :capabilities
 
@@ -119,8 +119,8 @@ module Deeprails
         # Mapping of guardrail metric names to tolerance values. Values can be strings
         # (`low`, `medium`, `high`) for automatic tolerance levels.
         automatic_hallucination_tolerance_levels:,
-        # Extended AI capabilities available to the event, if any. Can be `web_search`
-        # and/or `file_search`.
+        # Extended AI capabilities available to the event, if any. Can be `web_search`,
+        # `file_search`, and/or `context_awareness`.
         capabilities:,
         # The time the workflow was created in UTC.
         created_at:,
@@ -254,6 +254,13 @@ module Deeprails
             )
           end
 
+        # The ID of the billing request for the event.
+        sig { returns(T.nilable(String)) }
+        attr_reader :billing_request_id
+
+        sig { params(billing_request_id: String).void }
+        attr_writer :billing_request_id
+
         # An array of evaluations for this event.
         sig do
           returns(
@@ -284,42 +291,88 @@ module Deeprails
         sig { params(improved_model_output: String).void }
         attr_writer :improved_model_output
 
-        # Status of the improvement tool used to improve the event.
-        sig { returns(T.nilable(String)) }
+        # Status of the improvement tool used to improve the event. `improvement_required`
+        # indicates that the evaluation is complete and the improvement action is needed
+        # but is not taking place. `improved` and `improvement_failed` indicate when the
+        # improvement action concludes, successfully and unsuccessfully, respectively.
+        # `no_improvement_required` means that the first evaluation passed all its
+        # metrics!
+        sig do
+          returns(
+            T.nilable(
+              Deeprails::DefendResponse::Event::ImprovementToolStatus::TaggedSymbol
+            )
+          )
+        end
         attr_reader :improvement_tool_status
 
-        sig { params(improvement_tool_status: String).void }
+        sig do
+          params(
+            improvement_tool_status:
+              Deeprails::DefendResponse::Event::ImprovementToolStatus::OrSymbol
+          ).void
+        end
         attr_writer :improvement_tool_status
 
+        # Status of the event.
+        sig do
+          returns(
+            T.nilable(Deeprails::DefendResponse::Event::Status::TaggedSymbol)
+          )
+        end
+        attr_reader :status
+
+        sig do
+          params(
+            status: Deeprails::DefendResponse::Event::Status::OrSymbol
+          ).void
+        end
+        attr_writer :status
+
         sig do
           params(
+            billing_request_id: String,
             evaluations:
               T::Array[Deeprails::DefendResponse::Event::Evaluation::OrHash],
             event_id: String,
             improved_model_output: String,
-            improvement_tool_status: String
+            improvement_tool_status:
+              Deeprails::DefendResponse::Event::ImprovementToolStatus::OrSymbol,
+            status: Deeprails::DefendResponse::Event::Status::OrSymbol
           ).returns(T.attached_class)
         end
         def self.new(
+          # The ID of the billing request for the event.
+          billing_request_id: nil,
           # An array of evaluations for this event.
           evaluations: nil,
           # A unique workflow event ID.
           event_id: nil,
           # Improved model output after improvement tool was applied.
           improved_model_output: nil,
-          # Status of the improvement tool used to improve the event.
-          improvement_tool_status: nil
+          # Status of the improvement tool used to improve the event. `improvement_required`
+          # indicates that the evaluation is complete and the improvement action is needed
+          # but is not taking place. `improved` and `improvement_failed` indicate when the
+          # improvement action concludes, successfully and unsuccessfully, respectively.
+          # `no_improvement_required` means that the first evaluation passed all its
+          # metrics!
+          improvement_tool_status: nil,
+          # Status of the event.
+          status: nil
         )
         end
 
         sig do
           override.returns(
             {
+              billing_request_id: String,
               evaluations:
                 T::Array[Deeprails::DefendResponse::Event::Evaluation],
               event_id: String,
               improved_model_output: String,
-              improvement_tool_status: String
+              improvement_tool_status:
+                Deeprails::DefendResponse::Event::ImprovementToolStatus::TaggedSymbol,
+              status: Deeprails::DefendResponse::Event::Status::TaggedSymbol
             }
           )
         end
@@ -335,6 +388,14 @@ module Deeprails
               )
             end
 
+          # Analysis of the failures of the model_output according to the guardrail metrics
+          # evaluated.
+          sig { returns(T.nilable(String)) }
+          attr_reader :analysis_of_failures
+
+          sig { params(analysis_of_failures: String).void }
+          attr_writer :analysis_of_failures
+
           # The attempt number or identifier for this evaluation.
           sig { returns(T.nilable(String)) }
           attr_reader :attempt
@@ -384,6 +445,36 @@ module Deeprails
           sig { params(guardrail_metrics: T::Array[String]).void }
           attr_writer :guardrail_metrics
 
+          # Status of the improvement tool used to improve the event. `improvement_required`
+          # indicates that the evaluation is complete and the improvement action is needed
+          # but is not taking place. `improved` and `improvement_failed` indicate when the
+          # improvement action concludes, successfully and unsuccessfully, respectively.
+          # `no_improvement_required` means that the first evaluation passed all its
+          # metrics!
+          sig do
+            returns(
+              T.nilable(
+                Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :improvement_tool_status
+
+          sig do
+            params(
+              improvement_tool_status:
+                Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::OrSymbol
+            ).void
+          end
+          attr_writer :improvement_tool_status
+
+          # A list of key improvements made to the model_output to address the failures.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_reader :key_improvements
+
+          sig { params(key_improvements: T::Array[String]).void }
+          attr_writer :key_improvements
+
           # The model input used for the evaluation.
           sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
           attr_reader :model_input
@@ -428,6 +519,7 @@ module Deeprails
 
           sig do
             params(
+              analysis_of_failures: String,
               attempt: String,
               created_at: Time,
               error_message: String,
@@ -435,6 +527,9 @@ module Deeprails
               evaluation_status: String,
               evaluation_total_cost: Float,
               guardrail_metrics: T::Array[String],
+              improvement_tool_status:
+                Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::OrSymbol,
+              key_improvements: T::Array[String],
               model_input: T::Hash[Symbol, T.anything],
               model_output: String,
               modified_at: Time,
@@ -444,6 +539,9 @@ module Deeprails
             ).returns(T.attached_class)
           end
           def self.new(
+            # Analysis of the failures of the model_output according to the guardrail metrics
+            # evaluated.
+            analysis_of_failures: nil,
             # The attempt number or identifier for this evaluation.
             attempt: nil,
             # The time the evaluation was created in UTC.
@@ -458,6 +556,15 @@ module Deeprails
             evaluation_total_cost: nil,
             # An array of guardrail metrics evaluated.
             guardrail_metrics: nil,
+            # Status of the improvement tool used to improve the event. `improvement_required`
+            # indicates that the evaluation is complete and the improvement action is needed
+            # but is not taking place. `improved` and `improvement_failed` indicate when the
+            # improvement action concludes, successfully and unsuccessfully, respectively.
+            # `no_improvement_required` means that the first evaluation passed all its
+            # metrics!
+            improvement_tool_status: nil,
+            # A list of key improvements made to the model_output to address the failures.
+            key_improvements: nil,
             # The model input used for the evaluation.
             model_input: nil,
             # The model output that was evaluated.
@@ -476,6 +583,7 @@ module Deeprails
           sig do
             override.returns(
               {
+                analysis_of_failures: String,
                 attempt: String,
                 created_at: Time,
                 error_message: String,
@@ -483,6 +591,9 @@ module Deeprails
                 evaluation_status: String,
                 evaluation_total_cost: Float,
                 guardrail_metrics: T::Array[String],
+                improvement_tool_status:
+                  Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::TaggedSymbol,
+                key_improvements: T::Array[String],
                 model_input: T::Hash[Symbol, T.anything],
                 model_output: String,
                 modified_at: Time,
@@ -494,6 +605,141 @@ module Deeprails
           end
           def to_hash
           end
+
+          # Status of the improvement tool used to improve the event. `improvement_required`
+          # indicates that the evaluation is complete and the improvement action is needed
+          # but is not taking place. `improved` and `improvement_failed` indicate when the
+          # improvement action concludes, successfully and unsuccessfully, respectively.
+          # `no_improvement_required` means that the first evaluation passed all its
+          # metrics!
+          module ImprovementToolStatus
+            extend Deeprails::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            IMPROVED =
+              T.let(
+                :improved,
+                Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::TaggedSymbol
+              )
+            IMPROVEMENT_FAILED =
+              T.let(
+                :improvement_failed,
+                Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::TaggedSymbol
+              )
+            NO_IMPROVEMENT_REQUIRED =
+              T.let(
+                :no_improvement_required,
+                Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::TaggedSymbol
+              )
+            IMPROVEMENT_REQUIRED =
+              T.let(
+                :improvement_required,
+                Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Deeprails::DefendResponse::Event::Evaluation::ImprovementToolStatus::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        # Status of the improvement tool used to improve the event. `improvement_required`
+        # indicates that the evaluation is complete and the improvement action is needed
+        # but is not taking place. `improved` and `improvement_failed` indicate when the
+        # improvement action concludes, successfully and unsuccessfully, respectively.
+        # `no_improvement_required` means that the first evaluation passed all its
+        # metrics!
+        module ImprovementToolStatus
+          extend Deeprails::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Deeprails::DefendResponse::Event::ImprovementToolStatus
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          IMPROVED =
+            T.let(
+              :improved,
+              Deeprails::DefendResponse::Event::ImprovementToolStatus::TaggedSymbol
+            )
+          IMPROVEMENT_FAILED =
+            T.let(
+              :improvement_failed,
+              Deeprails::DefendResponse::Event::ImprovementToolStatus::TaggedSymbol
+            )
+          NO_IMPROVEMENT_REQUIRED =
+            T.let(
+              :no_improvement_required,
+              Deeprails::DefendResponse::Event::ImprovementToolStatus::TaggedSymbol
+            )
+          IMPROVEMENT_REQUIRED =
+            T.let(
+              :improvement_required,
+              Deeprails::DefendResponse::Event::ImprovementToolStatus::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Deeprails::DefendResponse::Event::ImprovementToolStatus::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # Status of the event.
+        module Status
+          extend Deeprails::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Deeprails::DefendResponse::Event::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          COMPLETED =
+            T.let(
+              :completed,
+              Deeprails::DefendResponse::Event::Status::TaggedSymbol
+            )
+          FAILED =
+            T.let(
+              :failed,
+              Deeprails::DefendResponse::Event::Status::TaggedSymbol
+            )
+          IN_PROGRESS =
+            T.let(
+              :in_progress,
+              Deeprails::DefendResponse::Event::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Deeprails::DefendResponse::Event::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
         end
       end
 
@@ -521,19 +767,45 @@ module Deeprails
         sig { params(file_size: Integer).void }
         attr_writer :file_size
 
+        sig { returns(T.nilable(String)) }
+        attr_reader :presigned_url
+
+        sig { params(presigned_url: String).void }
+        attr_writer :presigned_url
+
+        sig { returns(T.nilable(Time)) }
+        attr_reader :presigned_url_expires_at
+
+        sig { params(presigned_url_expires_at: Time).void }
+        attr_writer :presigned_url_expires_at
+
         sig do
           params(
             file_id: String,
             file_name: String,
-            file_size: Integer
+            file_size: Integer,
+            presigned_url: String,
+            presigned_url_expires_at: Time
           ).returns(T.attached_class)
         end
-        def self.new(file_id: nil, file_name: nil, file_size: nil)
+        def self.new(
+          file_id: nil,
+          file_name: nil,
+          file_size: nil,
+          presigned_url: nil,
+          presigned_url_expires_at: nil
+        )
         end
 
         sig do
           override.returns(
-            { file_id: String, file_name: String, file_size: Integer }
+            {
+              file_id: String,
+              file_name: String,
+              file_size: Integer,
+              presigned_url: String,
+              presigned_url_expires_at: Time
+            }
           )
         end
         def to_hash

data/rbi/deeprails/models/defend_submit_and_stream_event_params.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class DefendSubmitAndStreamEventParams < Deeprails::Internal::Type::BaseModel
+      extend Deeprails::Internal::Type::RequestParameters::Converter
+      include Deeprails::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::DefendSubmitAndStreamEventParams,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      # The input provided to the model (e.g., prompt, messages).
+      sig { returns(T::Hash[Symbol, T.anything]) }
+      attr_accessor :model_input
+
+      # The output generated by the model to be evaluated.
+      sig { returns(String) }
+      attr_accessor :model_output
+
+      # The model that generated the output (e.g., "gpt-4", "claude-3").
+      sig { returns(String) }
+      attr_accessor :model_used
+
+      # The evaluation run mode. Streaming only supports fast, precision, and
+      # precision_codex.
+      sig do
+        returns(Deeprails::DefendSubmitAndStreamEventParams::RunMode::OrSymbol)
+      end
+      attr_accessor :run_mode
+
+      # Enable SSE streaming for real-time token feedback. Only supported for
+      # single-model run modes (fast, precision, precision_codex).
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stream
+
+      sig { params(stream: T::Boolean).void }
+      attr_writer :stream
+
+      # Optional tag to identify this event.
+      sig { returns(T.nilable(String)) }
+      attr_reader :nametag
+
+      sig { params(nametag: String).void }
+      attr_writer :nametag
+
+      sig do
+        params(
+          model_input: T::Hash[Symbol, T.anything],
+          model_output: String,
+          model_used: String,
+          run_mode:
+            Deeprails::DefendSubmitAndStreamEventParams::RunMode::OrSymbol,
+          stream: T::Boolean,
+          nametag: String,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The input provided to the model (e.g., prompt, messages).
+        model_input:,
+        # The output generated by the model to be evaluated.
+        model_output:,
+        # The model that generated the output (e.g., "gpt-4", "claude-3").
+        model_used:,
+        # The evaluation run mode. Streaming only supports fast, precision, and
+        # precision_codex.
+        run_mode:,
+        # Enable SSE streaming for real-time token feedback. Only supported for
+        # single-model run modes (fast, precision, precision_codex).
+        stream: nil,
+        # Optional tag to identify this event.
+        nametag: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            model_input: T::Hash[Symbol, T.anything],
+            model_output: String,
+            model_used: String,
+            run_mode:
+              Deeprails::DefendSubmitAndStreamEventParams::RunMode::OrSymbol,
+            stream: T::Boolean,
+            nametag: String,
+            request_options: Deeprails::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The evaluation run mode. Streaming only supports fast, precision, and
+      # precision_codex.
+      module RunMode
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::DefendSubmitAndStreamEventParams::RunMode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        FAST =
+          T.let(
+            :fast,
+            Deeprails::DefendSubmitAndStreamEventParams::RunMode::TaggedSymbol
+          )
+        PRECISION =
+          T.let(
+            :precision,
+            Deeprails::DefendSubmitAndStreamEventParams::RunMode::TaggedSymbol
+          )
+        PRECISION_CODEX =
+          T.let(
+            :precision_codex,
+            Deeprails::DefendSubmitAndStreamEventParams::RunMode::TaggedSymbol
+          )
+        PRECISION_MAX =
+          T.let(
+            :precision_max,
+            Deeprails::DefendSubmitAndStreamEventParams::RunMode::TaggedSymbol
+          )
+        PRECISION_MAX_CODEX =
+          T.let(
+            :precision_max_codex,
+            Deeprails::DefendSubmitAndStreamEventParams::RunMode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Deeprails::DefendSubmitAndStreamEventParams::RunMode::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/deeprails/models/defend_submit_and_stream_event_response.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    DefendSubmitAndStreamEventResponse = String
+  end
+end