openlayer 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e4cc5a98379f9ae05ca709024af12cf7858ad34ee8b0f5ea210aa81bd304ef4
-  data.tar.gz: 50a1a617e5bfd90d6b1e4de15bed85f96b76a79280ba6b09441db937552f0e66
+  metadata.gz: 676a996fd68cfe29c8abf62e4d4406e93842df91c067b4733deadf5ef7e6d583
+  data.tar.gz: 47d1c0944fa95169bfc003b26b7b12698820fec07503d562f88ee7baeaf192c1
 SHA512:
-  metadata.gz: 466925ac2e63aa675d10967906e219c1ded253af1d032ca9b524d0f2e5e9fe32fd859e9b679ad5a90c1d224f2166efc5ab9bb459456cbea3aa0f5df6756c523a
-  data.tar.gz: afeb1a7249dde3173191f80f141ce84afc5423882a4749fb75acd82ef6fcf03dccd0b9b233686cd61036337efa6f5890072f0116772735d84efa72111c6d562f
+  metadata.gz: 69fc4228f987067c305b5078f6ce37d1f02a20ccf877cb38c1b578ed70e085ab15429fdfbe41ccdf157a4d42416ae24c28cda425a59b1370c6524186fd70810c
+  data.tar.gz: 10fe98ac7f9ae76e30f30641bf49c0d729a6e2f2718baeb4b5dd33a5a8d2947f82a165cc2fed674cc90b63adaf67d184a90f883a9d83f1ff3b7194bd9fbc5f4f

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.7.0 (2025-12-17)
+
+Full Changelog: [v0.6.0...v0.7.0](https://github.com/openlayer-ai/openlayer-ruby/compare/v0.6.0...v0.7.0)
+
+### Features
+
+* **closes OPEN-8478:** add ConversationalSearchService tracer to Ruby SDK ([a33bc2e](https://github.com/openlayer-ai/openlayer-ruby/commit/a33bc2eab12db4b8e2d95a66435b1f7fbc1d0397))
+
+## 0.6.0 (2025-12-17)
+
+Full Changelog: [v0.5.0...v0.6.0](https://github.com/openlayer-ai/openlayer-ruby/compare/v0.5.0...v0.6.0)
+
+### Features
+
+* **api:** add test evaluation method ([18f2855](https://github.com/openlayer-ai/openlayer-ruby/commit/18f28556f722aad06666f8a247e597328d218b14))
+
+
+### Bug Fixes
+
+* calling `break` out of streams should be instantaneous ([8fe6142](https://github.com/openlayer-ai/openlayer-ruby/commit/8fe6142fdb2c5590bb28678f8fbf4958bdcfb9f9))
+
 ## 0.5.0 (2025-12-16)
 
 Full Changelog: [v0.4.1...v0.5.0](https://github.com/openlayer-ai/openlayer-ruby/compare/v0.4.1...v0.5.0)

data/README.md

@@ -17,7 +17,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "openlayer", "~> 0.5.0"
+gem "openlayer", "~> 0.7.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/openlayer/client.rb

@@ -30,6 +30,9 @@ module Openlayer
     # @return [Openlayer::Resources::Storage]
     attr_reader :storage
 
+    # @return [Openlayer::Resources::Tests]
+    attr_reader :tests
+
     # @api private
     #
     # @return [Hash{String=>String}]
@@ -77,6 +80,7 @@ module Openlayer
       @commits = Openlayer::Resources::Commits.new(client: self)
       @inference_pipelines = Openlayer::Resources::InferencePipelines.new(client: self)
       @storage = Openlayer::Resources::Storage.new(client: self)
+      @tests = Openlayer::Resources::Tests.new(client: self)
     end
   end
 end

data/lib/openlayer/integrations/google_conversational_search_tracer.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+# typed: false
+
+require "json"
+require "time"
+
+module Openlayer
+  module Integrations
+    # Tracer for Google Cloud DiscoveryEngine ConversationalSearchService
+    #
+    # This class provides integration with Google's ConversationalSearchService
+    # to automatically trace answer_query calls and send them to the Openlayer platform.
+    #
+    # @example Basic usage
+    #   require 'openlayer/integrations/google_conversational_search_tracer'
+    #   require 'google/cloud/discovery_engine/v1'
+    #
+    #   google_client = Google::Cloud::DiscoveryEngine::V1::ConversationalSearchService::Client.new
+    #   openlayer = Openlayer::Client.new(api_key: ENV['OPENLAYER_API_KEY'])
+    #
+    #   Openlayer::Integrations::GoogleConversationalSearchTracer.trace_client(
+    #     google_client,
+    #     openlayer_client: openlayer,
+    #     inference_pipeline_id: 'your-pipeline-id'
+    #   )
+    #
+    #   # Now all answer_query calls are automatically traced
+    #   response = google_client.answer_query(
+    #     serving_config: "projects/.../servingConfigs/default",
+    #     query: { text: "What is the meaning of life?" }
+    #   )
+    class GoogleConversationalSearchTracer
+      # Enable tracing on a Google ConversationalSearchService client
+      #
+      # @param client [Google::Cloud::DiscoveryEngine::V1::ConversationalSearchService::Client]
+      #   The Google client instance to trace
+      # @param openlayer_client [Openlayer::Client]
+      #   The Openlayer client instance for sending traces
+      # @param inference_pipeline_id [String]
+      #   The Openlayer inference pipeline ID to send traces to
+      # @return [void]
+      def self.trace_client(client, openlayer_client:, inference_pipeline_id:)
+        # Store original method reference
+        original_answer_query = client.method(:answer_query)
+
+        # Define traced wrapper method
+        client.define_singleton_method(:answer_query) do |*args, **kwargs, &block|
+          # Capture start time
+          start_time = Time.now
+
+          # Execute the original method
+          response = original_answer_query.call(*args, **kwargs, &block)
+
+          # Capture end time
+          end_time = Time.now
+
+          # Send trace to Openlayer (with error handling)
+          begin
+            GoogleConversationalSearchTracer.send_trace(
+              args: args,
+              kwargs: kwargs,
+              response: response,
+              start_time: start_time,
+              end_time: end_time,
+              openlayer_client: openlayer_client,
+              inference_pipeline_id: inference_pipeline_id
+            )
+          rescue StandardError => e
+            # Never break the user's application due to tracing errors
+            GoogleConversationalSearchTracer.warn_if_debug("[Openlayer] Failed to send trace: #{e.message}")
+            GoogleConversationalSearchTracer.warn_if_debug("[Openlayer] #{e.backtrace.first(3).join("\n")}") if e.backtrace
+          end
+
+          # Always return the original response
+          response
+        end
+
+        nil
+      end
+
+      # Send trace data to Openlayer platform
+      #
+      # @param args [Array] Original method positional arguments
+      # @param kwargs [Hash] Original method keyword arguments
+      # @param response [Google::Cloud::DiscoveryEngine::V1::AnswerQueryResponse] The API response
+      # @param start_time [Time] Request start time
+      # @param end_time [Time] Request end time
+      # @param openlayer_client [Openlayer::Client] Openlayer client instance
+      # @param inference_pipeline_id [String] Pipeline ID
+      # @return [void]
+      def self.send_trace(args:, kwargs:, response:, start_time:, end_time:, openlayer_client:, inference_pipeline_id:)
+        # Calculate latency
+        latency_ms = ((end_time - start_time) * 1000).round(2)
+
+        # Extract query from request
+        query_text = extract_query(args, kwargs)
+
+        # Extract answer and metadata from response
+        answer_data = extract_answer_data(response)
+
+        # Extract additional metadata
+        metadata = extract_metadata(args, kwargs, response, latency_ms)
+
+        # Rough estimate of prompt and completion tokens
+        prompt_tokens = (query_text.length / 4.0).ceil
+        completion_tokens = (answer_data[:answer_text].length / 4.0).ceil
+
+        # Build trace data in Openlayer format
+        trace_data = {
+          config: {
+            inputVariableNames: ["query"],
+            outputColumnName: "answer",
+            latencyColumnName: "latency_ms",
+            timestampColumnName: "timestamp"
+          },
+          rows: [
+            {
+              query: query_text,
+              answer: answer_data[:answer_text],
+              latency_ms: latency_ms,
+              timestamp: start_time.to_i,
+              metadata: metadata,
+              steps: [
+                {
+                  name: "Conversational Search answer_query",
+                  type: "chat_completion",
+                  provider: "Google",
+                  startTime: start_time.to_i,
+                  endTime: end_time.to_i,
+                  latency: latency_ms,
+                  metadata: metadata,
+                  inputs: {
+                    prompt: [
+                      {role: "user", content: query_text}
+                    ]
+                  },
+                  output: answer_data[:answer_text],
+                  promptTokens: prompt_tokens,
+                  completionTokens: completion_tokens,
+                  tokens: prompt_tokens + completion_tokens,
+                  model: "google-discovery-engine"
+                }
+              ]
+            }
+          ]
+        }
+
+        # Send to Openlayer
+        openlayer_client
+          .inference_pipelines
+          .data
+          .stream(
+            inference_pipeline_id,
+            **trace_data
+          )
+      end
+
+      # Extract query text from request arguments
+      #
+      # Handles both calling styles:
+      # 1. Request object: answer_query(request_object)
+      # 2. Keyword arguments: answer_query(query: {...}, serving_config: ...)
+      #
+      # @param args [Array] Positional arguments
+      # @param kwargs [Hash] Keyword arguments
+      # @return [String, nil] The query text or nil if not found
+      def self.extract_query(args, kwargs)
+        query_obj = nil
+
+        # Try to get query from request object (first positional arg)
+        if args.length.positive? && args[0].respond_to?(:query)
+          query_obj = args[0].query
+        # Try to get query from keyword arguments
+        elsif kwargs[:query]
+          query_obj = kwargs[:query]
+        end
+
+        return nil if query_obj.nil?
+
+        # Extract text from query object
+        if query_obj.respond_to?(:text)
+          query_obj.text
+        elsif query_obj.is_a?(Hash) && query_obj[:text]
+          query_obj[:text]
+        elsif query_obj.is_a?(Hash) && query_obj["text"]
+          query_obj["text"]
+        else
+          query_obj.to_s
+        end
+      rescue StandardError => e
+        warn_if_debug("[Openlayer] Failed to extract query: #{e.message}")
+        nil
+      end
+
+      # Extract answer data from response
+      #
+      # @param response [Google::Cloud::DiscoveryEngine::V1::AnswerQueryResponse] API response
+      # @return [Hash] Hash containing answer_text and other answer fields
+      def self.extract_answer_data(response)
+        return {answer_text: nil} unless response.respond_to?(:answer)
+
+        answer = response.answer
+        return {answer_text: nil} if answer.nil?
+
+        {
+          answer_text: safe_extract(answer, :answer_text),
+          state: safe_extract(answer, :state)&.to_s,
+          grounding_score: safe_extract(answer, :grounding_score),
+          create_time: extract_timestamp(answer, :create_time),
+          complete_time: extract_timestamp(answer, :complete_time),
+          citations_count: safe_count(answer, :citations),
+          references_count: safe_count(answer, :references)
+        }
+      rescue StandardError => e
+        warn_if_debug("[Openlayer] Failed to extract answer data: #{e.message}")
+        {answer_text: nil}
+      end
+
+      # Extract metadata from request and response
+      #
+      # @param args [Array] Positional arguments
+      # @param kwargs [Hash] Keyword arguments
+      # @param response [Google::Cloud::DiscoveryEngine::V1::AnswerQueryResponse] API response
+      # @param latency_ms [Float] Request latency in milliseconds
+      # @return [Hash] Metadata hash
+      def self.extract_metadata(args, kwargs, response, latency_ms)
+        answer_data = extract_answer_data(response)
+
+        metadata = {
+          provider: "google",
+          service: "conversational_search",
+          latency_ms: latency_ms
+        }
+
+        # Add answer metadata
+        metadata[:grounding_score] = answer_data[:grounding_score] if answer_data[:grounding_score]
+        metadata[:state] = answer_data[:state] if answer_data[:state]
+        metadata[:citations_count] = answer_data[:citations_count] if answer_data[:citations_count]
+        metadata[:references_count] = answer_data[:references_count] if answer_data[:references_count]
+
+        # Add request metadata
+        metadata[:serving_config] = extract_serving_config(args, kwargs)
+        metadata[:session] = extract_session(args, kwargs)
+
+        # Add timing metadata
+        if answer_data[:create_time] && answer_data[:complete_time]
+          generation_time_ms = ((answer_data[:complete_time] - answer_data[:create_time]) * 1000).round(2)
+          metadata[:generation_time_ms] = generation_time_ms
+        end
+
+        metadata.compact
+      rescue StandardError => e
+        warn_if_debug("[Openlayer] Failed to extract metadata: #{e.message}")
+        {
+          provider: "google",
+          service: "conversational_search",
+          latency_ms: latency_ms
+        }
+      end
+
+      # Extract serving_config from request
+      #
+      # @param args [Array] Positional arguments
+      # @param kwargs [Hash] Keyword arguments
+      # @return [String, nil] Serving config or nil
+      def self.extract_serving_config(args, kwargs)
+        if args.length.positive? && args[0].respond_to?(:serving_config)
+          args[0].serving_config
+        elsif kwargs[:serving_config]
+          kwargs[:serving_config]
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Extract session from request
+      #
+      # @param args [Array] Positional arguments
+      # @param kwargs [Hash] Keyword arguments
+      # @return [String, nil] Session ID or nil
+      def self.extract_session(args, kwargs)
+        if args.length.positive? && args[0].respond_to?(:session)
+          args[0].session
+        elsif kwargs[:session]
+          kwargs[:session]
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Safely extract a field from an object
+      #
+      # @param obj [Object] Object to extract from
+      # @param field [Symbol] Field name
+      # @return [Object, nil] Field value or nil
+      def self.safe_extract(obj, field)
+        obj.respond_to?(field) ? obj.public_send(field) : nil
+      rescue StandardError
+        nil
+      end
+
+      # Safely count elements in a collection field
+      #
+      # @param obj [Object] Object containing the collection
+      # @param field [Symbol] Field name
+      # @return [Integer, nil] Count or nil
+      def self.safe_count(obj, field)
+        collection = safe_extract(obj, field)
+        collection.respond_to?(:length) ? collection.length : nil
+      rescue StandardError
+        nil
+      end
+
+      # Extract timestamp and convert to Unix timestamp
+      #
+      # @param obj [Object] Object containing timestamp
+      # @param field [Symbol] Field name
+      # @return [Integer, nil] Unix timestamp or nil
+      def self.extract_timestamp(obj, field)
+        timestamp = safe_extract(obj, field)
+        return nil if timestamp.nil?
+
+        if timestamp.respond_to?(:to_time)
+          timestamp.to_time.to_i
+        elsif timestamp.respond_to?(:to_i)
+          timestamp.to_i
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Log warning message if debug mode is enabled
+      #
+      # @param message [String] Warning message
+      # @return [void]
+      def self.warn_if_debug(message)
+        warn(message) if ENV["OPENLAYER_DEBUG"]
+      end
+
+      # send_trace and warn_if_debug need to be public because they're called
+      # from the singleton method context
+      private_class_method :extract_query,
+                           :extract_answer_data,
+                           :extract_metadata,
+                           :extract_serving_config,
+                           :extract_session,
+                           :safe_extract,
+                           :safe_count,
+                           :extract_timestamp
+    end
+  end
+end

data/lib/openlayer/internal/transport/pooled_net_requester.rb

@@ -153,17 +153,19 @@ module Openlayer
                   end
 
                   self.class.calibrate_socket_timeout(conn, deadline)
-                  conn.request(req) do |rsp|
-                    y << [req, rsp]
-                    break if finished
-
-                    rsp.read_body do |bytes|
-                      y << bytes.force_encoding(Encoding::BINARY)
-                      break if finished
-
-                      self.class.calibrate_socket_timeout(conn, deadline)
+                  ::Kernel.catch(:jump) do
+                    conn.request(req) do |rsp|
+                      y << [req, rsp]
+                      ::Kernel.throw(:jump) if finished
+
+                      rsp.read_body do |bytes|
+                        y << bytes.force_encoding(Encoding::BINARY)
+                        ::Kernel.throw(:jump) if finished
+
+                        self.class.calibrate_socket_timeout(conn, deadline)
+                      end
+                      eof = true
                     end
-                    eof = true
                   end
                 end
               ensure

data/lib/openlayer/models/test_evaluate_params.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Openlayer
+  module Models
+    # @see Openlayer::Resources::Tests#evaluate
+    class TestEvaluateParams < Openlayer::Internal::Type::BaseModel
+      extend Openlayer::Internal::Type::RequestParameters::Converter
+      include Openlayer::Internal::Type::RequestParameters
+
+      # @!attribute end_timestamp
+      #   End timestamp in seconds (Unix epoch)
+      #
+      #   @return [Integer]
+      required :end_timestamp, Integer, api_name: :endTimestamp
+
+      # @!attribute start_timestamp
+      #   Start timestamp in seconds (Unix epoch)
+      #
+      #   @return [Integer]
+      required :start_timestamp, Integer, api_name: :startTimestamp
+
+      # @!attribute inference_pipeline_id
+      #   ID of the inference pipeline to evaluate. If not provided, all inference
+      #   pipelines the test applies to will be evaluated.
+      #
+      #   @return [String, nil]
+      optional :inference_pipeline_id, String, api_name: :inferencePipelineId
+
+      # @!attribute overwrite_results
+      #   Whether to overwrite existing test results
+      #
+      #   @return [Boolean, nil]
+      optional :overwrite_results, Openlayer::Internal::Type::Boolean, api_name: :overwriteResults
+
+      # @!method initialize(end_timestamp:, start_timestamp:, inference_pipeline_id: nil, overwrite_results: nil, request_options: {})
+      #   Some parameter documentations has been truncated, see
+      #   {Openlayer::Models::TestEvaluateParams} for more details.
+      #
+      #   @param end_timestamp [Integer] End timestamp in seconds (Unix epoch)
+      #
+      #   @param start_timestamp [Integer] Start timestamp in seconds (Unix epoch)
+      #
+      #   @param inference_pipeline_id [String] ID of the inference pipeline to evaluate. If not provided, all inference pipelin
+      #
+      #   @param overwrite_results [Boolean] Whether to overwrite existing test results
+      #
+      #   @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/openlayer/models/test_evaluate_response.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Openlayer
+  module Models
+    # @see Openlayer::Resources::Tests#evaluate
+    class TestEvaluateResponse < Openlayer::Internal::Type::BaseModel
+      # @!attribute message
+      #
+      #   @return [String]
+      required :message, String
+
+      # @!attribute pipeline_count
+      #   Number of inference pipelines the test was queued for evaluation on
+      #
+      #   @return [Integer]
+      required :pipeline_count, Integer, api_name: :pipelineCount
+
+      # @!attribute requested_end_timestamp
+      #   The end timestamp you requested (in seconds)
+      #
+      #   @return [Integer]
+      required :requested_end_timestamp, Integer, api_name: :requestedEndTimestamp
+
+      # @!attribute requested_start_timestamp
+      #   The start timestamp you requested (in seconds)
+      #
+      #   @return [Integer]
+      required :requested_start_timestamp, Integer, api_name: :requestedStartTimestamp
+
+      # @!attribute tasks
+      #   Array of background task information for each pipeline evaluation
+      #
+      #   @return [Array<Openlayer::Models::TestEvaluateResponse::Task>]
+      required :tasks, -> { Openlayer::Internal::Type::ArrayOf[Openlayer::Models::TestEvaluateResponse::Task] }
+
+      # @!method initialize(message:, pipeline_count:, requested_end_timestamp:, requested_start_timestamp:, tasks:)
+      #   @param message [String]
+      #
+      #   @param pipeline_count [Integer] Number of inference pipelines the test was queued for evaluation on
+      #
+      #   @param requested_end_timestamp [Integer] The end timestamp you requested (in seconds)
+      #
+      #   @param requested_start_timestamp [Integer] The start timestamp you requested (in seconds)
+      #
+      #   @param tasks [Array<Openlayer::Models::TestEvaluateResponse::Task>] Array of background task information for each pipeline evaluation
+
+      class Task < Openlayer::Internal::Type::BaseModel
+        # @!attribute pipeline_id
+        #   ID of the inference pipeline this task is for
+        #
+        #   @return [String]
+        required :pipeline_id, String, api_name: :pipelineId
+
+        # @!attribute task_result_id
+        #   ID of the background task
+        #
+        #   @return [String]
+        required :task_result_id, String, api_name: :taskResultId
+
+        # @!attribute task_result_url
+        #   URL to check the status of this background task
+        #
+        #   @return [String]
+        required :task_result_url, String, api_name: :taskResultUrl
+
+        # @!method initialize(pipeline_id:, task_result_id:, task_result_url:)
+        #   @param pipeline_id [String] ID of the inference pipeline this task is for
+        #
+        #   @param task_result_id [String] ID of the background task
+        #
+        #   @param task_result_url [String] URL to check the status of this background task
+      end
+    end
+  end
+end

data/lib/openlayer/models.rb

@@ -58,4 +58,6 @@ module Openlayer
   Projects = Openlayer::Models::Projects
 
   Storage = Openlayer::Models::Storage
+
+  TestEvaluateParams = Openlayer::Models::TestEvaluateParams
 end

data/lib/openlayer/resources/tests.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Openlayer
+  module Resources
+    class Tests
+      # Some parameter documentations has been truncated, see
+      # {Openlayer::Models::TestEvaluateParams} for more details.
+      #
+      # Triggers one-off evaluation of a specific monitoring test for a custom timestamp
+      # range. This allows evaluating tests for historical data or custom time periods
+      # outside the regular evaluation window schedule. It also allows overwriting the
+      # existing test results.
+      #
+      # @overload evaluate(test_id, end_timestamp:, start_timestamp:, inference_pipeline_id: nil, overwrite_results: nil, request_options: {})
+      #
+      # @param test_id [String] The test id.
+      #
+      # @param end_timestamp [Integer] End timestamp in seconds (Unix epoch)
+      #
+      # @param start_timestamp [Integer] Start timestamp in seconds (Unix epoch)
+      #
+      # @param inference_pipeline_id [String] ID of the inference pipeline to evaluate. If not provided, all inference pipelin
+      #
+      # @param overwrite_results [Boolean] Whether to overwrite existing test results
+      #
+      # @param request_options [Openlayer::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Openlayer::Models::TestEvaluateResponse]
+      #
+      # @see Openlayer::Models::TestEvaluateParams
+      def evaluate(test_id, params)
+        parsed, options = Openlayer::TestEvaluateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["tests/%1$s/evaluate", test_id],
+          body: parsed,
+          model: Openlayer::Models::TestEvaluateResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Openlayer::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/openlayer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Openlayer
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/openlayer.rb

@@ -87,6 +87,8 @@ require_relative "openlayer/models/projects/test_update_params"
 require_relative "openlayer/models/projects/test_update_response"
 require_relative "openlayer/models/storage/presigned_url_create_params"
 require_relative "openlayer/models/storage/presigned_url_create_response"
+require_relative "openlayer/models/test_evaluate_params"
+require_relative "openlayer/models/test_evaluate_response"
 require_relative "openlayer/models"
 require_relative "openlayer/resources/commits"
 require_relative "openlayer/resources/commits/test_results"
@@ -100,3 +102,4 @@ require_relative "openlayer/resources/projects/inference_pipelines"
 require_relative "openlayer/resources/projects/tests"
 require_relative "openlayer/resources/storage"
 require_relative "openlayer/resources/storage/presigned_url"
+require_relative "openlayer/resources/tests"

data/rbi/google_discovery_engine.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+# frozen_string_literal: true
+
+# Stub for google-cloud-discovery_engine-v1 gem
+module Google
+  module Cloud
+    module DiscoveryEngine
+      module V1
+        class Query
+          sig { params(text: String).void }
+          def initialize(
+            text:
+          )
+          end
+          sig { returns(String) }
+          def text; end
+        end
+
+        class ConversationalSearchService
+          class Client
+            sig { void }
+            def initialize; end
+
+            sig do
+              params(
+                serving_config: String,
+                query: Query,
+                session: T.nilable(String),
+                kwargs: T.untyped
+              ).returns(T.untyped)
+            end
+            def answer_query(
+              serving_config:,
+              query:,
+              session: nil,
+              **kwargs
+            )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/client.rbi

@@ -25,6 +25,9 @@ module Openlayer
     sig { returns(Openlayer::Resources::Storage) }
     attr_reader :storage
 
+    sig { returns(Openlayer::Resources::Tests) }
+    attr_reader :tests
+
     # @api private
     sig { override.returns(T::Hash[String, String]) }
     private def auth_headers

data/rbi/openlayer/integrations.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Openlayer
+  module Integrations
+    class GoogleConversationalSearchTracer
+      sig do
+        params(
+          client: T.untyped,
+          openlayer_client: Openlayer::Client,
+          inference_pipeline_id: String
+        ).void
+      end
+      def self.trace_client(
+        client,
+        openlayer_client:,
+        inference_pipeline_id:
+      )
+      end
+    end
+  end
+end

data/rbi/openlayer/models/test_evaluate_params.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Openlayer
+  module Models
+    class TestEvaluateParams < Openlayer::Internal::Type::BaseModel
+      extend Openlayer::Internal::Type::RequestParameters::Converter
+      include Openlayer::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Openlayer::TestEvaluateParams, Openlayer::Internal::AnyHash)
+        end
+
+      # End timestamp in seconds (Unix epoch)
+      sig { returns(Integer) }
+      attr_accessor :end_timestamp
+
+      # Start timestamp in seconds (Unix epoch)
+      sig { returns(Integer) }
+      attr_accessor :start_timestamp
+
+      # ID of the inference pipeline to evaluate. If not provided, all inference
+      # pipelines the test applies to will be evaluated.
+      sig { returns(T.nilable(String)) }
+      attr_reader :inference_pipeline_id
+
+      sig { params(inference_pipeline_id: String).void }
+      attr_writer :inference_pipeline_id
+
+      # Whether to overwrite existing test results
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :overwrite_results
+
+      sig { params(overwrite_results: T::Boolean).void }
+      attr_writer :overwrite_results
+
+      sig do
+        params(
+          end_timestamp: Integer,
+          start_timestamp: Integer,
+          inference_pipeline_id: String,
+          overwrite_results: T::Boolean,
+          request_options: Openlayer::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # End timestamp in seconds (Unix epoch)
+        end_timestamp:,
+        # Start timestamp in seconds (Unix epoch)
+        start_timestamp:,
+        # ID of the inference pipeline to evaluate. If not provided, all inference
+        # pipelines the test applies to will be evaluated.
+        inference_pipeline_id: nil,
+        # Whether to overwrite existing test results
+        overwrite_results: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            end_timestamp: Integer,
+            start_timestamp: Integer,
+            inference_pipeline_id: String,
+            overwrite_results: T::Boolean,
+            request_options: Openlayer::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/openlayer/models/test_evaluate_response.rbi

@@ -0,0 +1,121 @@
+# typed: strong
+
+module Openlayer
+  module Models
+    class TestEvaluateResponse < Openlayer::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Openlayer::Models::TestEvaluateResponse,
+            Openlayer::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :message
+
+      # Number of inference pipelines the test was queued for evaluation on
+      sig { returns(Integer) }
+      attr_accessor :pipeline_count
+
+      # The end timestamp you requested (in seconds)
+      sig { returns(Integer) }
+      attr_accessor :requested_end_timestamp
+
+      # The start timestamp you requested (in seconds)
+      sig { returns(Integer) }
+      attr_accessor :requested_start_timestamp
+
+      # Array of background task information for each pipeline evaluation
+      sig { returns(T::Array[Openlayer::Models::TestEvaluateResponse::Task]) }
+      attr_accessor :tasks
+
+      sig do
+        params(
+          message: String,
+          pipeline_count: Integer,
+          requested_end_timestamp: Integer,
+          requested_start_timestamp: Integer,
+          tasks: T::Array[Openlayer::Models::TestEvaluateResponse::Task::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        message:,
+        # Number of inference pipelines the test was queued for evaluation on
+        pipeline_count:,
+        # The end timestamp you requested (in seconds)
+        requested_end_timestamp:,
+        # The start timestamp you requested (in seconds)
+        requested_start_timestamp:,
+        # Array of background task information for each pipeline evaluation
+        tasks:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            message: String,
+            pipeline_count: Integer,
+            requested_end_timestamp: Integer,
+            requested_start_timestamp: Integer,
+            tasks: T::Array[Openlayer::Models::TestEvaluateResponse::Task]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Task < Openlayer::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Openlayer::Models::TestEvaluateResponse::Task,
+              Openlayer::Internal::AnyHash
+            )
+          end
+
+        # ID of the inference pipeline this task is for
+        sig { returns(String) }
+        attr_accessor :pipeline_id
+
+        # ID of the background task
+        sig { returns(String) }
+        attr_accessor :task_result_id
+
+        # URL to check the status of this background task
+        sig { returns(String) }
+        attr_accessor :task_result_url
+
+        sig do
+          params(
+            pipeline_id: String,
+            task_result_id: String,
+            task_result_url: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # ID of the inference pipeline this task is for
+          pipeline_id:,
+          # ID of the background task
+          task_result_id:,
+          # URL to check the status of this background task
+          task_result_url:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              pipeline_id: String,
+              task_result_id: String,
+              task_result_url: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openlayer/models.rbi

@@ -23,4 +23,6 @@ module Openlayer
   Projects = Openlayer::Models::Projects
 
   Storage = Openlayer::Models::Storage
+
+  TestEvaluateParams = Openlayer::Models::TestEvaluateParams
 end

data/rbi/openlayer/resources/tests.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Openlayer
+  module Resources
+    class Tests
+      # Triggers one-off evaluation of a specific monitoring test for a custom timestamp
+      # range. This allows evaluating tests for historical data or custom time periods
+      # outside the regular evaluation window schedule. It also allows overwriting the
+      # existing test results.
+      sig do
+        params(
+          test_id: String,
+          end_timestamp: Integer,
+          start_timestamp: Integer,
+          inference_pipeline_id: String,
+          overwrite_results: T::Boolean,
+          request_options: Openlayer::RequestOptions::OrHash
+        ).returns(Openlayer::Models::TestEvaluateResponse)
+      end
+      def evaluate(
+        # The test id.
+        test_id,
+        # End timestamp in seconds (Unix epoch)
+        end_timestamp:,
+        # Start timestamp in seconds (Unix epoch)
+        start_timestamp:,
+        # ID of the inference pipeline to evaluate. If not provided, all inference
+        # pipelines the test applies to will be evaluated.
+        inference_pipeline_id: nil,
+        # Whether to overwrite existing test results
+        overwrite_results: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Openlayer::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/sig/openlayer/client.rbs

@@ -18,6 +18,8 @@ module Openlayer
 
     attr_reader storage: Openlayer::Resources::Storage
 
+    attr_reader tests: Openlayer::Resources::Tests
+
     private def auth_headers: -> ::Hash[String, String]
 
     def initialize: (

data/sig/openlayer/models/test_evaluate_params.rbs

@@ -0,0 +1,45 @@
+module Openlayer
+  module Models
+    type test_evaluate_params =
+      {
+        end_timestamp: Integer,
+        start_timestamp: Integer,
+        inference_pipeline_id: String,
+        overwrite_results: bool
+      }
+      & Openlayer::Internal::Type::request_parameters
+
+    class TestEvaluateParams < Openlayer::Internal::Type::BaseModel
+      extend Openlayer::Internal::Type::RequestParameters::Converter
+      include Openlayer::Internal::Type::RequestParameters
+
+      attr_accessor end_timestamp: Integer
+
+      attr_accessor start_timestamp: Integer
+
+      attr_reader inference_pipeline_id: String?
+
+      def inference_pipeline_id=: (String) -> String
+
+      attr_reader overwrite_results: bool?
+
+      def overwrite_results=: (bool) -> bool
+
+      def initialize: (
+        end_timestamp: Integer,
+        start_timestamp: Integer,
+        ?inference_pipeline_id: String,
+        ?overwrite_results: bool,
+        ?request_options: Openlayer::request_opts
+      ) -> void
+
+      def to_hash: -> {
+        end_timestamp: Integer,
+        start_timestamp: Integer,
+        inference_pipeline_id: String,
+        overwrite_results: bool,
+        request_options: Openlayer::RequestOptions
+      }
+    end
+  end
+end

data/sig/openlayer/models/test_evaluate_response.rbs

@@ -0,0 +1,63 @@
+module Openlayer
+  module Models
+    type test_evaluate_response =
+      {
+        message: String,
+        pipeline_count: Integer,
+        requested_end_timestamp: Integer,
+        requested_start_timestamp: Integer,
+        tasks: ::Array[Openlayer::Models::TestEvaluateResponse::Task]
+      }
+
+    class TestEvaluateResponse < Openlayer::Internal::Type::BaseModel
+      attr_accessor message: String
+
+      attr_accessor pipeline_count: Integer
+
+      attr_accessor requested_end_timestamp: Integer
+
+      attr_accessor requested_start_timestamp: Integer
+
+      attr_accessor tasks: ::Array[Openlayer::Models::TestEvaluateResponse::Task]
+
+      def initialize: (
+        message: String,
+        pipeline_count: Integer,
+        requested_end_timestamp: Integer,
+        requested_start_timestamp: Integer,
+        tasks: ::Array[Openlayer::Models::TestEvaluateResponse::Task]
+      ) -> void
+
+      def to_hash: -> {
+        message: String,
+        pipeline_count: Integer,
+        requested_end_timestamp: Integer,
+        requested_start_timestamp: Integer,
+        tasks: ::Array[Openlayer::Models::TestEvaluateResponse::Task]
+      }
+
+      type task =
+        { pipeline_id: String, task_result_id: String, task_result_url: String }
+
+      class Task < Openlayer::Internal::Type::BaseModel
+        attr_accessor pipeline_id: String
+
+        attr_accessor task_result_id: String
+
+        attr_accessor task_result_url: String
+
+        def initialize: (
+          pipeline_id: String,
+          task_result_id: String,
+          task_result_url: String
+        ) -> void
+
+        def to_hash: -> {
+          pipeline_id: String,
+          task_result_id: String,
+          task_result_url: String
+        }
+      end
+    end
+  end
+end

data/sig/openlayer/models.rbs

@@ -18,4 +18,6 @@ module Openlayer
   module Projects = Openlayer::Models::Projects
 
   module Storage = Openlayer::Models::Storage
+
+  class TestEvaluateParams = Openlayer::Models::TestEvaluateParams
 end

data/sig/openlayer/resources/tests.rbs

@@ -0,0 +1,16 @@
+module Openlayer
+  module Resources
+    class Tests
+      def evaluate: (
+        String test_id,
+        end_timestamp: Integer,
+        start_timestamp: Integer,
+        ?inference_pipeline_id: String,
+        ?overwrite_results: bool,
+        ?request_options: Openlayer::request_opts
+      ) -> Openlayer::Models::TestEvaluateResponse
+
+      def initialize: (client: Openlayer::Client) -> void
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openlayer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Openlayer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-16 00:00:00.000000000 Z
+date: 2025-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -39,6 +39,7 @@ files:
 - lib/openlayer/client.rb
 - lib/openlayer/errors.rb
 - lib/openlayer/file_part.rb
+- lib/openlayer/integrations/google_conversational_search_tracer.rb
 - lib/openlayer/internal.rb
 - lib/openlayer/internal/transport/base_client.rb
 - lib/openlayer/internal/transport/pooled_net_requester.rb
@@ -90,6 +91,8 @@ files:
 - lib/openlayer/models/projects/test_update_response.rb
 - lib/openlayer/models/storage/presigned_url_create_params.rb
 - lib/openlayer/models/storage/presigned_url_create_response.rb
+- lib/openlayer/models/test_evaluate_params.rb
+- lib/openlayer/models/test_evaluate_response.rb
 - lib/openlayer/request_options.rb
 - lib/openlayer/resources/commits.rb
 - lib/openlayer/resources/commits/test_results.rb
@@ -103,11 +106,14 @@ files:
 - lib/openlayer/resources/projects/tests.rb
 - lib/openlayer/resources/storage.rb
 - lib/openlayer/resources/storage/presigned_url.rb
+- lib/openlayer/resources/tests.rb
 - lib/openlayer/version.rb
 - manifest.yaml
+- rbi/google_discovery_engine.rbi
 - rbi/openlayer/client.rbi
 - rbi/openlayer/errors.rbi
 - rbi/openlayer/file_part.rbi
+- rbi/openlayer/integrations.rbi
 - rbi/openlayer/internal.rbi
 - rbi/openlayer/internal/transport/base_client.rbi
 - rbi/openlayer/internal/transport/pooled_net_requester.rbi
@@ -159,6 +165,8 @@ files:
 - rbi/openlayer/models/projects/test_update_response.rbi
 - rbi/openlayer/models/storage/presigned_url_create_params.rbi
 - rbi/openlayer/models/storage/presigned_url_create_response.rbi
+- rbi/openlayer/models/test_evaluate_params.rbi
+- rbi/openlayer/models/test_evaluate_response.rbi
 - rbi/openlayer/request_options.rbi
 - rbi/openlayer/resources/commits.rbi
 - rbi/openlayer/resources/commits/test_results.rbi
@@ -172,6 +180,7 @@ files:
 - rbi/openlayer/resources/projects/tests.rbi
 - rbi/openlayer/resources/storage.rbi
 - rbi/openlayer/resources/storage/presigned_url.rbi
+- rbi/openlayer/resources/tests.rbi
 - rbi/openlayer/version.rbi
 - sig/openlayer/client.rbs
 - sig/openlayer/errors.rbs
@@ -227,6 +236,8 @@ files:
 - sig/openlayer/models/projects/test_update_response.rbs
 - sig/openlayer/models/storage/presigned_url_create_params.rbs
 - sig/openlayer/models/storage/presigned_url_create_response.rbs
+- sig/openlayer/models/test_evaluate_params.rbs
+- sig/openlayer/models/test_evaluate_response.rbs
 - sig/openlayer/request_options.rbs
 - sig/openlayer/resources/commits.rbs
 - sig/openlayer/resources/commits/test_results.rbs
@@ -240,6 +251,7 @@ files:
 - sig/openlayer/resources/projects/tests.rbs
 - sig/openlayer/resources/storage.rbs
 - sig/openlayer/resources/storage/presigned_url.rbs
+- sig/openlayer/resources/tests.rbs
 - sig/openlayer/version.rbs
 homepage: https://gemdocs.org/gems/openlayer
 licenses: []