mistral_translator 0.3.2 → 0.5.0

data/lib/mistral_translator/summarizer.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "logger"
+require_relative "retries"
 require_relative "security"
 
 module MistralTranslator
   class Summarizer
+    include Retries
+
     DEFAULT_MAX_WORDS = 250
-    DEFAULT_RETRY_COUNT = 3
-    DEFAULT_RETRY_DELAY = 2
+    DEFAULT_RETRY_COUNT = Retries::RETRY_COUNT
+    DEFAULT_RETRY_DELAY = Retries::RETRY_DELAY
 
     def initialize(client: nil)
       @client = client || Client.new
@@ -15,7 +18,7 @@ module MistralTranslator
     end
 
     # Résumé simple dans une langue donnée
-    def summarize(text, language: "fr", max_words: DEFAULT_MAX_WORDS)
+    def summarize(text, language: "fr", max_words: DEFAULT_MAX_WORDS, context: nil, style: nil)
       log_debug("Starting summarize - language: #{language}, max_words: #{max_words}")
 
       # Validation basique des entrées
@@ -26,18 +29,14 @@ module MistralTranslator
       return "" if validated_text.empty?
 
       target_locale = LocaleHelper.validate_locale!(language)
-      log_debug("Target locale validated: #{target_locale}")
-
       cleaned_text = clean_document_content(validated_text)
-      log_debug("Text cleaned, length: #{cleaned_text&.length}")
 
-      result = summarize_with_retry(cleaned_text, target_locale, max_words)
-      log_debug("Summary completed successfully")
-      result
+      prompt = PromptBuilder.summary_prompt(cleaned_text, max_words, target_locale, context: context, style: style)
+      request_summary(prompt, target_locale)
     end
 
     # Résumé avec traduction simultanée
-    def summarize_and_translate(text, from:, to:, max_words: DEFAULT_MAX_WORDS)
+    def summarize_and_translate(text, from:, to:, max_words: DEFAULT_MAX_WORDS, context: nil, style: nil) # rubocop:disable Metrics/ParameterLists
       log_debug("Starting summarize_and_translate - from: #{from}, to: #{to}")
       validate_summarize_translate_inputs!(text, from, to, max_words)
 
@@ -47,143 +46,57 @@ module MistralTranslator
 
       # Si même langue, juste résumer
       if source_locale == target_locale
-        log_debug("Same language detected, using simple summarize")
-        return summarize(cleaned_text, language: target_locale, max_words: max_words)
+        return summarize(cleaned_text, language: target_locale, max_words: max_words, context: context, style: style)
       end
 
-      # Sinon, créer un prompt qui fait les deux à la fois
-      log_debug("Different languages, using combined summarize+translate")
-      prompt = build_summary_translation_prompt(cleaned_text, source_locale, target_locale, max_words)
-      raw_response = @client.complete(prompt)
-
-      result = ResponseParser.parse_summary_response(raw_response)
-      if result.nil? || result[:summary].nil? || result[:summary].empty?
-        # Fallback: si le JSON est manquant ou vide, on tente un résumé simple puis traduction
-        log_error(
-          "Empty or invalid summary response for summarize_and_translate. Using fallback. " \
-          "Raw length: #{raw_response.to_s.length}"
-        )
-        summary_only = summarize(cleaned_text, language: source_locale, max_words: max_words)
-        begin
-          return MistralTranslator.translate(summary_only, from: source_locale, to: target_locale)
-        rescue EmptyTranslationError, InvalidResponseError, RateLimitError => e
-          log_error("Translation fallback failed: #{e.class.name} - returning source summary")
-          return summary_only
-        end
-      end
-
-      result[:summary]
+      prompt = PromptBuilder.summary_and_translation_prompt(cleaned_text, source_locale, target_locale, max_words,
+                                                            context: context, style: style)
+      request_summary(prompt, target_locale)
     end
 
     # Résumé en plusieurs langues
