nitro_intelligence 1.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4de13e4abd28f0e4ce7533a094fd184c18f7804a116e8812c8c6ecbd5036521
-  data.tar.gz: b98ecfd8fd43f901bf8a4fd4ee36a41c3740a0c43e7e674a0fc9792cec6b1097
+  metadata.gz: 7d1c0e6c9ddffc032a989ebffb001d58aefabf86e50f92966a6d384a5218628f
+  data.tar.gz: 60b9ae5ef4fd8c7a79bc45f13a1b965c9d9a0792f38bc285e361822b7d91a8ad
 SHA512:
-  metadata.gz: eaa80ace33f1bbdd3c94ef6ea7c7d718903f4cbe1e2559a714be34a6207ddd6c7ebd34a4874f0545d583a76df6af9975b4b36c46ce6eddcfd26a85482c51907c
-  data.tar.gz: 9b404c2f250b6ba80f46ec957faa31895107b81d2011c5f2ad35e3a1cc6845efe8510bd4e5760b8313d5e30dbf2b74a030d3ea09482af9c76fc193fe64b28e95
+  metadata.gz: a13a9b1a0a58f58c142ab87ec89f491f409341717b3101b9bb1579c88b8ed9335413ea73d621c489749b7d151d62672e9277e3d39da80c4721008cad28a301b0
+  data.tar.gz: 1c498a0a4ec99af32f039dd43272ad61650da433c4f4d3b4297aadd473fba4c93af8d9ed08db0d2faf5012ed3a721e6d47587bf5429eb16368161d224f773cf7

data/docs/README.md

@@ -33,6 +33,39 @@ NitroIntelligence.configure do |config|
 
   # Agent server settings (optional)
   config.agent_server_config = {}                # Hash of AgentServer keyword arguments
+
+  # Model configuration
+  config.model_config = {
+    "default_audio_transcription_model" => "gpt-4o-transcribe",
+    "default_text_model" => "gpt-4o-mini",
+    "default_image_model" => "nano-banana-2",
+    "default_text_to_speech_model" => "gpt-4o-mini-tts",
+    "models" => [
+      {
+        "name" => "gpt-4o-mini",
+        "type" => "text"
+      },
+      {
+        "name" => "gpt-4o-transcribe",
+        "type" => "audio_transcription"
+      },
+      {
+        "name" => "nano-banana-2",
+        "type" => "image",
+        "aspect_ratios" => ["1:1", "2:3", "3:2", "3:4", "4:3"],
+        "resolutions" => ["512", "1K", "2K"],
+        "omit_output_fields" => ["provider_specific_fields.thought_signatures"]
+      },
+      {
+        "name" => "gpt-4o-mini-tts",
+        "type" => "text_to_speech",
+        "default_voice" => "marin",
+        "default_response_format" => "mp3",
+        "voices" => ["echo", "nova", "marin", "cedar"],
+        "response_formats" => ["mp3", "wav"]
+      }
+    ]
+  }
 end
 ```
 
@@ -48,6 +81,7 @@ end
 | `observability_base_url` | `String`      | `""`                  | Base URL for the Langfuse observability service                                                                                                                                                            |
 | `observability_projects` | `Array<Hash>` | `[]`                  | Langfuse project credentials (slug, id, public_key, secret_key)                                                                                                                                            |
 | `agent_server_config`    | `Hash`        | `{}`                  | Credentials for `AgentServer.new`. Expected keys: `base_url` (String) — HTTP base URL of the agent server; `api_key` (String) — bearer token; `user_id` (String, default: `"default-user"`) — caller identity |
+| `model_config`           | `Hash`        | `{}`                  | Model defaults and per-model settings. Top-level keys: `default_text_model`, `default_audio_transcription_model`, `default_image_model`, `default_text_to_speech_model`, and `models` (array of per-model hashes keyed by `name` and `type`, with type-specific options like `aspect_ratios`/`resolutions` for images or `voices`/`response_formats` for TTS) |
 
 ## Basic Usage
 
@@ -111,6 +145,40 @@ puts result
 # <OpenAI::Models::Audio::Transcription:0x2fd8c {:text=>"Hola, ¿cómo estás hoy?", :usage=>{:input_tokens=>37, :output_tokens=>9, :total_tokens=>46, :type=>:tokens, :input_token_details=>{:audio_tokens=>28, :text_tokens=>9}}}>
 ```
 
