deeprails 0.1.0

data/rbi/deeprails/models/monitor_submit_event_response.rbi

@@ -0,0 +1,134 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class MonitorSubmitEventResponse < Deeprails::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Deeprails::Models::MonitorSubmitEventResponse,
+            Deeprails::Internal::AnyHash
+          )
+        end
+
+      # Represents whether the request was completed successfully.
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      # Response payload for monitor event operations.
+      sig do
+        returns(T.nilable(Deeprails::Models::MonitorSubmitEventResponse::Data))
+      end
+      attr_reader :data
+
+      sig do
+        params(
+          data: Deeprails::Models::MonitorSubmitEventResponse::Data::OrHash
+        ).void
+      end
+      attr_writer :data
+
+      # The accompanying message for the request. Includes error details when
+      # applicable.
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # Response wrapper for operations returning a MonitorEventResponse.
+      sig do
+        params(
+          success: T::Boolean,
+          data: Deeprails::Models::MonitorSubmitEventResponse::Data::OrHash,
+          message: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Represents whether the request was completed successfully.
+        success:,
+        # Response payload for monitor event operations.
+        data: nil,
+        # The accompanying message for the request. Includes error details when
+        # applicable.
+        message: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            success: T::Boolean,
+            data: Deeprails::Models::MonitorSubmitEventResponse::Data,
+            message: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Deeprails::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Deeprails::Models::MonitorSubmitEventResponse::Data,
+              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
+
+        # Monitor ID associated with this event.
+        sig { returns(String) }
+        attr_accessor :monitor_id
+
+        # The time the monitor event was created in UTC.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :created_at
+
+        sig { params(created_at: Time).void }
+        attr_writer :created_at
+
+        # Response payload for monitor event operations.
+        sig do
+          params(
+            evaluation_id: String,
+            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.
+          monitor_id:,
+          # The time the monitor event was created in UTC.
+          created_at: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              evaluation_id: String,
+              event_id: String,
+              monitor_id: String,
+              created_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/deeprails/models/monitor_update_params.rbi

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class MonitorUpdateParams < Deeprails::Internal::Type::BaseModel
+      extend Deeprails::Internal::Type::RequestParameters::Converter
+      include Deeprails::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Deeprails::MonitorUpdateParams, Deeprails::Internal::AnyHash)
+        end
+
+      # Description of the monitor.
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      # 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)
+        )
+      end
+      attr_reader :monitor_status
+
+      sig do
+        params(
+          monitor_status:
+            Deeprails::MonitorUpdateParams::MonitorStatus::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
+
+      sig do
+        params(
+          description: String,
+          monitor_status:
+            Deeprails::MonitorUpdateParams::MonitorStatus::OrSymbol,
+          name: String,
+          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,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            description: String,
+            monitor_status:
+              Deeprails::MonitorUpdateParams::MonitorStatus::OrSymbol,
+            name: String,
+            request_options: Deeprails::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Status of the monitor. Can be `active` or `inactive`. Inactive monitors no
+      # longer record and evaluate events.
+      module MonitorStatus
+        extend Deeprails::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Deeprails::MonitorUpdateParams::MonitorStatus)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE =
+          T.let(
+            :active,
+            Deeprails::MonitorUpdateParams::MonitorStatus::TaggedSymbol
+          )
+        INACTIVE =
+          T.let(
+            :inactive,
+            Deeprails::MonitorUpdateParams::MonitorStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Deeprails::MonitorUpdateParams::MonitorStatus::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/deeprails/models/workflow_event_response.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Deeprails
+  module Models
+    class WorkflowEventResponse < Deeprails::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Deeprails::WorkflowEventResponse, Deeprails::Internal::AnyHash)
+        end
+
+      # A unique workflow event ID.
+      sig { returns(String) }
+      attr_accessor :event_id
+
+      # Workflow ID associated with the event.
+      sig { returns(String) }
+      attr_accessor :workflow_id
+
+      # Count of improvement attempts for the event. If greater than one then all
+      # previous improvement attempts failed.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :attempt_number
+
+      sig { params(attempt_number: Integer).void }
+      attr_writer :attempt_number
+
+      # A unique evaluation ID associated with this event. Every event has one or more
+      # evaluation attempts.
+      sig { returns(T.nilable(String)) }
+      attr_reader :evaluation_id
+
+      sig { params(evaluation_id: String).void }
+      attr_writer :evaluation_id
+
+      # `False` if evaluation passed all of the guardrail metrics, `True` if evaluation
+      # failed any of the guardrail metrics.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :filtered
+
+      sig { params(filtered: T::Boolean).void }
+      attr_writer :filtered
+
+      # Response payload for workflow event operations.
+      sig do
+        params(
+          event_id: String,
+          workflow_id: String,
+          attempt_number: Integer,
+          evaluation_id: String,
+          filtered: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A unique workflow event ID.
+        event_id:,
+        # Workflow ID associated with the event.
+        workflow_id:,
+        # Count of improvement attempts for the event. If greater than one then all
+        # previous improvement attempts failed.
+        attempt_number: nil,
+        # A unique evaluation ID associated with this event. Every event has one or more
+        # evaluation attempts.
+        evaluation_id: nil,
+        # `False` if evaluation passed all of the guardrail metrics, `True` if evaluation
+        # failed any of the guardrail metrics.
+        filtered: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            event_id: String,
+            workflow_id: String,
+            attempt_number: Integer,
+            evaluation_id: String,
+            filtered: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/deeprails/models.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Deeprails
+  APIResponse = Deeprails::Models::APIResponse
+
+  DefendCreateWorkflowParams = Deeprails::Models::DefendCreateWorkflowParams
+
+  DefendResponse = Deeprails::Models::DefendResponse
+
+  DefendRetrieveEventParams = Deeprails::Models::DefendRetrieveEventParams
+
+  DefendRetrieveWorkflowParams = Deeprails::Models::DefendRetrieveWorkflowParams
+
+  DefendSubmitEventParams = Deeprails::Models::DefendSubmitEventParams
+
+  DefendUpdateWorkflowParams = Deeprails::Models::DefendUpdateWorkflowParams
+
+  EvaluateCreateParams = Deeprails::Models::EvaluateCreateParams
+
+  EvaluateRetrieveParams = Deeprails::Models::EvaluateRetrieveParams
+
+  Evaluation = Deeprails::Models::Evaluation
+
+  MonitorCreateParams = Deeprails::Models::MonitorCreateParams
+
+  MonitorRetrieveParams = Deeprails::Models::MonitorRetrieveParams
+
+  MonitorSubmitEventParams = Deeprails::Models::MonitorSubmitEventParams
+
+  MonitorUpdateParams = Deeprails::Models::MonitorUpdateParams
+
+  WorkflowEventResponse = Deeprails::Models::WorkflowEventResponse
+end

data/rbi/deeprails/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Deeprails
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Deeprails::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(Deeprails::RequestOptions, Deeprails::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: Deeprails::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: Deeprails::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/deeprails/resources/defend.rbi

@@ -0,0 +1,151 @@
+# typed: strong
+
+module Deeprails
+  module Resources
+    class Defend
+      # Create a new guardrail workflow with optional guardrail thresholds and
+      # improvement actions.
+      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(Deeprails::DefendResponse)
+      end
+      def create_workflow(
+        # 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
+
+      # Retrieve a specific event of a guardrail workflow.
+      sig do
+        params(
+          event_id: String,
+          workflow_id: String,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(Deeprails::WorkflowEventResponse)
+      end
+      def retrieve_event(
+        # The ID of the requested workflow event.
+        event_id,
+        # The ID of the workflow associated with the event.
+        workflow_id:,
+        request_options: {}
+      )
+      end
+
+      # Retrieve the details for a specific guardrail workflow.
+      sig do
+        params(
+          workflow_id: String,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(Deeprails::DefendResponse)
+      end
+      def retrieve_workflow(
+        # The ID of the workflow to retrieve.
+        workflow_id,
+        request_options: {}
+      )
+      end
+
+      # Submit a model input and output pair to a workflow for evaluation.
+      sig do
+        params(
+          workflow_id: String,
+          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(Deeprails::WorkflowEventResponse)
+      end
+      def submit_event(
+        # Workflow ID associated with this event.
+        workflow_id,
+        # 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
+
+      # Update an existing guardrail workflow.
+      sig do
+        params(
+          workflow_id: String,
+          description: String,
+          name: String,
+          type: Deeprails::DefendUpdateWorkflowParams::Type::OrSymbol,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(Deeprails::DefendResponse)
+      end
+      def update_workflow(
+        # The ID of the workflow to edit.
+        workflow_id,
+        # Description for the workflow.
+        description: nil,
+        # Name of the workflow.
+        name: nil,
+        # Type of thresholds to use for the workflow, either `automatic` or `custom`.
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Deeprails::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/deeprails/resources/evaluate.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Deeprails
+  module Resources
+    class Evaluate
+      # Use this endpoint to evaluate a model's input and output pair against selected
+      # guardrail metrics
+      sig do
+        params(
+          model_input: Deeprails::EvaluateCreateParams::ModelInput::OrHash,
+          model_output: String,
+          run_mode: Deeprails::EvaluateCreateParams::RunMode::OrSymbol,
+          guardrail_metrics:
+            T::Array[
+              Deeprails::EvaluateCreateParams::GuardrailMetric::OrSymbol
+            ],
+          model_used: String,
+          nametag: String,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(Deeprails::Evaluation)
+      end
+      def create(
+        # 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:,
+        # Run mode for the evaluation. 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:,
+        # 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 the allowed
+        # guardrail metrics.
+        guardrail_metrics: nil,
+        # Model ID used to generate the output, like `gpt-4o` or `o3`.
+        model_used: nil,
+        # An optional, user-defined tag for the evaluation.
+        nametag: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve the evaluation record for a given evaluation ID.
+      sig do
+        params(
+          eval_id: String,
+          request_options: Deeprails::RequestOptions::OrHash
+        ).returns(Deeprails::Evaluation)
+      end
+      def retrieve(
+        # The ID of the evaluation to retrieve.
+        eval_id,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Deeprails::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end