runtype 0.1.0

data/generated/lib/runtype/evals/client.rb

@@ -0,0 +1,1286 @@
+# frozen_string_literal: true
+
+module Runtype
+  module Evals
+    class Client
+      # @param client [Runtype::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Analyze step results for keyword/phrase occurrences across evals.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalAnalyzeStepsRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.analyze_step_results(
+      #     case_sensitive: false,
+      #     eval_group_id: "evalgrp_01jv0000000000000000000001",
+      #     search_terms: %w[error success completed failed],
+      #     step_ids: ["step_01jv0000000000000000000001"]
+      #   )
+      #
+      # @return [Runtype::Evals::Types::PostV1EvalAnalyzeStepsResponse]
+      def analyze_step_results(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/analyze-steps",
+          body: Runtype::Evals::Types::PostV1EvalAnalyzeStepsRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::PostV1EvalAnalyzeStepsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List all eval batches for the current user with optional filtering and pagination.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :limit
+      # @option params [String, nil] :offset
+      # @option params [String, nil] :status
+      # @option params [Runtype::Evals::Types::GetV1EvalBatchesRequestOrigin, nil] :origin
+      # @option params [String, nil] :eval_suite_id
+      #
+      # @example
+      #   client.evals.list_eval_batches
+      #
+      # @return [Runtype::Evals::Types::GetV1EvalBatchesResponse]
+      def list_eval_batches(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["offset"] = params[:offset] if params.key?(:offset)
+        query_params["status"] = params[:status] if params.key?(:status)
+        query_params["origin"] = params[:origin] if params.key?(:origin)
+        query_params["evalSuiteId"] = params[:eval_suite_id] if params.key?(:eval_suite_id)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/batches",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::GetV1EvalBatchesResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Compare aggregate metrics across eval batches in a group.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalCompareRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.compare_evals(
+      #     eval_group_id: "evalgrp_01jv0000000000000000000001",
+      #     step_ids: %w[step_01jv0000000000000000000001 step_01jv0000000000000000000002]
+      #   )
+      #
+      # @return [Runtype::Evals::Types::PostV1EvalCompareResponse]
+      def compare_evals(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/compare",
+          body: Runtype::Evals::Types::PostV1EvalCompareRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::PostV1EvalCompareResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Compare results for a specific record across eval batches in a group.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalCompareRecordRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.compare_record_across_evals(
+      #     eval_group_id: "evalgrp_01jv0000000000000000000001",
+      #     record_id: "record_01jv0000000000000000000001",
+      #     step_ids: %w[step_01jv0000000000000000000001 step_01jv0000000000000000000002]
+      #   )
+      #
+      # @return [Runtype::Evals::Types::PostV1EvalCompareRecordResponse]
+      def compare_record_across_evals(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/compare-record",
+          body: Runtype::Evals::Types::PostV1EvalCompareRecordRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::PostV1EvalCompareRecordResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Idempotently converge a repo-defined eval suite (target + cases + graders) onto the platform. Identity is the
+      # suite name + account scope; the target flow/agent is resolved by name. Hash-only probes skip the payload in the
+      # steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the
+      # suite or replace its cases when the canonical content hash differs. Non-executing: never runs the eval. The
+      # response always carries the server-computed canonical hash.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalEnsureRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.ensure_eval_suite_config_as_code_converge(name: "name")
+      #
+      # @return [Runtype::Types::EvalEnsureResponse]
+      def ensure_eval_suite_config_as_code_converge(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/ensure",
+          body: Runtype::Evals::Types::PostV1EvalEnsureRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalEnsureResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Dry-run of POST /eval/suites/{id}/cases/from-execution: reconstructs the agent execution exactly as capture
+      # would (same reader, same message math) and returns its recorded actions with the fork index each one maps to,
+      # plus whether the case would be fully replayable. Reads only — nothing is written. Restricted to agent executions
+      # the caller owns.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :execution_id
+      #
+      # @example
+      #   client.evals.preview_trace_to_eval_capture_for_a_run(execution_id: "executionId")
+      #
+      # @return [Runtype::Types::CaptureExecutionPreview]
+      def preview_trace_to_eval_capture_for_a_run(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/executions/#{URI.encode_uri_component(params[:execution_id].to_s)}/capture-preview",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::CaptureExecutionPreview.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Split one plain-language AI-grader criterion carrying several obligations into focused, independently judgeable
+      # sub-checks. Authoring assist only: review the proposal, then save each accepted sub-check as its own AI grader
+      # (kind "ai") on the suite. Nothing is persisted by this endpoint.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::DecomposeCriteriaRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.decompose_grader_criteria(criteria: "criteria")
+      #
+      # @return [Runtype::Types::DecomposeCriteriaResponse]
+      def decompose_grader_criteria(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/graders/decompose",
+          body: Runtype::Evals::Types::DecomposeCriteriaRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::DecomposeCriteriaResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get all eval batches in a group for comparison.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :group_id
+      #
+      # @example
+      #   client.evals.get_eval_group(group_id: "groupId")
+      #
+      # @return [Runtype::Evals::Types::GetV1EvalGroupGroupIDResponse]
+      def get_eval_group(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/group/#{URI.encode_uri_component(params[:group_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::GetV1EvalGroupGroupIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Return the canonical config-as-code definition and provenance for an eval suite by name — the absorb-drift
+      # direction of the ensure protocol. The contentHash is recomputed from the live suite state.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :name
+      #
+      # @example
+      #   client.evals.pull_eval_suite_definition_config_as_code(name: "name")
+      #
+      # @return [Runtype::Types::EvalPullResponse]
+      def pull_eval_suite_definition_config_as_code(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["name"] = params[:name] if params.key?(:name)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/pull",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalPullResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Run every case of an eval suite against its target flow/agent and grade the outputs with the suite graders,
+      # returning the suite score + per-case gate outcomes in one response. Powers the `runtype eval` CI gate.
+      # Saved-suite runs persist by default: the run gets a durable id (`runId`) and per-case scores queryable via GET
+      # /eval/runs/{runId}/scores; pass `virtual: true` to skip persistence. Inline definition runs are always
+      # ephemeral. Bounded — suites over the case limit must use the batch path (/eval/submit). Flow and standard-agent
+      # targets are supported (in both saved and inline/virtual modes); external and claude_managed agent targets are
+      # not.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalRunRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.run_eval_suite_synchronously
+      #
+      # @return [Runtype::Types::RunEvalResponse]
+      def run_eval_suite_synchronously(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/run",
+          body: Runtype::Evals::Types::PostV1EvalRunRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::RunEvalResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Return the persisted per-case grader scores for a run (a `batchExecutions` row) — the read side of eval score
+      # persistence. Grader outcomes use the same shape as the synchronous POST /eval/run response, so live and
+      # historical results render identically. Runs land here from persisted saved-suite runs (POST /eval/run) and
+      # completed suite-linked batch runs. Returns an empty case list for a run with no persisted scores
+      # (ephemeral/virtual runs, ad-hoc comparisons, legacy evals).
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :batch_id
+      #
+      # @example
+      #   client.evals.get_persisted_grader_scores_for_an_eval_run(batch_id: "batchId")
+      #
+      # @return [Runtype::Types::EvalRunScoresResponse]
+      def get_persisted_grader_scores_for_an_eval_run(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/runs/#{URI.encode_uri_component(params[:batch_id].to_s)}/scores",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalRunScoresResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Record a lightweight human review of one AI-grader verdict ("the grader got this right / wrong"). Reviews
+      # accumulate into the suite's judge-trust display ("agrees with you N of M times") returned on GET
+      # /eval/suites/{id}. Only AI-grader score rows are reviewable; check graders are deterministic. Pass verdict null
+      # to clear an earlier review.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalScoresScoreIDReviewRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :score_id
+      #
+      # @example
+      #   client.evals.review_an_ai_grader_verdict(score_id: "scoreId")
+      #
+      # @return [Runtype::Types::EvalScoreReviewed]
+      def review_an_ai_grader_verdict(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Evals::Types::PostV1EvalScoresScoreIDReviewRequest.new(params).to_h
+        non_body_param_names = %w[scoreId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/scores/#{URI.encode_uri_component(params[:score_id].to_s)}/review",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalScoreReviewed.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Execute virtual eval with record/messages input and stream results via multiplexed SSE. All eval configs execute
+      # simultaneously in parallel.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalStreamRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.stream_eval_execution
+      #
+      # @return [untyped]
+      def stream_eval_execution(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/stream",
+          body: Runtype::Evals::Types::PostV1EvalStreamRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+
+      # Submit a flow or agent eval. Hosted targets support overrides and multi-model requests; delegated external
+      # agents support one baseline config without overrides and not /eval/stream.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalSubmitRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.submit_eval(eval_config: {
+      #     overrides: {
+      #       steps: {
+      #         step_01jv0000000000000000000001: {
+      #           max_tokens: 2000,
+      #           model: "gpt-4o",
+      #           temperature: 0.7
+      #         }
+      #       }
+      #     }
+      #   })
+      #
+      # @return [Runtype::Evals::Types::PostV1EvalSubmitResponse]
+      def submit_eval(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/submit",
+          body: Runtype::Evals::Types::PostV1EvalSubmitRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::PostV1EvalSubmitResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List eval suites in the account scope with case counts and each suite’s latest run + score. Filter by target
+      # with flowId/agentId.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :flow_id
+      # @option params [String, nil] :agent_id
+      # @option params [String, nil] :limit
+      # @option params [String, nil] :offset
+      #
+      # @example
+      #   client.evals.list_eval_suites
+      #
+      # @return [Runtype::Types::EvalSuiteListResponse]
+      def list_eval_suites(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["flowId"] = params[:flow_id] if params.key?(:flow_id)
+        query_params["agentId"] = params[:agent_id] if params.key?(:agent_id)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["offset"] = params[:offset] if params.key?(:offset)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/suites",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalSuiteListResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create an eval suite (named test cases + graders) attached to one flow or agent, optionally with initial cases.
+      # Suites created here are dashboard/API-managed; config-as-code suites converge via POST /eval/ensure instead.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalSuitesRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.evals.create_eval_suite(name: "name")
+      #
+      # @return [Runtype::Types::EvalSuiteDetail]
+      def create_eval_suite(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/suites",
+          body: Runtype::Evals::Types::PostV1EvalSuitesRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalSuiteDetail.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get an eval suite including its cases and latest run + score.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.get_eval_suite(id: "id")
+      #
+      # @return [Runtype::Types::EvalSuiteDetail]
+      def get_eval_suite(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalSuiteDetail.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete an eval suite and its cases. Past runs and their persisted scores survive (scores keep the case name
+      # snapshot).
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.delete_eval_suite(id: "id")
+      #
+      # @return [Runtype::Evals::Types::DeleteV1EvalSuitesIDResponse]
+      def delete_eval_suite(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::DeleteV1EvalSuitesIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Update a suite’s Definition (name, description, graders) or state (default flag, baseline run pin). The target
+      # is immutable — create a new suite to evaluate a different flow/agent. Definition edits stamp provenance; a
+      # graders change invalidates the config-as-code content hash so the next ensure re-converges.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PatchV1EvalSuitesIDRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.update_eval_suite(id: "id")
+      #
+      # @return [Runtype::Types::EvalSuiteSummary]
+      def update_eval_suite(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Evals::Types::PatchV1EvalSuitesIDRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PATCH",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalSuiteSummary.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Add one or more test cases to an eval suite. Cases are server-authoritative data: adding them does not affect
+      # the suite’s config-as-code provenance.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalSuitesIDCasesRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.add_eval_cases(
+      #     id: "id",
+      #     cases: [{
+      #       name: "name"
+      #     }]
+      #   )
+      #
+      # @return [Runtype::Types::EvalCasesCreated]
+      def add_eval_cases(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Evals::Types::PostV1EvalSuitesIDCasesRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/cases",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalCasesCreated.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Fork an agent execution into a test case: freeze its conversation history up to a fork point, attach every
+      # recorded tool result as an editable mock, and save it with origin "saved_from_run". Capture only — reads the run
+      # and writes a case; it never re-executes anything. Restricted to agent executions the caller owns.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalSuitesIDCasesFromExecutionRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.capture_an_eval_case_from_a_run(
+      #     id: "id",
+      #     execution_id: "executionId"
+      #   )
+      #
+      # @return [Runtype::Types::CapturedEvalCase]
+      def capture_an_eval_case_from_a_run(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Evals::Types::PostV1EvalSuitesIDCasesFromExecutionRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/cases/from-execution",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::CapturedEvalCase.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Delete a test case. Persisted scores from past runs survive with the case name snapshot (caseId nulls out).
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :case_id
+      #
+      # @example
+      #   client.evals.delete_eval_case(
+      #     id: "id",
+      #     case_id: "caseId"
+      #   )
+      #
+      # @return [Runtype::Evals::Types::DeleteV1EvalSuitesIDCasesCaseIDResponse]
+      def delete_eval_case(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/cases/#{URI.encode_uri_component(params[:case_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::DeleteV1EvalSuitesIDCasesCaseIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Edit, enable, or disable a test case.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PatchV1EvalSuitesIDCasesCaseIDRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :case_id
+      #
+      # @example
+      #   client.evals.update_eval_case(
+      #     id: "id",
+      #     case_id: "caseId"
+      #   )
+      #
+      # @return [Runtype::Types::EvalCase]
+      def update_eval_case(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Evals::Types::PatchV1EvalSuitesIDCasesCaseIDRequest.new(params).to_h
+        non_body_param_names = %w[id caseId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PATCH",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/cases/#{URI.encode_uri_component(params[:case_id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalCase.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # The coverage meter: which of the target’s tools and instruction clauses the suite’s cases and graders already
+      # exercise. Tools come structurally from the definition; instruction clauses come from a cached,
+      # definition-hash-invalidated inventory pass. Write-gated because a cache miss spends model tokens.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.get_eval_suite_coverage(id: "id")
+      #
+      # @return [Runtype::Types::EvalCoverage]
+      def get_eval_suite_coverage(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/coverage",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalCoverage.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Propose test cases from the target’s definition, fanned out over an explicit diversity matrix (category ×
+      # persona) and filtered for gradeability. Generated cases land as PROPOSALS for review — never directly in the
+      # suite. One daily-eval quota slot per call.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalSuitesIDGenerateCasesRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.generate_eval_case_proposals(id: "id")
+      #
+      # @return [Runtype::Types::EvalCasesGenerated]
+      def generate_eval_case_proposals(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Evals::Types::PostV1EvalSuitesIDGenerateCasesRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/generate-cases",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalCasesGenerated.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # List a suite’s machine-proposed cases (the review queue). Every generation source — definition-seeded
+      # generation, coverage gaps, trace mining, feedback — lands here; nothing enters the suite without an accept.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [Runtype::Evals::Types::GetV1EvalSuitesIDProposalsRequestStatus, nil] :status
+      # @option params [String, nil] :limit
+      # @option params [String, nil] :offset
+      #
+      # @example
+      #   client.evals.list_eval_case_proposals(id: "id")
+      #
+      # @return [Runtype::Types::EvalCaseProposalList]
+      def list_eval_case_proposals(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["status"] = params[:status] if params.key?(:status)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["offset"] = params[:offset] if params.key?(:offset)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/proposals",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalCaseProposalList.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Materialize a proposal as a test case (origin "generated", or "saved_from_run" for trace-sourced proposals) and
+      # backlink it. Pass an edited body to save your version instead — recorded as "edited_accepted"; the machine
+      # original stays for audit.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalSuitesIDProposalsProposalIDAcceptRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :proposal_id
+      #
+      # @example
+      #   client.evals.accept_an_eval_case_proposal(
+      #     id: "id",
+      #     proposal_id: "proposalId"
+      #   )
+      #
+      # @return [Runtype::Types::EvalCaseProposalAccepted]
+      def accept_an_eval_case_proposal(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Evals::Types::PostV1EvalSuitesIDProposalsProposalIDAcceptRequest.new(params).to_h
+        non_body_param_names = %w[id proposalId]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/proposals/#{URI.encode_uri_component(params[:proposal_id].to_s)}/accept",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::EvalCaseProposalAccepted.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Reject a proposal. The row survives as audit and as a dedup signal for future generation passes.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [String] :proposal_id
+      #
+      # @example
+      #   client.evals.reject_an_eval_case_proposal(
+      #     id: "id",
+      #     proposal_id: "proposalId"
+      #   )
+      #
+      # @return [Runtype::Evals::Types::PostV1EvalSuitesIDProposalsProposalIDRejectResponse]
+      def reject_an_eval_case_proposal(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/proposals/#{URI.encode_uri_component(params[:proposal_id].to_s)}/reject",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::PostV1EvalSuitesIDProposalsProposalIDRejectResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Run every enabled case of the suite against its target and grade the outputs with the suite graders. Suites
+      # within the synchronous case limit (50) run inline and return the full scored result; larger suites are queued as
+      # a durable run (202) that is graded when it completes — poll GET /eval/runs/{runId}/scores. Both paths persist
+      # per-case scores to the same run history.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::Evals::Types::PostV1EvalSuitesIDRunRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.run_eval_suite(id: "id")
+      #
+      # @return [Runtype::Types::RunEvalResponse]
+      def run_eval_suite(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::Evals::Types::PostV1EvalSuitesIDRunRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/eval/suites/#{URI.encode_uri_component(params[:id].to_s)}/run",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::RunEvalResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Get detailed results for a specific eval batch including step results and tool calls.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.evals.get_eval_results(id: "id")
+      #
+      # @return [Runtype::Evals::Types::GetV1EvalIDResultsResponse]
+      def get_eval_results(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/eval/#{URI.encode_uri_component(params[:id].to_s)}/results",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Evals::Types::GetV1EvalIDResultsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end