nitro_intelligence 0.0.1 → 1.0.0

data/lib/nitro_intelligence/observability/prompt_store.rb

@@ -0,0 +1,112 @@
+require "base64"
+require "cgi"
+require "httparty"
+
+require "nitro_intelligence/observability/prompt"
+
+module NitroIntelligence
+  module Observability
+    class PromptStore
+      OBSERVABILITY_PROMPTS_CACHE_KEY_PREFIX = "nitro_intelligence_observability_prompts_".freeze
+
+      class ObservabilityPromptError < StandardError; end
+      class ObservabilityPromptNotFoundError < StandardError; end
+
+      def initialize(observability_project_slug:, observability_public_key:, observability_secret_key:)
+        @observability_project_slug = observability_project_slug
+        @observability_public_key = observability_public_key
+        @observability_secret_key = observability_secret_key
+        @observability_host = NitroIntelligence.config.observability_base_url
+      end
+
+      def get_prompt(prompt_name:, prompt_label: nil, prompt_version: nil)
+        safe_prompt_name = CGI.escapeURIComponent(prompt_name)
+        prompt = nil
+
+        if prompt_version.present?
+          prompt = get_prompt_by_version(safe_prompt_name:, prompt_version:)
+        else
+          prompt_label = "production" if prompt_label.nil?
+          prompt = get_prompt_by_label(safe_prompt_name:, prompt_label:)
+        end
+
+        prompt = Prompt.new(**prompt) if prompt.present?
+
+        prompt
+      end
+
+    private
+
+      def get_prompt_by_label(safe_prompt_name:, prompt_label:)
+        cache_key = "#{OBSERVABILITY_PROMPTS_CACHE_KEY_PREFIX}#{@observability_project_slug}_" \
+                    "#{safe_prompt_name}_#{prompt_label}"
+        if (cached_prompt = NitroIntelligence.cache.read(cache_key)).present?
+          return cached_prompt
+        end
+
+        NitroIntelligence.logger.info(
+          "#{self.class} - Prompt label cache miss. Fetching prompt: #{safe_prompt_name} - #{prompt_label}"
+        )
+        get_prompt_request(safe_prompt_name:, prompt_url_params: "label=#{prompt_label}")
+      rescue => e
+        if (rolling_cached_prompt = NitroIntelligence.cache.read("#{cache_key}_rolling")).present?
+          NitroIntelligence.logger.warn(
+            "#{self.class} #{e} - Using rolling cached prompt: #{safe_prompt_name} - #{prompt_label}"
+          )
+          return rolling_cached_prompt
+        end
+
+        raise e
+      end
+
+      def get_prompt_by_version(safe_prompt_name:, prompt_version:)
+        cache_key = "#{OBSERVABILITY_PROMPTS_CACHE_KEY_PREFIX}#{@observability_project_slug}_" \
+                    "#{safe_prompt_name}_#{prompt_version}"
+
+        if (cached_prompt = NitroIntelligence.cache.read(cache_key)).present?
+          return cached_prompt
+        end
+
+        NitroIntelligence.logger.info(
+          "#{self.class} - Prompt version cache miss. Fetching prompt: #{safe_prompt_name} - #{prompt_version}"
+        )
+        get_prompt_request(safe_prompt_name:, prompt_url_params: "version=#{prompt_version}")
+      end
+
+      def get_prompt_request(safe_prompt_name:, prompt_url_params:)
+        auth_token = Base64.strict_encode64("#{@observability_public_key}:#{@observability_secret_key}")
+        response = HTTParty.get(
+          "#{@observability_host}/api/public/v2/prompts/#{safe_prompt_name}?#{prompt_url_params}",
+          headers: {
+            "Authorization" => "Basic #{auth_token}",
+          }
+        )
+
+        if response.code != 200
+          raise ObservabilityPromptNotFoundError, "Prompt: #{safe_prompt_name} Not Found" if response.code == 404
+
+          raise ObservabilityPromptError, response.body
+        end
+
+        prompt = JSON.parse(response.body, symbolize_names: true)
+        write_prompt_caches(safe_prompt_name:, prompt:)
+        prompt
+      end
+
+      def write_prompt_caches(safe_prompt_name:, prompt:)
+        # Write versioned cache key
+        version_cache_key = "#{OBSERVABILITY_PROMPTS_CACHE_KEY_PREFIX}#{@observability_project_slug}_" \
+                            "#{safe_prompt_name}_#{prompt[:version]}"
+        NitroIntelligence.cache.write(version_cache_key, prompt, expires_in: nil)
+
+        # Store all versions in an array cache per label
+        prompt[:labels].each do |label|
+          label_cache_key = "#{OBSERVABILITY_PROMPTS_CACHE_KEY_PREFIX}#{@observability_project_slug}_" \
+                            "#{safe_prompt_name}_#{label}"
+          NitroIntelligence.cache.write(label_cache_key, prompt, expires_in: 5.minutes)
+          NitroIntelligence.cache.write("#{label_cache_key}_rolling", prompt, expires_in: nil)
+        end
+      end
+    end
+  end
+end

