deeprails 0.17.0 → 0.23.0

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

data/rbi/deeprails/models/defend_submit_event_params.rbi

@@ -15,8 +15,8 @@ module Deeprails
         end
 
       # 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 the
-      # ground_truth_adherence guardrail metric, `ground_truth` should be provided.
+      # contain a `user_prompt` field. For the ground_truth_adherence guardrail metric,
+      # `ground_truth` should be provided.
       sig { returns(Deeprails::DefendSubmitEventParams::ModelInput) }
       attr_reader :model_input
 
@@ -37,8 +37,8 @@ module Deeprails
 
       # Run mode for the workflow 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`.
+      # event. Available run modes include `precision_plus_codex`, `precision_plus`,
+      # `precision`, `smart`, and `economy`. Defaults to `smart`.
       sig { returns(Deeprails::DefendSubmitEventParams::RunMode::OrSymbol) }
       attr_accessor :run_mode
 
@@ -61,8 +61,8 @@ module Deeprails
       end
       def self.new(
         # 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 the
-        # ground_truth_adherence guardrail metric, `ground_truth` should be provided.
+        # contain a `user_prompt` field. For the ground_truth_adherence guardrail metric,
+        # `ground_truth` should be provided.
         model_input:,
         # Output generated by the LLM to be evaluated.
         model_output:,
@@ -70,8 +70,8 @@ module Deeprails
         model_used:,
         # Run mode for the workflow 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`.
+        # event. Available run modes include `precision_plus_codex`, `precision_plus`,
+        # `precision`, `smart`, and `economy`. Defaults to `smart`.
         run_mode:,
         # An optional, user-defined tag for the event.
         nametag: nil,
@@ -103,6 +103,34 @@ module Deeprails
             )
           end
 
+        # The user prompt used to generate the output.
+        sig { returns(String) }
+        attr_accessor :user_prompt
+
+        # 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.
+        sig do
+          returns(
+            T.nilable(
+              T::Array[Deeprails::DefendSubmitEventParams::ModelInput::Context]
+            )
+          )
+        end
+        attr_reader :context
+
+        sig do
+          params(
+            context:
+              T::Array[
+                Deeprails::DefendSubmitEventParams::ModelInput::Context::OrHash
+              ]
+          ).void
+        end
+        attr_writer :context
+
         # The ground truth for evaluating the Ground Truth Adherence guardrail.
         sig { returns(T.nilable(String)) }
         attr_reader :ground_truth
@@ -117,46 +145,96 @@ module Deeprails
         sig { params(system_prompt: String).void }
         attr_writer :system_prompt
 
-        # The user prompt used to generate the output.
-        sig { returns(T.nilable(String)) }
-        attr_reader :user_prompt
-
-        sig { params(user_prompt: String).void }
-        attr_writer :user_prompt
-
         # 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 the
-        # ground_truth_adherence guardrail metric, `ground_truth` should be provided.
+        # contain a `user_prompt` field. For the ground_truth_adherence guardrail metric,
+        # `ground_truth` should be provided.
         sig do
           params(
+            user_prompt: String,
+            context:
+              T::Array[
+                Deeprails::DefendSubmitEventParams::ModelInput::Context::OrHash
+              ],
             ground_truth: String,
-            system_prompt: String,
-            user_prompt: String
+            system_prompt: String
           ).returns(T.attached_class)
         end
         def self.new(
+          # The user prompt used to generate the output.
+          user_prompt:,
+          # 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.
+          context: nil,
           # The ground truth for evaluating the Ground Truth Adherence guardrail.
           ground_truth: nil,
           # The system prompt used to generate the output.
-          system_prompt: nil,
-          # The user prompt used to generate the output.
-          user_prompt: nil
+          system_prompt: nil
         )
         end
 
         sig do
           override.returns(
-            { ground_truth: String, system_prompt: String, user_prompt: String }
+            {
+              user_prompt: String,
+              context:
+                T::Array[
+                  Deeprails::DefendSubmitEventParams::ModelInput::Context
+                ],
+              ground_truth: String,
+              system_prompt: String
+            }
           )
         end
         def to_hash
         end
+
+        class Context < Deeprails::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Deeprails::DefendSubmitEventParams::ModelInput::Context,
+                Deeprails::Internal::AnyHash
+              )
+            end
+
+          # The content of the message.
+          sig { returns(T.nilable(String)) }
+          attr_reader :content
+
+          sig { params(content: String).void }
+          attr_writer :content
+
+          # The role of the speaker.
+          sig { returns(T.nilable(String)) }
+          attr_reader :role
+
+          sig { params(role: String).void }
+          attr_writer :role
+
+          sig do
+            params(content: String, role: String).returns(T.attached_class)
+          end
+          def self.new(
+            # The content of the message.
+            content: nil,
+            # The role of the speaker.
+            role: nil
+          )
+          end
+
+          sig { override.returns({ content: String, role: String }) }
+          def to_hash
+          end
+        end
       end
 
       # Run mode for the workflow 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`.
+      # event. Available run modes include `precision_plus_codex`, `precision_plus`,
+      # `precision`, `smart`, and `economy`. Defaults to `smart`.
       module RunMode
         extend Deeprails::Internal::Type::Enum
 
@@ -166,6 +244,11 @@ module Deeprails
           end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
+        PRECISION_PLUS_CODEX =
+          T.let(
+            :precision_plus_codex,
+            Deeprails::DefendSubmitEventParams::RunMode::TaggedSymbol
+          )
         PRECISION_PLUS =
           T.let(
             :precision_plus,

data/rbi/deeprails/models/defend_update_response.rbi

@@ -21,11 +21,19 @@ module Deeprails
       sig { returns(String) }
       attr_accessor :workflow_id
 
+      # The name of the workflow.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
       sig do
         params(
           modified_at: Time,
           status: Deeprails::DefendUpdateResponse::Status::OrSymbol,
-          workflow_id: String
+          workflow_id: String,
+          name: String
         ).returns(T.attached_class)
       end
       def self.new(
@@ -35,7 +43,9 @@ module Deeprails
         # workflows will not accept events.
         status:,
         # A unique workflow ID.
-        workflow_id:
+        workflow_id:,
+        # The name of the workflow.
+        name: nil
       )
       end
 
@@ -44,7 +54,8 @@ module Deeprails
           {
             modified_at: Time,
             status: Deeprails::DefendUpdateResponse::Status::TaggedSymbol,
-            workflow_id: String
+            workflow_id: String,
+            name: String
           }
         )
       end