-    def summarize_to_multiple(text, languages:, max_words: DEFAULT_MAX_WORDS)
+    def summarize_to_multiple(text, languages:, max_words: DEFAULT_MAX_WORDS, context: nil, style: nil)
       log_debug("Starting summarize_to_multiple - languages: #{languages}")
       validate_multiple_summarize_inputs!(text, languages, max_words)
 
       target_locales = Array(languages).map { |locale| LocaleHelper.validate_locale!(locale) }
       cleaned_text = clean_document_content(text)
-      results = {}
-
-      target_locales.each_with_index do |target_locale, index|
-        log_debug("Processing language #{index + 1}/#{target_locales.length}: #{target_locale}")
 
+      target_locales.each_with_index.to_h do |target_locale, index|
         # Ajouter un délai seulement entre les requêtes (pas avant la première)
-        if index.positive?
-          log_debug("Adding delay between requests: #{DEFAULT_RETRY_DELAY}s")
-          sleep(DEFAULT_RETRY_DELAY)
-        end
+        sleep(DEFAULT_RETRY_DELAY) if index.positive?
 
-        results[target_locale] = summarize_with_retry(cleaned_text, target_locale, max_words)
+        prompt = PromptBuilder.summary_prompt(cleaned_text, max_words, target_locale, context: context, style: style)
+        [target_locale, request_summary(prompt, target_locale)]
       end
-
-      log_debug("Multiple summarization completed")
-      results
     end
 
     # Résumé par niveaux (court, moyen, long)
-    def summarize_tiered(text, language: "fr", short: 50, medium: 150, long: 300)
+    def summarize_tiered(text, language: "fr", short: 50, medium: 150, long: 300, context: nil, style: nil) # rubocop:disable Metrics/ParameterLists
       log_debug("Starting summarize_tiered - short: #{short}, medium: #{medium}, long: #{long}")
       validate_tiered_inputs!(text, language, short, medium, long)
 
       target_locale = LocaleHelper.validate_locale!(language)
       cleaned_text = clean_document_content(text)
 
-      {
-        short: summarize_with_retry(cleaned_text, target_locale, short),
-        medium: summarize_with_retry(cleaned_text, target_locale, medium),
-        long: summarize_with_retry(cleaned_text, target_locale, long)
-      }
+      { short: short, medium: medium, long: long }.transform_values do |max_words|
+        prompt = PromptBuilder.summary_prompt(cleaned_text, max_words, target_locale, context: context, style: style)
+        request_summary(prompt, target_locale)
+      end
     end
 
     private
 
-    # rubocop:disable Metrics/PerceivedComplexity
-    def summarize_with_retry(text, target_locale, max_words, attempt = 0)
-      log_debug("Summarize attempt #{attempt + 1} for #{target_locale}")
-
-      prompt = PromptBuilder.summary_prompt(text, max_words, target_locale)
-      raw_response = @client.complete(prompt)
-      response_len = raw_response&.length || 0
-
-      result = ResponseParser.parse_summary_response(raw_response)
-      if result.nil? || result[:summary].nil? || result[:summary].empty?
-        log_error(
-          "Empty or invalid summary response for #{target_locale}. " \
-          "Raw response length: #{response_len}"
-        )
-        raise EmptyTranslationError, "Empty summary received"
-      end
+    # Commun à tous les résumés ; une réponse inexploitable finit par lever une erreur.
+    def request_summary(prompt, target_locale)
+      with_retries(operation: "summary", subject: target_locale) do |attempt|
+        log_debug("Summary attempt #{attempt + 1} for #{target_locale}")
 
-      log_debug("Summary successful for #{target_locale}")
-      result[:summary]
-    rescue EmptyTranslationError, InvalidResponseError => e
-      if attempt < DEFAULT_RETRY_COUNT
-        wait_time = DEFAULT_RETRY_DELAY * (2**attempt)
-        log_retry(e, attempt + 1, wait_time, target_locale)
-        sleep(wait_time)
-        summarize_with_retry(text, target_locale, max_words, attempt + 1)
-      else
-        log_debug("Max retries reached for #{target_locale}, giving up")
-        raise e
-      end
-    rescue RateLimitError
-      # Le client a déjà relancé avec backoff : quelques tentatives de plus suffisent.
-      raise if attempt >= DEFAULT_RETRY_COUNT
+        result = ResponseParser.parse_summary_response(@client.complete(prompt, json: true))
+        raise EmptyTranslationError, "Empty summary received" if result.nil? || result[:summary].to_s.empty?
 
