mistral_translator 0.3.2 → 0.4.0

data/lib/mistral_translator/response_parser.rb

@@ -4,47 +4,75 @@ require_relative "logger"
 
 module MistralTranslator
   class ResponseParser
+    # Emplacements possibles du texte traduit ou résumé, par ordre de priorité
+    TARGET_PATHS = [
+      %w[content target], %w[translation target], %w[target],
+      %w[content translated], %w[translated],
+      %w[content summary], %w[summary]
+    ].freeze
+
+    SOURCE_PATHS = [
+      %w[content source], %w[translation source], %w[source],
+      %w[content original], %w[original]
+    ].freeze
+
     class << self
       def parse_translation_response(raw_content)
         return nil if raw_content.nil? || raw_content.empty?
 
-        begin
-          json_content = extract_json_from_content(raw_content)
-          return nil unless json_content
-
-          translation_data = parse_json_content(json_content)
-          translated_text = extract_target_content(translation_data)
-          validate_translation_content(translated_text)
-
-          build_translation_result(translation_data, translated_text)
-        rescue JSON::ParserError => e
-          handle_json_parse_error(e, raw_content, json_content)
-        rescue EmptyTranslationError
-          raise # Re-raise EmptyTranslationError
-        rescue StandardError => e
-          raise InvalidResponseError, "Error processing response: #{e.message}"
+        with_response_errors("translation", raw_content) do
+          data = parse_response_json(raw_content, "translation")
+          translated_text = target_text!(data, "Empty translation received from API", raw_content)
+
+          build_translation_result(data, translated_text)
         end
       end
 
       def parse_quality_check_response(raw_content)
         return { translation: nil, quality_check: {}, metadata: {} } if raw_content.nil? || raw_content.empty?
 
-        json_content = extract_json_from_content(raw_content)
-        raise InvalidResponseError, "Invalid JSON in quality check response" unless json_content
+        with_response_errors("quality check", raw_content) do
+          data = parse_response_json(raw_content, "quality check")
 
-        data = JSON.parse(json_content)
+          {
+            translation: target_text!(data, "Empty translation received from API", raw_content),
+            quality_check: data["quality_check"] || value_at(data, %w[metadata quality_check]) || {},
+            metadata: metadata_of(data)
+          }
+        end
+      end
 
-        translation = extract_target_content(data)
-        quality = data["quality_check"] || data.dig("metadata", "quality_check") || {}
-        {
-          translation: translation,
-          quality_check: quality,
-          metadata: data["metadata"] || {}
-        }
-      rescue JSON::ParserError
-        raise InvalidResponseError, "Invalid JSON in quality check response"
-      rescue StandardError => e
-        raise InvalidResponseError, "Error processing quality check response: #{e.message}"
+      def parse_summary_response(raw_content)
+        return nil if raw_content.nil? || raw_content.empty?
+
+        with_response_errors("summary", raw_content) do
+          data = parse_response_json(raw_content, "summary")
+
+          {
+            original: extract_source_content(data),
+            summary: target_text!(data, "Empty summary received", raw_content),
+            metadata: metadata_of(data)
+          }
+        end
+      end
+
+      def parse_bulk_translation_response(raw_content)
+        return [] if raw_content.nil? || raw_content.empty?
+
+        with_response_errors("bulk", raw_content) do
+          translations = parse_response_json(raw_content, "bulk")["translations"]
+          unless translations.is_a?(Array)
+            raise InvalidResponseError.new("No translations array in response", raw_content)
+          end
+
+          translations.map do |translation|
+            {
+              index: translation["index"],
+              original: translation["source"],
+              translated: translation["target"]
+            }
+          end
+        end
       end
 
       def parse_json_content(json_content)
@@ -62,112 +90,41 @@ module MistralTranslator
         end
       end
 
-      def validate_translation_content(translated_text)
-        return unless translated_text.nil? || translated_text.empty?
-
-        raise EmptyTranslationError, "Empty translation received from API"
-      end
-
       def build_translation_result(translation_data, translated_text)
         {
           original: extract_source_content(translation_data),
           translated: translated_text,
-          metadata: translation_data["metadata"] || {}
-        }
-      end
-
-      def handle_json_parse_error(error, raw_content, json_content)
-        error_details = {
-          error_message: error.message,
-          raw_content_length: raw_content&.length,
-          json_content_length: json_content&.length,
-          has_json_content: !json_content.nil?
+          metadata: metadata_of(translation_data)
         }