data/lib/nitro_intelligence/observability/upload_handler.rb

@@ -0,0 +1,138 @@
+require "base64"
+require "digest"
+require "httparty"
+require "time"
+
+module NitroIntelligence
+  module Observability
+    class UploadHandler
+      def initialize(auth_token:)
+        @host = NitroIntelligence.config.observability_base_url
+        @auth_token = auth_token
+        @uploaded_media = []
+      end
+
+      def replace_base64_with_media_references(payload)
+        # Make it easier to lookup message style image_urls
+        media_lookup = @uploaded_media.index_by { |image| "data:#{image.mime_type};base64,#{image.base64}" }
+
+        replace_base64_image_url = ->(node) do
+          case node
+          when Hash
+            url_key = if node.key?(:url)
+                        :url
+                      else
+                        (node.key?("url") ? "url" : nil)
+                      end
+
+            if url_key
+              url_value = node[url_key]
+
+              # Replace base64 strings if they match with our uploaded media
+              if (media = media_lookup[url_value])
+                # Overwrite base64 string with Langfuse media ref
+                # This *should* be rendering inline in the gui
+                # https://github.com/langfuse/langfuse/issues/4555
+                # https://github.com/langfuse/langfuse/issues/5030
+                node[url_key] = "@@@langfuseMedia:type=#{media.mime_type}|id=#{media.reference_id}|source=bytes@@@"
+              # Sometimes models can generate unwanted images that will not have a reference
+              # these untracked base64 strings can easily push 4.5mb Langfuse limit
+              elsif url_value.is_a?(String) && url_value.start_with?("data:")
+                node[url_key] = "[Discarded media]"
+              end
+            end
+
+            node.each_value { |val| replace_base64_image_url.call(val) }
+
+          when Array
+            node.each { |val| replace_base64_image_url.call(val) }
+          end
+        end
+
+        replace_base64_image_url.call(payload)
+
+        payload
+      end
+
+      def upload(trace_id, upload_queue: Queue.new)
+        until upload_queue.empty?
+          media = upload_queue.pop
+
+          content_length = media.byte_string.bytesize
+          content_sha256 = Base64.strict_encode64(Digest::SHA256.digest(media.byte_string))
+
+          # returns {"mediaId" -> "", "uploadUrl" => ""}
+          upload_url_response = get_upload_url({
+                                                 traceId: trace_id,
+                                                 contentType: media.mime_type,
+                                                 contentLength: content_length,
+                                                 sha256Hash: content_sha256,
+                                                 field: media.direction,
+                                               })
+
+          # NOTE: uploadUrl is None if the file is stored in Langfuse already
+          # there is no need to upload it again.
+          upload_response = upload_media(
+            upload_url_response["mediaId"],
+            upload_url_response["uploadUrl"],
+            media.mime_type,
+            content_sha256,
+            media.byte_string
+          )
+
+          associate_media(upload_url_response["mediaId"], upload_response) if upload_response.present?
+
+          media.reference_id = upload_url_response["mediaId"]
+          @uploaded_media.append(media)
+        end
+
+        @uploaded_media
+      end
+
+    private
+
+      def get_upload_url(request_body)
+        HTTParty.post(
+          "#{@host}/api/public/media",
+          body: request_body.to_json,
+          headers: {
+            "Content-Type" => "application/json",
+            "Authorization" => "Basic #{@auth_token}",
+          }
+        )
+      end
+
+      def associate_media(media_id, upload_response)
+        request_body = {
+          uploadedAt: Time.now.utc.iso8601(6),
+          uploadHttpStatus: upload_response.code,
+          uploadHttpError: upload_response.code == 200 ? nil : upload_response.body,
+        }
+
+        HTTParty.patch(
+          "#{@host}/api/public/media/#{media_id}",
+          body: request_body.to_json,
+          headers: {
+            "Content-Type" => "application/json",
+            "Authorization" => "Basic #{@auth_token}",
+          }
+        )
+      end
+
+      def upload_media(media_id, upload_url, content_type, content_sha256, content_bytes)
+        if media_id.present? && upload_url.present?
+          return HTTParty.put(
+            upload_url,
+            headers: {
+              "Content-Type" => content_type,
+              "x-amz-checksum-sha256" => content_sha256,
+            },
+            body: content_bytes
+          )
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/nitro_intelligence/reporter.rb