-      log_rate_limit_hit("summary", target_locale)
-      sleep(DEFAULT_RETRY_DELAY)
-      summarize_with_retry(text, target_locale, max_words, attempt + 1)
-    end
-    # rubocop:enable Metrics/PerceivedComplexity
-
-    def build_summary_translation_prompt(text, source_locale, target_locale, max_words)
-      source_name = LocaleHelper.locale_to_language(source_locale)
-      target_name = LocaleHelper.locale_to_language(target_locale)
-
-      <<~PROMPT
-        Tu es un assistant spécialisé dans la création de résumés et traductions simultanées.#{" "}
-        Résume ET traduis le texte suivant en respectant ces règles strictes :
-        1. Langue source : #{source_name} (#{source_locale})
-        2. Langue cible : #{target_name} (#{target_locale})
-        3. Longueur maximale : #{max_words} mots
-        4. Créer un résumé du texte ET le traduire vers la langue cible
-        5. Format de réponse obligatoire en JSON :
-        {
-          "content": {
-            "source": "texte original",
-            "target": "résumé traduit en #{target_name}"
-          },
-          "metadata": {
-            "source_language": "#{source_locale}",
-            "target_language": "#{target_locale}",
-            "max_words": #{max_words},
-            "operation": "summarize_and_translate"
-          }
-        }
-
-        Texte à résumer et traduire :
-        #{text}
-      PROMPT
+        result[:summary]
+      end
     end
 
     def clean_document_content(content)
@@ -211,6 +124,8 @@ module MistralTranslator
 
     def validate_summarize_inputs!(text, language, max_words)
       raise ArgumentError, "Text cannot be nil or empty" if text.nil? || text.empty?
+
+      Security::BasicValidator.validate_text!(text)
       raise ArgumentError, "Language cannot be nil" if language.nil?
       raise ArgumentError, "Max words must be a positive integer" unless max_words.is_a?(Integer) && max_words.positive?
     end
@@ -233,36 +148,8 @@ module MistralTranslator
       raise ArgumentError, "Long length must be greater than medium" unless long > medium
     end
 
-    def log_retry(error, attempt, wait_time, locale)
-      message = "Summary retry #{attempt}/#{DEFAULT_RETRY_COUNT} for #{locale} in #{wait_time}s: #{error.message}"
-      # Log une seule fois par locale et type d'erreur
-      Logger.warn_once(message, key: "summary_retry_#{locale}_#{error.class.name}", sensitive: false, ttl: 120)
-    end
-
-    def log_rate_limit_hit(operation, locale)
-      message = "Rate limit hit for #{operation} in #{locale}, retrying..."
-      # Log une seule fois par opération et locale
-      Logger.warn_once(message, key: "summary_rate_limit_#{operation}_#{locale}", sensitive: false, ttl: 300)
-    end
-
     def log_debug(message)
-      # Log de debug seulement si mode verbose activé
       Logger.debug_if_verbose(message, sensitive: false)
-
-      # Pour les tests, permettre un output dans stdout si nécessaire
-      return unless ENV["MISTRAL_TRANSLATOR_TEST_OUTPUT"] == "true"
-
-      puts "[MistralTranslator] #{message}"
-    end
-
-    def log_error(message)
-      # Utiliser le logger centralisé
-      Logger.warn(message, sensitive: false)
-
-      # Pour les tests, optionnellement afficher en stdout
-      return unless ENV["MISTRAL_TRANSLATOR_TEST_OUTPUT"] == "true"
-
-      puts "[MistralTranslator] ERROR: #{message}"
     end
   end
 end

data/lib/mistral_translator/translator.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
 require_relative "logger"
+require_relative "retries"
 require_relative "translator_helpers"
 require_relative "security"
 
 module MistralTranslator
   class Translator
+    include Retries
     include TranslatorHelpers::InputValidator
-    include TranslatorHelpers::RetryHandler
-    include TranslatorHelpers::LoggingHelper
-    include TranslatorHelpers::PromptHandler
     include TranslatorHelpers::AnalysisHelper
     include TranslatorHelpers::RequestHelper
     include TranslatorHelpers::MultiTargetHelper
 