-        Logger.debug_if_verbose(
-          "JSON parse failed: #{error.message} raw_len=#{error_details[:raw_content_length]} " \
-          "json_len=#{error_details[:json_content_length]} snippet=#{raw_content&.slice(0, 120)}",
-          sensitive: false
-        )
-        raise InvalidResponseError, "Invalid JSON in response: #{error.message}. Details: #{error_details}"
       end
 
-      # rubocop:disable Metrics/PerceivedComplexity
-      def parse_summary_response(raw_content)
-        return nil if raw_content.nil? || raw_content.empty?
-
-        begin
-          json_content = extract_json_from_content(raw_content)
-          unless json_content
-            # Aucun JSON détecté: utiliser le texte brut comme repli si non vide
-            text = raw_content.to_s.strip
-            raise EmptyTranslationError, "Empty summary received" if text.empty?
-
-            return {
-              original: nil,
-              summary: text,
-              metadata: { "operation" => "summarization", "fallback" => true }
-            }
-          end
-
-          summary_data = JSON.parse(json_content)
-          summary_text = extract_target_content(summary_data)
-
-          raise EmptyTranslationError, "Empty summary received" if summary_text.nil? || summary_text.empty?
-
-          {
-            original: extract_source_content(summary_data),
-            summary: summary_text,
-            metadata: summary_data["metadata"] || {}
-          }
-        rescue JSON::ParserError
-          # Fallback: si ce n'est pas du JSON, essayer d'utiliser le texte brut s'il a du contenu
-          text = raw_content.to_s.strip
-          raise InvalidResponseError, "Invalid JSON in summary response: #{raw_content}" if text.empty?
+      private
 
-          {
-            original: nil,
-            summary: text,
-            metadata: { "operation" => "summarization", "fallback" => true }
-          }
-        rescue EmptyTranslationError
-          raise # Re-raise EmptyTranslationError
-        rescue StandardError => e
-          raise InvalidResponseError, "Error processing summary response: #{e.message}"
-        end
+      # Les erreurs Ruby (JSON::ParserError, NoMethodError, TypeError…) citent la réponse dans
+      # leur message : ni ce message ni l'erreur d'origine (cause) ne sont repris.
+      # La réponse reste accessible au code appelant via InvalidResponseError#raw_response.
+      def with_response_errors(label, raw_content)
+        yield
+      rescue EmptyTranslationError, InvalidResponseError
+        raise
+      rescue StandardError => e
+        raise InvalidResponseError.new("Error processing #{label} response (#{e.class})", raw_content), cause: nil
       end
-      # rubocop:enable Metrics/PerceivedComplexity
 
-      def parse_bulk_translation_response(raw_content)
-        return [] if raw_content.nil? || raw_content.empty?
-
-        begin
-          json_content = extract_json_from_content(raw_content)
-          raise InvalidResponseError, "Invalid JSON in bulk response: #{raw_content}" unless json_content
-
-          bulk_data = JSON.parse(json_content)
-          translations = bulk_data["translations"]
-
-          raise InvalidResponseError, "No translations array in response" unless translations.is_a?(Array)
+      def parse_response_json(raw_content, label)
+        json_content = extract_json_from_content(raw_content)
+        raise InvalidResponseError.new("No JSON in #{label} response", raw_content) unless json_content
 
-          translations.map do |translation|
-            {
-              index: translation["index"],
-              original: translation["source"],
-              translated: translation["target"]
-            }
-          end
-        rescue JSON::ParserError
-          raise InvalidResponseError, "Invalid JSON in bulk response: #{raw_content}"
-        rescue StandardError => e
-          # Ne pas wrapper l'erreur "No translations array in response"
-          raise e if e.message == "No translations array in response"
+        data = parse_json_content(json_content)
+        raise InvalidResponseError.new("Unexpected JSON in #{label} response", raw_content) unless data.is_a?(Hash)
 