@@ -0,0 +1,43 @@
+require "base64"
+require "httparty"
+
+module NitroIntelligence
+  class Reporter
+    def initialize(observability_project_slug:)
+      @observability_project_slug = observability_project_slug
+      @project_client = fetch_project_client
+      @host = NitroIntelligence.config.observability_base_url
+    end
+
+    def create_dataset_item(attributes)
+      HTTParty.post("#{@host}/api/public/dataset-items",
+                    body: attributes.to_json,
+                    headers: {
+                      "Content-Type" => "application/json",
+                      "Authorization" => "Basic #{@project_client.project.auth_token}",
+                    })
+    end
+
+    def score(trace_id:, name:, value:, id: "#{trace_id}-#{name}")
+      @project_client.observability_client.create_score(
+        id:,
+        trace_id:,
+        name:,
+        value:,
+        environment: NitroIntelligence.environment
+      )
+    end
+
+  private
+
+    def fetch_project_client
+      project_client = NitroIntelligence.project_client_registry.fetch(@observability_project_slug)
+      if project_client.nil?
+        raise NitroIntelligence::Observability::ProjectClient::NotFoundError,
+              "No project session found for slug: #{@observability_project_slug}"
+      end
+
+      project_client
+    end
+  end
+end

data/lib/nitro_intelligence/tool_call_review_validator.rb