-    DEFAULT_RETRY_COUNT = 3
-    DEFAULT_RETRY_DELAY = 2
+    DEFAULT_RETRY_COUNT = Retries::RETRY_COUNT
+    DEFAULT_RETRY_DELAY = Retries::RETRY_DELAY
 
     def initialize(client: nil)
       @client = client || Client.new
@@ -67,6 +66,7 @@ module MistralTranslator
     # Traduction vers plusieurs langues avec support du batch
     def translate_to_multiple(text, from:, to:, **options)
       validate_translation_inputs!(text, from, to)
+      Security::BasicValidator.validate_text!(text)
 
       source_locale = LocaleHelper.validate_locale!(from)
       target_locales = Array(to).map { |locale| LocaleHelper.validate_locale!(locale) }
@@ -82,33 +82,33 @@ module MistralTranslator
     end
 
     # Traduction en lot (plusieurs textes vers une langue)
-    def translate_batch(texts, from:, to:, context: nil, glossary: nil)
+    def translate_batch(texts, from:, to:, context: nil, glossary: nil, preserve_html: false) # rubocop:disable Metrics/ParameterLists
       validated_texts = Security::BasicValidator.validate_batch!(texts)
       source_locale = LocaleHelper.validate_locale!(from)
       target_locale = LocaleHelper.validate_locale!(to)
 
       return handle_same_language_batch(validated_texts) if source_locale == target_locale
 
-      process_mixed_batch(validated_texts, source_locale, target_locale, context, glossary)
+      batch_config = { source_locale: source_locale, target_locale: target_locale, context: context,
+                       glossary: glossary, preserve_html: preserve_html }
+      process_mixed_batch(validated_texts, batch_config)
     end
 
     # Auto-détection de la langue source avec support du contexte
-    def translate_auto(text, to:, context: nil, glossary: nil)
+    def translate_auto(text, to:, context: nil, glossary: nil, preserve_html: false)
+      validated_text = Security::BasicValidator.validate_text!(text)
+      return "" if validated_text.empty?
+
       target_locale = LocaleHelper.validate_locale!(to)
 
-      # Premier appel pour détecter la langue
-      detection_prompt = build_language_detection_prompt(text)
-      detection_response = @client.complete(detection_prompt)
+      # Premier appel pour détecter la langue ; un échec lève une erreur
+      detection_response = @client.complete(build_language_detection_prompt(validated_text), json: true)
       detected_language = parse_language_detection(detection_response)
-
-      # Vérifier que la langue détectée est différente de la cible
-      if detected_language == target_locale
-        # Si même langue, retourner le texte original
-        return text
-      end
+      return validated_text if detected_language == target_locale
 
       # Puis traduction normale avec contexte
-      translate(text, from: detected_language, to: target_locale, context: context, glossary: glossary)
+      translate(validated_text, from: detected_language, to: target_locale, context: context, glossary: glossary,
+                                preserve_html: preserve_html)
     end
 
     private
@@ -119,10 +119,8 @@ module MistralTranslator
       validated_texts.each_with_index.to_h { |text, index| [index, text] }
     end
 
-    def process_mixed_batch(validated_texts, source_locale, target_locale, context, glossary)
+    def process_mixed_batch(validated_texts, batch_config)
       results = {}
-      batch_config = { source_locale: source_locale, target_locale: target_locale, context: context,
-                       glossary: glossary }
       requests = build_batch_requests(validated_texts, batch_config, results)
 
       process_batch_requests(requests, results) if requests.any?
@@ -147,7 +145,8 @@ module MistralTranslator
     def create_batch_request(text, batch_config, index)
       {
         prompt: build_translation_prompt(text, batch_config[:source_locale], batch_config[:target_locale],
-                                         context: batch_config[:context], glossary: batch_config[:glossary]),
+                                         context: batch_config[:context], glossary: batch_config[:glossary],
+                                         preserve_html: batch_config[:preserve_html]),
         from: batch_config[:source_locale],
         to: batch_config[:target_locale],
         index: index,
