mistral_translator 0.3.1 → 0.4.0

data/lib/mistral_translator/client_helpers.rb

@@ -6,10 +6,10 @@ module MistralTranslator
   module ClientHelpers
     # Helper pour la gestion des requêtes HTTP
     module RequestHandler
-      def make_request(prompt, max_tokens, temperature)
+      def make_request(prompt, max_tokens, temperature, json: false)
         uri = URI("#{@base_uri}/v1/chat/completions")
 
-        request_body = build_request_body(prompt, max_tokens, temperature)
+        request_body = build_request_body(prompt, max_tokens, temperature, json: json)
 
         request = Net::HTTP::Post.new(uri.path, headers)
         request.body = request_body.to_json
@@ -22,6 +22,9 @@ module MistralTranslator
         raise ApiError, "Request timeout: #{e.message}"
       rescue Net::HTTPError => e
         raise ApiError, "HTTP error: #{e.message}"
+      rescue Net::HTTP::Persistent::Error => e
+        # Proxy ou API injoignable ; le message d'origine peut citer l'adresse du proxy
+        raise ApiError, "Connection failed (#{e.class})", cause: nil
       end
 
       def http_pool
@@ -34,6 +37,7 @@ module MistralTranslator
 
           # SSL/TLS configuration
           configure_ssl(pool)
+          configure_proxy(pool)
 
           pool
         end
@@ -56,18 +60,32 @@ module MistralTranslator
         pool.ca_path = config.ssl_ca_path if config.ssl_ca_path
       end
 
-      def build_request_body(prompt, max_tokens, temperature)
+      def configure_proxy(pool)
+        proxy_uri = Proxy.resolve(MistralTranslator.configuration.proxy, host: URI(@base_uri).host)
+        pool.proxy = proxy_uri if proxy_uri
+      end
+
+      def build_request_body(prompt, max_tokens, temperature, json: false)
         body = {
           model: @model,
-          messages: [{ role: "user", content: prompt }]
+          messages: request_messages(prompt)
         }
 
         body[:max_tokens] = max_tokens if max_tokens
         body[:temperature] = temperature if temperature
+        # L'API garantit alors un objet JSON syntaxiquement valide
+        body[:response_format] = { type: "json_object" } if json
 
         body
       end
 
+      # Un Prompt sépare consignes et texte ; une String part en un seul message.
+      def request_messages(prompt)
+        return prompt.messages if prompt.respond_to?(:messages)
+
+        [{ role: "user", content: prompt }]
+      end
+
       def headers
         {
           "Authorization" => "Bearer #{@api_key}",
@@ -79,15 +97,17 @@ module MistralTranslator
 
     # Helper pour la gestion des erreurs et retry
     module ErrorHandler
-      def make_request_with_retry(prompt, max_tokens, temperature, context, attempt = 0)
+      # request_options : max_tokens, temperature, json
+      def make_request_with_retry(prompt, request_options, context, attempt = 0)
         context[:attempt] = attempt
-        response = make_request(prompt, max_tokens, temperature)
+        response = make_request(prompt, request_options[:max_tokens], request_options[:temperature],
+                                json: request_options.fetch(:json, false))
 
         # Vérifier les erreurs dans la réponse
         check_response_for_errors(response)
 
         if rate_limit_exceeded?(response)
-          handle_rate_limit(prompt, max_tokens, temperature, context, attempt)
+          handle_rate_limit(prompt, request_options, context, attempt)
         else
           response
         end
@@ -101,24 +121,19 @@ module MistralTranslator
           # Rate limit sera géré séparément
           nil
         when 400..499
-          raise ApiError, "Client error (#{response.code})}"
+          raise ApiError, "Client error (#{response.code})"
         when 500..599
-          raise ApiError, "Server error (#{response.code})}"
+          raise ApiError, "Server error (#{response.code})"
         end
       end
 
+      # Seul le statut compte : le corps d'une réponse 200 contient le texte traduit,
+      # qui peut très bien parler de « rate limit ».
       def rate_limit_exceeded?(response)
-        return true if response.code.to_i == 429
-
-        return false unless response.code.to_i == 200
-
-        body_content = response.body.to_s
-        return false if body_content.length > 1000
-
-        body_content.match?(/rate.?limit|quota.?exceeded/i)
+        response.code.to_i == 429
       end
 
-      def handle_rate_limit(prompt, max_tokens, temperature, context, attempt)
+      def handle_rate_limit(prompt, request_options, context, attempt)
         unless attempt < @retry_delays.length
           raise RateLimitError, "API rate limit exceeded after #{@retry_delays.length} retries"
         end
@@ -135,7 +150,7 @@ module MistralTranslator
 
         log_rate_limit_retry(wait_time, attempt)
         sleep(wait_time)
-        make_request_with_retry(prompt, max_tokens, temperature, context, attempt + 1)
+        make_request_with_retry(prompt, request_options, context, attempt + 1)
       end
     end
 
@@ -153,7 +168,7 @@ module MistralTranslator
             attempt: 0
           }
 
-          result = complete(request[:prompt], context: context)
+          result = complete(request[:prompt], context: context, json: true)
           results << {
             success: true,
             result: result,
@@ -175,10 +190,13 @@ module MistralTranslator
 
     # Helper pour le logging
     module LoggingHelper
+      # Jamais le contenu des messages : seulement le modèle et les tailles
       def log_request_response(request_body, response)
-        # Log seulement si mode verbose activé
-        Logger.debug_if_verbose("Request sent to API: #{request_body.to_json}", sensitive: true)
-        Logger.debug_if_verbose("Response received: #{response.code}", sensitive: false)
+        sizes = request_body[:messages].map { |message| "#{message[:role]}=#{message[:content].to_s.length}" }
+        Logger.debug_if_verbose(
+          "Request sent to API: model=#{request_body[:model]} #{sizes.join(" ")}, response #{response.code}",
+          sensitive: false
+        )
       end
 
       def log_rate_limit_retry(wait_time, attempt)

data/lib/mistral_translator/configuration.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "proxy"
+
 module MistralTranslator
   class Configuration
     attr_accessor :api_key, :model, :default_max_tokens, :default_temperature, :retry_delays,
                   :on_translation_start, :on_translation_complete, :on_translation_error,
                   :on_rate_limit, :on_batch_complete, :enable_metrics,
                   :ssl_verify_mode, :ssl_ca_file, :ssl_ca_path, :ssl_timeout
-    attr_reader :api_url
+    attr_reader :api_url, :proxy
 
     def initialize
       @api_key = nil
@@ -30,6 +32,9 @@ module MistralTranslator
       @ssl_ca_path = nil        # Path to CA certificates directory
       @ssl_timeout = 60         # SSL handshake timeout in seconds
 
+      # Proxy : nil (aucun), URI ou String, ou :env (HTTPS_PROXY, HTTP_PROXY, NO_PROXY)
+      @proxy = nil
+
       # Métriques intégrées (thread-safe avec mutex)
       @metrics_mutex = Mutex.new
       @metrics = {
@@ -56,6 +61,11 @@ module MistralTranslator
       @api_url = url
     end
 
+    def proxy=(value)
+      Proxy.validate!(value)
+      @proxy = value
+    end
+
     # Méthodes pour les callbacks
     def trigger_translation_start(from_locale, to_locale, text_length)
       @on_translation_start&.call(from_locale, to_locale, text_length, Time.now)