deeprails 0.17.0 → 0.23.0

data/rbi/deeprails/internal/type/base_stream.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Deeprails
+  module Internal
+    module Type
+      # @api private
+      #
+      # This module provides a base implementation for streaming responses in the SDK.
+      module BaseStream
+        include Enumerable
+
+        Message = type_member(:in)
+        Elem = type_member(:out)
+
+        sig { returns(Integer) }
+        attr_reader :status
+
+        sig { returns(T::Hash[String, String]) }
+        attr_reader :headers
+
+        sig { void }
+        def close
+        end
+
+        # @api private
+        sig { overridable.returns(T::Enumerable[Elem]) }
+        private def iterator
+        end
+
+        sig { params(blk: T.proc.params(arg0: Elem).void).void }
+        def each(&blk)
+        end
+
+        sig { returns(T::Enumerator[Elem]) }
+        def to_enum
+        end
+
+        # @api private
+        sig do
+          params(
+            model:
+              T.any(T::Class[T.anything], Deeprails::Internal::Type::Converter),
+            url: URI::Generic,
+            status: Integer,
+            headers: T::Hash[String, String],
+            response: Net::HTTPResponse,
+            unwrap:
+              T.any(
+                Symbol,
+                Integer,
+                T::Array[T.any(Symbol, Integer)],
+                T.proc.params(arg0: T.anything).returns(T.anything)
+              ),
+            stream: T::Enumerable[Message]
+          ).void
+        end
+        def initialize(
+          model:,
+          url:,
+          status:,
+          headers:,
+          response:,
+          unwrap:,
+          stream:
+        )
+        end
+
+        # @api private
+        sig { returns(String) }
+        def inspect
+        end
+      end
+    end
+  end
+end

data/rbi/deeprails/models/defend_create_workflow_params.rbi

@@ -67,6 +67,18 @@ module Deeprails
       end
       attr_writer :automatic_hallucination_tolerance_levels
 
+      # Context includes any structured information that directly relates to the model’s
+      # input and expected output—e.g., the recent turn-by-turn history between an AI
+      # tutor and a student, facts or state passed through an agentic workflow, or other
+      # domain-specific signals your system already knows and wants the model to
+      # condition on. This field determines whether to enable context awareness for this
+      # workflow's evaluations. Defaults to false.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :context_awareness
+
+      sig { params(context_awareness: T::Boolean).void }
+      attr_writer :context_awareness
+
       # Mapping of guardrail metrics to floating point threshold values. Possible
       # metrics are `correctness`, `completeness`, `instruction_adherence`,
       # `context_adherence`, `ground_truth_adherence`, or `comprehensive_safety`.
@@ -122,6 +134,7 @@ module Deeprails
               Symbol,
               Deeprails::DefendCreateWorkflowParams::AutomaticHallucinationToleranceLevel::OrSymbol
             ],
+          context_awareness: T::Boolean,
           custom_hallucination_threshold_values: T::Hash[Symbol, Float],
           description: String,
           file_search: T::Array[String],
@@ -150,6 +163,13 @@ module Deeprails
         # `instruction_adherence`, `context_adherence`, `ground_truth_adherence`, or
         # `comprehensive_safety`.
         automatic_hallucination_tolerance_levels: nil,
+        # Context includes any structured information that directly relates to the model’s
+        # input and expected output—e.g., the recent turn-by-turn history between an AI
+        # tutor and a student, facts or state passed through an agentic workflow, or other
+        # domain-specific signals your system already knows and wants the model to
+        # condition on. This field determines whether to enable context awareness for this
+        # workflow's evaluations. Defaults to false.
+        context_awareness: nil,
         # Mapping of guardrail metrics to floating point threshold values. Possible
         # metrics are `correctness`, `completeness`, `instruction_adherence`,
         # `context_adherence`, `ground_truth_adherence`, or `comprehensive_safety`.
@@ -181,6 +201,7 @@ module Deeprails
                 Symbol,
                 Deeprails::DefendCreateWorkflowParams::AutomaticHallucinationToleranceLevel::OrSymbol
               ],
+            context_awareness: T::Boolean,
             custom_hallucination_threshold_values: T::Hash[Symbol, Float],
             description: String,
             file_search: T::Array[String],

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
 
@@ -65,7 +65,7 @@ module Deeprails
       sig { returns(Time) }
       attr_accessor :updated_at
 
-      # A unique workflow ID.
+      # A unique workflow ID used to identify the workflow in other endpoints.
       sig { returns(String) }
       attr_accessor :workflow_id
 
@@ -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:,
@@ -144,7 +144,7 @@ module Deeprails
         threshold_type:,
         # The most recent time the workflow was updated in UTC.
         updated_at:,
-        # A unique workflow ID.
+        # A unique workflow ID used to identify the workflow in other endpoints.
         workflow_id:,
         # The action used to improve outputs that fail one or more guardrail metrics for
         # the workflow events.
@@ -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