@@ -172,86 +171,25 @@ module MistralTranslator
       parsed_result[:translated] if parsed_result
     rescue EmptyTranslationError
       ""
+    rescue InvalidResponseError
+      # Une réponse illisible fait échouer son élément, pas tout le lot
+      nil
     end
 
-    def translate_with_retry(text, source_locale, target_locale, attempt = 0, **options)
-      prompt = build_prompt_for_retry(text, source_locale, target_locale, **options)
-      request_context = build_request_context(source_locale, target_locale, attempt)
+    def translate_with_retry(text, source_locale, target_locale, **)
+      prompt = build_translation_prompt(text, source_locale, target_locale, **)
 
-      raw_response = perform_client_request(prompt, request_context)
-      extract_translated_text!(raw_response)
-    rescue EmptyTranslationError, InvalidResponseError => e
-      handle_retryable_error!(e, attempt) do
-        translate_with_retry(text, source_locale, target_locale, attempt + 1, **options)
+      with_retries(operation: "translation", subject: "#{source_locale}->#{target_locale}") do |attempt|
+        raw_response = perform_client_request(prompt, build_request_context(source_locale, target_locale, attempt))
+        extract_translated_text!(raw_response)
       end
-    rescue RateLimitError
-      # Le client a déjà relancé avec backoff : quelques tentatives de plus suffisent.
-      raise if attempt >= DEFAULT_RETRY_COUNT
-
-      log_rate_limit_hit(source_locale, target_locale)
-      sleep(DEFAULT_RETRY_DELAY)
-      translate_with_retry(text, source_locale, target_locale, attempt + 1, **options)
     end
 
-    # Ces méthodes sont héritées via RequestHelper
-
-    # Log via LoggingHelper
-
     def build_translation_prompt(text, source_locale, target_locale, **options)
-      base_prompt = PromptBuilder.translation_prompt(text, source_locale, target_locale,
-                                                     preserve_html: options.fetch(:preserve_html, false))
-
-      # Enrichir le prompt avec le contexte et le glossaire
-      context_present = options[:context] && !options[:context].to_s.strip.empty?
-      glossary_present =
-        (options[:glossary].is_a?(Hash) && options[:glossary].any?) ||
-        (options[:glossary].is_a?(String) && !options[:glossary].to_s.strip.empty?)
-      if context_present || glossary_present
-        enrich_prompt_with_context(base_prompt, options[:context], options[:glossary])
-      else
-        base_prompt
-      end
-    end
-
-    def enrich_prompt_with_context(base_prompt, context, glossary)
-      enriched_parts = []
-      context_part = build_context_enrichment(context)
-      glossary_part = build_glossary_enrichment(glossary)
-      enriched_parts << context_part if context_part
-      enriched_parts << glossary_part if glossary_part
-
-      return base_prompt if enriched_parts.empty?
-
-      enriched_context = enriched_parts.join("\n")
-      base_prompt.sub("RÈGLES :", "#{enriched_context}\n\nRÈGLES :")
-    end
-
-    def build_context_enrichment(context)
-      return nil if context.nil? || context.to_s.strip.empty?
-
-      "CONTEXTE : #{context}"
-    end
-
-    def build_glossary_enrichment(glossary)
-      return nil if glossary.nil?
-      return build_glossary_hash(glossary) if glossary.is_a?(Hash)
-      return build_glossary_string(glossary) if glossary.is_a?(String)
-
-      nil
-    end
-
-    def build_glossary_hash(glossary_hash)
-      return nil if glossary_hash.empty?
-
-      glossary_text = glossary_hash.map { |key, value| "#{key} → #{value}" }.join(", ")
-      "GLOSSAIRE (à respecter strictement) : #{glossary_text}"
-    end
-
-    def build_glossary_string(glossary_string)
-      value = glossary_string.to_s.strip
-      return nil if value.empty?
-
-      "GLOSSAIRE : #{value}"
+      PromptBuilder.translation_prompt(text, source_locale, target_locale,
+                                       context: options[:context],
+                                       glossary: options[:glossary],
+                                       preserve_html: options.fetch(:preserve_html, false))
     end
   end
 end

data/lib/mistral_translator/translator_helpers.rb