@@ -0,0 +1,69 @@
+require "active_support/core_ext/hash/indifferent_access"
+
+module NitroIntelligence
+  class ToolCallReviewValidator
+    def validate!(thread_state:, tool_calls:, pending_tool_calls:)
+      tool_calls = normalize_tool_calls(tool_calls)
+      pending_tool_calls_by_id = Array(pending_tool_calls).index_by { |tool_call| tool_call["id"] }
+      review_actions = Array(thread_state.dig("interrupts", 0, "value", "review_actions"))
+
+      tool_calls.each do |tool_call_id, review|
+        pending_tool_call = pending_tool_calls_by_id[tool_call_id]&.with_indifferent_access
+        raise_error!("Unknown tool call ids: #{tool_call_id}") unless pending_tool_call
+
+        review = normalize_review(tool_call_id, review)
+        review_action = review[:action].to_s
+
+        unless review_actions.include?(review_action)
+          raise_error!("Invalid review action `#{review_action}` for tool call #{tool_call_id}")
+        end
+
+        validate_edited_args!(tool_call_id:, review:, pending_tool_call:) if review_action == "edit"
+      end
+
+      validate_completeness!(
+        submitted_tool_call_ids: tool_calls.keys,
+        pending_tool_calls:
+      )
+    end
+
+  private
+
+    def normalize_tool_calls(tool_calls)
+      raise_error!("tool_calls must be a hash") unless tool_calls.is_a?(Hash)
+
+      tool_calls.with_indifferent_access
+    end
+
+    def normalize_review(tool_call_id, review)
+      raise_error!("Review for tool call #{tool_call_id} must be a hash") unless review.is_a?(Hash)
+
+      review.with_indifferent_access
+    end
+
+    def validate_edited_args!(tool_call_id:, review:, pending_tool_call:)
+      provided_args = review[:args]
+      raise_error!("Edited args for tool call #{tool_call_id} must be a hash") unless provided_args.is_a?(Hash)
+
+      valid_arg_names = pending_tool_call.fetch(:args, {}).keys.map(&:to_s)
+      invalid_arg_names = provided_args.keys.map(&:to_s) - valid_arg_names
+      return if invalid_arg_names.empty?
+
+      raise_error!("Invalid edited args for tool call #{tool_call_id}: #{invalid_arg_names.join(', ')}")
+    end
+
+    def validate_completeness!(submitted_tool_call_ids:, pending_tool_calls:)
+      missing_tool_call_ids = Array(pending_tool_calls).filter_map do |tool_call|
+        tool_call_id = tool_call["id"].to_s
+        tool_call_id unless submitted_tool_call_ids.include?(tool_call_id)
+      end
+      return if missing_tool_call_ids.empty?
+
+      raise_error!("Missing reviews for tool calls: #{missing_tool_call_ids.join(', ')}")
+    end
+
+    def raise_error!(message)
+      raise NitroIntelligence::AgentServer::ThreadResumptionError, message
+    end
+  end
+end

data/lib/nitro_intelligence/trace.rb

@@ -1,7 +1,7 @@
 module NitroIntelligence
   module Trace
-    def self.create_id(seed: SecureRandom.uuid, length: 32)
-      Digest::SHA256.hexdigest(seed)[0, length]
+    def self.create_id(seed:)
+      Langfuse::TraceId.create(seed:)
     end
   end
 end

data/lib/nitro_intelligence/version.rb

@@ -1,3 +1,3 @@
 module NitroIntelligence
-  VERSION = "0.0.1".freeze
+  VERSION = "1.0.0".freeze
 end

data/lib/nitro_intelligence.rb

@@ -1,31 +1,21 @@
 require "active_support"
 require "active_support/core_ext"
 require "base64"
-require "httparty"
+
 require "langfuse"
 require "openai"
 
 require "nitro_intelligence/version"
 require "nitro_intelligence/agent_server"
-require "nitro_intelligence/client"
+require "nitro_intelligence/client/base"
+require "nitro_intelligence/client/client"
 require "nitro_intelligence/configuration"
-require "nitro_intelligence/langfuse_extension"
-require "nitro_intelligence/langfuse_tracer_provider"
 require "nitro_intelligence/media/image_generation"
-require "nitro_intelligence/media/upload_handler"
 require "nitro_intelligence/models/model_catalog"
-require "nitro_intelligence/prompt/prompt_store"
+require "nitro_intelligence/observability/project_client_registry"
+require "nitro_intelligence/reporter"
 
 module NitroIntelligence
-  OBSERVABILITY_PROJECTS_CACHE_KEY_PREFIX = "nitro_intelligence_observability_projects_".freeze
-  CUSTOM_PARAMS = %i[observability_project_slug prompt_config_disabled prompt_label
-                     prompt_name prompt_variables prompt_version trace_name user_id trace_seed].freeze
-
-  class ObservabilityUnavailableError < StandardError; end
-  class ObservabilityProjectNotFoundError < StandardError; end
-  class ObservabilityProjectConfigNotFoundError < StandardError; end
-  class LangfuseClientNotFoundError < StandardError; end
-
   mattr_accessor :configuration, default: Configuration
 
   class << self