+### Text-to-Speech
+
+Nitro Intelligence can be used to create spoken-word audio files from text.
+
+Basic example of usage:
+
+```ruby
+client = NitroIntelligence::Client.new
+tts = client.text_to_speech(message: 'Hello, this is Power Home Remodeling Group.')
+
+# tts is a StringIO object, we can write the file to disk
+File.binwrite('tts.mp3', tts.string)
+```
+
+Supplying custom parameters:
+
+```ruby
+client = NitroIntelligence::Client.new
+tts = client.text_to_speech(
+  message: 'Hello, this is Power Home Remodeling Group.',
+  parameters: {
+    voice: 'marin',
+    response_format: 'mp3',
+    instructions: 'Translate the English into Spanish before speaking.',
+    speed: 1.25
+  }
+)
+
+# tts is a StringIO object, we can write the file to disk
+File.binwrite('tts.mp3', tts.string)
+```
+
+For a full list of supported parameters, see the [API reference here](https://developers.openai.com/api/reference/resources/audio/subresources/speech/methods/create ). Note that `voice` and `response_format` are further constrained to the `voices` and `response_formats` listed for the chosen model in `config.model_config`.
+
 ### Image Editing and Generation
 
 Nitro Intelligence can be used for image editing and generation

data/lib/nitro_intelligence/agent_server.rb

@@ -1,3 +1,6 @@
+require "json"
+require "net/http"
+require "uri"
 require "nitro_intelligence/tool_call_review_validator"
 
 module NitroIntelligence
@@ -7,6 +10,9 @@ module NitroIntelligence
     class RunError < StandardError; end
     class ThreadResumptionError < StandardError; end
 
+    # Aegra answers with a conflict when `ifExists: "raise"` is sent for a thread that already exists.
+    THREAD_CONFLICT_CODE = 409
+
     attr_reader :base_url, :user_id
 
     def initialize(base_url:, api_key:, user_id: "default-user")
@@ -18,6 +24,7 @@ module NitroIntelligence
       @api_key = api_key
       @user_id = user_id
       @tool_call_review_validator = ToolCallReviewValidator.new
+      @graph_ids = {}
     end
 
     def await_run(thread_id:, assistant_id:, messages:, context: {})
@@ -26,7 +33,7 @@ module NitroIntelligence
       initial_state = messages[0..-2]
       last_message = messages.last
 
-      initialize_thread_if_needed(thread_id:, initial_state:)
+      initialize_thread_if_needed(thread_id:, assistant_id:, initial_state:)
       trigger_run(thread_id:, assistant_id:, context:, last_message:)
     end
 
@@ -74,36 +81,94 @@ module NitroIntelligence
 
   private
 
-    def initialize_thread_if_needed(thread_id:, initial_state:)
-      thread_response = post(
+    # Aegra accepts `initial_state` on thread creation but never applies it, so a brand new thread is
+    # seeded through the thread state endpoint instead. A thread that already exists is left untouched:
+    # its state was seeded when it was created and has been built up by every run since.
+    def initialize_thread_if_needed(thread_id:, assistant_id:, initial_state:)
+      thread_response = create_thread(thread_id:, assistant_id:)
+
+      return if thread_already_exists?(thread_response)
+      raise ThreadInitializationError, thread_response.body if thread_response.code.to_i != 200
+      return if initial_state.blank?
+
+      seed_new_thread_state(thread_id:, initial_state:)
+    end
+
+    # Creating the thread and seeding its state are separate requests, so a failure between them leaves
+    # an empty thread behind. A retry would find that thread, take it for one already under way, skip
+    # seeding and run without the history -- losing the very thing seeding exists for, without an error.
+    # Discard the thread instead, so a retry starts over from a clean slate.
+    def seed_new_thread_state(thread_id:, initial_state:)
+      seed_thread_state(thread_id:, initial_state:)
+    rescue
+      discard_thread(thread_id:)
+      raise
+    end
+
+    def discard_thread(thread_id:)
+      delete(path: "/threads/#{thread_id}")
+    rescue
+      # Best effort. The seeding failure is the one worth surfacing, and it is raised either way.
+    end
+
+    def create_thread(thread_id:, assistant_id:)
+      post(
         path: "/threads",
         body: {
           threadId: thread_id.to_s,
-          ifExists: "do_nothing",
-          initial_state: { messages: initial_state },
+          ifExists: "raise",
+          # Without a graph_id, the thread state cannot be updated before the thread's first run.
+          metadata: { graph_id: graph_id_for(assistant_id) },
           user_id:,
         }
       )
+    end
+
+    def graph_id_for(assistant_id)
+      @graph_ids[assistant_id] ||= fetch_graph_id(assistant_id)
+    end
+
+    def fetch_graph_id(assistant_id)
+      assistant_response = get(path: "/assistants/#{assistant_id}")
+
+      raise ThreadInitializationError, assistant_response.body if assistant_response.code.to_i != 200
+
+      graph_id = JSON.parse(assistant_response.body)["graph_id"]
+
+      raise ThreadInitializationError, "Assistant #{assistant_id} has no graph_id" if graph_id.blank?
+
+      graph_id
+    end
+
+    def seed_thread_state(thread_id:, initial_state:)
+      state_response = post(
+        path: "/threads/#{thread_id}/state",
+        body: { values: { messages: initial_state } }
+      )
 
-      raise ThreadInitializationError, thread_response.body if thread_response.code != 200
+      raise ThreadInitializationError, state_response.body if state_response.code.to_i != 200
 
-      thread_response
+      JSON.parse(state_response.body)
+    end
+
+    def thread_already_exists?(response)
+      response.code.to_i == THREAD_CONFLICT_CODE
     end
 
     def get_thread_state(thread_id:)
       state_response = get(path: "/threads/#{thread_id}/state")
 
-      raise ThreadResumptionError, state_response.body if state_response.code != 200
+      raise ThreadResumptionError, state_response.body if state_response.code.to_i != 200
 
-      state_response
+      JSON.parse(state_response.body)
     end
 
     def get_thread(thread_id:)
       thread_response = get(path: "/threads/#{thread_id}")
 
-      raise ThreadResumptionError, thread_response.body if thread_response.code != 200
+      raise ThreadResumptionError, thread_response.body if thread_response.code.to_i != 200
 
-      thread_response
+      JSON.parse(thread_response.body)
     end
 
     def trigger_run(thread_id:, assistant_id:, last_message:, context: {})
@@ -118,9 +183,10 @@ module NitroIntelligence
         }
       )
 