@@ -20,103 +20,6 @@ module MistralTranslator
         validate_inputs!(text, from, to)
         raise ArgumentError, "Target languages cannot be empty" if Array(to).empty?
       end
-
-      def validate_batch_inputs!(texts, from, to)
-        raise ArgumentError, "Texts array cannot be nil or empty" if texts.nil? || texts.empty?
-
-        ensure_present!(from, "Source language")
-        ensure_present!(to, "Target language")
-
-        texts.each_with_index do |t, i|
-          ensure_present!(t, "Text at index #{i}")
-        end
-      end
-
-      private
-
-      def ensure_present!(value, field_name)
-        raise ArgumentError, "#{field_name} cannot be nil or empty" if value.nil? || value.to_s.strip.empty?
-      end
-    end
-
-    # Helper pour la gestion des retry
-    module RetryHandler
-      DEFAULT_RETRY_DELAY = 2
-
-      def handle_retry_error(error, source_locale, target_locale, attempt)
-        case error
-        when RateLimitError
-          handle_rate_limit_retry?(source_locale, target_locale, attempt)
-        when ApiError
-          handle_api_error_retry?(error, source_locale, target_locale, attempt)
-        else
-          raise error
-        end
-      end
-
-      # Renvoie true si un retry a été effectué
-      def handle_rate_limit_retry?(source_locale, target_locale, _attempt)
-        log_rate_limit_hit(source_locale, target_locale)
-        sleep(DEFAULT_RETRY_DELAY)
-        # NOTE: retry logic should be handled by the calling method
-        true
-      end
-
-      # Renvoie true si un retry a été effectué
-      def handle_api_error_retry?(error, _source_locale, _target_locale, attempt)
-        raise error unless attempt < 3 && error.message.include?("timeout")
-
-        Logger.warn("API timeout, retrying... (attempt #{attempt + 1})")
-        sleep(DEFAULT_RETRY_DELAY)
-        # NOTE: retry logic should be handled by the calling method
-        true
-      end
-    end
-
-    # Helper pour le logging
-    module LoggingHelper
-      def log_rate_limit_hit(source_locale, target_locale)
-        message = "Rate limit hit for #{source_locale}->#{target_locale}"
-        Logger.warn_once(message, key: "rate_limit_#{source_locale}_#{target_locale}", sensitive: false, ttl: 300)
-      end
-
-      def log_translation_attempt(source_locale, target_locale, attempt)
-        Logger.debug("Translation attempt #{attempt} for #{source_locale}->#{target_locale}")
-      end
-
-      def log_retry(error, attempt, wait_time)
-        default_retry_count = MistralTranslator::Translator::DEFAULT_RETRY_COUNT
-        message = "Translation retry #{attempt}/#{default_retry_count} in #{wait_time}s: #{error.message}"
-        Logger.warn_once(message, key: "translate_retry_#{error.class.name}_#{attempt}", sensitive: false, ttl: 120)
-      end
-    end
-
-    # Helper pour la gestion des prompts
-    module PromptHandler
-      def enrich_prompt_with_context(base_prompt, context, glossary)
-        context_section = build_context_section(context, glossary)
-        base_prompt + context_section
-      end
-
-      def build_context_section(context, glossary)
-        context_section = ""
-        context_section += add_context_text(context) if context && !context.to_s.strip.empty?
-        context_section += add_glossary_text(glossary) if glossary && !glossary.to_s.strip.empty?
-        context_section
-      end
-
-      def add_context_text(context)
-        "\nCONTEXTE : #{context}\n"
-      end
-
-      def add_glossary_text(glossary)
-        if glossary.is_a?(Hash) && glossary.any?
-          glossary_text = glossary.map { |key, value| "#{key} → #{value}" }.join(", ")
-          "\nGLOSSAIRE (à respecter strictement) : #{glossary_text}\n"
-        else
-          "\nGLOSSAIRE : #{glossary}\n"
-        end
-      end
     end
 
     # Helper pour l'analyse et la détection de langue
@@ -152,32 +55,22 @@ module MistralTranslator
         PromptBuilder.language_detection_prompt(text)
       end
 
