deeprails 0.1.0

data/rbi/deeprails/models/defend_create_workflow_params.rbi

@@ -0,0 +1,270 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class DefendCreateWorkflowParams < Deeprails::Internal::Type::BaseModel
+      extend Deeprails::Internal::Type::RequestParameters::Converter
+      include Deeprails::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::DefendCreateWorkflowParams,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      # The action used to improve outputs that fail one or guardrail metrics for the
+      # workflow events. May be `regenerate`, `fixit`, or null which represents “do
+      # nothing”. ReGen runs the user's exact input prompt with minor induced variance.
+      # Fixit attempts to directly address the shortcomings of the output using the
+      # guardrail failure rationale. Do nothing does not attempt any improvement.
+      sig do
+        returns(
+          T.nilable(
+            Deeprails::DefendCreateWorkflowParams::ImprovementAction::OrSymbol
+          )
+        )
+      end
+      attr_accessor :improvement_action
+
+      # Mapping of guardrail metrics to floating point threshold values. If the workflow
+      # type is automatic, only the metric names are used (`automatic_tolerance`
+      # determines thresholds). Possible metrics are `correctness`, `completeness`,
+      # `instruction_adherence`, `context_adherence`, `ground_truth_adherence`, or
+      # `comprehensive_safety`.
+      sig { returns(T::Hash[Symbol, Float]) }
+      attr_accessor :metrics
+
+      # Name of the workflow.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Type of thresholds to use for the workflow, either `automatic` or `custom`.
+      # Automatic thresholds are assigned internally after the user specifies a
+      # qualitative tolerance for the metrics, whereas custom metrics allow the user to
+      # set the threshold for each metric as a floating point number between 0.0 and
+      # 1.0.
+      sig { returns(Deeprails::DefendCreateWorkflowParams::Type::OrSymbol) }
+      attr_accessor :type
+
+      # Hallucination tolerance for automatic workflows; may be `low`, `medium`, or
+      # `high`. Ignored if `type` is `custom`.
+      sig do
+        returns(
+          T.nilable(
+            Deeprails::DefendCreateWorkflowParams::AutomaticTolerance::OrSymbol
+          )
+        )
+      end
+      attr_reader :automatic_tolerance
+
+      sig do
+        params(
+          automatic_tolerance:
+            Deeprails::DefendCreateWorkflowParams::AutomaticTolerance::OrSymbol
+        ).void
+      end
+      attr_writer :automatic_tolerance
+
+      # Description for the workflow.
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      # Max. number of improvement action retries until a given event passes the
+      # guardrails. Defaults to 10.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_retries
+
+      sig { params(max_retries: Integer).void }
+      attr_writer :max_retries
+
+      sig do
+        params(
+          improvement_action:
+            T.nilable(
+              Deeprails::DefendCreateWorkflowParams::ImprovementAction::OrSymbol
+            ),
+          metrics: T::Hash[Symbol, Float],
+          name: String,
+          type: Deeprails::DefendCreateWorkflowParams::Type::OrSymbol,
+          automatic_tolerance:
+            Deeprails::DefendCreateWorkflowParams::AutomaticTolerance::OrSymbol,
+          description: String,
+          max_retries: Integer,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The action used to improve outputs that fail one or guardrail metrics for the
+        # workflow events. May be `regenerate`, `fixit`, or null which represents “do
+        # nothing”. ReGen runs the user's exact input prompt with minor induced variance.
+        # Fixit attempts to directly address the shortcomings of the output using the
+        # guardrail failure rationale. Do nothing does not attempt any improvement.
+        improvement_action:,
+        # Mapping of guardrail metrics to floating point threshold values. If the workflow
+        # type is automatic, only the metric names are used (`automatic_tolerance`
+        # determines thresholds). Possible metrics are `correctness`, `completeness`,
+        # `instruction_adherence`, `context_adherence`, `ground_truth_adherence`, or
+        # `comprehensive_safety`.
+        metrics:,
+        # Name of the workflow.
+        name:,
+        # Type of thresholds to use for the workflow, either `automatic` or `custom`.
+        # Automatic thresholds are assigned internally after the user specifies a
+        # qualitative tolerance for the metrics, whereas custom metrics allow the user to
+        # set the threshold for each metric as a floating point number between 0.0 and
+        # 1.0.
+        type:,
+        # Hallucination tolerance for automatic workflows; may be `low`, `medium`, or
+        # `high`. Ignored if `type` is `custom`.
+        automatic_tolerance: nil,
+        # Description for the workflow.
+        description: nil,
+        # Max. number of improvement action retries until a given event passes the
+        # guardrails. Defaults to 10.
+        max_retries: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            improvement_action:
+              T.nilable(
+                Deeprails::DefendCreateWorkflowParams::ImprovementAction::OrSymbol
+              ),
+            metrics: T::Hash[Symbol, Float],
+            name: String,
+            type: Deeprails::DefendCreateWorkflowParams::Type::OrSymbol,
+            automatic_tolerance:
+              Deeprails::DefendCreateWorkflowParams::AutomaticTolerance::OrSymbol,
+            description: String,
+            max_retries: Integer,
+            request_options: Deeprails::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The action used to improve outputs that fail one or guardrail metrics for the
+      # workflow events. May be `regenerate`, `fixit`, or null which represents “do
+      # nothing”. ReGen runs the user's exact input prompt with minor induced variance.
+      # Fixit attempts to directly address the shortcomings of the output using the
+      # guardrail failure rationale. Do nothing does not attempt any improvement.
+      module ImprovementAction
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Deeprails::DefendCreateWorkflowParams::ImprovementAction
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        REGENERATE =
+          T.let(
+            :regenerate,
+            Deeprails::DefendCreateWorkflowParams::ImprovementAction::TaggedSymbol
+          )
+        FIXIT =
+          T.let(
+            :fixit,
+            Deeprails::DefendCreateWorkflowParams::ImprovementAction::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Deeprails::DefendCreateWorkflowParams::ImprovementAction::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Type of thresholds to use for the workflow, either `automatic` or `custom`.
+      # Automatic thresholds are assigned internally after the user specifies a
+      # qualitative tolerance for the metrics, whereas custom metrics allow the user to
+      # set the threshold for each metric as a floating point number between 0.0 and
+      # 1.0.
+      module Type
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::DefendCreateWorkflowParams::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AUTOMATIC =
+          T.let(
+            :automatic,
+            Deeprails::DefendCreateWorkflowParams::Type::TaggedSymbol
+          )
+        CUSTOM =
+          T.let(
+            :custom,
+            Deeprails::DefendCreateWorkflowParams::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Deeprails::DefendCreateWorkflowParams::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Hallucination tolerance for automatic workflows; may be `low`, `medium`, or
+      # `high`. Ignored if `type` is `custom`.
+      module AutomaticTolerance
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Deeprails::DefendCreateWorkflowParams::AutomaticTolerance
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        LOW =
+          T.let(
+            :low,
+            Deeprails::DefendCreateWorkflowParams::AutomaticTolerance::TaggedSymbol
+          )
+        MEDIUM =
+          T.let(
+            :medium,
+            Deeprails::DefendCreateWorkflowParams::AutomaticTolerance::TaggedSymbol
+          )
+        HIGH =
+          T.let(
+            :high,
+            Deeprails::DefendCreateWorkflowParams::AutomaticTolerance::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Deeprails::DefendCreateWorkflowParams::AutomaticTolerance::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/deeprails/models/defend_response.rbi

@@ -0,0 +1,198 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class DefendResponse < Deeprails::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Deeprails::DefendResponse, Deeprails::Internal::AnyHash)
+        end
+
+      # Name of the workflow.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # A unique workflow ID.
+      sig { returns(String) }
+      attr_accessor :workflow_id
+
+      # The time the workflow was created in UTC.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :created_at
+
+      sig { params(created_at: Time).void }
+      attr_writer :created_at
+
+      # Description for the workflow.
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      # The action used to improve outputs that fail one or more guardrail metrics for
+      # the workflow events. May be `regenerate`, `fixit`, or null which represents “do
+      # nothing”. ReGen runs the user's exact input prompt with minor induced variance.
+      # Fixit attempts to directly address the shortcomings of the output using the
+      # guardrail failure rationale. Do nothing does not attempt any improvement.
+      sig do
+        returns(
+          T.nilable(Deeprails::DefendResponse::ImprovementAction::TaggedSymbol)
+        )
+      end
+      attr_accessor :improvement_action
+
+      # Max. number of improvement action retries until a given event passes the
+      # guardrails.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_retries
+
+      sig { params(max_retries: Integer).void }
+      attr_writer :max_retries
+
+      # The most recent time the workflow was modified in UTC.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :modified_at
+
+      sig { params(modified_at: Time).void }
+      attr_writer :modified_at
+
+      # Status of the selected workflow. May be `archived` or `active`. Archived
+      # workflows will not accept events.
+      sig do
+        returns(T.nilable(Deeprails::DefendResponse::Status::TaggedSymbol))
+      end
+      attr_reader :status
+
+      sig { params(status: Deeprails::DefendResponse::Status::OrSymbol).void }
+      attr_writer :status
+
+      # Rate of events associated with this workflow that passed evaluation.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :success_rate
+
+      sig { params(success_rate: Float).void }
+      attr_writer :success_rate
+
+      # Response payload for guardrail workflow operations.
+      sig do
+        params(
+          name: String,
+          workflow_id: String,
+          created_at: Time,
+          description: String,
+          improvement_action:
+            T.nilable(Deeprails::DefendResponse::ImprovementAction::OrSymbol),
+          max_retries: Integer,
+          modified_at: Time,
+          status: Deeprails::DefendResponse::Status::OrSymbol,
+          success_rate: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Name of the workflow.
+        name:,
+        # A unique workflow ID.
+        workflow_id:,
+        # The time the workflow was created in UTC.
+        created_at: nil,
+        # Description for the workflow.
+        description: nil,
+        # The action used to improve outputs that fail one or more guardrail metrics for
+        # the workflow events. May be `regenerate`, `fixit`, or null which represents “do
+        # nothing”. ReGen runs the user's exact input prompt with minor induced variance.
+        # Fixit attempts to directly address the shortcomings of the output using the
+        # guardrail failure rationale. Do nothing does not attempt any improvement.
+        improvement_action: nil,
+        # Max. number of improvement action retries until a given event passes the
+        # guardrails.
+        max_retries: nil,
+        # The most recent time the workflow was modified in UTC.
+        modified_at: nil,
+        # Status of the selected workflow. May be `archived` or `active`. Archived
+        # workflows will not accept events.
+        status: nil,
+        # Rate of events associated with this workflow that passed evaluation.
+        success_rate: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            workflow_id: String,
+            created_at: Time,
+            description: String,
+            improvement_action:
+              T.nilable(
+                Deeprails::DefendResponse::ImprovementAction::TaggedSymbol
+              ),
+            max_retries: Integer,
+            modified_at: Time,
+            status: Deeprails::DefendResponse::Status::TaggedSymbol,
+            success_rate: Float
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The action used to improve outputs that fail one or more guardrail metrics for
+      # the workflow events. May be `regenerate`, `fixit`, or null which represents “do
+      # nothing”. ReGen runs the user's exact input prompt with minor induced variance.
+      # Fixit attempts to directly address the shortcomings of the output using the
+      # guardrail failure rationale. Do nothing does not attempt any improvement.
+      module ImprovementAction
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::DefendResponse::ImprovementAction)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        REGENERATE =
+          T.let(
+            :regenerate,
+            Deeprails::DefendResponse::ImprovementAction::TaggedSymbol
+          )
+        FIXIT =
+          T.let(
+            :fixit,
+            Deeprails::DefendResponse::ImprovementAction::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Deeprails::DefendResponse::ImprovementAction::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Status of the selected workflow. May be `archived` or `active`. Archived
+      # workflows will not accept events.
+      module Status
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Deeprails::DefendResponse::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ARCHIVED =
+          T.let(:archived, Deeprails::DefendResponse::Status::TaggedSymbol)
+        ACTIVE = T.let(:active, Deeprails::DefendResponse::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Deeprails::DefendResponse::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/deeprails/models/defend_retrieve_event_params.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class DefendRetrieveEventParams < Deeprails::Internal::Type::BaseModel
+      extend Deeprails::Internal::Type::RequestParameters::Converter
+      include Deeprails::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::DefendRetrieveEventParams,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :workflow_id
+
+      sig do
+        params(
+          workflow_id: String,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(workflow_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { workflow_id: String, request_options: Deeprails::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/deeprails/models/defend_retrieve_workflow_params.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class DefendRetrieveWorkflowParams < Deeprails::Internal::Type::BaseModel
+      extend Deeprails::Internal::Type::RequestParameters::Converter
+      include Deeprails::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::DefendRetrieveWorkflowParams,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(request_options: Deeprails::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Deeprails::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/deeprails/models/defend_submit_event_params.rbi

@@ -0,0 +1,170 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class DefendSubmitEventParams < Deeprails::Internal::Type::BaseModel
+      extend Deeprails::Internal::Type::RequestParameters::Converter
+      include Deeprails::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::DefendSubmitEventParams,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      # 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::DefendSubmitEventParams::ModelInput) }
+      attr_reader :model_input
+
+      sig do
+        params(
+          model_input: Deeprails::DefendSubmitEventParams::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(String) }
+      attr_accessor :model_used
+
+      # An optional, user-defined tag for the event.
+      sig { returns(String) }
+      attr_accessor :nametag
+
+      # 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`.
+      sig { returns(Deeprails::DefendSubmitEventParams::RunMode::OrSymbol) }
+      attr_accessor :run_mode
+
+      sig do
+        params(
+          model_input: Deeprails::DefendSubmitEventParams::ModelInput::OrHash,
+          model_output: String,
+          model_used: String,
+          nametag: String,
+          run_mode: Deeprails::DefendSubmitEventParams::RunMode::OrSymbol,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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:,
+        # An optional, user-defined tag for the event.
+        nametag:,
+        # 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`.
+        run_mode:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            model_input: Deeprails::DefendSubmitEventParams::ModelInput,
+            model_output: String,
+            model_used: String,
+            nametag: String,
+            run_mode: Deeprails::DefendSubmitEventParams::RunMode::OrSymbol,
+            request_options: Deeprails::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class ModelInput < Deeprails::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Deeprails::DefendSubmitEventParams::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 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`.
+      module RunMode
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::DefendSubmitEventParams::RunMode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PRECISION_PLUS =
+          T.let(
+            :precision_plus,
+            Deeprails::DefendSubmitEventParams::RunMode::TaggedSymbol
+          )
+        PRECISION =
+          T.let(
+            :precision,
+            Deeprails::DefendSubmitEventParams::RunMode::TaggedSymbol
+          )
+        SMART =
+          T.let(
+            :smart,
+            Deeprails::DefendSubmitEventParams::RunMode::TaggedSymbol
+          )
+        ECONOMY =
+          T.let(
+            :economy,
+            Deeprails::DefendSubmitEventParams::RunMode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Deeprails::DefendSubmitEventParams::RunMode::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end