-      raise RunError, run_response.body if run_response.code != 200
+      raise RunError, run_response.body if run_response.code.to_i != 200
 
-      Array(run_response["messages"]).last&.dig("content")
+      run = JSON.parse(run_response.body)
+      Array(run["messages"]).last&.dig("content")
     end
 
     def resume_run(thread_id:, assistant_id:, resume:, context:)
@@ -135,9 +201,9 @@ module NitroIntelligence
         }
       )
 
-      raise ThreadResumptionError, run_response.body if run_response.code != 200
+      raise ThreadResumptionError, run_response.body if run_response.code.to_i != 200
 
-      run_response
+      JSON.parse(run_response.body)
     end
 
     def interrupted?(thread)
@@ -163,18 +229,37 @@ module NitroIntelligence
     end
 
     def get(path:)
-      HTTParty.get(
-        "#{base_url}#{path}",
-        headers: request_headers
-      )
+      uri = URI("#{base_url}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Get.new(uri)
+      request_headers.each { |k, v| request[k] = v }
+
+      http.request(request)
+    end
+
+    def delete(path:)
+      uri = URI("#{base_url}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Delete.new(uri)
+      request_headers.each { |k, v| request[k] = v }
+
+      http.request(request)
     end
 
     def post(path:, body:)
-      HTTParty.post(
-        "#{base_url}#{path}",
-        headers: request_headers,
-        body: body.to_json
-      )
+      uri = URI("#{base_url}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Post.new(uri)
+      request_headers.each { |k, v| request[k] = v }
+      request.body = body.to_json
+
+      http.request(request)
     end
 
     def request_headers

data/lib/nitro_intelligence/client/base.rb

@@ -1,6 +1,7 @@
 require "nitro_intelligence/client/handlers/audio_transcription_handler"
 require "nitro_intelligence/client/handlers/chat_handler"
 require "nitro_intelligence/client/handlers/image_handler"
+require "nitro_intelligence/client/handlers/text_to_speech_handler"
 
 module NitroIntelligence
   module Client
@@ -26,6 +27,11 @@ module NitroIntelligence
         audio_transcription_handler.create(message:, audio_file:, parameters:)
       end
 
+      # Returns StringIO
+      def text_to_speech(message: "", parameters: {})
+        text_to_speech_handler.create(message:, parameters:)
+      end
+
     private
 
       def audio_transcription_handler
@@ -47,6 +53,10 @@ module NitroIntelligence
       def respond_to_missing?(method_name, include_private = false)
         @client.respond_to?(method_name, include_private) || super
       end
+
+      def text_to_speech_handler
+        @text_to_speech_handler ||= Handlers::TextToSpeechHandler.new(client: @client)
+      end
     end
   end
 end

data/lib/nitro_intelligence/client/handlers/audio_transcription_handler.rb

@@ -1,21 +1,19 @@
 require "openai"
+require "nitro_intelligence/client/handlers/base_handler"
 
 module NitroIntelligence
   module Client
     module Handlers
-      class AudioTranscriptionHandler
+      class AudioTranscriptionHandler < BaseHandler
         ALLOWED_EXTRA_PARAMETERS = OpenAI::Models::Audio::TranscriptionCreateParams.fields.keys.uniq.freeze
 
-        def initialize(client:)
-          @client = client
-        end
-
         def create(audio_file:, message: "", parameters: {})
           validate_and_resolve!(parameters)
           perform_request(audio_file:, message:, parameters:)
         end
 
         def perform_request(audio_file:, message: "", parameters: {})
+          add_request_headers(parameters, MODALITY_HEADER => "audio", REQUESTED_MODEL_HEADER => parameters[:model])
           @client.audio.transcriptions.create(
             prompt: message,
             file: audio_file,

data/lib/nitro_intelligence/client/handlers/base_handler.rb

@@ -0,0 +1,22 @@
+module NitroIntelligence
+  module Client
+    module Handlers
+      class BaseHandler
+        MODALITY_HEADER = "nip-modality".freeze
+        REQUESTED_MODEL_HEADER = "nip-requested-model".freeze
+
+        def initialize(client:)
+          @client = client
+        end
+
+      private
+
+        def add_request_headers(parameters, headers)
+          request_options = (parameters[:request_options] ||= {})
+          (request_options[:extra_headers] ||= {}).merge!(headers.compact)
+          parameters
+        end
+      end
+    end
+  end
+end

data/lib/nitro_intelligence/client/handlers/chat_handler.rb

@@ -1,21 +1,19 @@
 require "openai"
+require "nitro_intelligence/client/handlers/base_handler"
 
 module NitroIntelligence
   module Client
     module Handlers
-      class ChatHandler
+      class ChatHandler < BaseHandler
         ALLOWED_EXTRA_PARAMETERS = OpenAI::Models::Chat::CompletionCreateParams.fields.keys.uniq.freeze
 
-        def initialize(client:)
-          @client = client
-        end
-
         def create(message: "", parameters: {})
           validate_and_resolve!(parameters, message)
           perform_request(parameters:)
         end
 
         def perform_request(parameters: {})
+          add_request_headers(parameters, REQUESTED_MODEL_HEADER => parameters[:model])
           @client.chat.completions.create(**parameters.slice(*ALLOWED_EXTRA_PARAMETERS))
         end
 
@@ -29,7 +27,6 @@ module NitroIntelligence
             metadata: {},
             messages: [],
             model: NitroIntelligence.model_catalog.default_text_model&.name,
-            extra_headers: { "Prefer" => "wait" },
           }
 
           parameters.replace(default_parameters.merge(parameters))

data/lib/nitro_intelligence/client/handlers/image_handler.rb

@@ -1,16 +1,13 @@
 require "openai"
+require "nitro_intelligence/client/handlers/base_handler"
 require "nitro_intelligence/media/image_generation"
 
 module NitroIntelligence
   module Client
     module Handlers
-      class ImageHandler
+      class ImageHandler < BaseHandler
         ALLOWED_EXTRA_PARAMETERS = OpenAI::Models::Chat::CompletionCreateParams.fields.keys.uniq.freeze
 
-        def initialize(client:)
-          @client = client
-        end
-
         def create(message: "", target_image: nil, reference_images: [], parameters: {})
           image_generation = build_image_generation(message:, target_image:, reference_images:, parameters:)
 
@@ -23,6 +20,7 @@ module NitroIntelligence
         end
 
         def perform_request(parameters: {})
+          add_request_headers(parameters, MODALITY_HEADER => "image", REQUESTED_MODEL_HEADER => parameters[:model])
           @client.chat.completions.create(**parameters.slice(*ALLOWED_EXTRA_PARAMETERS))
         end
 
@@ -32,7 +30,6 @@ module NitroIntelligence
             metadata: {},
             messages: image_generation.messages,
             model: image_generation.config.model,
-            extra_headers: { "Prefer" => "wait" },
             request_options: {
               extra_body: {
                 image_config: {

data/lib/nitro_intelligence/client/handlers/observed/text_to_speech_handler.rb

@@ -0,0 +1,100 @@
+require "nitro_intelligence/media/audio"
+
+module NitroIntelligence
+  module Client
+    module Handlers
+      module Observed
+        class TextToSpeechHandler
+          class ObservedTextToSpeechPromptError < StandardError; end
+
+          def initialize(base_handler:, observer:)
+            @base_handler = base_handler
+            @observer = observer
+          end
+
+          def create(message: "", parameters: {})
+            prompt = handle_prompt(parameters:)
+
+            @base_handler.validate_and_resolve!(parameters)
+
+            trace_name = parameters[:trace_name] || prompt&.name || @observer.project_client.project.slug
+
+            @observer.observe(
+              "text-to-speech",
+              type: :generation,
+              parameters:,
+              trace_name:,
+              prompt:
+            ) do |generation|
+              workflow(message:, parameters:, trace_id: generation.trace_id)
+            end
+          end
+
+        private
+
+          def handle_prompt(parameters:)
+            return nil if parameters[:prompt_name].blank?
+
+            prompt = @observer.project_client.project.prompt_store.get_prompt(
+              prompt_name: parameters[:prompt_name],
+              prompt_label: parameters[:prompt_label],
+              prompt_version: parameters[:prompt_version]
+            )
+            prompt_variables = parameters[:prompt_variables] || {}
+
+            if prompt.present?
+              # Prompts for tts should only be text
+              if prompt.type != "text"
+                raise ObservedTextToSpeechPromptError,
+                      "Prompt type for text-to-speech must be text: #{prompt.name}"
+              end
+              interpolated_prompt = prompt.compile(**prompt_variables)
+
+              parameters.merge!(prompt.config) unless parameters[:prompt_config_disabled]
+              parameters[:instructions] = interpolated_prompt
+            end
+
+            prompt
+          end
+
+          def handle_text_to_speech_upload(tts_file, trace_id)
+            upload_handler = NitroIntelligence::Observability::UploadHandler.new(
+              auth_token: @observer.project_client.project.auth_token
+            )
+            upload_handler.upload(
+              trace_id,
+              upload_queue: Queue.new([Audio.new(tts_file)])
+            )
+
+            uploaded_media = upload_handler.uploaded_media.first
+            "@@@langfuseMedia:type=#{uploaded_media.mime_type}|id=#{uploaded_media.reference_id}|source=bytes@@@"
+          end
+
+          def workflow(message:, parameters:, trace_id:)
+            tts = @base_handler.perform_request(message:, parameters:)
+            output = ""
+
+            Tempfile.create(["tts", ".#{parameters[:response_format]}"]) do |tempfile|
+              tempfile.binmode
+              tempfile.write(tts.string)
+              tempfile.rewind
+
+              output = handle_text_to_speech_upload(tempfile, trace_id)
+            end
+
+            # We only get StringIO object as a response
+            # We dont have usage on tokens and the actual model that was used
+            # We will log the requested model instead
+            trace_attributes = {
+              model: parameters[:model],
+              input: message,
+              output:,
+            }
+
+            [tts, trace_attributes]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nitro_intelligence/client/handlers/text_to_speech_handler.rb

@@ -0,0 +1,56 @@
+require "openai"
+require "nitro_intelligence/client/handlers/base_handler"
+
+module NitroIntelligence
+  module Client
+    module Handlers
+      class TextToSpeechHandler < BaseHandler
+        ALLOWED_EXTRA_PARAMETERS = OpenAI::Models::Audio::SpeechCreateParams.fields.keys.uniq.freeze
+
+        def create(message: "", parameters: {})
+          validate_and_resolve!(parameters)
+          perform_request(message:, parameters:)
+        end
+
+        def perform_request(message: "", parameters: {})
+          add_request_headers(parameters, MODALITY_HEADER => "audio", REQUESTED_MODEL_HEADER => parameters[:model])
+          @client.audio.speech.create(
+            input: message,
+            **parameters.slice(*ALLOWED_EXTRA_PARAMETERS)
+          )
+        end
+
+        def validate_and_resolve!(parameters)
+          model_name = parameters[:model] || NitroIntelligence.model_catalog.default_text_to_speech_model&.name
+          model = NitroIntelligence.model_catalog.lookup_by_name(model_name)
+          raise ArgumentError, "Unsupported model: '#{model_name}'" unless model
+
+          default_parameters = {
+            metadata: {},
+            model: model.name,
+            voice: model.default_voice,
+            response_format: model.default_response_format,
+          }
+          parameters.replace(default_parameters.merge(parameters))
+          validate_voice_and_format!(model, parameters)
+        end
+
+      private
+
+        def validate_voice_and_format!(model, parameters)
+          unless model.voices.include?(parameters[:voice])
+            raise ArgumentError,
+                  "Unsupported voice: '#{parameters[:voice]}'. " \
+                  "Supported voices for #{model.name} are: #{model.voices}"
+          end
+
+          return if model.response_formats.include?(parameters[:response_format])
+
+          raise ArgumentError,
+                "Unsupported response_format: '#{parameters[:response_format]}'. " \
+                "Supported response_formats for #{model.name} are: #{model.response_formats}"
+        end
+      end
+    end
+  end
+end

data/lib/nitro_intelligence/client/observed.rb

@@ -1,6 +1,7 @@
 require "nitro_intelligence/client/handlers/observed/audio_transcription_handler"
 require "nitro_intelligence/client/handlers/observed/chat_handler"
 require "nitro_intelligence/client/handlers/observed/image_handler"
+require "nitro_intelligence/client/handlers/observed/text_to_speech_handler"
 require "nitro_intelligence/observability/prompt_store"
 require "nitro_intelligence/observability/upload_handler"
 require "nitro_intelligence/trace"
@@ -33,6 +34,12 @@ module NitroIntelligence
           base_handler: Handlers::ImageHandler.new(client: @client), observer: @observer
         )
       end
+
+      def text_to_speech_handler
+        @text_to_speech_handler ||= Handlers::Observed::TextToSpeechHandler.new(
+          base_handler: Handlers::TextToSpeechHandler.new(client: @client), observer: @observer
+        )
+      end
     end
   end
 end

data/lib/nitro_intelligence/models/model.rb

@@ -8,8 +8,6 @@ module NitroIntelligence
     end
   end
 
-  class TextModel < Model; end
-
   class ImageModel < Model
     attr_reader :aspect_ratios, :resolutions
 
@@ -19,4 +17,28 @@ module NitroIntelligence
       @resolutions = resolutions
     end
   end
+
+  class TextModel < Model; end
+
+  class TextToSpeechModel < Model
+    attr_reader :default_voice,
+                :default_response_format,
+                :voices,
+                :response_formats
+
+    def initialize(
+      name:,
+      default_voice:,
+      default_response_format:,
+      voices: [],
+      response_formats: [],
+      **
+    )
+      super
+      @default_voice = default_voice
+      @default_response_format = default_response_format
+      @voices = voices
+      @response_formats = response_formats
+    end
+  end
 end

data/lib/nitro_intelligence/models/model_catalog.rb

@@ -2,13 +2,19 @@ require "nitro_intelligence/models/model_factory"
 
 module NitroIntelligence
   class ModelCatalog
-    attr_reader :models, :default_audio_transcription_model, :default_image_model, :default_text_model
+    attr_reader :models,
+                :default_audio_transcription_model,
+                :default_image_model,
+                :default_text_model,
+                :default_text_to_speech_model
 
     def initialize(model_config)
+      model_config = model_config.symbolize_keys
       @models = (model_config[:models] || []).map { |model_metadata| ModelFactory.build(model_metadata) }
       @default_audio_transcription_model = lookup_by_name(model_config[:default_audio_transcription_model])
       @default_image_model = lookup_by_name(model_config[:default_image_model])
       @default_text_model = lookup_by_name(model_config[:default_text_model])
+      @default_text_to_speech_model = lookup_by_name(model_config[:default_text_to_speech_model])
     end
 
     def lookup_by_name(name)

data/lib/nitro_intelligence/models/model_factory.rb

@@ -2,18 +2,18 @@ require "nitro_intelligence/models/model"
 
 module NitroIntelligence
   class ModelFactory
+    TYPES = {
+      "text" => TextModel,
+      "audio_transcription" => TextModel,
+      "image" => ImageModel,
+      "text_to_speech" => TextToSpeechModel,
+    }.freeze
+
     def self.build(model_metadata)
       model_metadata = model_metadata.symbolize_keys
-
-      if image_model?(model_metadata)
-        ImageModel.new(**model_metadata)
-      else
-        TextModel.new(**model_metadata)
-      end
-    end
-
-    def self.image_model?(model_metadata)
-      model_metadata.key?(:aspect_ratios) || model_metadata.key?(:resolutions)
+      type = model_metadata[:type]
+      model_class = TYPES.fetch(type) { raise ArgumentError, "Unknown model type: #{type.inspect}" }
+      model_class.new(**model_metadata)
     end
   end
 end

data/lib/nitro_intelligence/observability/prompt_store.rb

@@ -1,6 +1,7 @@
 require "base64"
 require "cgi"
-require "httparty"
+require "net/http"
+require "uri"
 
 require "nitro_intelligence/observability/prompt"
 
@@ -75,15 +76,17 @@ module NitroIntelligence
 
       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}",
-          }
-        )
+        uri = URI("#{@observability_host}/api/public/v2/prompts/#{safe_prompt_name}?#{prompt_url_params}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = "Basic #{auth_token}"
+
+        response = http.request(request)
 
-        if response.code != 200
-          raise ObservabilityPromptNotFoundError, "Prompt: #{safe_prompt_name} Not Found" if response.code == 404
+        if response.code.to_i != 200
+          raise ObservabilityPromptNotFoundError, "Prompt: #{safe_prompt_name} Not Found" if response.code.to_i == 404
 
           raise ObservabilityPromptError, response.body
         end

data/lib/nitro_intelligence/observability/upload_handler.rb

@@ -1,11 +1,15 @@
 require "base64"
 require "digest"
-require "httparty"
+require "json"
+require "net/http"
 require "time"
+require "uri"
 
 module NitroIntelligence
   module Observability
     class UploadHandler
+      attr_reader :uploaded_media
+
       def initialize(auth_token:)
         @host = NitroIntelligence.config.observability_base_url
         @auth_token = auth_token
@@ -92,43 +96,50 @@ module NitroIntelligence
     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}",
-          }
-        )
+        uri = URI("#{@host}/api/public/media")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Basic #{@auth_token}"
+        request.body = request_body.to_json
+
+        response = http.request(request)
+        JSON.parse(response.body)
       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,