+      # Fail-closed : une détection illisible ou une langue non supportée lève une erreur,
+      # au lieu de supposer une langue et de renvoyer le texte non traduit.
       def parse_language_detection(response)
-        json_content = response.match(/\{.*\}/m)&.[](0)
-        return "en" unless json_content
-
-        data = JSON.parse(json_content)
-        detected = data.dig("metadata", "detected_language")
+        data = JSON.parse(response.to_s)
+        metadata = data["metadata"] if data.is_a?(Hash)
+        detected = LocaleHelper.normalize_locale(metadata["detected_language"]) if metadata.is_a?(Hash)
+        return detected if detected && LocaleHelper.locale_supported?(detected)
 
-        LocaleHelper.locale_supported?(detected) ? detected : "en"
+        raise InvalidResponseError.new("Language detection failed", response)
       rescue JSON::ParserError
-        "en"
+        raise InvalidResponseError.new("Language detection failed", response), cause: nil
       end
     end
 
     # Helper pour requêtes client et retries
     module RequestHelper
-      def build_prompt_for_retry(text, source_locale, target_locale, **options)
-        build_translation_prompt(
-          text,
-          source_locale,
-          target_locale,
-          context: options[:context],
-          glossary: options[:glossary],
-          preserve_html: options.fetch(:preserve_html, false)
-        )
-      end
-
       def build_request_context(source_locale, target_locale, attempt)
         {
           from_locale: source_locale,
@@ -187,43 +80,16 @@ module MistralTranslator
       end
 
       def perform_client_request(prompt, request_context)
-        if @client.respond_to?(:complete)
-          begin
-            return @client.complete(prompt, context: request_context)
-          rescue StandardError => e
-            raise e unless e.class.name.include?("MockExpectationError") && @client.respond_to?(:make_request)
-
-            return @client.make_request(prompt, nil, nil)
-          end
-        end
-
-        return @client.make_request(prompt, nil, nil) if @client.respond_to?(:make_request)
-
-        @client.complete(prompt, context: request_context)
+        @client.complete(prompt, context: request_context, json: true)
       end
 
+      # Une réponse inexploitable lève une erreur : jamais de réponse brute enregistrée comme traduction.
       def extract_translated_text!(raw_response)
-        begin
-          result = ResponseParser.parse_translation_response(raw_response)
-          return result[:translated] if result && !result[:translated].to_s.empty?
-        rescue EmptyTranslationError, InvalidResponseError
-          # Fallback: accepter une réponse texte brute non vide
-          fallback_text = raw_response.to_s.strip
-          return fallback_text unless fallback_text.empty?
-          # sinon on relance l'erreur plus bas
-        end
+        result = ResponseParser.parse_translation_response(raw_response)
+        return result[:translated] if result && !result[:translated].to_s.empty?
 
         raise EmptyTranslationError
       end
-
-      def handle_retryable_error!(error, attempt)
-        raise error unless attempt < MistralTranslator::Translator::DEFAULT_RETRY_COUNT
-
-        wait_time = MistralTranslator::Translator::DEFAULT_RETRY_DELAY * (2**attempt)
-        log_retry(error, attempt + 1, wait_time)
-        sleep(wait_time)
-        yield
-      end
     end
 
     # Helper pour traductions multi-cibles
@@ -248,14 +114,20 @@ module MistralTranslator
         batch_results.each do |result|
           next unless result[:success]
 
-          target_locale = result[:original_request][:to]
-          parsed_result = ResponseParser.parse_translation_response(result[:result])
-          results[target_locale] = parsed_result[:translated] if parsed_result
+          translated = parse_batch_translation(result[:result])
+          results[result[:original_request][:to]] = translated if translated
         end
 
         results
       end
 
+      # Une réponse illisible fait échouer sa langue, pas tout le lot
+      def parse_batch_translation(response)
+        ResponseParser.parse_translation_response(response)&.fetch(:translated)
+      rescue EmptyTranslationError, InvalidResponseError
+        nil
+      end
+
       def translate_to_multiple_sequential(text, source_locale, target_locales, **options)
         options = DEFAULT_MULTI_TARGET_OPTIONS.merge(options)
         results = {}