-          raise InvalidResponseError, "Error processing bulk response: #{e.message}"
-        end
+        data
+      rescue JSON::ParserError
+        details = "raw_len=#{raw_content.length} json_len=#{json_content&.length}"
+        Logger.debug_if_verbose("JSON parse failed: #{details}", sensitive: false)
+        raise InvalidResponseError.new("Invalid JSON in #{label} response (#{details})", raw_content), cause: nil
       end
 
-      private
-
       def extract_json_from_content(content)
         return nil if content.nil? || content.empty?
 
@@ -268,28 +225,51 @@ module MistralTranslator
         end
       end
 
-      def extract_target_content(data)
-        # Essayer différents chemins possibles pour le contenu traduit
-        [
-          data.dig("content", "target"),
-          data.dig("translation", "target"),
-          data["target"],
-          data.dig("content", "translated"),
-          data["translated"],
-          data.dig("content", "summary"),
-          data["summary"]
-        ].find { |item| item && !item.to_s.empty? }
+      # Le texte traduit ou résumé : toujours une String non vide, jamais un objet ou un tableau.
+      def target_text!(data, empty_message, raw_content)
+        target = find_target(data)
+        nested = nested_response(target)
+        target = find_target(nested) || "" if nested && target_candidates(nested).any?
+
+        unless target.nil? || target.is_a?(String)
+          raise InvalidResponseError.new("Unexpected target in response", raw_content)
+        end
+        raise EmptyTranslationError, empty_message if target.to_s.strip.empty?
+
+        target
+      end
+
+      def find_target(data)
+        target_candidates(data).find { |item| !(item.respond_to?(:empty?) && item.empty?) }
+      end
+
+      def target_candidates(data)
+        TARGET_PATHS.filter_map { |path| value_at(data, path) }
+      end
+
+      # Comme Hash#dig, mais un nœud intermédiaire qui n'est pas un objet donne nil au lieu de TypeError.
+      def value_at(data, path)
+        path.reduce(data) { |node, key| node.is_a?(Hash) ? node[key] : nil }
+      end
+
+      def metadata_of(data)
+        data["metadata"].is_a?(Hash) ? data["metadata"] : {}
+      end
+
+      # Le modèle renvoie parfois l'objet de réponse attendu, tel quel ou sérialisé, dans "target" :
+      # on y cherche la cible un niveau plus bas. Un JSON sans clé connue reste une traduction.
+      def nested_response(target)
+        return target if target.is_a?(Hash)
+        return nil unless target.is_a?(String) && target.lstrip.start_with?("{")
+
+        parsed = JSON.parse(target)
+        parsed if parsed.is_a?(Hash)
+      rescue JSON::ParserError
+        nil
       end
 
       def extract_source_content(data)
-        # Essayer différents chemins possibles pour le contenu source
-        [
-          data.dig("content", "source"),
-          data.dig("translation", "source"),
-          data["source"],
-          data.dig("content", "original"),
-          data["original"]
-        ].find { |item| item && !item.to_s.empty? }
+        SOURCE_PATHS.map { |path| value_at(data, path) }.find { |item| item.is_a?(String) && !item.empty? }
       end
     end
   end

data/lib/mistral_translator/summarizer.rb

@@ -15,7 +15,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 +26,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 +43,69 @@ 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)
-      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
+        return summarize(cleaned_text, language: target_locale, max_words: max_words, context: context, style: style)
       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
+    # Relances communes à tous les résumés ; une réponse inexploitable finit par lever une erreur.
+    def request_summary(prompt, target_locale, attempt = 0)
+      log_debug("Summary attempt #{attempt + 1} for #{target_locale}")
+
+      result = ResponseParser.parse_summary_response(@client.complete(prompt, json: true))
+      raise EmptyTranslationError, "Empty summary received" if result.nil? || result[:summary].to_s.empty?
 
-      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
+      raise if attempt >= DEFAULT_RETRY_COUNT
+
+      wait_time = DEFAULT_RETRY_DELAY * (2**attempt)
+      log_retry(e, attempt + 1, wait_time, target_locale)
+      sleep(wait_time)
+      request_summary(prompt, target_locale, attempt + 1)
     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("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
+      request_summary(prompt, target_locale, attempt + 1)
     end
 
     def clean_document_content(content)
@@ -211,6 +133,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