+          uploadHttpStatus: upload_response.code.to_i,
+          uploadHttpError: upload_response.code.to_i == 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}",
-          }
-        )
+        uri = URI("#{@host}/api/public/media/#{media_id}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        request = Net::HTTP::Patch.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Basic #{@auth_token}"
+        request.body = request_body.to_json
+
+        http.request(request)
       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
-          )
+          uri = URI(upload_url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+
+          request = Net::HTTP::Put.new(uri)
+          request["Content-Type"] = content_type
+          request["x-amz-checksum-sha256"] = content_sha256
+          request.body = content_bytes
+
+          return http.request(request)
         end
 
         nil

data/lib/nitro_intelligence/reporter.rb

@@ -1,5 +1,6 @@
 require "base64"
-require "httparty"
+require "net/http"
+require "uri"
 
 module NitroIntelligence
   class Reporter
@@ -10,12 +11,16 @@ module NitroIntelligence
     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}",
-                    })
+      uri = URI("#{@host}/api/public/dataset-items")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = "Basic #{@project_client.project.auth_token}"
+      request.body = attributes.to_json
+
+      http.request(request)
     end
 
     def score(trace_id:, name:, value:, id: "#{trace_id}-#{name}")

data/lib/nitro_intelligence/version.rb

@@ -1,3 +1,3 @@
 module NitroIntelligence