@@ -40,37 +30,13 @@ module NitroIntelligence
     end
 
     def model_catalog
-      @model_catalog ||= NitroIntelligence::ModelCatalog.new(configuration.model_config)
-    end
-
-    def omit_params
-      (CUSTOM_PARAMS + ImageGeneration::Config::CUSTOM_PARAMS).uniq
+      @model_catalog ||= ModelCatalog.new(configuration.model_config)
     end
 
-    def langfuse_clients
-      if @langfuse_clients.nil?
-        NitroIntelligence.logger.warn("Langfuse clients were not initialized")
-        return {}
-      end
-
-      @langfuse_clients
-    end
-
-    def initialize_langfuse_clients
-      @langfuse_clients = configuration.observability_projects.to_h do |project|
-        key = project["slug"]
-
-        value = LangfuseExtension.new do |config|
-          config.public_key = project["public_key"]
-          config.secret_key = project["secret_key"]
-          config.base_url = NitroIntelligence.config.observability_base_url
-          # Default flush of 60 seconds can be too quick when
-          # dealing with longer responses like image gen
-          config.flush_interval = 120
-        end
-
-        [key, value]
-      end
+    def project_client_registry
+      @project_client_registry ||= Observability::ProjectClientRegistry.new(
+        base_url: configuration.observability_base_url
+      )
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nitro_intelligence
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Igor Artemenko
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: mini_magick
   requirement: !ruby/object:Gem::Requirement
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.23.0
+        version: '0.58'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.23.0
+        version: '0.58'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -236,20 +236,36 @@ files:
 - docs/README.md
 - lib/nitro_intelligence.rb
 - lib/nitro_intelligence/agent_server.rb
-- lib/nitro_intelligence/client.rb
+- lib/nitro_intelligence/client/base.rb
+- lib/nitro_intelligence/client/client.rb
+- lib/nitro_intelligence/client/factory.rb
+- lib/nitro_intelligence/client/handlers/audio_transcription_handler.rb
+- lib/nitro_intelligence/client/handlers/chat_handler.rb
+- lib/nitro_intelligence/client/handlers/image_handler.rb
+- lib/nitro_intelligence/client/handlers/observed/audio_transcription_handler.rb
+- lib/nitro_intelligence/client/handlers/observed/chat_handler.rb
+- lib/nitro_intelligence/client/handlers/observed/image_handler.rb
+- lib/nitro_intelligence/client/observed.rb
+- lib/nitro_intelligence/client/observers/langfuse_observer.rb
 - lib/nitro_intelligence/configuration.rb
 - lib/nitro_intelligence/langfuse_extension.rb
 - lib/nitro_intelligence/langfuse_tracer_provider.rb
+- lib/nitro_intelligence/media/audio.rb
 - lib/nitro_intelligence/media/image.rb
 - lib/nitro_intelligence/media/image_generation.rb
 - lib/nitro_intelligence/media/media.rb
-- lib/nitro_intelligence/media/upload_handler.rb
 - lib/nitro_intelligence/models/model.rb
 - lib/nitro_intelligence/models/model_catalog.rb
 - lib/nitro_intelligence/models/model_factory.rb
 - lib/nitro_intelligence/null_cache.rb
-- lib/nitro_intelligence/prompt/prompt.rb
-- lib/nitro_intelligence/prompt/prompt_store.rb
+- lib/nitro_intelligence/observability/project.rb
+- lib/nitro_intelligence/observability/project_client.rb
+- lib/nitro_intelligence/observability/project_client_registry.rb
+- lib/nitro_intelligence/observability/prompt.rb
+- lib/nitro_intelligence/observability/prompt_store.rb
+- lib/nitro_intelligence/observability/upload_handler.rb
+- lib/nitro_intelligence/reporter.rb
+- lib/nitro_intelligence/tool_call_review_validator.rb
 - lib/nitro_intelligence/trace.rb
 - lib/nitro_intelligence/version.rb
 homepage: https://github.com/powerhome/nitro-intelligence.rb
@@ -264,7 +280,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="