-  VERSION = "1.0.1".freeze
+  VERSION = "2.1.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nitro_intelligence
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Igor Artemenko
@@ -23,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '7.1'
-- !ruby/object:Gem::Dependency
-  name: httparty
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.16'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.16'
 - !ruby/object:Gem::Dependency
   name: langfuse-rb
   requirement: !ruby/object:Gem::Requirement
@@ -79,152 +65,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.58'
-- !ruby/object:Gem::Dependency
-  name: railties
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '7.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '7.1'
-- !ruby/object:Gem::Dependency
-  name: license_finder
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 7.2.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 7.2.1
-- !ruby/object:Gem::Dependency
-  name: parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.5'
-    - - "!="
-      - !ruby/object:Gem::Version
-        version: 2.5.1.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.5'
-    - - "!="
-      - !ruby/object:Gem::Version
-        version: 2.5.1.1
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.14.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.14.2
-- !ruby/object:Gem::Dependency
-  name: pry-byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.10.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.10.1
-- !ruby/object:Gem::Dependency
-  name: rainbow
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 2.2.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 2.2.2
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.13.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.13.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-powerhome
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.6.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.6.1
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.26.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.26.1
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.9.37
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.9.37
 description: The Ruby client for Nitro Intelligence
 email:
 - igor.artemenko@powerhrg.com
@@ -240,11 +80,14 @@ files:
 - 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/base_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/handlers/observed/text_to_speech_handler.rb
+- lib/nitro_intelligence/client/handlers/text_to_speech_handler.rb
 - lib/nitro_intelligence/client/observed.rb
 - lib/nitro_intelligence/client/observers/langfuse_observer.rb
 - lib/nitro_intelligence/configuration.rb